gloomberb 0.11.1 → 0.11.2

package/src/plugins/prediction-markets/detail/trades.tsx

@@ -1,3 +1,4 @@
+import { useEffect, useState } from "react";
 import { DataTableView, type DataTableColumn } from "../../../components";
 import { colors } from "../../../theme/colors";
 import { formatNumber } from "../../../utils/format";
@@ -24,20 +25,44 @@ export function PredictionMarketTradesView({
   trades: PredictionTrade[];
   width: number;
 }) {
+  const visibleTrades = trades.slice(0, 30);
+  const [selectedIndex, setSelectedIndex] = useState<number | null>(() =>
+    visibleTrades.length > 0 ? 0 : null,
+  );
+
+  useEffect(() => {
+    setSelectedIndex((current) => {
+      if (visibleTrades.length === 0) return null;
+      if (current == null || current >= visibleTrades.length) return 0;
+      return current;
+    });
+  }, [visibleTrades.length]);
+
   return (
     <DataTableView<PredictionTrade, TradeColumn>
       focused={focused}
-      keyboardNavigation={false}
+      keyboardNavigation={focused}
       rootWidth={width}
       rootBackgroundColor={colors.panel}
-      selection={{ kind: "none" }}
+      selection={{
+        kind: "index",
+        selectedIndex,
+        onChange: (index) => setSelectedIndex(index),
+      }}
       columns={TRADE_COLUMNS}
-      items={trades.slice(0, 30)}
+      items={visibleTrades}
       sortColumnId={null}
       sortDirection="asc"
       onHeaderClick={() => {}}
       getItemKey={(trade) => trade.id}
-      renderCell={(trade, column) => {
+      onRowMouseDown={(_trade, index, event) => {
+        event.preventDefault();
+        setSelectedIndex(index);
+        return true;
+      }}
+      renderCell={(trade, column, _index, rowState) => {
+        const color = (fallback: string) =>
+          rowState.selected ? undefined : fallback;
         const tradeColor = trade.side === "buy" ? colors.positive : colors.negative;
         switch (column.id) {
           case "time":
@@ -45,27 +70,27 @@ export function PredictionMarketTradesView({
               text: new Date(trade.timestamp).toLocaleTimeString("en-US", {
                 hour12: false,
               }),
-              color: colors.textDim,
+              color: color(colors.textDim),
             };
           case "side":
             return {
               text: trade.side.toUpperCase(),
-              color: tradeColor,
+              color: color(tradeColor),
             };
           case "outcome":
             return {
               text: trade.outcome.toUpperCase(),
-              color: colors.text,
+              color: color(colors.text),
             };
           case "price":
             return {
               text: formatPredictionProbability(trade.price),
-              color: tradeColor,
+              color: color(tradeColor),
             };
           case "size":
             return {
               text: formatNumber(trade.size, 0),
-              color: colors.textDim,
+              color: color(colors.textDim),
             };
         }
       }}

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

@@ -1,4 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
+import { act } from "react";
 import { testRender } from "../../renderers/opentui/test-utils";
 import {
   ChartHarness,
@@ -32,7 +33,7 @@ describe("prediction markets detail views", () => {
     expect(frame).not.toContain("TypeError");
   });
 
-  test("renders grouped selections as ranked outcomes in the detail overview", async () => {
+  test("renders grouped outcomes with their chart directly below", async () => {
     testSetup = await testRender(<GroupedDetailHarness />, {
       width: 64,
       height: 24,
@@ -43,6 +44,9 @@ describe("prediction markets detail views", () => {
     expect(frame).toContain("Outcomes");
     expect(frame).toContain("Above 4.25%");
     expect(frame).toContain("Above 4.50%");
+    expect(frame).toContain("1M");
+    expect(frame.indexOf("1M")).toBeGreaterThan(frame.indexOf("Above 4.50%"));
+    expect(frame).not.toContain(" Chart ");
     expect(frame).not.toContain("Ranked by implied YES probability.");
     expect(frame).not.toContain("TOP Above 4.25%");
     expect(frame).not.toContain("Kalshi");
@@ -59,9 +63,32 @@ describe("prediction markets detail views", () => {
     const frame = testSetup.captureCharFrame();
     expect(frame).toContain("Outcomes");
     expect(frame).toContain("Above 4.25%");
-    expect(frame).toContain("Chart");
+    expect(frame).toContain("Loading chart...");
     expect(frame).not.toContain("No chart history.");
     expect(frame).not.toContain("Loading market detail...");
   });
 
+  test("shows the chart crosshair on pointer movement", async () => {
+    testSetup = await testRender(
+      <ChartHarness
+        history={[
+          { date: "2026-04-01T00:00:00Z", close: 0.45 },
+          { date: "2026-04-02T00:00:00Z", close: 0.48 },
+          { date: "2026-04-03T00:00:00Z", close: 0.51 },
+        ]}
+      />,
+      { width: 80, height: 12 },
+    );
+    await flushFrames(testSetup);
+    const initialFrame = testSetup.captureCharFrame();
+
+    await act(async () => {
+      await testSetup!.mockMouse.moveTo(30, 5);
+      await testSetup!.renderOnce();
+    });
+    await flushFrames(testSetup);
+
+    expect(testSetup.captureCharFrame()).not.toBe(initialFrame);
+  });
+
 });

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

@@ -1,4 +1,5 @@
 import type { GloomPlugin, GloomPluginContext } from "../../types/plugin";
+import { resolvePaneInstance } from "../../types/config";
 import { parsePredictionSearchShortcut } from "./navigation";
 import { PredictionMarketsPane } from "./pane";
 import { attachPredictionMarketsPersistence, resetPredictionMarketsPersistence } from "./services/fetch";
@@ -15,10 +16,13 @@ const MAIN_INSTANCE_ID = `${PANE_ID}:main`;
 
 function openPredictionMarkets(ctx: GloomPluginContext, query = ""): void {
   const parsed = parsePredictionSearchShortcut(query);
-  ctx.resume.setPaneState(MAIN_INSTANCE_ID, "venueScope", parsed.venueScope);
-  ctx.resume.setPaneState(MAIN_INSTANCE_ID, "searchQuery", parsed.searchQuery);
-  ctx.resume.setPaneState(MAIN_INSTANCE_ID, "selectedMarketKey", null);
-  ctx.focusPane(PANE_ID);
+  const existingInstanceId = resolvePaneInstance(ctx.getConfig().layout, PANE_ID)?.instanceId;
+  const targetInstanceId = existingInstanceId ?? MAIN_INSTANCE_ID;
+  ctx.resume.setPaneState(targetInstanceId, "venueScope", parsed.venueScope);
+  ctx.resume.setPaneState(targetInstanceId, "searchQuery", parsed.searchQuery);
+  ctx.resume.setPaneState(targetInstanceId, "selectedRowKey", null);
+  ctx.resume.setPaneState(targetInstanceId, "selectedDetailMarketKey", null);
+  ctx.focusPane(existingInstanceId ?? PANE_ID);
 }
 
 export const predictionMarketsPlugin: GloomPlugin = {

package/src/plugins/prediction-markets/navigation.ts

@@ -28,7 +28,6 @@ export const DETAIL_TABS: ReadonlyArray<{
   value: PredictionDetailTab;
 }> = [
   { label: "Overview", value: "overview" },
-  { label: "Chart", value: "chart" },
   { label: "Book", value: "book" },
   { label: "Trades", value: "trades" },
   { label: "Rules", value: "rules" },

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

@@ -262,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

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/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/cloud-transport.test.ts

@@ -24,6 +24,42 @@ test("browser cloud transport uses host cookies without forwarding forbidden hea
   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();

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

@@ -1,8 +1,27 @@
 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");

package/src/renderers/browser/config-host.ts

@@ -56,7 +56,3 @@ export function createBrowserConfigStore(storage: StorageLike): ConfigStoreHost
 export function installBrowserConfigStore(storage: StorageLike = localStorage): void {
   setConfigStoreHost(createBrowserConfigStore(storage));
 }
-
-export async function loadBrowserConfig(store = createBrowserConfigStore(localStorage)): Promise<AppConfig> {
-  return store.loadConfig(BROWSER_DATA_DIR);
-}

package/src/renderers/browser/deeplink-bridge.test.ts

@@ -0,0 +1,41 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { createBrowserDeepLinkBridge } from "./deeplink-bridge";
+
+const originalWindow = globalThis.window;
+
+afterEach(() => {
+  if (originalWindow === undefined) delete (globalThis as { window?: unknown }).window;
+  else Object.defineProperty(globalThis, "window", { configurable: true, value: originalWindow });
+});
+
+describe("browser social share handoff", () => {
+  test("maps a valid pane share query to the common deep-link runtime", () => {
+    const id = "0123456789abcdef0123456789abcdef";
+    Object.defineProperty(globalThis, "window", {
+      configurable: true,
+      value: {
+        location: { search: `?share=${id}` },
+        addEventListener() {},
+        removeEventListener() {},
+      },
+    });
+    const seen: string[] = [];
+    createBrowserDeepLinkBridge().subscribe((deeplink) => seen.push(deeplink.url));
+    expect(seen).toEqual([`gloomberb://share/${id}`]);
+  });
+
+  test("prefers a shared layout query", () => {
+    const id = "fedcba9876543210fedcba9876543210";
+    Object.defineProperty(globalThis, "window", {
+      configurable: true,
+      value: {
+        location: { search: `?layout=${id}&share=0123456789abcdef0123456789abcdef` },
+        addEventListener() {},
+        removeEventListener() {},
+      },
+    });
+    const seen: string[] = [];
+    createBrowserDeepLinkBridge().subscribe((deeplink) => seen.push(deeplink.url));
+    expect(seen).toEqual([`gloomberb://layout/${id}`]);
+  });
+});

package/src/renderers/browser/deeplink-bridge.ts

@@ -0,0 +1,22 @@
+import { marketplaceLayoutIdFromSearch } from "../../layout-marketplace/api";
+import { paneShareIdFromSearch } from "../../shares/location";
+import type { DesktopDeepLinkBridge } from "../../types/desktop-deeplink";
+
+export function createBrowserDeepLinkBridge(): DesktopDeepLinkBridge {
+  return {
+    subscribe(listener) {
+      const emit = () => {
+        const layoutId = marketplaceLayoutIdFromSearch(window.location.search);
+        if (layoutId) {
+          listener({ url: `gloomberb://layout/${layoutId}` });
+          return;
+        }
+        const shareId = paneShareIdFromSearch(window.location.search);
+        if (shareId) listener({ url: `gloomberb://share/${shareId}` });
+      };
+      emit();
+      window.addEventListener("popstate", emit);
+      return () => window.removeEventListener("popstate", emit);
+    },
+  };
+}

package/src/renderers/browser/main.tsx

@@ -19,6 +19,7 @@ import {
 } from "./cloud-transport";
 import { BROWSER_DATA_DIR, installBrowserConfigStore } from "./config-host";
 import { browserRendererHost, browserUiHost } from "./ui-host";
+import { createBrowserDeepLinkBridge } from "./deeplink-bridge";
 
 const rootElement = document.getElementById("root");
 if (!rootElement) throw new Error("Missing root element");
@@ -34,6 +35,7 @@ async function boot(): Promise<void> {
   await restoreBrowserCloudSession();
   const config = await loadConfig(BROWSER_DATA_DIR);
   applyLanguageFromConfig(config);
+  const deepLinkBridge = createBrowserDeepLinkBridge();
   root.render(
     <BrowserErrorBoundary>
       <UiHostProvider ui={browserUiHost} renderer={browserRendererHost} nativeRenderer={webNativeRenderer}>
@@ -44,6 +46,7 @@ async function boot(): Promise<void> {
                 config={config}
                 servicesFactory={createBrowserAppServices}
                 plugins={getBrowserBuiltinPlugins()}
+                desktopDeepLinkBridge={deepLinkBridge}
                 updatesEnabled={false}
               />
             </WebDialogHostProvider>

package/src/renderers/cloudflare/worker.test.ts

@@ -34,11 +34,14 @@ describe("static Cloudflare host", () => {
     expect(response.headers.get("cache-control")).toBe("no-store");
   });
 
-  test("rewrites only valid public share paths to the slim document", async () => {
-    const { env, requests } = fixture();
-    const response = await handleRequest(new Request("https://term.example/s/0123456789abcdef0123456789abcdef"), env);
-    expect(new URL(requests[0]!.url).pathname).toBe("/share.html");
-    expect(response.headers.get("x-robots-tag")).toBe("noindex, nofollow, noarchive");
+  test("rewrites valid pane and layout share paths to the slim document", async () => {
+    const id = "0123456789abcdef0123456789abcdef";
+    for (const prefix of ["s", "l"]) {
+      const { env, requests } = fixture();
+      const response = await handleRequest(new Request(`https://term.example/${prefix}/${id}`), env);
+      expect(new URL(requests[0]!.url).pathname).toBe("/share.html");
+      expect(response.headers.get("x-robots-tag")).toBe("noindex, nofollow, noarchive");
+    }
   });
 
   test("serves the Apple app site association without touching static assets", async () => {