diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 495d06c5f..bc13dfdaa 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -526,6 +526,12 @@ jobs:
           CHROMIUM_REQUIRE=1 node test-a11y-1719-contrast-root-causes-e2e.js 2>&1 | tee -a e2e-output.txt
           CHROMIUM_REQUIRE=1 node test-nodes-favorite-rerender-e2e.js 2>&1 | tee -a e2e-output.txt
           CHROMIUM_REQUIRE=1 node test-packet-trace-alignment-e2e.js 2>&1 | tee -a e2e-output.txt
+          # Root E2Es repaired or ported to plain playwright in #189.
+          CHROMIUM_REQUIRE=1 BASE_URL=http://localhost:13581 node test-live-pulse-ring-weight-e2e.js 2>&1 | tee -a e2e-output.txt
+          CHROMIUM_REQUIRE=1 BASE_URL=http://localhost:13581 node test-channel-modal-e2e.js 2>&1 | tee -a e2e-output.txt
+          CHROMIUM_REQUIRE=1 BASE_URL=http://localhost:13581 node test-node-reach-e2e.js 2>&1 | tee -a e2e-output.txt
+          CHROMIUM_REQUIRE=1 BASE_URL=http://localhost:13581 node test-path-inspector-e2e.js 2>&1 | tee -a e2e-output.txt
+          CHROMIUM_REQUIRE=1 BASE_URL=http://localhost:13581 node test-issue-1522-trace-url-sync-e2e.js 2>&1 | tee -a e2e-output.txt
 
       # #1616: slide-over focus-restore flake-gate. Runs the slide-over
       # E2E 20 consecutive times against the SAME backend instance so
diff --git a/test-all.sh b/test-all.sh
index 1eb9ecff4..edea7f19a 100755
--- a/test-all.sh
+++ b/test-all.sh
@@ -237,6 +237,18 @@ run test-map-clustering.js
 run test-panel-corner.js
 run test-customizer-v2.js
 
+# Repaired orphans (#189)
+run test-channel-colors.js
+run test-channel-ux-followup.js
+run test-channel-ux-round2.js
+run test-drag-manager.js
+run test-fluid-scaffolding.js
+run test-hop-resolver-affinity.js
+run test-issue-1470-card-bg-contrast.js
+run test-issue-1646-compare-polish.js
+run test-perf-disk-io-1120.js
+run test-table-sort.js
+
 # test-all.sh self-test (#174)
 run test-test-all.js
 
diff --git a/test-channel-colors.js b/test-channel-colors.js
index 06c0e249d..9fb35962b 100644
--- a/test-channel-colors.js
+++ b/test-channel-colors.js
@@ -146,20 +146,19 @@ test('getRowStyle returns empty string for null channel', function() {
   assert.strictEqual(ctx.window.ChannelColors.getRowStyle('GRP_TXT', null), '');
 });
 
