@3sln/trove 0.0.7 → 0.0.9

package/packages/web/src/platform/context.js

@@ -1,74 +1,169 @@
-// ContextKeyService — the reactive bag of boolean/string/number flags that
-// describe the workbench's current state (which view is focused, whether a file
-// is open, its type, whether the palette is showing…). when-clauses evaluate
-// against it, so commands/keybindings/menus light up and dim as state changes.
+// ContextRegistry — the named facts a when-clause is evaluated against.
 //
-// It's a single cell of the whole context object, so any consumer can `watch` it and
-// re-render, and keybinding resolution reads a plain snapshot.
-// Plugins get a *scoped* setter (keys they set are namespaced under their id) so
-// they can drive their own when-clauses without stomping core keys.
+// A REGISTRY of cells, not a bag of values, and the difference is the whole design:
+//
+//   - Every key is backed by a cell somebody OWNS. The registry never hands the cell out,
+//     only its value, so a key can be read by anyone and written by exactly one thing.
+//   - A contributor registers while it exists and unregisters when it is disposed, so the
+//     set of keys is a fact about what is currently installed rather than a pile that only
+//     grows.
+//   - Because the backings are cells, a derived layer sits on top for free: a built-in key
+//     is a `derive` over the resource it summarises, and so cannot go stale.
+//
+// That last point is why this replaced a plain map with setters. Context keys are DERIVED
+// state — what is selected, what is open, what is focused — and they were maintained by
+// pushing: OverlayService wrote `palette.open` as a side effect of opening the palette,
+// NavigationService wrote three `editor.*` keys, WorkbenchService four more, ViewportService
+// three, and an effect in bl/index.js the explorer's two. Five writers for one derivation,
+// and the bug that shape produces is on the record: selecting a file never flipped
+// `explorer.hasSelection`, so the Delete keybinding silently did nothing, because only
+// NavigateAction had been taught to set it. The fix at the time was to add another writer.
+//
+// Nothing sets a built-in key now. They are derived — see bl/context.js.
+
+import { cell, derive } from '../runtime.js';
+import { evaluateWhen, compileWhen } from './whenclause.js';
 
