@gloom-sh/terminal 0.18.5 → 0.19.0

package/src/renderers/electrobun/view/view-ids.ts

@@ -0,0 +1,85 @@
+import { ANONYMOUS_ID_STORAGE_KEY, ATTRIBUTION_STORAGE_KEY } from "../../../api-client/research-activity";
+import { SYNC_CLIENT_ID_STORAGE_KEY } from "../../../sync/controller";
+import { logFailure } from "../../../utils/log-failure";
+import type { DesktopViewIds } from "../shared/protocol";
+
+/**
+ * What the desktop view keeps only in its WebView storage: the id Cloud sync
+ * knows this device by, and the visitor id and first touch a gloom.sh link
+ * handed over. macOS and Windows keep that storage under the app's bundle
+ * identifier, so a build under another identifier would start without them.
+ * The Bun process keeps a copy in the data folder (bun/desktop/view-ids.ts),
+ * and a view whose storage lacks one takes it back from there.
+ */
+const VIEW_ID_KEYS = [SYNC_CLIENT_ID_STORAGE_KEY, ANONYMOUS_ID_STORAGE_KEY, ATTRIBUTION_STORAGE_KEY] as const;
+
+interface ViewIdStorage {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+/** The view's WebView storage, or null where it is refused. */
+export function viewIdStorage(): ViewIdStorage | null {
+  try {
+    return globalThis.localStorage ?? null;
+  } catch {
+    // Intentional ignore: without storage there is nothing to restore or keep.
+    return null;
+  }
+}
+
+function readViewIds(storage: ViewIdStorage): DesktopViewIds {
+  const ids: DesktopViewIds = {};
+  for (const key of VIEW_ID_KEYS) {
+    const value = storage.getItem(key);
+    if (value) ids[key] = value;
+  }
+  return ids;
+}
+
+function sameIds(left: DesktopViewIds, right: DesktopViewIds): boolean {
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => left[key] === right[key]);
+}
+
+/** Puts the ids kept on disk into `storage` where it has none. One it has is never replaced. */
+export function restoreViewIds(storage: ViewIdStorage, kept: DesktopViewIds | undefined): void {
+  try {
+    for (const key of VIEW_ID_KEYS) {
+      const value = kept?.[key];
+      if (value && !storage.getItem(key)) storage.setItem(key, value);
+    }
+  } catch (error) {
+    logFailure("desktop-view-ids", "Could not restore the view's ids")(error);
+  }
+}
+
+/**
+ * A function that sends the ids in `storage` to be kept on disk when they
+ * differ from the copy there (`kept`, from `init`). It reads three keys, so it
+ * can run whenever one of them may have been written. A save that fails is
+ * tried again at the next call.
+ */
+export function createViewIdMirror(
+  storage: ViewIdStorage,
+  kept: DesktopViewIds | undefined,
+  save: (ids: DesktopViewIds) => Promise<unknown>,
+): () => void {
+  let onDisk: DesktopViewIds = { ...kept };
+  return () => {
+    let ids: DesktopViewIds;
+    try {
+      ids = readViewIds(storage);
+    } catch (error) {
+      logFailure("desktop-view-ids", "Could not read the view's ids")(error);
+      return;
+    }
+    if (sameIds(ids, onDisk)) return;
+    const previous = onDisk;
+    onDisk = ids;
+    save(ids).catch((error: unknown) => {
+      if (onDisk === ids) onDisk = previous;
+      logFailure("desktop-view-ids", "Could not send the view's ids to be kept")(error);
+    });
+  };
+}

package/src/renderers/opentui/start.tsx

@@ -38,6 +38,9 @@ import {
 } from "../../telemetry/crash-reports-node";
 import { currentTelemetryConfig } from "../../telemetry/live-config";
 import { installUpdateFailureReporter } from "../../telemetry/update-failures";