-test('getRowStyle returns border + background for assigned GRP_TXT channel', function() {
+// #675 (#674): a 3px left border only, no background tint.
+test('getRowStyle returns a 3px left border for assigned GRP_TXT channel', function() {
   const ctx = makeSandbox();
   ctx.window.ChannelColors.set('#sf', '#ef4444');
   const style = ctx.window.ChannelColors.getRowStyle('GRP_TXT', '#sf');
-  assert.ok(style.includes('border-left:4px solid #ef4444'), 'should have left border');
-  assert.ok(style.includes('background:#ef44441a'), 'should have 10% opacity background');
+  assert.strictEqual(style, 'border-left:3px solid #ef4444;');
 });
 
 test('getRowStyle works with CHAN type (alias for GRP_TXT)', function() {
   const ctx = makeSandbox();
   ctx.window.ChannelColors.set('#mesh', '#3b82f6');
   const style = ctx.window.ChannelColors.getRowStyle('CHAN', '#mesh');
-  assert.ok(style.includes('border-left:4px solid #3b82f6'), 'should have left border');
-  assert.ok(style.includes('background:#3b82f61a'), 'should have background tint');
+  assert.strictEqual(style, 'border-left:3px solid #3b82f6;');
 });
 
 test('getRowStyle returns empty when channel has no assigned color', function() {
diff --git a/test-channel-modal-e2e.js b/test-channel-modal-e2e.js
index 106776b73..60cc67218 100644
--- a/test-channel-modal-e2e.js
+++ b/test-channel-modal-e2e.js
@@ -6,7 +6,8 @@
  *   - sidebar [+ Add Channel] opens modal
  *   - modal renders three labeled sections + privacy footer + QR placeholders
  *   - close (✕) hides modal
- *   - sectioned sidebar renders My Channels / Network / Encrypted sections
+ *   - sectioned sidebar renders Network / Encrypted sections, and My Channels
+ *     only once this browser holds a key (#1111)
  *   - PSK add flow: invalid hex → error; valid hex → modal closes
  *
  * Usage: BASE_URL=http://localhost:38201 node test-channel-modal-e2e.js
@@ -42,8 +43,13 @@ function assert(c, m) { if (!c) throw new Error(m || 'assertion failed'); }
   });
 
   await step('Add Channel button is visible', async () => {
-    const text = await page.textContent('#chAddChannelBtn');
-    assert(/Add Channel/.test(text), 'button text: ' + text);
+    // #1227 (#1224) shortened the label to a "+ Add" chip; the accessible
+    // name is still "Add channel".
+    assert(await page.isVisible('#chAddChannelBtn'), '#chAddChannelBtn not visible');
+    const text = (await page.textContent('#chAddChannelBtn')).trim();
+    assert(/^\+\s*Add\b/.test(text), 'button text: ' + text);
+    const label = await page.getAttribute('#chAddChannelBtn', 'aria-label');
+    assert(/^Add channel$/i.test(label || ''), 'aria-label: ' + label);
   });
 
   await step('modal hidden on load', async () => {
@@ -104,20 +110,20 @@ function assert(c, m) { if (!c) throw new Error(m || 'assertion failed'); }
     }, { timeout: 3000 });
   });
 
-  await step('sidebar renders three sections (My Channels / Network / Encrypted)', async () => {
+  await step('sidebar renders Network + Encrypted, and no My Channels without a key (#1111)', async () => {
     // Wait for channel list to populate from API (or render empty-state).
     await page.waitForFunction(() => {
       const el = document.getElementById('chList');
       if (!el) return false;
-      return el.querySelector('.ch-section-mychannels') &&
-             el.querySelector('.ch-section-network') &&
+      return el.querySelector('.ch-section-network') &&
              el.querySelector('.ch-section-encrypted');
     }, { timeout: 8000 });
     const headers = await page.$$eval('.ch-section-header', els => els.map(e => e.textContent.trim()));
     const joined = headers.join(' | ');
-    assert(/My Channels/.test(joined), 'My Channels header missing: ' + joined);
-    assert(/Network/.test(joined), 'Network header missing');
-    assert(/Encrypted/.test(joined), 'Encrypted header missing');
+    assert(/Network/.test(joined), 'Network header missing: ' + joined);
+    assert(/Encrypted/.test(joined), 'Encrypted header missing: ' + joined);
+    // 12d96a9d (#1111): the My Channels section is hidden while empty.
+    assert(!(await page.$('.ch-section-mychannels')), 'My Channels must not render without a stored key: ' + joined);
   });
 
   await step('Encrypted section is collapsed by default', async () => {
@@ -154,6 +160,13 @@ function assert(c, m) { if (!c) throw new Error(m || 'assertion failed'); }
     assert(/cafebabe/i.test(stored), 'expected stored key in localStorage corescope_channel_keys, got: ' + stored);
   });
 
+  await step('sidebar now renders My Channels with the new channel', async () => {
+    await page.waitForFunction(() => {
+      const sec = document.querySelector('#chList .ch-section-mychannels');
+      return sec && /My Channels/.test(sec.textContent) && /E2E Test Channel/.test(sec.textContent);
+    }, { timeout: 5000 });
+  });
+
   await browser.close();
 
   console.log(`\n=== Results: passed ${passed} failed ${failed} ===`);
diff --git a/test-channel-ux-followup.js b/test-channel-ux-followup.js
index 6e2f284a2..c049b5207 100644
--- a/test-channel-ux-followup.js
+++ b/test-channel-ux-followup.js
@@ -43,8 +43,12 @@ assert(!/\$\{ch\.messageCount\s*\|\|\s*0\}\s*packets/.test(chSrc),
 console.log('\n=== Fix 3: privacy footer wording ===');
 assert(!/Clear browser data to remove stored keys/.test(chSrc),
   'old "Clear browser data to remove stored keys" copy is gone');
-assert(/Use\s+✕\s+to remove individual channels/.test(chSrc),
-  'new copy points at the ✕ button for individual key removal');
+// b812a98a (#1648 M3) swapped the ✕ glyph for the #ph-x sprite and reworded
+// the hint to "close button"; the remove button must still be that X icon.
+assert(/Use the close button to remove individual channels/.test(chSrc),
+  'new copy points at the close (X) button for individual key removal');
+assert(/iconBtn\(\s*'ch-remove-btn'[^)]*'<svg class="ph-icon" aria-hidden="true"><use href="\/icons\/phosphor-sprite\.svg#ph-x"\/><\/svg>'/.test(chSrc),
+  "the remove button the copy points at renders the #ph-x close icon");
 
 console.log('\n=== Fix 4: Share/reshare affordance on user-added rows ===');
 // Source-level: data attribute and helper exist. Behavior-level checks
diff --git a/test-channel-ux-round2.js b/test-channel-ux-round2.js
index 4d223b6f9..bf887c8b2 100644
--- a/test-channel-ux-round2.js
+++ b/test-channel-ux-round2.js
@@ -64,12 +64,13 @@ assert(/channelDisplayName\(ch\)/.test(chSrc),
 console.log('\n=== Fix 2: share button has recognizable label ===');
 assert(!/'⤴'/.test(chSrc) && !/"⤴"/.test(chSrc),
   'bare ⤴ glyph no longer used as the share button content');
-// Tighten: assert the literal '📤 Share' string is the glyph argument
-// passed into the iconBtn(...) call for ch-share-btn — this catches the
-// case where someone removes the icon from the button content but leaves
-// "Share" in an aria-label or title.
-assert(/iconBtn\(\s*'ch-share-btn'[^)]*'📤 Share'/.test(chSrc),
-  "iconBtn('ch-share-btn', ...) is called with '📤 Share' as the glyph");
+// Tighten: assert the icon + " Share" string is the glyph argument passed
+// into the iconBtn(...) call for ch-share-btn — this catches the case where
+// someone removes the icon from the button content but leaves "Share" in an
+// aria-label or title. b812a98a (#1648 M3) replaced 📤 with the
+// #ph-share-network sprite.
+assert(/iconBtn\(\s*'ch-share-btn'[^)]*'<svg class="ph-icon" aria-hidden="true"><use href="\/icons\/phosphor-sprite\.svg#ph-share-network"\/><\/svg> Share'/.test(chSrc),
+  "iconBtn('ch-share-btn', ...) is called with the #ph-share-network icon + ' Share' as the glyph");
 
 console.log('\n=== Fix 3: ✕ delete button is a visibly red destructive button ===');
 const removeRule = (cssSrc.match(/\.ch-remove-btn\s*\{[^}]*\}/) || [''])[0];
diff --git a/test-drag-manager.js b/test-drag-manager.js
index 1bec20ba5..78493c291 100644
--- a/test-drag-manager.js
+++ b/test-drag-manager.js
@@ -10,14 +10,23 @@ const assert = require('assert');
 function makePanel(id) {
   const listeners = {};
   const style = {};
-  const dataset = {};
+  let attrs = {};
+  // Like a real DOMStringMap, dataset is a live view of the data-*
+  // attributes: removeAttribute('data-dragged') clears dataset.dragged
+  // (#1567 switched clearPanel to removeAttribute).
+  const attrName = (prop) => 'data-' + String(prop).replace(/[A-Z]/g, (c) => '-' + c.toLowerCase());
+  const dataset = new Proxy({}, {
+    get(_, prop) { return typeof prop === 'string' ? attrs[attrName(prop)] : undefined; },
+    set(_, prop, v) { attrs[attrName(prop)] = String(v); return true; },
+    deleteProperty(_, prop) { delete attrs[attrName(prop)]; return true; },
+    has(_, prop) { return attrName(prop) in attrs; }
+  });
   const classList = {
     _set: new Set(),
     add(c) { this._set.add(c); },
     remove(c) { this._set.delete(c); },
     contains(c) { return this._set.has(c); }
   };
-  let attrs = {};
   const header = {
     _listeners: {},
     addEventListener(ev, fn) {
diff --git a/test-fluid-scaffolding.js b/test-fluid-scaffolding.js
index 3768f63bb..a45523110 100644
--- a/test-fluid-scaffolding.js
+++ b/test-fluid-scaffolding.js
@@ -18,18 +18,27 @@ function test(name, fn) {
 
 // --- Helpers ---------------------------------------------------------------
 
-// Extract the :root { ... } block (first occurrence — the light/default one).
-function rootBlock() {
-  const m = css.match(/:root\s*\{([\s\S]*?)\}/);
-  if (!m) throw new Error(':root block not found in style.css');
-  return m[1];
+// The bodies of every top-level, unconditional `:root { ... }` block.
+// style.css has several (f0addfda / #1668 put the palette block first), so
+// reading only the first one misses the fluid tokens. Comments are stripped
+// first; a block preceded by `{` is nested (e.g. in @media) and skipped.
+function rootBlocks() {
+  const code = css.replace(/\/\*[\s\S]*?\*\//g, '');
+  const blocks = [...code.matchAll(/(?<=(?:^|\})\s*):root\s*\{([^}]*)\}/g)].map((m) => m[1]);
+  if (!blocks.length) throw new Error(':root block not found in style.css');
+  return blocks;
 }
 
-// Find the value of a custom property declared in :root.
+// Find the value of a custom property declared in :root (the last
+// declaration wins, as in the cascade).
 function rootVar(name) {
-  const re = new RegExp(`${name}\\s*:\\s*([^;]+);`);
-  const m = rootBlock().match(re);
-  return m ? m[1].trim() : null;
+  const re = new RegExp(`(?:^|[;{\\s])${name}\\s*:\\s*([^;]+);`);
+  let value = null;
+  for (const block of rootBlocks()) {
+    const m = block.match(re);
+    if (m) value = m[1].trim();
+  }
+  return value;
 }
 
 function assertClamp(name) {
diff --git a/test-hop-resolver-affinity.js b/test-hop-resolver-affinity.js
index a9ce2dda7..e5871b96d 100644
--- a/test-hop-resolver-affinity.js
+++ b/test-hop-resolver-affinity.js
@@ -22,7 +22,12 @@ function assert(condition, msg) {
 
 // ── Test nodes ──
 // Two nodes share the same 1-byte prefix "ab"
-const nodeA = { public_key: 'ab1111', name: 'NodeA', role: 'repeater', lat: 37.0, lon: -122.0 };
+// NodeA must be clearly geo-closer to NodeC than NodeB. At (37.0, -122.0)
+// the two were mirror images in degrees, and with haversine (2b9f3056, #874)
+// NodeB was the closer one (70.88 vs 71.06 km). At (37.2, -122.2) NodeA is
+// ~43 km from NodeC and NodeB ~71 km, so Tests 1 and 5 prove that affinity
+// overrides geography, and Test 2 proves the geo fallback.
+const nodeA = { public_key: 'ab1111', name: 'NodeA', role: 'repeater', lat: 37.2, lon: -122.2 };
 const nodeB = { public_key: 'ab2222', name: 'NodeB', role: 'repeater', lat: 38.0, lon: -123.0 };
 const nodeC = { public_key: 'cd3333', name: 'NodeC', role: 'repeater', lat: 37.5, lon: -122.5 };
 
@@ -49,8 +54,10 @@ HopResolver.init([nodeA, nodeB, nodeC]);
 HopResolver.setAffinity({}); // No edges
 
 // With anchor at NodeC's position, NodeA is closer to NodeC than NodeB
+assert(HopResolver.haversineKm(nodeC.lat, nodeC.lon, nodeA.lat, nodeA.lon) <
+       HopResolver.haversineKm(nodeC.lat, nodeC.lon, nodeB.lat, nodeB.lon),
+  'fixture: NodeA is geo-closer to NodeC than NodeB');
 const result2 = HopResolver.resolve(['cd33', 'ab'], nodeC.lat, nodeC.lon, null, null, null);
-// NodeA (37, -122) is closer to NodeC (37.5, -122.5) than NodeB (38, -123)
 assert(result2['ab'].name === 'NodeA', 'Should pick NodeA (geo-closest) — got: ' + result2['ab'].name);
 
 // Test 3: setAffinity with null/undefined doesn't crash
diff --git a/test-issue-1470-card-bg-contrast.js b/test-issue-1470-card-bg-contrast.js
index 9a1bf14c5..fcfdd15f9 100644
--- a/test-issue-1470-card-bg-contrast.js
+++ b/test-issue-1470-card-bg-contrast.js
@@ -22,6 +22,9 @@ const assert = require('assert');
 
 const ROOT = __dirname;
 function read(rel) { return fs.readFileSync(path.join(ROOT, rel), 'utf8'); }
+// style.css with comments removed: e2212f50 (#1627) added a comment that
+// mentions [data-theme="dark"] above the real block, and indexOf landed on it.
+function readCss() { return read('public/style.css').replace(/\/\*[\s\S]*?\*\//g, ''); }
 
 let passed = 0, failed = 0;
 function test(name, fn) {
@@ -34,7 +37,7 @@ function test(name, fn) {
 console.log('\n── #1470 CSS: --card-bg dark-mode variable ──');
 
 test('@media dark block sets --card-bg to var(--surface-2)', () => {
-  const css = read('public/style.css');
+  const css = readCss();
   // Find the @media (prefers-color-scheme: dark) block
   const mediaIdx = css.indexOf('@media (prefers-color-scheme: dark)');
   assert.ok(mediaIdx !== -1, '@media dark block not found');
@@ -46,7 +49,7 @@ test('@media dark block sets --card-bg to var(--surface-2)', () => {
 });
 
 test('[data-theme="dark"] block sets --card-bg to var(--surface-2)', () => {
-  const css = read('public/style.css');
+  const css = readCss();
   const themeIdx = css.indexOf('[data-theme="dark"]');
   assert.ok(themeIdx !== -1, '[data-theme="dark"] block not found');
   const themeBlock = css.slice(themeIdx, themeIdx + 2000);
@@ -57,7 +60,7 @@ test('[data-theme="dark"] block sets --card-bg to var(--surface-2)', () => {
 });
 
 test('light-mode block keeps --card-bg as var(--surface-1)', () => {
-  const css = read('public/style.css');
+  const css = readCss();
   // Light mode block ends before the @media dark block
   const mediaIdx = css.indexOf('@media (prefers-color-scheme: dark)');
   const lightBlock = css.slice(0, mediaIdx);
diff --git a/test-issue-1522-trace-url-sync-e2e.js b/test-issue-1522-trace-url-sync-e2e.js
index 4a9fa6cd9..99c482716 100644
--- a/test-issue-1522-trace-url-sync-e2e.js
+++ b/test-issue-1522-trace-url-sync-e2e.js
@@ -1,26 +1,89 @@
-// E2E test for issue #1522 — trace hash written into URL after doTrace().
-// Run: npx playwright test test-issue-1522-trace-url-sync-e2e.js
-// Requires: running server on BASE_URL (default http://localhost:3000).
+/**
+ * E2E (#1522 / #1523, ported for #189): the Trace tool keeps the packet hash
+ * in the URL.
+ *
+ *   1. Typing a hash on #/tools/trace/ and clicking Trace writes it into the
+ *      URL (#/tools/trace/<hash>) with replaceState, so the URL can be shared
+ *      and Back does not step through each trace.
+ *   2. Opening #/tools/trace/<hash> directly pre-fills the input, runs the
+ *      trace (GET /api/traces/<hash>) and leaves the URL as it was.
+ *
+ * Previously an @playwright/test spec; that runner is not a dependency, so it
+ * never ran. This port uses the plain `playwright` API like the other
+ * *-e2e.js files. The hashes are made up: the tests are about the URL, and
+ * an unknown hash takes the same doTrace() path.
+ *
+ * Usage: BASE_URL=http://localhost:13581 node test-issue-1522-trace-url-sync-e2e.js
+ */
 'use strict';
+const { chromium } = require('playwright');
 
-const { test, expect } = require('@playwright/test');
-const BASE_URL = process.env.BASE_URL || 'http://localhost:3000';
+const BASE = process.env.BASE_URL || 'http://localhost:13581';
 
-test.describe('Trace URL sync — issue #1522', () => {
-  test('hash written into URL after clicking Trace', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/tools/trace/`);
-    await page.waitForSelector('#traceHashInput', { timeout: 8000 });
-    await page.fill('#traceHashInput', 'deadbeef');
-    await page.click('#traceBtn');
-    await expect(page).toHaveURL(/#\/tools\/trace\/deadbeef$/);
-  });
+let passed = 0, failed = 0;
+async function step(name, fn) {
+  try { await fn(); passed++; console.log('  ✓ ' + name); }
+  catch (e) { failed++; console.error('  ✗ ' + name + ': ' + e.message); }
+}
+function assert(c, m) { if (!c) throw new Error(m || 'assertion failed'); }
+const traceRequest = (hash) => (r) => new URL(r.url()).pathname === '/api/traces/' + hash;
 
-  test('deep-link pre-fills input and fires trace on load', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/tools/trace/cafebabe`);
-    await page.waitForSelector('#traceHashInput', { timeout: 8000 });
-    const value = await page.inputValue('#traceHashInput');
-    expect(value).toBe('cafebabe');
-    // URL must remain unchanged (no extra replaceState pollution)
-    await expect(page).toHaveURL(/#\/tools\/trace\/cafebabe$/);
-  });
-});
+(async () => {
+  const requireChromium = process.env.CHROMIUM_REQUIRE === '1';
+  let browser;
+  try {
+    browser = await chromium.launch({
+      headless: true,
+      executablePath: process.env.CHROMIUM_PATH || undefined,
+      args: ['--no-sandbox', '--disable-gpu', '--disable-dev-shm-usage'],
+    });
+  } catch (err) {
+    if (requireChromium) {
+      console.error('test-issue-1522-trace-url-sync-e2e.js: FAIL — Chromium required but unavailable: ' + err.message);
+      process.exit(1);
+    }
+    console.log('test-issue-1522-trace-url-sync-e2e.js: SKIP (Chromium unavailable: ' + err.message.split('\n')[0] + ')');
+    process.exit(0);
+  }
+  const ctx = await browser.newContext();
+  const page = await ctx.newPage();
+  page.setDefaultTimeout(8000);
+  const errors = [];
+  page.on('pageerror', (e) => errors.push(e.message));
+
+  console.log('\n=== #1522 trace URL sync E2E against ' + BASE + ' ===');
+  try {
+    await step('clicking Trace writes the hash into the URL (replaceState)', async () => {
+      await page.goto(BASE + '/#/tools/trace/', { waitUntil: 'domcontentloaded' });
+      await page.waitForSelector('#traceHashInput');
+      const historyBefore = await page.evaluate(() => history.length);
+      await page.fill('#traceHashInput', 'deadbeef');
+      const traced = page.waitForRequest(traceRequest('deadbeef'));
+      await page.click('#traceBtn');
+      await traced;
+      await page.waitForFunction(() => /#\/tools\/trace\/deadbeef$/.test(location.hash));
+      const historyAfter = await page.evaluate(() => history.length);
+      assert(historyAfter === historyBefore, 'history grew from ' + historyBefore + ' to ' + historyAfter + ' (pushState instead of replaceState?)');
+    });
+
+    await step('a deep link pre-fills the input, runs the trace and keeps the URL', async () => {
+      const traced = page.waitForRequest(traceRequest('cafebabe'));
+      await page.goto(BASE + '/#/tools/trace/cafebabe', { waitUntil: 'domcontentloaded' });
+      await page.waitForSelector('#traceHashInput');
+      assert((await page.inputValue('#traceHashInput')) === 'cafebabe', 'input not pre-filled');
+      await traced;
+      // The trace finished rendering (an unknown hash renders .trace-empty).
+      await page.waitForSelector('#traceResults .trace-empty');
+      const hash = await page.evaluate(() => location.hash);
+      assert(/^#\/tools\/trace\/cafebabe$/.test(hash), 'URL changed to ' + hash);
+    });
+
+    await step('no page errors', async () => {
+      assert(errors.length === 0, errors.join(' | '));
+    });
+  } finally {
+    await browser.close();
+  }
+  console.log('\ntest-issue-1522-trace-url-sync-e2e.js: ' + passed + ' passed, ' + failed + ' failed');
+  process.exit(failed ? 1 : 0);
+})().catch((e) => { console.error(e); process.exit(1); });
diff --git a/test-issue-1646-compare-polish.js b/test-issue-1646-compare-polish.js
index 6490e5b90..14700acc0 100644
--- a/test-issue-1646-compare-polish.js
+++ b/test-issue-1646-compare-polish.js
@@ -31,7 +31,11 @@
 const fs = require('fs');
 const path = require('path');
 
-const CSS = fs.readFileSync(path.join(__dirname, 'public/style.css'), 'utf8');
+// Comments are blanked (newlines kept, so line-anchored regexes still work):
+// d954ea74 (#1668 M5) added a comment with `font-size:10px` inside the
+// .compare-vs rule, and the font-size parser read the comment.
+const CSS = fs.readFileSync(path.join(__dirname, 'public/style.css'), 'utf8')
+  .replace(/\/\*[\s\S]*?\*\//g, (c) => c.replace(/[^\n]/g, ''));
 const COMPARE_JS = fs.readFileSync(path.join(__dirname, 'public/compare.js'), 'utf8');
 
 // Token-rank used by font-size comparisons. Comments-only mirror of the
diff --git a/test-live-pulse-ring-weight-e2e.js b/test-live-pulse-ring-weight-e2e.js
new file mode 100644
index 000000000..8a0e35e5c
--- /dev/null
+++ b/test-live-pulse-ring-weight-e2e.js
@@ -0,0 +1,124 @@
+/**
+ * E2E (#1521, ported for #189): the Live map's node-pulse highlight ring
+ * never drops below a 2px stroke while it is visible (a11y minimum).
+ *
+ * Since #1521 the pulse rings are drawn on the canvas animation engine:
+ * pulseNode() queues a pulse with hl_weight 3, and stepPulse() thins it to 2
+ * once hl_op falls to 0.4 or below, until the ring fades out (hl_op <= 0).
+ *
+ * The test loads /#/live, waits for init and an idle engine in LIVE mode,
+ * fires one pulse through window._liveTestSeams.triggerPulse, and then
+ * follows that pulse frame by frame (awaiting rAF inside the page, as in
+ * test-pr-1490-live-map-gpu-animations-e2e.js) until the engine drops it.
+ * It checks that the ring was seen visible in both phases (so the thin
+ * phase was really observed) and that its weight was >= 2 in every visible
+ * frame.
+ *
+ * Previously test-marker-outline-weight.js, an @playwright/test spec;
+ * that runner is not a dependency, so the spec never ran. This port uses the
+ * plain `playwright` API like the other *-e2e.js files.
+ *
+ * Usage: BASE_URL=http://localhost:13581 node test-live-pulse-ring-weight-e2e.js
+ */
+'use strict';
+const { chromium } = require('playwright');
+
+const BASE = process.env.BASE_URL || 'http://localhost:13581';
+const MIN_WEIGHT = 2;
+// The ring fades out in ~0.7s at 1x; 5s is ample headroom for slow CI.
+const LIFETIME_TIMEOUT_MS = 5000;
+
+let passed = 0, failed = 0;
+async function step(name, fn) {
+  try { await fn(); passed++; console.log('  ✓ ' + name); }
+  catch (e) { failed++; console.error('  ✗ ' + name + ': ' + e.message); }
+}
+function assert(c, m) { if (!c) throw new Error(m || 'assertion failed'); }
+
+async function run(browser) {
+  const ctx = await browser.newContext({ viewport: { width: 1400, height: 900 } });
+  const page = await ctx.newPage();
+  page.setDefaultTimeout(15000);
+  const errors = [];
+  page.on('pageerror', (e) => errors.push(e.message));
+  try {
+    await page.goto(BASE + '/#/live', { waitUntil: 'domcontentloaded' });
+    await page.waitForSelector('#liveMap', { state: 'visible' });
+    await page.waitForFunction(() => typeof window._liveWSHandler === 'function' && !!window._liveWSHandler() &&
+      !!window._liveTestSeams && typeof window._liveTestSeams.triggerPulse === 'function');
+    await page.evaluate(() => { if (window._liveVcrSetMode) window._liveVcrSetMode('LIVE'); });
+
+    const seen = await page.evaluate(async (timeoutMs) => {
+      const seams = window._liveTestSeams;
+      // stepPulse runs for every queued pulse, on screen or not.
+      const before = seams.getPulses().length;
+      seams.triggerPulse('test-189-pulse-ring', [37.45, -122.05], 'ADVERT');
+      const pulses = seams.getPulses();
+      if (pulses.length !== before + 1) return { queued: false };
+      const pulse = pulses[pulses.length - 1];
+      const out = { queued: true, initialWeight: pulse.hl_weight, frames: 0, thick: 0, thin: 0,
+        minWeight: Infinity, minWeightOp: null, done: false };
+      const t0 = performance.now();
+      while (performance.now() - t0 < timeoutMs) {
+        await new Promise((r) => requestAnimationFrame(r));
+        if (!seams.getPulses().includes(pulse)) { out.done = true; break; }
+        if (!(pulse.hl_op > 0)) continue;
+        out.frames++;
+        if (pulse.hl_op > 0.4) out.thick++; else out.thin++;
+        if (pulse.hl_weight < out.minWeight) { out.minWeight = pulse.hl_weight; out.minWeightOp = pulse.hl_op; }
+      }
+      out.ms = Math.round(performance.now() - t0);
+      return out;
+    }, LIFETIME_TIMEOUT_MS);
+
+    await step('the pulse is queued with a ' + seen.initialWeight + 'px ring', async () => {
+      assert(seen.queued, 'triggerPulse did not add a pulse to activePulses');
+      assert(seen.initialWeight >= MIN_WEIGHT, 'initial hl_weight ' + seen.initialWeight + ' < ' + MIN_WEIGHT);
+    });
+
+    await step('the ring is followed through its visible life (' + seen.frames + ' frames, ' +
+      seen.thick + ' thick + ' + seen.thin + ' thin, ' + seen.ms + 'ms)', async () => {
+      assert(seen.done, 'the pulse was not removed within ' + LIFETIME_TIMEOUT_MS + 'ms');
+      assert(seen.thick > 0, 'no visible frame with hl_op > 0.4 was observed');
+      assert(seen.thin > 0, 'no visible frame with 0 < hl_op <= 0.4 was observed (the thin phase)');
+    });
+
+    await step('the visible ring is never thinner than ' + MIN_WEIGHT + 'px (min ' + seen.minWeight + ')', async () => {
+      assert(seen.minWeight >= MIN_WEIGHT, 'hl_weight dropped to ' + seen.minWeight + ' at hl_op ' + seen.minWeightOp);
+    });
+
+    await step('no page errors', async () => {
+      assert(errors.length === 0, errors.join(' | '));
+    });
+  } finally {
+    await ctx.close();
+  }
+}
+
+(async () => {
+  const requireChromium = process.env.CHROMIUM_REQUIRE === '1';
+  let browser;
+  try {
+    browser = await chromium.launch({
+      headless: true,
+      executablePath: process.env.CHROMIUM_PATH || undefined,
+      args: ['--no-sandbox', '--disable-gpu', '--disable-dev-shm-usage'],
+    });
+  } catch (err) {
+    if (requireChromium) {
+      console.error('test-live-pulse-ring-weight-e2e.js: FAIL — Chromium required but unavailable: ' + err.message);
+      process.exit(1);
+    }
+    console.log('test-live-pulse-ring-weight-e2e.js: SKIP (Chromium unavailable: ' + err.message.split('\n')[0] + ')');
+    process.exit(0);
+  }
+  console.log('=== #1521 live pulse ring weight E2E — ' + BASE + ' ===');
+  try {
+    try { await run(browser); }
+    catch (e) { failed++; console.error('  ✗ ' + e.message); }
+  } finally {
+    await browser.close();
+  }
+  console.log('\ntest-live-pulse-ring-weight-e2e.js: ' + passed + ' passed, ' + failed + ' failed');
+  process.exit(failed ? 1 : 0);
+})();
diff --git a/test-marker-outline-weight.js b/test-marker-outline-weight.js
deleted file mode 100644
index 098858958..000000000
--- a/test-marker-outline-weight.js
+++ /dev/null
@@ -1,51 +0,0 @@
-import { test, expect } from '@playwright/test';
-
-test.describe('Canvas Animations A11y', () => {
-  test('Canvas pulse highlight ring maintains minimum a11y weight of 2', async ({ page }) => {
-    // Navigate to the live map 
-    await page.goto('/#/live');
-
-    // Wait for the map and our test seams to initialize
-    await page.waitForFunction(() => window._liveTestSeams !== undefined);
-
-    // Evaluate the pulse lifecycle inside the browser context
-    const minWeightSeen = await page.evaluate(async () => {
-      return new Promise((resolve) => {
-        const seams = window._liveTestSeams;
-        
-        // Trigger a synthetic pulse at an arbitrary coordinate
-        seams.triggerPulse('a11y-test-node', [38.8951, -77.0364], 'ADVERT');
-        
-        let minSeenWeight = Infinity;
-
-        // Monitor the pulse frame-by-frame
-        function checkFrame() {
-          const pulses = seams.getPulses();
-          
-          // If the array is empty, the pulse finished its lifecycle
-          if (pulses.length === 0) {
-            resolve(minSeenWeight);
-            return;
-          }
-
-          const p = pulses[0];
-          
-          // Only assert weight while the highlight ring is actually visible
-          if (p.hl_op > 0) {
-            if (p.hl_weight < minSeenWeight) {
-              minSeenWeight = p.hl_weight;
-            }
-          }
-          
-          requestAnimationFrame(checkFrame);
-        }
-        
-        // Start the monitoring loop
-        requestAnimationFrame(checkFrame);
-      });
-    });
-
-    // Assert that at no point during the visible lifecycle did the stroke weight drop below 2
-    expect(minWeightSeen).toBeGreaterThanOrEqual(2);
-  });
-});
\ No newline at end of file
diff --git a/test-node-reach-e2e.js b/test-node-reach-e2e.js
index 639333dd8..a937207d5 100644
--- a/test-node-reach-e2e.js
+++ b/test-node-reach-e2e.js
@@ -65,9 +65,13 @@ async function getJson(page, url) {
       if (!href || !href.startsWith('#/nodes/')) throw new Error('neighbour link malformed: ' + href);
     }
 
-    // Map must render whenever at least one link has GPS (no swallowed failure).
-    if (reach.links.some(l => l.lat != null && l.lon != null)) {
-      await page.waitForSelector('#nqMap .leaflet-container', { timeout: 10000 });
+    // Map must render whenever the node and at least one link have GPS (no
+    // swallowed failure). node-reach.js only builds the map when the node
+    // itself has a location. L.map('nqMap') puts .leaflet-container on #nqMap
+    // itself, so the selector is a compound one, not a descendant one.
+    if (reach.node.lat != null && reach.links.some(l => l.lat != null && l.lon != null)) {
+      await page.waitForSelector('#nqMap.leaflet-container', { timeout: 10000 });
+      await page.waitForSelector('#nqMap .leaflet-map-pane', { state: 'attached', timeout: 10000 });
     }
   }
 
diff --git a/test-packets.js b/test-packets.js
index 71f525c0e..4c44d79a3 100644
--- a/test-packets.js
+++ b/test-packets.js
@@ -16,6 +16,13 @@ function test(name, fn) {
   }
 }
 
+// The aria-hidden Phosphor sprite icon packets.js renders. 30627454 (#1648 M2)
+// replaced the row emoji with these, one to one (💬 → chat-circle, 📡 →
+// broadcast, 🔒 → lock, …).
+function phIcon(name) {
+  return '<svg class="ph-icon" aria-hidden="true"><use href="/icons/phosphor-sprite.svg#ph-' + name + '"/></svg>';
+}
+
 // Build a browser-like sandbox with all deps packets.js needs
 function makeSandbox() {
   const registeredPages = {};
@@ -212,7 +219,7 @@ console.log('\n=== packets.js: getDetailPreview ===');
 
   test('getDetailPreview handles CHAN type', () => {
     const result = api.getDetailPreview({ type: 'CHAN', text: 'hello world', channel: 'general' });
-    assert(result.includes('💬'));
+    assert(result.includes(phIcon('chat-circle')));
     assert(result.includes('hello world'));
     assert(result.includes('chan-tag'));
     assert(result.includes('general'));
@@ -230,7 +237,7 @@ console.log('\n=== packets.js: getDetailPreview ===');
       type: 'ADVERT', name: 'TestNode', pubKey: 'abc123',
       flags: { repeater: true }
     });
-    assert(result.includes('📡'));
+    assert(result.includes(phIcon('broadcast')));
     assert(result.includes('TestNode'));
     assert(result.includes('hop-link'));
   });
@@ -240,7 +247,7 @@ console.log('\n=== packets.js: getDetailPreview ===');
       type: 'ADVERT', name: 'RoomNode', pubKey: 'abc',
       flags: { room: true }
     });
-    assert(result.includes('🏠'));
+    assert(result.includes(phIcon('house-line')));
   });
 
   test('getDetailPreview handles ADVERT sensor', () => {
@@ -248,7 +255,7 @@ console.log('\n=== packets.js: getDetailPreview ===');
       type: 'ADVERT', name: 'Sensor1', pubKey: 'abc',
       flags: { sensor: true }
     });
-    assert(result.includes('🌡'));
+    assert(result.includes(phIcon('thermometer')));
   });
 
   test('getDetailPreview handles ADVERT companion (default)', () => {
@@ -256,14 +263,14 @@ console.log('\n=== packets.js: getDetailPreview ===');
       type: 'ADVERT', name: 'Comp', pubKey: 'abc',
       flags: {}
     });
-    assert(result.includes('📻'));
+    assert(result.includes(phIcon('radio')));
   });
 
   test('getDetailPreview handles GRP_TXT with channelHash (no_key)', () => {
     const result = api.getDetailPreview({
       type: 'GRP_TXT', channelHash: 0xAB, decryptionStatus: 'no_key'
     });
-    assert(result.includes('🔒'));
+    assert(result.includes(phIcon('lock')));
     assert(result.includes('0xAB'));
     assert(result.includes('no key'));
   });
@@ -447,7 +454,7 @@ console.log('\n=== packets.js: getDetailPreview ===');
     const result = api.getDetailPreview({
       type: 'TXT_MSG', srcHash: 'abcdef01', destHash: '12345678'
     });
-    assert(result.includes('✉️'));
+    assert(result.includes(phIcon('envelope')));
     assert(result.includes('abcdef01'));
     assert(result.includes('12345678'));
   });
@@ -456,14 +463,14 @@ console.log('\n=== packets.js: getDetailPreview ===');
     const result = api.getDetailPreview({
       type: 'PATH', srcHash: 'aabb', destHash: 'ccdd'
     });
-    assert(result.includes('🔀'));
+    assert(result.includes(phIcon('shuffle')));
   });
 
   test('getDetailPreview handles REQ', () => {
     const result = api.getDetailPreview({
       type: 'REQ', srcHash: 'aa', destHash: 'bb'
     });
-    assert(result.includes('🔒'));
+    assert(result.includes(phIcon('lock')));
     assert(result.includes('aa'));
   });
 
@@ -471,7 +478,7 @@ console.log('\n=== packets.js: getDetailPreview ===');
     const result = api.getDetailPreview({
       type: 'RESPONSE', srcHash: 'aa', destHash: 'bb'
     });
-    assert(result.includes('🔒'));
+    assert(result.includes(phIcon('lock')));
   });
 
   test('getDetailPreview handles ANON_REQ', () => {
@@ -545,7 +552,7 @@ console.log('\n=== packets.js: getDetailPreview ===');
 
   test('getDetailPreview handles public_key fallback', () => {
     const result = api.getDetailPreview({ public_key: 'abcdef1234567890abcdef' });
-    assert(result.includes('📡'));
+    assert(result.includes(phIcon('broadcast')));
     assert(result.includes('abcdef1234567890'));
   });
 
@@ -1122,7 +1129,12 @@ console.log('\n=== packets.js: buildGroupRowHtml ===');
     };
     const result = api.buildGroupRowHtml(p);
     assert(result.includes('group-header'));
-    assert(result.includes('▶'));  // collapsed arrow
+    // Collapsed arrow. Before 30627454 (#1648 M2) a collapsed group showed ▶
+    // (and an expanded one ▼); the right-pointing sprite is #ph-caret-right.
+    // The migration mapped ▶ to #ph-caret-up, so this assertion is RED on
+    // purpose: it documents the collapsed-caret bug tracked in #189.
+    assert(result.includes(phIcon('caret-right')), 'collapsed group shows a right caret');
+    assert(!result.includes(phIcon('caret-down')), 'collapsed group does not show the expanded caret');
   });
 
   test('buildGroupRowHtml shows observation count badge', () => {
@@ -1134,7 +1146,7 @@ console.log('\n=== packets.js: buildGroupRowHtml ===');
     };
     const result = api.buildGroupRowHtml(p);
     assert(result.includes('badge-obs'));
-    assert(result.includes('👁'));
+    assert(result.includes(phIcon('eye')));
     assert(result.includes('5'));
   });
 
diff --git a/test-path-inspector-coverage-e2e.js b/test-path-inspector-coverage-e2e.js
index 33ce8db36..97e750a0a 100644
--- a/test-path-inspector-coverage-e2e.js
+++ b/test-path-inspector-coverage-e2e.js
@@ -1,11 +1,10 @@
 #!/usr/bin/env node
 /* Coverage E2E for public/path-inspector.js (#1297 B5).
  *
- * The existing test-path-inspector-e2e.js uses @playwright/test runner
- * which is not wired into CI's `e2e-test` step (CI runs raw
- * `node test-…-e2e.js`). This file uses the plain chromium-launch
- * pattern compatible with CI and exercises the standalone tools page
- * surface end-to-end:
+ * test-path-inspector-e2e.js covers the map side pane and the Tools
+ * landing (ported from @playwright/test in #189). This file uses the
+ * plain chromium-launch pattern compatible with CI and exercises the
+ * standalone tools page surface end-to-end:
  *
  *   - navigate to /#/tools/path-inspector
  *   - assert page chrome renders (input, submit btn, help text)
diff --git a/test-path-inspector-e2e.js b/test-path-inspector-e2e.js
index ddf16c453..a17afa3ef 100644
--- a/test-path-inspector-e2e.js
+++ b/test-path-inspector-e2e.js
@@ -1,87 +1,131 @@
-// E2E tests for Path Inspector (spec §5 — Playwright).
-// Run: npx playwright test test-path-inspector-e2e.js
-// Requires: running server on BASE_URL (default http://localhost:3000).
+/**
+ * E2E (Path Inspector spec §2.7 / §2.8, ported for #189): the Path Inspector
+ * side pane on the map page, and the Tools landing.
+ *
+ * Previously an @playwright/test spec; that runner is not a dependency, so it
+ * never ran. This port uses the plain `playwright` API like the other
+ * *-e2e.js files and keeps the cases nothing else in CI covers:
+ *   1. #mapSidePane is visible and collapsed on load; the toggle expands it;
+ *   2. submitting prefixes in the pane renders a candidate table;
+ *   3. "Show on Map" draws the candidate route (an .mc-rt-edge path) and
+ *      enters route view;
+ *   4. the Tools landing links to the Path Inspector and to Trace.
+ *
+ * Dropped from the old spec, covered elsewhere in CI:
+ *   - standalone deep link ?prefixes= auto-fills and runs →
+ *     test-path-inspector-coverage-e2e.js ("deep link ?prefixes=2c …");
+ *   - #/traces/<hash> → #/tools/trace/<hash> → test-issue-1883-redirect-history.js;
+ *   - "switching candidate clears prior polyline" asserted nothing.
+ *
+ * The old spec used the fixed prefixes 2c,a1, which have no candidates in
+ * the CI fixture. The test now asks /api/paths/inspect for a two-hop pair
+ * of repeater prefixes that does (bounded search).
+ *
+ * Usage: BASE_URL=http://localhost:13581 node test-path-inspector-e2e.js
+ */
 'use strict';
+const { chromium } = require('playwright');
 
-const { test, expect } = require('@playwright/test');
-const BASE_URL = process.env.BASE_URL || 'http://localhost:3000';
+const BASE = process.env.BASE_URL || 'http://localhost:13581';
+const MAX_PROBES = 400; // bounded /api/paths/inspect calls for the pair search
 
-test.describe('Path Inspector — Map Side Pane (spec §2.7)', () => {
-  test('side pane present and collapsed by default', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/map`);
-    const pane = page.locator('#mapSidePane');
-    await expect(pane).toBeVisible();
-    await expect(pane).not.toHaveClass(/expanded/);
-  });
+let passed = 0, failed = 0;
+async function step(name, fn) {
+  try { await fn(); passed++; console.log('  ✓ ' + name); }
+  catch (e) { failed++; console.error('  ✗ ' + name + ': ' + e.message); }
+}
+function assert(c, m) { if (!c) throw new Error(m || 'assertion failed'); }
 
-  test('click toggle expands the pane', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/map`);
-    await page.click('#mapPaneToggle');
-    const pane = page.locator('#mapSidePane');
-    await expect(pane).toHaveClass(/expanded/);
-  });
+// A pair of 1-byte repeater prefixes with at least one candidate path.
+async function findCandidatePair(request) {
+  const nodes = await (await request.get(BASE + '/api/nodes?role=repeater&limit=500')).json();
+  const prefixes = [...new Set((nodes.nodes || []).map((n) => n.public_key.slice(0, 2).toLowerCase()))].sort();
+  let probes = 0;
+  for (const a of prefixes) {
+    for (const b of prefixes) {
+      if (a === b) continue;
+      if (++probes > MAX_PROBES) return null;
+      const res = await request.post(BASE + '/api/paths/inspect', { data: { prefixes: [a, b] } });
+      if (!res.ok()) continue;
+      const body = await res.json();
+      if (body.candidates && body.candidates.length) return { prefixes: a + ',' + b, count: body.candidates.length };
+    }
+  }
+  return null;
+}
 
-  test('submit valid prefixes renders candidates within 1s', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/map`);
-    await page.click('#mapPaneToggle');
-    await page.fill('#mapPiInput', '2c,a1,f4');
-    await page.click('#mapPiSubmit');
-    // Wait for results or error (both indicate API round-trip complete).
-    await expect(page.locator('#mapPiResults table, #mapPiResults .no-results, #mapPiError')).toBeVisible({ timeout: 1000 });
-  });
+(async () => {
+  const requireChromium = process.env.CHROMIUM_REQUIRE === '1';
+  let browser;
+  try {
+    browser = await chromium.launch({
+      headless: true,
+      executablePath: process.env.CHROMIUM_PATH || undefined,
+      args: ['--no-sandbox', '--disable-gpu', '--disable-dev-shm-usage'],
+    });
+  } catch (err) {
+    if (requireChromium) {
+      console.error('test-path-inspector-e2e.js: FAIL — Chromium required but unavailable: ' + err.message);
+      process.exit(1);
+    }
+    console.log('test-path-inspector-e2e.js: SKIP (Chromium unavailable: ' + err.message.split('\n')[0] + ')');
+    process.exit(0);
+  }
+  const ctx = await browser.newContext({ viewport: { width: 1400, height: 900 } });
+  const page = await ctx.newPage();
+  page.setDefaultTimeout(15000);
+  const errors = [];
+  page.on('pageerror', (e) => errors.push(e.message));
 
-  test('Show on Map button draws polyline on map', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/map`);
-    await page.click('#mapPaneToggle');
-    await page.fill('#mapPiInput', '2c,a1');
-    await page.click('#mapPiSubmit');
-    // Wait for results.
-    const btn = page.locator('#mapPiResults button[data-idx="0"]');
-    await btn.waitFor({ timeout: 2000 });
-    await btn.click();
-    // Check that route layer has SVG polyline paths drawn.
-    const svg = page.locator('#leaflet-map .leaflet-overlay-pane svg path');
-    await expect(svg.first()).toBeVisible({ timeout: 2000 });
-  });
+  console.log('\n=== Path Inspector map pane + Tools landing E2E against ' + BASE + ' ===');
+  try {
+    const pair = await findCandidatePair(ctx.request);
 
-  test('switching candidate clears prior polyline', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/map`);
-    await page.click('#mapPaneToggle');
-    await page.fill('#mapPiInput', '2c,a1');
-    await page.click('#mapPiSubmit');
-    const btn0 = page.locator('#mapPiResults button[data-idx="0"]');
-    await btn0.waitFor({ timeout: 2000 });
-    await btn0.click();
-    // Click second candidate if available.
-    const btn1 = page.locator('#mapPiResults button[data-idx="1"]');
-    if (await btn1.isVisible()) {
-      await btn1.click();
-      // Prior route should be cleared — only one polyline group visible.
-    }
-  });
-});
+    await page.goto(BASE + '/#/map', { waitUntil: 'domcontentloaded' });
+    await page.waitForSelector('#mapSidePane', { state: 'visible' });
+
+    await step('side pane is visible and collapsed on load', async () => {
+      const cls = await page.getAttribute('#mapSidePane', 'class');
+      assert(!/\bexpanded\b/.test(cls), 'pane should start collapsed, class="' + cls + '"');
+    });
+
+    await step('clicking the toggle expands the pane', async () => {
+      await page.click('#mapPaneToggle');
+      await page.waitForFunction(() => document.getElementById('mapSidePane').classList.contains('expanded'));
+      assert(await page.isVisible('#mapPiInput'), '#mapPiInput not visible in the expanded pane');
+    });
+
+    await step('submitting prefixes renders a candidate table' + (pair ? ' (' + pair.prefixes + ')' : ''), async () => {
+      assert(pair, 'no repeater prefix pair with candidates found in ' + MAX_PROBES + ' probes');
+      await page.fill('#mapPiInput', pair.prefixes);
+      await page.click('#mapPiSubmit');
+      await page.waitForSelector('#mapPiResults .path-inspector-table');
+      const err = ((await page.textContent('#mapPiError')) || '').trim();
+      assert(!err, 'unexpected error: ' + err);
+      const rows = await page.locator('#mapPiResults button[data-idx]').count();
+      assert(rows === pair.count, 'rendered ' + rows + ' candidates, API returned ' + pair.count);
+    });
 
-test.describe('Path Inspector — Standalone Page', () => {
-  test('deep link auto-fills and runs', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/tools/path-inspector?prefixes=2c,a1,f4`);
-    const input = page.locator('#path-inspector-input');
-    await expect(input).toHaveValue('2c,a1,f4');
-    // Should auto-submit and show results or error.
-    await expect(page.locator('#path-inspector-results table, #path-inspector-results .no-results, #path-inspector-error')).toBeVisible({ timeout: 2000 });
-  });
+    await step('"Show on Map" draws the candidate route', async () => {
+      assert(pair, 'no candidate to show');
+      await page.click('#mapPiResults button[data-idx="0"]');
+      await page.waitForSelector('#leaflet-map .leaflet-overlay-pane path.mc-rt-edge', { state: 'visible' });
+      assert(await page.evaluate(() => document.body.classList.contains('mc-route-active')), 'route view not active');
+    });
 
-  test('old #/traces/<hash> redirects to #/tools/trace/<hash>', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/traces/abc123`);
-    await page.waitForTimeout(500);
-    expect(page.url()).toContain('#/tools/trace/abc123');
-  });
-});
+    await step('Tools landing links to the Path Inspector and to Trace', async () => {
+      await page.goto(BASE + '/#/tools', { waitUntil: 'domcontentloaded' });
+      await page.waitForSelector('.tools-landing', { state: 'visible' });
+      assert(await page.isVisible('.tools-landing a[href="#/tools/path-inspector"]'), 'Path Inspector entry missing');
+      assert(await page.isVisible('.tools-landing a[href^="#/tools/trace"]'), 'Trace entry missing');
+    });
 
-test.describe('Path Inspector — Tools Landing (spec §2.8)', () => {
-  test('Tools nav shows landing with both entries', async ({ page }) => {
-    await page.goto(`${BASE_URL}/#/tools`);
-    await expect(page.locator('.tools-landing')).toBeVisible();
-    await expect(page.locator('a[href="#/tools/path-inspector"]')).toBeVisible();
-    await expect(page.locator('a[href*="#/tools/trace"]')).toBeVisible();
-  });
-});
+    await step('no page errors', async () => {
+      assert(errors.length === 0, errors.join(' | '));
+    });
+  } finally {
+    await browser.close();
+  }
+  console.log('\ntest-path-inspector-e2e.js: ' + passed + ' passed, ' + failed + ' failed');
+  process.exit(failed ? 1 : 0);
+})().catch((e) => { console.error(e); process.exit(1); });
diff --git a/test-perf-disk-io-1120.js b/test-perf-disk-io-1120.js
index b9b692319..1dc3f2e6a 100644
--- a/test-perf-disk-io-1120.js
+++ b/test-perf-disk-io-1120.js
@@ -10,6 +10,14 @@ async function test(name, fn) {
   catch (e) { failed++; console.log(`  ❌ ${name}: ${e.message}`); }
 }
 
