gloomberb 0.13.3 → 0.14.0

package/src/api-client/views.ts

@@ -0,0 +1,125 @@
+import { ApiRequestError } from "./errors";
+import type { TeamPluginStateEntry, TeamView } from "./types";
+
+type CloudApiRequest = <T>(path: string, options?: RequestInit) => Promise<T>;
+
+/** A write refused because the server holds a newer revision. */
+export class TeamRevisionConflictError extends Error {
+  constructor(
+    message: string,
+    public readonly currentRevision: number,
+    public readonly current: unknown = null,
+  ) {
+    super(message);
+    this.name = "TeamRevisionConflictError";
+  }
+}
+
+function ifMatch(revision: number | undefined): Record<string, string> {
+  return revision ? { "if-match": String(revision) } : {};
+}
+
+export class CloudViewsApi {
+  constructor(private readonly request: CloudApiRequest) {}
+
+  async listTeamViews(teamId: string): Promise<TeamView[]> {
+    const body = await this.request<{ items?: TeamView[] }>(`/teams/${encodeURIComponent(teamId)}/views`);
+    return Array.isArray(body?.items) ? body.items : [];
+  }
+
+  async getTeamView(viewId: string): Promise<TeamView | null> {
+    try {
+      return await this.request<TeamView>(`/views/${encodeURIComponent(viewId)}`);
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 404) return null;
+      throw error;
+    }
+  }
+
+  async createTeamView(teamId: string, input: { name: string; spec: Record<string, unknown> }): Promise<TeamView> {
+    return this.request(`/teams/${encodeURIComponent(teamId)}/views`, {
+      method: "POST",
+      body: JSON.stringify(input),
+    });
+  }
+
+  async publishTeamViewRevision(
+    viewId: string,
+    input: { spec: Record<string, unknown>; name?: string; expectedRevision: number },
+  ): Promise<TeamView> {
+    try {
+      return await this.request<TeamView>(`/views/${encodeURIComponent(viewId)}`, {
+        method: "PUT",
+        headers: ifMatch(input.expectedRevision),
+        body: JSON.stringify({ spec: input.spec, ...(input.name ? { name: input.name } : {}) }),
+      });
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 412) {
+        const current = await this.getTeamView(viewId).catch(() => null);
+        throw new TeamRevisionConflictError(error.message, current?.revision ?? input.expectedRevision + 1, current);
+      }
+      throw error;
+    }
+  }
+
+  async renameTeamView(viewId: string, name: string): Promise<TeamView> {
+    return this.request(`/views/${encodeURIComponent(viewId)}`, { method: "PATCH", body: JSON.stringify({ name }) });
+  }
+
+  async deleteTeamView(viewId: string): Promise<void> {
+    await this.request(`/views/${encodeURIComponent(viewId)}`, { method: "DELETE" });
+  }
+
+  // Plugin state
+
+  async listTeamPluginState(teamId: string, pluginId: string): Promise<TeamPluginStateEntry[]> {
+    const body = await this.request<{ items: TeamPluginStateEntry[] }>(
+      `/teams/${encodeURIComponent(teamId)}/plugin-state/${encodeURIComponent(pluginId)}`,
+    );
+    return body.items;
+  }
+
+  async getTeamPluginState(teamId: string, pluginId: string, key: string): Promise<TeamPluginStateEntry | null> {
+    try {
+      return await this.request<TeamPluginStateEntry>(
+        `/teams/${encodeURIComponent(teamId)}/plugin-state/${encodeURIComponent(pluginId)}/${encodeURIComponent(key)}`,
+      );
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 404) return null;
+      throw error;
+    }
+  }
+
+  async putTeamPluginState(
+    teamId: string,
+    pluginId: string,
+    key: string,
+    value: unknown,
+    expectedRevision?: number,
+  ): Promise<TeamPluginStateEntry> {
+    try {
+      return await this.request<TeamPluginStateEntry>(
+        `/teams/${encodeURIComponent(teamId)}/plugin-state/${encodeURIComponent(pluginId)}/${encodeURIComponent(key)}`,
+        { method: "PUT", headers: ifMatch(expectedRevision), body: JSON.stringify({ value }) },
+      );
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 412) {
+        const current = await this.getTeamPluginState(teamId, pluginId, key).catch(() => null);
+        throw new TeamRevisionConflictError(error.message, current?.revision ?? (expectedRevision ?? 0) + 1, current);
+      }
+      throw error;
+    }
+  }
+
+  async deleteTeamPluginState(teamId: string, pluginId: string, key: string): Promise<void> {
+    try {
+      await this.request(
+        `/teams/${encodeURIComponent(teamId)}/plugin-state/${encodeURIComponent(pluginId)}/${encodeURIComponent(key)}`,
+        { method: "DELETE" },
+      );
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 404) return;
+      throw error;
+    }
+  }
+}