-import { cell } from '../runtime.js';
-import { evaluateWhen } from './whenclause.js';
+/** A cell whose value never changes — for facts about the machine rather than the drive. */
+const constant = (value) => ({ onDirty: () => () => {}, getValue: () => value });
+
+export class ContextRegistry {
+  #cells = new Map(); // key -> a Cell its owner holds
+  #offs = new Map(); // key -> unsubscribe
+  #slots = new Map(); // key -> a stable cell that outlives any one owner
+  #snapshot = cell({});
 
-export class ContextKeyService {
   constructor(initial = {}) {
-    this.state = {
+    const fixed = {
       platform: navigatorPlatform(),
       isMac: /mac/i.test(navigatorPlatform()),
       ...initial,
     };
-    this.cell = cell(this.state);
+    for (const [key, value] of Object.entries(fixed)) this.register(key, constant(value));
   }
 
-  get(key) {
-    return this.state[key];
+  /**
+   * Back `key` with a cell. Returns the unregister function.
+   *
+   * The caller keeps the cell, and that is what makes it the owner: writing means writing
+   * something the registry cannot reach. Registering a key twice is refused rather than
+   * silently taken over — two owners for one fact is exactly the confusion this shape
+   * exists to prevent, so it should be loud.
+   *
+   * @param {string} key
+   * @param {{onDirty: Function, getValue: Function}} source
+   * @returns {() => void} unregister
+   */
+  register(key, source) {
+    if (this.#cells.has(key)) {
+      throw new Error(`Context key "${key}" already has an owner`);
+    }
+    this.#cells.set(key, source);
+    this.#offs.set(key, source.onDirty(() => this.#changed(key)));
+    this.#changed(key); // gaining an owner is itself a change
+    return () => this.unregister(key);
   }
-  snapshot() {
-    return this.state;
+
+  unregister(key) {
+    const off = this.#offs.get(key);
+    if (!off) return;
+    off();
+    this.#offs.delete(key);
+    this.#cells.delete(key);
+    this.#changed(key); // and so is losing one
   }
-  observe() {
-    return this.cell;
+
+  /**
+   * A cell for one key, whether or not anything owns it yet.
+   *
+   * The indirection is the point. A keymap naming a plugin's register is parsed long before
+   * that plugin installs, and the plugin may later be uninstalled — so a watcher cannot
+   * hold the OWNER's cell, which does not exist at either end. It holds this slot, which
+   * reads through to whoever currently owns the key and goes dirty when ownership changes
+   * as well as when the value does. Unowned reads as `undefined`, which every clause
+   * already treats as falsy.
+   *
+   * Slots are kept once created. They are bounded by the number of distinct keys any
+   * when-clause has ever named, which is small and does not grow with use.
+   */
+  cellFor(key) {
+    let slot = this.#slots.get(key);
+    if (!slot) {
+      const listeners = new Set();
+      slot = {
+        listeners,
+        onDirty: (fn) => { listeners.add(fn); return () => listeners.delete(fn); },
+        getValue: () => this.#cells.get(key)?.getValue(),
+      };
+      this.#slots.set(key, slot);
+    }
+    return slot;
   }
 
-  set(key, value) {
-    if (this.state[key] === value) return;
-    this.state = { ...this.state, [key]: value };
-    this.cell.setValue(this.state);
+  /**
+   * A when-clause as a live boolean.
+   *
+   * Derived over exactly the keys the expression NAMES (the parser collects them — see
+   * whenclause.js), so a clause about `view.active` does not recompute when the selection
+   * changes. That is the difference from `evaluate`, which reads the whole snapshot: a
+   * consumer holding many clauses — the palette holds one per registered command — stops
+   * re-running all of them on every unrelated change.
+   *
+   * A clause naming nothing derives over nothing and is computed once, which is right: a
+   * constant cannot become false.
+   */
+  watch(expr) {
+    const predicate = compileWhen(expr);
+    const keys = predicate.keys ?? [];
+    return derive(keys.map((key) => this.cellFor(key)), (...values) => {
+      const ctx = {};
+      for (let i = 0; i < keys.length; i++) ctx[keys[i]] = values[i];
+      return predicate(ctx);
+    });
   }
-  setMany(obj) {
-    let changed = false;
-    const next = { ...this.state };
-    for (const [k, v] of Object.entries(obj)) {
-      if (next[k] !== v) {
-        next[k] = v;
-        changed = true;
-      }
-    }
-    if (changed) {
-      this.state = next;
-      this.cell.setValue(next);
-    }
+
+  #changed(key) {
+    this.#recompute();
+    const slot = this.#slots.get(key);
+    if (slot) for (const fn of [...slot.listeners]) fn();
   }
-  remove(key) {
-    if (!(key in this.state)) return;
-    const { [key]: _drop, ...rest } = this.state;
-    this.state = rest;
-    this.cell.setValue(rest);
+
+  /**
+   * Own a key outright: the registry makes the cell and hands back the writer.
+   *
+   * For the facts that genuinely are pushed rather than derived — a plugin setting its own
+   * declared register over RPC. The write capability IS the returned `set`, so holding a
+   * reference to the registry is not enough to change anything.
+   */
+  own(key, initial = undefined) {
+    const held = cell(initial);
+    const dispose = this.register(key, held);
+    return { set: (value) => held.setValue(value), dispose };
   }
 
-  /** True if `whenExpr` holds against the current context. */
-  evaluate(whenExpr) {
-    return evaluateWhen(whenExpr, this.state);
+  #recompute() {
+    const next = {};
+    for (const [key, source] of this.#cells) next[key] = source.getValue();
+    this.#snapshot.setValue(next);
   }
 
-  /** A setter namespaced under a plugin id, so plugin keys can't collide. */
-  scopedFor(pluginId) {
-    const prefix = `${pluginId}.`;
-    return {
-      set: (key, value) => this.set(prefix + key, value),
-      remove: (key) => this.remove(prefix + key),
-    };
+  /** Every key and its current value. */
+  snapshot() {
+    return this.#snapshot.getValue();
+  }
+  get(key) {
+    return this.#cells.get(key)?.getValue();
+  }
+  has(key) {
+    return this.#cells.has(key);
+  }
+  observe() {
+    return this.#snapshot;
+  }
+
+  /** True if `whenExpr` holds against the current context. */
+  evaluate(whenExpr) {
+    return evaluateWhen(whenExpr, this.snapshot());
   }
 }
 

package/packages/web/src/platform/index.js

@@ -1,20 +1,21 @@
 // createPlatform — assemble every service into one object the whole app shares.
-// This is the "workbench platform": the reactive registries and services that
-// core features and plugins both build on. It also registers the default
-// settings schema and keybindings so the shell has sensible behaviour out of the
-// box. UI-facing shell state (which activity is open, is the palette showing…)
-// lives in WorkbenchService; data and mutations go through ngin (see ../bl).
+// This is the "workbench platform": the reactive registries and services that core
+// features and plugins both build on. It also registers the default settings schema and
+// keybindings so the shell has sensible behaviour out of the box.
+//
+// It does NOT hold the shell's state. Which activity is open, whether the palette is
+// showing, what is on the panel stack — those are engine resources, built by createApp
+// (see ../bl/state.js). The platform is the machinery underneath them.
 
 import { reactive } from '../runtime.js';
 import { ContributionRegistry } from './contributions.js';
-import { ContextKeyService } from './context.js';
+import { ContextRegistry } from './context.js';
 import { CommandService } from './commands.js';
 import { KeybindingService } from './keybindings.js';
 import { SettingsService } from './settings.js';
 import { NotificationService } from './notifications.js';
 import { TroveApiClient } from './api.js';
 import { PluginHost } from './pluginHost.js';
-import { WorkbenchService } from './workbench.js';
 import { ViewportService } from './viewport.js';
 import { SpatialNavigationService } from './spatialNav.js';
 import { VoiceSearchService } from './voiceSearch.js';
@@ -42,12 +43,18 @@ export function writeToken(token) {
 
 export function createPlatform({ baseUrl = '' } = {}) {
   const contributions = new ContributionRegistry();
-  // 'home' is where the app actually starts (WorkbenchService's initial `activity`), and
-  // nothing writes this key until the user navigates. Seeding it with a view that no
-  // longer exists left every `when: view.active == 'home'` binding — the Delete
-  // shortcut among them — dead from boot until the first click on the rail, while the
-  // row menu cheerfully advertised "Del" as the way to delete.
-  const context = new ContextKeyService({ 'view.active': 'home', 'sidebar.visible': true });
+  // Only the fixed facts are seeded. Everything else is registered by whoever owns it —
+  // the built-in keys are derived from the shell and the drive (see bl/context.js), so
+  // there is nothing sensible to pre-fill them with and nothing that would go stale if
+  // there were.
+  //
+  // It used to be seeded with `view.active: 'home'` for a reason worth remembering: nothing
+  // wrote that key until the user navigated, so every `when: view.active == 'home'`
+  // binding — the Delete shortcut among them — was dead from boot until the first click on
+  // the rail, while the row menu cheerfully advertised "Del" as the way to delete. A
+  // derived key is never unwritten, so the seed is not needed and cannot drift from the
+  // state it was standing in for.
+  const context = new ContextRegistry();
   const notifications = new NotificationService();
   const commands = new CommandService(contributions, context, notifications);
   const settings = new SettingsService();
@@ -57,22 +64,22 @@ export function createPlatform({ baseUrl = '' } = {}) {
   // But a deployment where the user HOLDS a token has no other way to present it, and
   // reading it here — once, from one place — keeps that out of every call site.
   const api = new TroveApiClient({ baseUrl, token: () => readToken() });
-  const workbench = new WorkbenchService(context);
   // Which shell to render — phone, desktop, or TV. Constructed before the defaults are
   // registered, so it reads the setting through `settings.get` once that exists.
-  const viewport = new ViewportService({ settings, context });
+  const viewport = new ViewportService({ settings });
   // Arrow keys → geometry, but only on a TV. Inert everywhere else.
-  const spatialNav = new SpatialNavigationService({ workbench, viewport });
+  const spatialNav = new SpatialNavigationService({ viewport });
   // Speak to search. Mostly this just puts the search field under the remote's mic —
   // see voiceSearch.js for why that is the whole feature on a TV.
-  const voice = new VoiceSearchService({ workbench, notifications, settings });
+  const voice = new VoiceSearchService({ notifications, settings });
 
   const platform = {
     reactive,
-    contributions, context, commands, keybindings, settings, notifications, api, workbench,
+    contributions, context, commands, keybindings, settings, notifications, api,
     viewport, spatialNav, voice,
-    capabilities: null,
-    openPluginPanel: null, // set by the workbench UI
+    // The shell's own state is the engine's, not the platform's — createApp builds it and
+    // hands back what the few imperative edges below still need.
+    openPluginPanel: null,
   };
   platform.mediaUrls = new MediaUrlService({ api: platform.api, settings });
   platform.plugins = new PluginHost(platform);

package/packages/web/src/platform/navigation.js

@@ -11,8 +11,7 @@ const RECENTS_KEY = 'trove.recents';
 const RECENTS_MAX = 12;
 
 export class NavigationService {
-  constructor(context) {
-    this.context = context;
+  constructor() {
     this.state = {
       stack: [{ kind: 'search' }], // [{kind:'search'}, {kind:'file', id, node, openerId}, …]
       activeTabId: null, // top file panel id (or null)
@@ -43,7 +42,6 @@ export class NavigationService {
     const top = stack[stack.length - 1];
     const file = top && top.kind === 'file' ? top : null;
     this.#set({ stack, activeTabId: file ? file.id : null, activeFile: file ? file.node : null });
-    this.context.setMany({ 'editor.open': !!file, 'editor.openerId': file?.openerId || '', 'editor.contentType': file?.node.contentType || '' });
     if (history) this.#pushHistory();
   }
 
@@ -83,11 +81,43 @@ export class NavigationService {
   pop() {
     if (this.state.stack.length > 1) this.#applyStack(this.state.stack.slice(0, -1), { history: false });
   }
-  closeTab(id) {
+  /**
+   * The node is GONE — drop it from everywhere this service holds a copy.
+   *
+   * Named for what happened rather than for the stack, because it was `closeTab` and so
+   * only closed the panel: a deleted file kept its recent tile, and clicking that tile
+   * opened nothing. Recents are a snapshot, not a reference, so nothing else was ever
+   * going to notice.
+   *
+   * Trashing is reversible and this is not, quite: restoring a file does not put it back
+   * in recents, it just stops being listed until opened again. That is the right way
+   * round — a tile that leads nowhere is worse than one that is missing.
+   */
+  forget(id) {
+    const recents = this.state.recents.filter((r) => r.id !== id);
+    if (recents.length !== this.state.recents.length) {
+      this.#set({ recents });
+      saveRecents(recents);
+    }
     const stack = this.state.stack.filter((p) => !(p.kind === 'file' && p.id === id));
     this.#applyStack(stack.length ? stack : [{ kind: 'search' }], { history: false });
   }
+  /**
+   * A node changed underneath us — a rename — so every copy of it here has to change.
+   *
+   * BOTH the stack and the recents list, because recents hold a SNAPSHOT (id, name,
+   * contentType) rather than a reference: updating only the stack renamed the open panel's
+   * title and left the recent tile showing the old name until it aged off the end of the
+   * list, which reads as the rename half-failing.
+   */
   updateTabNode(node) {
+    const recents = this.state.recents.map((r) => (r.id === node.id
+      ? { ...r, name: node.name, contentType: node.contentType || r.contentType }
+      : r));
+    if (recents.some((r, i) => r !== this.state.recents[i])) {
+      this.#set({ recents });
+      saveRecents(recents);
+    }
     const stack = this.state.stack.map((p) => (p.kind === 'file' && p.id === node.id ? { ...p, node } : p));
     this.#applyStack(stack, { history: false });
   }

package/packages/web/src/platform/pickers.js

@@ -0,0 +1,46 @@
+// The two things only the browser can do: ask for a file, and save one.
+//
+// These are effects, so they are reached from actions rather than from a render — but they
+// are effects on the DOCUMENT rather than on the drive, which is why they live in
+// `platform` and not in `bl`. An action that needs a file from the user calls in here; the
+// action is still the thing that decides what happens to it.
+//
+// They were private to bl/commands.js, where the command handlers that used them lived.
+
+/**
+ * Open a native file picker.
+ *
+ * The hidden `<input>` is removed on selection AND on cancel — cancelling fires no
+ * `change`, so cleanup also hangs off the next window focus (which the OS dialog returns)
+ * to avoid leaking a growing pile of inputs.
+ */
+function pick(cb, configure) {
+  const input = document.createElement('input');
+  input.type = 'file';
+  configure(input);
+  input.style.display = 'none';
+  document.body.appendChild(input);
+  const cleanup = () => { input.remove(); window.removeEventListener('focus', onFocus); };
+  const onFocus = () => setTimeout(() => { if (!input.files.length) cleanup(); }, 300);
+  input.addEventListener('change', () => { cb(input.files); cleanup(); }, { once: true });
+  window.addEventListener('focus', onFocus);
+  input.click();
+}
+
+export function pickFiles(cb) {
+  pick((files) => cb(files), (input) => { input.multiple = true; });
+}
+
+export function pickZip(cb) {
+  pick((files) => cb(files[0]), (input) => { input.accept = '.zip,application/zip'; });
+}
+
+/** Hand a URL to the browser as a download. */
+export function triggerDownload(url, name) {
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = name || '';
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+}

package/packages/web/src/platform/pluginHost.js

@@ -27,6 +27,7 @@ import { pluginId, contribUri } from '@3sln/trove/core/plugins/identity.js';
 import { endpointSummary } from './pluginNet.js';
 import { MediaController } from './pluginMedia.js';
 import { FrameDock } from './pluginDock.js';
+import { InvokePluginCommandAction, OpenInPanelAction } from '../bl/actions.js';
 import { FrameManager } from './pluginFrames.js';
 import { PluginRpcRouter } from './pluginRpc.js';
 // The canonical capability list lives in core (the server's authority); import it so
@@ -54,7 +55,9 @@ export class PluginHost {
     this.media = new MediaController();
     this.dock = new FrameDock({
       destroyFrame: (frame) => this.frames.destroy(frame),
-      openFile: (node, openerId) => this.platform.workbench.openFile(node, openerId),
+      // Dispatched, not called: opening a file from a docked plugin frame is the same
+      // intent as opening one from the drive, and the engine should see both.
+      openFile: (node, openerId) => this.platform.dispatch?.(new OpenInPanelAction(node, openerId)),
       onChange: () => this.#emit(),
     });
     this.frames = new FrameManager({ media: this.media, dock: this.dock });
@@ -107,15 +110,19 @@ export class PluginHost {
           if (runtime.grants.includes('opener')) keep(reg.register(c.uri, base));
           break;
 
-        // Declared, implemented by the plugin's primary frame. The handler proxies
-        // over RPC using the contribution's short name — inside its own frame a
-        // plugin addresses its commands by name, not by URI.
+        // Declared, implemented by the plugin's primary frame. Addressed over RPC by the
+        // contribution's short NAME — inside its own frame a plugin addresses its commands
+        // by name, not by URI.
         case 'command':
           keep(this.platform.commands.register({
             id: c.uri, title: c.title || `${label}: ${c.name}`,
             category: c.category || label, icon: c.icon,
             when: c.when, offline: c.offline, palette: c.palette, pluginId: pid,
-            handler: (...args) => runtime.channel?.call('command:execute', { id: c.name, args }),
+            // A description, like every other command. It used to be a closure over
+            // `runtime` proxying straight to the channel, which left a plugin command
+            // running invisible to the engine — the same hole ExecCommandAction closed for
+            // the host's own commands, still open for everyone else's.
+            actions: (...args) => new InvokePluginCommandAction(pid, c.name, args),
           }));
           break;
 
@@ -133,13 +140,20 @@ export class PluginHost {
           break;
         }
 
-        // A context value slot. Seed the context with its declared default so
-        // when-clauses referencing it evaluate sensibly before the plugin runs.
-        case 'register':
+        // A context value slot — the one kind of key that genuinely is PUSHED rather than
+        // derived, because only the plugin knows what it means. Owned here, on the
+        // plugin's behalf: the registry hands back a writer, which goes on the runtime
+        // record so `context:setRegister` can reach it and nothing else can.
+        //
+        // Seeded with its declared default so when-clauses referencing it evaluate
+        // sensibly before the plugin has run at all.
+        case 'register': {
           keep(reg.register(c.uri, base));
-          this.platform.context.set(c.uri, c.default);
-          keep(() => this.platform.context.remove(c.uri));
+          const owned = this.platform.context.own(c.uri, c.default);
+          runtime.registers.set(c.uri, owned.set);
+          keep(() => { runtime.registers.delete(c.uri); owned.dispose(); });
           break;
+        }
 
         // A keymap JSON file inside the package. Read + validated here, at register
         // time, so a malformed keymap is a visible install-time problem rather than a
@@ -373,6 +387,10 @@ export class PluginHost {
     if (this.plugins.get(record.id)?.status === 'active') return;
     const runtime = {
       ...record, iframe: null, status: 'loading', error: null, disposers: [], channel: null,
+      // Writers for the context registers this plugin DECLARED, keyed by contribution URI.
+      // Holding them here is what makes "a plugin may only set its own registers" structural
+      // rather than a check: there is no setter for a key it did not declare.
+      registers: new Map(),
       hasUi: false, responsive: false, frame: null, frames: new Set(),
       // Storage scopes (defaulted for records saved before this field existed).
       storage: record.storage || (record.grants?.includes('storage') ? grantedStorageScopes(record.manifest, record.trust) : { plugin: false, domain: false }),
@@ -445,6 +463,21 @@ export class PluginHost {
       this._probing = false;
     }
   }
+  /**
+   * Run one of a plugin's own commands, in its frame.
+   *
+   * Public because `InvokePluginCommandAction` is what reaches it now, rather than a closure
+   * captured at registration. Addressed by short NAME: the URI is the host's way of keeping
+   * two plugins' `status` commands apart and means nothing on the other side.
+   *
+   * A plugin that is not running answers undefined rather than throwing. Its commands are
+   * already filtered out of the palette by `isAvailable`, so getting here at all means a
+   * stale reference, which is not worth an error.
+   */
+  invokeCommand(pluginId, name, args = []) {
+    return this.plugins.get(pluginId)?.channel?.call('command:execute', { id: name, args });
+  }
+
   setHeartbeat(ms) {
     this.heartbeatMs = ms;
     this.#stopHeartbeat();

package/packages/web/src/platform/pluginRpc.js

@@ -112,7 +112,11 @@ export class PluginRpcRouter {
       // can read, addressed by its contribution URI.
       case 'context:setRegister': {
         const slot = this.#ownContribution(record, params.name, 'register');
-        this.platform.context.set(slot.uri, params.value);
+        // The writer for a register the plugin declared. There is no path to a key it did
+        // not declare, because it was never handed a setter for one.
+        const write = record.registers?.get(slot.uri);
+        if (!write) throw new Error(`Register "${params.name}" is not available`);
+        write(params.value);
         return { ok: true };
       }
       // Package resources — opaque byte handles (transferred, no host URLs). Code
@@ -170,7 +174,7 @@ export class PluginRpcRouter {
       case 'ui:showPanel':
         cap('ui');
         record.hasUi = true;
-        this.platform.openPluginPanel?.(pid);
+        this.platform.openPluginPanel(pid);
         this.onChange();
         return { ok: true };
 

package/packages/web/src/platform/spatialNav.js

@@ -43,12 +43,10 @@ const ACTIVATES_ITSELF = new Set(['A', 'BUTTON', 'INPUT', 'SELECT', 'TEXTAREA'])
 export class SpatialNavigationService {
   /**
    * @param {object} deps
-   * @param {import('./workbench.js').WorkbenchService} deps.workbench
    * @param {import('./viewport.js').ViewportService} deps.viewport
    * @param {Window} [deps.window]
    */
   constructor({ workbench, viewport, window: win = globalThis }) {
-    this.workbench = workbench;
     this.viewport = viewport;
     this.window = win;
     this.active = false;

package/packages/web/src/platform/viewport.js

@@ -33,12 +33,10 @@ export class ViewportService {
    * @param {object} [deps]
    * @param {Window} [deps.window] the window to measure and listen to
    * @param {import('./settings.js').SettingsService} [deps.settings]
-   * @param {import('./context.js').ContextKeyService} [deps.context]
    */
-  constructor({ window: win = globalThis, settings = null, context = null } = {}) {
+  constructor({ window: win = globalThis, settings = null } = {}) {
     this.window = win;
     this.settings = settings;
-    this.context = context;
     // A URL override outranks the setting: it is how someone checks the phone layout on
     // a laptop, and how the e2e suite drives each shell without a device farm.
     this.urlOverride = readUrlOverride(win);
@@ -82,9 +80,6 @@ export class ViewportService {
   #publish(vp) {
     // Context keys so plugin `when` clauses and keybindings can target a form factor
     // the same way they target a view.
-    this.context?.set('viewport.mode', vp.mode);
-    this.context?.set('viewport.phone', vp.mode === 'phone');
-    this.context?.set('viewport.tv', vp.mode === 'tv');
     // The root element carries it too, so CSS can respond without every rule needing a
     // media query that would disagree with the JS branch above it.
     const el = this.window.document?.documentElement;

package/packages/web/src/platform/voiceSearch.js

@@ -19,11 +19,9 @@ import { canTranscribeLocally, localAvailability, installLocal, listen } from '.
 export class VoiceSearchService {
   /**
    * @param {object} deps
-   * @param {import('./workbench.js').WorkbenchService} deps.workbench
    * @param {object} deps.notifications
    */
-  constructor({ workbench, notifications, settings } = {}) {
-    this.workbench = workbench;
+  constructor({ notifications, settings } = {}) {
     this.notifications = notifications;
     this.settings = settings;
     this.session = null;