+// The warning flag perf.js renders. 30627454 (#1648 M2) replaced the ⚠️
+// emoji with this sprite, so every "⚠️" check below now matches WARN; the
+// negative checks were passing vacuously while they looked for ⚠️.
+const WARN = '<svg class="ph-icon" aria-hidden="true"><use href="/icons/phosphor-sprite.svg#ph-warning"/></svg>';
+const reEsc = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+// `value` followed by the warning icon in the same card (`value WARN`).
+const flagged = (html, value) => new RegExp(reEsc(value) + ' ' + reEsc(WARN)).test(html);
+
 function makeSandbox() {
   let capturedHtml = '';
   const pages = {};
@@ -147,140 +155,141 @@ await test('Renders ingestor row alongside server row in Disk I/O', async () =>
   assert.ok(/1\.0\s*MB/.test(html), 'should render ingestor write 1 MB/s');
 });
 
-await test('WAL >100 MB fires ⚠️ flag', async () => {
+await test('WAL >100 MB fires the warning flag', async () => {
   const sb = loadPerf();
   const sql = { ...sqliteData, walSizeMB: 150, walSize: 150 * 1048576 };
   stubFetch(sb, { ...basePerf, goRuntime }, goHealth, ioData, sql, sourcesData);
   await sb.pages.perf.init({ set innerHTML(v) {} });
   await new Promise(r => setTimeout(r, 100));
   const html = sb.getHtml();
-  // The warning appears in the WAL Size card; assert proximity by extracting
-  // the WAL Size card's text content.
-  const walSection = html.match(/150\.0MB[^<]*⚠️/);
-  assert.ok(walSection, 'expected ⚠️ next to 150MB WAL value, html=' + html.slice(html.indexOf('WAL Size') - 200, html.indexOf('WAL Size') + 200));
+  assert.ok(flagged(html, '150.0MB'), 'expected the warning icon next to the 150MB WAL value, html=' + html.slice(html.indexOf('WAL Size') - 200, html.indexOf('WAL Size') + 200));
 });
 
-await test('WAL <100 MB does NOT fire ⚠️ flag', async () => {
+await test('WAL <100 MB does NOT fire the warning flag', async () => {
   const sb = loadPerf();
   const sql = { ...sqliteData, walSizeMB: 12.3 };
   stubFetch(sb, { ...basePerf, goRuntime }, goHealth, ioData, sql, sourcesData);
   await sb.pages.perf.init({ set innerHTML(v) {} });
   await new Promise(r => setTimeout(r, 100));
   const html = sb.getHtml();
-  const walIdx = html.indexOf('WAL Size');
-  const slice = html.slice(Math.max(0, walIdx - 200), walIdx);
-  assert.ok(!/12\.3MB[^<]*⚠️/.test(slice), 'expected NO ⚠️ next to 12.3MB WAL value');
+  assert.ok(html.includes('12.3MB'), 'WAL value rendered');
+  assert.ok(!flagged(html, '12.3MB'), 'expected NO warning icon next to the 12.3MB WAL value');
 });
 
-await test('Cache hit <90% fires ⚠️ flag', async () => {
+await test('Cache hit <90% fires the warning flag', async () => {
   const sb = loadPerf();
   const sql = { ...sqliteData, cacheHitRate: 0.85 };
   stubFetch(sb, { ...basePerf, goRuntime }, goHealth, ioData, sql, sourcesData);
   await sb.pages.perf.init({ set innerHTML(v) {} });
   await new Promise(r => setTimeout(r, 100));
   const html = sb.getHtml();
-  assert.ok(/85\.0%[^<]*⚠️/.test(html), 'expected ⚠️ next to 85.0% cache hit value');
+  assert.ok(flagged(html, '85.0%'), 'expected the warning icon next to the 85.0% cache hit value');
 });
 
-await test('Cache hit ≥90% does NOT fire ⚠️ flag', async () => {
+await test('Cache hit ≥90% does NOT fire the warning flag', async () => {
   const sb = loadPerf();
   const sql = { ...sqliteData, cacheHitRate: 0.987 };
   stubFetch(sb, { ...basePerf, goRuntime }, goHealth, ioData, sql, sourcesData);
   await sb.pages.perf.init({ set innerHTML(v) {} });
   await new Promise(r => setTimeout(r, 100));
   const html = sb.getHtml();
-  assert.ok(!/98\.7%[^<]*⚠️/.test(html), 'expected NO ⚠️ next to 98.7% cache hit value');
+  assert.ok(html.includes('98.7%'), 'cache hit value rendered');
+  assert.ok(!flagged(html, '98.7%'), 'expected NO warning icon next to the 98.7% cache hit value');
 });
 
 // === #1167 must-fix #7: threshold boundary cases ===
 
-await test('WAL exactly 100 MB does NOT fire ⚠️ (boundary, strict >)', async () => {
+await test('WAL exactly 100 MB does NOT fire the warning (boundary, strict >)', async () => {
   const sb = loadPerf();
   const sql = { ...sqliteData, walSizeMB: 100 };
   stubFetch(sb, { ...basePerf, goRuntime }, goHealth, ioData, sql, sourcesData);
   await sb.pages.perf.init({ set innerHTML(v) {} });
   await new Promise(r => setTimeout(r, 100));
   const html = sb.getHtml();
-  const walIdx = html.indexOf('WAL Size');
-  const slice = html.slice(Math.max(0, walIdx - 200), walIdx);
-  assert.ok(!/100\.0MB[^<]*⚠️/.test(slice), 'expected NO ⚠️ at exactly 100 MB WAL (boundary), slice=' + slice);
+  assert.ok(html.includes('100.0MB'), 'WAL value rendered');
+  assert.ok(!flagged(html, '100.0MB'), 'expected NO warning icon at exactly 100 MB WAL (boundary)');
 });
 
-await test('WAL infinitesimally over 100 MB DOES fire ⚠️', async () => {
+await test('WAL infinitesimally over 100 MB DOES fire the warning', async () => {
   const sb = loadPerf();
   const sql = { ...sqliteData, walSizeMB: 100.01 };
   stubFetch(sb, { ...basePerf, goRuntime }, goHealth, ioData, sql, sourcesData);
   await sb.pages.perf.init({ set innerHTML(v) {} });
   await new Promise(r => setTimeout(r, 100));
   const html = sb.getHtml();
-  assert.ok(/100\.0MB[^<]*⚠️/.test(html), 'expected ⚠️ next to 100.0MB WAL value (just over threshold)');
+  assert.ok(flagged(html, '100.0MB'), 'expected the warning icon next to the 100.0MB WAL value (just over threshold)');
 });
 
-await test('Cache hit exactly 90% does NOT fire ⚠️ (boundary, strict <)', async () => {
+await test('Cache hit exactly 90% does NOT fire the warning (boundary, strict <)', async () => {
   const sb = loadPerf();
   const sql = { ...sqliteData, cacheHitRate: 0.90 };
   stubFetch(sb, { ...basePerf, goRuntime }, goHealth, ioData, sql, sourcesData);
   await sb.pages.perf.init({ set innerHTML(v) {} });
   await new Promise(r => setTimeout(r, 100));
   const html = sb.getHtml();
-  assert.ok(!/90\.0%[^<]*⚠️/.test(html), 'expected NO ⚠️ at exactly 90.0% cache hit (boundary)');
+  assert.ok(html.includes('90.0%'), 'cache hit value rendered');
+  assert.ok(!flagged(html, '90.0%'), 'expected NO warning icon at exactly 90.0% cache hit (boundary)');
 });
 
-await test('Cache hit infinitesimally below 90% DOES fire ⚠️', async () => {
+await test('Cache hit infinitesimally below 90% DOES fire the warning', async () => {
   const sb = loadPerf();
   const sql = { ...sqliteData, cacheHitRate: 0.8999 };
   stubFetch(sb, { ...basePerf, goRuntime }, goHealth, ioData, sql, sourcesData);
   await sb.pages.perf.init({ set innerHTML(v) {} });
   await new Promise(r => setTimeout(r, 100));
   const html = sb.getHtml();
-  assert.ok(/90\.0%[^<]*⚠️/.test(html), 'expected ⚠️ next to 90.0% cache hit value (just under threshold)');
+  assert.ok(flagged(html, '90.0%'), 'expected the warning icon next to the 90.0% cache hit value (just under threshold)');
 });
 
-await test('Backfill anomaly: rate >10× tx-rate WITH baseline tx≥100 fires ⚠️', async () => {
-  // Two-phase: prime the previous-snapshot cache, then tick again with
-  // a backfill rate >10× the tx rate AND tx_inserted past the baseline gate.
+// === Write Sources anomaly flag, rendered (#1120, detector from a26a412c / #1593) ===
+// detectPerfAnomalies itself is unit-tested in test-perf-anomaly.js. These
+// cases check the page wiring: history kept on window across refreshes, the
+// detector's verdict rendered as the warning icon on that source's row only,
+// and the 30 s minimum-history guard holding back a flag on a fresh page.
+
+async function renderWriteSources(sb, snapshots) {
+  for (const snap of snapshots) {
+    stubFetch(sb, { ...basePerf, goRuntime }, goHealth, ioData, sqliteData, snap);
+    await sb.pages.perf.init({ set innerHTML(v) {} });
+    await new Promise(r => setTimeout(r, 30));
+  }
+  return sb.getHtml();
+}
+function sourceRow(html, name) {
+  const idx = html.indexOf('<code>' + name + '</code>');
+  assert.ok(idx >= 0, name + ' row missing');
+  return html.slice(idx, html.indexOf('</tr>', idx));
+}
+const at = (sec) => new Date(Date.UTC(2026, 0, 1, 0, 0, sec)).toISOString();
+
+await test('Write Sources: a source at >10× its rolling baseline gets the warning flag, a steady one does not', async () => {
   const sb = loadPerf();
-  // Reset any previous cached snapshot
-  sb.ctx.window._perfWriteSourcesPrev = null;
-  const t0 = '2026-01-01T00:00:00Z';
-  const t1 = '2026-01-01T00:00:01Z'; // 1s later
-  const phase1 = { sources: { tx_inserted: 100, backfill_path_json: 0 }, sampleAt: t0 };
-  const phase2 = { sources: { tx_inserted: 105, backfill_path_json: 1000 }, sampleAt: t1 };
-  // First render: no prev → no flags possible
-  stubFetch(sb, { ...basePerf, goRuntime }, goHealth, ioData, sqliteData, phase1);
-  await sb.pages.perf.init({ set innerHTML(v) {} });
-  await new Promise(r => setTimeout(r, 50));
-  // Second render: simulate tick with delta. Reuse the same fetch wiring.
-  stubFetch(sb, { ...basePerf, goRuntime }, goHealth, ioData, sqliteData, phase2);
-  await sb.pages.perf.init({ set innerHTML(v) {} });
-  await new Promise(r => setTimeout(r, 50));
-  const html = sb.getHtml();
-  // After phase2: tx_rate = 5/s, backfill_rate = 1000/s → ratio = 200x → ⚠️
-  const idx = html.indexOf('backfill_path_json');
-  assert.ok(idx >= 0, 'backfill_path_json row missing');
-  const row = html.slice(idx, idx + 400);
-  assert.ok(row.includes('⚠️'), 'expected ⚠️ on backfill row when rate ratio >10×, row=' + row);
+  // 40 s of baseline (backfill 1/s, tx 5/s), then 1 s where backfill jumps
+  // to 100/s while tx stays at 5/s.
+  const html = await renderWriteSources(sb, [
+    { sources: { tx_inserted: 0, backfill_path_json: 0 }, sampleAt: at(0) },
+    { sources: { tx_inserted: 200, backfill_path_json: 40 }, sampleAt: at(40) },
+    { sources: { tx_inserted: 205, backfill_path_json: 140 }, sampleAt: at(41) },
+  ]);
+  const backfill = sourceRow(html, 'backfill_path_json');
+  assert.ok(backfill.includes('<td>100.00</td><td>1.00</td>'), 'backfill rate 100/s vs baseline 1/s rendered, row=' + backfill);
+  assert.ok(backfill.includes(WARN), 'expected the warning icon on the backfill row, row=' + backfill);
+  const tx = sourceRow(html, 'tx_inserted');
+  assert.ok(tx.includes('<td>5.00</td><td>5.00</td>'), 'tx rate and baseline 5/s rendered, row=' + tx);
+  assert.ok(!tx.includes(WARN), 'expected NO warning icon on the steady tx_inserted row, row=' + tx);
 });
 
-await test('Backfill anomaly: tx_inserted <100 baseline guard SUPPRESSES ⚠️', async () => {
-  // Same shape but tx_inserted stays well below the 100 floor; even a huge
-  // backfill rate ratio must NOT fire while we lack a meaningful baseline.
+await test('Write Sources: less than 30 s of history SUPPRESSES the warning flag', async () => {
   const sb = loadPerf();
-  sb.ctx.window._perfWriteSourcesPrev = null;
-  const t0 = '2026-01-01T00:00:00Z';
-  const t1 = '2026-01-01T00:00:01Z';
-  const phase1 = { sources: { tx_inserted: 5, backfill_path_json: 0 }, sampleAt: t0 };
-  const phase2 = { sources: { tx_inserted: 6, backfill_path_json: 1000 }, sampleAt: t1 };
-  stubFetch(sb, { ...basePerf, goRuntime }, goHealth, ioData, sqliteData, phase1);
-  await sb.pages.perf.init({ set innerHTML(v) {} });
-  await new Promise(r => setTimeout(r, 50));
-  stubFetch(sb, { ...basePerf, goRuntime }, goHealth, ioData, sqliteData, phase2);
-  await sb.pages.perf.init({ set innerHTML(v) {} });
-  await new Promise(r => setTimeout(r, 50));
-  const html = sb.getHtml();
-  const idx = html.indexOf('backfill_path_json');
-  const row = html.slice(idx, idx + 400);
-  assert.ok(!row.includes('⚠️'), 'expected NO ⚠️ on backfill row when tx_inserted<100, row=' + row);
+  // Same spike, but the baseline only spans 10 s (< minHistorySec 30).
+  const html = await renderWriteSources(sb, [
+    { sources: { tx_inserted: 0, backfill_path_json: 0 }, sampleAt: at(0) },
+    { sources: { tx_inserted: 50, backfill_path_json: 10 }, sampleAt: at(10) },
+    { sources: { tx_inserted: 55, backfill_path_json: 110 }, sampleAt: at(11) },
+  ]);
+  const backfill = sourceRow(html, 'backfill_path_json');
+  assert.ok(backfill.includes('<td>100.00</td><td>—</td>'), 'rate shown, baseline not yet established, row=' + backfill);
+  assert.ok(!backfill.includes(WARN), 'expected NO warning icon with < 30 s of history, row=' + backfill);
 });
 
 console.log(`\n${passed} passed, ${failed} failed\n`);
diff --git a/test-table-sort.js b/test-table-sort.js
index a6255b911..72da63a0b 100644
--- a/test-table-sort.js
+++ b/test-table-sort.js
@@ -1,7 +1,7 @@
 /* test-table-sort.js — Unit tests for TableSort utility */
 'use strict';
 
-const { JSDOM } = require('jsdom');
+const vm = require('vm');
 const fs = require('fs');
 const path = require('path');
 const assert = require('assert');
@@ -21,52 +21,132 @@ function test(name, fn) {
   }
 }
 
-function createDOM(html) {
-  const dom = new JSDOM(`<!DOCTYPE html><html><body>${html}</body></html>`, {
-    url: 'http://localhost',
-    runScripts: 'dangerously'
-  });
-  // Load TableSort into this DOM
-  const script = fs.readFileSync(path.join(__dirname, 'public', 'table-sort.js'), 'utf8');
-  const el = dom.window.document.createElement('script');
-  el.textContent = script;
-  dom.window.document.head.appendChild(el);
-  return dom;
+// ── Minimal DOM (#189: jsdom is not a dependency) ─────────────────────────
+// Just enough of the element API that table-sort.js touches: attributes,
+// classList, style, child lists with real moves on appendChild, remove(),
+// listeners + click(), cells, textContent and a small selector engine
+// (tag, .class, tag[attr], tag[attr="v"]; descendants, document order).
+class FakeEl {
+  constructor(tag) {
+    this.tagName = tag.toUpperCase();
+    this.children = [];
+    this.parentNode = null;
+    this.attrs = {};
+    this.style = {};
+    this.listeners = {};
+    this.text = '';
+    const el = this;
+    this.classList = {
+      add(c) { const s = el._classes(); if (!s.includes(c)) el.className = s.concat(c).join(' '); },
+      remove(c) { el.className = el._classes().filter((x) => x !== c).join(' '); },
+      contains(c) { return el._classes().includes(c); },
+    };
+  }
+  _classes() { return (this.attrs.class || '').split(/\s+/).filter(Boolean); }
+  get className() { return this.attrs.class || ''; }
+  set className(v) { this.attrs.class = String(v); }
+  getAttribute(k) { return Object.prototype.hasOwnProperty.call(this.attrs, k) ? this.attrs[k] : null; }
+  setAttribute(k, v) { this.attrs[k] = String(v); }
+  removeAttribute(k) { delete this.attrs[k]; }
+  appendChild(child) {
+    if (child.parentNode) child.remove();
+    child.parentNode = this;
+    this.children.push(child);
+    return child;
+  }
+  remove() {
+    if (!this.parentNode) return;
+    const sibs = this.parentNode.children;
+    sibs.splice(sibs.indexOf(this), 1);
+    this.parentNode = null;
+  }
+  // innerHTML is only ever assigned (the sort arrow); keep the markup as text.
+  set innerHTML(html) { this.children = []; this.text = String(html); }
+  get innerHTML() { return this.text + this.children.map((c) => c.innerHTML).join(''); }
+  get textContent() { return this.text + this.children.map((c) => c.textContent).join(''); }
+  get cells() { return this.children.filter((c) => c.tagName === 'TD' || c.tagName === 'TH'); }
+  addEventListener(type, fn) { (this.listeners[type] = this.listeners[type] || []).push(fn); }
+  removeEventListener(type, fn) { this.listeners[type] = (this.listeners[type] || []).filter((f) => f !== fn); }
+  click() { (this.listeners.click || []).slice().forEach((fn) => fn({ type: 'click', preventDefault() {} })); }
+  _descendants() { return this.children.flatMap((c) => [c, ...c._descendants()]); }
+  querySelectorAll(sel) { return this._descendants().filter((el) => matches(el, sel)); }
+  querySelector(sel) { return this.querySelectorAll(sel)[0] || null; }
+}
+
+function matches(el, sel) {
+  const m = /^([a-z]*)(?:\.([\w-]+))?(?:\[([\w-]+)(?:="([^"]*)")?\])?$/.exec(sel);
+  if (!m) throw new Error('FakeEl: unsupported selector ' + sel);
+  const [, tag, cls, attr, val] = m;
+  if (tag && el.tagName !== tag.toUpperCase()) return false;
+  if (cls && !el.classList.contains(cls)) return false;
+  if (attr && el.getAttribute(attr) == null) return false;
+  if (val !== undefined && el.getAttribute(attr) !== val) return false;
+  return true;
+}
+
+function createDOM(table) {
+  const body = new FakeEl('body');
+  if (table) body.appendChild(table);
+  const store = {};
+  const document = {
+    body,
+    createElement: (tag) => new FakeEl(tag),
+    getElementById: (id) => body._descendants().find((el) => el.getAttribute('id') === id) || null,
+    querySelector: (sel) => body.querySelector(sel),
+    querySelectorAll: (sel) => body.querySelectorAll(sel),
+  };
+  const window = { document };
+  const ctx = {
+    window, document,
+    localStorage: {
+      getItem: (k) => (k in store ? store[k] : null),
+      setItem: (k, v) => { store[k] = String(v); },
+    },
+  };
+  vm.createContext(ctx);
+  vm.runInContext(fs.readFileSync(path.join(__dirname, 'public', 'table-sort.js'), 'utf8'), ctx);
+  return { window };
 }
 
 function makeTable(headers, rows) {
   // headers: [{key, type?, label}], rows: [[value, ...]]
-  let html = '<table id="t"><thead><tr>';
+  const el = (tag, attrs, text) => {
+    const e = new FakeEl(tag);
+    for (const k in attrs || {}) e.setAttribute(k, attrs[k]);
+    if (text != null) e.text = String(text);
+    return e;
+  };
+  const table = el('table', { id: 't' });
+  const thead = table.appendChild(el('thead'));
+  const headRow = thead.appendChild(el('tr'));
   for (const h of headers) {
-    html += `<th data-sort-key="${h.key}"${h.type ? ` data-type="${h.type}"` : ''}>${h.label || h.key}</th>`;
+    headRow.appendChild(el('th', Object.assign({ 'data-sort-key': h.key }, h.type ? { 'data-type': h.type } : {}), h.label || h.key));
   }
-  html += '</tr></thead><tbody>';
+  const tbody = table.appendChild(el('tbody'));
   for (const row of rows) {
-    html += '<tr>';
-    for (let i = 0; i < row.length; i++) {
-      const val = row[i];
-      if (typeof val === 'object' && val !== null) {
-        html += `<td data-value="${val.dataValue}">${val.text || ''}</td>`;
-      } else {
-        html += `<td data-value="${val}">${val}</td>`;
-      }
+    const tr = tbody.appendChild(el('tr'));
+    for (const val of row) {
+      if (typeof val === 'object' && val !== null) tr.appendChild(el('td', { 'data-value': val.dataValue }, val.text || ''));
+      else tr.appendChild(el('td', { 'data-value': val }, val));
     }
-    html += '</tr>';
   }
-  html += '</tbody></table>';
-  return html;
+  return table;
 }
 
 function getColumnValues(dom, colIndex) {
-  const rows = dom.window.document.querySelectorAll('tbody tr');
-  return Array.from(rows).map(r => r.cells[colIndex].getAttribute('data-value'));
+  const rows = dom.window.document.querySelector('tbody').children;
+  return rows.map(r => r.cells[colIndex].getAttribute('data-value'));
 }
 
+// The arrow table-sort.js renders: since #1648 M2 a Phosphor caret sprite
+// (was ▲ / ▼).
+const caret = (dir) => '#ph-caret-' + dir + '"';
+
 console.log('\nTableSort — comparators');
 
 test('text comparator: basic alphabetical', () => {
   const cmp = (() => {
-    const dom = createDOM('<div></div>');
+    const dom = createDOM(null);
     return dom.window.TableSort.comparators.text;
   })();
   assert.ok(cmp('apple', 'banana') < 0);
@@ -75,14 +155,14 @@ test('text comparator: basic alphabetical', () => {
 });
 
 test('text comparator: null/undefined handling', () => {
-  const dom = createDOM('<div></div>');
+  const dom = createDOM(null);
   const cmp = dom.window.TableSort.comparators.text;
   assert.strictEqual(cmp(null, null), 0);
   assert.strictEqual(cmp(undefined, undefined), 0);
 });
 
 test('numeric comparator: basic numbers', () => {
-  const dom = createDOM('<div></div>');
+  const dom = createDOM(null);
   const cmp = dom.window.TableSort.comparators.numeric;
   assert.ok(cmp('1', '2') < 0);
   assert.ok(cmp('10', '2') > 0);
@@ -90,7 +170,7 @@ test('numeric comparator: basic numbers', () => {
 });
 
 test('numeric comparator: NaN sorts last', () => {
-  const dom = createDOM('<div></div>');
+  const dom = createDOM(null);
   const cmp = dom.window.TableSort.comparators.numeric;
   assert.ok(cmp('abc', '5') > 0);  // NaN > number (sorts last)
   assert.ok(cmp('5', 'abc') < 0);
@@ -98,14 +178,14 @@ test('numeric comparator: NaN sorts last', () => {
 });
 
 test('numeric comparator: negative numbers', () => {
-  const dom = createDOM('<div></div>');
+  const dom = createDOM(null);
   const cmp = dom.window.TableSort.comparators.numeric;
   assert.ok(cmp('-10', '-5') < 0);
   assert.ok(cmp('-5', '-10') > 0);
 });
 
 test('date comparator: ISO dates', () => {
-  const dom = createDOM('<div></div>');
+  const dom = createDOM(null);
   const cmp = dom.window.TableSort.comparators.date;
   assert.ok(cmp('2024-01-01T00:00:00Z', '2024-06-01T00:00:00Z') < 0);
   assert.ok(cmp('2024-06-01T00:00:00Z', '2024-01-01T00:00:00Z') > 0);
@@ -113,14 +193,14 @@ test('date comparator: ISO dates', () => {
 });
 
 test('date comparator: invalid dates sort last', () => {
-  const dom = createDOM('<div></div>');
+  const dom = createDOM(null);
   const cmp = dom.window.TableSort.comparators.date;
   assert.ok(cmp('invalid', '2024-01-01') > 0);
   assert.ok(cmp('2024-01-01', 'invalid') < 0);
 });
 
 test('dBm comparator: strips suffix', () => {
-  const dom = createDOM('<div></div>');
+  const dom = createDOM(null);
   const cmp = dom.window.TableSort.comparators.dbm;
   assert.ok(cmp('-120 dBm', '-80 dBm') < 0);
   assert.ok(cmp('-80 dBm', '-120 dBm') > 0);
@@ -128,7 +208,7 @@ test('dBm comparator: strips suffix', () => {
 });
 
 test('dBm comparator: works without suffix', () => {
-  const dom = createDOM('<div></div>');
+  const dom = createDOM(null);
   const cmp = dom.window.TableSort.comparators.dbm;
   assert.ok(cmp('-120', '-80') < 0);
 });
@@ -136,11 +216,11 @@ test('dBm comparator: works without suffix', () => {
 console.log('\nTableSort — DOM sorting');
 
 test('sort ascending by text column', () => {
-  const html = makeTable(
+  const tableEl = makeTable(
     [{key: 'name'}],
     [['Charlie'], ['Alice'], ['Bob']]
   );
-  const dom = createDOM(html);
+  const dom = createDOM(tableEl);
   const table = dom.window.document.getElementById('t');
   const inst = dom.window.TableSort.init(table, { defaultColumn: 'name', defaultDirection: 'asc' });
   const vals = getColumnValues(dom, 0);
@@ -148,11 +228,11 @@ test('sort ascending by text column', () => {
 });
 
 test('sort descending by numeric column', () => {
-  const html = makeTable(
+  const tableEl = makeTable(
     [{key: 'val', type: 'numeric'}],
     [['3'], ['1'], ['2']]
   );
-  const dom = createDOM(html);
+  const dom = createDOM(tableEl);
   const table = dom.window.document.getElementById('t');
   dom.window.TableSort.init(table, { defaultColumn: 'val', defaultDirection: 'desc' });
   const vals = getColumnValues(dom, 0);
@@ -160,11 +240,11 @@ test('sort descending by numeric column', () => {
 });
 
 test('click toggles direction', () => {
-  const html = makeTable(
+  const tableEl = makeTable(
     [{key: 'name'}],
     [['B'], ['A'], ['C']]
   );
-  const dom = createDOM(html);
+  const dom = createDOM(tableEl);
   const table = dom.window.document.getElementById('t');
   const inst = dom.window.TableSort.init(table, { defaultColumn: 'name', defaultDirection: 'asc' });
 
@@ -184,11 +264,11 @@ test('click toggles direction', () => {
 console.log('\nTableSort — aria-sort attributes');
 
 test('aria-sort set correctly on active column', () => {
-  const html = makeTable(
+  const tableEl = makeTable(
     [{key: 'a'}, {key: 'b'}],
     [['1', 'x'], ['2', 'y']]
   );
-  const dom = createDOM(html);
+  const dom = createDOM(tableEl);
   const table = dom.window.document.getElementById('t');
   dom.window.TableSort.init(table, { defaultColumn: 'a', defaultDirection: 'asc' });
 
@@ -199,11 +279,11 @@ test('aria-sort set correctly on active column', () => {
 });
 
 test('aria-sort updates on direction change', () => {
-  const html = makeTable(
+  const tableEl = makeTable(
     [{key: 'a'}],
     [['1'], ['2']]
   );
-  const dom = createDOM(html);
+  const dom = createDOM(tableEl);
   const table = dom.window.document.getElementById('t');
   dom.window.TableSort.init(table, { defaultColumn: 'a', defaultDirection: 'asc' });
 
@@ -215,11 +295,11 @@ test('aria-sort updates on direction change', () => {
 });
 
 test('aria-sort updates when switching columns', () => {
-  const html = makeTable(
+  const tableEl = makeTable(
     [{key: 'a'}, {key: 'b'}],
     [['1', 'x'], ['2', 'y']]
   );
-  const dom = createDOM(html);
+  const dom = createDOM(tableEl);
   const table = dom.window.document.getElementById('t');
   dom.window.TableSort.init(table, { defaultColumn: 'a', defaultDirection: 'asc' });
 
@@ -234,42 +314,42 @@ test('aria-sort updates when switching columns', () => {
 console.log('\nTableSort — visual indicator');
 
 test('sort arrow shows on active column', () => {
-  const html = makeTable(
+  const tableEl = makeTable(
     [{key: 'a'}],
     [['1'], ['2']]
   );
-  const dom = createDOM(html);
+  const dom = createDOM(tableEl);
   const table = dom.window.document.getElementById('t');
   dom.window.TableSort.init(table, { defaultColumn: 'a', defaultDirection: 'asc' });
 
   const arrow = dom.window.document.querySelector('.sort-arrow');
   assert.ok(arrow, 'sort arrow should exist');
-  assert.ok(arrow.textContent.includes('▲'), 'ascending should show ▲');
+  assert.ok(arrow.innerHTML.includes(caret('up')), 'ascending should show the up caret');
 });
 
 test('sort arrow changes on direction toggle', () => {
-  const html = makeTable(
+  const tableEl = makeTable(
     [{key: 'a'}],
     [['1'], ['2']]
   );
-  const dom = createDOM(html);
+  const dom = createDOM(tableEl);
   const table = dom.window.document.getElementById('t');
   dom.window.TableSort.init(table, { defaultColumn: 'a', defaultDirection: 'asc' });
 
   const th = dom.window.document.querySelector('th[data-sort-key="a"]');
   th.click(); // desc
   const arrow = dom.window.document.querySelector('.sort-arrow');
-  assert.ok(arrow.textContent.includes('▼'), 'descending should show ▼');
+  assert.ok(arrow.innerHTML.includes(caret('down')), 'descending should show the down caret');
 });
 
 console.log('\nTableSort — onSort callback');
 
 test('onSort fires with column and direction', () => {
-  const html = makeTable(
+  const tableEl = makeTable(
     [{key: 'a'}, {key: 'b'}],
     [['1', 'x'], ['2', 'y']]
   );
-  const dom = createDOM(html);
+  const dom = createDOM(tableEl);
   const table = dom.window.document.getElementById('t');
   let called = null;
   dom.window.TableSort.init(table, {
@@ -287,11 +367,11 @@ test('onSort fires with column and direction', () => {
 console.log('\nTableSort — domReorder: false');
 
 test('domReorder: false skips DOM sorting', () => {
-  const html = makeTable(
+  const tableEl = makeTable(
     [{key: 'name'}],
     [['C'], ['A'], ['B']]
   );
-  const dom = createDOM(html);
+  const dom = createDOM(tableEl);
   const table = dom.window.document.getElementById('t');
   dom.window.TableSort.init(table, { defaultColumn: 'name', defaultDirection: 'asc', domReorder: false });
 
@@ -303,11 +383,11 @@ test('domReorder: false skips DOM sorting', () => {
 console.log('\nTableSort — destroy');
 
 test('destroy removes event handlers and cleans up', () => {
-  const html = makeTable(
+  const tableEl = makeTable(
     [{key: 'a'}],
     [['2'], ['1']]
   );
-  const dom = createDOM(html);
+  const dom = createDOM(tableEl);
   const table = dom.window.document.getElementById('t');
   const inst = dom.window.TableSort.init(table, { defaultColumn: 'a', defaultDirection: 'asc' });
 
@@ -322,11 +402,11 @@ test('destroy removes event handlers and cleans up', () => {
 console.log('\nTableSort — custom comparators');
 
 test('custom comparator overrides built-in', () => {
-  const html = makeTable(
+  const tableEl = makeTable(
     [{key: 'val', type: 'numeric'}],
     [['3'], ['1'], ['2']]
   );
-  const dom = createDOM(html);
+  const dom = createDOM(tableEl);
   const table = dom.window.document.getElementById('t');
   // Custom: reverse numeric
   dom.window.TableSort.init(table, {
@@ -340,11 +420,11 @@ test('custom comparator overrides built-in', () => {
 console.log('\nTableSort — date sort with data-type="date"');
 
 test('date column sorts correctly', () => {
-  const html = makeTable(
+  const tableEl = makeTable(
     [{key: 'ts', type: 'date'}],
     [['2024-06-15T10:00:00Z'], ['2024-01-01T00:00:00Z'], ['2024-12-25T23:59:59Z']]
   );
-  const dom = createDOM(html);
+  const dom = createDOM(tableEl);
   const table = dom.window.document.getElementById('t');
   dom.window.TableSort.init(table, { defaultColumn: 'ts', defaultDirection: 'asc' });
   const vals = getColumnValues(dom, 0);
diff --git a/test-test-all.js b/test-test-all.js
index f613e4961..08af253e7 100644
--- a/test-test-all.js
+++ b/test-test-all.js
@@ -130,25 +130,10 @@ test('test-all.sh registers itself through this test', () => {
 // test past the check below: register it instead.
 const KNOWN_UNREGISTERED = {
   // red unit tests (stale after intended UI changes)
-  'test-channel-colors.js': 'red: expects 4px border + tint, #675 changed it to 3px',
-  'test-channel-ux-followup.js': 'red: copy text changed by the Phosphor migration',
-  'test-channel-ux-round2.js': 'red: expects the 📤 glyph, now #ph-share-network',
-  'test-drag-manager.js': 'red: removeAttribute mock does not update dataset (#1567)',
-  'test-fluid-scaffolding.js': 'red: reads only the first :root block',
-  'test-hop-resolver-affinity.js': 'red: fixture geometry wrong since #874',
-  'test-issue-1470-card-bg-contrast.js': 'red: indexOf matches a style.css comment',
-  'test-issue-1646-compare-polish.js': 'red: font-size parser reads a comment',
-  'test-packets.js': 'red: 13 emoji assertions after the Phosphor migration',
-  'test-perf-disk-io-1120.js': 'red: ⚠️ is #ph-warning; anomaly detector reworked (#1593)',
+  'test-packets.js': 'red on 1 assertion: collapsed group caret is #ph-caret-up, a real bug (#189); register once packets.js is fixed',
   // need something CI's unit job does not have
-  'test-marker-outline-weight.js': 'needs @playwright/test (not a dependency) and a server',
-  'test-table-sort.js': 'needs jsdom (not a dependency)',
-  'test-touch-targets.js': 'red in Chromium: expects 48px targets, CSS has 44px',
+  'test-touch-targets.js': 'red in Chromium: 48px (upstream #2078) vs 44px (#85) is pending a decision (#189); harness also stale',
   // E2E
-  'test-channel-modal-e2e.js': 'red: Add button text and sidebar sections changed',
-  'test-issue-1522-trace-url-sync-e2e.js': 'needs @playwright/test (not a dependency)',
-  'test-node-reach-e2e.js': 'red: #nqMap .leaflet-container never visible',
-  'test-path-inspector-e2e.js': 'needs @playwright/test (not a dependency)',
   'test-rx-coverage-mobile-nav-e2e.js': 'skips while clientRxCoverage is off (the default)',
 };