package/src/app/global-shortcuts.test.tsx

@@ -1,10 +1,10 @@
-import { afterEach, describe, expect, test } from "bun:test";
 import { createTestRenderer } from "@opentui/core/testing";
+import { afterEach, describe, expect, test } from "bun:test";
 import { act } from "react";
-import { createOpenTuiTestRoot as createRoot, TestDialogProvider } from "../renderers/opentui/test-utils";
-import { cloneLayout, createDefaultConfig } from "../types/config";
-import { createInitialState, type AppAction, type AppState } from "../state/app/context";
 import type { PluginRegistry } from "../plugins/registry";
+import { TestDialogProvider, createOpenTuiTestRoot as createRoot, emitKeypress as emitTuiKeypress, type TestKeyEvent } from "../renderers/opentui/test-utils";
+import { createInitialState, type AppAction, type AppState } from "../state/app/context";
+import { cloneLayout, createDefaultConfig } from "../types/config";
 import { useAppGlobalShortcuts } from "./global-shortcuts";
 
 let testSetup: Awaited<ReturnType<typeof createTestRenderer>> | undefined;
@@ -108,39 +108,7 @@ function focusEditor() {
   });
 }
 
-async function emitKeypress(event: {
-  name?: string;
-  ctrl?: boolean;
-  meta?: boolean;
-  super?: boolean;
-  shift?: boolean;
-  alt?: boolean;
-}) {
-  const keyEvent = {
-    ctrl: false,
-    meta: false,
-    super: false,
-    option: false,
-    alt: false,
-    shift: false,
-    eventType: "press",
-    repeated: false,
-    defaultPrevented: false,
-    propagationStopped: false,
-    preventDefault() {
-      this.defaultPrevented = true;
-    },
-    stopPropagation() {
-      this.propagationStopped = true;
-    },
-    ...event,
-  };
-  await act(async () => {
-    testSetup!.renderer.keyInput.emit("keypress", keyEvent as any);
-    await testSetup!.renderOnce();
-  });
-  return keyEvent;
-}
+const emitKeypress = (event: TestKeyEvent) => emitTuiKeypress(testSetup!, event, { trackPropagation: true });
 
 describe("useAppGlobalShortcuts", () => {
   test("toggles the command bar with Ctrl-P", async () => {

package/src/app/pane-runtime/plugin-bindings.ts

@@ -7,6 +7,13 @@ import type { AppTickerRepositoryPort } from "../../core/app-service-ports";
 import { setLayoutManagerDispatch } from "../../plugins/builtin/layout-manager";
 import { setMarketplaceHost } from "../../plugins/builtin/plugin-marketplace/store";
 import type { InstalledPlugin } from "../../plugins/builtin/plugin-marketplace/model";
+import {
+  listExternalPlugins,
+  removeExternalPlugin,
+  seedExternalPlugins,
+  upsertExternalPlugin,
+} from "../../plugins/external-runtime";
+import { getPluginHealth } from "../../plugins/health";
 import type { LoadedExternalPlugin } from "../../plugins/loader";
 import { materializeMarketplaceLayout } from "../../layout-marketplace/payload";
 import {
@@ -35,6 +42,13 @@ import type {
   PinTickerOptions,
 } from "../../types/plugin";
 import type { TickerOpenTarget } from "../../tickers/open-target";
+import { instrumentFromTicker } from "../../market-data/request-types";
+import { tickerInstrumentLabel } from "../../tickers/instrument-label";
+import { stableStringify } from "../../remote/revision";
+
+// Registry callbacks are rebound on renders. Request ownership must survive
+// that rebinding, while separate source panes retain independent navigation.
+const tickerNavigationRequests = new WeakMap<PluginRegistry, Map<string | null, symbol>>();
 
 interface BindAppPanePluginRegistryOptions {
   activatePane: (paneId: string, layout?: LayoutConfig) => void;
@@ -64,7 +78,11 @@ interface BindAppPanePluginRegistryOptions {
   placePinnedTickerTarget: (target: TickerOpenTarget, options?: PinTickerOptions) => void;
   pluginRegistry: PluginRegistry;
   publishTickerOpenTarget: (target: TickerOpenTarget) => void;
-  resolveOpenTickerTarget: (rawSymbol: string) => Promise<TickerOpenTarget | null>;
+  resolveOpenTickerTarget: (
+    rawSymbol: string,
+    publicOnly?: boolean,
+    canPresentFeedback?: () => boolean,
+  ) => Promise<TickerOpenTarget | null>;
   resolvePaneTarget: (paneId: string, layout?: LayoutConfig) => string | null;
   selectTickerInPane: (symbol: string, preferredPaneId?: string | null) => void;
   showPane: (paneId: string) => void;
@@ -204,10 +222,29 @@ export function bindAppPanePluginRegistry({
   pluginRegistry.navigateTickerFn = (rawSymbol, options) => {
     if (isDetachedWindow) return;
     const sourcePaneId = options?.sourcePaneId ?? stateRef.current.focusedPaneId;
+    const requests = tickerNavigationRequests.get(pluginRegistry) ?? new Map<string | null, symbol>();
+    tickerNavigationRequests.set(pluginRegistry, requests);
+    const request = Symbol();
+    requests.set(sourcePaneId, request);
+    const ownsRequest = () => requests.get(sourcePaneId) === request;
+    const originalPane = resolveTickerNavigationReplacementPane(stateRef.current.config.layout, sourcePaneId);
+    const originalBinding = originalPane ? stableStringify(originalPane.binding) : null;
+    const ownsDestination = () => {
+      if (!ownsRequest()) return false;
+      if (!originalPane) return true;
+      const currentPane = resolveTickerNavigationReplacementPane(stateRef.current.config.layout, sourcePaneId);
+      // Direct commands and pane closure also supersede a pending navigation.
+      return !!currentPane && stableStringify(currentPane.binding) === originalBinding;
+    };
+    const canPresentFeedback = () => ownsDestination() && shouldFocusTickerNavigationTarget({
+      sourcePaneId,
+      currentFocusedPaneId: stateRef.current.focusedPaneId,
+      targetPaneId: originalPane?.instanceId ?? null,
+    });
     (async () => {
       try {
-        const target = await resolveOpenTickerTarget(rawSymbol);
-        if (!target) return;
+        const target = await resolveOpenTickerTarget(rawSymbol, false, canPresentFeedback);
+        if (!target || !ownsDestination()) return;
         const symbol = target.symbol;
 
         const currentState = stateRef.current;
@@ -226,11 +263,17 @@ export function bindAppPanePluginRegistry({
 
         if (detailPane) {
           publishTickerOpenTarget(target);
+          const instrument = target.instrument !== undefined ? target.instrument
+            : instrumentFromTicker(target.ticker)?.instrument ?? undefined;
+          const binding = { kind: "fixed" as const, symbol,
+            ...(instrument !== undefined ? { instrument } : {}),
+            ...(target.listing ? { listing: target.listing } : {}),
+          };
           const nextLayout = {
             ...currentLayout,
             instances: currentLayout.instances.map((instance) => (
               instance.instanceId === detailPane.instanceId
-                ? { ...instance, title: symbol, binding: { kind: "fixed" as const, symbol } }
+                ? { ...instance, title: tickerInstrumentLabel(symbol, instrument), binding }
                 : instance
             )),
           };
@@ -244,8 +287,11 @@ export function bindAppPanePluginRegistry({
           placePinnedTickerTarget(target, { floating: false });
         }
       } catch (err) {
+        if (!canPresentFeedback()) return;
         const message = err instanceof Error ? err.message : String(err);
         pluginRegistry.notify({ body: `Failed to navigate to ${rawSymbol}: ${message}`, type: "error" });
+      } finally {
+        if (ownsRequest()) requests.delete(sourcePaneId);
       }
     })();
   };
@@ -257,15 +303,19 @@ export function bindAppPanePluginRegistry({
     focusedPaneId: state.focusedPaneId,
   }));
 
+  seedExternalPlugins(externalPlugins);
+
   setMarketplaceHost({
     listInstalled: () => {
       const disabled = new Set(stateRef.current.config.disabledPlugins ?? []);
-      const externalById = new Map(externalPlugins.map((entry) => [entry.plugin.id, entry]));
+      const externalById = new Map(listExternalPlugins().map((entry) => [entry.plugin.id, entry]));
       const installed: InstalledPlugin[] = [];
 
       for (const plugin of pluginRegistry.allPlugins.values()) {
         const external = externalById.get(plugin.id);
         externalById.delete(plugin.id);
+        const health = getPluginHealth(plugin.id);
+        const hasSetup = !!plugin.configSchema && plugin.configSchema.length > 0;
         installed.push({
           id: plugin.id,
           name: plugin.name,
@@ -274,6 +324,14 @@ export function bindAppPanePluginRegistry({
           toggleable: plugin.toggleable === true,
           enabled: !disabled.has(plugin.id),
           source: external ? "external" : "builtin",
+          ...(external?.directory ? { directory: external.directory } : {}),
+          ...(external?.commit ? { commit: external.commit } : {}),
+          ...(external?.linked ? { linked: true } : {}),
+          hasSetup,
+          needsSetup: hasSetup && !pluginRegistry.isPluginConfigured(plugin.id),
+          errorCount: health.errorCount,
+          ...(health.lastError ? { lastError: health.lastError.message } : {}),
+          ...(external?.needsRestart ? { needsRestart: true } : {}),
         });
       }
 
@@ -284,18 +342,79 @@ export function bindAppPanePluginRegistry({
         installed.push({
           id: entry.plugin.id,
           name: entry.plugin.name,
-          version: entry.plugin.version ?? "0.0.0",
+          version: entry.plugin.version ?? "",
           ...(entry.plugin.description ? { description: entry.plugin.description } : {}),
           toggleable: true,
           enabled: !disabled.has(entry.plugin.id),
           source: "external",
+          ...(entry.directory ? { directory: entry.directory } : {}),
+          ...(entry.commit ? { commit: entry.commit } : {}),
+          ...(entry.linked ? { linked: true } : {}),
           ...(entry.unsupportedTarget ? { unsupportedTarget: entry.unsupportedTarget } : {}),
           ...(entry.error ? { loadError: entry.error } : {}),
+          ...(entry.needsRestart ? { needsRestart: true } : {}),
         });
       }
 
       return installed;
     },
+    activate: async (entry) => {
+      if (isDetachedWindow) throw new Error("Manage plugins from the main window.");
+      const pluginId = entry.plugin.id;
+      if (entry.error || entry.unsupportedTarget) {
+        upsertExternalPlugin(entry);
+        return;
+      }
+      // An update replaces the running registration. If the old one will not
+      // let go cleanly, the new code cannot be trusted to coexist with it, so
+      // the row asks for a restart instead of half-loading.
+      if (pluginRegistry.allPlugins.has(pluginId)) {
+        try {
+          pluginRegistry.unregister(pluginId);
+        } catch (error) {
+          upsertExternalPlugin({ ...entry, needsRestart: true });
+          throw error;
+        }
+      }
+      try {
+        await pluginRegistry.register(entry.plugin);
+        upsertExternalPlugin(entry);
+      } catch (error) {
+        upsertExternalPlugin({ ...entry, error: error instanceof Error ? error.message : String(error) });
+        throw error;
+      }
+    },
+    deactivate: async (pluginId, directory) => {
+      if (isDetachedWindow) throw new Error("Manage plugins from the main window.");
+      const paneIds = pluginRegistry.getPluginPaneIds(pluginId);
+      for (const paneId of paneIds) pluginRegistry.hidePane(paneId);
+      const current = stateRef.current.config;
+      const layout = current.layout;
+      const orphaned = new Set(layout.instances.filter((instance) => paneIds.includes(instance.paneId)).map((instance) => instance.instanceId));
+      if (orphaned.size > 0) {
+        let next: LayoutConfig = layout;
+        for (const instanceId of orphaned) next = removePane(next, instanceId);
+        persistLayout(next);
+      }
+      if (pluginRegistry.allPlugins.has(pluginId)) pluginRegistry.unregister(pluginId);
+      removeExternalPlugin(pluginId, directory);
+    },
+    contributions: (pluginId) => {
+      const panes = pluginRegistry.getPluginPaneIds(pluginId)
+        .map((id) => ({ id, name: pluginRegistry.panes.get(id)?.name ?? id }));
+      const templates = pluginRegistry.getPluginPaneTemplateIds(pluginId)
+        .map((id) => {
+          const template = pluginRegistry.paneTemplates.get(id);
+          return { id, label: template?.label ?? id, ...(template?.shortcut?.prefix ? { prefix: template.shortcut.prefix } : {}) };
+        });
+      const commands = [...pluginRegistry.commands.entries()]
+        .filter(([id]) => pluginRegistry.getCommandPluginId(id) === pluginId && !id.endsWith(":setup"))
+        .map(([id, command]) => ({ id, label: command.label }));
+      const capabilities = pluginRegistry.capabilities.manifests()
+        .filter((manifest) => pluginRegistry.getCapabilityPluginId(manifest.id) === pluginId).length;
+      const broker = [...pluginRegistry.brokers.keys()].some((type) => pluginRegistry.getBrokerPluginId(type) === pluginId);
+      return { panes, templates, commands, capabilities, broker };
+    },
     setPluginEnabled: (pluginId, enabled) => {
       const current = stateRef.current.config;
       if (!enabled) {

package/src/app/pane-runtime/ticker-navigation-runtime.test.ts

@@ -0,0 +1,144 @@
+import { expect, test } from "bun:test";
+import { createInitialState } from "../../state/app/context";
+import { createTestDataProvider } from "../../test-support/data-provider";
+import { createTestTicker } from "../../test-support/pane";
+import { createDefaultConfig, type LayoutConfig, type PaneBinding } from "../../types/config";
+import type { BrokerContractRef } from "../../types/instrument";
+import type { TickerOpenTarget } from "../../tickers/open-target";
+import { bindAppPanePluginRegistry } from "./plugin-bindings";
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason: unknown) => void;
+  const promise = new Promise<T>((yes, no) => { resolve = yes; reject = no; });
+  return { promise, resolve, reject };
+}
+
+async function settle() {
+  for (let turn = 0; turn < 4; turn++) await Promise.resolve();
+}
+
+function target(symbol: string, instrument?: BrokerContractRef | null): TickerOpenTarget {
+  return { symbol, ticker: createTestTicker(symbol), created: false,
+    ...(instrument !== undefined ? { instrument } : {}),
+    listing: { name: symbol, exchange: "NASDAQ", currency: "USD", type: instrument?.secType ?? "EQUITY" },
+  };
+}
+
+function runtime() {
+  const state = createInitialState(createDefaultConfig(":memory:"));
+  state.config.layout = {
+    dockRoot: { kind: "split", axis: "horizontal", ratio: 0.5,
+      first: { kind: "pane", instanceId: "first" }, second: { kind: "pane", instanceId: "second" } },
+    instances: ["first", "second"].map(instanceId => ({ instanceId, paneId: "ticker-research",
+      binding: { kind: "fixed", symbol: "INITIAL", instrument: null } })),
+    floating: [], detached: [],
+  };
+  state.focusedPaneId = "first";
+  const stateRef = { current: state };
+  const published: TickerOpenTarget[] = [];
+  const focused: string[] = [];
+  const placed: TickerOpenTarget[] = [];
+  const notifications: unknown[] = [];
+  const requests = new Map<string, ReturnType<typeof deferred<TickerOpenTarget | null>>>();
+  const feedbackOwners = new Map<string, (() => boolean) | undefined>();
+  const registry = { panes: new Map(), getTermSizeFn: () => ({ width: 120, height: 40 }),
+    notify: (message: unknown) => notifications.push(message) } as any;
+  const persistLayout = (layout: LayoutConfig) => {
+    stateRef.current = { ...stateRef.current, config: { ...stateRef.current.config, layout } };
+  };
+  const rebind = () => bindAppPanePluginRegistry({
+    activatePane: (id) => { focused.push(id); stateRef.current = { ...stateRef.current, focusedPaneId: id }; },
+    buildPaneInstance: () => null,
+    createPaneFromTemplate: async () => {}, dataProvider: createTestDataProvider(), detachedPaneId: null,
+    dispatch() {}, externalPlugins: [], focusVisiblePane() {}, isDetachedWindow: false,
+    openPaneSettings: async () => {}, openPinnedTicker: async () => {}, persistConfig() {}, persistLayout,
+    placePaneInstance() {}, placePinnedTickerTarget: (value) => placed.push(value), pluginRegistry: registry,
+    publishTickerOpenTarget: (value) => published.push(value),
+    resolveOpenTickerTarget: (symbol, _publicOnly, canPresentFeedback) => {
+      feedbackOwners.set(symbol, canPresentFeedback);
+      const request = deferred<TickerOpenTarget | null>(); requests.set(symbol, request); return request.promise;
+    },
+    resolvePaneTarget: () => null, selectTickerInPane() {}, showPane() {}, state: stateRef.current, stateRef,
+    switchTickerResearchTab() {}, tickerRepository: {} as any,
+  });
+  rebind();
+  return { stateRef, registry, requests, feedbackOwners, published, focused, placed, notifications, rebind, persistLayout,
+    binding: (id = "first") => stateRef.current.config.layout.instances.find(pane => pane.instanceId === id)!.binding,
+  };
+}
+
+const future: BrokerContractRef = { brokerId: "ibkr", brokerInstanceId: "retirement", conId: 123,
+  symbol: "ES", localSymbol: "ESZ6", secType: "FUT", currency: "USD", exchange: "CME" };
+
+test("replacement preserves an explicit public selection or broker contract instead of ticker fallback", async () => {
+  for (const instrument of [null, future]) {
+    const app = runtime();
+    const selected = target("ES", instrument);
+    // The record's default is intentionally a competing instrument.
+    selected.ticker.metadata.broker_contracts = [{ ...future, brokerInstanceId: "taxable", conId: 456 }];
+    app.registry.navigateTickerFn("ES", { sourcePaneId: "first" });
+    app.requests.get("ES")!.resolve(selected);
+    await settle();
+    expect(app.binding()).toEqual({ kind: "fixed", symbol: "ES", instrument, listing: selected.listing });
+    expect(app.published).toEqual([selected]);
+    expect(app.focused).toEqual(["first"]);
+  }
+});
+
+test("a newer navigation owns the pane across registry rebinding and stale failure cannot notify", async () => {
+  for (const staleFails of [false, true]) {
+    const app = runtime();
+    app.registry.navigateTickerFn("OLD", { sourcePaneId: "first" });
+    app.rebind();
+    app.registry.navigateTickerFn("NEW", { sourcePaneId: "first" });
+    expect(app.feedbackOwners.get("OLD")?.()).toBe(false);
+    expect(app.feedbackOwners.get("NEW")?.()).toBe(true);
+    const selected = target("NEW", null);
+    app.requests.get("NEW")!.resolve(selected);
+    await settle();
+    if (staleFails) app.requests.get("OLD")!.reject(new Error("obsolete request failure"));
+    else app.requests.get("OLD")!.resolve(target("OLD", future));
+    await settle();
+    expect(app.binding()).toMatchObject({ symbol: "NEW", instrument: null });
+    expect(app.published).toEqual([selected]);
+    expect(app.focused).toEqual(["first"]);
+    expect(app.notifications).toEqual([]);
+  }
+});
+
+test("independent pane navigation completes without reclaiming focus from the other pane", async () => {
+  const app = runtime();
+  app.registry.navigateTickerFn("LEFT", { sourcePaneId: "first" });
+  app.stateRef.current = { ...app.stateRef.current, focusedPaneId: "second" };
+  app.rebind();
+  app.registry.navigateTickerFn("RIGHT", { sourcePaneId: "second" });
+  expect(app.feedbackOwners.get("LEFT")?.()).toBe(false);
+  expect(app.feedbackOwners.get("RIGHT")?.()).toBe(true);
+  app.requests.get("RIGHT")!.resolve(target("RIGHT", future));
+  await settle();
+  app.requests.get("LEFT")!.resolve(target("LEFT", null));
+  await settle();
+  expect(app.binding("first")).toMatchObject({ symbol: "LEFT", instrument: null });
+  expect(app.binding("second")).toMatchObject({ symbol: "RIGHT", instrument: future });
+  expect(app.published.map(value => value.symbol)).toEqual(["RIGHT", "LEFT"]);
+  expect(app.focused).toEqual(["second"]);
+});
+
+test("a pending result cannot overwrite an intervening direct selection or reopen a closed destination", async () => {
+  for (const close of [false, true]) {
+    const app = runtime();
+    app.registry.navigateTickerFn("SLOW", { sourcePaneId: "first" });
+    const layout = app.stateRef.current.config.layout;
+    const replacement: PaneBinding = { kind: "fixed", symbol: "DIRECT", instrument: future };
+    app.persistLayout({ ...layout, instances: close ? layout.instances.filter(pane => pane.instanceId !== "first")
+      : layout.instances.map(pane => pane.instanceId === "first" ? { ...pane, binding: replacement } : pane) });
+    expect(app.feedbackOwners.get("SLOW")?.()).toBe(false);
+    app.requests.get("SLOW")!.resolve(target("SLOW", null));
+    await settle();
+    expect(app.published).toEqual([]);
+    expect(app.focused).toEqual([]);
+    expect(app.placed).toEqual([]);
+    if (!close) expect(app.binding()).toEqual(replacement);
+  }
+});