@tryinget/pi-activity-strip 0.3.0 → 0.5.0

package/src/electron/niri-native-window-runtime.mjs

@@ -1,178 +0,0 @@
-// ---
-// summary: "owns Niri native strip remapping, floating conversion, and exact top-edge alignment"
-// read_when:
-//   - "changing compositor-native activity-strip placement or animation detection"
-// ---
-
-import { hasNiriFloatingPosition, isNiriWindowAligned } from "../common/alignment-controller.mjs";
-import { resolveActivityStripWindow } from "../common/niri-focus.mjs";
-
-const defaultWait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
-
-function formatDelta(value) {
-  const rounded = Math.round(value);
-  return rounded >= 0 ? `+${rounded}` : String(rounded);
-}
-
-function readPosition(window) {
-  const position = window?.layout?.tile_pos_in_workspace_view;
-  if (!Array.isArray(position) || position.length < 2) return null;
-  return {
-    x: Number(position[0] ?? 0),
-    y: Number(position[1] ?? 0),
-  };
-}
-
-/**
- * @param {{
- *   execFileAsync: (file: string, args: string[], options: object) => Promise<unknown>;
- *   env: NodeJS.ProcessEnv;
- *   timeoutMs: number;
- *   processId: number;
- *   readWindows: () => Promise<Array<Record<string, unknown>>>;
- *   getBrowserWindow: () => import("electron").BrowserWindow | null;
- *   getBounds: () => {x: number; y: number; width: number; height: number};
- *   isNiriSession: () => boolean;
- *   wait?: (milliseconds: number) => Promise<unknown>;
- * }} options
- */
-export function createNiriNativeWindowRuntime(options) {
-  const wait = options.wait ?? defaultWait;
-
-  function resolveProcessWindow(windows) {
-    return resolveActivityStripWindow(
-      windows.filter((window) => window?.pid === options.processId),
-    );
-  }
-
-  async function getProcessWindow() {
-    return resolveProcessWindow(await options.readWindows());
-  }
-
-  async function moveWindowToWorkspace(stripWindow, workspace) {
-    const reference = workspace.name || workspace.idx;
-    if (reference == null) return false;
-    try {
-      await options.execFileAsync(
-        "niri",
-        [
-          "msg",
-          "action",
-          "move-window-to-workspace",
-          "--window-id",
-          String(stripWindow.id),
-          "--focus",
-          "false",
-          String(reference),
-        ],
-        { env: options.env, timeout: options.timeoutMs },
-      );
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async function moveWindowToTop(isCurrent) {
-    let animated = false;
-    const browserWindow = options.getBrowserWindow();
-    if (!isCurrent() || !browserWindow || browserWindow.isDestroyed() || !options.isNiriSession()) {
-      return { ok: false, animated };
-    }
-
-    let niriWindow = await getProcessWindow();
-    if (!isCurrent() || !niriWindow?.id) return { ok: false, animated };
-    if (niriWindow.is_floating !== true) {
-      try {
-        await options.execFileAsync(
-          "niri",
-          ["msg", "action", "move-window-to-floating", "--id", String(niriWindow.id)],
-          { env: options.env },
-        );
-        animated = true;
-      } catch {
-        return { ok: false, animated };
-      }
-    }
-
-    for (let attempt = 0; attempt < 8; attempt += 1) {
-      if (!isCurrent()) return { ok: false, animated };
-      const position = readPosition(niriWindow);
-      if (hasNiriFloatingPosition(niriWindow) && position) {
-        const target = options.getBounds();
-        if (isNiriWindowAligned(niriWindow, target)) return { ok: true, animated };
-        const deltaX = target.x - position.x;
-        const deltaY = target.y - position.y;
-        if (Math.abs(deltaX) >= 1 || Math.abs(deltaY) >= 1) {
-          try {
-            await options.execFileAsync(
-              "niri",
-              [
-                "msg",
-                "action",
-                "move-floating-window",
-                "--id",
-                String(niriWindow.id),
-                "-x",
-                formatDelta(deltaX),
-                "-y",
-                formatDelta(deltaY),
-              ],
-              { env: options.env },
-            );
-            animated = true;
-          } catch {
-            return { ok: false, animated };
-          }
-        }
-      }
-      await wait(60);
-      if (!isCurrent()) return { ok: false, animated };
-      niriWindow = await getProcessWindow();
-      if (!niriWindow?.id) return { ok: false, animated };
-    }
-    return { ok: false, animated };
-  }
-
-  async function alignWindowToTop(isCurrent) {
-    const browserWindow = options.getBrowserWindow();
-    if (!isCurrent() || !browserWindow || browserWindow.isDestroyed()) {
-      return { ok: false, animated: false };
-    }
-    if (!options.isNiriSession()) {
-      browserWindow.setBounds(options.getBounds(), false);
-      return { ok: true, animated: false };
-    }
-
-    const niriWindow = await getProcessWindow();
-    if (!isCurrent()) return { ok: false, animated: false };
-    const target = options.getBounds();
-    const currentSize = niriWindow?.layout?.window_size;
-    const widthMatches = Array.isArray(currentSize) && Number(currentSize[0]) === target.width;
-    const heightMatches = Array.isArray(currentSize) && Number(currentSize[1]) === target.height;
-    let animated = false;
-
-    if (!widthMatches || !heightMatches) {
-      browserWindow.setSize(target.width, target.height, false);
-      animated = true;
-      await wait(80);
-      if (!isCurrent()) return { ok: false, animated };
-    }
-
-    for (let attempt = 0; attempt < 8; attempt += 1) {
-      const result = await moveWindowToTop(isCurrent);
-      animated ||= result.animated;
-      if (result.ok) return { ok: true, animated };
-      if (!isCurrent()) return { ok: false, animated };
-      await wait(60);
-    }
-    return { ok: false, animated };
-  }
-
-  return {
-    alignWindowToTop,
-    isWindowAligned: (window) => isNiriWindowAligned(window, options.getBounds()),
-    moveWindowToWorkspace,
-    resolveProcessWindow,
-  };
-}

package/src/electron/preload.cjs

@@ -1,50 +0,0 @@
-// ---
-// summary: "exposes a sandboxed renderer subscription API for activity-strip snapshot IPC messages"
-// read_when:
-//   - "changing the preload bridge or renderer snapshot subscription contract"
-// ---
-
-const { contextBridge, ipcRenderer } = require("electron");
-
-contextBridge.exposeInMainWorld("activityStrip", {
-  activate(sessionId) {
-    return ipcRenderer.invoke("pi-activity-strip:focus", String(sessionId ?? ""));
-  },
-  setExpanded(expanded) {
-    return ipcRenderer.invoke("pi-activity-strip:set-expanded", Boolean(expanded));
-  },
-  onCollapse(handler) {
-    if (typeof handler !== "function") return () => {};
-    const listener = () => handler();
-    ipcRenderer.on("pi-activity-strip:collapse", listener);
-    return () => ipcRenderer.removeListener("pi-activity-strip:collapse", listener);
-  },
-  onVisibility(handler) {
-    if (typeof handler !== "function") return () => {};
-    let latestRequestId = 0;
-    const listener = (_event, visible, requestId) => {
-      if (!Number.isInteger(requestId) || requestId <= 0) return;
-      latestRequestId = Math.max(latestRequestId, requestId);
-      const isCurrent = () => requestId === latestRequestId;
-      Promise.resolve()
-        .then(() => handler(Boolean(visible), isCurrent))
-        .then((applied) =>
-          ipcRenderer.send(
-            "pi-activity-strip:visibility-applied",
-            requestId,
-            Boolean(visible),
-            applied !== false,
-          ),
-        )
-        .catch(() => {});
-    };
-    ipcRenderer.on("pi-activity-strip:visibility", listener);
-    return () => ipcRenderer.removeListener("pi-activity-strip:visibility", listener);
-  },
-  subscribe(handler) {
-    if (typeof handler !== "function") return () => {};
-    const listener = (_event, snapshot) => handler(snapshot);
-    ipcRenderer.on("pi-activity-strip:snapshot", listener);
-    return () => ipcRenderer.removeListener("pi-activity-strip:snapshot", listener);
-  },
-});

package/src/electron/renderer-visibility-runtime.mjs

@@ -1,107 +0,0 @@
-// ---
-// summary: "acknowledges renderer conceal and reveal frames before native Niri lifecycle effects"
-// read_when:
-//   - "changing renderer visibility handshakes or wrong-workspace flash prevention"
-// ---
-
-export const VISIBILITY_CHANNEL = "pi-activity-strip:visibility";
-export const VISIBILITY_APPLIED_CHANNEL = "pi-activity-strip:visibility-applied";
-
-/**
- * Coordinate one bounded main-to-renderer visibility request. The renderer
- * acknowledges only after its CSS visibility change crosses two animation
- * frames, so callers can keep stale cards concealed during native remaps.
- * @param {{
- *   getWebContents: () => {send: (channel: string, ...args: unknown[]) => void} | null;
- *   setInputEnabled: (enabled: boolean) => void;
- *   timeoutMs: number;
- *   setTimer?: typeof setTimeout;
- *   clearTimer?: typeof clearTimeout;
- * }} options
- */
-export function createRendererVisibilityRuntime(options) {
-  const setTimer = options.setTimer ?? setTimeout;
-  const clearTimer = options.clearTimer ?? clearTimeout;
-  let nextRequestId = 0;
-  let latestRequestId = 0;
-  const pending = new Map();
-
-  function settle(requestId, applied) {
-    const request = pending.get(requestId);
-    if (!request) return false;
-    pending.delete(requestId);
-    clearTimer(request.timer);
-    request.resolve(applied);
-    return true;
-  }
-
-  async function apply(visible, isCurrent = () => true) {
-    const webContents = options.getWebContents();
-    if (!webContents) return false;
-    if (!visible) options.setInputEnabled(false);
-
-    nextRequestId += 1;
-    const requestId = nextRequestId;
-    latestRequestId = requestId;
-    const applied = new Promise((resolve) => {
-      const timer = setTimer(() => settle(requestId, false), options.timeoutMs);
-      pending.set(requestId, { resolve, timer, webContents, visible: Boolean(visible) });
-    });
-    try {
-      webContents.send(VISIBILITY_CHANNEL, Boolean(visible), requestId);
-    } catch {
-      settle(requestId, false);
-    }
-
-    const succeeded = await applied;
-    const appliedToCurrentRenderer =
-      succeeded &&
-      requestId === latestRequestId &&
-      isCurrent() &&
-      options.getWebContents() === webContents;
-    if (appliedToCurrentRenderer && visible) options.setInputEnabled(true);
-    return appliedToCurrentRenderer;
-  }
-
-  function acknowledge(event, requestId, visible, applied = true) {
-    const request = pending.get(requestId);
-    if (!request || event?.sender !== request.webContents || Boolean(visible) !== request.visible) {
-      return false;
-    }
-    return settle(requestId, Boolean(applied));
-  }
-
-  function dispose() {
-    nextRequestId += 1;
-    latestRequestId = nextRequestId;
-    for (const requestId of [...pending.keys()]) settle(requestId, false);
-    options.setInputEnabled(false);
-  }
-
-  return {
-    acknowledge,
-    appliedChannel: VISIBILITY_APPLIED_CHANNEL,
-    apply,
-    dispose,
-  };
-}
-
-/**
- * @param {() => import("electron").BrowserWindow | null} getWindow
- * @param {boolean} interactive
- */
-export function createBrowserWindowVisibilityRuntime(getWindow, interactive) {
-  return createRendererVisibilityRuntime({
-    getWebContents: () => {
-      const window = getWindow();
-      return window && !window.isDestroyed() ? window.webContents : null;
-    },
-    setInputEnabled: (enabled) => {
-      const window = getWindow();
-      if (!window || window.isDestroyed()) return;
-      window.setFocusable(enabled && interactive);
-      window.setIgnoreMouseEvents(!enabled || !interactive, { forward: true });
-    },
-    timeoutMs: 750,
-  });
-}

package/src/electron/workspace-view-runtime.mjs

@@ -1,360 +0,0 @@
-// ---
-// summary: "reconciles one workspace-local Niri strip view with native show, hide, move, and alignment effects"
-// read_when:
-//   - "changing workspace-local session filtering or Niri strip visibility lifecycle"
-// ---
-
-import { createLatestOnlyRunner } from "../common/alignment-controller.mjs";
-import {
-  resolveFocusedNiriWorkspace,
-  resolveFocusedWorkspaceView,
-  resolveWorkspaceView,
-} from "../common/niri-focus.mjs";
-
-const STRIP_DISCOVERY_ATTEMPTS = 8;
-const STRIP_DISCOVERY_DELAY_MS = 80;
-
-const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
-
-function emptyView(workspace = null) {
-  return { workspace, sessions: [], focusedSessionId: null };
-}
-
-/** @param {Array<Record<string, unknown>>} left @param {Array<Record<string, unknown>>} right */
-export function haveSameSessionIds(left, right) {
-  if (left.length !== right.length) return false;
-  const leftIds = new Set(left.map((session) => session.sessionId));
-  return leftIds.size === left.length && right.every((session) => leftIds.has(session.sessionId));
-}
-
-/**
- * Keep the global broker snapshot authoritative while projecting one exact,
- * workspace-local renderer view. Native effects are injected so the lifecycle
- * can be tested without Electron or a compositor.
- * @param {{
- *   readWindows: () => Promise<Array<Record<string, unknown>>>;
- *   readWorkspaces: () => Promise<Array<Record<string, unknown>>>;
- *   getSessions: () => Array<Record<string, unknown>>;
- *   getStripWindow: (windows: Array<Record<string, unknown>>) => Record<string, unknown> | null;
- *   isWindowVisible: () => boolean;
- *   isWindowExpanded: () => boolean;
- *   showWindow: () => Promise<void> | void;
- *   hideWindow: () => void;
- *   concealWindow: () => Promise<boolean | void> | boolean | void;
- *   revealWindow: (isCurrent: () => boolean) => Promise<boolean | void> | boolean | void;
- *   cancelReveal: () => void;
- *   collapseWindow: () => Promise<unknown> | unknown;
- *   publishView: (view: {workspace: Record<string, unknown> | null; sessions: Array<Record<string, unknown>>; focusedSessionId: string | null}) => void;
- *   moveWindowToWorkspace: (window: Record<string, unknown>, workspace: Record<string, unknown>) => Promise<boolean>;
- *   alignWindow: (isCurrent: () => boolean) => Promise<{ok: boolean; animated: boolean}>;
- *   settleWindow: (isCurrent: () => boolean) => Promise<boolean>;
- *   isWindowAligned: (window: Record<string, unknown>) => boolean;
- *   identityOptions?: {env?: NodeJS.ProcessEnv; readFileSync?: Function; existsSync?: Function};
- *   wait?: (milliseconds: number) => Promise<unknown>;
- * }} options
- */
-export function createNiriWorkspaceViewRuntime(options) {
-  const wait = options.wait ?? delay;
-  let passiveRequestQueued = false;
-  let passiveProbe = null;
-  let reconciling = false;
-  let reconcilingWorkspaceId = null;
-  let revealing = false;
-
-  function requestLatest() {
-    passiveRequestQueued = false;
-    if (revealing) options.cancelReveal();
-    return runner.request();
-  }
-
-  function probeFocusedWorkspace() {
-    const expectedWorkspaceId = reconcilingWorkspaceId;
-    if (expectedWorkspaceId == null || passiveProbe) return passiveProbe;
-    passiveProbe = Promise.resolve()
-      .then(() => options.readWorkspaces())
-      .then((workspaces) => {
-        if (!reconciling || reconcilingWorkspaceId !== expectedWorkspaceId) return;
-        const focusedWorkspace = resolveFocusedNiriWorkspace(workspaces);
-        if (!focusedWorkspace || focusedWorkspace.id !== expectedWorkspaceId) requestLatest();
-      })
-      .catch(() => {
-        if (reconciling && reconcilingWorkspaceId === expectedWorkspaceId) requestLatest();
-      })
-      .finally(() => {
-        passiveProbe = null;
-      });
-    return passiveProbe;
-  }
-
-  async function waitForPassiveProbe(isCurrent) {
-    if (passiveProbe) await passiveProbe;
-    return isCurrent();
-  }
-
-  async function findStripWindow(initialWindows, isCurrent) {
-    let windows = initialWindows;
-    for (let attempt = 0; attempt < STRIP_DISCOVERY_ATTEMPTS; attempt += 1) {
-      const stripWindow = options.getStripWindow(windows);
-      if (stripWindow) return stripWindow;
-      if (attempt === STRIP_DISCOVERY_ATTEMPTS - 1) break;
-      await wait(STRIP_DISCOVERY_DELAY_MS);
-      if (!isCurrent()) return null;
-      windows = await options.readWindows();
-      if (!isCurrent()) return null;
-    }
-    return null;
-  }
-
-  async function concealAndClear(view, isCurrent) {
-    let concealed = false;
-    try {
-      concealed = (await options.concealWindow()) !== false;
-    } catch {
-      // A transition may proceed only after renderer concealment is acknowledged.
-    }
-    if (!isCurrent()) return false;
-    options.publishView(emptyView(view?.workspace ?? null));
-    return concealed;
-  }
-
-  async function hideView(view, isCurrent, { skipConceal = false } = {}) {
-    if (options.isWindowVisible() || options.isWindowExpanded()) {
-      try {
-        await options.collapseWindow();
-      } catch {
-        // Hiding remains fail-closed even if expansion reconciliation is unavailable.
-      }
-    }
-    if (!isCurrent()) return;
-    if (!skipConceal) {
-      try {
-        await options.concealWindow();
-      } catch {
-        // Native hiding remains the final fail-closed boundary.
-      }
-    }
-    if (!isCurrent()) return;
-    options.publishView(emptyView(view?.workspace ?? null));
-    options.hideWindow();
-  }
-
-  async function parkView(view, isCurrent) {
-    if (options.isWindowExpanded()) {
-      try {
-        await options.collapseWindow();
-      } catch {
-        // Concealment below remains the fail-closed visual boundary.
-      }
-    }
-    if (!isCurrent()) return;
-    const concealed = await concealAndClear(view, isCurrent);
-    if (!isCurrent()) return;
-    if (!concealed) await hideView(view, isCurrent, { skipConceal: true });
-  }
-
-  async function revealView(view, isCurrent) {
-    let revealed = false;
-    revealing = true;
-    try {
-      revealed = (await options.revealWindow(isCurrent)) !== false;
-    } finally {
-      revealing = false;
-    }
-    if (!isCurrent()) {
-      try {
-        await options.concealWindow();
-      } catch {
-        // A newer reconciliation owns the next fail-closed state.
-      }
-      return false;
-    }
-    if (!revealed) {
-      await hideView(view, isCurrent);
-      return false;
-    }
-    return true;
-  }
-
-  async function verifyPlacement(expectedWorkspace, isCurrent, requireAlignment = false) {
-    for (let attempt = 0; attempt < STRIP_DISCOVERY_ATTEMPTS; attempt += 1) {
-      const [windows, workspaces] = await Promise.all([
-        options.readWindows(),
-        options.readWorkspaces(),
-      ]);
-      if (!isCurrent()) return null;
-      const focusedWorkspace = resolveFocusedNiriWorkspace(workspaces);
-      const stripWindow = options.getStripWindow(windows);
-      if (
-        focusedWorkspace?.id === expectedWorkspace.id &&
-        stripWindow?.workspace_id === expectedWorkspace.id &&
-        (!requireAlignment || options.isWindowAligned(stripWindow))
-      ) {
-        const verifiedView = resolveFocusedWorkspaceView(
-          windows,
-          workspaces,
-          options.getSessions(),
-          options.identityOptions,
-        );
-        return verifiedView?.sessions.length ? verifiedView : null;
-      }
-      if (focusedWorkspace && focusedWorkspace.id !== expectedWorkspace.id) return null;
-      if (attempt === STRIP_DISCOVERY_ATTEMPTS - 1) break;
-      await wait(STRIP_DISCOVERY_DELAY_MS);
-      if (!isCurrent()) return null;
-    }
-    return null;
-  }
-
-  async function reconcileOnce({ isCurrent }) {
-    const [windows, workspaces] = await Promise.all([
-      options.readWindows(),
-      options.readWorkspaces(),
-    ]);
-    if (!isCurrent()) return;
-
-    let view = resolveFocusedWorkspaceView(
-      windows,
-      workspaces,
-      options.getSessions(),
-      options.identityOptions,
-    );
-    if (!view) {
-      // Ambiguous or missing focused-workspace truth must never reactivate a resident view.
-      await parkView(null, isCurrent);
-      return;
-    }
-    reconcilingWorkspaceId = view.workspace.id;
-    if (passiveRequestQueued) void probeFocusedWorkspace();
-    if (view.sessions.length === 0) {
-      // Keep an aligned surface rendered on its prior workspace while that workspace still owns
-      // exact tracked terminals. It then travels only with the workspace itself and never reopens
-      // at Niri's middle-left default position on a return visit.
-      const residentStrip = options.getStripWindow(windows);
-      const residentWorkspaces = residentStrip
-        ? workspaces.filter((workspace) => workspace?.id === residentStrip.workspace_id)
-        : [];
-      const residentView =
-        residentWorkspaces.length === 1 && residentStrip && options.isWindowAligned(residentStrip)
-          ? resolveWorkspaceView(
-              windows,
-              residentWorkspaces[0],
-              options.getSessions(),
-              options.identityOptions,
-            )
-          : null;
-      if (residentView?.sessions.length) {
-        if (!(await waitForPassiveProbe(isCurrent))) return;
-        options.publishView(residentView);
-        if (!isCurrent()) return;
-        await revealView(residentView, isCurrent);
-        return;
-      }
-      await parkView(view, isCurrent);
-      return;
-    }
-
-    const wasVisible = options.isWindowVisible();
-    const initialStripWindow = options.getStripWindow(windows);
-    const requiresPlacement =
-      !wasVisible ||
-      !initialStripWindow ||
-      initialStripWindow.workspace_id !== view.workspace.id ||
-      !options.isWindowAligned(initialStripWindow);
-
-    if (requiresPlacement) {
-      const concealed = await concealAndClear(view, isCurrent);
-      if (!isCurrent()) return;
-      if (!concealed) {
-        await hideView(view, isCurrent, { skipConceal: true });
-        return;
-      }
-      if (!wasVisible) await options.showWindow();
-    }
-
-    const stripWindow = await findStripWindow(windows, isCurrent);
-    if (!isCurrent()) return;
-    if (!stripWindow) {
-      await hideView(view, isCurrent, { skipConceal: requiresPlacement });
-      return;
-    }
-
-    let movedBetweenWorkspaces = false;
-    if (stripWindow.workspace_id !== view.workspace.id) {
-      const moved = await options.moveWindowToWorkspace(stripWindow, view.workspace);
-      if (!isCurrent()) return;
-      if (!moved) {
-        await hideView(view, isCurrent, { skipConceal: requiresPlacement });
-        return;
-      }
-      movedBetweenWorkspaces = true;
-    }
-
-    if (requiresPlacement) {
-      let verifiedView = await verifyPlacement(view.workspace, isCurrent);
-      if (!verifiedView) {
-        if (isCurrent()) await hideView(view, isCurrent, { skipConceal: true });
-        return;
-      }
-      const alignment = await options.alignWindow(isCurrent);
-      if (!isCurrent()) return;
-      if (!alignment.ok) {
-        await hideView(view, isCurrent, { skipConceal: true });
-        return;
-      }
-      verifiedView = await verifyPlacement(view.workspace, isCurrent, true);
-      if (!verifiedView) {
-        if (isCurrent()) await hideView(view, isCurrent, { skipConceal: true });
-        return;
-      }
-
-      // Niri reports final logical coordinates while its render offset is still animating. Wait
-      // only after operations that can animate; an aligned resident window can reveal immediately.
-      if (!wasVisible || movedBetweenWorkspaces || alignment.animated) {
-        const settled = await options.settleWindow(isCurrent);
-        if (!isCurrent()) return;
-        if (!settled) {
-          await hideView(view, isCurrent, { skipConceal: true });
-          return;
-        }
-        verifiedView = await verifyPlacement(view.workspace, isCurrent, true);
-        if (!verifiedView) {
-          if (isCurrent()) await hideView(view, isCurrent, { skipConceal: true });
-          return;
-        }
-      }
-      view = verifiedView;
-    }
-    if (!isCurrent() || !(await waitForPassiveProbe(isCurrent))) return;
-
-    options.publishView(view);
-    if (!isCurrent()) return;
-    await revealView(view, isCurrent);
-  }
-
-  let runner;
-  async function reconcile(context) {
-    reconciling = true;
-    reconcilingWorkspaceId = null;
-    try {
-      await reconcileOnce(context);
-    } catch {
-      if (context.isCurrent()) await hideView(null, context.isCurrent);
-    } finally {
-      reconcilingWorkspaceId = null;
-      reconciling = false;
-      if (passiveRequestQueued && context.isCurrent()) requestLatest();
-    }
-  }
-
-  runner = createLatestOnlyRunner(reconcile);
-  return {
-    request: requestLatest,
-    requestPassive() {
-      if (!reconciling) return requestLatest();
-      passiveRequestQueued = true;
-      void probeFocusedWorkspace();
-      return null;
-    },
-    waitForIdle: runner.waitForIdle,
-  };
-}