@3sln/trove 0.0.8 → 0.0.9

package/packages/web/src/ui/components/activityPanel.js

@@ -11,6 +11,7 @@
 import { dd } from '../../runtime.js';
 import { icon } from '../icon.js';
 import { bytes } from '../format.js';
+import { CancelTaskAction, CopyTextAction, DismissIssueAction, DismissTaskAction, ExecCommandAction, RetryIssueAction, ToggleActivityPanelAction } from '../../bl/actions.js';
 
 const { div, button, span, h3, p, pre } = dd;
 
@@ -24,9 +25,7 @@ const STATUS_ICON = { running: 'refresh', done: 'check', failed: 'close', cancel
  * of the app and into a terminal.
  */
 function copyText(text, ui) {
-  navigator.clipboard?.writeText(text)
-    .then(() => ui.platform.notifications.success('Copied'))
-    .catch(() => ui.platform.notifications.info(text, { sticky: true }));
+  ui.engine.dispatch(new CopyTextAction(text));
 }
 
 function amount(task) {
@@ -51,9 +50,9 @@ function taskRow(task, ui) {
         task.error ? div({ className: 'act-error' }, task.error) : null,
       ),
       running && task.cancellable
-        ? button({ className: 'act-action', title: 'Cancel' }, icon('close', { size: 12 })).on({ click: () => ui.app.activity.cancel(task.id) })
+        ? button({ className: 'act-action', title: 'Cancel' }, icon('close', { size: 12 })).on({ click: () => ui.engine.dispatch(new CancelTaskAction(task.id)) })
         : !running
-          ? button({ className: 'act-action', title: 'Dismiss' }, icon('close', { size: 12 })).on({ click: () => ui.app.activity.dismiss(task.id) })
+          ? button({ className: 'act-action', title: 'Dismiss' }, icon('close', { size: 12 })).on({ click: () => ui.engine.dispatch(new DismissTaskAction(task.id)) })
           : null,
     ),
     running
@@ -89,10 +88,10 @@ function issueRow(issue, ui) {
       // Retry only when the server said pressing it will actually do something.
       issue.retryable
         ? button({ className: 'btn small act-retry' }, icon('refresh', { size: 12 }), span('Retry'))
-          .on({ click: () => ui.app.activity.retryIssue(issue.id) })
+          .on({ click: () => ui.engine.dispatch(new RetryIssueAction(issue.id)) })
         : null,
       button({ className: 'btn small ghost act-dismiss' }, 'Dismiss')
-        .on({ click: () => ui.app.activity.dismissIssue(issue.id) }),
+        .on({ click: () => ui.engine.dispatch(new DismissIssueAction(issue.id)) }),
     ),
   );
 }
@@ -107,7 +106,7 @@ export default function activityPanel(state, ui) {
     div({ className: 'act-head' },
       h3('Activity'),
       button({ className: 'act-action', title: 'Close' }, icon('close', { size: 13 }))
-        .on({ click: () => ui.app.activity.togglePanel(false) }),
+        .on({ click: () => ui.engine.dispatch(new ToggleActivityPanelAction(false)) }),
     ),
 
     // "Nothing is wrong" and "we couldn't ask" look identical unless one says so. Both
@@ -145,15 +144,15 @@ export default function activityPanel(state, ui) {
 
     div({ className: 'act-foot act-actions' },
       button({ className: 'btn small ghost act-rebuild' }, icon('refresh', { size: 12 }), span('Rebuild search index'))
-        .on({ click: () => ui.exec('workbench.rebuildIndex') }),
+        .on({ click: () => ui.engine.dispatch(new ExecCommandAction('workbench.rebuildIndex')) }),
       button({ className: 'btn small ghost act-scan' }, icon('refresh', { size: 12 }), span('Scan for outside changes'))
-        .on({ click: () => ui.exec('workbench.scanCollection') }),
+        .on({ click: () => ui.engine.dispatch(new ExecCommandAction('workbench.scanCollection')) }),
       // On demand as well as on a schedule, because the moment an admin wants to know
       // whether they fixed the bucket is right after they changed it — not up to five
       // minutes later. It also checks against THIS browser's origin, which the scheduled
       // run can only do if the deployment configured one.
       button({ className: 'btn small ghost act-storage' }, icon('plug', { size: 12 }), span('Check storage'))
-        .on({ click: () => ui.exec('workbench.checkStorage') }),
+        .on({ click: () => ui.engine.dispatch(new ExecCommandAction('workbench.checkStorage')) }),
     ),
   );
 }

