gloomberb 0.17.4 → 0.17.6

package/src/app/runtime/broker-import.ts

@@ -8,7 +8,7 @@ import {
 import type { SyncBrokerInstanceResult } from "../../brokers/sync-broker-instance";
 import type { AppTickerRepositoryPort } from "../../core/app-service-ports";
 import type { PluginRegistry } from "../../plugins/registry";
-import { adoptHeldPortfolioCurrencies } from "../../plugins/builtin/portfolio-list/mutations";
+import { adoptHeldPortfolioCurrencies } from "../../portfolio/mutations";
 import { saveConfigImmediately } from "../../state/config-save-scheduler";
 import type { AppAction, AppState } from "../../state/app/context";
 import type { AppConfig } from "../../types/config";
@@ -18,6 +18,7 @@ import { getBrokerInstance } from "../../utils/broker-instances";
 export interface AppBrokerImportRuntime {
   importBrokerPositions: (
     instanceId: string,
+    /** What the sync reads. It lands on the app's tickers as they are when it commits, whatever was passed. */
     tickerMap?: Map<string, TickerRecord>,
     options?: BrokerImportOptions,
   ) => Promise<SyncBrokerInstanceResult>;
@@ -52,6 +53,13 @@ export function useBrokerImportRuntime({
   stateRef: { current: AppState };
   tickerRepository: AppTickerRepositoryPort;
 }): AppBrokerImportRuntime {
+  /**
+   * Commits a sync: carried onto the app as it is now (a pull or an edit while
+   * the broker answered stays) and handed to the app before anything is
+   * written. With a wait in between, a pull landing in it would be overwritten
+   * by this older copy and pushed from here as an edit. The writes start in
+   * the same tick, so the copy of anyone writing after lands on disk after it.
+   */
   const applyBrokerImportResult = useCallback(async (
     instanceId: string,
     result: SyncBrokerInstanceResult,
@@ -62,31 +70,27 @@ export function useBrokerImportRuntime({
     },
   ) => {
     throwIfBrokerImportCancelled(options?.signal);
-    dispatch({ type: "SET_BROKER_ACCOUNTS", instanceId, accounts: result.brokerAccounts });
-
-    const liveConfig = stateRef.current.config;
+    const live = stateRef.current;
+    result.rebase(live);
     const nextConfig = options?.callerOwnsConfig
-      ? (result.config !== baseConfig ? result.config : liveConfig)
-      : rebaseBrokerSyncConfig(liveConfig, baseConfig, result.config, instanceId);
-    if (nextConfig !== liveConfig) {
-      throwIfBrokerImportCancelled(options?.signal);
-      dispatch({ type: "SET_CONFIG", config: nextConfig });
-      await saveConfigImmediately(nextConfig);
-      throwIfBrokerImportCancelled(options?.signal);
-      pluginRegistry.events.emit("config:changed", { config: nextConfig });
+      ? (result.config !== baseConfig ? result.config : live.config)
+      : rebaseBrokerSyncConfig(live.config, baseConfig, result.config, instanceId);
+    const configChanged = nextConfig !== live.config;
+
+    dispatch({ type: "SET_BROKER_ACCOUNTS", instanceId, accounts: result.brokerAccounts });
+    if (configChanged) dispatch({ type: "SET_CONFIG", config: nextConfig });
+    for (const ticker of [...result.addedTickers, ...result.updatedTickers]) {
+      dispatch({ type: "UPDATE_TICKER", ticker });
     }
+    await Promise.all([result.commit(), configChanged ? saveConfigImmediately(nextConfig) : undefined]);
 
+    if (configChanged) pluginRegistry.events.emit("config:changed", { config: nextConfig });
     for (const ticker of result.addedTickers) {
-      throwIfBrokerImportCancelled(options?.signal);
       pluginRegistry.events.emit("ticker:added", { symbol: ticker.metadata.ticker, ticker });
     }
-    for (const ticker of [...result.addedTickers, ...result.updatedTickers]) {
-      throwIfBrokerImportCancelled(options?.signal);
-      dispatch({ type: "UPDATE_TICKER", ticker: { ...ticker } });
-    }
 
     for (const position of result.positions) {
-      throwIfBrokerImportCancelled(options?.signal);
+      if (options?.signal?.aborted) break;
       // Skip market data for broker option symbols; position marks are already available.
       // Position data (markPrice, marketValue, unrealizedPnl) is used directly.
       if (options?.refreshImportedTickers !== false && position.assetCategory !== "OPT") {
@@ -120,8 +124,6 @@ export function useBrokerImportRuntime({
       throwIfBrokerImportCancelled(options?.signal);
       options?.onCommitStart?.();
       commitStarted = true;
-      await result.commit();
-      throwIfBrokerImportCancelled(options?.signal);
       await applyBrokerImportResult(instanceId, result, baseConfig, {
         ...options,
         callerOwnsConfig: options?.config !== undefined,
@@ -155,7 +157,7 @@ export function useBrokerImportRuntime({
       deferPersistence: true,
       onResult: async (result, instance, previousConfig) => {
         if (!getBrokerInstance(stateRef.current.config.brokerInstances, instance.id)) return;
-        await result.commit();
+        // Startup syncs run beside the first pull: each lands on what it left.
         await applyBrokerImportResult(instance.id, result, previousConfig, {
           refreshImportedTickers: false,
         });

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

@@ -3,7 +3,7 @@ import {
   clearPersistedBrokerAccounts,
   getBrokerAccountCacheSourceKey,
 } from "../../brokers/account-cache";
-import { findPortfolioHeir } from "../../brokers/broker-portfolio-sync";
+import { clearLeftoverBrokerHoldings, findPortfolioHeir, knownBrokerHoldings } from "../../brokers/broker-portfolio-sync";
 import type { AppTickerRepositoryPort } from "../../core/app-service-ports";
 import type { MarketDataCoordinator } from "../../market-data/coordinator";
 import { instrumentFromTicker } from "../../market-data/request-types";
@@ -216,15 +216,20 @@ export function bindPluginRegistryRuntimeAccess({
         return [heirId ? { ...portfolio, brokerInstanceId: heirId } : portfolio];
       });
       const nextTickers = new Map(stateRef.current.tickers);
+      const nextBrokerInstances = stateRef.current.config.brokerInstances.filter((entry) => entry.id !== instanceId);
+      // What older removals and pulls from other devices left behind goes as well.
+      const known = knownBrokerHoldings({ portfolios: nextPortfolios, brokerInstances: nextBrokerInstances });
 
       for (const ticker of stateRef.current.tickers.values()) {
-        const nextPositions = ticker.metadata.positions.filter((position) => position.brokerInstanceId !== instanceId);
+        // A position here without a profile came from another device's sync of this one.
+        const nextPositions = ticker.metadata.positions.filter((position) => position.brokerInstanceId !== instanceId
+          && !(removedPortfolioIds.has(position.portfolio) && !position.brokerInstanceId));
         const heldPortfolioIds = new Set(nextPositions.map((position) => position.portfolio));
         const nextPortfolioRefs = ticker.metadata.portfolios.filter((portfolioId) =>
           !removedPortfolioIds.has(portfolioId) && (!heirs.has(portfolioId) || heldPortfolioIds.has(portfolioId)));
         const nextBrokerContracts = (ticker.metadata.broker_contracts ?? []).filter((contract) => contract.brokerInstanceId !== instanceId);
 
-        const nextTicker: TickerRecord = {
+        const removedTicker: TickerRecord = {
           ...ticker,
           metadata: {
             ...ticker.metadata,
@@ -233,12 +238,13 @@ export function bindPluginRegistryRuntimeAccess({
             broker_contracts: nextBrokerContracts,
           },
         };
+        const nextTicker = clearLeftoverBrokerHoldings(removedTicker, known) ?? removedTicker;
 
         const shouldDeleteTicker =
-          nextPositions.length === 0
-          && nextPortfolioRefs.length === 0
+          nextTicker.metadata.positions.length === 0
+          && nextTicker.metadata.portfolios.length === 0
           && nextTicker.metadata.watchlists.length === 0
-          && nextBrokerContracts.length === 0
+          && (nextTicker.metadata.broker_contracts ?? []).length === 0
           && nextTicker.metadata.tags.length === 0
           && Object.keys(nextTicker.metadata.custom).length === 0;
 
@@ -256,7 +262,7 @@ export function bindPluginRegistryRuntimeAccess({
 
       const nextConfig = {
         ...stateRef.current.config,
-        brokerInstances: stateRef.current.config.brokerInstances.filter((entry) => entry.id !== instanceId),
+        brokerInstances: nextBrokerInstances,
         portfolios: nextPortfolios,
       };
 

package/src/app/runtime/update.ts

@@ -7,13 +7,17 @@ import {
   canRestartToApply,
   canSelfUpdate,
   checkForUpdateDetailed,
+  discardStagedUpdate,
   performUpdate,
   type ReleaseInfo,
   type UpdateCheckResult,
   type UpdateProgress,
 } from "../../updater";
+import { resolveUpdateChannel, stagedUpdateFitsChannel } from "../../updater/channel";
+import type { UpdateChannel } from "../../types/config";
 import { VERSION } from "../../version";
 import { debugLog } from "../../utils/debug-log";
+import { isPrereleaseVersion } from "../../utils/semver";
 import { reportCrash } from "../../telemetry/crash-reports";
 import { runAutomated } from "../../telemetry/usage-counts";
 
@@ -41,6 +45,7 @@ export function useAppUpdateRuntime({
   pluginRegistry,
   stateRef,
   updateAvailable,
+  updateChannel = "stable",
   updateCheckInProgress,
   updateProgress,
 }: {
@@ -50,6 +55,8 @@ export function useAppUpdateRuntime({
   pluginRegistry: PluginRegistry;
   stateRef: { current: AppState };
   updateAvailable: ReleaseInfo | null;
+  /** The channel in effect (`resolveUpdateChannel`); a change checks again at once. */
+  updateChannel?: UpdateChannel;
   updateCheckInProgress: boolean;
   updateProgress: unknown;
 }): {
@@ -61,11 +68,24 @@ export function useAppUpdateRuntime({
   runUpdateCommand: () => void;
 } {
   const restartingRef = useRef(false);
+  /** The tag of a release whose download found nothing to take; the hourly check does not offer it again. */
+  const declinedTagRef = useRef<string | null>(null);
 
   const startUpdate = useCallback((release: ReleaseInfo) => {
     dispatch({ type: "SET_UPDATE_PROGRESS", progress: { phase: "downloading", percent: 0 } });
     void performUpdate(release, (progress) => {
       logUpdateFailure(progress);
+      if (progress.phase === "done") {
+        // The download had nothing to take (that build is the installed one):
+        // an answer like a check's, so it passes as a notice like one. The
+        // release goes before the progress, so the effect below never starts
+        // it again, and the hourly check does not offer it again.
+        declinedTagRef.current = release.tagName;
+        dispatch({ type: "SET_UPDATE_AVAILABLE", release: null });
+        dispatch({ type: "SET_UPDATE_PROGRESS", progress: null });
+        dispatch({ type: "SET_UPDATE_NOTICE", notice: progress.message ?? null });
+        return;
+      }
       dispatch({ type: "SET_UPDATE_PROGRESS", progress });
     });
   }, [dispatch]);
@@ -97,7 +117,8 @@ export function useAppUpdateRuntime({
     // failed check like any other: the hourly one must not end as an
     // unhandled rejection, and a manual one must clear its progress state.
     // The timeout is still reported, as it was when it went unhandled.
-    const result = await checkForUpdateDetailed(VERSION).catch((error: unknown): UpdateCheckResult => {
+    const channel = resolveUpdateChannel(stateRef.current.config);
+    const result = await checkForUpdateDetailed(VERSION, channel).catch((error: unknown): UpdateCheckResult => {
       const message = error instanceof Error ? error.message : "";
       if (message.startsWith("RPC request timed out")) {
         reportCrash(error, { kind: "unhandled-rejection" });
@@ -108,7 +129,7 @@ export function useAppUpdateRuntime({
     if (result.kind === "error") updateLog.warn("update check failed", { error: result.error });
 
     if (!manual) {
-      if (result.kind === "available") {
+      if (result.kind === "available" && result.release.tagName !== declinedTagRef.current) {
         dispatch({ type: "SET_UPDATE_AVAILABLE", release: result.release });
       }
       return;
@@ -123,7 +144,7 @@ export function useAppUpdateRuntime({
 
     if (result.kind === "current") {
       dispatch({ type: "SET_UPDATE_AVAILABLE", release: null });
-      dispatch({ type: "SET_UPDATE_NOTICE", notice: `Already on v${VERSION}` });
+      dispatch({ type: "SET_UPDATE_NOTICE", notice: result.notice ?? `Already on v${VERSION}` });
       return;
     }
 
@@ -147,6 +168,44 @@ export function useAppUpdateRuntime({
     return () => { clearInterval(interval); };
   }, [enabled, isDetachedWindow, runUpdateCheck]);
 
+  // A channel switch checks again at once and says what it found: nightly
+  // starts on today's build, stable says when this nightly build stays. An
+  // update already downloading or waiting for a restart is left to the effect
+  // below, which takes it back once it is ready if the channel rules it out.
+  const checkedChannelRef = useRef(updateChannel);
+  useEffect(() => {
+    if (!enabled || isDetachedWindow || checkedChannelRef.current === updateChannel) return;
+    checkedChannelRef.current = updateChannel;
+    if (updateInFlight(stateRef.current.updateProgress)) return;
+    // What the other channel offered, or how its download failed, is not this one's answer.
+    if (stateRef.current.updateProgress) dispatch({ type: "SET_UPDATE_PROGRESS", progress: null });
+    dispatch({ type: "SET_UPDATE_AVAILABLE", release: null });
+    void runUpdateCheck(true);
+  }, [dispatch, enabled, isDetachedWindow, runUpdateCheck, stateRef, updateChannel]);
+
+  // A downloaded update the channel does not allow (a nightly build waiting
+  // for a restart after the switch back to stable, or one that finished
+  // downloading after it) is taken back rather than installed by the restart,
+  // and stable checks again.
+  const discardingRef = useRef(false);
+  useEffect(() => {
+    if (!enabled || isDetachedWindow || discardingRef.current) return;
+    const { updateProgress: progress, updateAvailable: staged } = stateRef.current;
+    if (progress?.phase !== "ready" || stagedUpdateFitsChannel(staged, updateChannel)) return;
+    discardingRef.current = true;
+    void discardStagedUpdate().then((error) => {
+      discardingRef.current = false;
+      if (error) {
+        updateLog.warn("could not take back the staged update", { error, version: staged?.version });
+        dispatch({ type: "SET_UPDATE_NOTICE", notice: `Could not take back v${staged?.version ?? "?"}: ${error}` });
+        return;
+      }
+      dispatch({ type: "SET_UPDATE_PROGRESS", progress: null });
+      dispatch({ type: "SET_UPDATE_AVAILABLE", release: null });
+      void runUpdateCheck(true);
+    });
+  }, [dispatch, enabled, isDetachedWindow, runUpdateCheck, stateRef, updateAvailable, updateChannel, updateProgress]);
+
   // First launch on a new version: show that release's notes, then remember the version.
   useEffect(() => {
     if (!enabled || isDetachedWindow) return;
@@ -156,7 +215,8 @@ export function useAppUpdateRuntime({
     const nextConfig = { ...config, lastLaunchedVersion: VERSION };
     dispatch({ type: "SET_CONFIG", config: nextConfig });
     void saveConfigImmediately(nextConfig).catch(() => {});
-    if (!isUpgrade) return;
+    // Nightly builds come daily and the changelog lists stable releases only.
+    if (!isUpgrade || isPrereleaseVersion(VERSION)) return;
     // Opened by the app, not the user: usage counts leave it out.
     void runAutomated(() => pluginRegistry.createPaneFromTemplateAsync("changelog-pane", {
       values: { version: VERSION },

package/src/app.tsx

@@ -50,6 +50,7 @@ import { bindPluginRegistryRuntimeAccess } from "./app/runtime/plugin-bindings";
 import { useAppStartupRuntime } from "./app/runtime/startup";
 import { useTickerRefreshRuntime } from "./app/runtime/ticker-refresh";
 import { useAppUpdateRuntime } from "./app/runtime/update";
+import { resolveUpdateChannel } from "./updater/channel";
 import { createCoreSyncContributors } from "./sync/core-contributors";
 import { useCloudSyncRuntime } from "./sync/react";
 import { RemoteControlHost, type RemoteControlAdapter } from "./remote/app-host";
@@ -278,6 +279,7 @@ function AppInner({
     pluginRegistry,
     stateRef,
     updateAvailable: state.updateAvailable,
+    updateChannel: resolveUpdateChannel(state.config),
     updateCheckInProgress: state.updateCheckInProgress,
     updateProgress: state.updateProgress,
   });

package/src/architecture/core-builtin-allowlist.json

@@ -3,7 +3,6 @@
   "src/app.tsx": ["cloud"],
   "src/app/global-shortcuts.ts": ["help"],
   "src/app/pane-runtime/plugin-bindings.ts": ["broker-manager","layout-manager"],
-  "src/app/runtime/broker-import.ts": ["portfolio-list"],
   "src/app/runtime/desktop-deeplink.ts": ["account-management","chat"],
   "src/app/runtime/startup.ts": ["chat"],
   "src/cli/commands/market.ts": ["holders","insider","research","sec"],
@@ -19,21 +18,14 @@
   "src/cli/pane-functions/resolver.ts": ["chart-composer"],
   "src/cli/pane-functions/screenshot-evidence.ts": ["attention","awards","catalysts","company-attention","company-kpis","credit-documents","exposure","market-heatmap","options-calculator","options-scenario","power","realized-vol","supply-chain","vol-surface","volatility","world-venue-map"],
   "src/cli/pane-functions/screenshot.ts": ["chart-composer","econ-statistics","market-valuation","portfolio-list","ticker-detail","time-sales"],
-  "src/components/command-bar/commands/collection.ts": ["portfolio-list"],
-  "src/components/command-bar/commands/direct/index.ts": ["broker-manager","portfolio-list"],
-  "src/components/command-bar/routes/root/command-items.ts": ["portfolio-list"],
+  "src/components/command-bar/commands/direct/index.ts": ["broker-manager"],
   "src/components/command-bar/routes/root/help-items.ts": ["help"],
-  "src/components/command-bar/routes/root/shortcut-items.ts": ["portfolio-list"],
   "src/components/command-bar/workflow/builtin.ts": ["portfolio-list"],
-  "src/components/command-bar/workflow/collection-actions.ts": ["portfolio-list"],
   "src/components/command-bar/workflow/ops.ts": ["correlation","portfolio-list","ticker-detail"],
-  "src/components/command-bar/workflow/tickers.ts": ["portfolio-list"],
   "src/components/form-modal/routes.ts": ["portfolio-list"],
   "src/components/index.ts": ["portfolio-list"],
   "src/components/layout/shell/index.tsx": ["cloud"],
   "src/components/onboarding/use-onboarding-upgrade.ts": ["chat"],
-  "src/components/onboarding/wizard-model.ts": ["portfolio-list"],
-  "src/components/onboarding/wizard-positions.ts": ["portfolio-list"],
   "src/layout/desks.ts": ["chart-composer"],
   "src/plugins/catalog-browser.ts": ["alerts","analytics","attention","awards","backtest","bond-calculator","catalysts","cds","central-bank-rates","changelog","chart-composer","clinical-trials","cloud","comment-letters","commodities-energy","commodity-balances","company-attention","company-kpis","connections","correlation","cot","cpi","credit-boards","credit-conditions","credit-documents","crypto-board","debt-maturities","dividend-yield","docs","doe","earnings-calls","earnings-ripple","econ","econ-statistics","equity-screener","estimate-revisions","executives","exposure","fear-greed","filing-events","fixed-income","futures","futures-curve","fx-matrix","gpu","help","insider","ipo-calendar","iv-history","jobs","jodi","kelly-sizer","layout-manager","macro-day","market-halts","market-heatmap","market-valuation","members","mna","money-markets","news","openfda","options","options-calculator","options-positioning","options-scenario","pe-band","perps","portfolio-list","power","primary-dealers","rate-path","realized-vol","relative-rotation","research","research-search","revenue-breakdown","reverse-dcf","risk-factors","scanner","seasonality","sec","sectors","short-interest","short-volume","social-mentions","supply-chain","ticker-detail","time-sales","trace-bonds","treasury-auctions","treasury-daily","vol-surface","volatility","world-indices","world-venue-map","yield-curve"],
   "src/plugins/catalog-ui.ts": ["alerts","clinical-trials","cloud","comment-letters","custom-view","fear-greed","ipo-calendar","market-halts","market-heatmap","members","news","notes","openfda","research-search"],
@@ -43,5 +35,5 @@
   "src/renderers/electrobun/view/cli-pane-shot-entry.tsx": ["econ-statistics","market-valuation","time-sales"],
   "src/renderers/electrobun/view/main.tsx": ["notes"],
   "src/renderers/electrobun/view/remote/connection-health.ts": ["connections"],
-  "src/sync/core-contributors.ts": ["analytics","portfolio-list"]
+  "src/sync/core-contributors.ts": ["analytics"]
 }

package/src/ask-gloom/pane-context.ts

@@ -41,7 +41,7 @@ function scalarArgs(source: ArgSource, privateFields: PaneSharePrivateFields | u
  * that opens this pane (a chart opened with `GP` stays `GP`), else the first
  * template that opens it.
  */
-function functionCode(registry: Pick<PluginRegistry, "paneTemplates">, paneType: string, title: string): string | null {
+export function functionCode(registry: Pick<PluginRegistry, "paneTemplates">, paneType: string, title: string): string | null {
   const prefixes = [...registry.paneTemplates.values()]
     .filter((template) => template.paneId === paneType && template.shortcut?.prefix)
     .map((template) => template.shortcut!.prefix.toUpperCase());
@@ -50,6 +50,16 @@ function functionCode(registry: Pick<PluginRegistry, "paneTemplates">, paneType:
   return prefixes[0] ?? null;
 }
 
+/**
+ * A pane named by its function and what it shows, such as `DES AAPL`: its
+ * title, led by its function code unless the title already starts with it.
+ */
+export function paneFunctionLabel(pane: { title: string; code: string | null; paneType: string }): string {
+  const title = pane.title.trim() || pane.paneType;
+  if (!pane.code) return title;
+  return title.split(/\s+/)[0]?.toUpperCase() === pane.code ? title : `${pane.code} ${title}`;
+}
+
 export interface PaneAttachmentSource {
   registry: Pick<PluginRegistry, "paneTemplates" | "brokers" | "getPanePluginId" | "getBrokerPluginId">;
   pane: Pick<ResolvedPane, "instance" | "def">;

package/src/brokers/broker-portfolio-sync.ts

@@ -181,10 +181,17 @@ export function clearBrokerInstanceTickerData(
   brokerPortfolioIds: Set<string>,
   /** Portfolios this profile just took over: whatever another profile imported there goes too. */
   takenOverPortfolioIds: ReadonlySet<string> = new Set(),
+  /**
+   * Portfolios this sync writes. A position there without a profile came from
+   * another device's sync of the same account, so this one replaces it too;
+   * one entered by hand stays.
+   */
+  syncedPortfolioIds: ReadonlySet<string> = new Set(),
 ): TickerRecord | null {
   const positions = ticker.metadata.positions.filter((position) =>
     position.brokerInstanceId !== instanceId
     && !(takenOverPortfolioIds.has(position.portfolio) && position.brokerInstanceId)
+    && !(syncedPortfolioIds.has(position.portfolio) && !position.brokerInstanceId && position.broker !== "manual")
   );
   const remainingPositionPortfolios = new Set(positions.map((position) => position.portfolio));
   const portfolios = ticker.metadata.portfolios.filter((portfolioId) =>
@@ -211,6 +218,65 @@ export function clearBrokerInstanceTickerData(
   };
 }
 
+/** The profile a broker portfolio id was made for: `broker:<profile>:<account>`. */
+function brokerInstanceIdOfPortfolio(portfolioId: string): string | undefined {
+  return isBrokerPortfolioId(portfolioId) ? portfolioId.split(":")[1] || undefined : undefined;
+}
+
+/** The broker portfolios and profiles that still exist somewhere this device knows of. */
+export interface KnownBrokerHoldings {
+  portfolioIds: ReadonlySet<string>;
+  instanceIds: ReadonlySet<string>;
+}
+
+export function knownBrokerHoldings(
+  ...sources: Array<{ portfolios?: ReadonlyArray<{ id: string }>; brokerInstances?: ReadonlyArray<{ id: string }> }>
+): KnownBrokerHoldings {
+  return {
+    portfolioIds: new Set(sources.flatMap((source) => source.portfolios?.map((portfolio) => portfolio.id) ?? [])),
+    instanceIds: new Set(sources.flatMap((source) => source.brokerInstances?.map((instance) => instance.id) ?? [])),
+  };
+}
+
+/**
+ * A broker portfolio that is gone, along with the profile it was made for. One
+ * that still has its profile stays: that profile restores it on its next sync.
+ */
+function isGoneBrokerPortfolio(portfolioId: string, known: KnownBrokerHoldings): boolean {
+  if (!isBrokerPortfolioId(portfolioId) || known.portfolioIds.has(portfolioId)) return false;
+  const instanceId = brokerInstanceIdOfPortfolio(portfolioId);
+  return !instanceId || !known.instanceIds.has(instanceId);
+}
+
+function isLeftoverBrokerPosition(position: TickerPosition, known: KnownBrokerHoldings): boolean {
+  return isGoneBrokerPortfolio(position.portfolio, known)
+    && !(position.brokerInstanceId && known.instanceIds.has(position.brokerInstanceId));
+}
+
+/**
+ * The ticker without what removed broker profiles left on it: positions and
+ * links in portfolios that are gone with their profile, and contracts of
+ * profiles that are gone. A pull from another device brings such positions
+ * without the profile that imported them, as a profile never leaves its
+ * device, so nothing else ever clears them. Null when there is none.
+ */
+export function clearLeftoverBrokerHoldings(ticker: TickerRecord, known: KnownBrokerHoldings): TickerRecord | null {
+  const { metadata } = ticker;
+  const positions = metadata.positions.filter((position) => !isLeftoverBrokerPosition(position, known));
+  const held = new Set(positions.map((position) => position.portfolio));
+  const portfolios = metadata.portfolios.filter((portfolioId) => held.has(portfolioId) || !isGoneBrokerPortfolio(portfolioId, known));
+  const contracts = metadata.broker_contracts ?? [];
+  const brokerContracts = contracts.filter((contract) => !contract.brokerInstanceId || known.instanceIds.has(contract.brokerInstanceId));
+  if (
+    positions.length === metadata.positions.length
+    && portfolios.length === metadata.portfolios.length
+    && brokerContracts.length === contracts.length
+  ) {
+    return null;
+  }
+  return { ...ticker, metadata: { ...metadata, positions, portfolios, broker_contracts: brokerContracts } };
+}
+
 function inferBrokerAccountId(position: TickerPosition, portfolioId: string, instanceId: string): string | undefined {
   if (position.brokerAccountId) return position.brokerAccountId;
   const prefix = `broker:${instanceId}:`;

package/src/brokers/sync-broker-instance.ts

@@ -7,9 +7,11 @@ import type { TickerRecord } from "../types/ticker";
 import { getBrokerInstance } from "../utils/broker-instances";
 import {
   clearBrokerInstanceTickerData,
+  clearLeftoverBrokerHoldings,
   ensureBrokerPortfolio,
   findReusableBrokerPortfolioId,
   isHeldByOtherSignedInProfile,
+  knownBrokerHoldings,
   removeStaleBrokerPortfolios,
   resolvePortfolioBrokerId,
 } from "./broker-portfolio-sync";
@@ -33,6 +35,12 @@ export interface SyncBrokerInstanceArgs {
   deferPersistence?: boolean;
 }
 
+/** The app as it is when a sync commits, which may be seconds after the sync read it. */
+interface BrokerSyncCommitTarget {
+  tickers: ReadonlyMap<string, TickerRecord>;
+  config: Pick<AppConfig, "portfolios" | "brokerInstances">;
+}
+
 export interface SyncBrokerInstanceResult {
   config: AppConfig;
   tickers: Map<string, TickerRecord>;
@@ -41,6 +49,15 @@ export interface SyncBrokerInstanceResult {
   portfolioIds: string[];
   addedTickers: TickerRecord[];
   updatedTickers: TickerRecord[];
+  /**
+   * Carries the sync onto the app as it is now, which may be seconds after the
+   * sync read it, so what changed while the broker answered (a pull from
+   * another device, an edit) stays; `tickers`, `addedTickers` and
+   * `updatedTickers` then hold the sync over it. Hand them to the app before
+   * anything waits: a pull landing in a wait would be overwritten in turn.
+   */
+  rebase(onto: BrokerSyncCommitTarget): void;
+  /** Writes the sync's tickers and broker accounts. */
   commit(): Promise<void>;
 }
 
@@ -310,62 +327,78 @@ export async function syncBrokerInstance({
     : []);
 
   nextConfig = removeStaleBrokerPortfolios(nextConfig, instance.id, currentPortfolioIds);
-  const cleanedTickers = new Map<string, TickerRecord>();
-  for (const ticker of tickers.values()) {
-    const cleanedTicker = clearBrokerInstanceTickerData(ticker, instance.id, brokerPortfolioIds, takenOverPortfolioIds);
-    if (!cleanedTicker) continue;
-    tickers.set(cleanedTicker.metadata.ticker, cleanedTicker);
-    cleanedTickers.set(cleanedTicker.metadata.ticker, cleanedTicker);
-  }
-
   nextConfig = await maybePersistResolvedBrokerConfig(nextConfig, instance, broker, persistResolvedBrokerConfig);
   throwIfBrokerImportCancelled(signal);
   nextConfig = markBrokerInstanceSynced(nextConfig, instance.id, syncedAt);
+  const syncedConfig = nextConfig;
+
+  // What the sync does to the tickers, given them: it runs on the tickers it
+  // read, and again on the live ones when it commits after the broker answered.
+  const writeTickers = (source: ReadonlyMap<string, TickerRecord>, liveConfig?: BrokerSyncCommitTarget["config"]) => {
+    const tickers = new Map(source);
+    // Only a portfolio and a profile gone everywhere this device knows of make a leftover.
+    const known = knownBrokerHoldings(config, syncedConfig, ...(liveConfig ? [liveConfig] : []));
+    const cleanedTickers = new Map<string, TickerRecord>();
+    for (const ticker of tickers.values()) {
+      const cleared = clearBrokerInstanceTickerData(
+        ticker, instance.id, brokerPortfolioIds, takenOverPortfolioIds, currentPortfolioIds,
+      );
+      const cleanedTicker = clearLeftoverBrokerHoldings(cleared ?? ticker, known) ?? cleared;
+      if (!cleanedTicker) continue;
+      tickers.set(cleanedTicker.metadata.ticker, cleanedTicker);
+      cleanedTickers.set(cleanedTicker.metadata.ticker, cleanedTicker);
+    }
 
-  const addedTickers = new Map<string, TickerRecord>();
-  const updatedTickers = new Map<string, TickerRecord>();
+    const addedTickers = new Map<string, TickerRecord>();
+    const updatedTickers = new Map<string, TickerRecord>();
+
+    for (const position of positions) {
+      throwIfBrokerImportCancelled(signal);
+      const portfolioId = findReusableBrokerPortfolioId(syncedConfig, instance, position.accountId, portfolioBrokerId);
+      if (heldElsewhere.has(portfolioId)) continue;
+      const { ticker, created } = upsertBrokerPositionTicker({
+        tickers,
+        instance,
+        portfolioId,
+        position,
+      });
+      if (created) {
+        addedTickers.set(position.ticker, ticker);
+      } else {
+        cleanedTickers.delete(ticker.metadata.ticker);
+        if (!addedTickers.has(position.ticker)) {
+          updatedTickers.set(position.ticker, ticker);
+        }
+      }
 
-  for (const position of positions) {
-    throwIfBrokerImportCancelled(signal);
-    const portfolioId = findReusableBrokerPortfolioId(nextConfig, instance, position.accountId, portfolioBrokerId);
-    if (heldElsewhere.has(portfolioId)) continue;
-    const { ticker, created } = upsertBrokerPositionTicker({
-      tickers,
-      instance,
-      portfolioId,
-      position,
-    });
-    if (created) {
-      addedTickers.set(position.ticker, ticker);
-    } else {
-      cleanedTickers.delete(ticker.metadata.ticker);
-      if (!addedTickers.has(position.ticker)) {
+      tickers.set(position.ticker, ticker);
+      if (addedTickers.has(position.ticker)) {
+        addedTickers.set(position.ticker, ticker);
+      } else {
         updatedTickers.set(position.ticker, ticker);
       }
     }
 
-    tickers.set(position.ticker, ticker);
-    if (addedTickers.has(position.ticker)) {
-      addedTickers.set(position.ticker, ticker);
-    } else {
-      updatedTickers.set(position.ticker, ticker);
-    }
-  }
-
-  for (const ticker of cleanedTickers.values()) {
-    if (!addedTickers.has(ticker.metadata.ticker) && !updatedTickers.has(ticker.metadata.ticker)) {
-      updatedTickers.set(ticker.metadata.ticker, ticker);
+    for (const ticker of cleanedTickers.values()) {
+      if (!addedTickers.has(ticker.metadata.ticker) && !updatedTickers.has(ticker.metadata.ticker)) {
+        updatedTickers.set(ticker.metadata.ticker, ticker);
+      }
     }
-  }
+    return { tickers, addedTickers: [...addedTickers.values()], updatedTickers: [...updatedTickers.values()] };
+  };
 
+  let written = writeTickers(tickers);
   let committed = false;
+  const rebase = (onto: BrokerSyncCommitTarget) => {
+    if (!committed) written = writeTickers(onto.tickers, onto.config);
+  };
   const commit = async () => {
     if (committed) return;
     throwIfBrokerImportCancelled(signal);
     if (resources) {
       persistBrokerAccounts(resources, instance, broker, brokerAccounts);
     }
-    await Promise.all([...addedTickers.values(), ...updatedTickers.values()].map((ticker) => (
+    await Promise.all([...written.addedTickers, ...written.updatedTickers].map((ticker) => (
       tickerRepository.saveTicker(ticker)
     )));
     committed = true;
@@ -377,12 +410,13 @@ export async function syncBrokerInstance({
 
   return {
     config: nextConfig,
-    tickers,
+    get tickers() { return written.tickers; },
     brokerAccounts,
     positions,
     portfolioIds,
-    addedTickers: [...addedTickers.values()],
-    updatedTickers: [...updatedTickers.values()],
+    get addedTickers() { return written.addedTickers; },
+    get updatedTickers() { return written.updatedTickers; },
+    rebase,
     commit,
   };
 }