refactor: one shared extension-API module, and drive the dApp flows on Firefox (closes #153)

Every call site that touched `browser.*` or `chrome.*` now goes through
`src/shared/browserApi.js`, the only file in the tree that names either.
It exposes lazily-resolved namespace handles for events and synchronous
methods, and promise-returning wrappers for everything that is
callback-shaped on Chrome. Callers await; `runtime.lastError` is gone,
folded into the rejection the wrapper produces on the Chrome path.

The Firefox suite gains the four dApp round trips the issue's definition
of done asks for — `eth_requestAccounts`, `personal_sign`,
`eth_sendTransaction`, and a closed approval window rejecting with
EIP-1193 4001 — driven through the real content script, background page
and approval windows. `--network none` was thought to rule that out
because it leaves no `http://` origin to inject into; loopback survives
it, so the page and a JSON-RPC node are served from 127.0.0.1 inside the
container and the run still reaches nothing but itself.

That harness refutes the premise it was built to verify. On Firefox
153.0.3, `browser.*` honours a trailing Chrome-style callback and does
populate `runtime.lastError`, both measured directly, and all four flows
pass against the unconverted code. So this is a uniformity and coverage
change, not a repair of a broken target; the PR records the measurement
in full.

One real defect is fixed on the way past: the window id written back
into a pending approval after `windows.create()` was unguarded, so an
approval settled during the open — an address switch will do it —
dereferenced a deleted entry.

tests/e2e/firefox/run.js

@@ -15,8 +15,15 @@
 // UI steps below are written twice on purpose. Chrome runs on Playwright,
 // which cannot see extension-page errors in Firefox at all (see the BiDi
 // note in driver.js), so the two backends have no common substrate to
-// abstract over. Three duplicated steps do not pay for a shim; revisit if
-// this suite grows to where they do.
+// abstract over. Duplicated steps do not pay for a shim; revisit if this
+// suite grows to where they do. What IS shared is the dApp page fixture
+// itself — DAPP_HTML, served here from loopback by dapp.js — so an assertion
+// about the __dapp API means the same thing on both browsers.
+//
+// The dApp steps need an http:// origin, which --network none was thought to
+// rule out. It does not: loopback survives it, so the page and the stub node
+// are served from 127.0.0.1 inside the container and the run reaches nothing
+// but this process. See tests/e2e/firefox/dapp.js.
 //
 // LIMITATION, and the difference from the Chrome suite worth knowing: error
 // capture here is POLL-BASED, not event-streamed. The console service is
@@ -40,7 +47,21 @@
 const fs = require("fs");
 const path = require("path");
 
+const {
+    Transaction,
+    formatEther,
+    getAddress,
+    getBytes,
+    hexlify,
+    parseEther,
+    toQuantity,
+    toUtf8Bytes,
+    verifyMessage,
+} = require("ethers");
+
 const { ConsoleErrors, EXTENSION_ORIGIN, start, sleep } = require("./driver");
+const { startDappServer } = require("./dapp");
+const { STUB_COUNTERPARTY } = require("../network");
 
 const REPO_ROOT = path.resolve(__dirname, "..", "..", "..");
 const POPUP_URL = EXTENSION_ORIGIN + "/src/popup/index.html";
@@ -137,8 +158,596 @@ step("add token screen opens from address detail", async (env) => {
     assert(picks > 0, "no common-token quick-pick buttons rendered");
 });
 
+// ------------------------------------------------- the dApp round trips
+//
+// Everything above drives the popup on its own. From here the page, the
+// content script, the inpage provider, the background page and the approval
+// window all have to work together, which on Firefox is exactly the seam
+// https://git.eeqj.de/sneak/AutistMask/issues/153 is about: every one of
+// these paths used to hand a Chrome-style callback to the promise-only
+// browser.* namespace and simply never complete.
+//
+// The shape is the Chrome suite's (tests/e2e/run.js, the #183 section) and
+// the assertions mean the same things:
+//
+//  - the signature is recovered here, in the runner, from the artifact the
+//    extension produced, and compared against the address read out of
+//    extension storage. The background verifies too; these assertions do not
+//    lean on that, because a test that trusted the wallet's own verdict would
+//    pass against a wallet that verified nothing.
+//  - the transaction is asserted against the raw signed transaction that
+//    reached the stub node, not against anything the extension reported.
+//
+// What this does NOT cover: a real dApp with real funds against a real
+// network. The node is a fixture on loopback.
+
+const SIGN_TEXT = "AutistMask e2e round trip: personal_sign";
+const SIGN_HEX = hexlify(toUtf8Bytes(SIGN_TEXT));
+
+const TX_VALUE_ETH = "0.0123";
+const TX_VALUE_WEI = parseEther(TX_VALUE_ETH);
+// Call data that decodes as nothing, so the screen assertion compares the
+// calldata itself rather than a decoder's summary of it.
+const TX_DATA = "0xdeadbeef" + "01".repeat(28);
+
+const USER_REJECTION_MESSAGE = "User rejected the request.";
+
+// Read the extension's persisted state, point its rpcUrl at the loopback stub
+// node, and hand back the active address. Runs on the popup page, which is
+// the one moz-extension:// document the suite has open and therefore the only
+// place the storage API is reachable from.
+async function pointAtStubNode(d, rpcUrl) {
+    const outcome = await d.executeAsync(
+        `const done = arguments[arguments.length - 1];
+         const rpcUrl = arguments[0];
+         const api = typeof browser !== "undefined" ? browser : chrome;
+         Promise.resolve(api.storage.local.get("autistmask"))
+             .then((r) => {
+                 const s = r.autistmask;
+                 if (!s) throw new Error("the extension has no persisted state");
+                 s.rpcUrl = rpcUrl;
+                 const w = s.wallets && s.wallets[0];
+                 const first = w && w.addresses && w.addresses[0];
+                 const address = s.activeAddress || (first && first.address);
+                 if (!address) throw new Error("the extension holds no address");
+                 return Promise.resolve(api.storage.local.set({ autistmask: s }))
+                     .then(() => done({ address: address }));
+             })
+             .catch((e) => done({ error: String((e && e.message) || e) }));`,
+        [rpcUrl],
+    );
+    assert(
+        outcome && !outcome.error,
+        "could not point the extension at the stub node: " +
+            (outcome && outcome.error),
+    );
+    return getAddress(outcome.address);
+}
+
+// The approval window the background opened. Approvals are raised from an RPC
+// call rather than from a user gesture, so the extension opens a real window
+// for them, which is an ordinary window handle here.
+async function waitForApprovalWindow(d, timeout = 30000) {
+    const deadline = Date.now() + timeout;
+    for (;;) {
+        const handle = await d.findWindow((u) => u.includes("?approval="));
+        if (handle) return handle;
+        if (Date.now() > deadline) {
+            throw new Error(
+                "the extension opened no approval window within " +
+                    timeout +
+                    "ms",
+            );
+        }
+        await sleep(100);
+    }
+}
+
+function startRequest(d, key, method, params) {
+    return d.execute(
+        "window.__dapp.start(arguments[0], arguments[1], arguments[2]);" +
+            " return true;",
+        [key, method, params],
+    );
+}
+
+// The settled outcome of a parked request, or {settled:"pending"} if it is
+// still outstanding. A bounded wait rather than a bare await: "returns a
+// rejection rather than hanging" is one of the things under test, and an
+// await would report a hang as a step timeout with no indication of which
+// call never settled.
+function settleRequest(d, key, timeout = 45000) {
+    return d.executeAsync(
+        `const done = arguments[arguments.length - 1];
+         const key = arguments[0];
+         const timeout = arguments[1];
+         Promise.race([
+             window.__dapp.settle(key),
+             new Promise((r) => setTimeout(() => r({ settled: "pending" }), timeout)),
+         ]).then(done, (e) => done({ settled: "error", message: String(e) }));`,
+        [key, timeout],
+    );
+}
+
+// Every AUTISTMASK_* message that has crossed between the page and the
+// content script. This is the boundary half of the rejection assertion: the
+// code has to be on the wire as well as on the Error the page catches, so a
+// pass cannot come from the provider inventing one.
+function dappMessages(d, type) {
+    return d.execute(
+        // `want` is bound outside the callback deliberately: inside it,
+        // arguments[0] is the message being tested, not the script argument,
+        // and the filter silently matches nothing.
+        "var want = arguments[0];" +
+            " return window.__dapp.messages.filter(function (m) {" +
+            " return !want || m.type === want; });",
+        [type || null],
+    );
+}
+
+async function lastResponseError(d) {
+    const responses = await dappMessages(d, "AUTISTMASK_RESPONSE");
+    const last = responses[responses.length - 1];
+    assert(last, "the page received no AUTISTMASK_RESPONSE at all");
+    return last.error || null;
+}
+
+// A rejected prompt, asserted at both ends: the page's promise rejected
+// rather than hanging or resolving, and the response that crossed the
+// boundary carried EIP-1193 code 4001.
+async function assertUserRejection(d, key, label) {
+    const outcome = await settleRequest(d, key);
+    assert(
+        outcome.settled !== "pending",
+        label + " never settled: the rejected prompt left the page hanging",
+    );
+    assert(
+        outcome.settled === "rejected",
+        label + " resolved instead of rejecting: " + JSON.stringify(outcome),
+    );
+    assert(
+        outcome.message === USER_REJECTION_MESSAGE,
+        label + " rejected with the wrong message: " + outcome.message,
+    );
+    const error = await lastResponseError(d);
+    assert(
+        error && error.code === 4001,
+        label +
+            " did not carry EIP-1193 code 4001 across the boundary: " +
+            JSON.stringify(error),
+    );
+    assert(
+        outcome.hasCode,
+        label +
+            " reached the page as an error with no code property at all, so a " +
+            "dApp cannot tell the user's refusal from a failure: " +
+            JSON.stringify(outcome),
+    );
+    assert(
+        outcome.code === 4001,
+        label +
+            " reached the page with code " +
+            JSON.stringify(outcome.code) +
+            " rather than EIP-1193 4001",
+    );
+    assert(
+        outcome.name === "ProviderRpcError",
+        label +
+            " reached the page as " +
+            JSON.stringify(outcome.name) +
+            " rather than an EIP-1193 ProviderRpcError",
+    );
+    console.log(
+        "# " +
+            label +
+            ": code 4001 on the wire and on the page's " +
+            outcome.name,
+    );
+}
+
+step("the loopback dApp page gets the real inpage provider", async (env) => {
+    const d = env.driver;
+
+    // The popup is still the current window; point the extension at the stub
+    // node from there, then reload it so its in-memory copy of the state
+    // carries the new rpcUrl and cannot save the old one back over it.
+    env.address = await pointAtStubNode(d, env.server.rpcUrl);
+    await d.navigate(POPUP_URL);
+    await d.waitVisible("#view-main", STEP_TIMEOUT_MS);
+    env.popupWindow = await d.currentWindow();
+
+    env.dappWindow = await d.newWindow("tab");
+    await d.switchToWindow(env.dappWindow);
+    await d.navigate(env.server.url);
+
+    // window.ethereum is not the fixture's doing — it is the shipped content
+    // script, injected into a real http:// origin. Waiting for it is waiting
+    // for the real provider to have installed itself.
+    await d.waitFor(
+        "the injected EIP-1193 provider and the test page API",
+        "return !!window.ethereum && !!window.__dapp;",
+        [],
+        STEP_TIMEOUT_MS,
+    );
+
+    // EIP-6963, asked of the provider itself. The announcement carries the
+    // uuid src/content/index.js reads out of extension storage — call site 1
+    // in the issue — and it has to name this extension and hand back the very
+    // object on window.ethereum.
+    const announced = await d.executeAsync(
+        `const done = arguments[arguments.length - 1];
+         const onAnnounce = (e) => {
+             window.removeEventListener("eip6963:announceProvider", onAnnounce);
+             done({
+                 rdns: e.detail.info.rdns,
+                 uuid: e.detail.info.uuid,
+                 isWindowEthereum: e.detail.provider === window.ethereum,
+             });
+         };
+         window.addEventListener("eip6963:announceProvider", onAnnounce);
+         window.dispatchEvent(new Event("eip6963:requestProvider"));
+         setTimeout(() => done(null), 15000);`,
+    );
+    assert(announced, "the provider announced itself to no EIP-6963 request");
+    assert(
+        announced.rdns === "berlin.sneak.autistmask",
+        "the announced provider is not this extension: " +
+            JSON.stringify(announced),
+    );
+    assert(
+        announced.isWindowEthereum,
+        "the announced provider is not the object on window.ethereum",
+    );
+    assert(
+        typeof announced.uuid === "string" && announced.uuid.length === 36,
+        "the announcement carries no stored provider uuid: " +
+            JSON.stringify(announced.uuid),
+    );
+
+    // A full page -> content script -> background round trip that needs no
+    // approval, so the relay is proven before any prompt is driven. This is
+    // call site 2, the one that used to fail for every window.ethereum
+    // request a dApp made.
+    const chainId = await d.executeAsync(
+        `const done = arguments[arguments.length - 1];
+         window.ethereum.request({ method: "eth_chainId" }).then(
+             (r) => done({ ok: r }),
+             (e) => done({ err: String((e && e.message) || e) }),
+         );`,
+    );
+    assert(
+        chainId && chainId.ok === "0x1",
+        "eth_chainId did not round trip through the extension: " +
+            JSON.stringify(chainId),
+    );
+    console.log(
+        "# dapp origin " + env.server.origin + " active address " + env.address,
+    );
+});
+
+step(
+    "eth_requestAccounts approved returns the selected address",
+    async (env) => {
+        const d = env.driver;
+        await d.switchToWindow(env.dappWindow);
+        await startRequest(d, "accounts", "eth_requestAccounts", []);
+
+        const popup = await waitForApprovalWindow(d);
+        await d.switchToWindow(popup);
+        await d.waitVisible("#view-approve-site");
+
+        const hostname = await d.text("#approve-hostname");
+        assert(
+            hostname === "127.0.0.1",
+            "the site prompt names the wrong origin: " +
+                JSON.stringify(hostname),
+        );
+        const shown = await d.text("#approve-address");
+        assert(
+            shown.toLowerCase().includes(env.address.toLowerCase()),
+            "the site prompt shows the wrong address: " + JSON.stringify(shown),
+        );
+
+        // Remembered, so the origin stays authorized for the sign and transaction
+        // steps below.
+        const checked = await d.execute(
+            'return document.getElementById("approve-remember").checked;',
+        );
+        if (!checked) await d.click("#approve-remember");
+        await d.click("#btn-approve");
+
+        // The approve button closes its own window, so get off it before asking
+        // the page anything.
+        await d.switchToWindow(env.dappWindow);
+        const outcome = await settleRequest(d, "accounts");
+        assert(
+            outcome.settled === "resolved",
+            "eth_requestAccounts did not resolve: " + JSON.stringify(outcome),
+        );
+        assert(
+            Array.isArray(outcome.result) && outcome.result.length === 1,
+            "eth_requestAccounts returned no single account: " +
+                JSON.stringify(outcome.result),
+        );
+        assert(
+            getAddress(outcome.result[0]) === env.address,
+            "eth_requestAccounts returned " +
+                outcome.result[0] +
+                ", not the selected address " +
+                env.address,
+        );
+    },
+);
+
+step(
+    "personal_sign returns a signature that recovers to the address",
+    async (env) => {
+        const d = env.driver;
+        await d.switchToWindow(env.dappWindow);
+        await startRequest(d, "sign", "personal_sign", [SIGN_HEX, env.address]);
+
+        const popup = await waitForApprovalWindow(d);
+        await d.switchToWindow(popup);
+        await d.waitVisible("#view-approve-sign");
+
+        const screen = await d.execute(
+            `return {
+             hostname: document.getElementById("approve-sign-hostname").textContent,
+             type: document.getElementById("approve-sign-type").textContent,
+             message: document.getElementById("approve-sign-message").textContent,
+             from: document.getElementById("approve-sign-from").textContent,
+         };`,
+        );
+        assert(
+            screen.hostname === "127.0.0.1",
+            "the sign prompt names the wrong origin: " +
+                JSON.stringify(screen.hostname),
+        );
+        assert(
+            screen.type === "Personal message",
+            "the sign prompt reports the wrong type: " +
+                JSON.stringify(screen.type),
+        );
+        assert(
+            screen.message === SIGN_TEXT,
+            "the sign prompt shows the wrong message: " +
+                JSON.stringify(screen.message),
+        );
+        assert(
+            screen.from.toLowerCase().includes(env.address.toLowerCase()),
+            "the sign prompt shows the wrong signing address: " +
+                JSON.stringify(screen.from),
+        );
+
+        await d.fill("#approve-sign-password", PASSWORD);
+        await d.click("#btn-approve-sign");
+
+        await d.switchToWindow(env.dappWindow);
+        const outcome = await settleRequest(d, "sign");
+        assert(
+            outcome.settled === "resolved",
+            "personal_sign did not resolve: " + JSON.stringify(outcome),
+        );
+        const recovered = getAddress(
+            verifyMessage(getBytes(SIGN_HEX), outcome.result),
+        );
+        console.log(
+            "# personal_sign: recovered=" +
+                recovered +
+                " expected=" +
+                env.address,
+        );
+        assert(
+            recovered === env.address,
+            "the personal_sign signature recovers to " +
+                recovered +
+                ", not to the approved address " +
+                env.address,
+        );
+    },
+);
+
+step(
+    "eth_sendTransaction shows the transaction and returns its hash",
+    async (env) => {
+        const d = env.driver;
+        const before = env.server.broadcast.length;
+
+        await d.switchToWindow(env.dappWindow);
+        await startRequest(d, "tx", "eth_sendTransaction", [
+            {
+                from: env.address,
+                to: STUB_COUNTERPARTY,
+                value: toQuantity(TX_VALUE_WEI),
+                data: TX_DATA,
+            },
+        ]);
+
+        const popup = await waitForApprovalWindow(d);
+        await d.switchToWindow(popup);
+        await d.waitVisible("#view-approve-tx");
+
+        const screen = await d.execute(
+            `return {
+             hostname: document.getElementById("approve-tx-hostname").textContent,
+             from: document.getElementById("approve-tx-from").textContent,
+             to: document.getElementById("approve-tx-to").textContent,
+             value: document.getElementById("approve-tx-value").textContent,
+             data: document.getElementById("approve-tx-data").textContent,
+             dataShown: !document
+                 .getElementById("approve-tx-data-section")
+                 .classList.contains("hidden"),
+         };`,
+        );
+        assert(
+            screen.hostname === "127.0.0.1",
+            "the transaction prompt names the wrong origin: " +
+                JSON.stringify(screen.hostname),
+        );
+        assert(
+            screen.from.toLowerCase().includes(env.address.toLowerCase()),
+            "the transaction prompt shows the wrong sender: " +
+                JSON.stringify(screen.from),
+        );
+        assert(
+            screen.to.toLowerCase().includes(STUB_COUNTERPARTY.toLowerCase()),
+            "the transaction prompt shows the wrong recipient: " +
+                JSON.stringify(screen.to),
+        );
+        assert(
+            screen.value.startsWith(TX_VALUE_ETH + " ETH"),
+            "the transaction prompt shows the wrong value: " +
+                JSON.stringify(screen.value),
+        );
+        assert(
+            screen.dataShown && screen.data === TX_DATA,
+            "the transaction prompt does not show the approved call data: " +
+                JSON.stringify(screen.data),
+        );
+
+        await d.fill("#approve-tx-password", PASSWORD);
+        await d.click("#btn-approve-tx");
+
+        // The approval window hands off to the wait screen rather than closing,
+        // and the hash it shows is asserted before it is retired: left open it
+        // polls the stub node for a receipt for the rest of the run.
+        await d.waitVisible("#view-wait-tx", STEP_TIMEOUT_MS);
+        const waitHash = await d.text("#wait-tx-hash");
+
+        await d.switchToWindow(env.dappWindow);
+        const outcome = await settleRequest(d, "tx");
+        assert(
+            outcome.settled === "resolved",
+            "eth_sendTransaction did not resolve: " + JSON.stringify(outcome),
+        );
+
+        // The artifact as the node saw it, not as the extension described it.
+        assert(
+            env.server.broadcast.length === before + 1,
+            "expected exactly one raw transaction to reach the node, got " +
+                (env.server.broadcast.length - before),
+        );
+        const signed = Transaction.from(
+            env.server.broadcast[env.server.broadcast.length - 1],
+        );
+        console.log(
+            "# eth_sendTransaction: signer=" +
+                getAddress(signed.from) +
+                " to=" +
+                getAddress(signed.to) +
+                " value=" +
+                formatEther(signed.value) +
+                " chainId=" +
+                signed.chainId,
+        );
+        assert(
+            getAddress(signed.from) === env.address,
+            "the broadcast transaction was signed by " +
+                getAddress(signed.from) +
+                ", not by the approved address " +
+                env.address,
+        );
+        assert(
+            getAddress(signed.to) === getAddress(STUB_COUNTERPARTY),
+            "the broadcast transaction goes to " + signed.to,
+        );
+        assert(
+            signed.value === TX_VALUE_WEI,
+            "the broadcast transaction carries " +
+                formatEther(signed.value) +
+                " ETH, not the approved " +
+                TX_VALUE_ETH,
+        );
+        assert(
+            signed.data === TX_DATA,
+            "the broadcast transaction carries different call data: " +
+                signed.data,
+        );
+        assert(
+            signed.chainId === 1n,
+            "the broadcast transaction is for chain " + signed.chainId,
+        );
+        assert(
+            outcome.result === signed.hash,
+            "the page received " +
+                outcome.result +
+                ", not the hash of the broadcast transaction " +
+                signed.hash,
+        );
+        assert(
+            waitHash.includes(signed.hash),
+            "the wait screen shows a different hash: " +
+                JSON.stringify(waitHash),
+        );
+
+        await d.switchToWindow(popup);
+        await d.closeWindow(env.dappWindow);
+    },
+);
+
+step(
+    "closing an approval window rejects the request with 4001",
+    async (env) => {
+        const d = env.driver;
+        const before = env.server.broadcast.length;
+
+        await d.switchToWindow(env.dappWindow);
+        await startRequest(d, "sign-closed", "personal_sign", [
+            SIGN_HEX,
+            env.address,
+        ]);
+
+        const popup = await waitForApprovalWindow(d);
+        await d.switchToWindow(popup);
+        await d.waitVisible("#view-approve-sign");
+
+        // Closed, not rejected: this is the windows.onRemoved path, which can
+        // only fire if windows.create() handed back a window id for the approval
+        // to be matched against — call site 4 in the issue, where the id used to
+        // be assigned from a callback the browser.* namespace never invoked.
+        await d.closeWindow(env.dappWindow);
+
+        await assertUserRejection(d, "sign-closed", "a closed approval window");
+        assert(
+            env.server.broadcast.length === before,
+            "a closed approval window still put a transaction on the node",
+        );
+    },
+);
+
 // ------------------------------------------------------------- runner
 
+// Uncaught extension errors that are known, tracked and deliberately
+// tolerated, in the same spirit as ALLOWED_ERRORS in tests/e2e/harness.js:
+// every entry names the issue that will delete it, and every occurrence is
+// still printed, so tolerating one is visible in the log rather than silent.
+// This is the only concession in an otherwise zero-tolerance policy.
+const ALLOWED_ERRORS = [
+    {
+        // The site-connection buttons in src/popup/views/approval.js send
+        // their decision and call window.close() on the next line. Firefox's
+        // BaseContext.wrapPromise reports, through Cu.reportError, any
+        // extension-API promise that settles after its context unloaded —
+        // whether or not the caller attached a handler, so notify()'s catch
+        // cannot suppress it.
+        //
+        // Pre-existing, and not introduced by the promise shim: the send was
+        // already unawaited, and this suite is merely the first thing to
+        // drive that window on Firefox. It is the same teardown ordering as
+        // the issue below, whose fix — making the outcome independent of when
+        // the popup closes — removes this entry with it.
+        pattern: /Promise (?:resolved|rejected) after context unloaded/,
+        source: /\/src\/popup\/index\.js$/,
+        issue: "https://git.eeqj.de/sneak/AutistMask/issues/275",
+    },
+];
+
+function allowedFor(e) {
+    return ALLOWED_ERRORS.find(
+        (a) => a.pattern.test(e.msg) && a.source.test(e.src),
+    );
+}
+
 function formatError(e) {
     return (
         e.msg + " (" + e.src + ":" + e.line + (e.cat ? ", " + e.cat : "") + ")"
@@ -165,6 +774,21 @@ async function main() {
         return;
     }
 
+    // Loopback survives --network none, so this is the http:// origin the
+    // dApp steps need and the node they talk to. Started before the browser
+    // so its url is available to the first step that asks for it.
+    let server;
+    try {
+        server = await startDappServer();
+    } catch (e) {
+        console.error(
+            "e2e-firefox: cannot serve the dApp fixture: " + e.message,
+        );
+        process.exitCode = 1;
+        return;
+    }
+    console.log("# dapp fixture: " + server.url + " rpc " + server.rpcUrl);
+
     let driver;
     try {
         driver = await start();
@@ -175,12 +799,20 @@ async function main() {
         // absent suite. Never skip and report success.
         console.error("e2e-firefox: cannot run the suite: " + e.message);
         if (driver) await driver.quit().catch(() => {});
+        await server.close();
         process.exitCode = 1;
         return;
     }
 
     const errors = new ConsoleErrors(driver, EXTENSION_ORIGIN);
-    const env = { driver, phrase: null };
+    const env = {
+        driver,
+        server,
+        phrase: null,
+        address: null,
+        dappWindow: null,
+        popupWindow: null,
+    };
 
     console.log("# extension origin: " + EXTENSION_ORIGIN);
     console.log("1.." + steps.length);
@@ -232,6 +864,20 @@ async function main() {
                 installFailure = null;
             }
 
+            // Tolerated errors are set aside, never dropped: each one is
+            // printed with the issue that keeps it on the list, so the
+            // concession stays in the run output.
+            const tolerated = found.filter((e) => allowedFor(e));
+            found = found.filter((e) => !allowedFor(e));
+            for (const e of tolerated) {
+                console.log(
+                    "# tolerated (" +
+                        allowedFor(e).issue +
+                        "): " +
+                        formatError(e),
+                );
+            }
+
             // Any uncaught error from an extension source fails the step
             // that provoked it, whether or not its assertions passed.
             if (!failure && found.length > 0) {
@@ -256,7 +902,13 @@ async function main() {
         // blamed on any one step, but they are still reported and they
         // still fail the run.
         await sleep(1000);
-        const trailing = await errors.take();
+        const trailingAll = await errors.take();
+        for (const e of trailingAll.filter((x) => allowedFor(x))) {
+            console.log(
+                "# tolerated (" + allowedFor(e).issue + "): " + formatError(e),
+            );
+        }
+        const trailing = trailingAll.filter((e) => !allowedFor(e));
         console.log(
             "# " +
                 (steps.length - failed) +
@@ -273,12 +925,25 @@ async function main() {
             );
             for (const e of trailing) console.log("#   " + formatError(e));
         }
+        // A JSON-RPC method nothing answered means the extension asked the
+        // node something this fixture does not model, and whatever depended
+        // on the answer took the error branch instead. That is a hole in the
+        // fixture, not a pass.
+        if (server.unstubbed.length > 0) {
+            console.log(
+                "# FAILED: no fixture for JSON-RPC method(s) " +
+                    [...new Set(server.unstubbed)].join(", "),
+            );
+            process.exitCode = 1;
+        }
+
         if (failed > 0 || trailing.length > 0) {
             console.log("# FAILED");
             process.exitCode = 1;
         }
     } finally {
         await driver.quit().catch(() => {});
+        await server.close();
     }
 }