@sanqianx/project-knowledge 5.0.24 → 5.0.26

package/_site/_test/parallel-nav-offline-test.js

@@ -0,0 +1,272 @@
+'use strict';
+// NAV-008 — 断网恢复。
+//
+// When the browser loses the network the shell must close the old stream, and
+// when the network comes back it must restore the snapshot and open a new
+// stream — exactly one subscription per stream, and no content that pretends
+// to be live while it is not.
+//
+// The regression drives the real product UI in a real browser against an
+// isolated instance (own port, own data dir, own knowledge dir, own Bridge
+// journal, own browser profile, own vendored knowledge engine). The network
+// outage is a real browser outage: CDP Network.emulateNetworkConditions puts
+// the browser offline, so navigator.onLine really turns false, the browser
+// really cannot reach the product, and the real 'offline' and 'online' events
+// really fire.
+//
+// The evidence is taken from three independent places:
+//
+//   * the page itself: every WebSocket the shell opened and every
+//     subscription message it sent, recorded before the page's own scripts
+//     run;
+//   * the product proxy: the reads the browser really made;
+//   * the engine proxy: the streams the product really opened on the engine.
+//
+// Screenshots are written to PK_TEST_EVIDENCE_DIR when the batch sets it, so
+// this tracked file stays free of machine-specific paths.
+
+const path = require('node:path');
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+
+const { startHarness, makeRepo } = require('./helpers/parallel-nav-shell');
+
+const EVIDENCE = process.env.PK_TEST_EVIDENCE_DIR ? path.resolve(process.env.PK_TEST_EVIDENCE_DIR) : null;
+
+const SNAPSHOT = '/api/engine/snapshot';
+
+/**
+ * Record every WebSocket the page opens, every subscription message it
+ * sends and every close the browser really performed. The hook is installed
+ * before the page's own scripts run, so the first stream of the page is
+ * recorded too.
+ *
+ * The close event is the evidence that the browser really closed the old
+ * stream: the shell drops its own bookkeeping as soon as it asks the socket
+ * to close, while the browser reaches the closed state only when the
+ * connection is really gone.
+ */
+const SOCKET_HOOK = `(() => {
+  window.__sockets = [];
+  window.__sent = [];
+  window.__closed = [];
+  const Native = window.WebSocket;
+  const Wrapped = function (...args) {
+    const ws = new Native(...args);
+    const generation = window.__sockets.length;
+    window.__sockets.push(ws);
+    ws.addEventListener('close', event => {
+      window.__closed.push({ generation, code: event.code, wasClean: event.wasClean, readyState: ws.readyState, at: Date.now() });
+    });
+    const send = ws.send.bind(ws);
+    ws.send = function (data) {
+      try {
+        const parsed = JSON.parse(data);
+        window.__sent.push({ generation, type: parsed.type || '', id: parsed.id || '', route: parsed.route || '' });
+      } catch {}
+      return send(data);
+    };
+    return ws;
+  };
+  Wrapped.prototype = Native.prototype;
+  Object.setPrototypeOf(Wrapped, Native);
+  window.WebSocket = Wrapped;
+})()`;
+
+const socketStates = harness => harness.run('window.__sockets.map(socket => socket.readyState)');
+const sentMessages = harness => harness.run('window.__sent || []');
+const closeEvents = harness => harness.run('window.__closed || []');
+const liveStats = harness => harness.run('window.KnowledgeLive.stats()');
+const connectionLabel = harness => harness.run("document.getElementById('activityConnection').textContent");
+const homeText = harness => harness.run("document.getElementById('homeContent').textContent");
+
+/** The subscriptions that are still live on one socket generation. */
+function activeSubscriptions(messages, generation) {
+  const active = new Map();
+  for (const message of messages) {
+    if (message.generation !== generation) continue;
+    if (message.type === 'subscribe') active.set(message.id, message.route);
+    else if (message.type === 'unsubscribe') active.delete(message.id);
+  }
+  return active;
+}
+
+function gitCommit(repo, fileName, content) {
+  const fs = require('node:fs');
+  fs.writeFileSync(path.join(repo, fileName), content);
+  const run = args => {
+    const result = spawnSync('git', ['-C', repo, ...args], { encoding: 'utf8', windowsHide: true });
+    assert.equal(result.status, 0, `git ${args.join(' ')} failed: ${result.stderr}`);
+    return String(result.stdout || '').trim();
+  };
+  run(['add', '.']);
+  run(['commit', '-qm', `second ${fileName}`]);
+  return run(['rev-parse', 'HEAD']);
+}
+
+async function main() {
+  const harness = await startHarness({ tag: 'nav008', evidenceDir: EVIDENCE || undefined });
+  try {
+    const repo = makeRepo(harness.fixture, 'nav008-a');
+    const project = await harness.importProject(repo, 'NAV008 甲');
+    const shortFirst = repo.headCommit.slice(0, 8);
+    // Real engine state: the first run of the project.
+    harness.engine.store.addRun({ projectId: project.projectId, commitSha: repo.headCommit, trigger: 'manual' });
+
+    // The page is reloaded with the socket hook in place, so the very first
+    // stream of the page is recorded as well.
+    await harness.browser.send('Page.addScriptToEvaluateOnNewDocument', { source: SOCKET_HOOK });
+    await harness.browser.send('Page.reload', { ignoreCache: true });
+    await harness.waitFor(() => harness.run("document.readyState === 'complete'"), 'the reloaded page');
+    await harness.waitFor(
+      async () => (await homeText(harness)).includes(shortFirst),
+      'the reloaded page shows the run of the project',
+      20000,
+    );
+    await harness.waitFor(
+      async () => {
+        const stats = await liveStats(harness);
+        return stats.connections === 1 && stats.subscriptions >= 2;
+      },
+      'the live channel is connected',
+      20000,
+    );
+    await harness.waitFor(
+      async () => (await connectionLabel(harness)).includes('已连接实时更新'),
+      'the shell reports the live connection',
+      20000,
+    );
+
+    // The baseline of the healthy state.
+    const baselineStats = await liveStats(harness);
+    const baselineSockets = await socketStates(harness);
+    const baselineSent = await sentMessages(harness);
+    assert.equal(baselineSockets.length, 1, `the page opened one live socket: ${JSON.stringify(baselineSockets)}`);
+    assert.equal(baselineSockets[0], 1, 'the live socket is open');
+    assert.equal(baselineStats.subscriptions, 2, `the shell holds two subscriptions: ${JSON.stringify(baselineStats)}`);
+    const baselineActive = activeSubscriptions(baselineSent, 0);
+    assert.equal(baselineActive.size, 2, `the shell subscribed two channels: ${JSON.stringify([...baselineActive])}`);
+    assert.equal(new Set(baselineActive.values()).size, 2, `the two baseline subscriptions are for two different streams: ${JSON.stringify([...baselineActive])}`);
+    const baselineProgressReads = harness.engineProxy.requests.filter(entry => entry.path.startsWith('/api/progress')).length;
+    assert.ok(baselineProgressReads >= 1, `the engine really holds a progress stream: ${baselineProgressReads}`);
+
+    // The second commit of the fixture repository gives the second run a
+    // real commit of its own.
+    const secondSha = gitCommit(repo.path, 'SECOND.md', '# second\n');
+    const shortSecond = secondSha.slice(0, 8);
+
+    // ---- the network goes away ----
+    await harness.setOffline(true);
+    await harness.waitFor(() => harness.run('navigator.onLine === false'), 'the browser really goes offline');
+    await harness.waitFor(
+      async () => {
+        const stats = await liveStats(harness);
+        return stats.connections === 0 && stats.subscriptions === 0;
+      },
+      'the shell closes the old stream',
+      20000,
+    );
+
+    const offlineSockets = await socketStates(harness);
+    assert.equal(offlineSockets.length, 1, `the page still holds one socket object: ${JSON.stringify(offlineSockets)}`);
+    // The browser closes the stream on its own schedule: the shell drops its
+    // bookkeeping as soon as it asks the socket to close, so the closed
+    // state has to be waited for instead of being sampled right away.
+    const closedOld = await harness.waitFor(
+      async () => {
+        const events = await closeEvents(harness);
+        const close = events.find(event => event.generation === 0);
+        if (!close) return null;
+        const states = await socketStates(harness);
+        return { close, states };
+      },
+      'the browser really closes the old stream',
+      20000,
+    );
+    assert.equal(closedOld.states[0], 3, `the old stream is really closed by the browser: ${JSON.stringify(closedOld)}`);
+    assert.equal(closedOld.close.readyState, 3, `the browser closed the old stream in the closed state: ${JSON.stringify(closedOld.close)}`);
+
+    // NAV-008 expected 3: the content does not pretend to be live. The shell
+    // says the connection is broken, and it does not show the update list as
+    // if it were live information.
+    const offlineLabel = await connectionLabel(harness);
+    assert.equal(offlineLabel.includes('已连接实时更新'), false, `the shell does not claim a live connection while it is offline: ${offlineLabel}`);
+    assert.ok(offlineLabel.includes('连接中断'), `the shell reports the broken connection: ${offlineLabel}`);
+    const offlineHome = await homeText(harness);
+    assert.ok(offlineHome.includes('知识引擎暂时不可用'), `the home does not show stale updates as live information: ${offlineHome}`);
+    await harness.browser.screenshot(path.join(harness.evidence, 'nav008-offline.png'));
+
+    // No read of the snapshot reached the product while the browser was
+    // offline: the outage is real, not a silent retry.
+    const requestsBeforeOffline = harness.productProxy.requests.length;
+    await harness.wait(1200);
+    const requestsDuringOffline = harness.productProxy.requests.slice(requestsBeforeOffline);
+    const snapshotDuringOffline = requestsDuringOffline.filter(entry => entry.path.startsWith(SNAPSHOT));
+    assert.deepEqual(snapshotDuringOffline, [], `no snapshot read reached the product while the browser was offline: ${JSON.stringify(snapshotDuringOffline)}`);
+
+    // Real engine state that the browser cannot know while it is offline.
+    harness.engine.store.addRun({ projectId: project.projectId, commitSha: secondSha, trigger: 'manual' });
+
+    // ---- the network comes back ----
+    await harness.setOffline(false);
+    await harness.waitFor(() => harness.run('navigator.onLine === true'), 'the browser really comes online');
+    await harness.waitFor(
+      async () => {
+        const stats = await liveStats(harness);
+        return stats.connections === 1 && stats.subscriptions === 2;
+      },
+      'the shell opens the new stream',
+      20000,
+    );
+    await harness.waitFor(
+      async () => (await connectionLabel(harness)).includes('已连接实时更新'),
+      'the shell reports the new live connection',
+      20000,
+    );
+
+    const recoveredStats = await liveStats(harness);
+    const recoveredSockets = await socketStates(harness);
+    const recoveredSent = await sentMessages(harness);
+    const recoveredClosed = await closeEvents(harness);
+    assert.equal(recoveredSockets.length, 2, `the page opened a second socket after the recovery: ${JSON.stringify(recoveredSockets)}`);
+    assert.equal(recoveredSockets[0], 3, `the old socket stays closed: ${JSON.stringify(recoveredSockets)} ${JSON.stringify(recoveredClosed)}`);
+    assert.equal(recoveredSockets[1], 1, 'the new socket is open');
+    assert.equal(recoveredClosed.filter(event => event.generation === 1).length, 0, `the new stream was not closed by the outage: ${JSON.stringify(recoveredClosed)}`);
+
+    // NAV-008 expected 2: no duplicated subscription. The subscriptions of
+    // the new socket are exactly the two streams of the shell, each of them
+    // once, and the count of the shell matches them.
+    const recoveredActive = activeSubscriptions(recoveredSent, 1);
+    assert.equal(recoveredActive.size, 2, `the new socket carries exactly two subscriptions: ${JSON.stringify([...recoveredActive])}`);
+    assert.equal(new Set(recoveredActive.values()).size, 2, `the two recovered subscriptions are for two different streams: ${JSON.stringify([...recoveredActive])}`);
+    assert.equal(recoveredStats.subscriptions, recoveredActive.size, `the shell counts the live subscriptions exactly: ${JSON.stringify(recoveredStats)} ${JSON.stringify([...recoveredActive])}`);
+    assert.equal(recoveredStats.connections, 1, 'the shell holds exactly one live connection');
+    const progressReads = harness.engineProxy.requests.filter(entry => entry.path.startsWith('/api/progress')).length;
+    assert.equal(progressReads, baselineProgressReads + 1, `the engine holds one progress stream more, not more: ${progressReads}`);
+
+    // NAV-008 expected 1: the snapshot is restored. The run that appeared
+    // while the browser was offline is on the page now, and the page was
+    // updated by a real read of the snapshot after the recovery.
+    const snapshotReads = harness.productProxy.requests.filter(entry => entry.path.startsWith(SNAPSHOT));
+    assert.ok(snapshotReads.length >= 1, 'the shell read the snapshot after the recovery');
+    const lastSnapshot = snapshotReads[snapshotReads.length - 1];
+    assert.equal(lastSnapshot.status, 200, `the last snapshot read really succeeded: ${JSON.stringify(lastSnapshot)}`);
+    await harness.waitFor(
+      async () => (await homeText(harness)).includes(shortSecond),
+      'the run that appeared while the browser was offline is on the page now',
+      20000,
+    );
+    const recoveredHome = await homeText(harness);
+    assert.ok(recoveredHome.includes(shortFirst), 'the run of before the outage is still on the page');
+    assert.equal(recoveredHome.includes('知识引擎暂时不可用'), false, 'the page shows the real records again');
+    await harness.browser.screenshot(path.join(harness.evidence, 'nav008-recovered.png'));
+
+    assert.equal(harness.browser.exceptions.length, 0, `no uncaught product JavaScript exceptions: ${JSON.stringify(harness.browser.exceptions)}`);
+
+    console.log('parallel-nav-offline-test PASS (the old stream is closed, the snapshot and a new stream are restored, no duplicated subscription, nothing pretends to be live)');
+  } finally {
+    await harness.cleanup();
+  }
+}
+
+main().catch(error => { console.error(error.stack || error.message); process.exitCode = 1; });