package/packages/web/src/ui/components/adminView.js

@@ -0,0 +1,191 @@
+// The admin console.
+//
+// Drive-level administration had accumulated in three places and no place: API keys in
+// Settings, storage diagnostics behind a status-bar item, ACLs in a dialog, and the driver
+// registry, the indexers and the identity provider only through the API. Each landed where
+// it did for a local reason, and the result was that there was nowhere to send someone who
+// had just been made an administrator.
+//
+// A DESTINATION, not a route. 006 introduced share links, and what it actually established
+// is that this app does not reflect its state in the address bar — it consumes a share path
+// at boot and immediately replaces it with `/`, because a URL that goes stale the moment
+// you navigate is worse than one that says nothing. So there is no router to hang a route
+// on, and an activity-bar destination beside Plugins and Settings is the consistent answer.
+//
+// Almost nothing here is new capability. It is gathering: every value below already comes
+// from `/api/capabilities`, which the app fetches at startup, or from a query that already
+// exists. What was missing was somewhere to look.
+
+import { dd } from '../../runtime.js';
+import { icon } from '../icon.js';
+import { bytes } from '../format.js';
+import { ExecCommandAction } from '../../bl/actions.js';
+
+const { div, h2, h3, p, span, button } = dd;
+
+export default function adminView(state, ui) {
+  const caps = state.caps;
+  return div({ className: 'editor' },
+    div({ className: 'stage' },
+      div({ className: 'settings admin' },
+        h2('Administration'),
+        p({ className: 'sub' }, 'How this drive is configured, and what it can do. Most of it is decided by the deployment rather than here.'),
+        accessSection(caps, state, ui),
+        storageSection(caps, state, ui),
+        extensionsSection(caps, state),
+        workSection(state, ui),
+      ),
+    ),
+  );
+}
+
+/** A label/value row, matching the settings screen so the two read as one thing. */
+function row(title, detail, value) {
+  return div({ className: 'setting' },
+    div({ className: 'info' },
+      div({ className: 't' }, title),
+      detail ? div({ className: 'd' }, detail) : null,
+    ),
+    div({ className: 'control' }, typeof value === 'string' ? span({ className: 'mono' }, value) : value),
+  );
+}
+
+/**
+ * Who this drive thinks you are, and who it lets in.
+ *
+ * The identity driver and whether authentication is required are deployment decisions —
+ * environment variables, not preferences — so they are reported rather than offered. Which
+ * is the point: an admin needs to know what is in force, and previously could only find out
+ * by reading the server's configuration or calling the API.
+ */
+function accessSection(caps, state, ui) {
+  const auth = caps?.auth || {};
+  const me = caps?.principal || state.so?.me || {};
+  const servers = auth.authorizationServers || [];
+  return div({ className: 'group' },
+    h3('Access'),
+    p({ className: 'sub' }, 'Who can reach this drive. Set by the deployment, not here.'),
+    row('Signed in as', me.anonymous ? 'This drive does not require a sign-in.' : (me.email || me.id),
+      me.anonymous ? 'anonymous' : (me.name || me.id || '—')),
+    row('Sign-in required', 'Whether a caller must present a token.',
+      caps?.mcp?.requiresAuth ? 'Yes' : 'No'),
+    row('Authorization server', 'Where clients are sent to sign in.',
+      servers.length ? servers.join(', ') : 'not set'),
+    // API keys stay in Settings for now and are LINKED rather than duplicated: two places
+    // to revoke a credential is worse than one place in the wrong screen.
+    row('API keys', 'Credentials for scripts and services, scoped per collection.',
+      button({ className: 'btn small' }, 'In Settings')
+        .on({ click: () => ui.engine.dispatch(new ExecCommandAction('workbench.openSettings')) })),
+  );
+}
+
+/**
+ * What this deployment can actually do with bytes.
+ *
+ * The driver registry is the list a collection form offers, and it is deployment
+ * configuration: `TROVE_STORAGE_DRIVERS` narrows it, and a driver missing from here is the
+ * reason a collection cannot be made on it. The capability flags below explain behaviour
+ * that otherwise looks arbitrary — why a download is proxied rather than direct, why a
+ * usage figure is missing.
+ */
+function storageSection(caps, state, ui) {
+  const s = caps?.storage || {};
+  const drivers = caps?.storageDrivers || [];
+  const usage = state.ex?.usage;
+  const can = (on) => span({ className: `mono ${on ? '' : 'muted'}` }, on ? 'yes' : 'no');
+  return div({ className: 'group' },
+    h3('Storage'),
+    p({ className: 'sub' }, 'The backing stores this deployment offers, and what they support.'),
+    row('Drivers offered', 'What a new collection may be created on.',
+      drivers.length ? drivers.map((d) => d.label || d.key).join(', ') : 'none registered'),
+    row('Direct downloads', 'A presigned URL sends bytes from the store, not through the drive.', can(s.presignDownload)),
+    row('Direct uploads', 'A presigned PUT sends bytes to the store, not through the drive.', can(s.presignUpload)),
+    row('Multipart', 'Large files go up in parts, resumably.', can(s.multipart)),
+    row('Range requests', 'Seeking inside a file without fetching the whole thing.', can(s.range)),
+    usage?.total
+      ? row('Space', 'Reported by the backing store.', `${bytes(usage.available)} free of ${bytes(usage.total)}`)
+      : row('Space', 'This store does not report a total, which object stores generally cannot.', 'not reported'),
+    // The check and its remedy already exist as a command — this is where someone would
+    // look for it, which is the whole complaint the ticket makes.
+    div({ className: 'setting' },
+      div({ className: 'info' },
+        div({ className: 't' }, 'Check the backing stores'),
+        div({ className: 'd' }, 'Asks whether each store can actually be reached from here — the failure that makes every file open to a spinner.'),
+      ),
+      div({ className: 'control' },
+        button({ className: 'btn small' }, 'Run check')
+          .on({ click: () => ui.engine.dispatch(new ExecCommandAction('workbench.checkStorage')) })),
+    ),
+  );
+}
+
+/**
+ * What extends this drive, and what each extension is permitted.
+ *
+ * Indexers matter here for a reason that is easy to miss: an indexer reads file CONTENTS,
+ * including from an encrypted collection, because indexing happens on the drive's side of
+ * the encryption. Anyone weighing what encryption protects needs to know which ones are
+ * installed, so the same list appears on the collection form.
+ */
+function extensionsSection(caps, state) {
+  const indexers = caps?.indexers || [];
+  const plugins = state.plugins || [];
+  return div({ className: 'group' },
+    h3('Extensions'),
+    p({ className: 'sub' }, 'What reads and adds to this drive.'),
+    div({ className: 'setting' },
+      div({ className: 'info' },
+        div({ className: 't' }, 'Indexers'),
+        div({ className: 'd' }, 'They read file contents to make them searchable — including in an encrypted collection, since indexing happens on the drive’s side of the encryption.'),
+      ),
+      div({ className: 'control' },
+        span({ className: 'mono' }, indexers.length ? indexers.map((i) => i.displayName || i.id).join(', ') : 'none')),
+    ),
+    plugins.length
+      ? div({}, ...plugins.map((pl) => div({ className: 'setting' },
+        div({ className: 'info' },
+          div({ className: 't' }, pl.manifest?.displayName || pl.id),
+          div({ className: 'd' }, (pl.grants || []).length
+            ? `May: ${(pl.grants || []).join(', ')}`
+            : 'Granted nothing — it runs in its sandbox and can only draw.'),
+        ),
+        div({ className: 'control' }, span({ className: `mono ${pl.status === 'active' ? '' : 'muted'}` }, pl.status || 'idle')),
+      )))
+      : row('Plugins', 'Installed by an administrator, from a signed package.', 'none installed'),
+  );
+}
+
+/**
+ * What the drive is doing, and what it has not finished.
+ *
+ * The panel that shows running work already exists and is reached from the status bar,
+ * which is fine when something is running and undiscoverable when nothing is. The counts
+ * here are the discoverable version; the panel is still where the detail lives.
+ */
+function workSection(state, ui) {
+  const act = state.act || { tasks: [], issues: [] };
+  const running = (act.tasks || []).filter((t) => t.status === 'running');
+  return div({ className: 'group' },
+    h3('Work'),
+    p({ className: 'sub' }, 'Background jobs and anything that needs attention.'),
+    row('Running now', 'Scans, reindexes and rotations happening on the server.',
+      running.length ? `${running.length}` : 'nothing running'),
+    row('Needs attention', 'Standing problems — they persist until fixed, unlike a toast.',
+      act.issues?.length ? `${act.issues.length}` : 'none'),
+    // `stacked`: three buttons do not fit the 200px control column — see styles.css.
+    div({ className: 'setting stacked' },
+      div({ className: 'info' },
+        div({ className: 't' }, 'Maintenance'),
+        div({ className: 'd' }, 'A scan picks up files changed in the bucket by something other than Trove. A reindex rebuilds search from scratch.'),
+      ),
+      div({ className: 'control admin-actions' },
+        button({ className: 'btn small' }, 'Activity panel')
+          .on({ click: () => ui.engine.dispatch(new ExecCommandAction('workbench.showActivity')) }),
+        button({ className: 'btn small' }, 'Scan')
+          .on({ click: () => ui.engine.dispatch(new ExecCommandAction('workbench.scanCollection')) }),
+        button({ className: 'btn small' }, 'Reindex')
+          .on({ click: () => ui.engine.dispatch(new ExecCommandAction('workbench.rebuildIndex')) }),
+      ),
+    ),
+  );
+}

