gloomberb 0.11.0 → 0.11.2

package/src/plugins/prediction-markets/pane.test.tsx

@@ -340,6 +340,83 @@ describe("prediction markets pane interactions", () => {
     expect(frame).toContain("/ search markets");
   });
 
+  test("navigates the book and trades tables with arrow keys", async () => {
+    installPredictionMarketMocks();
+
+    testSetup = await testRender(<Harness />, { width: 120, height: 34 });
+    await flushFrames(testSetup);
+    await emitKeypress(testSetup, { name: "j", sequence: "j" });
+    await emitKeypress(testSetup, { name: "enter", sequence: "\r" });
+    await flushFrames(testSetup);
+
+    let rows = testSetup.captureCharFrame().split("\n");
+    const detailTabsRow = rows.findIndex((line) =>
+      line.includes("Overview") && line.includes("Book") && line.includes("Trades"),
+    );
+    const bookColumn = rows[detailTabsRow]!.indexOf("Book");
+    await act(async () => {
+      await testSetup!.mockMouse.click(bookColumn, detailTabsRow);
+      await testSetup!.renderOnce();
+    });
+    await flushFrames(testSetup);
+
+    rows = testSetup.captureCharFrame().split("\n");
+    let headerRow = rows.findIndex((line) =>
+      line.includes("OUT") && line.includes("SIDE") && line.includes("PRICE"),
+    );
+    expect(headerRow).toBeGreaterThanOrEqual(0);
+    let spans = testSetup.captureSpans().lines;
+    const bookFirstBefore = spans[headerRow + 1]!.spans.find(
+      (span) => span.text.trim(),
+    )!.bg;
+    const bookSecondBefore = spans[headerRow + 2]!.spans.find(
+      (span) => span.text.trim(),
+    )!.bg;
+    expect(bookFirstBefore).not.toEqual(bookSecondBefore);
+
+    await emitKeypress(testSetup, { name: "down", sequence: "\u001b[B" });
+    await flushFrames(testSetup);
+    spans = testSetup.captureSpans().lines;
+    expect(
+      spans[headerRow + 1]!.spans.find((span) => span.text.trim())!.bg,
+    ).toEqual(bookSecondBefore);
+    expect(
+      spans[headerRow + 2]!.spans.find((span) => span.text.trim())!.bg,
+    ).toEqual(bookFirstBefore);
+
+    rows = testSetup.captureCharFrame().split("\n");
+    const tradesColumn = rows[detailTabsRow]!.indexOf("Trades");
+    await act(async () => {
+      await testSetup!.mockMouse.click(tradesColumn, detailTabsRow);
+      await testSetup!.renderOnce();
+    });
+    await flushFrames(testSetup);
+
+    rows = testSetup.captureCharFrame().split("\n");
+    headerRow = rows.findIndex((line) =>
+      line.includes("TIME") && line.includes("SIDE") && line.includes("PRICE"),
+    );
+    expect(headerRow).toBeGreaterThanOrEqual(0);
+    spans = testSetup.captureSpans().lines;
+    const tradeFirstBefore = spans[headerRow + 1]!.spans.find(
+      (span) => span.text.trim(),
+    )!.bg;
+    const tradeSecondBefore = spans[headerRow + 2]!.spans.find(
+      (span) => span.text.trim(),
+    )!.bg;
+    expect(tradeFirstBefore).not.toEqual(tradeSecondBefore);
+
+    await emitKeypress(testSetup, { name: "down", sequence: "\u001b[B" });
+    await flushFrames(testSetup);
+    spans = testSetup.captureSpans().lines;
+    expect(
+      spans[headerRow + 1]!.spans.find((span) => span.text.trim())!.bg,
+    ).toEqual(tradeSecondBefore);
+    expect(
+      spans[headerRow + 2]!.spans.find((span) => span.text.trim())!.bg,
+    ).toEqual(tradeFirstBefore);
+  });
+
   test("supports detail outcome navigation and escape return from the keyboard", async () => {
     attachPredictionMarketsPersistence(new MemoryPersistence());
 

package/src/plugins/prediction-markets/pane.tsx

@@ -5,6 +5,7 @@ import {
   Spinner,
   Tabs,
   usePaneFooter,
+  useTableLoadMore,
   type DataTableKeyEvent,
   type DataTableRootKeyContext,
 } from "../../components";
@@ -238,6 +239,12 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
     watchlistedRowKeys,
   ]);
 
