@3sln/trove 0.0.11 → 0.0.13

package/packages/web/src/bl/queries.js

@@ -7,10 +7,14 @@
 // observers", `boot`/`kill` bracket a query's life, and a lease holds the providers it needs
 // for exactly that long.
 //
-// This is step one of moving onto it (docs/tickets/009). Each query here wraps the service
-// that exists today, so nothing in the UI has to change yet and the two describe the same
-// state rather than competing to. The services are deleted in a later phase, at which point
-// these stop wrapping and simply hold.
+// That move is DONE. The state bags became slices (see bl/state.js) and most of these
+// queries now view a slice rather than wrapping a service — which is why the base class is
+// `CellQuery`: one cell, viewed, whatever is behind it. `ViewQuery` is the other shape,
+// composing several cells into an answer the UI actually asks for.
+//
+// Four resources stayed services because they cover something a state bag cannot — history
+// and recents, polling, a queue that replays on reconnect — and they answer `get()` and
+// `observe()` like everything else, so a query cannot tell which it is looking at.
 //
 // INSTANCE IDENTITY IS THE SHARING KEY. ngin keys live realizations by the query INSTANCE —
 // `#controllers` is a Map keyed on the object — and nothing anywhere looks at the class or
@@ -32,7 +36,10 @@
 import { Query } from '@3sln/ngin';
 import { queryOf } from './intern.js';
 import { selectedNodesOf, draftScopesOf, collectionMenuOf, collectionAdminOf } from './services.js';
-import { ExecCommandAction, LoadSidecarAction, ClearSidecarAction, LoadRotationAction, LoadGrantsAction, ShowCollectionAccessAction } from './actions.js';
+import {
+  ExecCommandAction, LoadSidecarAction, ClearSidecarAction, LoadRotationAction, LoadGrantsAction,
+  LoadApiKeysAction, ShowCollectionAccessAction,
+} from './actions.js';
 import { ASSOC_KEY, describeOpener } from './openers.js';
 import { rankCommands } from './match.js';
 import { statusFactsOf, driveConditionOf } from './status.js';
@@ -41,20 +48,22 @@ import { pickView } from './views.js';
 import { prettyKey } from '../platform/keybindings.js';
 
 /**
- * A live query over one of the existing cell-backed services.
- *
- * The service exposes dodo's Cell protocol — `onDirty(fn)` to learn it changed, `getValue()`
- * to read it — and a query wants push. Bridging is two lines, so rather than write them per
- * service this takes the cell as a function of the leased `app`.
- *
- * It reads the CELL, never the service's own `state` field. Most services keep both in step
- * (`this.state = {...}; this.cell.setValue(this.state)`) so the two usually agree, but not
- * all of them do — `settings`' cell holds `effective()`, the defaults merged with the
- * overrides, and there is no `state` field at all. The existing snapshot passes cells to
- * `derive`, which hands it their values; reading the same way is what makes these queries
- * and the snapshot describe the same state rather than two subtly different ones.
+ * A live query over ONE cell — whatever holds it.
+ *
+ * Named for what it does rather than for what used to be behind it: most of these view a
+ * slice now, not a service, and `ServiceQuery` told a reader its dep was a service when
+ * usually it is not. `ViewQuery` below is the other shape, composing several cells.
+ *
+ * The resource exposes dodo's Cell protocol — `onDirty(fn)` to learn it changed,
+ * `getValue()` to read it — and a query wants push. Bridging is two lines, so rather than
+ * write them per resource this takes the cell as a function of the leased one.
+ *
+ * It reads the CELL and nothing else. That is not a stylistic preference: `settings`' cell
+ * holds `effective()`, the defaults merged with the overrides, which no field anywhere
+ * holds. Reading the cell is what makes these queries and the shell's snapshot describe the
+ * same state rather than two subtly different ones.
  */