package/_site/_test/parallel-nav-operability-test.js

@@ -0,0 +1,257 @@
+'use strict';
+// NAV-006 — 可操作性。
+//
+// The shell must be operable by a real pointer and by a real keyboard: a
+// native pointer click must reach the control, the focus must be visible, and
+// nothing transparent may intercept the click.
+//
+// The regression drives the real product UI in a real browser against an
+// isolated instance (own port, own data dir, own knowledge dir, own Bridge
+// journal, own browser profile). Every pointer action is a CDP
+// Input.dispatchMouseEvent on the real coordinates of the real control, and
+// the hit test (document.elementFromPoint) must resolve to that control, so
+// no transparent layer can stand in for a click. Every key action is a CDP
+// Input.dispatchKeyEvent. element.click() is never used.
+//
+// The proof that the pointer really was the browser's is not the harness but
+// the page: the shell's own listener records the event, and the recorded
+// event carries isTrusted === true, which a synthesized DOM click can never
+// produce.
+//
+// Screenshots are written to PK_TEST_EVIDENCE_DIR when the batch sets it, so
+// this tracked file stays free of machine-specific paths.
+
+const path = require('node:path');
+const assert = require('node:assert/strict');
+
+const { startHarness, makeRepo } = require('./helpers/parallel-nav-shell');
+
+const EVIDENCE = process.env.PK_TEST_EVIDENCE_DIR ? path.resolve(process.env.PK_TEST_EVIDENCE_DIR) : null;
+
+/** Record every click the page really receives, trusted or not. */
+async function installClickRecorder(harness) {
+  await harness.run(`(() => {
+    window.__navClicks = [];
+    if (!window.__navClickHooked) {
+      window.__navClickHooked = true;
+      document.addEventListener('click', event => {
+        const target = event.target;
+        const nav = target.closest ? target.closest('[data-view]') : null;
+        window.__navClicks.push({
+          trusted: event.isTrusted === true,
+          tag: target.tagName,
+          id: target.id || '',
+          view: nav ? nav.getAttribute('data-view') : '',
+          label: (target.textContent || '').trim().slice(0, 30),
+        });
+      }, true);
+    }
+    return true;
+  })()`);
+}
+
+const clicks = harness => harness.run('window.__navClicks || []');
+
+/** The focus ring the browser draws for the keyboard-focused element. */
+const focusState = harness => harness.run(`(() => {
+  const el = document.activeElement;
+  if (!el || el === document.body) return { none: true };
+  const style = getComputedStyle(el);
+  const rect = el.getBoundingClientRect();
+  return {
+    none: false,
+    tag: el.tagName,
+    id: el.id || '',
+    view: el.getAttribute ? (el.getAttribute('data-view') || '') : '',
+    label: (el.textContent || '').trim().slice(0, 24),
+    outlineStyle: style.outlineStyle,
+    outlineWidth: style.outlineWidth,
+    outlineColor: style.outlineColor,
+    boxShadow: style.boxShadow,
+    width: rect.width,
+    height: rect.height,
+    visible: rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none',
+    inViewport: rect.left >= 0 && rect.top >= 0 && rect.right <= innerWidth + 1 && rect.bottom <= innerHeight + 1,
+  };
+})()`);
+
+/**
+ * Every element that could swallow a pointer across the whole viewport.
+ * A transparent full-screen layer with pointer-events enabled is exactly the
+ * defect this case looks for.
+ */
+const overlayScan = harness => harness.run(`(() => {
+  const full = [];
+  const covers = (rect) => rect.width >= innerWidth - 2 && rect.height >= innerHeight - 2;
+  for (const el of document.querySelectorAll('body *')) {
+    const style = getComputedStyle(el);
+    if (style.display === 'none' || style.visibility === 'hidden') continue;
+    if (style.pointerEvents === 'none') continue;
+    // Only a positioned element can float over the page; the layout
+    // containers are static and hold the controls themselves.
+    if (!['fixed', 'absolute', 'sticky'].includes(style.position)) continue;
+    const rect = el.getBoundingClientRect();
+    if (rect.width <= 0 || rect.height <= 0) continue;
+    if (!covers(rect)) continue;
+    const opacity = Number(style.opacity);
+    full.push({
+      tag: el.tagName,
+      id: el.id || '',
+      className: typeof el.className === 'string' ? el.className : '',
+      opacity: Number.isFinite(opacity) ? opacity : 1,
+      zIndex: style.zIndex,
+      background: style.backgroundColor,
+    });
+  }
+  return full;
+})()`);
+
+async function main() {
+  const harness = await startHarness({ tag: 'nav006', evidenceDir: EVIDENCE || undefined });
+  try {
+    const repo = makeRepo(harness.fixture, 'nav006-a');
+    await harness.importProject(repo, 'NAV006 甲');
+    await harness.requestRegistryRefresh();
+    await harness.waitFor(
+      () => harness.run("document.getElementById('homeContent').textContent.includes('NAV006 甲')"),
+      'the imported project is listed',
+      20000,
+    );
+    await installClickRecorder(harness);
+
+    // NAV-006 expected 4: the pointer is the browser's own, not a
+    // synthesized DOM event. The page records what it really received.
+    await harness.nativeClick('nav [data-view="search"]');
+    const afterNavClick = await clicks(harness);
+    assert.ok(afterNavClick.length >= 1, 'the page really received the click');
+    const navClick = afterNavClick[afterNavClick.length - 1];
+    assert.equal(navClick.trusted, true, `the click the page received is a trusted browser event: ${JSON.stringify(navClick)}`);
+    assert.equal(navClick.view, 'search', `the click reached the navigation control: ${JSON.stringify(navClick)}`);
+    await harness.waitFor(
+      () => harness.run("document.getElementById('view-search').classList.contains('active')"),
+      'the search view is open',
+    );
+
+    // NAV-006 expected 4 (continued): the hit test of the very same control
+    // resolves to the control, so nothing transparent stands in front.
+    const hit = await harness.nativeClick('nav [data-view="memory"]');
+    assert.equal(hit.hitIsTarget, true, `the control is the hit target: ${JSON.stringify(hit)}`);
+    await harness.waitFor(
+      () => harness.run("document.getElementById('view-memory').classList.contains('active')"),
+      'the memory view is open',
+    );
+    const memoryClick = (await clicks(harness)).pop();
+    assert.equal(memoryClick.trusted, true, 'the memory navigation click is trusted too');
+    assert.equal(memoryClick.view, 'memory', 'the memory navigation click reached the control');
+
+    // NAV-006 expected 1: no transparent layer intercepts the page.
+    const overlays = await overlayScan(harness);
+    assert.deepEqual(overlays, [], `no transparent full-viewport layer covers the page: ${JSON.stringify(overlays)}`);
+
+    // NAV-006 expected 2: the input focus is visible.
+    //
+    // The keyboard walk starts at the top of the document. Every Tab stop is
+    // recorded, and every stop must be visible on the screen and must carry
+    // a visible focus ring.
+    await harness.run("document.querySelector('nav [data-view=\"home\"]').focus()");
+    const stops = [];
+    for (let index = 0; index < 22; index += 1) {
+      await harness.pressTab();
+      const state = await focusState(harness);
+      if (!state.none) stops.push(state);
+    }
+    assert.ok(stops.length >= 8, `the keyboard walk reaches the main controls: ${stops.length} stops`);
+    const distinct = new Set(stops.map(stop => `${stop.tag}#${stop.id}.${stop.view}:${stop.label}`));
+    assert.ok(distinct.size >= 6, `the keyboard focus really moves between controls: ${[...distinct].join(' | ')}`);
+    for (const stop of stops) {
+      assert.equal(stop.visible, true, `the focused control is visible: ${JSON.stringify(stop)}`);
+      assert.equal(stop.inViewport, true, `the focused control is on the screen: ${JSON.stringify(stop)}`);
+      const hasRing = stop.outlineStyle !== 'none' && parseFloat(stop.outlineWidth) > 0;
+      assert.equal(hasRing, true, `the focused control shows a focus ring: ${JSON.stringify(stop)}`);
+    }
+
+    // NAV-006 expected 2 (continued): the focus ring is really painted, not
+    // only declared. The computed style of the focused element is compared
+    // with the computed style of the same element when it is not focused.
+    await harness.run("document.querySelector('nav [data-view=\"home\"]').focus()");
+    const focused = await harness.run(`(() => {
+      const el = document.querySelector('nav [data-view="home"]');
+      const style = getComputedStyle(el);
+      return { outlineStyle: style.outlineStyle, outlineWidth: style.outlineWidth, outlineColor: style.outlineColor };
+    })()`);
+    assert.equal(focused.outlineStyle, 'solid', `the focused control has a solid focus ring: ${JSON.stringify(focused)}`);
+    assert.ok(parseFloat(focused.outlineWidth) >= 2, `the focus ring is thick enough to see: ${JSON.stringify(focused)}`);
+    await harness.browser.screenshot(path.join(harness.evidence, 'nav006-focus-ring.png'));
+
+    // NAV-006 expected 1 and 2: the keyboard alone can open a page and
+    // reach the fields of a form.
+    //
+    // The navigation control is reached with Tab only, then Enter opens the
+    // view. The click the keyboard produces is trusted as well, because the
+    // browser itself synthesises it from the key press.
+    await harness.run("document.body.focus(); if (document.activeElement) document.activeElement.blur();");
+    let reachedSearch = false;
+    for (let index = 0; index < 12 && !reachedSearch; index += 1) {
+      await harness.pressTab();
+      const state = await focusState(harness);
+      if (state.view === 'search') reachedSearch = true;
+    }
+    assert.equal(reachedSearch, true, 'the keyboard reaches the search control');
+    const before = (await clicks(harness)).length;
+    await harness.pressEnter();
+    await harness.waitFor(
+      () => harness.run("document.getElementById('view-search').classList.contains('active')"),
+      'the search view is open by keyboard alone',
+    );
+    const after = await clicks(harness);
+    assert.ok(after.length > before, 'the key press really produced a click');
+    const keyboardClick = after[after.length - 1];
+    assert.equal(keyboardClick.trusted, true, `the keyboard click is a trusted browser event: ${JSON.stringify(keyboardClick)}`);
+    assert.equal(keyboardClick.view, 'search', `the keyboard click reached the search control: ${JSON.stringify(keyboardClick)}`);
+
+    // The form of the import dialog is reachable and operable by keyboard.
+    await harness.nativeClick('nav [data-view="projects"]');
+    await harness.waitFor(
+      () => harness.run("document.getElementById('view-projects').classList.contains('active')"),
+      'the projects view is open',
+    );
+    await harness.nativeClick('#createDomain');
+    await harness.waitFor(
+      () => harness.run("document.getElementById('domainDialog').open === true"),
+      'the domain dialog is open',
+    );
+    await harness.run("document.querySelector('#domainDialog input[name=\"name\"]').focus()");
+    const fieldStop = await focusState(harness);
+    assert.equal(fieldStop.visible, true, `the form field is visible: ${JSON.stringify(fieldStop)}`);
+    assert.equal(fieldStop.inViewport, true, `the form field is on the screen: ${JSON.stringify(fieldStop)}`);
+    assert.equal(fieldStop.outlineStyle !== 'none' && parseFloat(fieldStop.outlineWidth) > 0, true, `the form field shows a focus ring: ${JSON.stringify(fieldStop)}`);
+    await harness.browser.screenshot(path.join(harness.evidence, 'nav006-form-focus.png'));
+
+    // The keyboard can type into the focused field, and the value really
+    // lands in the product's own input.
+    await harness.pressKey('a', { code: 'KeyA', keyCode: 65, text: 'a' });
+    await harness.pressKey('b', { code: 'KeyB', keyCode: 66, text: 'b' });
+    const typed = await harness.run("document.querySelector('#domainDialog input[name=\"name\"]').value");
+    assert.equal(typed, 'ab', `the keyboard typed into the focused field: ${JSON.stringify(typed)}`);
+
+    // Escape closes the dialog again, so the keyboard owns the whole flow.
+    await harness.pressKey('Escape', { code: 'Escape', keyCode: 27 });
+    await harness.waitFor(
+      () => harness.run("document.getElementById('domainDialog').open === false"),
+      'the dialog closes by keyboard',
+    );
+
+    // Every click the page received during the case was a browser click.
+    const recorded = await clicks(harness);
+    assert.ok(recorded.length >= 5, `the page received the clicks of the case: ${recorded.length}`);
+    assert.equal(recorded.every(entry => entry.trusted === true), true, `no synthesized click reached the page: ${JSON.stringify(recorded)}`);
+
+    assert.equal(harness.browser.exceptions.length, 0, `no uncaught product JavaScript exceptions: ${JSON.stringify(harness.browser.exceptions)}`);
+
+    console.log('parallel-nav-operability-test PASS (native pointer and keyboard reach the controls, the focus is visible, nothing transparent intercepts)');
+  } finally {
+    await harness.cleanup();
+  }
+}
+
+main().catch(error => { console.error(error.stack || error.message); process.exitCode = 1; });