llm-switcher 1.2.7 → 1.2.9

package/tests/shim.test.mjs

@@ -282,6 +282,22 @@ test('the POSIX shims source launch files only when this account owns them', ()
 
 // ISS-CC-LS-002: on zsh a later line in .zshrc or .zprofile can prepend npm-global or Homebrew
 // ahead of the shim. The hint names both files and says the line must come last.
+test('pathOrderHint gives a fish user the fish file and fish syntax', () => {
+  // `export PATH=...` is not fish syntax. A fish user who pasted the old hint got an error, and
+  // the hint named ~/.profile, which fish does not read.
+  const shell = process.env.SHELL;
+  process.env.SHELL = '/usr/bin/fish';
+  try {
+    assert.deepEqual(suggestedRcFiles('linux'), [path.join(os.homedir(), '.config', 'fish', 'config.fish')]);
+    const text = pathOrderHint('linux').join(' ');
+    assert.ok(text.includes('config.fish'), text);
+    assert.ok(text.includes('fish_add_path'), text);
+    assert.ok(!text.includes('export PATH='), text);
+  } finally {
+    if (shell === undefined) delete process.env.SHELL; else process.env.SHELL = shell;
+  }
+});
+
 test('pathOrderHint tells a zsh user to put the export last in .zshrc and .zprofile', () => {
   const shell = process.env.SHELL;
   process.env.SHELL = '/bin/zsh';
@@ -340,3 +356,99 @@ test('A8: the Windows shim scrubs a loopback base URL and resolves every subrout
   assert.match(child.stdout || '', /HTTPS=\[http:\/\/127\.0\.0\.1:3457\]/,
     'R2: the proxy comes from the env file of this tool');
 });
+
+// ---- The route notice: the launcher tells the person the switcher took the traffic -------------
+
+// A person opens `claude`, the switcher routes it to another provider, and nothing on screen says
+// so. The shim therefore raises a notice at launch. It is guarded by TOOL_ACTIVE, so a tool whose
+// profile is off stays silent: the guard is the same one that decides whether to source the env.
+test('the route notice is guarded by TOOL_ACTIVE and names only this tool route file', () => {
+  for (const platform of ['win32', 'linux']) {
+    const claude = renderShim('claude', platform);
+    const codex = renderShim('codex', platform);
+    assert.match(claude, /route-claude\.txt/, `${platform}: the claude shim reads its own route file`);
+    assert.doesNotMatch(claude, /route-codex/, `${platform}: and never the other tool file`);
+    assert.match(codex, /route-codex\.txt/);
+    assert.doesNotMatch(codex, /route-claude/);
+    // Everything that raises the notice sits after the TOOL_ACTIVE decision, never before it.
+    const guard = platform === 'win32' ? claude.indexOf('set "TOOL_ACTIVE=1"') : claude.indexOf('TOOL_ACTIVE=1');
+    assert.ok(guard > 0, `${platform}: the guard exists`);
+    assert.ok(claude.indexOf('route-claude.txt') > guard, `${platform}: the notice comes after the guard`);
+  }
+});
+
+test('the POSIX shim prints the route line for an active tool and nothing for one that is off', (t) => {
+  if (process.platform === 'win32') return t.skip('posix only');
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'shimfake-'));
+  t.after(() => fs.rmSync(fakeDir, { recursive: true, force: true }));
+  fs.writeFileSync(path.join(fakeDir, 'claude'), '#!/bin/sh\necho ran\n');
+  fs.chmodSync(path.join(fakeDir, 'claude'), 0o755);
+
+  const run = ({ active, route }) => {
+    for (const f of fs.readdirSync(STATE)) fs.rmSync(path.join(STATE, f), { force: true });
+    if (active) {
+      fs.writeFileSync(path.join(STATE, 'active.flag'), 'active');
+      fs.writeFileSync(path.join(STATE, 'env-claude.sh'), "export HTTPS_PROXY='http://127.0.0.1:3457'\n");
+    }
+    fs.writeFileSync(path.join(STATE, 'route-claude.txt'), route);
+    return spawnSync(path.join(RENDER_DIR, 'claude'), [], {
+      encoding: 'utf8', timeout: 15000,
+      env: { ...process.env, PATH: [RENDER_DIR, fakeDir, '/usr/bin:/bin', NODE_DIR].join(path.delimiter) }
+    });
+  };
+
+  const on = run({ active: true, route: 'claude -> cl | intact.example.io | gemini | 1M\n' });
+  assert.match(on.stderr, /intact\.example\.io/, 'an active tool shows where its traffic goes');
+  assert.match(on.stdout, /ran/, 'and the real binary still runs');
+
+  const off = run({ active: false, route: 'claude -> cl | intact.example.io | gemini | 1M\n' });
+  assert.doesNotMatch(off.stderr, /intact\.example\.io/, 'a tool that is off says nothing, even with a stale route file');
+  assert.match(off.stdout, /ran/);
+});
+
+// The Windows notice is a detached toast, so the only way to prove it fires is to put a fake
+// `powershell` on PATH and read what the shim asked it to do.
+test('the Windows shim raises the toast only while this tool is routed', (t) => {
+  if (process.platform !== 'win32') return t.skip('cmd.exe only');
+  const shimDir = fs.mkdtempSync(path.join(os.tmpdir(), 'shimwintoast-'));
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'shimfaketoast-'));
+  t.after(() => {
+    fs.rmSync(shimDir, { recursive: true, force: true });
+    fs.rmSync(fakeDir, { recursive: true, force: true });
+  });
+  const log = path.join(fakeDir, 'toast.log');
+  fs.writeFileSync(path.join(fakeDir, 'claude.cmd'), '@echo off\r\necho ran\r\n');
+  fs.writeFileSync(path.join(fakeDir, 'powershell.cmd'), `@echo off\r\necho %*>>"${log}"\r\n`);
+  const shim = path.join(shimDir, 'shim.cmd');
+  fs.writeFileSync(shim, renderShim('claude', 'win32'), 'utf8');
+
+  const run = ({ active }) => {
+    for (const f of fs.readdirSync(STATE)) fs.rmSync(path.join(STATE, f), { force: true });
+    fs.rmSync(log, { force: true });
+    if (active) {
+      fs.writeFileSync(path.join(STATE, 'active.flag'), 'active');
+      fs.writeFileSync(path.join(STATE, 'env-claude.cmd'), 'SET "HTTPS_PROXY=http://127.0.0.1:3457"\r\n');
+    }
+    fs.writeFileSync(path.join(STATE, 'route-claude.txt'), 'claude -> cl | intact.example.io | gemini | 1M\r\n');
+    const child = spawnSync('cmd.exe', ['/d', '/c', shim, '--version'], {
+      encoding: 'utf8', timeout: 30000,
+      env: {
+        ...process.env,
+        PATH: [fakeDir, shimDir, path.join(process.env.SystemRoot, 'System32'), path.dirname(process.execPath)]
+          .join(path.delimiter)
+      }
+    });
+    // `start /b` detaches, so the fake may still be writing when the shim has already exited.
+    for (let i = 0; i < 60 && !fs.existsSync(log); i++) execFileSync(process.execPath, ['-e', 'setTimeout(()=>{},50)']);
+    return { out: child.stdout || '', asked: fs.existsSync(log) ? fs.readFileSync(log, 'utf8') : '' };
+  };
+
+  const on = run({ active: true });
+  assert.match(on.out, /ran/, 'the real binary still runs');
+  assert.match(on.asked, /route-claude\.txt/, 'the toast is asked for, with this tool route file');
+  assert.match(on.asked, /notify-route\.ps1/, 'through the notifier that ships with the switcher');
+
+  const off = run({ active: false });
+  assert.match(off.out, /ran/);
+  assert.equal(off.asked, '', 'a tool that is off raises no toast');
+});