package/packages/web/src/ui/components/collectionGate.js

@@ -13,6 +13,7 @@
 
 import { dd } from '../../runtime.js';
 import { icon } from '../icon.js';
+import { ExecCommandAction } from '../../bl/actions.js';
 
 const { div, h2, p, button, span } = dd;
 
@@ -44,7 +45,7 @@ function createPrompt(ui) {
       + 'there is somewhere to put it.'),
     div({ className: 'gate-actions' },
       button({ className: 'btn primary' }, icon('plus', { size: 14 }), 'New collection')
-        .on({ click: () => ui.exec('collections.create') }),
+        .on({ click: () => ui.engine.dispatch(new ExecCommandAction('collections.create')) }),
     ),
   );
 }
@@ -69,12 +70,12 @@ function choosePrompt(ex, ui) {
         // What they may do, from the server's own answer — so a read-only collection says
         // so before they open it and find the Upload button missing.
         span({ className: 'gate-caps' }, (c.capabilities || []).join(' · ')),
-      ).on({ click: () => ui.exec('collections.switch', c.id) })),
+      ).on({ click: () => ui.engine.dispatch(new ExecCommandAction('collections.switch', c.id)) })),
     ),
     ex.canCreateCollection
       ? div({ className: 'gate-actions' },
         button({ className: 'btn' }, icon('plus', { size: 14 }), 'New collection')
-          .on({ click: () => ui.exec('collections.create') }),
+          .on({ click: () => ui.engine.dispatch(new ExecCommandAction('collections.create')) }),
       )
       : null,
   );