+import { installStallReporter, recordStall } from "../../telemetry/stall-reports";
+import { createNodeStallReporterHost } from "../../telemetry/stall-reports-node";
+import { setStallSink } from "../../utils/main-thread-stall";
 import { createNodeUpdateFailureHost } from "../../telemetry/update-failures-node";
 import { terminalInstallKind } from "../../updater";
 import { flushUsageCounts, installUsageCounter, usageCountsEnabled } from "../../telemetry/usage-counts";
@@ -124,6 +127,8 @@ export async function startOpenTuiApp({ externalPlugins, cliLaunchRequest }: Sta
       installKind: terminalInstallKind(),
       getDataDir: () => config.dataDir,
     }));
+    installStallReporter(createNodeStallReporterHost({ getDataDir: () => config.dataDir }));
+    setStallSink((event) => recordStall("terminal", event));
     installUsageCounter({
       surface: "terminal",
       os: describeNodeOs(),

package/src/series/registry.ts

@@ -63,6 +63,7 @@ export function seriesCatalogEntry(series: RegisteredSeries): SeriesCatalogEntry
     ...(definition.description ? { description: definition.description } : {}),
     ...(definition.publisher ? { publisher: definition.publisher } : {}),
     ...(definition.url ? { url: definition.url } : {}),
+    ...(definition.limitation ? { limitation: definition.limitation } : {}),
     ...(definition.input ? { input: definition.input } : {}),
     ...(definition.placement ? { placement: definition.placement } : {}),
     ...(definition.lines?.length ? {

package/src/series/types.ts

@@ -133,6 +133,11 @@ interface SeriesDefinitionBase {
   publisher?: string;
   /** The publisher's page for the series. */
   url?: string;
+  /**
+   * A limit on the data the publisher sets, such as a cap on how far back its
+   * history goes. One sentence: the catalog lists it beside the series.
+   */
+  limitation?: string;
   /** Ask for a ticker, an option or a crypto pair before charting. */
   input?: SeriesInput;
   /**
@@ -203,6 +208,7 @@ export interface SeriesCatalogEntry {
   description?: string;
   publisher?: string;
   url?: string;
+  limitation?: string;
   input?: SeriesInput;
   placement?: SeriesPlacement;
   /** The lines of a series that draws several, each with the expression that charts it alone. */

package/src/series/validate.ts

@@ -136,6 +136,7 @@ export function validateSeriesDefinition(definition: SeriesDefinition, context:
   checkLabel(id, "group", definition.group, 32, context);
   checkLabel(id, "description", definition.description, 300, context);
   checkLabel(id, "publisher", definition.publisher, 60, context);
+  checkLabel(id, "limitation", definition.limitation, 160, context);
   if (definition.tags !== undefined) {
     if (!Array.isArray(definition.tags) || definition.tags.length > 16) fail(id, "tags must be a list of at most 16 words.");
     for (const tag of definition.tags) checkLabel(id, "tag", tag, 40, context, false);

package/src/sources/gloomberb-cloud/index.ts

@@ -964,6 +964,7 @@ export function createGloomberbCloudCapabilities(provider = createGloomberbCloud
           return {
             articles: cloudNewsReadArticles(read, query.ticker),
             nextCursor: read.nextCursor ?? null,
+            access: read.access ?? null,
           };
         },
         async fetchNews(query: NewsQuery): Promise<NewsArticle[]> {

package/src/sources/gloomberb-cloud/news.ts

@@ -1,7 +1,8 @@
 import { normalizeNewsFeed } from "../../news/news-model";
 import { readableNewsSource } from "../../news/source-label";
 import { collectNewsDisplayTickers } from "../../news/ticker-symbols";
-import type { NewsArticle, NewsQuery, NewsStoryItem } from "../../types/news-source";
+import type { NewsAccess, NewsArticle, NewsQuery, NewsStoryItem } from "../../types/news-source";
+import { CLOUD_NEWS_DELAY_HOURS } from "../../api-client/plan-rules";
 import type {
   apiClient,
   CloudNewsListResponse,
@@ -134,10 +135,44 @@ export function cloudNewsParams(query: NewsQuery): CloudNewsParams {
   };
 }
 
-/** A page of Gloom Cloud stories, with the text searched for when a coin pair's feed had none filed under it. */
-export type CloudNewsRead = CloudNewsListResponse & { searchedFor?: string };
+/**
+ * A page of Gloom Cloud stories, with the text searched for when a coin pair's
+ * feed had none filed under it, and which news the service answered with.
+ */
+export type CloudNewsRead = Omit<CloudNewsListResponse, "access"> & { searchedFor?: string; access?: NewsAccess | null };
+
+/**
+ * How recently the service must have seen a story for the answer to be the
+ * live wire. It holds a story back from an account without real-time news
+ * until it last saw it {@link CLOUD_NEWS_DELAY_HOURS} hours ago; the hour
+ * less leaves room for this clock and the service's to disagree.
+ */
+const LIVE_STORY_WINDOW_MS = (CLOUD_NEWS_DELAY_HOURS - 1) * 60 * 60 * 1000;
+
+/**
+ * Which news a Gloom Cloud answer is, from the answer: what the service says
+ * when it says it; held back when the request carried no session, since the
+ * service holds news back for anyone it cannot name; live when it holds a
+ * story seen too recently to have been held back. Otherwise null: a quiet
+ * feed read live looks the same as a held-back one.
+ */
+export function cloudNewsAccess(
+  response: Pick<CloudNewsListResponse, "items" | "access">,
+  sentSession: boolean,
+  now = Date.now(),
+): NewsAccess | null {
+  if (response.access === "realtime" || response.access === "delayed") return response.access;
+  if (!sentSession) return "delayed";
+  const live = response.items.some((item) => {
+    const seenAt = Date.parse(item.lastSeenAt);
+    return Number.isFinite(seenAt) && now - seenAt < LIVE_STORY_WINDOW_MS;
+  });
+  return live ? "realtime" : null;
+}
 
-type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "searchCloudNews">;
+/** A client that cannot say whether a session goes with its requests (a test double) is taken to send one. */
+type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "searchCloudNews">
+  & Partial<Pick<typeof apiClient, "hasSessionCredential">>;
 
 /**
  * A news query's first page from Gloom Cloud. Stories are filed under company
@@ -147,13 +182,18 @@ type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "searchCloudNews"
  * no name to search keeps the empty answer.
  */
 export async function readCloudNews(client: CloudNewsClient, query: NewsQuery): Promise<CloudNewsRead> {
+  // Asked in the tick the request goes out in, which is when its headers take the session.
+  const sentSession = client.hasSessionCredential?.() ?? true;
   const response = await client.getCloudNews(cloudNewsParams(query));
-  if (response.items.length > 0 || query.cursor || normalizeNewsFeed(query) !== "ticker") return response;
+  const read: CloudNewsRead = { ...response, access: cloudNewsAccess(response, sentSession) };
+  if (response.items.length > 0 || query.cursor || normalizeNewsFeed(query) !== "ticker") return read;
   const text = coinSearchName(query.ticker, query.exchange, query.listingName);
-  if (!text) return response;
+  if (!text) return read;
   const found = await client.searchCloudNews(text, query.limit)
     .catch(logFailure("sources.gloomberb-cloud.news", "Search a coin's stories failed", null));
-  return found && found.items.length > 0 ? { items: found.items, nextCursor: null, searchedFor: text } : response;
+  return found && found.items.length > 0
+    ? { items: found.items, nextCursor: null, searchedFor: text, access: cloudNewsAccess(found, sentSession) }
+    : read;
 }
 
 /** A read's stories as articles, each marked with the text a coin's fallback searched for. */

package/src/sources/provider-router/financials.ts

@@ -3,7 +3,7 @@ import type { AnalystResearchData, CompanyProfile, CorporateActionsData, Financi
 import { hasLikelyQuoteUnitMismatch } from "../../utils/currency-units";
 import { coalesceFinancialPeriodAliases, mergeFinancialStatementRows } from "../../utils/financial-statements";
 import { normalizePriceHistory, normalizeTickerFinancialsPriceHistory } from "../../utils/price-history";
-import { redactUnavailableFundamentals, RETRACTABLE_VALUATION_FIELDS } from "../../utils/fundamentals";
+import { redactUnavailableFundamentals, RETRACTABLE_VALUATION_FIELDS, RETRACTED_FUNDAMENTALS_FIELDS } from "../../utils/fundamentals";
 import { hasValidQuoteObservationTime, isExtendedHoursExchange, isQuoteStaleForCurrentSession } from "../../market-data/quotes/freshness";
 import { mergeQuoteMetadata, quoteMetadataFromQuote, quoteMetadataMatchesTarget } from "../../market-data/quotes/metadata";
 import { canonicalExchange, parsePublicTickerKey } from "../../utils/exchanges";
@@ -458,12 +458,21 @@ function mergeFundamentals(primary: Fundamentals | undefined, fallback: Fundamen
   const merged = mergeDefinedObject(primary, fallback);
   if (merged) {
     const unavailable = new Set(fallback?.unavailableFields ?? []);
-    for (const field of RETRACTABLE_VALUATION_FIELDS) {
+    for (const field of RETRACTED_FUNDAMENTALS_FIELDS) {
       if (primary?.unavailableFields?.includes(field)) unavailable.add(field);
       else if (typeof primary?.[field] === "number" && Number.isFinite(primary[field])) unavailable.delete(field);
     }
     if (unavailable.size) merged.unavailableFields = [...unavailable];
     else delete merged.unavailableFields;
+    // A retracted cap is none, whatever an older observation held; its reason goes with the retraction that stands.
+    if (unavailable.has("marketCap")) {
+      delete merged.marketCap;
+      merged.marketCapUnavailable = primary?.unavailableFields?.includes("marketCap")
+        ? primary.marketCapUnavailable : fallback?.marketCapUnavailable;
+      if (!merged.marketCapUnavailable) delete merged.marketCapUnavailable;
+    } else {
+      delete merged.marketCapUnavailable;
+    }
   }
   const dividend = primary?.dividendYield != null ? primary : fallback;
   if (merged && dividend) {
@@ -557,7 +566,10 @@ export function mergeRefreshedFinancials(cached: TickerFinancials, fresh: Ticker
   const merged = mergeFinancials(cached, fresh)!;
   const statistics = redactUnavailableFundamentals(fresh?.fundamentals);
   if (!statistics) return merged;
-  const update: Fundamentals = { unavailableFields: statistics.unavailableFields };
+  const update: Fundamentals = {
+    unavailableFields: statistics.unavailableFields,
+    ...statistics.marketCapUnavailable ? { marketCapUnavailable: statistics.marketCapUnavailable } : {},
+  };
   const currencyConflict = cached.fundamentals?.financialCurrency && statistics.financialCurrency
     && cached.fundamentals.financialCurrency !== statistics.financialCurrency;
   for (const field of RETRACTABLE_VALUATION_FIELDS) {

package/src/sources/provider-router/index.ts

@@ -53,6 +53,7 @@ import { ProviderRouterSearchRoutes } from "./search";
 import { collectCapabilityRouteSources, normalizeRouteSource } from "./sources";
 import type { ProviderRouterCoreDeps } from "./route-types";
 import { withProviderConnectionHealth } from "./connection-health";
+import { withFiledTrailingEps } from "../../time-series/filed-trailing-eps";
 import {
   contextFromCachedTarget,
   getBrokerCandidates,
@@ -213,7 +214,7 @@ export class AssetDataRouter implements DataProvider {
     for (const target of valid) {
       const key = target.symbol.toUpperCase();
       const financials = cached.get(key);
-      if (financials) cached.set(key, this.knownFinancials(financials, listingOf(target, contextFromCachedTarget(target))));
+      if (financials) cached.set(key, withFiledTrailingEps(this.knownFinancials(financials, listingOf(target, contextFromCachedTarget(target)))));
     }
     return cached;
   }
@@ -263,8 +264,9 @@ export class AssetDataRouter implements DataProvider {
     const dated = await this.datedAnswers(quoted, options.datesChangeBasis);
     let next = 0;
     const results = answered.map((result) => {
-      if (!result.financials?.quote) return result;
-      const financials = this.withDatedQuote(result.financials, dated[next++]!, listingOfResult(result));
+      if (!result.financials) return result;
+      const quoted = result.financials.quote ? this.withDatedQuote(result.financials, dated[next++]!, listingOfResult(result)) : result.financials;
+      const financials = withFiledTrailingEps(quoted);
       return financials === result.financials ? result : { ...result, financials };
     });
     const restored = new Map(results.map((result) => {
@@ -279,10 +281,11 @@ export class AssetDataRouter implements DataProvider {
     const { context, datesChangeBasis } = splitDating(requestContext);
     exchange = this.resolvePublicExchange(ticker, exchange, context);
     const financials = await this.financialRoutes.getTickerFinancials(ticker, exchange, context);
-    if (!financials.quote) return financials;
+    if (!financials.quote) return withFiledTrailingEps(financials);
     const listing = listingOf({ symbol: ticker, exchange }, context);
     const [quote] = await this.datedAnswers([{ quote: financials.quote, listing }], datesChangeBasis);
-    return this.withDatedQuote(financials, quote!, listing);
+    // One trailing EPS and P/E for every view of the listing: the filed quarters', as PEB and GE read them.
+    return withFiledTrailingEps(this.withDatedQuote(financials, quote!, listing));
   }
 
   async getQuote(ticker: string, exchange?: string, requestContext?: MarketDataRequestContext): Promise<Quote> {

package/src/state/ticker-cleanup.ts

@@ -0,0 +1,50 @@
+import type { AppTickerRepositoryPort } from "../core/app-service-ports";
+import { hasPendingTickerWrites, settleTickerWrites, tickerWriteRevision } from "../data/ticker-writes";
+import type { TickerRecord } from "../types/ticker";
+
+/**
+ * Persist cleanup before publishing it, retrying against edits acknowledged in between.
+ * Return the cleaned map so callers can recheck it after their config save.
+ */
+export async function persistTickerCleanup({
+  tickerRepository,
+  getTickers,
+  transform,
+  publish,
+  isCurrent = () => true,
+}: {
+  tickerRepository: AppTickerRepositoryPort;
+  getTickers: () => ReadonlyMap<string, TickerRecord>;
+  transform: (ticker: TickerRecord) => TickerRecord | null;
+  publish: (symbol: string, ticker: TickerRecord | null) => void;
+  isCurrent?: () => boolean;
+}): Promise<ReadonlyMap<string, TickerRecord> | null> {
+  for (;;) {
+    do {
+      await settleTickerWrites(tickerRepository);
+    } while (hasPendingTickerWrites(tickerRepository));
+    if (!isCurrent()) return null;
+    const before = getTickers();
+    let wrote = false;
+    for (const symbol of before.keys()) {
+      do {
+        await settleTickerWrites(tickerRepository);
+      } while (hasPendingTickerWrites(tickerRepository));
+      if (!isCurrent()) return null;
+      const source = getTickers().get(symbol);
+      if (!source) continue;
+      const next = transform(source);
+      if (next === source) continue;
+      wrote = true;
+      const save = next ? tickerRepository.saveTicker(next) : tickerRepository.deleteTicker(symbol);
+      const revision = tickerWriteRevision(tickerRepository, symbol);
+      await save;
+      if (!isCurrent()) return null;
+      // An edit can start its save before publishing state, especially over RPC.
+      if (tickerWriteRevision(tickerRepository, symbol) !== revision || getTickers().get(symbol) !== source) continue;
+      publish(symbol, next);
+    }
+    // Include rows created or recreated while earlier rows were being saved.
+    if (!wrote && getTickers() === before) return before;
+  }
+}

package/src/sync/controller.ts

@@ -41,7 +41,8 @@ interface SyncRuntime {
   isLocalMarketData?: LocalMarketDataLookup;
 }
 
-const CLIENT_ID_STORAGE_KEY = "gloomberb.sync.clientId";
+/** Kept in the view's storage; the desktop app also keeps a copy on disk (electrobun/view/view-ids.ts). */
+export const SYNC_CLIENT_ID_STORAGE_KEY = "gloomberb.sync.clientId";
 const PUSH_DEBOUNCE_MS = 2500;
 /** How soon after a change contributors date it, so an edit made just before quitting still is. */
 const OBSERVE_DEBOUNCE_MS = 250;
@@ -60,10 +61,10 @@ function nowIso(): string {
 
 function resolveClientId(): string {
   const storage = globalThis.localStorage;
-  const existing = storage?.getItem(CLIENT_ID_STORAGE_KEY);
+  const existing = storage?.getItem(SYNC_CLIENT_ID_STORAGE_KEY);
   if (existing) return existing;
   const id = `client_${crypto.randomUUID()}`;
-  storage?.setItem(CLIENT_ID_STORAGE_KEY, id);
+  storage?.setItem(SYNC_CLIENT_ID_STORAGE_KEY, id);
   return id;
 }
 

package/src/sync/core-contributors.ts

@@ -1,4 +1,6 @@
 import { saveConfigImmediately, scheduleConfigSave } from "../state/config-save-scheduler";
+import { persistTickerCleanup } from "../state/ticker-cleanup";
+import { hasPendingTickerWrites } from "../data/ticker-writes";
 import { normalizeStoredBaseCurrency } from "../utils/base-currency";
 import { debugLog } from "../utils/debug-log";
 import { fnv1aHex, stableStringify } from "../utils/hash";
@@ -1184,6 +1186,23 @@ function holdingIn(positions: readonly TickerPosition[], links: readonly unknown
   };
 }
 
+/** Without a shared baseline, keep both devices' manual lots, matching identical copies one for one. */
+function mergeUntrackedManualPositions(local: TickerPosition[], pulled: TickerPosition[]): TickerPosition[] {
+  const unmatched = new Map<string, number>();
+  for (const position of local) {
+    const key = JSON.stringify(sanitizePosition(position));
+    unmatched.set(key, (unmatched.get(key) ?? 0) + 1);
+  }
+  const merged = [...local];
+  for (const position of pulled) {
+    const key = JSON.stringify(sanitizePosition(position));
+    const count = unmatched.get(key) ?? 0;
+    if (count > 0) unmatched.set(key, count - 1);
+    else merged.push(position);
+  }
+  return merged;
+}
+
 interface PulledTickersMerge {
   lastSyncedTickers: Map<string, Record<string, unknown>> | null;
   /** This device's live broker portfolios, each with the side holding its latest broker sync. */
@@ -1274,8 +1293,25 @@ function mergePulledTicker(
         holdingIn(baselinePositions, baselineLinks, portfolioId),
       );
     const [sidePositions, sideLinks] = takePulled ? [pulledPositions, pulledLinks] : [localPositions, localLinks];
-    positions.push(...sidePositions.filter((position) => position.portfolio === portfolioId));
-    if (sideLinks.includes(portfolioId)) portfolios.push(portfolioId);
+    if (brokerSide && !merge.localOnly?.portfolioIds.has(portfolioId)) {
+      // A broker's timestamp governs imported holdings, never hand-entered
+      // lots. Those use the same edit comparison as a manual portfolio.
+      const manualIn = (entries: readonly TickerPosition[]) => entries.filter((position) => (
+        position.portfolio === portfolioId && position.broker === "manual"
+      ));
+      const localManual = manualIn(localPositions);
+      const manualEdited = comparable && !sameAsStored(
+        localManual.map(sanitizePosition), manualIn(baselinePositions).map(sanitizePosition),
+      );
+      const pulledManual = manualIn(pulledPositions);
+      const manual = !comparable ? mergeUntrackedManualPositions(localManual, pulledManual)
+        : manualEdited ? localManual : pulledManual;
+      positions.push(...sidePositions.filter((position) => position.portfolio === portfolioId && position.broker !== "manual"), ...manual);
+      if (sideLinks.includes(portfolioId) || manual.length > 0) portfolios.push(portfolioId);
+    } else {
+      positions.push(...sidePositions.filter((position) => position.portfolio === portfolioId));
+      if (sideLinks.includes(portfolioId)) portfolios.push(portfolioId);
+    }
   }
 
   const record: TickerRecord = {
@@ -1297,8 +1333,9 @@ function mergePulledTicker(
 function withoutUnpulledHoldings(ticker: TickerRecord, merge: PulledTickersMerge): TickerRecord | null {
   const sold = (portfolioId: string) => merge.brokerPortfolios.get(portfolioId) === "pulled";
   const { metadata } = ticker;
-  const positions = metadata.positions.filter((position) => !sold(position.portfolio));
-  const portfolios = metadata.portfolios.filter((portfolioId) => !sold(portfolioId));
+  const positions = metadata.positions.filter((position) => position.broker === "manual" || !sold(position.portfolio));
+  const held = new Set(positions.map((position) => position.portfolio));
+  const portfolios = metadata.portfolios.filter((portfolioId) => held.has(portfolioId) || !sold(portfolioId));
   const kept = positions.length === metadata.positions.length && portfolios.length === metadata.portfolios.length
     ? ticker
     : { ...ticker, metadata: { ...metadata, positions, portfolios } };
@@ -1322,12 +1359,57 @@ export const coreConfigSyncContributor: SyncContributor = {
   },
   apply: async (payload, { snapshot, baselinePayload, baselineState, state, getState, isCurrent, dispatch, tickerRepository, memo }) => {
     const pushedAt = snapshot?.contributors[CORE_CONFIG_CONTRIBUTOR_ID]?.updatedAt;
-    const nextConfig = mergeConfigPayload(state.config, payload, baselineState.config, baselinePayload, {
+    const merge = (config: AppConfig) => mergeConfigPayload(config, payload, baselineState.config, baselinePayload, {
       memo: memo?.get(),
       pushedAt,
-    }, localOnlyScope(state.config));
+    }, localOnlyScope(config));
+    let nextConfig = merge(state.config);
     if (!nextConfig) return;
-    const configChanged = !valuesEqual(nextConfig, state.config);
+    const removed = removedBrokerHoldings(state.config, nextConfig);
+    if (removed) {
+      // Keep the profile until row and config writes succeed, so a failed
+      // cleanup remains visible to the next attempt.
+      const cleanTickers = () => persistTickerCleanup({
+        tickerRepository,
+        getTickers: () => getState().tickers,
+        transform: (ticker) => withoutRemovedBrokerHoldings(ticker, removed),
+        publish: (symbol, ticker) => {
+          const tickers = new Map(getState().tickers);
+          if (ticker) tickers.set(symbol, ticker);
+          else tickers.delete(symbol);
+          dispatch({ type: "SET_TICKERS", tickers });
+        },
+        isCurrent,
+      });
+      let savedRemoval = false;
+      for (;;) {
+        const cleaned = await cleanTickers().catch(async (error: unknown) => {
+          // Restore the profile if a late row fails after config was saved,
+          // so retry can also recover after restarting the app.
+          if (savedRemoval) await saveConfigImmediately(getState().config);
+          throw error;
+        });
+        if (!cleaned || !isCurrent()) return;
+        if (hasPendingTickerWrites(tickerRepository) || getState().tickers !== cleaned) continue;
+        const source = getState().config;
+        const merged = merge(source);
+        if (!merged) return;
+        // Preserve unrelated edits while retaining the removal already applied
+        // to rows, including pulls from builds that merged whole profile lists.
+        nextConfig = {
+          ...merged,
+          brokerInstances: merged.brokerInstances.filter((instance) => !removed.instanceIds.has(instance.id)),
+          portfolios: merged.portfolios.filter((portfolio) => !removed.portfolioIds.has(portfolio.id)),
+        };
+        await saveConfigImmediately(nextConfig);
+        savedRemoval = true;
+        if (!isCurrent()) return;
+        if (getState().config !== source || getState().tickers !== cleaned
+          || hasPendingTickerWrites(tickerRepository)) continue;
+        break;
+      }
+    }
+    const configChanged = !valuesEqual(nextConfig, getState().config);
     if (configChanged) {
       // Adopting another device's workspace rearranges the screen under the
       // user, so it is worth a line in the log when a report says "my panes
@@ -1339,32 +1421,9 @@ export const coreConfigSyncContributor: SyncContributor = {
         });
       }
       dispatch({ type: "SET_CONFIG", config: nextConfig });
-      scheduleConfigSave(nextConfig);
+      if (!removed) scheduleConfigSave(nextConfig);
     }
     if (memo && isRecord(payload)) rememberCloudLayout(payload, pushedAt, getState().config, memo, nextConfig.layouts !== state.config.layouts);
-    if (!configChanged) return;
-
-    // A profile removed on another device takes its positions with it here
-    // too; kept, this device would push them back and recreate the tickers
-    // that removal deleted.
-    const removed = removedBrokerHoldings(state.config, nextConfig);
-    if (!removed) return;
-    const nextTickers = new Map(getState().tickers);
-    let changed = false;
-    for (const ticker of getState().tickers.values()) {
-      if (!isCurrent()) return;
-      const next = withoutRemovedBrokerHoldings(ticker, removed);
-      if (next === ticker) continue;
-      changed = true;
-      if (next) {
-        await tickerRepository.saveTicker(next);
-        nextTickers.set(next.metadata.ticker, next);
-      } else {
-        await tickerRepository.deleteTicker(ticker.metadata.ticker);
-        nextTickers.delete(ticker.metadata.ticker);
-      }
-    }
-    if (changed && isCurrent()) dispatch({ type: "SET_TICKERS", tickers: nextTickers });
   },
 };
 

package/src/telemetry/stall-reports-dom.ts

@@ -0,0 +1,38 @@
+import type { StallEvent } from "../utils/main-thread-stall";
+
+/**
+ * Only the freezes a user sat through. The system slows the timers of a
+ * window behind others or out of view, sometimes to one a second, and the
+ * stall monitor cannot tell that from a freeze: a timer back a second late
+ * reads the same either way. A window that has been in front, with focus,
+ * since before the stall began ran at full speed, so its late timers are
+ * freezes. Anything else is dropped, including a real freeze the user
+ * clicked into the window during: missing one beats reporting a false one.
+ */
+export function forwardAttendedStalls(
+  forward: (event: StallEvent) => void,
+  target: Window = window,
+  now: () => number = () => performance.now(),
+): { sink: (event: StallEvent) => void; dispose: () => void } {
+  const doc = target.document;
+  const attended = () => doc.visibilityState === "visible" && doc.hasFocus();
+  // Since when the window has been attended; never while it is not.
+  let attendedSince = attended() ? now() : Number.POSITIVE_INFINITY;
+  const update = () => {
+    if (!attended()) attendedSince = Number.POSITIVE_INFINITY;
+    else if (attendedSince === Number.POSITIVE_INFINITY) attendedSince = now();
+  };
+  target.addEventListener("focus", update);
+  target.addEventListener("blur", update);
+  doc.addEventListener("visibilitychange", update);
+  return {
+    sink: (event) => {
+      if (attended() && attendedSince <= now() - event.blockedMs) forward(event);
+    },
+    dispose: () => {
+      target.removeEventListener("focus", update);
+      target.removeEventListener("blur", update);
+      doc.removeEventListener("visibilitychange", update);
+    },
+  };
+}