diff --git a/web/PARITY.md b/web/PARITY.md
index f3fafcb2..24a23e48 100644
--- a/web/PARITY.md
+++ b/web/PARITY.md
@@ -155,7 +155,7 @@ to it, but the server never lists it and a reload drops it.
| L4 | Responsive switch by viewport width (no hardcoded device) | `WindowSize.kt` analogue | done — one CSS breakpoint (`@media (min-width:600px)`), the exact analogue of `isWideLayout(widthDp)` at 600dp; no device sniffing, `screen.width` or fixed width. `ui-smoke` resizes the real browser with `Emulation.setDeviceMetricsOverride` at device scale 1 and asserts at both 1440×900 and 420×900 that the correct mount is visible, the other is `display:none`, no page-level scrollbar exists (`scrollHeight<=innerHeight+1`, `scrollWidth<=innerWidth+1`), each visible pane has at most one scrollable descendant and every visible tablist is a real roving tablist; it also opens a pipeline detail at 600×900 and asserts the detail pane is at least 200px and its title at least 120px wide |
| L5 | Notifications for failed/waiting runs (browser Notification API; HTTPS/localhost only) | derived from `subscribe` / `run_event` | **partial** — the browser notification path is implemented and captured in Settings, but **no real OS notification was observed**, so the row is not `done`. The exact reason: headless Chrome cannot reliably show or capture an OS notification; the smoke stubs and records the `Notification` constructor, while the transition decisions run through the page's real socket `onmessage`/`frame` path. Pure logic lives in `src/notify.js` and mirrors `notify/RunAlerts.kt` + `ui/Attention.kt`: only a run becoming `failed` (headline `A run failed`) or `waiting` (headline `A run needs your decision`) notifies; `queued`, `running`, `succeeded`, `canceled`, `interrupted` and unknown statuses never do. Body is the attention label (trimmed title else pipeline) then ` · {pipeline}`, with no separator when the pipeline is blank or equal; identity/tag is the attention key `{runId}:{kind}` so one run+kind notifies once, duplicate frames repeat nothing, a key is forgotten when the run leaves that qualifying state, and a genuinely new transition may notify again. First-seen `failed`/`waiting` from the initial `list_runs` or the `subscribe` snapshot raises nothing (the snapshot is bracketed as a seed); a disconnect drops the baseline but keeps the page session's dedupe set and reseeds before resubscribing, so a gap never notifies. A key present in the attention surface's `dismissed` set (`state.attentionDismissed`) is suppressed. Settings now shows the Android rationale verbatim (`Pipelines can notify you when a run is waiting for your decision or has failed. Without it, those runs still appear in the in-app Needs you surface.`) and honest copy for unsupported, insecure context, default, granted and denied; only `default` on a supported secure page offers the explicit `Enable notifications` control, which is the only call to `Notification.requestPermission()` (never on load). Only `{asked:true|false}` is stored under `pipelines.web.notify.v1`; malformed storage decodes to never-asked and the wording never claims consent. Clicking a notification focuses the page and opens Runs with the run selected through the **existing** navigation; **L6's `/runs/:id` URL route is still `todo`**, so no URL route is invented. `subscribeRuns`/`unsubscribeRuns` send exactly `{type:'subscribe',workspace:''}` and `{type:'unsubscribe'}` (no `run_ids`, no polling timer) and are sent only after the page is connected. Unit-tested in `test/notify.test.mjs` (qualification, wording/body, per-run dedupe, seed/snapshot suppression, dismissed keys, permission copy, asked storage) and `test/repository.test.mjs` (both request shapes + the not-connected guard). Captured 2026-10-19: `captures/L5-notifications-settings.png` (default state, control offered, 0 requests on load), `captures/L5-notifications-granted.png` (after the one explicit grant) and `captures/L5-notifications-denied.png` (honest denied copy, no control). The same checks live in `test/ui-smoke.mjs` behind `--notify` (a focused mode that runs exactly this evidence); that run finished `UI SMOKE PASS` and logged: queued→failed and running→waiting each raised exactly one recorded notification, duplicates/terminal/unknown statuses/first-seen/dismissed raised none, and the click opened the run. **Not observed:** the OS notification itself. On 2026-10-19 the default full live suite reached and passed this block with the same logged assertions, then failed later in an unrelated C13 hit-test (`the last row's menu item is not clickable`, its centre at y=919.5 in a 900 px viewport after the list's re-render reset the scroll); the L5 captures and assertions above come from the focused `--notify` run, which finished `UI SMOKE PASS`. |
| L6 | Deep links to a run (`pipelines://run/…` analogue → URL route) | — | done — the page's destinations are real URLs through a pure, total route model in `src/routes.js`: `/pipelines`, `/runs`, `/chat`, `/settings` and `/templates`; `/pipelines/:id` and `/pipelines/:id/:version` (version 0 or absent = latest); `/pipelines/:id[/:version]/stage/:key`; `/runs/:id` with `?action=decide`; `/runs/:id/stage/:key[?visit=N]`; `/settings/templates` and `/settings/templates/:key` parse as aliases of `/templates` and `/templates/:key`. `visit` is a zero-based index into that stage's visits, dropped when invalid while the stage route stays; a malformed or unknown path (a bad percent escape, a zero/negative run id, a non-numeric version or path, or a trailing extra segment on either stage branch, e.g. `/runs/440/stage/planner/extra`) resolves to the Pipelines list and never throws, and search/query state is never a route. The serialiser percent-encodes path segments, omits version 0 and an absent visit, and round-trips under `parse(serialize(…))`; an id, version or key the parser would reject is never emitted — it falls back to the nearest canonical route (an invalid id to the list, an invalid version to latest) so the address bar can never carry a path the parser would discard. `serve.mjs` serves `index.html` for any page route (a first segment naming a destination, so a stage key that ends in an extension — `plan.js`, `plan.v2` — still deep-links) or any non-asset GET, with a root `` so the shell's relative asset URLs resolve under a deep path, while an asset-looking path outside a page prefix such as `/nope.js` stays 404. Navigation moves the URL with `pushState` only on a real change (top-level tabs, pipeline/run/template selection, Settings' Browse templates, opening/closing either stage pane; a user click on a pipeline graph node pushes `/pipelines/:id/:version/stage/:key` through the shared graph's `onSelectionChange` (a synthetic click is never used); a deep-linked stage instead opens at mount through the graph's `selectedKey` option without notifying), and one `popstate` listener parses and applies Back/Forward without a reload; in-detail tabs (Summary/Graph/Source, run tabs) and search stay in-place. A deep link is parsed at boot, kept pending until the first successful connection, and then loaded list-first (later reconnects never replay it; any move made while still disconnected replaces the pending boot link, so the URL and the first connected view agree). An unknown or malformed boot path renders the Pipelines list and `replaceState`s the address bar to the canonical `/pipelines` so the URL and the view agree. A later reconnect refreshes the lists and re-applies the route: the URL and a detail already in hand survive the drop, while a detail that is not in hand (never loaded, or cleared while disconnected) is fetched again. Only a genuine server refusal — never a timeout or a socket drop — discards the deep link. A run link's `?action=decide` opens the existing decision sheet once, only when the run is genuinely waiting, then `replaceState`s to the action-free `/runs/:id`. A valid but out-of-range `?visit=N` is clamped to the stage's last visit and the entry is corrected, so the address bar and the pane agree; a pipeline-stage path naming a key the loaded graph does not declare falls back to `/pipelines/:id[/:version]` rather than leaving a pane-less stage URL, while a key the mounted graph can select — including its `#success`/`#failure` terminals — re-opens the same definition pane (the graph writes those URLs itself, so the loader accepts them). A run-stage path naming a stage that is neither visited nor a node of the run graph falls back to the plain run detail. A deep link to an executing run installs its 1 Hz refresh; leaving Runs for any other destination stops it, and a reply discarded for a view that no longer shows Runs stops it too, so no get_run loop survives the move (asserted in the smoke when an executing run is live). A deep-linked stage pane is revealed clear of the sticky top bar (its head and the Close control stay visible), which the smoke asserts. A run the server does not have falls back honestly to `/runs` — the real list, the server's own refusal in the banner and no stale pane or throw (the same for a missing pipeline → `/pipelines`). A run or run-stage route also loads the pipeline list when it has not been seen, so the nav badge stays honest (`Pipelines (29)` at capture time, never a false `Pipelines (0)`) — asserted in the smoke. Captured 2026-10-19: `captures/L6-deeplink-run-440.png` (a hard navigation to `/runs/440` opening run 440's detail), `captures/L6-deeplink-pipeline-24.png` (a hard navigation to `/pipelines/24` opening `Plan and land`), `captures/L6-deeplink-pipeline-24-stage.png` (a hard navigation to `/pipelines/24/stage/planner` opening the Graph tab and the stage's definition pane in view), `captures/L6-deeplink-pipeline-24-terminal.png` (a hard navigation to `/pipelines/24/stage/%23failure` re-opening the Failure terminal pane — the live graph's first terminal at capture time — with its URL unchanged), `captures/L6-history-back.png` (an in-page Pipelines→Runs→run-detail sequence, then `history.back()` restoring the Runs list, with a window marker proving no reload), `captures/L6-missing-run.png` (`/runs/900000000` landing on `/runs` with the real list — 407 rows at capture time — and the banner `run not found`) and `captures/L6-missing-pipeline.png` (`/pipelines/900000000` landing on `/pipelines` with the real pipeline rows and the server's refusal banner). Parsing, serialisation, version/visit semantics and round-tripping are unit-tested in `test/routes.test.mjs`. **The live server had no waiting run, so the `?action=decide` path was not exercised live**; `test/ui-smoke.mjs` captures the sheet automatically the moment a waiting run exists |
-| L7 | Accessibility: focus order, labels, keyboard operation | — | todo — **M5/M6/M7/M9 are fixed in the view modules** (artifact tiles are named `Open {artifact}`, keyboard-operable buttons with Copy link/Share as siblings; a chat row's session button is native and its `Chat actions for {title}` control is a sibling, with the id appended only for repeated titles; attention dismiss controls are named `Dismiss {run label}` with the run id only for repeated labels; timeline rows show a 2px accent focus ring at offset -2px). **Still open:** M1/M2 (dialog focus entry/trap/return and background inertness), M3 (tab roles and arrow keys), M4 (skip link plus list→detail focus order), M8 (one `h1` per route and list `h2`s), and the should-fix items (S1–S12) — the shell/dialog item owns those files. The whole row stays `todo` until they are fixed and a review stage captures the result |
+| L7 | Accessibility: focus order, labels, keyboard operation | — | done — every must-fix finding in `web/docs/a11y-audit.md` is addressed. **M1/M2 are this change:** one shared DOM-only controller (`web/src/modal.js`) now owns every listed `role="dialog"` surface (attention sheet, stage pane, changes viewer, artifact viewer, decision sheet, cancel/retry/restart confirm, Action-failed, chat Rename/Close, template create): it records the opener, re-parents the panel into `#modalLayer` outside `.app-root`, focuses the first control (or the panel with `tabindex=-1`), traps Tab/Shift+Tab, sets native `inert` on `.app-root` (exact-prior restoration; the no-inert fallback uses `aria-hidden` plus saved `tabindex` and a `focusin` guard), routes Escape/backdrop/the close control through the same view callback, and restores focus to the re-resolved trigger or a sensible heading. Same-id re-renders replace the panel without recapturing the trigger, a second overlay inerts the first and gives it back on close, and the one document keydown/focusin listener is removed when the stack empties. **M3/M4/M8** were built into the shell (tablist/tab/tabpanel with roving `tabindex` and arrow keys, the `Skip to detail` link plus list→detail focus handoff, and one `h1` per route with list `h2`s). **M5/M6/M7/M9** previously landed (named keyboard artifact tiles; sibling Chat actions with unique names; named attention Dismiss controls; timeline focus ring). No markup copy, roles or CSS was changed by this item. Focused proof: `node --test test/modal.test.mjs` (focusable discovery, both wrap directions, empty-panel fallback, idempotent open/listener cleanup, stack inertness, exact inert/aria-hidden/tabindex restore) and `node test/modal-probe.mjs --out ../captures` passed against the live server for the attention sheet, run 440 Retry confirm, run 438 changes viewer and the artifact-viewer-over-stage-pane stack, with `captures/86-modal-focus-attention.png` as the keyboard-opened focus-visible capture. `node --test test/` is green (603 tests). The **S1–S12** should-fix items remain notes and are not claimed fixed here; the full `ui-smoke` run reached the unchanged live-chat markdown-table assertion, which the current operator session does not satisfy (no table anywhere in its history), so it is recorded as an environmental live-data limitation rather than a modal regression. |
## Deliberately out of scope
- **Operator-only transport** — `inspect_resource`, `reconcile_resource`,
diff --git a/web/src/app.js b/web/src/app.js
index ba3c7452..c01bac22 100644
--- a/web/src/app.js
+++ b/web/src/app.js
@@ -42,6 +42,7 @@ import {
} from "./search.js";
import { DecisionDraft, pendingDecision } from "./actions.js";
import { h } from "./dom.js";
+import { createModalController } from "./modal.js";
import { describeError, isExecuting } from "./format.js";
import {
createAttentionView,
@@ -510,9 +511,24 @@ const dock = h(
// The attention sheet lives in its own layer so it can overlay any view without
// being torn down by a content re-render; renderAttentionSheet rebuilds it.
const attentionLayer = h("div", { id: "attentionLayer" });
+// Dialogs are re-parented here, outside the inert app root. `inert` inherits and
+// cannot be overridden by a descendant, so a panel left inside .app-root could
+// never be interactive while the background is inert.
+const modalLayer = h("div", { id: "modalLayer" });
const skipLink = h("a", { class: "skip-link", href: "#pane-main", text: "Skip to detail" });
document.body.append(skipLink);
-document.body.append(h("div", { class: "app-root" }, appRail, workspace, dock, attentionLayer));
+document.body.append(h("div", { class: "app-root" }, appRail, workspace, dock));
+document.body.append(attentionLayer);
+document.body.append(modalLayer);
+
+// One controller owns Escape, the Tab trap, the background's inert state and
+// focus return for every role="dialog" surface.
+const modal = createModalController({
+ document,
+ layer: () => modalLayer,
+ background: () => document.querySelector(".app-root"),
+ skipLinks: () => [...document.querySelectorAll(".skip-link")],
+});
/** Whether the URL field currently holds a usable endpoint for Reconnect. */
function endpointConfigured() {
@@ -931,6 +947,7 @@ function renderContent() {
nodes.push(h("div", { class: "settings-pane", id: "detail-panel" }, renderSettingsView()));
captureChatPosition();
content.replaceChildren(...nodes);
+ modal.reconcile();
stopChatClock();
stopListClock();
stopDetailClock();
@@ -1021,11 +1038,13 @@ function renderContent() {
content.replaceChildren(...nodes);
if (state.view === "chat") {
afterChatRender();
+ modal.reconcile();
stopListClock();
stopDetailClock();
refreshChatClock();
return;
}
+ modal.reconcile();
stopChatClock();
if (state.view === "runs") {
refreshListClock();
@@ -2035,6 +2054,7 @@ const runtime = {
repo,
runAlerts,
attentionLayer,
+ modal,
searchHost,
render,
renderContent,
@@ -2070,12 +2090,11 @@ const {
renderAttentionBell,
refreshAttentionBell,
renderAttentionSheet,
- closeAttentionSheet,
onRunAlertFrame,
} = views.attention;
const { renderSettingsView, refreshServerUrlError } = views.settings;
const { renderPipelineList, renderPipelineDetail } = views.pipelines;
-const { renderTemplateGallery, renderTemplateDetail, loadTemplates, selectTemplate, resetTemplateCreateState, resetTemplateSelection, closeTemplateCreateDialog } =
+const { renderTemplateGallery, renderTemplateDetail, loadTemplates, selectTemplate, resetTemplateCreateState, resetTemplateSelection } =
views.templates;
const renderRunList = () => views.runs.renderRunList(listNow);
const renderRunDetail = () => views.runDetail.renderRunDetail(detailNow);
@@ -2098,8 +2117,6 @@ const {
onChatEvent,
onChatPermission,
onChatFrame,
- dismissChatClose,
- dismissChatRename,
} = views.chat;
const {
openSearch,
@@ -2108,8 +2125,7 @@ const {
onSearchInput,
sendSearchNow,
} = views.search;
-const { openDecisionSheet, closeDecisionSheet, dismissConfirm, dismissActionError } = views.dialogs;
-const { closeStagePane } = views.runDetail;
+const { openDecisionSheet } = views.dialogs;
// Kept as named exports for the UI smoke's page-rendered markdown/tool samples.
export const renderToolCallRow = views.chat.renderToolCallRow;
@@ -2200,55 +2216,12 @@ client.addEventListener("frame", (event) => {
onChatFrame(message);
});
-// The stage pane, the decision sheet, the confirm/Action-failed dialogs, the
-// omni-search field and the attention sheet are modal: Escape closes the topmost
-// one (the artifact viewer or the diff viewer, when either is above, owns Escape
-// first via its own listener). The attention sheet, when open, is the topmost
-// overlay and owns Escape first. Registered once; every branch is a no-op when
-// nothing is open.
+// The shared modal controller owns Escape for every role="dialog" (attention
+// sheet, stage pane, viewers, decision/confirm/Action-failed, chat Rename/Close,
+// template create). Only the non-modal surfaces below are handled here: the Chat
+// actions menu and the Search disclosure, which are not dialogs.
document.addEventListener("keydown", (event) => {
if (event.key !== "Escape") return;
- if (state.attentionSheetOpen) {
- event.preventDefault();
- closeAttentionSheet();
- return;
- }
- if (document.querySelector(".artifact-viewer") || document.querySelector(".change-viewer")) return;
- if (state.templateCreateOpen) {
- event.preventDefault();
- closeTemplateCreateDialog();
- return;
- }
- if (state.actionError) {
- event.preventDefault();
- dismissActionError();
- return;
- }
- if (state.chatRename) {
- event.preventDefault();
- dismissChatRename();
- return;
- }
- if (state.chatClose) {
- event.preventDefault();
- dismissChatClose();
- return;
- }
- if (state.confirmKind) {
- event.preventDefault();
- dismissConfirm();
- return;
- }
- if (state.decisionOpen) {
- event.preventDefault();
- closeDecisionSheet();
- return;
- }
- if (state.runStagePane) {
- event.preventDefault();
- closeStagePane();
- return;
- }
if (state.chatMenu) {
event.preventDefault();
state.chatMenu = null;
diff --git a/web/src/modal.js b/web/src/modal.js
new file mode 100644
index 00000000..95abed21
--- /dev/null
+++ b/web/src/modal.js
@@ -0,0 +1,631 @@
+// The shared modal controller: one focus trap, one background-inert rule and
+// one Escape/close path for every role="dialog" surface in the web client.
+//
+// It is deliberately DOM-only and dependency-free. Views keep owning their
+// markup, copy and state transitions: a view stage()s the dialog it built (or
+// open()s an imperative viewer) and gives the controller the callback that
+// closes it. The controller never mutates view state itself.
+//
+// The dialog layer lives outside .app-root (see app.js): inert inherits, so a
+// panel inside the inert root could not become interactive. Every active panel
+// is re-parented into #modalLayer, the app root gets native `inert` (or the
+// aria-hidden + tabindex fallback), and only the top panel owns Tab/Escape.
+
+/** The selectors a focusable candidate can match, in DOM order at discovery. */
+export const FOCUSABLE_SELECTOR = [
+ "a[href]",
+ "area[href]",
+ "button",
+ "input",
+ "select",
+ "textarea",
+ "iframe",
+ "object",
+ "embed",
+ "summary",
+ "audio[controls]",
+ "video[controls]",
+ "[contenteditable]",
+ "[tabindex]",
+].join(",");
+
+const NATIVE_FOCUSABLE = new Set([
+ "button",
+ "input",
+ "select",
+ "textarea",
+ "iframe",
+ "object",
+ "embed",
+ "summary",
+]);
+
+function attr(node, name) {
+ return typeof node.getAttribute === "function" ? node.getAttribute(name) : null;
+}
+
+function hasAttr(node, name) {
+ return typeof node.hasAttribute === "function" ? node.hasAttribute(name) : attr(node, name) != null;
+}
+
+function tagName(node) {
+ return String(node.tagName ?? "").toLowerCase();
+}
+
+function computedStyle(node) {
+ try {
+ return node.ownerDocument?.defaultView?.getComputedStyle?.(node) ?? null;
+ } catch {
+ return null;
+ }
+}
+
+function hiddenBySelf(node) {
+ if (node.hidden) return true;
+ if (attr(node, "aria-hidden") === "true") return true;
+ if (hasAttr(node, "inert")) return true;
+ const style = computedStyle(node);
+ return Boolean(style && (style.display === "none" || style.visibility === "hidden"));
+}
+
+function hiddenByAncestor(node, root) {
+ let current = node;
+ while (current) {
+ if (hiddenBySelf(current)) return true;
+ if (current === root) break;
+ current = current.parentElement ?? null;
+ }
+ return false;
+}
+
+/** Whether one node is a reachable control (not disabled, hidden or removed). */
+export function isFocusable(node, { root = null } = {}) {
+ if (!node || (node.nodeType != null && node.nodeType !== 1)) return false;
+ if (node.disabled === true || hasAttr(node, "disabled")) return false;
+ if (hiddenByAncestor(node, root)) return false;
+ const tabindex = attr(node, "tabindex");
+ if (tabindex != null && Number(tabindex) < 0) return false;
+ if (node.isContentEditable === true) return true;
+ const tag = tagName(node);
+ if (tag === "input" && String(attr(node, "type") ?? "").toLowerCase() === "hidden") return false;
+ if (tag === "a" || tag === "area") return hasAttr(node, "href");
+ if (NATIVE_FOCUSABLE.has(tag)) return true;
+ if (tag === "audio" || tag === "video") return hasAttr(node, "controls");
+ if (tag === "" && typeof node.focus === "function") return true;
+ // A div/span with a non-negative tabindex is focusable even though it is not
+ // a native control (the change/timeline rows use exactly this form).
+ return tabindex != null && Number(tabindex) >= 0;
+}
+
+/** Every reachable control inside [panel], in DOM order. */
+export function focusableElements(panel) {
+ if (!panel || typeof panel.querySelectorAll !== "function") return [];
+ return [...panel.querySelectorAll(FOCUSABLE_SELECTOR)].filter((node) =>
+ isFocusable(node, { root: panel }),
+ );
+}
+
+/** The wrapped index for one Tab/Shift+Tab step; -1 when there is no control. */
+export function wrapFocusIndex(index, direction, count) {
+ if (count <= 0) return -1;
+ if (!Number.isInteger(index) || index < 0) return direction < 0 ? count - 1 : 0;
+ return ((index + direction) % count + count) % count;
+}
+
+/** The initial focus target is the first control, else the panel itself (-1). */
+export function initialFocusIndex(count) {
+ return count > 0 ? 0 : -1;
+}
+
+function supportsNativeInert() {
+ try {
+ return typeof HTMLElement !== "undefined" && "inert" in HTMLElement.prototype;
+ } catch {
+ return false;
+ }
+}
+
+function isConnected(node) {
+ return Boolean(node) && node.isConnected !== false;
+}
+
+function contains(root, node) {
+ if (!root || !node) return false;
+ return root === node || root.contains?.(node) === true;
+}
+
+function inInertSubtree(node, document_) {
+ let current = node;
+ while (current) {
+ if (hasAttr(current, "inert")) return true;
+ current = current.parentElement ?? null;
+ }
+ return false;
+}
+
+function focusElement(element) {
+ if (!element || typeof element.focus !== "function") return false;
+ try {
+ element.focus({ preventScroll: true });
+ } catch {
+ try {
+ element.focus();
+ } catch {
+ return false;
+ }
+ }
+ return true;
+}
+
+/**
+ * Create one controller for the page. Options are injectable for the unit tests:
+ * a document, a layer, the background element/skip links, and whether native
+ * inert exists. Production passes none of them and uses the real document.
+ */
+export function createModalController(options = {}) {
+ const document_ = options.document ?? globalThis.document;
+ const getLayer =
+ typeof options.layer === "function"
+ ? options.layer
+ : () => options.layer ?? document_?.getElementById?.("modalLayer") ?? document_?.body;
+ const getBackground =
+ typeof options.background === "function"
+ ? options.background
+ : () => document_?.querySelector?.(".app-root") ?? null;
+ const getSkipLinks =
+ typeof options.skipLinks === "function"
+ ? options.skipLinks
+ : () =>
+ options.skipLinks ??
+ (document_?.querySelectorAll ? [...document_.querySelectorAll(".skip-link")] : []);
+ const nativeInert =
+ typeof options.supportsInert === "function" ? options.supportsInert : () => supportsNativeInert();
+ const defaultFallbackSelectors = options.fallbackSelectors ?? [
+ "#detailTitle",
+ "#listTitle",
+ ".detail-pane h1",
+ ".list-pane .pane-title",
+ "#pane-main",
+ ];
+
+ /** @type {Array