gloomberb 0.18.4 → 0.19.0

package/src/renderers/electrobun/bun/desktop/update.ts

@@ -1,4 +1,4 @@
-import { readdir, rm } from "fs/promises";
+import { open, readdir, rm } from "fs/promises";
 import { basename, dirname, join } from "path";
 import type Electrobun from "electrobun/bun";
 import type { UpdateStatusEntry } from "electrobun/bun";
@@ -33,13 +33,14 @@ import {
 import { logFailure } from "../../../../utils/log-failure";
 import { compareSemver, isPrereleaseVersion } from "../../../../utils/semver";
 import { VERSION } from "../../../../version";
+import { DESKTOP_APP_NAME, LEGACY_DESKTOP_APP_NAME } from "../../shared/app-name";
 
 type ElectrobunUpdater = typeof Electrobun.Updater;
 
 /**
  * The part of Electrobun's updater this flow uses. Tests pass a fake, because
  * the real module cannot be loaded or exercised outside the packaged app.
- * `setUpdateSource` is Gloomberb's patch (patches/electrobun@*.patch).
+ * `setUpdateSource` is this app's patch (patches/electrobun@*.patch).
  */
 export type ElectrobunUpdaterApi = Pick<
   ElectrobunUpdater,
@@ -51,7 +52,7 @@ export type ElectrobunUpdaterApi = Pick<
   | "getStatusHistory"
   | "onStatusChange"
   | "setUpdateSource"
-> & {
+> & Partial<Pick<ElectrobunUpdater, "appDataFolder">> & {
   localInfo: Pick<ElectrobunUpdater["localInfo"], "channel" | "baseUrl">;
 };
 
@@ -81,6 +82,8 @@ function isUpdateAside(entry: string, appName: string): boolean {
  * process runs from: starting from it means the install that left them worked.
  * macOS keeps the app in its bundle, Linux in `<app data>/app` (`bin/bun`
  * inside it); Windows installs through its own script and leaves none.
+ * Beside `Gloom.app` it also takes `Gloomberb.app.previous`: the copy the
+ * update that brought the new name moved aside, under the old one.
  * Resolves to the paths it removed.
  */
 export async function removeUpdateAsides(
@@ -92,9 +95,12 @@ export async function removeUpdateAsides(
     : platform === "linux" && basename(dirname(execPath)) === "bin" ? dirname(dirname(execPath)) : undefined;
   if (!app) return [];
   const folder = dirname(app);
+  const names = platform === "darwin" && basename(app) === `${DESKTOP_APP_NAME}.app`
+    ? [basename(app), `${LEGACY_DESKTOP_APP_NAME}.app`]
+    : [basename(app)];
   const removed: string[] = [];
   for (const entry of await readdir(folder).catch(() => [] as string[])) {
-    if (!isUpdateAside(entry, basename(app))) continue;
+    if (!names.some((name) => isUpdateAside(entry, name))) continue;
     const path = join(folder, entry);
     // One that still cannot be removed (another user's) is tried again at the next start.
     const done = await rm(path, { recursive: true, force: true }).then(() => true, logFailure("desktop-update", "Could not remove an old copy of the app", false));
@@ -103,6 +109,142 @@ export async function removeUpdateAsides(
   return removed;
 }
 
+const TAR_BLOCK = 512;
+
+/**
+ * The first path in a tar, read from its leading headers: a ustar name and
+ * prefix, or the long name a pax (`x`) or GNU (`L`) header gives it. Null when
+ * `bytes` ends before one.
+ */
+export function firstTarPath(bytes: Uint8Array): string | null {
+  const decoder = new TextDecoder();
+  const field = (start: number, length: number) => {
+    const raw = bytes.subarray(start, start + length);
+    const end = raw.indexOf(0);
+    return decoder.decode(end === -1 ? raw : raw.subarray(0, end));
+  };
+  let longName: string | null = null;
+  for (let header = 0; header + TAR_BLOCK <= bytes.length;) {
+    if (bytes[header] === 0) return null;
+    const type = String.fromCharCode(bytes[header + 156] ?? 0);
+    const size = Number.parseInt(field(header + 124, 12).trim() || "0", 8);
+    const data = header + TAR_BLOCK;
+    if (type === "x" || type === "L" || type === "g" || type === "K") {
+      if (!Number.isFinite(size) || data + size > bytes.length) return null;
+      if (type === "L") longName = field(data, size);
+      if (type === "x") longName = /(?:^|\n)\d+ path=([^\n]*)\n/.exec(decoder.decode(bytes.subarray(data, data + size)))?.[1] ?? longName;
+      header = data + Math.ceil(size / TAR_BLOCK) * TAR_BLOCK;
+      continue;
+    }
+    if (longName) return longName;
+    const name = field(header, 100);
+    // POSIX ustar ("ustar\0") only: GNU tar keeps other fields where the prefix would be.
+    const prefix = field(header + 257, 6) === "ustar" ? field(header + 345, 155) : "";
+    return prefix ? `${prefix}/${name}` : name;
+  }
+  return null;
+}
+
+/**
+ * An octal number field of a tar header, read as tar readers do: the digits
+ * after any leading spaces, up to the first other character. The checksum is
+ * what tells a header from noise.
+ */
+function tarOctal(header: Uint8Array, start: number, length: number): number {
+  const digits = /^[\0 ]*([0-7]*)/.exec(new TextDecoder().decode(header.subarray(start, start + length)))?.[1];
+  return digits ? Number.parseInt(digits, 8) : 0;
+}
+
+/** Whether a header's checksum matches it: its bytes summed with the checksum field as spaces. */
+function tarHeaderChecksumMatches(header: Uint8Array): boolean {
+  const stored = tarOctal(header, 148, 8);
+  let unsigned = 0;
+  let signed = 0;
+  for (let index = 0; index < TAR_BLOCK; index += 1) {
+    const byte = index >= 148 && index < 156 ? 0x20 : header[index]!;
+    unsigned += byte;
+    signed += byte > 127 ? byte - 256 : byte;
+  }
+  return stored === unsigned || stored === signed;
+}
+
+/**
+ * Whether the file at `path` is a whole tar: every header from the first
+ * matches its checksum, and the entries reach the end-of-archive block before
+ * the file ends. A tar cut off partway (a decompress that failed, an app that
+ * quit while writing it) or no tar at all is not. It reads the headers only,
+ * so it says nothing about the files' contents.
+ */
+export async function isWholeTar(path: string): Promise<boolean> {
+  const file = await open(path, "r").catch(() => null);
+  if (!file) return false;
+  try {
+    const { size } = await file.stat();
+    const header = new Uint8Array(TAR_BLOCK);
+    for (let offset = 0; offset + TAR_BLOCK <= size;) {
+      const { bytesRead } = await file.read(header, 0, TAR_BLOCK, offset);
+      if (bytesRead < TAR_BLOCK) return false;
+      if (header.every((byte) => byte === 0)) return offset > 0;
+      if (!tarHeaderChecksumMatches(header)) return false;
+      // Octal: the base-256 sizes past 8 GB are not in an app's archive.
+      const entrySize = tarOctal(header, 124, 12);
+      offset += TAR_BLOCK + Math.ceil(entrySize / TAR_BLOCK) * TAR_BLOCK;
+    }
+    return false;
+  } catch {
+    return false;
+  } finally {
+    await file.close().catch(() => {});
+  }
+}
+
+/** Whether `path` holds a file that is not a whole tar. A missing one is not damaged. */
+async function isDamagedTar(path: string): Promise<boolean> {
+  return await Bun.file(path).exists() && !(await isWholeTar(path));
+}
+
+/** Where Electrobun keeps the update with build hash `hash` once it is downloaded. */
+function stagedArchivePath(extractionFolder: string, hash: string | undefined): string | null {
+  return hash ? join(extractionFolder, `${hash}.tar`) : null;
+}
+
+async function removeStagedArchive(path: string): Promise<void> {
+  await rm(path, { force: true }).catch(logFailure("desktop-update", "Could not remove a damaged update archive"));
+}
+
+/**
+ * Removes the unpacked update archives in Electrobun's `self-extraction`
+ * folder it must not build on. Electrobun takes `<hash>.tar` there as the
+ * update already downloaded without reading it, and a damaged one (part of a
+ * tar, from a decompress that failed) then failed to unpack at every install:
+ * without it, the download fetches a fresh copy. Also removed are the ones
+ * whose app carries its name from before the rename. The one that matters is
+ * the Windows archive an install from then updated from: it is packed again
+ * with the folder renamed (scripts/write-legacy-desktop-files.ts), so its
+ * bytes are not those of the archive the next release's patch is made from,
+ * and bspatch would turn it into a broken build. Without it the updater
+ * downloads the full archive instead. Resolves to the paths it removed.
+ */
+async function removeUnusableUpdateArchives(folder: string): Promise<string[]> {
+  const removed: string[] = [];
+  for (const entry of await readdir(folder).catch(() => [] as string[])) {
+    if (!entry.endsWith(".tar")) continue;
+    const path = join(folder, entry);
+    let reason: string;
+    if (!(await isWholeTar(path))) {
+      reason = "Could not remove a damaged update archive";
+    } else {
+      const head = await Bun.file(path).slice(0, 64 * 1024).bytes().catch(() => null);
+      const top = head ? firstTarPath(head)?.replace(/^\.\//, "").split("/")[0] : undefined;
+      if (top !== LEGACY_DESKTOP_APP_NAME && top !== `${LEGACY_DESKTOP_APP_NAME}.app`) continue;
+      reason = "Could not remove an update archive from before the rename";
+    }
+    const done = await rm(path, { force: true }).then(() => true, logFailure("desktop-update", reason, false));
+    if (done) removed.push(path);
+  }
+  return removed;
+}
+
 /**
  * Where the running app sits, for update failure reports and for what an
  * install that cannot replace it means. Electrobun replaces the macOS bundle
@@ -278,6 +420,12 @@ export function createElectrobunDesktopUpdater(
   /** An apply is under way, or finished and the app is quitting. */
   let applyInProgress = false;
 
+  /** Electrobun's `self-extraction` folder, where the download leaves the update as `<hash>.tar`. */
+  async function extractionFolder(): Promise<string | null> {
+    const appData = await updater.appDataFolder?.().catch(() => null);
+    return appData ? join(appData, "self-extraction") : null;
+  }
+
   /** The error progress for a failed step, reported to error tracking on the way. */
   function failed(failure: UpdateFailure, error: string, release?: { version?: string; channel?: UpdateChannel } | null): UpdateProgress {
     reportUpdateFailure(failure, {
@@ -464,6 +612,8 @@ export function createElectrobunDesktopUpdater(
       }
       target = result.release;
 
+      const extraction = await extractionFolder();
+      if (extraction) await removeUnusableUpdateArchives(extraction);
       await updater.downloadUpdate();
       const updateInfo = updater.updateInfo();
       if (updateInfo?.error) {
@@ -474,6 +624,15 @@ export function createElectrobunDesktopUpdater(
         onProgress(failed({ phase: "download", code: "interrupted" }, "Desktop update did not finish downloading.", result.release));
         return;
       }
+      // However Electrobun came by it (a patch, the full download), an archive
+      // that is not whole is never offered for a restart. It goes, so the retry
+      // downloads it again.
+      const staged = extraction ? stagedArchivePath(extraction, updateInfo.hash) : null;
+      if (staged && await isDamagedTar(staged)) {
+        await removeStagedArchive(staged);
+        onProgress(failed({ phase: "verify", code: "corrupt" }, "The downloaded update is damaged.", result.release));
+        return;
+      }
 
       // Downloaded, not installed: applying relaunches the app, and that waits
       // for the user's explicit request (`apply`).
@@ -503,9 +662,12 @@ export function createElectrobunDesktopUpdater(
     }
 
     const target = readyRelease;
+    const stagedHash = updater.updateInfo()?.hash;
     applyInProgress = true;
     let relaunching = false;
     let reportedError = false;
+    /** The install failed on the archive itself: it does not unpack. */
+    let damaged = false;
     const report = (progress: UpdateProgress) => {
       if (progress.phase === "error") reportedError = true;
       onProgress(progress);
@@ -513,6 +675,7 @@ export function createElectrobunDesktopUpdater(
     const installFailed = (error: unknown, message: string) => {
       // Electrobun names the system error in its message ("Failed to replace app: EACCES: ...").
       const code = installFailureCode(classifyUpdateError(error), installKind);
+      if (code === "corrupt") damaged = true;
       report(failed({ phase: relaunching ? "relaunch" : "apply", code }, message, target));
     };
     // Kept before Electrobun quits the app, so the next launch can tell whether it took.
@@ -543,9 +706,14 @@ export function createElectrobunDesktopUpdater(
     }
 
     // Past this point the app is quitting, so the guard stays up. A failed apply
-    // drops the staged release: the retry starts from the download again.
+    // drops the staged release: the retry starts from the download again. An
+    // archive that does not unpack goes too, or that download would take it as
+    // done once more and the install would fail on it again.
     if (!relaunching) {
       readyRelease = null;
+      const extraction = damaged ? await extractionFolder() : null;
+      const staged = extraction ? stagedArchivePath(extraction, stagedHash) : null;
+      if (staged) await removeStagedArchive(staged);
       applyInProgress = false;
     }
   }

package/src/renderers/electrobun/bun/desktop/view-ids.ts

@@ -0,0 +1,52 @@
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import type { DesktopViewIds } from "../../shared/protocol";
+
+/**
+ * The copy on disk of the ids the desktop view keeps in its WebView storage
+ * (view/view-ids.ts), in the data folder beside the install id. That storage
+ * belongs to the app's bundle identifier, and this copy is what a build under
+ * another identifier starts from.
+ */
+const FILE_NAME = "desktop-view-ids.json";
+const KEY = /^gloomberb\.[a-z0-9.-]{1,64}$/i;
+const MAX_IDS = 16;
+const MAX_VALUE_LENGTH = 4096;
+
+function viewIdsPath(dataDir: string): string {
+  return join(dataDir, FILE_NAME);
+}
+
+/** The entries of `raw` shaped like view ids: a storage key of this app's and a short string. */
+function parseViewIds(raw: unknown): DesktopViewIds {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const ids: DesktopViewIds = {};
+  for (const [key, value] of Object.entries(raw).slice(0, MAX_IDS)) {
+    if (KEY.test(key) && typeof value === "string" && value.length > 0 && value.length <= MAX_VALUE_LENGTH) ids[key] = value;
+  }
+  return ids;
+}
+
+/** What the data folder keeps; nothing when the file is missing or unreadable. */
+export function readDesktopViewIds(dataDir: string): DesktopViewIds {
+  try {
+    return parseViewIds(JSON.parse(readFileSync(viewIdsPath(dataDir), "utf8")));
+  } catch {
+    // Intentional ignore: no copy yet (a first launch, or a build from before it was kept), so the view keeps what it has.
+    return {};
+  }
+}
+
+/** Replaces the copy with what the view sent, written whole or not at all. Throws when it cannot, so the view tries again. */
+export function saveDesktopViewIds(dataDir: string, ids: unknown): void {
+  const path = viewIdsPath(dataDir);
+  const temporary = `${path}.${process.pid}.tmp`;
+  try {
+    mkdirSync(dataDir, { recursive: true });
+    writeFileSync(temporary, JSON.stringify(parseViewIds(ids)));
+    renameSync(temporary, path);
+  } catch (error) {
+    rmSync(temporary, { force: true });
+    throw error;
+  }
+}

package/src/renderers/electrobun/bun/desktop/workspace/index.ts

@@ -151,6 +151,7 @@ export function createDesktopWorkspace(
     paneState: clonePaneStateMap(sharedState.paneState),
     focusedPaneId: sharedState.focusedPaneId,
     statusBarVisible: sharedState.statusBarVisible,
+    brokerSyncErrors: { ...sharedState.brokerSyncErrors },
     mainStateRevision: sharedState.mainStateRevision,
     layoutChanged: sharedState.layoutChanged,
   });
@@ -179,6 +180,7 @@ export function createDesktopWorkspace(
         paneState: filterPaneState(syncedConfig.layout, clonePaneStateMap(snapshot.paneState)),
         focusedPaneId: snapshot.focusedPaneId,
         statusBarVisible: snapshot.statusBarVisible,
+        brokerSyncErrors: { ...snapshot.brokerSyncErrors },
         mainStateRevision: snapshot.mainStateRevision ?? currentRevision,
         layoutChanged: snapshot.layoutChanged,
       };

package/src/renderers/electrobun/bun/index.ts

@@ -1,4 +1,5 @@
-import Electrobun, { ApplicationMenu, Screen } from "electrobun/bun";
+import Electrobun, { ApplicationMenu, Screen, Utils } from "electrobun/bun";
+import { homedir } from "os";
 import { debugLog } from "../../../utils/debug-log";
 import { setConfigStoreHost } from "../../../data/config/store";
 import * as nodeConfigStoreHost from "../../../data/config/store/node";
@@ -25,6 +26,8 @@ import {
 } from "./window/remembered-frame";
 import { reapStaleTerminalMedia } from "../../opentui/terminal-media";
 import { installProcessCrashListeners } from "../../../telemetry/crash-reports-node";
+import { renameLegacyMacApp } from "./desktop/app-name";
+import { scheduleDesktopRelaunch } from "./desktop/relaunch";
 
 console.log = (...args) => console.error(...args);
 console.info = (...args) => console.error(...args);
@@ -42,6 +45,27 @@ setConfigStoreHost(nodeConfigStoreHost);
 // before the config, and its off switch, has been read.
 installProcessCrashListeners();
 
+// An install from before the rename runs from Gloomberb.app, where its updater
+// put this build. It takes the new name and opens again from there before any
+// window shows. Anywhere else this returns without touching the disk.
+const appRename = await renameLegacyMacApp({
+  execPath: process.execPath,
+  platform: process.platform,
+  homeDir: homedir(),
+  pathEnv: process.env.PATH ?? "",
+}).catch((error: unknown) => {
+  console.error("[desktop] could not give the app its new name", error instanceof Error ? error.message : String(error));
+  return null;
+});
+if (appRename?.kind === "renamed") {
+  scheduleDesktopRelaunch(appRename.bundle);
+  Utils.quit();
+  // The process is exiting; nothing below may open a window meanwhile.
+  await new Promise<never>(() => {});
+} else if (appRename?.kind === "skipped") {
+  console.error(`[desktop] kept the app's old name: ${appRename.reason}`);
+}
+
 function readOpenUrlEvent(event: unknown): string | null {
   const data = event && typeof event === "object" ? (event as { data?: unknown }).data : null;
   if (!data || typeof data !== "object") return null;

package/src/renderers/electrobun/shared/app-name.ts

@@ -0,0 +1,30 @@
+/**
+ * The desktop app is Gloom. Builds up to 0.18.4 were named Gloomberb, and an
+ * install from then still is: `Gloomberb.app` on a Mac, a `Gloomberb` folder
+ * inside the Windows update archive, and an updater that asks the release for
+ * `<channel>-<os>-<arch>-Gloomberb.*` files. The release keeps publishing
+ * those under the old name (scripts/write-legacy-desktop-files.ts), and a Mac
+ * bundle still named Gloomberb.app renames itself (bun/desktop/app-name.ts).
+ */
+export const DESKTOP_APP_NAME = "Gloom";
+export const LEGACY_DESKTOP_APP_NAME = "Gloomberb";
+
+/**
+ * Kept through the rename. Electrobun names the app's data and update folders
+ * after it, and macOS ties the app's settings, WebKit storage and permissions
+ * to it.
+ */
+export const DESKTOP_APP_IDENTIFIER = "com.vincelwt.gloomberb";
+
+/**
+ * The identifiers a build of this app carries: the one above, and the one a
+ * later release moves to. Until every install has moved, either one can be
+ * on disk (an app bundle, an install the script or Homebrew replaces), so
+ * anything that asks whether a copy is this app accepts both.
+ */
+export const DESKTOP_APP_IDENTIFIERS: readonly string[] = [DESKTOP_APP_IDENTIFIER, "sh.gloom.desktop"];
+
+/** Whether `identifier` is one a build of this app carries. */
+export function isDesktopAppIdentifier(identifier: string | null | undefined): boolean {
+  return !!identifier && DESKTOP_APP_IDENTIFIERS.includes(identifier);
+}

package/src/renderers/electrobun/shared/protocol.ts

@@ -10,6 +10,7 @@ import type { CapabilityManifest } from "../../../capabilities";
 import type { PluginOperationResult, PluginPin } from "../../../plugins/marketplace/store";
 import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
 import type { HttpProxyRequestEnvelope, HttpProxyResponseEnvelope } from "../../../utils/http-proxy-response";
+import type { StallEvent } from "../../../utils/main-thread-stall";
 import type { BootFrame } from "../../dom/boot-frame-page";
 
 export const ELECTROBUN_CONTEXT_MENU_ACTION = "gloom.context-menu.select";
@@ -32,8 +33,13 @@ export interface ElectrobunBackendInit {
   pluginSeedNotice?: { body: string; type: "error" | "info" };
   /** What the view needs to send crash reports and usage counts the same way the Bun process would. */
   telemetry: ElectrobunTelemetryInit;
+  /** The copy on disk of the ids the view keeps in its own storage (view/view-ids.ts). */
+  viewIds: DesktopViewIds;
 }
 
+/** Ids the view keeps in its WebView storage, by storage key. */
+export type DesktopViewIds = Record<string, string>;
+
 interface ElectrobunTelemetryInit {
   /** Random per-install id from `<dataDir>/install-id`; null when the file could not be written. */
   installId: string | null;
@@ -222,6 +228,8 @@ interface DesktopBackendRequestMap {
   "host.showContextMenu": { request: { menu: DesktopContextMenuItem[] }; response: boolean };
   /** The layout the main window draws at the next launch before its script loads (dom/boot-frame.ts). Only the main window's is kept. */
   "host.saveBootFrame": { request: { frame: BootFrame }; response: null };
+  /** The ids the view keeps in its storage, for the copy on disk. Only the main window's are kept. */
+  "host.saveViewIds": { request: { ids: DesktopViewIds }; response: null };
   /** The unread count for the Dock icon badge: `""` (none), `"1"` to `"99"` or `"99+"`. Only the main window's is applied. */
   "host.setAppBadge": { request: { label: string }; response: null };
   /** `channel` absent (an older view) means stable. */
@@ -337,6 +345,8 @@ export interface ElectrobunDesktopRpcSchema {
     };
     messages: {
       "host.restart": DesktopRestartMessage;
+      /** A window froze; the Bun process keeps the stall log and its report. */
+      "runtime.stall": StallEvent;
     };
   };
   webview: {

package/src/renderers/electrobun/view/backend-rpc.ts

@@ -17,6 +17,7 @@ import { subscribeCapability, type CapabilitySubscriptionOptions } from "./capab
 import { RpcTimeoutError } from "../../../utils/rpc-timeout-error";
 import { nameRpcTimeout, RPC_MAX_REQUEST_TIME_MS } from "./rpc-timeout";
 import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
+import type { StallEvent } from "../../../utils/main-thread-stall";
 
 type BackendMessages = ElectrobunDesktopRpcSchema["webview"]["messages"];
 type BackendMessageName = keyof BackendMessages;
@@ -153,6 +154,11 @@ export function requestElectrobunRestart(message: DesktopRestartMessage = {}): v
   rpc.send["host.restart"](message);
 }
 
+/** The Bun process keeps the stall log and sends its report. */
+export function sendElectrobunStall(event: StallEvent): void {
+  rpc.send["runtime.stall"](event);
+}
+
 export function getElectrobunBackendInitSnapshot(): ElectrobunBackendInit | null {
   return initSnapshot;
 }

package/src/renderers/electrobun/view/cli-pane-shot-frame.tsx

@@ -125,8 +125,8 @@ function useShotStatusLine(enabled: boolean, hasAsOf: () => boolean): ShotStatus
 }
 
 /**
- * Static captures retain warnings and optional source status without action
- * shortcuts. With `statusLine` the footer also carries the capture's dated
+ * Static captures retain warnings, what a filter leaves out (`capture`) and
+ * optional source status without action shortcuts. With `statusLine` the footer also carries the capture's dated
  * status line (`Fri 9 Oct close · 15 min delayed · markets closed until Mon`),
  * inside the requested size: the body gives up the footer row for it. The
  * pane's own text that says the same goes, so the date is said once: its `as
@@ -149,7 +149,7 @@ export function PaneShotFrame({ paneId, title, width, height, preserveStatus = f
   const datesData = statusLine && dates === "data";
   return <PaneFooterProvider>{(registeredFooter) => {
     const status: PaneFooterSegment[] = statusLine ? [{ id: "shot-status", parts: [{ text: statusText, tone: "label" }] }] : [];
-    const info = registeredFooter.info.filter((segment) => (preserveStatus || segment.icon === "warning")
+    const info = registeredFooter.info.filter((segment) => (preserveStatus || segment.icon === "warning" || segment.capture)
       && !(datesPaneData(segment) && (datesData || crowded))
       && !(segment.quoteStatus && statusLine && dates !== null));
     shownAsOf.current = info.some(datesPaneData);

package/src/renderers/electrobun/view/desktop/window/snapshot.ts

@@ -32,6 +32,7 @@ export function detachedSnapshotKey(snapshot: DesktopSharedStateSnapshot, paneId
     portfolios: snapshot.config.portfolios,
     watchlists: snapshot.config.watchlists,
     brokerInstances: snapshot.config.brokerInstances,
+    brokerSyncErrors: snapshot.brokerSyncErrors ?? {},
     pluginConfig: snapshot.config.pluginConfig,
     disabledPlugins: snapshot.config.disabledPlugins,
     chartPreferences: snapshot.config.chartPreferences,

package/src/renderers/electrobun/view/main.tsx

@@ -5,12 +5,14 @@ import { App } from "../../../app";
 import { applyLanguageFromConfig } from "../../../i18n";
 import { debugLog } from "../../../utils/debug-log";
 import { capturePaneImage } from "../../../utils/dom-screenshot";
+import { setStallSink } from "../../../utils/main-thread-stall";
 import { measurePerfAsync } from "../../../utils/perf-marks";
 import {
   backendRequest,
   initElectrobunBackend,
   onBackendMessage,
   replaceElectrobunCapabilityManifests,
+  sendElectrobunStall,
   setElectrobunRemoteRequestHandler,
 } from "./backend-rpc";
 import { installElectrobunCapabilityStreamClient } from "./capability-stream-client";
@@ -49,10 +51,13 @@ import { loadOfficialPluginIds } from "../../../plugins/marketplace/feed";
 import { setPluginSeedNotice } from "../../../plugins/seed-notice";
 import { crashReportsEnabled, installCrashReporter, reportCrash } from "../../../telemetry/crash-reports";
 import { browserDoNotTrack, installWindowCrashListeners } from "../../../telemetry/crash-reports-dom";
+import { forwardAttendedStalls } from "../../../telemetry/stall-reports-dom";
 import { currentTelemetryConfig } from "../../../telemetry/live-config";
 import { attentionCountsEnabled, installAttentionCounter } from "../../../telemetry/attention-counts";
 import { installUsageCounter, usageCountsEnabled } from "../../../telemetry/usage-counts";
 import { installWindowUsageFlush } from "../../../telemetry/usage-counts-dom";
+import { cloudSyncController } from "../../../sync/controller";
+import { createViewIdMirror, restoreViewIds, viewIdStorage } from "./view-ids";
 
 // Declared here rather than sniffed: the desktop view and the hosted browser
 // app are both browser contexts but differ in what plugins may do.
@@ -156,6 +161,8 @@ async function boot() {
     officialPluginIds: loadOfficialPluginIds,
   });
   installAttentionCounter(() => !init.telemetry.optedOut && !browserDoNotTrack() && attentionCountsEnabled(currentTelemetryConfig(init.config)));
+  // Desktop has no Debug Log: this window's freezes go to the Bun process, which keeps the stall log.
+  setStallSink(forwardAttendedStalls(sendElectrobunStall).sink);
   installElectrobunCapabilityStreamClient();
   installFocusScopeRelease();
   installElectrobunWindowFullscreenTracking();
@@ -173,10 +180,26 @@ async function boot() {
   const desktopApplicationMenuBridge: DesktopApplicationMenuBridge = {
     subscribe: (listener) => onBackendMessage("application-menu.select", ({ command }) => listener(command)),
   };
+  // Before anything reads them: ids this view's storage lacks come back from
+  // the copy on disk, and the main window keeps that copy up to date. The sync
+  // id is made at the first push, and a gloom.sh link can bring a visitor id.
+  const viewStorage = viewIdStorage();
+  if (viewStorage) restoreViewIds(viewStorage, init.viewIds);
+  const mirrorViewIds = viewStorage && init.windowKind === "main"
+    ? createViewIdMirror(viewStorage, init.viewIds, (ids) => backendRequest("host.saveViewIds", { ids }))
+    : () => {};
+  mirrorViewIds();
+  cloudSyncController.subscribe(mirrorViewIds);
   initializeDesktopResearchActivity();
-  const desktopDeepLinkBridge = observeDesktopDeepLinks({
+  const observedDeepLinks = observeDesktopDeepLinks({
     subscribe: (listener) => onBackendMessage("desktop.deepLink", listener),
   });
+  const desktopDeepLinkBridge: typeof observedDeepLinks = {
+    subscribe: (listener) => observedDeepLinks.subscribe((deeplink) => {
+      listener(deeplink);
+      mirrorViewIds();
+    }),
+  };
   const webUiHost = createWebUiHost(init.desktopPlatform);
   // Compiled by the Bun process, which owns the filesystem. A failure here must
   // not stop the app from starting: the marketplace reports broken plugins, and

package/src/renderers/electrobun/view/news-source.ts

@@ -10,7 +10,8 @@ interface BackendNews {
   getNewsPage(query: NewsQuery): Promise<NewsPage>;
 }
 
-type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "getCloudNewsStory" | "searchCloudNews">;
+type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "getCloudNewsStory" | "searchCloudNews">
+  & Partial<Pick<typeof apiClient, "hasSessionCredential">>;
 
 /**
  * The view's only news source: the desktop view runs without capability
@@ -32,6 +33,7 @@ export function createDesktopNewsSource(backend: BackendNews, client: CloudNewsC
           return {
             articles: cloudNewsReadArticles(read, query.ticker),
             nextCursor: read.nextCursor ?? null,
+            access: read.access ?? null,
           };
         } catch {
           // The aggregate page keeps RSS failures beside any usable stories.

package/src/renderers/electrobun/view/remote/ticker-repository.ts

@@ -1,5 +1,6 @@
 import type { TickerMetadata, TickerRecord } from "../../../../types/ticker";
 import { backendRequest } from "../backend-rpc";
+import { runTickerWrite } from "../../../../data/ticker-writes";
 
 export class RemoteTickerRepository {
   async loadAllTickers(): Promise<TickerRecord[]> {
@@ -10,17 +11,23 @@ export class RemoteTickerRepository {
     return backendRequest("ticker.load", { symbol });
   }
 
-  async saveTicker(ticker: TickerRecord): Promise<void> {
-    await backendRequest("ticker.save", { ticker });
+  saveTicker(ticker: TickerRecord): Promise<void> {
+    return runTickerWrite(this, ticker.metadata.ticker, async () => {
+      await backendRequest("ticker.save", { ticker });
+    });
   }
 
-  async createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
+  createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
     const ticker: TickerRecord = { metadata };
-    await this.saveTicker(ticker);
-    return ticker;
+    return runTickerWrite(this, metadata.ticker, async () => {
+      await backendRequest("ticker.save", { ticker });
+      return ticker;
+    });
   }
 
-  async deleteTicker(symbol: string): Promise<void> {
-    await backendRequest("ticker.delete", { symbol });
+  deleteTicker(symbol: string): Promise<void> {
+    return runTickerWrite(this, symbol, async () => {
+      await backendRequest("ticker.delete", { symbol });
+    });
   }
 }