package/packages/web/src/ui/components/commandPalette.js

@@ -4,31 +4,31 @@
 
 import { dd } from '../../runtime.js';
 import { icon, iconForNode } from '../icon.js';
-import { prettyKey } from '../../platform/keybindings.js';
-import { OpenFileAction, QuickOpenAction } from '../../bl/actions.js';
+import { ClosePaletteAction, ExecCommandAction, MovePaletteAction, OpenFileAction, QuickOpenAction, SetPaletteIndexAction, SetPaletteQueryAction } from '../../bl/actions.js';
 
 const { div, input, span } = dd;
 
 export default function commandPalette(state, ui) {
   const pal = state.overlay.palette;
   if (!pal) return null;
-  const wb = ui.platform.workbench;
   // With no query there is nothing to show — and showing the PREVIOUS session's hits
   // would be worse than nothing, since they don't match what the field now says.
+  // Already ranked — see the `paletteMatches` query. The palette used to score and sort
+  // here, with its own fuzzy algorithm that disagreed with the launcher's.
   const items = pal.mode === 'files'
     ? (pal.query.trim() ? state.se.paletteFiles || [] : [])
-    : filterCommands(state, ui, pal.query);
+    : state.matches || [];
   const index = Math.min(pal.index, Math.max(0, items.length - 1));
 
   const run = (item) => {
     if (!item) return;
-    wb.closePalette();
-    if (pal.mode === 'files') ui.go(new OpenFileAction(item.node));
-    else ui.exec(item.id);
+    ui.engine.dispatch(new ClosePaletteAction());
+    if (pal.mode === 'files') ui.engine.dispatch(new OpenFileAction(item.node));
+    else ui.engine.dispatch(new ExecCommandAction(item.id));
   };
 
   return div({},
-    div({ className: 'scrim' }).on({ click: () => wb.closePalette() }),
+    div({ className: 'scrim' }).on({ click: () => ui.engine.dispatch(new ClosePaletteAction()) }),
     div({ className: 'palette' },
       div({ className: 'search' },
         icon(pal.mode === 'files' ? 'search' : 'command', { size: 18 }),
@@ -54,7 +54,7 @@ export default function commandPalette(state, ui) {
       div({ className: 'results' },
         items.length
           ? items.map((item, i) => {
-            const hover = () => wb.setPaletteIndex(i);
+            const hover = () => ui.engine.dispatch(new SetPaletteIndexAction(i));
             return pal.mode === 'files' ? fileOpt(item, i === index, run, hover) : cmdOpt(item, i === index, ui, run, hover);
           })
           : emptyResults(pal, state),
@@ -72,23 +72,19 @@ function emptyResults(pal, state) {
   return div({ className: 'none' }, pal.query.trim() ? 'No files found' : 'Type to search files by name');
 }
 
+// Everything here arrives decided — see the paletteCommands view query. This used to ask
+// the keybinding service for a label, then throw the label away and re-resolve the raw key
+// to prettify it again, which was two lookups to render one `<kbd>`.
 function cmdOpt(cmd, active, ui, run, hover) {
-  const key = ui.platform.keybindings.labelFor(cmd.id);
-  const available = ui.platform.commands.isAvailable(cmd);
-  return div({ className: `opt ${active ? 'active' : ''} ${available ? '' : 'unavailable'}` },
+  return div({ className: `opt ${active ? 'active' : ''} ${cmd.available ? '' : 'unavailable'}` },
     span({ className: 'ico' }, icon(cmd.icon || 'command', { size: 16 })),
     cmd.category ? span({ className: 'cat' }, cmd.category + ' ›') : null,
     span({ className: 'title' }, cmd.title),
-    !available ? span({ className: 'offline-tag' }, 'offline') : null,
-    key ? span({ className: 'kbd' }, dd.h('kbd', prettyKey(keyRaw(ui, cmd.id)))) : null,
+    !cmd.available ? span({ className: 'offline-tag' }, 'offline') : null,
+    cmd.keybinding ? span({ className: 'kbd' }, dd.h('kbd', cmd.keybinding)) : null,
   ).on({ click: () => run(cmd), mouseenter: hover });
 }
 
-function keyRaw(ui, id) {
-  const b = ui.platform.keybindings.resolved().find((x) => x.command === id);
-  return b ? b.key : '';
-}
-
 function fileOpt(item, active, run, hover) {
   return div({ className: `opt ${active ? 'active' : ''}` },
     span({ className: 'ico' }, icon(iconForNode(item.node), { size: 16 })),
@@ -97,58 +93,31 @@ function fileOpt(item, active, run, hover) {
   ).on({ click: () => run(item), mouseenter: hover });
 }
 
-function filterCommands(state, ui, query) {
-  const all = ui.platform.commands.paletteCommands();
-  const q = query.trim().toLowerCase();
-  if (!q) return all.slice(0, 60);
-  const scored = [];
-  for (const c of all) {
-    const hay = `${c.category || ''} ${c.title}`.toLowerCase();
-    const s = fuzzyScore(hay, q);
-    if (s > 0) scored.push([s, c]);
-  }
-  return scored.sort((a, b) => b[0] - a[0]).slice(0, 60).map((x) => x[1]);
-}
 
-function fuzzyScore(hay, q) {
-  let score = 0;
-  let hi = 0;
-  for (const ch of q) {
-    const idx = hay.indexOf(ch, hi);
-    if (idx < 0) return 0;
-    score += idx === hi ? 3 : 1;
-    hi = idx + 1;
-  }
-  if (hay.includes(q)) score += 10;
-  return score;
-}
 
 function onKey(e, ui, items, index, run) {
-  const wb = ui.platform.workbench;
   if (e.key === 'ArrowDown') {
     e.preventDefault();
-    wb.movePalette(1, items.length);
+    ui.engine.dispatch(new MovePaletteAction(1, items.length));
   } else if (e.key === 'ArrowUp') {
     e.preventDefault();
-    wb.movePalette(-1, items.length);
+    ui.engine.dispatch(new MovePaletteAction(-1, items.length));
   } else if (e.key === 'Enter') {
     e.preventDefault();
     run(items[index]);
   } else if (e.key === 'Escape') {
     e.preventDefault();
-    wb.closePalette();
+    ui.engine.dispatch(new ClosePaletteAction());
   }
 }
 
 let fileTimer = null;
 function onQuery(ui, value) {
-  const wb = ui.platform.workbench;
-  wb.setPaletteQuery(value);
-  // The palette's CURRENT mode, not whichever one was on screen when this listener
-  // was created — see the note at the input.
+  ui.engine.dispatch(new SetPaletteQueryAction(value));
   clearTimeout(fileTimer);
-  if (wb.overlay.state.palette?.mode !== 'files') return;
-  // Route the file search through an action; results land in the reactive search
-  // service (state.se.paletteFiles), so the palette re-renders without ad-hoc state.
-  fileTimer = setTimeout(() => ui.go(new QuickOpenAction(value)), 200);
+  // The mode guard moved into QuickOpenAction, where "current" means current: the timer
+  // below outlives the render that set it, so checking here would test a stale mode.
+  // Results land in the search service (state.se.paletteFiles), so the palette re-renders
+  // without ad-hoc state.
+  fileTimer = setTimeout(() => ui.engine.dispatch(new QuickOpenAction(value)), 200);
 }

package/packages/web/src/ui/components/editorArea.js

@@ -8,7 +8,8 @@
 import { dd } from '../../runtime.js';
 import { icon, iconForNode } from '../icon.js';
 import { renderOpener } from './openers/index.js';
-import { availableOpeners } from '../../bl/openers.js';
+import { openersFor } from '../../bl/openers.js';
+import { NavigateBackAction, OpenInPanelAction, ShowDialogAction, ShowHomeAction, ToggleInfoPanelAction } from '../../bl/actions.js';
 
 const { div, span, button } = dd;
 
@@ -21,30 +22,29 @@ export default function editorArea(state, ui) {
   const active = files[files.length - 1];
   if (!active) return div({ className: 'editor' });
   return div({ className: 'editor' },
-    navBar(files, active, ui),
+    navBar(files, active, state, ui),
     div({ className: 'stage' }, openerHost(active, ui)),
   );
 }
 
-function navBar(files, active, ui) {
-  const w = ui.platform.workbench;
+function navBar(files, active, state, ui) {
   return div({ className: 'viewer-nav' },
     button({ className: 'vn-back', title: 'Back (Esc)' }, icon('chevron-left', { size: 16 }))
-      .on({ click: () => w.back() }),
+      .on({ click: () => ui.engine.dispatch(new NavigateBackAction()) }),
     div({ className: 'vn-trail' },
       button({ className: 'vn-crumb' }, icon('search', { size: 13 }), span('Search'))
-        .on({ click: () => w.showHome() }),
+        .on({ click: () => ui.engine.dispatch(new ShowHomeAction()) }),
       ...files.map((p) =>
         button({ className: `vn-crumb ${p.id === active.id ? 'active' : ''}`, title: p.node.name },
           icon(iconForNode(p.node), { size: 13 }), span({ className: 'label' }, p.node.name))
-          .on({ click: () => w.openFile(p.node, p.openerId) })),
+          .on({ click: () => ui.engine.dispatch(new OpenInPanelAction(p.node, p.openerId)) })),
     ),
     div({ className: 'vn-actions' },
-      openerSwitch(active, ui),
+      openerSwitch(active, state, ui),
       button({ className: 'iconbtn', title: 'Details & comments' }, icon('info', { size: 15 }))
-        .on({ click: () => w.toggleInfoPanel() }),
+        .on({ click: () => ui.engine.dispatch(new ToggleInfoPanelAction()) }),
       button({ className: 'iconbtn', title: 'Close (Esc)' }, icon('close', { size: 15 }))
-        .on({ click: () => w.showHome() }),
+        .on({ click: () => ui.engine.dispatch(new ShowHomeAction()) }),
     ),
   );
 }
@@ -52,11 +52,14 @@ function navBar(files, active, ui) {
 // "Open with…" — shown only when more than one opener can handle this file. Opens
 // the chooser (pre-selected to the current opener) so the user can switch viewers,
 // and optionally make the choice their default for this file type.
-function openerSwitch(active, ui) {
-  const openers = availableOpeners(ui.platform, active.node);
+function openerSwitch(active, state, ui) {
+  // `state.openers` has already had its when-clauses and plugin health resolved by the
+  // query; matching them against THIS file is pure. That split is why this no longer
+  // reaches for the contribution registry mid-render.
+  const openers = openersFor(state.openers, active.node);
   if (openers.length <= 1) return null;
   return button({ className: 'iconbtn', title: 'Open with…' }, icon('dots', { size: 15 }))
-    .on({ click: () => ui.platform.workbench.showDialog({ kind: 'opener-chooser', node: active.node, openers, current: active.openerId }) });
+    .on({ click: () => ui.engine.dispatch(new ShowDialogAction({ kind: 'opener-chooser', node: active.node, openers, current: active.openerId })) });
 }
 
 function openerHost(panel, ui) {