package/tests/state.test.mjs

@@ -7,7 +7,7 @@ import {
   modelSlotsForProfile, modelForSlot, primaryModel, codexPublicModel,
   certCoversHost, blindfoldPreflight, ROOT_DIR, openLog, probeGateway, isSafeModelName,
   getMigrationCollision, getMigrationError, getConfigLoadError, saveConfig, loadConfig,
-  migrateConfigInMemory, saveConfigAtomicCAS, TOOLS, validateProfileInput, needsMigration
+  migrateConfigInMemory, saveConfigAtomicCAS, TOOLS, validateProfileInput, needsMigration, hasPlaceholder
 } from '../state.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -52,6 +52,76 @@ test('activateProfile only assigns compatible tools; deactivateProfile leaves th
   assert.deepEqual(cfg.activeProfiles, { claude: null, codex: null });
 });
 
+test('switching a migrated config does not make it need migration again', () => {
+  // A legacy pointer written on every switch re-ran the migration on the next load and left one
+  // more config.json.bak-* (with the API keys) in the data folder each time.
+  const cfg = {
+    port: 4000,
+    activeProfiles: { claude: null, codex: null },
+    profiles: {
+      router: { tool: 'claude', apiKey: 'sk-1', baseURL: 'https://r/v1', defaultModels: { opus: 'o' } },
+      codexOnly: { tool: 'codex', apiKey: 'sk-2', baseURL: 'https://c/v1', defaultModels: { main: 'gpt-main' } }
+    }
+  };
+  assert.equal(needsMigration(cfg), false, 'fixture is already migrated');
+  assert.equal(activateProfile(cfg, 'router'), null);
+  assert.equal(setTargetProfile(cfg, 'codex', 'codexOnly'), null);
+  assert.equal(Object.hasOwn(cfg, 'activeProfile'), false);
+  assert.equal(needsMigration(cfg), false);
+});
+
+test('hasPlaceholder spots the example config values', () => {
+  assert.equal(hasPlaceholder({ baseURL: 'https://YOUR-ROUTER-HOST/v1', apiKey: 'sk-real' }), true);
+  assert.equal(hasPlaceholder({ baseURL: 'https://r/v1', apiKey: 'REPLACE-ME' }), true);
+  assert.equal(hasPlaceholder({ apiKey: 'sk-real' }), true, 'no baseURL');
+  assert.equal(hasPlaceholder({ baseURL: 'https://r/v1', apiKey: 'sk-real' }), false);
+  assert.equal(hasPlaceholder({ baseURL: 'http://127.0.0.1:11434/v1' }), false, 'a keyless local backend is fine');
+});
+
+test('the interceptor port follows LLM_SWITCHER_BLINDFOLD_PORT and never lands on the gateway port', () => {
+  // The gateway reads --port and LLM_SWITCHER_PORT through resolvePort. The interceptor read only
+  // config.json, so a second instance collided and HTTPS_PROXY named a port nothing listened on.
+  const saved = process.env.LLM_SWITCHER_BLINDFOLD_PORT;
+  delete process.env.LLM_SWITCHER_BLINDFOLD_PORT;
+  const cfg = {
+    port: 4000,
+    activeProfiles: { claude: 'router', codex: null },
+    profiles: { router: { tool: 'claude', apiKey: 'sk-1', baseURL: 'https://r/v1', defaultModels: { opus: 'o' } } }
+  };
+  try {
+    assert.equal(computeLaunchState(cfg, 4000).blindfold.port, 3457, 'the default');
+    assert.equal(computeLaunchState({ ...cfg, blindfold: { port: 4444 } }, 4000).blindfold.port, 4444, 'the file');
+    process.env.LLM_SWITCHER_BLINDFOLD_PORT = '5555';
+    assert.equal(computeLaunchState({ ...cfg, blindfold: { port: 4444 } }, 4000).blindfold.port, 5555, 'the environment wins');
+    delete process.env.LLM_SWITCHER_BLINDFOLD_PORT;
+    // A gateway moved onto 3457 by --port or by the environment must push the interceptor off it.
+    const st = computeLaunchState(cfg, 3457);
+    assert.notEqual(st.blindfold.port, 3457, 'the interceptor moved off the gateway port');
+    const proxy = st.envClaude.find(([k]) => k === 'HTTPS_PROXY');
+    assert.equal(proxy[1], `http://127.0.0.1:${st.blindfold.port}`, 'HTTPS_PROXY names the real port');
+  } finally {
+    if (saved === undefined) delete process.env.LLM_SWITCHER_BLINDFOLD_PORT;
+    else process.env.LLM_SWITCHER_BLINDFOLD_PORT = saved;
+  }
+});
+
+test('deleteProfile does not make a migrated config need migration again', () => {
+  // Reachable from the dashboard Delete Profile button via POST /api/delete-profile, which
+  // persists. A legacy pointer written here revives the backup leak the switch path just lost.
+  const cfg = {
+    port: 4000,
+    activeProfiles: { claude: null, codex: 'codexOnly' },
+    profiles: {
+      router: { tool: 'claude', apiKey: 'sk-1', baseURL: 'https://r/v1', defaultModels: { opus: 'o' } },
+      codexOnly: { tool: 'codex', apiKey: 'sk-2', baseURL: 'https://c/v1', defaultModels: { main: 'gpt-main' } }
+    }
+  };
+  assert.equal(needsMigration(cfg), false, 'fixture is already migrated');
+  assert.equal(deleteProfile(cfg, 'codexOnly'), null);
+  assert.equal(Object.hasOwn(cfg, 'activeProfile'), false);
+  assert.equal(needsMigration(cfg), false);
+});
+
 test('deleteProfile unassigns targets that pointed at it', () => {
   const cfg = makeCfg();
   activateProfile(cfg, 'codexOnly');
@@ -602,15 +672,21 @@ test('isSafeModelName refuses names that TOML reads as something other than a st
 test('launch-file writers take turns through a lock, and a dead holder does not block them', async (t) => {
   const { dir, env } = tmpDirs(t);
   const lock = path.join(dir, '.launch.lock');
+  const startedFile = path.join(dir, 'writer.started');
   // A live holder: this test process. The child must wait until the lock is gone.
   fs.writeFileSync(lock, String(process.pid));
-  setTimeout(() => fs.rmSync(lock, { force: true }), 400);
-  const started = Date.now();
-  const r = await new Promise((resolve, reject) => {
+  const done = new Promise((resolve, reject) => {
     execFileCb(process.execPath, ['--input-type=module', '-e',
-      `const s = await import(${JSON.stringify(pathToFileURL(path.join(ROOT_DIR, 'state.mjs')).href)}); const t0 = Date.now(); s.applyLaunchState(s.loadConfig(), 4000); console.log(Date.now() - t0);`],
+      `const s = await import(${JSON.stringify(pathToFileURL(path.join(ROOT_DIR, 'state.mjs')).href)}); (await import('node:fs')).writeFileSync(${JSON.stringify(startedFile)}, ''); const t0 = Date.now(); s.applyLaunchState(s.loadConfig(), 4000); console.log(Date.now() - t0);`],
     { env: { ...process.env, LLM_SWITCHER_PORT: '', ...env }, encoding: 'utf8' }, (err, out) => (err ? reject(err) : resolve(Number(out.trim()))));
   });
+  // The 400 ms count from the writer's start, the same way the next test does it. A spawn plus an
+  // import measured 163 to 541 ms on Node 18, so a fixed timer left under 100 ms of wait and the
+  // assertion below failed on a loaded machine.
+  for (let i = 0; i < 1000 && !fs.existsSync(startedFile); i++) await new Promise(r => setTimeout(r, 10));
+  const started = Date.now();
+  setTimeout(() => fs.rmSync(lock, { force: true }), 400);
+  const r = await done;
   // Without the lock the write takes a few ms; with it the child waits for the release at 400 ms.
   assert.ok(r >= 100, `the writer waited ${r} ms for the live holder`);
   assert.ok(Date.now() - started >= 380);
@@ -1496,3 +1572,52 @@ test('A5: config.example.json loads and passes validation without requiring migr
     }
   }
 });
+
+// ---- Route lines: what the launcher shows when it routes a tool -------------------------------
+
+// A person opens `claude` and cannot see that the switcher took over the traffic. The launcher
+// therefore reads one line per tool, written beside that tool's env file. The line exists exactly
+// when that tool is routed, so a tool whose profile is off stays silent with no extra condition.
+test('each routed tool gets a route line; a tool that is off gets an empty one', (t) => {
+  const { dir, env } = tmpDirs(t);
+  fs.writeFileSync(path.join(dir, 'config.json'), JSON.stringify({
+    port: 4000,
+    activeProfiles: { claude: 'cl', codex: 'cx' },
+    profiles: {
+      cl: {
+        name: 'Intact Claude', baseURL: 'https://intact.example.io/v1', apiKey: 'sk-secret-claude',
+        defaultModels: { opus: 'gemini-3.8-flash' }, model1M: { opus: true }
+      },
+      cx: {
+        inFormat: 'responses', baseURL: 'https://other.example.io/v1', apiKey: 'sk-secret-codex',
+        defaultModels: { main: 'gpt-5.6-sol' }
+      }
+    }
+  }), { mode: 0o600 });
+
+  const r = runState(env, `
+    const read = (f) => { try { return fs.readFileSync(f, 'utf8'); } catch { return null; } };
+    s.applyLaunchState(s.loadConfig(), 4000);
+    const on = { claude: read(s.paths.routeClaude), codex: read(s.paths.routeCodex) };
+    s.emptyToolEnvFiles('claude');
+    const oneOff = { claude: read(s.paths.routeClaude), codex: read(s.paths.routeCodex) };
+    s.applyLaunchState(s.loadConfig(), 4000);
+    s.clearLaunchState(4000);
+    const allOff = { claude: read(s.paths.routeClaude), codex: read(s.paths.routeCodex) };
+    return { on, oneOff, allOff };
+  `);
+
+  assert.match(r.on.claude, /\bcl\b/, 'the line names the profile that serves claude');
+  assert.match(r.on.claude, /intact\.example\.io/, 'and the host the traffic goes to');
+  assert.match(r.on.claude, /gemini-3\.8-flash/, 'and the model it maps to');
+  assert.match(r.on.claude, /1M/, 'and the 1M window, because that changes what the session costs');
+  assert.match(r.on.codex, /\bcx\b/);
+  assert.match(r.on.codex, /other\.example\.io/);
+  assert.doesNotMatch(r.on.codex, /intact\.example\.io/, 'one tool never shows the other tool route');
+  assert.doesNotMatch(`${r.on.claude}${r.on.codex}`, /sk-secret/, 'a route line never carries the API key');
+
+  assert.equal(r.oneOff.claude.trim(), '', 'the tool switched off has no route line');
+  assert.notEqual(r.oneOff.codex.trim(), '', 'the other tool keeps its own');
+  assert.equal(r.allOff.claude.trim(), '', 'switch off leaves no route line for either tool');
+  assert.equal(r.allOff.codex.trim(), '');
+});

package/ui.html

@@ -811,6 +811,10 @@
         position: sticky;
         top: 0;
         height: auto;
+        /* The base rule makes this a scroll container, and a grid item that scrolls has an automatic
+           minimum size of zero. The row then collapsed to the padding (16 px measured) and the nav
+           was drawn outside it, so no link could be pressed. Reset it, or the height is ignored. */
+        overflow: visible;
         flex-direction: row;
         flex-wrap: wrap;
         align-items: center;
@@ -926,7 +930,7 @@
     <div class="ph">
       <div class="title-box">
         <h1 id="page-title">Routes & Profiles</h1>
-        <p id="status-sub">Route Claude Code, Codex, and OpenAI clients independently.</p>
+        <p id="status-sub">Route Claude Code and Codex independently.</p>
       </div>
       <div class="ph-actions" id="ph-actions">
         <!-- Rendered dynamically per route -->
@@ -1323,18 +1327,44 @@
     for (const ev of ['focusout', 'click', 'scroll']) addEventListener(ev, hideTip, true);
 
     // Modal Control
+
+    // A result belongs to the profile it was measured on. Cleared on every open, because a dialog
+    // that opens showing "HTTP 200 OK" from the profile before it says the wrong thing about this one.
+    // Empties the three fields, never the box: they are static markup, and innerHTML would delete
+    // them for the rest of the session.
+    function clearTestResult() {
+      const box = document.getElementById('test-result');
+      if (!box) return;
+      for (const id of ['test-status-badge', 'test-latency', 'test-sample']) {
+        const el = document.getElementById(id);
+        if (el) el.textContent = '';
+      }
+      document.getElementById('test-status-badge')?.setAttribute('class', 'badge');
+      box.className = 'test-result-box';
+    }
+
     function openProfileModal(isNew = false) {
       const modal = document.getElementById('profile-modal-overlay');
       if (modal) modal.style.display = 'grid';
+      clearTestResult();
       if (isNew) {
         initNewProfile();
       }
+      // Without this the focus stays on the button behind the overlay, so the first Tab walks into
+      // the page under the dialog instead of through the dialog.
+      const first = modal?.querySelector('input:not([readonly]):not([disabled]), select, textarea, button');
+      first?.focus();
     }
 
     function closeProfileModal() {
       const modal = document.getElementById('profile-modal-overlay');
       if (modal) modal.style.display = 'none';
       formDirty = false;
+      // render() reads this to draw the ring and the "Editing Profile" label. Left set, a card stayed
+      // marked as being edited after Escape, Cancel or a press on the dark area.
+      currentlyEditingKey = '';
+      formLoadedKey = null;
+      render();
     }
 
     // The close button, Cancel, the dark area and Escape. A save or a delete calls closeProfileModal
@@ -2086,6 +2116,15 @@
       if (existing.publicModels) profilePayload.publicModels = existing.publicModels;
 
       showToast('Saving profile "' + key + '"...');
+      // A double-click sent the save twice. The same pattern as the catalog sync button: disabled
+      // while the request runs, re-enabled in `finally` so a failed save can be tried again.
+      const submit = e.target?.querySelector?.('button[type="submit"]')
+        || document.querySelector('#profile-modal-overlay button[type="submit"]');
+      if (submit) {
+        if (submit.disabled) return;
+        submit.disabled = true;
+        submit.setAttribute('aria-busy', 'true');
+      }
       try {
         const res = await api('/api/save-profile', {
           method: 'POST',
@@ -2102,6 +2141,11 @@
         }
       } catch (err) {
         showToast('Network error saving profile', true);
+      } finally {
+        if (submit) {
+          submit.disabled = false;
+          submit.removeAttribute('aria-busy');
+        }
       }
     }
 
@@ -2434,8 +2478,15 @@
         const ctModels = document.getElementById('ct-models');
         if (ctModels) ctModels.textContent = claudeModels.length + codexModels.length;
 
-        document.getElementById('badge-claude-count').textContent = claudeModels.length + ' models · ' + claudeTiers.size + ' tiers';
-        document.getElementById('badge-codex-count').textContent = codexModels.length + ' models · ' + codexRoles.size + ' roles';
+        // `data-full` is what the search box restores when it is emptied again.
+        for (const [id, text] of [
+          ['badge-claude-count', claudeModels.length + ' models · ' + claudeTiers.size + ' tiers'],
+          ['badge-codex-count', codexModels.length + ' models · ' + codexRoles.size + ' roles']
+        ]) {
+          const el = document.getElementById(id);
+          el.textContent = text;
+          el.dataset.full = text;
+        }
 
         claudeContainer.innerHTML = claudeModels.map(m => `
           <div class="row" style="padding:0.6rem 0.8rem; background:var(--card2); border-radius:8px;">
@@ -2465,12 +2516,40 @@
       }
     }
 
+    // A filter that hides every row but keeps the header count reads as a broken page: the header
+    // still promised 11 models over an empty list. So the count follows the filter, and an empty
+    // result says so in words.
     function filterCatalogView(q) {
       const term = (q || '').toLowerCase();
-      document.querySelectorAll('#catalog-claude-items .row, #catalog-codex-items .row').forEach(row => {
-        const text = row.textContent.toLowerCase();
-        row.style.display = text.includes(term) ? 'flex' : 'none';
-      });
+      for (const [list, badge, unit] of [
+        ['#catalog-claude-items', 'badge-claude-count', 'models'],
+        ['#catalog-codex-items', 'badge-codex-count', 'models']
+      ]) {
+        const container = document.querySelector(list);
+        if (!container) continue;
+        let shown = 0;
+        container.querySelectorAll('.row').forEach(row => {
+          const hit = row.textContent.toLowerCase().includes(term);
+          row.style.display = hit ? 'flex' : 'none';
+          if (hit) shown++;
+        });
+        let empty = container.querySelector('.catalog-empty');
+        if (!shown) {
+          if (!empty) {
+            empty = document.createElement('div');
+            empty.className = 'catalog-empty hint';
+            empty.style.padding = '0.8rem';
+            container.appendChild(empty);
+          }
+          empty.textContent = term ? 'No model matches "' + term + '".' : 'No model in this list.';
+          empty.style.display = 'block';
+        } else if (empty) {
+          empty.style.display = 'none';
+        }
+        const el = document.getElementById(badge);
+        // `data-full` is the unfiltered text that the render wrote. An empty box restores it.
+        if (el) el.textContent = term ? shown + ' ' + unit + ' shown' : (el.dataset.full || el.textContent);
+      }
     }
 
     async function refreshCatalogUpstream() {