-class ServiceQuery extends Query {
+class CellQuery extends Query {
   /**
    * @param {string} dep the engine resource this views
    * @param {(resource: object) => {onDirty: Function, getValue: Function}} cellOf
@@ -66,12 +75,15 @@ class ServiceQuery extends Query {
    * @param {string} dep the engine resource this views
    * @param {(resource: object) => {onDirty: Function, getValue: Function}} cellOf
    * @param {(value: any, resource: object) => any} [project] shape the value into a view
+   * @param {{bootAction?: object}} [opts] dispatched when the first observer arrives — for
+   *   a value that has to be FETCHED before there is anything to view.
    */
-  constructor(dep, cellOf, project) {
+  constructor(dep, cellOf, project, { bootAction = null } = {}) {
     super();
     this.dep = dep;
     this.cellOf = cellOf;
     this.project = project;
+    if (bootAction) this.bootAction = bootAction;
   }
 
   /**
@@ -141,7 +153,7 @@ function release(resources, query) {
  * answer is the difference between a component knowing what is selected and a component
  * knowing how selection resolution works.
  */
-export const explorer = new ServiceQuery('explorer', (r) => r.observe(), (v) => ({
+export const explorer = new CellQuery('explorer', (r) => r.observe(), (v) => ({
   ...v,
   selectedNodes: selectedNodesOf(v),
   // The collection switcher's rows. In the view because it is a question about state, and
@@ -160,13 +172,13 @@ export const explorer = new ServiceQuery('explorer', (r) => r.observe(), (v) =>
   }),
 }));
 /** Query text, results, and the palette's file list. */
-export const search = new ServiceQuery('search', (r) => r.observe());
+export const search = new CellQuery('search', (r) => r.observe());
 /** Uploads and downloads in flight. */
-export const transfers = new ServiceQuery('transfers', (r) => r.observe());
+export const transfers = new CellQuery('transfers', (r) => r.observe());
 /** Running tasks and standing issues, both sides of the wire. */
-export const activity = new ServiceQuery('activity', (r) => r.observe());
+export const activity = new CellQuery('activity', (r) => r.observe());
 /** Conversations, tags and backlinks for the open item. */
-export const social = new ServiceQuery('social', (r) => r.observe());
+export const social = new CellQuery('social', (r) => r.observe());
 /**
  * Online state, pinned files, and the queue waiting to sync.
  *
@@ -174,7 +186,7 @@ export const social = new ServiceQuery('social', (r) => r.observe());
  * calling a method on the service to find out. A Set rather than a repeated scan: the
  * question is asked once per row.
  */
-export const offline = new ServiceQuery('offline', (r) => r.observe(),
+export const offline = new CellQuery('offline', (r) => r.observe(),
   (v) => ({ ...v, pinnedIds: new Set((v?.pins || []).map((p) => p.id)) }));
 /**
  * The open collection's key, and any rotation running over it.
@@ -198,7 +210,9 @@ class RotationView extends Query {
   constructor(collectionId) {
     super();
     this.collectionId = collectionId;
-    this.bootAction = new LoadRotationAction();
+    // The id is PASSED, so the load stops depending on `explorer` happening to agree with
+    // the query's key — which is what makes the key mean anything at all.
+    this.bootAction = new LoadRotationAction(collectionId);
   }
 
   boot(r, { notify }) {
@@ -206,7 +220,7 @@ class RotationView extends Query {
     notify(cell.getValue());
     const off = cell.onDirty(() => notify(cell.getValue()));
     const timer = setInterval(() => {
-      if (r.rotation.get().rotation?.status === 'running') r.engine.dispatch(new LoadRotationAction());
+      if (r.rotation.get().rotation?.status === 'running') r.engine.dispatch(new LoadRotationAction(this.collectionId));
     }, 2500);
     hold(r, this, [off, () => clearInterval(timer)]);
   }
@@ -246,22 +260,33 @@ class GrantsView extends Query {
   }
 }
 
-/** The admin API-key list, with the unsubmitted draft resolved into what it would grant. */
-export const apiKeys = new ServiceQuery('apiKeys', (r) => r.observe(),
-  (v) => ({ ...v, draftScopes: draftScopesOf(v) }));
+/**
+ * The admin API-key list, with the unsubmitted draft resolved into what it would grant.
+ *
+ * `bootAction`, like `rotationFor` and `grantsFor`: it loads when the settings region is
+ * first realized and the list is admin-only, so most sessions never ask. The alternative
+ * was what this section used to do — dispatch from inside a render behind a module-level
+ * "have I asked yet" flag, which is a render with a side effect, and module state the
+ * engine cannot see or reset. A second `createWorkbench` on the page (a documented
+ * embedding entry point) found the flag already true against a fresh slice and never
+ * loaded at all.
+ */
+export const apiKeys = new CellQuery('apiKeys', (r) => r.observe(),
+  (v) => ({ ...v, draftScopes: draftScopesOf(v) }),
+  { bootAction: new LoadApiKeysAction() });
 
 // --- the shell -----------------------------------------------------------------
 
 /** Which activity is showing, and the rest of the shell's own state. */
-export const workbench = new ServiceQuery('workbench', (r) => r.observe());
+export const workbench = new CellQuery('workbench', (r) => r.observe());
 /** The tab and panel stack. */
-export const navigation = new ServiceQuery('navigation', (r) => r.observe());
+export const navigation = new CellQuery('navigation', (r) => r.observe());
 /** Dialogs, menus and panels. */
-export const overlay = new ServiceQuery('overlay', (r) => r.observe());
+export const overlay = new CellQuery('overlay', (r) => r.observe());
 /** Toasts. */
-export const notifications = new ServiceQuery('notifications', (r) => r.observe());
+export const notifications = new CellQuery('notifications', (r) => r.observe());
 /** Settings, defaults merged with overrides. */
-export const settings = new ServiceQuery('settings', (r) => r.observe());
+export const settings = new CellQuery('settings', (r) => r.observe());
 /**
  * The settings SCHEMA, grouped by category, for the screen that edits them.
  *
@@ -269,42 +294,24 @@ export const settings = new ServiceQuery('settings', (r) => r.observe());
  * values keyed by setting name — adding a `groups` key to it would put a made-up entry in
  * among the real ones.
  */
-export const settingsGroups = new ServiceQuery('settings', (r) => r.observe(), (_v, r) => r.grouped());
+export const settingsGroups = new CellQuery('settings', (r) => r.observe(), (_v, r) => r.grouped());
 
 /** The when-clause keys: what is selected, what is open, what is focused. */
-export const context = new ServiceQuery('context', (r) => r.observe());
+export const context = new CellQuery('context', (r) => r.observe());
 /** Phone, desktop or TV. */
-export const viewport = new ServiceQuery('viewport', (r) => r.observe());
+export const viewport = new CellQuery('viewport', (r) => r.observe());
 /**
  * Whether this browser can transcribe on-device, and whether it is listening now.
  *
  * `canListen` is folded in: it is a question about the state, so a component should not
  * have to call the service to find out.
  */
-export const voice = new ServiceQuery('voice', (r) => r.observe(),
+export const voice = new CellQuery('voice', (r) => r.observe(),
   (v, r) => ({ ...v, canListen: !!r.canListen?.() }));
 /** Installed plugins; null where the plugin host is not installed. */
-export const plugins = new ServiceQuery('plugins', (r) => r?.observe?.());
+export const plugins = new CellQuery('plugins', (r) => r?.observe?.());
 /** What the UI is in the middle of doing: drafts, captures, ticked boxes. See viewState.js. */
-export const viewState = new ServiceQuery('viewState', (r) => r.observe());
-
-/**
- * Contributions of one type — status items, openers, views.
- *
- * Parameterised, so it MUST memoise: a fresh instance per render would boot a second live
- * realization every frame and never share one. Keyed by the type, which is the only thing
- * that distinguishes them.
- */
-export const contributionsOfType = (type) => ContributionsOfType.of(type);
-
-class ContributionsOfType extends ServiceQuery {
-  static of = queryOf(ContributionsOfType);
-
-  constructor(type) {
-    super('contributions', (r) => r.observeType(type));
-    this.type = type;
-  }
-}
+export const viewState = new CellQuery('viewState', (r) => r.observe());
 
 // --- view queries ---------------------------------------------------------------
 //
@@ -372,8 +379,6 @@ const registries = (r) => [
  * No `when` expression and no handler. A component shows the title, greys out what is
  * disabled, and dispatches `ExecCommandAction(id)`.
  */
-export const paletteCommands = new ViewQuery(REGISTRY_DEPS, registries, paletteCommandsOf);
-
 function paletteCommandsOf(r) {
   return r.commands.paletteCommands().map((c) => ({
     id: c.id,
@@ -381,12 +386,15 @@ function paletteCommandsOf(r) {
     category: c.category ?? null,
     icon: c.icon ?? null,
     keybinding: r.keybindings.labelFor(c.id),
-    // Two different reasons a command might not run, and they are labelled differently in
-    // the palette: `available` is the plugin behind it being reachable, `enabled` also
-    // folds in the when-clause. Collapsing them would tag a command disabled by context as
-    // "offline", which is a false explanation rather than a vague one.
+    // Only `available` — the plugin behind this command being reachable. There was an
+    // `enabled` beside it, under a paragraph explaining that collapsing the two would tag a
+    // context-disabled command as "offline", and the code made the distinction impossible:
+    // `paletteCommands()` has already dropped every when-clause failure, so for every row
+    // that survives, `isEnabled` re-evaluates the same clause against the same registry and
+    // agrees with `isAvailable` by construction. Nothing rendered it. If greying a gated
+    // command out with a reason is wanted, do the other half — stop filtering in
+    // `paletteCommands()` — rather than keeping the label for a state that cannot occur.
     available: r.commands.isAvailable(c),
-    enabled: r.commands.isEnabled(c.id),
   }));
 }
 
@@ -635,7 +643,7 @@ export const openerAssociations = new ViewQuery(REGISTRY_DEPS, registries, (r) =
  */
 export const sidecarFor = (nodeId) => Sidecar.of(nodeId);
 
-class Sidecar extends ServiceQuery {
+class Sidecar extends CellQuery {
   static of = queryOf(Sidecar);
 
   constructor(nodeId) {
@@ -706,4 +714,4 @@ function commandKeysOf(r) {
  * PENDING while the request was in flight. Both go away when the fetch belongs to the
  * provider: the cell already holds null, and reading a cell is all this does.
  */
-export const capabilities = new ServiceQuery('capabilities', (r) => r);
+export const capabilities = new CellQuery('capabilities', (r) => r);

package/packages/web/src/bl/services.js

@@ -51,10 +51,12 @@ export function selectedNodesOf(state) {
  * fact is how they drift.
  */
 export class TransfersService {
+  #state;
+
   /** @param {import('./activity.js').ActivityService} [activity] */
   constructor(activity = null) {
-    this.state = { items: [] }; // { id, name, direction, ratio, loaded, total, status, error, retryable }
-    this.cell = cell(this.state);
+    this.#state = { items: [] }; // { id, name, direction, ratio, loaded, total, status, error, retryable }
+    this.cell = cell(this.#state);
     this._controllers = new Map();
     this.activity = activity;
     this._tasks = new Map(); // transfer id -> activity task handle
@@ -67,11 +69,17 @@ export class TransfersService {
     // and the alternative is asking the user to find the file and drag it in again.
     this._retries = new Map();
   }
+  /** The value, for whoever is about to decide something from it. See bl/state.js: one
+   *  value, one way to read it — a public `state` field is a second, writable door. */
+  get() {
+    return this.#state;
+  }
+
   observe() {
     return this.cell;
   }
   #emit() {
-    this.cell.setValue(this.state);
+    this.cell.setValue(this.#state);
   }
   /**
    * @param {{retry?: () => Promise<any>}} [opts] how to run this transfer again, if it can be
@@ -79,8 +87,8 @@ export class TransfersService {
   start(id, name, total, controller, { retry = null } = {}) {
     this._controllers.set(id, controller);
     if (retry) this._retries.set(id, retry);
-    this.state = {
-      items: [...this.state.items, {
+    this.#state = {
+      items: [...this.#state.items, {
         id, name, direction: 'up', ratio: 0, loaded: 0, total, status: 'active', error: null,
         // Surfaced in state so the tray renders from a snapshot rather than interrogating
         // the service — it is a fact about the row, like `status`.
@@ -109,7 +117,7 @@ export class TransfersService {
   retry(id) {
     const again = this._retries.get(id);
     if (!again) return null;
-    const item = this.state.items.find((t) => t.id === id);
+    const item = this.#state.items.find((t) => t.id === id);
     if (!item || item.status === 'active') return null;
     return again();
   }
@@ -117,9 +125,9 @@ export class TransfersService {
   /** Put an existing row back into flight — see `retry`. */
   restart(id, controller) {
     this._controllers.set(id, controller);
-    const item = this.state.items.find((t) => t.id === id);
-    this.state = {
-      items: this.state.items.map((t) => (t.id === id
+    const item = this.#state.items.find((t) => t.id === id);
+    this.#state = {
+      items: this.#state.items.map((t) => (t.id === id
         ? { ...t, status: 'active', error: null, ratio: 0, loaded: 0 }
         : t)),
     };
@@ -130,12 +138,12 @@ export class TransfersService {
     this.#task(id, item?.name || 'file', item?.total || null);
   }
   progress(id, { loaded, total, ratio }) {
-    this.state = { items: this.state.items.map((t) => (t.id === id ? { ...t, loaded, total, ratio } : t)) };
+    this.#state = { items: this.#state.items.map((t) => (t.id === id ? { ...t, loaded, total, ratio } : t)) };
     this.#emit();
     this._tasks.get(id)?.progress({ done: loaded, total: total || null });
   }
   finish(id, status = 'done', error = null) {
-    this.state = { items: this.state.items.map((t) => (t.id === id ? { ...t, status, error, ratio: status === 'done' ? 1 : t.ratio } : t)) };
+    this.#state = { items: this.#state.items.map((t) => (t.id === id ? { ...t, status, error, ratio: status === 'done' ? 1 : t.ratio } : t)) };
     this._controllers.delete(id);
     this.#emit();
     const task = this._tasks.get(id);
@@ -152,17 +160,17 @@ export class TransfersService {
     this.finish(id, 'cancelled');
   }
   dismiss(id) {
-    this.state = { items: this.state.items.filter((t) => t.id !== id) };
+    this.#state = { items: this.#state.items.filter((t) => t.id !== id) };
     this._retries.delete(id);
     this.#emit();
   }
   clearDone() {
-    const kept = this.state.items.filter((t) => t.status === 'active');
+    const kept = this.#state.items.filter((t) => t.status === 'active');
     const keptIds = new Set(kept.map((t) => t.id));
     // Drop the retry thunks of the rows that just left, so a dismissed upload does not
     // hold its File alive for the rest of the session.
     for (const id of [...this._retries.keys()]) if (!keptIds.has(id)) this._retries.delete(id);
-    this.state = { items: kept };
+    this.#state = { items: kept };
     this.#emit();
   }
 }

package/packages/web/src/bl/social.js

@@ -8,12 +8,14 @@
 import { cell } from '../runtime.js';
 
 export class SocialService {
+  #state;
+
   constructor(platform, offline = null) {
     // How a comment or tag written while disconnected reaches the server later.
     this.offline = offline;
     this.platform = platform;
     this.api = platform.api;
-    this.state = {
+    this.#state = {
       me: null,
       notifications: { items: [], unread: 0 },
       inboxOpen: false,
@@ -24,16 +26,28 @@ export class SocialService {
       posting: false,
       replyTo: null, // { id, author } when composing a reply
     };
-    this.cell = cell(this.state);
+    this.cell = cell(this.#state);
     this._pollTimer = null;
   }
 
+  /**
+   * The value, for whoever is about to decide something from it.
+   *
+   * The same door every slice offers. Actions read `.state` and queries read `.cell`, and
+   * the two are only equal by habit — bl/state.js says so, and says a resource has one
+   * value and one way to read it. `state` is also a public field on a service, which is one
+   * typo from `social.state.sidecar = null` bypassing the cell and notifying nothing.
+   */
+  get() {
+    return this.#state;
+  }
+
   observe() {
     return this.cell;
   }
   #set(patch) {
-    this.state = { ...this.state, ...patch };
-    this.cell.setValue(this.state);
+    this.#state = { ...this.#state, ...patch };
+    this.cell.setValue(this.#state);
   }
 
   async init() {
@@ -60,14 +74,14 @@ export class SocialService {
   }
 
   toggleInbox(open) {
-    const next = open ?? !this.state.inboxOpen;
+    const next = open ?? !this.#state.inboxOpen;
     this.#set({ inboxOpen: next });
-    if (next && this.state.notifications.unread) this.markAllRead();
+    if (next && this.#state.notifications.unread) this.markAllRead();
   }
   async markAllRead() {
     try {
       await this.api.markNotificationsRead();
-      this.#set({ notifications: { ...this.state.notifications, unread: 0, items: this.state.notifications.items.map((i) => ({ ...i, read: true })) } });
+      this.#set({ notifications: { ...this.#state.notifications, unread: 0, items: this.#state.notifications.items.map((i) => ({ ...i, read: true })) } });
     } catch { /* ignore */ }
   }
 
@@ -83,10 +97,10 @@ export class SocialService {
       // same guard loadBacklinks already had. Without it, opening A then quickly opening
       // B let A resolve last, so `state.sidecar.nodeId` became A while B was on screen
       // and comment()/addTag()/removeTag() all wrote to A.
-      if (this.state.sidecar?.nodeId !== nodeId) return;
+      if (this.#state.sidecar?.nodeId !== nodeId) return;
       this.#set({ sidecar: { ...view, loading: false } });
     } catch (err) {
-      if (this.state.sidecar?.nodeId !== nodeId) return;
+      if (this.#state.sidecar?.nodeId !== nodeId) return;
       this.#set({ sidecar: { nodeId, loading: false, error: err.message, tags: [], comments: [] } });
     }
   }
@@ -102,26 +116,26 @@ export class SocialService {
     try {
       const res = await this.api.backlinks(nodeId);
       // A slower request for a previously-open item must not land on this one.
-      if (this.state.backlinks?.nodeId !== nodeId) return;
+      if (this.#state.backlinks?.nodeId !== nodeId) return;
       this.#set({ backlinks: { nodeId, items: res.items || [], loading: false, error: null } });
     } catch (err) {
-      if (this.state.backlinks?.nodeId !== nodeId) return;
+      if (this.#state.backlinks?.nodeId !== nodeId) return;
       this.#set({ backlinks: { nodeId, items: [], loading: false, error: err.message } });
     }
   }
   async #reload() {
-    if (this.state.sidecar?.nodeId) await this.loadSidecar(this.state.sidecar.nodeId);
+    if (this.#state.sidecar?.nodeId) await this.loadSidecar(this.#state.sidecar.nodeId);
   }
 
   setReplyTo(target) {
     this.#set({ replyTo: target });
   }
   async comment(body) {
-    const nodeId = this.state.sidecar?.nodeId;
+    const nodeId = this.#state.sidecar?.nodeId;
     if (!nodeId || !body.trim()) return;
-    const parentId = this.state.replyTo?.id || null;
+    const parentId = this.#state.replyTo?.id || null;
     // Offline → queue the op; it replays (CRDT-merges) on reconnect.
-    if (this.offline && !this.offline.state.online) {
+    if (this.offline && !this.offline.get().online) {
       await this.offline.queueOp({ method: 'POST', path: `/api/items/${encodeURIComponent(nodeId)}/comments`, body: { body, parentId } });
       this.#set({ replyTo: null });
       this.platform.notifications.info('Offline — your comment will post when you reconnect.');
@@ -139,14 +153,14 @@ export class SocialService {
     }
   }
   async deleteComment(cid) {
-    const nodeId = this.state.sidecar?.nodeId;
+    const nodeId = this.#state.sidecar?.nodeId;
     await this.api.deleteComment(nodeId, cid).catch((e) => this.platform.notifications.error(e.message));
     await this.#reload();
   }
   async react(cid, emoji) {
-    const nodeId = this.state.sidecar?.nodeId;
-    const comment = findComment(this.state.sidecar?.comments || [], cid);
-    const on = !(comment?.reactions?.[emoji] || []).includes(this.state.me?.id);
+    const nodeId = this.#state.sidecar?.nodeId;
+    const comment = findComment(this.#state.sidecar?.comments || [], cid);
+    const on = !(comment?.reactions?.[emoji] || []).includes(this.#state.me?.id);
     try {
       await this.api.reactComment(nodeId, cid, emoji, on);
     } catch (err) {
@@ -155,9 +169,9 @@ export class SocialService {
     await this.#reload();
   }
   async addTag(name, value) {
-    const nodeId = this.state.sidecar?.nodeId;
+    const nodeId = this.#state.sidecar?.nodeId;
     if (!name.trim()) return;
-    if (this.offline && !this.offline.state.online) {
+    if (this.offline && !this.offline.get().online) {
       await this.offline.queueOp({ method: 'POST', path: `/api/items/${encodeURIComponent(nodeId)}/tags`, body: { name: name.trim(), value } });
       this.platform.notifications.info('Offline — tag will sync when you reconnect.');
       return;
@@ -166,9 +180,9 @@ export class SocialService {
     await this.#reload();
   }
   async removeTag(name) {
-    const nodeId = this.state.sidecar?.nodeId;
+    const nodeId = this.#state.sidecar?.nodeId;
     // Offline → queue like addTag so the removal isn't silently lost.
-    if (this.offline && !this.offline.state.online) {
+    if (this.offline && !this.offline.get().online) {
       await this.offline.queueOp({ method: 'DELETE', path: `/api/items/${encodeURIComponent(nodeId)}/tags/${encodeURIComponent(name)}` });
       this.platform.notifications.info('Offline — tag removal will sync when you reconnect.');
       return;
@@ -184,7 +198,7 @@ export class SocialService {
   // --- web push --------------------------------------------------------------
 
   async #detectPush() {
-    if (!this.state.pushSupported) return;
+    if (!this.#state.pushSupported) return;
     try {
       const reg = await navigator.serviceWorker.getRegistration();
       const sub = await reg?.pushManager?.getSubscription();
@@ -193,7 +207,7 @@ export class SocialService {
   }
 
   async enablePush() {
-    if (!this.state.pushSupported) {
+    if (!this.#state.pushSupported) {
       this.platform.notifications.warn('Push notifications are not supported in this browser.');
       return;
     }

package/packages/web/src/bl/state.js

@@ -27,8 +27,9 @@ import { cell } from '../runtime.js';
  * One named piece of the drive's state.
  *
  * `set` merges, because every caller was already merging and doing it here removes the
- * chance of a caller replacing a slice by forgetting to spread it. `replace` exists for
- * the cases that genuinely mean "all of it" — a fresh panel stack, an emptied list.
+ * chance of a caller replacing a slice by forgetting to spread it. There is no `replace`:
+ * one existed for "the cases that genuinely mean all of it" and no caller ever turned out
+ * to mean that, so a slice has exactly one way to be written.
  *
  * @param {object} initial
  */
@@ -41,8 +42,6 @@ export function slice(initial = {}) {
     get: () => held.getValue(),
     /** Merge a patch in. A new object every time — a cell compares with Object.is. */
     set: (patch) => held.setValue({ ...held.getValue(), ...patch }),
-    /** Replace it outright, for when a patch would be a lie. */
-    replace: (next) => held.setValue(next),
   };
 }
 
@@ -57,12 +56,21 @@ export const explorerState = (settings) => slice({
   // `stats` is the whole collection; `items` is the page on screen. Keeping both is what
   // lets the UI say "500 of 3,006" instead of quietly claiming 500.
   stats: null, usage: null, nextCursor: null, loadingMore: false, trash: null,
+  // The selected NODES, not just their ids — the primary read path in `selectedNodesOf`,
+  // with `items` as the fallback for when a selection was made somewhere `items` covers.
+  // That function exists to end the class of silent bug where rename/trash/copy-link
+  // returned quietly while `hasSelection` said there was something to act on.
+  selectionNodes: null,
 });
 
 /** Query text, results, and the palette's separate file list. */
 export const searchState = () => slice({
   query: '', mode: 'hybrid', results: [], loading: false, error: null, ran: false,
   paletteFiles: [], paletteQuery: '', paletteLoading: false, paletteError: null,
+  // `filtered` is a tag/type filter rather than a query; `offline` says the results came
+  // from the local pinned index; `resolved` is the query the results on screen are FOR,
+  // and it is what `pickView` reads to decide whether to show them at all.
+  filtered: false, offline: false, resolved: null,
 });
 
 /**
@@ -78,6 +86,10 @@ export const searchState = () => slice({
  */
 export const apiKeysState = () => slice({
   keys: [], loading: false, loaded: false, error: null, minted: null, busy: null, draft: null,
+  // `forbidden` is not `error`. A non-admin's 403 is the correct answer to this request, so
+  // the section is simply absent for them; anything else is a failure worth reporting, with
+  // a way to try again. Conflating the two rendered a blank space for both.
+  forbidden: false,
 });
 
 /**
@@ -106,6 +118,12 @@ export const overlayState = () => slice({
   dialog: null,
   contextMenu: null,
   pluginPanel: null,
+  // The activity panel. It lived inside ActivityService's state, beside `tasks` and
+  // `issues` — the one field there with no justification while its neighbours had five
+  // lines of it — which made CloseOverlaysAction lease a task/issue poller in order to
+  // close a panel, and broke form on the sixth rung of an Escape ladder whose other five
+  // go through here.
+  activityPanel: false,
 });
 
 /**

package/packages/web/src/bl/viewState.js

@@ -42,6 +42,15 @@ export function draftFor(slice, key, ref, fallback) {
 /** Where a prompt dialog's typed value lives while it is being typed. */
 export const PROMPT = 'promptValue';
 
+/**
+ * Where the plugin review's ticked capabilities live.
+ *
+ * Named here rather than privately in the component, because the action that performs the
+ * install READS it — the dialog is data, so what the user ticked has to be state the action
+ * can find rather than something a callback closes over.
+ */
+export const PLUGIN_REVIEW = 'pluginReview';
+
 /**
  * What has been typed into the open prompt, or its initial value.
  *

package/packages/web/src/bl/watchQuery.js

@@ -59,14 +59,7 @@ export function watchQuery(engine, queryInstance) {
   }
   let cell = forEngine.get(queryInstance);
   if (!cell) {
-    // A query may declare what it means before it knows — `initial = null` for something
-    // fetched over the network, say. Without one the cell is PENDING, and PENDING reaching
-    // a `watch` renders its placeholder: fine for a region that can show an empty bar for a
-    // frame, wrong for a snapshot feeding the whole shell, which would blank until the
-    // request came back. The initial belongs to the query rather than to this call, so it
-    // cannot differ between two call sites reading the same thing.
-    const initial = 'initial' in queryInstance ? queryInstance.initial : PENDING;
-    cell = fromObservable(engine.query(queryInstance), { initial });
+    cell = fromObservable(engine.query(queryInstance), { initial: PENDING });
     forEngine.set(queryInstance, cell);
   }
   return cell;