@gloom-sh/terminal 0.18.5 → 0.19.0

package/src/renderers/dom/desktop/query-bar.tsx

@@ -1,6 +1,7 @@
 /** @jsxImportSource react */
 import { useCallback, useContext, useEffect, useLayoutEffect, useRef, useState, type CSSProperties, type ReactNode } from "react";
 import type { HostQueryBarItem, HostQueryBarProps } from "../../../ui/host";
+import { withChoiceGroupHeadings } from "../../../components/ui/choice-groups";
 import { WebPopover } from "./popover";
 import { WebMenu } from "./menu";
 import { useHorizontalOverflow } from "../host/overflow-fade";
@@ -75,15 +76,16 @@ function QueryMenu({ item, onClose }: { item: HostQueryBarItem; onClose: () => v
     <WebMenu
       label={item.label}
       selection={item.kind === "multi" ? "multi" : "single"}
-      items={item.options.map((option) => ({
+      items={withChoiceGroupHeadings(item.options.map((option) => ({
         id: option.value,
         label: option.label,
+        group: option.group,
         description: option.description,
         disabled: option.disabled,
         selected: item.kind === "select" ? option.selected : undefined,
         checked: item.kind === "multi" ? option.selected : undefined,
         color: option.color,
-      }))}
+      })))}
       onSelect={(value) => {
         item.onSelect(value);
         if (item.kind === "select") onClose();

package/src/renderers/dom/desktop/select-field.tsx

@@ -5,6 +5,7 @@ import { WEB_CELL_HEIGHT } from "../../../theme/font-scale";
 import { Box } from "../../../ui";
 import { MenuPopover } from "../../../components/ui/menu";
 import type { SelectFieldHandle, SelectFieldProps } from "../../../components/ui/select-field";
+import { withChoiceGroupHeadings } from "../../../components/ui/choice-groups";
 import { WebIcon } from "./icons";
 import { isInsideDialogSurface } from "../host/focus-scope";
 
@@ -136,13 +137,14 @@ export function WebSelectField({
         minWidth={typeof resolvedWidth === "number" ? Math.max(160, resolvedWidth) : 170}
         items={[
           ...(showUnset ? [{ id: UNSET_VALUE, label: "Unset", selected: true, disabled: true }] : []),
-          ...options.map((option) => ({
+          ...withChoiceGroupHeadings(options.map((option) => ({
             id: option.value,
             label: option.label,
+            group: option.group,
             description: option.description,
             disabled: option.disabled,
             selected: option.value === value,
-          })),
+          }))),
         ]}
         onSelect={(id) => {
           if (id !== UNSET_VALUE && id !== value) onChange(id);

package/src/renderers/dom/host/chart-surface.tsx

@@ -168,6 +168,27 @@ const ChartVectors = memo(function ChartVectors({ vectors }: { vectors: readonly
           />
         ))
         : [])}
+      {vectors.map((shape) => shape.label && shape.points[0]
+        ? (
+          <div
+            key={`${shape.id}:label`}
+            style={{
+              position: "absolute",
+              left: `${shape.points[0].x * 100}%`,
+              top: `${shape.points[0].y * 100}%`,
+              transform: "translate(2px, -100%)",
+              color: shape.color,
+              fontSize: "var(--gloom-type-caption)",
+              lineHeight: 1.2,
+              whiteSpace: "nowrap",
+              pointerEvents: "none",
+              zIndex: 10,
+            }}
+          >
+            {shape.label}
+          </div>
+        )
+        : null)}
     </>
   );
 });

package/src/renderers/electrobun/bun/desktop/app-name.ts

@@ -3,7 +3,7 @@ import { access, lstat, readFile, readlink, rename, rm, symlink } from "fs/promi
 import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
 import { HOMEBREW_PREFIXES, macCommandFolders } from "../../../../updater/command-names";
 import { logFailure } from "../../../../utils/log-failure";
-import { DESKTOP_APP_IDENTIFIER, DESKTOP_APP_NAME, LEGACY_DESKTOP_APP_NAME } from "../../shared/app-name";
+import { DESKTOP_APP_NAME, isDesktopAppIdentifier, LEGACY_DESKTOP_APP_NAME } from "../../shared/app-name";
 
 /**
  * A Mac install from before the rename is `Gloomberb.app`, and its updater
@@ -171,7 +171,7 @@ export async function renameLegacyMacApp(options: MacAppNameOptions): Promise<Ma
 
   const renamed = join(dirname(bundle), APP_BUNDLE);
   const occupied = await exists(renamed);
-  if (occupied && await bundleIdentifier(renamed) !== DESKTOP_APP_IDENTIFIER) return { kind: "skipped", reason: "name-taken" };
+  if (occupied && !isDesktopAppIdentifier(await bundleIdentifier(renamed))) return { kind: "skipped", reason: "name-taken" };
   const links = await movableLinks(bundle, options);
   if (!links) return { kind: "skipped", reason: "command-folder-not-writable" };
 
@@ -209,7 +209,7 @@ export async function removeLegacyMacApp(options: MacAppNameOptions): Promise<st
   const bundle = runningBundle(options.execPath);
   if (!bundle || basename(bundle) !== APP_BUNDLE) return null;
   const legacy = join(dirname(bundle), LEGACY_APP_BUNDLE);
-  if (!(await exists(legacy)) || await bundleIdentifier(legacy) !== DESKTOP_APP_IDENTIFIER) return null;
+  if (!(await exists(legacy)) || !isDesktopAppIdentifier(await bundleIdentifier(legacy))) return null;
   if (await managedByHomebrew(options.homebrewPrefixes ?? HOMEBREW_PREFIXES)) return null;
   const links = await movableLinks(legacy, options);
   if (!links) return null;

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

@@ -16,11 +16,14 @@ import { startRemoteControlServer, type RemoteControlServer } from "../../../../
 import type { RemoteControlRequest, RemoteControlResponse } from "../../../../remote/types";
 import { installCrashReporter } from "../../../../telemetry/crash-reports";
 import { createNodeCrashReporterHost } from "../../../../telemetry/crash-reports-node";
+import { installStallReporter, parseStallEvent, recordStall } from "../../../../telemetry/stall-reports";
+import { createNodeStallReporterHost } from "../../../../telemetry/stall-reports-node";
 import { installUpdateFailureReporter, reviewLastUpdateAttempt } from "../../../../telemetry/update-failures";
 import { createNodeUpdateFailureHost } from "../../../../telemetry/update-failures-node";
 import type { AppConfig } from "../../../../types/config";
 import { linkDesktopCommands } from "../../../../updater/command-names";
 import { debugLog } from "../../../../utils/debug-log";
+import { setStallSink, startMainThreadStallMonitor } from "../../../../utils/main-thread-stall";
 import type { DesktopSharedStateSnapshot } from "../../../../types/desktop-window";
 import type {
   ContextMenuSelectMessage,
@@ -156,6 +159,10 @@ export class DesktopBackend {
       }));
       reviewLastUpdateAttempt();
       void removeUpdateAsides();
+      // Desktop has no Debug Log: freezes of this process and of its windows go to the stall log in the data folder.
+      installStallReporter(createNodeStallReporterHost({ getDataDir: () => this.config?.dataDir ?? null }));
+      setStallSink((event) => recordStall("app", event));
+      startMainThreadStallMonitor();
     }
     // The native menu shows the same accelerators the keys use, so a rebind
     // rebuilds it.
@@ -259,6 +266,10 @@ export class DesktopBackend {
           "host.restart": (message) => {
             this.restart(message);
           },
+          "runtime.stall": (message) => {
+            const event = parseStallEvent(message);
+            if (event) recordStall("window", event);
+          },
         },
       },
     });
@@ -564,6 +575,7 @@ export class DesktopBackend {
       case "host.notify":
       case "host.showContextMenu":
       case "host.saveBootFrame":
+      case "host.saveViewIds":
       case "host.setAppBadge":
         return handleDesktopHostRequest(this, rpc, request);
       case "update.check":

package/src/renderers/electrobun/bun/desktop/host-requests.ts

@@ -13,6 +13,7 @@ import { applyDesktopWindowControl } from "../window/controls";
 import { saveTextFileToDownloads } from "../../../../utils/save-text-file";
 import { setAppBadge } from "./app-badge";
 import { desktopBootFramePath, saveDesktopBootFrame } from "../window/boot-frame";
+import { saveDesktopViewIds } from "./view-ids";
 import type { DesktopBackend, DesktopRpc } from "./backend";
 
 function normalizeText(value: unknown): string | undefined {
@@ -162,6 +163,12 @@ export async function handleDesktopHostRequest(
         session: backend.config !== null,
       });
       return null;
+    case "host.saveViewIds":
+      // The main window's view keeps them; its popped-out panes share its storage.
+      if (backend.rpcs.getRpcWindowKey(rpc) === MAIN_WINDOW_RPC_KEY && backend.config) {
+        saveDesktopViewIds(backend.config.dataDir, request.payload.ids);
+      }
+      return null;
     case "host.setAppBadge":
       // One badge for the app, from the main window; a popped-out pane's view
       // has its own chat state and must not overwrite it.

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

@@ -24,6 +24,7 @@ import type { CapabilityRegistry } from "../../../../capabilities";
 import { telemetryOptedOut } from "../../../../telemetry/crash-reports";
 import { describeNodeOs, readOrCreateInstallId } from "../../../../telemetry/crash-reports-node";
 import type { DesktopBackend, DesktopRpc } from "./backend";
+import { readDesktopViewIds } from "./view-ids";
 
 interface DesktopWindowTarget {
   kind: "main" | "detached";
@@ -94,6 +95,7 @@ function buildInitializationPayload(
       homeDir: homedir(),
       optedOut: telemetryOptedOut(process.env),
     },
+    viewIds: readDesktopViewIds(config.dataDir),
   };
 }
 

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";
@@ -145,24 +145,101 @@ export function firstTarPath(bytes: Uint8Array): string | null {
   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 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
+ * 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 removeLegacyUpdateArchives(folder: string): Promise<string[]> {
+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);
-    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;
-    const done = await rm(path, { force: true }).then(() => true, logFailure("desktop-update", "Could not remove an update archive from before the rename", false));
+    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;
@@ -343,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, {
@@ -529,8 +612,8 @@ export function createElectrobunDesktopUpdater(
       }
       target = result.release;
 
-      const appData = await updater.appDataFolder?.().catch(() => null);
-      if (appData) await removeLegacyUpdateArchives(join(appData, "self-extraction"));
+      const extraction = await extractionFolder();
+      if (extraction) await removeUnusableUpdateArchives(extraction);
       await updater.downloadUpdate();
       const updateInfo = updater.updateInfo();
       if (updateInfo?.error) {
@@ -541,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`).
@@ -570,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);
@@ -580,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.
@@ -610,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/shared/app-name.ts

@@ -15,3 +15,16 @@ export const LEGACY_DESKTOP_APP_NAME = "Gloomberb";
  * 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/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 });
+    });
   }
 }