+  const onCatalogScroll = useTableLoadMore(
+    controller.scrollRef,
+    controller.catalogHasMore && !controller.catalogLoadingMore && !controller.detailOpen,
+    () => { void controller.actions.loadMoreCatalog(); },
+  );
+
   const handleRootKeyDown = useCallback((
     event: DataTableKeyEvent,
     context: DataTableRootKeyContext,
@@ -255,9 +262,13 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
       <Box
         flexDirection="column"
         flexGrow={1}
+        flexShrink={1}
+        flexBasis={0}
+        minHeight={0}
         width={width}
         height={Math.max(height - 1, 1)}
         paddingX={1}
+        overflow="hidden"
         backgroundColor={colors.panel}
       >
         <PredictionMarketDetailPane
@@ -314,6 +325,7 @@ export function PredictionMarketsPane({ focused, width, height }: PaneProps) {
       scrollRef={controller.scrollRef}
       getItemKey={(row) => row.key}
       virtualize
+      onBodyScrollActivity={onCatalogScroll}
       renderCell={renderCell}
       emptyContent={
         rowsLoading ? (

package/src/plugins/prediction-markets/plugin.test.tsx

@@ -1,4 +1,6 @@
 import { afterEach, describe, expect, test } from "bun:test";
+import { createDefaultConfig } from "../../types/config";
+import type { CommandDef } from "../../types/plugin";
 import {
   cleanupPredictionTest,
   installPredictionMarketMocks,
@@ -23,12 +25,46 @@ import {
   loadPolymarketDetail,
   normalizePolymarketMarket,
 } from "./services/polymarket/adapter";
+import { predictionMarketsPlugin } from "./index";
 
 afterEach(async () => {
   await cleanupPredictionTest();
 });
 
 describe("prediction markets plugin registration and services", () => {
+  test("routes search state to a materialized pane instance", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-prediction-command-test");
+    const instanceId = "prediction-markets:shared-test";
+    config.layout.instances.push({ instanceId, paneId: "prediction-markets" });
+    const commands: CommandDef[] = [];
+    const paneStateUpdates: Array<{ paneId: string; key: string; value: unknown }> = [];
+    const focused: string[] = [];
+
+    predictionMarketsPlugin.setup?.({
+      persistence: new MemoryPersistence(),
+      getConfig: () => config,
+      resume: {
+        setPaneState(paneId: string, key: string, value: unknown) {
+          paneStateUpdates.push({ paneId, key, value });
+        },
+      },
+      registerCommand: (command: CommandDef) => commands.push(command),
+      focusPane: (paneId: string) => focused.push(paneId),
+    } as any);
+
+    await commands.find((command) => command.id === "prediction-markets-search")?.execute({
+      query: "polymarket:fed",
+    });
+
+    expect(paneStateUpdates).toEqual([
+      { paneId: instanceId, key: "venueScope", value: "polymarket" },
+      { paneId: instanceId, key: "searchQuery", value: "fed" },
+      { paneId: instanceId, key: "selectedRowKey", value: null },
+      { paneId: instanceId, key: "selectedDetailMarketKey", value: null },
+    ]);
+    expect(focused).toEqual([instanceId]);
+  });
+
   test("uses fresh prediction resource cache without refetching", async () => {
     const persistence = new MemoryPersistence();
     attachPredictionMarketsPersistence(persistence);

package/src/plugins/prediction-markets/services/kalshi/adapter.ts

@@ -39,6 +39,23 @@ export { normalizeKalshiMarket } from "./normalize";
 const KALSHI_EVENT_PAGE_LIMIT = 200;
 const DEFAULT_KALSHI_EVENT_MAX_PAGES = 3;
 const SEARCH_KALSHI_EVENT_MAX_PAGES = 3;
+const kalshiCursors = new Map<string, string | null>();
+
+function kalshiCursorKey(searchQuery: string, categoryId: PredictionCategoryId): string {
+  return `${categoryId}:${searchQuery.trim().toLowerCase()}`;
+}
+
+function rememberKalshiCursor(
+  searchQuery: string,
+  categoryId: PredictionCategoryId,
+  cursor: string | null,
+): void {
+  kalshiCursors.set(kalshiCursorKey(searchQuery, categoryId), cursor);
+}
+
+export function kalshiCatalogCursor(searchQuery: string, categoryId: PredictionCategoryId): string | null {
+  return kalshiCursors.get(kalshiCursorKey(searchQuery, categoryId)) ?? null;
+}
 
 function kalshiSeriesTickerFromEvent(eventTicker: string | undefined): string | undefined {
   const trimmed = eventTicker?.trim().toUpperCase();
@@ -61,9 +78,10 @@ async function fetchKalshiCatalogEvents(
   maxPages = DEFAULT_KALSHI_EVENT_MAX_PAGES,
   limit = KALSHI_EVENT_PAGE_LIMIT,
   signal?: AbortSignal,
-): Promise<KalshiEventRecord[]> {
+  startCursor?: string,
+): Promise<{ events: KalshiEventRecord[]; nextCursor: string | null }> {
   const events: KalshiEventRecord[] = [];
-  let cursor: string | undefined;
+  let cursor: string | undefined = startCursor;
 
   for (let page = 0; page < maxPages; page += 1) {
     const response = await fetchJson<KalshiEventsResponse>(
@@ -75,7 +93,7 @@ async function fetchKalshiCatalogEvents(
     if (!cursor) break;
   }
 
-  return events;
+  return { events, nextCursor: cursor ?? null };
 }
 
 async function fetchKalshiCatalogEventsForCategory(
@@ -83,13 +101,15 @@ async function fetchKalshiCatalogEventsForCategory(
   maxPages = DEFAULT_KALSHI_EVENT_MAX_PAGES,
   limit = KALSHI_EVENT_PAGE_LIMIT,
   signal?: AbortSignal,
-): Promise<KalshiEventRecord[]> {
+  startCursor?: string,
+): Promise<{ events: KalshiEventRecord[]; nextCursor: string | null }> {
   const categories = getKalshiCategoryNames(categoryId);
-  if (categories.length === 0) return await fetchKalshiCatalogEvents(maxPages, limit, signal);
+  if (categories.length === 0) return await fetchKalshiCatalogEvents(maxPages, limit, signal, startCursor);
 
   const deduped = new Map<string, KalshiEventRecord>();
+  let nextCursor: string | null = null;
   for (const category of categories) {
-    let cursor: string | undefined;
+    let cursor: string | undefined = startCursor;
     for (let page = 0; page < maxPages; page += 1) {
       const response = await fetchJson<KalshiEventsResponse>(
         buildKalshiCatalogUrl(cursor, category, limit),
@@ -102,9 +122,10 @@ async function fetchKalshiCatalogEventsForCategory(
       cursor = response.cursor?.trim() || undefined;
       if (!cursor) break;
     }
+    nextCursor = cursor ?? nextCursor;
   }
 
-  return [...deduped.values()];
+  return { events: [...deduped.values()], nextCursor };
 }
 
 export async function loadKalshiCatalog(
@@ -120,15 +141,34 @@ export async function loadKalshiCatalog(
     "catalog",
     `${buildPredictionCatalogResourceKey("kalshi", categoryId, normalizedQuery)}:${requestedLimit}`,
     async () => {
-      const events = categoryId === "all"
+      const page = categoryId === "all"
         ? await fetchKalshiCatalogEvents(maxPages, pageLimit, options.signal)
         : await fetchKalshiCatalogEventsForCategory(categoryId, maxPages, pageLimit, options.signal);
-      return normalizeKalshiCatalog(events, normalizedQuery, categoryId).slice(0, requestedLimit);
+      rememberKalshiCursor(normalizedQuery, categoryId, page.nextCursor);
+      return normalizeKalshiCatalog(page.events, normalizedQuery, categoryId).slice(0, requestedLimit);
     },
     PREDICTION_CACHE_POLICIES.catalog,
   );
 }
 
+export async function loadMoreKalshiCatalog(
+  searchQuery: string,
+  categoryId: PredictionCategoryId,
+  cursor: string,
+  signal?: AbortSignal,
+): Promise<{ markets: PredictionMarketSummary[]; nextCursor: string | null; hasMore: boolean }> {
+  const normalizedQuery = searchQuery.trim().toLowerCase();
+  const page = categoryId === "all"
+    ? await fetchKalshiCatalogEvents(1, KALSHI_EVENT_PAGE_LIMIT, signal, cursor)
+    : await fetchKalshiCatalogEventsForCategory(categoryId, 1, KALSHI_EVENT_PAGE_LIMIT, signal, cursor);
+  rememberKalshiCursor(normalizedQuery, categoryId, page.nextCursor);
+  return {
+    markets: normalizeKalshiCatalog(page.events, normalizedQuery, categoryId),
+    nextCursor: page.nextCursor,
+    hasMore: !!page.nextCursor,
+  };
+}
+
 async function loadKalshiEvent(
   eventTicker: string | undefined,
 ): Promise<KalshiEventResponse | null> {

package/src/plugins/prediction-markets/services/polymarket/adapter.ts

@@ -30,6 +30,16 @@ export { loadPolymarketDetail } from "./detail";
 
 const POLYMARKET_CATALOG_OFFSETS = [0, 200, 400];
 const POLYMARKET_CATEGORY_OFFSETS = [0, 200];
+const POLYMARKET_PAGE_SIZE = 200;
+
+export function nextPolymarketCatalogOffset(
+  categoryId: PredictionCategoryId,
+  searchQuery = "",
+): number | null {
+  if (searchQuery.trim()) return null;
+  const offsets = categoryId === "all" ? POLYMARKET_CATALOG_OFFSETS : POLYMARKET_CATEGORY_OFFSETS;
+  return (offsets.at(-1) ?? 0) + POLYMARKET_PAGE_SIZE;
+}
 
 function buildPolymarketCatalogUrl(offset: number, tagSlug?: string, limit = 200): string {
   const url = new URL("https://gamma-api.polymarket.com/events");
@@ -144,3 +154,24 @@ export async function loadPolymarketCatalog(
     PREDICTION_CACHE_POLICIES.catalog,
   );
 }
+
+export async function loadMorePolymarketCatalog(
+  searchQuery: string,
+  categoryId: PredictionCategoryId,
+  offset: number,
+  signal?: AbortSignal,
+): Promise<{ markets: PredictionMarketSummary[]; hasMore: boolean; nextOffset: number }> {
+  if (searchQuery.trim()) {
+    return { markets: [], hasMore: false, nextOffset: offset };
+  }
+  const tagSlugs = categoryId === "all" ? [undefined] : getPolymarketCategoryTagSlugs(categoryId);
+  const pages = await Promise.all(
+    tagSlugs.map((tagSlug) => loadPolymarketCatalogPages([offset], tagSlug, POLYMARKET_PAGE_SIZE, signal).catch(() => [])),
+  );
+  const raw = pages.flat();
+  return {
+    markets: normalizePolymarketCatalog(raw, "", categoryId),
+    hasMore: raw.length >= POLYMARKET_PAGE_SIZE,
+    nextOffset: offset + POLYMARKET_PAGE_SIZE,
+  };
+}

package/src/plugins/prediction-markets/test-helpers.tsx

@@ -274,6 +274,15 @@ export function installPredictionMarketMocks() {
               count_fp: "50",
               created_time: "2026-04-01T00:00:00Z",
             },
+            {
+              trade_id: "kal-2",
+              ticker: "KAL-1",
+              taker_side: "no",
+              yes_price_dollars: "0.46",
+              no_price_dollars: "0.54",
+              count_fp: "40",
+              created_time: "2026-04-01T00:01:00Z",
+            },
           ],
         }),
         { status: 200 },

package/src/plugins/registry/index.ts

@@ -1,5 +1,6 @@
 import type { ReactNode } from "react";
 import type { AppPersistencePort, AppTickerRepositoryPort } from "../../core/app-service-ports";
+import type { LayoutMarketplacePayload } from "../../layout-marketplace/payload";
 import {
   connectionHealth as sharedConnectionHealth,
   type ConnectionHealthRegistry,
@@ -129,6 +130,7 @@ export class PluginRegistry implements PluginRuntimeAccess {
   showPaneFn: ((paneId: string) => void) = () => {};
   createPaneFromTemplateFn: ((templateId: string, options?: PaneTemplateCreateOptions) => void) = () => {};
   createPaneFromTemplateAsyncFn: ((templateId: string, options?: PaneTemplateCreateOptions) => Promise<void>) = async () => {};
+  openPortablePaneShareAsyncFn: ((layout: LayoutMarketplacePayload) => Promise<void>) = async () => {};
   hidePaneFn: ((paneId: string) => void) = () => {};
   focusPaneFn: ((paneId: string) => void) = () => {};
   pinTickerFn: ((symbol: string, options?: PinTickerOptions) => void) = () => {};

package/src/plugins/ticker-navigation.test.ts

@@ -7,6 +7,8 @@ import {
 } from "../types/config";
 import {
   findFixedTickerPaneForSymbol,
+  findTickerResearchFollower,
+  resolveTickerActivation,
   resolveTickerNavigationReplacementPane,
   shouldFocusTickerNavigationTarget,
 } from "./ticker-navigation";
@@ -26,6 +28,28 @@ function createLayout(instances: PaneInstanceConfig[]): LayoutConfig {
   };
 }
 
+describe("ticker source activation", () => {
+  test("focuses a bound follower unless the caller asks for a new pane", () => {
+    const layout = createLayout([
+      createPaneInstance("portfolio-list", {
+        instanceId: "portfolio-list:main",
+        binding: { kind: "none" },
+      }),
+      createPaneInstance("ticker-detail", {
+        instanceId: "ticker-detail:main",
+        binding: { kind: "follow", sourceInstanceId: "portfolio-list:main" },
+      }),
+    ]);
+
+    expect(findTickerResearchFollower(layout, "portfolio-list:main")?.instanceId).toBe("ticker-detail:main");
+    expect(resolveTickerActivation(layout, "portfolio-list:main")).toEqual({
+      kind: "focus",
+      paneId: "ticker-detail:main",
+    });
+    expect(resolveTickerActivation(layout, "portfolio-list:main", { newPane: true })).toEqual({ kind: "open" });
+  });
+});
+
 describe("resolveTickerNavigationReplacementPane", () => {
   test("only replaces the Ticker Research pane that opened ticker navigation", () => {
     const layout = createLayout([

package/src/plugins/ticker-navigation.ts

@@ -5,8 +5,48 @@ import {
   type LayoutConfig,
   type PaneInstanceConfig,
 } from "../types/config";
+import type { PaneDef } from "../types/plugin";
 import { isPaneInLayout } from "./pane-manager";
 
+/** Panes that publish a cursor symbol other panes can follow (`PaneDef.tickerSource`). */
+export function listVisibleTickerSourcePanes(
+  layout: LayoutConfig,
+  panes: ReadonlyMap<string, PaneDef>,
+): PaneInstanceConfig[] {
+  return layout.instances.filter((instance) => (
+    panes.get(instance.paneId)?.tickerSource === true
+    && isPaneInLayout(layout, instance.instanceId)
+  ));
+}
+
+/** The visible Ticker Research pane that follows `sourceInstanceId`, if any. */
+export function findTickerResearchFollower(
+  layout: LayoutConfig,
+  sourceInstanceId: string | null | undefined,
+): PaneInstanceConfig | null {
+  if (!sourceInstanceId) return null;
+  return layout.instances.find((instance) =>
+    instance.paneId === TICKER_RESEARCH_PANE_ID
+    && instance.binding?.kind === "follow"
+    && instance.binding.sourceInstanceId === sourceInstanceId
+    && isPaneInLayout(layout, instance.instanceId)
+  ) ?? null;
+}
+
+/**
+ * Enter opens the follower already bound to the source pane; Shift+Enter (`newPane`) and sources
+ * without a follower fall back to opening a ticker pane.
+ */
+export function resolveTickerActivation(
+  layout: LayoutConfig,
+  sourcePaneId: string | null | undefined,
+  options?: { newPane?: boolean },
+): { kind: "focus"; paneId: string } | { kind: "open" } {
+  if (options?.newPane) return { kind: "open" };
+  const follower = findTickerResearchFollower(layout, sourcePaneId);
+  return follower ? { kind: "focus", paneId: follower.instanceId } : { kind: "open" };
+}
+
 export function resolveTickerNavigationReplacementPane(
   layout: LayoutConfig,
   sourcePaneId: string | null,

package/src/remote/schema.ts

@@ -43,7 +43,7 @@ export const REMOTE_OPERATIONS: RemoteOperationSchema[] = [
   op("layout.delete", "Delete a layout.", "{ index: number }", "local-write"),
   op("layout.undo", "Undo last layout change.", "{}", "local-write"),
   op("layout.redo", "Redo last layout change.", "{}", "local-write"),
-  op("layout.gridlock", "Gridlock all visible panes into a dense layout.", "{}", "local-write"),
+  op("layout.gridlock", "Tidy all panes into a dense layout.", "{}", "local-write"),
   op("layout.closeFloating", "Close all floating panes in the active layout.", "{}", "local-write"),
   op("layout.placePane", "Move a pane to a layout region.", "{ paneId: string, region: 'left' | 'right' | 'top' | 'bottom' | 'floating', relativeTo?: string }", "local-write"),
   op("layout.focusRegion", "Focus a pane by visual layout region.", "{ region: 'left' | 'right' | 'top' | 'bottom' | 'center' }", "local-write"),

package/src/renderers/browser/app-services.ts

@@ -0,0 +1,61 @@
+import { newsProvider, type NewsCapability } from "../../capabilities";
+import type { AppRuntimeServices, AppServicesFactoryOptions } from "../../core/app-service-ports";
+import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../market-data/coordinator";
+import { NewsService } from "../../news/aggregator";
+import { setSharedNewsService } from "../../news/hooks";
+import { PluginRegistry } from "../../plugins/registry";
+import { createGloomberbCloudCapabilities, createGloomberbCloudProvider } from "../../sources/gloomberb-cloud";
+import { AssetDataRouter } from "../../sources/provider-router";
+import { BrowserPersistence } from "./persistence";
+import { BrowserTickerRepository } from "./ticker-repository";
+
+export function createBrowserAppServices({
+  config,
+  plugins,
+}: AppServicesFactoryOptions): AppRuntimeServices {
+  const persistence = new BrowserPersistence(localStorage);
+  const tickerRepository = new BrowserTickerRepository(localStorage);
+  const cloudProvider = createGloomberbCloudProvider();
+  const dataProvider = new AssetDataRouter(null, [cloudProvider]);
+  const marketData = new MarketDataCoordinator(dataProvider);
+  const cloudNews = createGloomberbCloudCapabilities(cloudProvider).find(
+    (capability): capability is NewsCapability => capability.kind === "news",
+  );
+  const pluginRegistry = new PluginRegistry(dataProvider, tickerRepository, persistence);
+  dataProvider.attachRegistry(pluginRegistry);
+  const newsService = new NewsService({
+    pollIntervalMs: () => Math.max(1, config.refreshIntervalMinutes) * 60_000,
+  });
+
+  pluginRegistry.getConfigFn = () => config;
+  pluginRegistry.getLayoutFn = () => config.layout;
+  pluginRegistry.registerNewsCapabilityFn = (capability) => newsService.register(capability);
+  pluginRegistry.watchNewsQueryFn = (query, listener) => newsService.watchQuery(query, listener);
+  newsService.register(newsProvider({
+    id: dataProvider.id,
+    name: dataProvider.name,
+    priority: 0,
+    provider: { fetchNews: (query) => cloudNews?.provider.fetchNews(query) ?? Promise.resolve([]) },
+  }));
+
+  setSharedMarketDataCoordinator(marketData);
+  setSharedNewsService(newsService);
+  const ready = Promise.all(plugins.map((plugin) => pluginRegistry.register(plugin))).then(() => {});
+  newsService.start();
+
+  return {
+    persistence,
+    tickerRepository,
+    dataProvider,
+    marketData,
+    pluginRegistry,
+    ready,
+    destroy() {
+      setSharedMarketDataCoordinator(null);
+      setSharedNewsService(null);
+      newsService.stop();
+      pluginRegistry.destroy();
+      persistence.close();
+    },
+  };
+}

package/src/renderers/browser/cloud-transport.test.ts

@@ -0,0 +1,68 @@
+import { afterEach, expect, spyOn, test } from "bun:test";
+import { apiClient } from "../../api-client";
+import {
+  browserCredentialedFetch,
+  restoreBrowserCloudSession,
+} from "./cloud-transport";
+
+const originalFetch = globalThis.fetch;
+afterEach(() => { globalThis.fetch = originalFetch; });
+
+test("browser cloud transport uses host cookies without forwarding forbidden headers", async () => {
+  let captured: RequestInit | undefined;
+  globalThis.fetch = (async (_url: string | URL | Request, init?: RequestInit) => {
+    captured = init;
+    return new Response("{}", { headers: { "content-type": "application/json" } });
+  }) as typeof fetch;
+  await browserCredentialedFetch("https://api.gloom.sh/auth/get-session", {
+    headers: { Cookie: "must-not-leak", Origin: "https://api.gloom.sh", Accept: "application/json" },
+  });
+  const headers = new Headers(captured?.headers);
+  expect(captured?.credentials).toBe("include");
+  expect(headers.has("Cookie")).toBe(false);
+  expect(headers.has("Origin")).toBe(false);
+  expect(headers.get("Accept")).toBe("application/json");
+});
+
+test("browser cloud transport plants session cookies before dropping the Cookie header", async () => {
+  const planted: string[] = [];
+  const previousDocument = (globalThis as { document?: unknown }).document;
+  (globalThis as { document?: { cookie: string } }).document = {
+    get cookie() {
+      return planted.join("; ");
+    },
+    set cookie(value: string) {
+      planted.push(value);
+    },
+  };
+  const previousLocation = (globalThis as { location?: unknown }).location;
+  (globalThis as { location?: { protocol: string } }).location = { protocol: "https:" };
+
+  globalThis.fetch = (async () => {
+    return new Response("{}", { headers: { "content-type": "application/json" } });
+  }) as typeof fetch;
+
+  try {
+    await browserCredentialedFetch("https://api.gloom.sh/auth/get-session", {
+      headers: {
+        Cookie: "__Secure-gloomberb.session_token=signed-token.value; gloomberb.session_token=signed-token.value",
+      },
+    });
+    expect(planted).toEqual([
+      "__Secure-gloomberb.session_token=signed-token.value; Path=/; SameSite=Lax; Secure",
+      "gloomberb.session_token=signed-token.value; Path=/; SameSite=Lax; Secure",
+    ]);
+  } finally {
+    if (previousDocument === undefined) delete (globalThis as { document?: unknown }).document;
+    else (globalThis as { document?: unknown }).document = previousDocument;
+    if (previousLocation === undefined) delete (globalThis as { location?: unknown }).location;
+    else (globalThis as { location?: unknown }).location = previousLocation;
+  }
+});
+
+test("browser boot restores an existing Gloom Cloud cookie session", async () => {
+  const getSession = spyOn(apiClient, "getSession").mockResolvedValue(null);
+  await restoreBrowserCloudSession();
+  expect(getSession).toHaveBeenCalledTimes(1);
+  getSession.mockRestore();
+});

package/src/renderers/browser/cloud-transport.ts

@@ -0,0 +1,48 @@
+import { apiClient, setCloudApiFetchTransport } from "../../api-client";
+import { setHttpFetchTransport } from "../../utils/http-transport";
+
+const SESSION_COOKIE_NAMES = ["__Secure-gloomberb.session_token", "gloomberb.session_token"] as const;
+
+function plantBrowserSessionCookies(cookieHeader: string): void {
+  if (typeof document === "undefined") return;
+  const secure = typeof location !== "undefined" && location.protocol === "https:";
+  for (const part of cookieHeader.split(";")) {
+    const trimmed = part.trim();
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0) continue;
+    const name = trimmed.slice(0, eq).trim();
+    const value = trimmed.slice(eq + 1);
+    if (!(SESSION_COOKIE_NAMES as readonly string[]).includes(name) || !value) continue;
+    const useSecure = secure || name.startsWith("__Secure-");
+    document.cookie = `${name}=${value}; Path=/; SameSite=Lax${useSecure ? "; Secure" : ""}`;
+  }
+}
+
+export function browserCredentialedFetch(url: string, init: RequestInit = {}): Promise<Response> {
+  const headers = new Headers(init.headers);
+  const cookieHeader = headers.get("Cookie");
+  if (cookieHeader) plantBrowserSessionCookies(cookieHeader);
+  // These are controlled by the browser. Desktop transports may set them, but
+  // carrying them into fetch would either fail or misrepresent the web origin.
+  headers.delete("Cookie");
+  headers.delete("Origin");
+  return fetch(url, { ...init, headers, credentials: "include" });
+}
+
+export function installBrowserFetchTransports(): void {
+  apiClient.setCookieSessionMode(true);
+  setCloudApiFetchTransport(browserCredentialedFetch);
+  setHttpFetchTransport((url, init) => fetch(url, init));
+}
+
+export async function restoreBrowserCloudSession(budgetMs = 5_000): Promise<void> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const deadline = new Promise<null>((resolve) => {
+    timer = setTimeout(() => resolve(null), budgetMs);
+  });
+  try {
+    await Promise.race([apiClient.getSession().catch(() => null), deadline]);
+  } finally {
+    clearTimeout(timer);
+  }
+}