gloomberb 0.13.2 → 0.14.0

package/src/state/hooks/inline-tickers.ts

@@ -1,14 +1,35 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { getSharedRegistry } from "../../plugins/registry";
 import { useAppDispatch, useAppSelector } from "../app/context";
-import { resolveTickerSearch, upsertTickerFromSearchResult } from "../../tickers/search";
+import {
+  AmbiguousTickerError,
+  resolveTickerSearch,
+  upsertTickerFromSearchResult,
+} from "../../tickers/search";
 import { collectUniqueTickerSymbols } from "../../tickers/tokenizer";
 import { useQuoteStreaming } from "./quote-streaming";
-import type { Quote } from "../../types/financials";
+import {
+  inlineTickerQuoteFailures,
+  inlineTickerResolutionFailures,
+  type InlineTickerFailureKind,
+} from "./inline-ticker-failures";
+import { getSharedMarketDataCoordinator, resolveEntryValue } from "../../market-data/coordinator";
+import { useQuoteEntries } from "../../market-data/hooks";
+import { instrumentFromTicker, type InstrumentRef } from "../../market-data/request-types";
+import { buildQuoteKey } from "../../market-data/selectors";
+import type { QueryEntry } from "../../market-data/result-types";
+import type { AppAction } from "../app/context";
+import type { PluginRegistry } from "../../plugins/registry";
+import type { Quote, TickerFinancials } from "../../types/financials";
 import type { TickerRecord } from "../../types/ticker";
 import { TICKER_RESEARCH_PANE_ID } from "../../types/config";
 
-type InlineTickerStatus = "loading" | "ready" | "missing";
+/**
+ * `ambiguous` is not a failure to show as one: the symbol resolved to several
+ * listings, so the badge stays a badge and opening it asks which listing was
+ * meant. Only `missing` degrades to plain text.
+ */
+export type InlineTickerStatus = "loading" | "ready" | "ambiguous" | "missing";
 
 export interface InlineTickerCatalogEntry {
   status: InlineTickerStatus;
@@ -18,18 +39,109 @@ export interface InlineTickerCatalogEntry {
 
 export interface UseInlineTickersOptions {
   liveQuotes?: boolean;
+  /**
+   * How long a badge must stay mounted before it resolves anything. Rows in a
+   * virtualised table mount only while they are in the visible range, so a
+   * settle window means rows flicked past during a scroll never cost a lookup
+   * or a quote subscription.
+   */
+  settleMs?: number;
 }
 
+const NO_INSTRUMENTS: InstrumentRef[] = [];
 const resolutionInFlight = new Map<string, Promise<void>>();
 const quoteInFlight = new Map<string, Promise<void>>();
-const missingSymbols = new Set<string>();
-const quoteMissingSymbols = new Set<string>();
-const initialQuoteRequested = new Set<string>();
 
 function normalizeSymbols(texts: readonly string[]): string[] {
   return collectUniqueTickerSymbols(texts);
 }
 
+function quoteFailureKind(entry: QueryEntry<Quote> | undefined): InlineTickerFailureKind {
+  const reasonCode = entry?.error?.reasonCode;
+  return reasonCode === "NOT_FOUND" || reasonCode === "BAD_MAPPING" || reasonCode === "NO_DATA"
+    ? "unknown"
+    : "error";
+}
+
+interface InlineTickerContext {
+  tickers: ReadonlyMap<string, TickerRecord>;
+  financials: ReadonlyMap<string, TickerFinancials>;
+  dispatch: (action: AppAction) => void;
+  registry: PluginRegistry | undefined;
+}
+
+interface QuoteRequest {
+  instrument: InstrumentRef;
+  context: InlineTickerContext;
+}
+
+/**
+ * Every badge in a table is its own component asking for its own symbol. Each
+ * one queues here instead of fetching, so the whole visible page of rows leaves
+ * as a single batch the coordinator can dedupe, cache and prioritise.
+ */
+let pendingQuoteBatch: { requests: Map<string, QuoteRequest>; promise: Promise<void> } | null = null;
+
+function queueQuoteLoad(symbol: string, request: QuoteRequest): Promise<void> {
+  if (!pendingQuoteBatch) {
+    const requests = new Map<string, QuoteRequest>();
+    const promise = new Promise<void>((resolve) => {
+      setTimeout(() => {
+        pendingQuoteBatch = null;
+        void loadInlineQuotes(requests).finally(resolve);
+      }, 0);
+    });
+    pendingQuoteBatch = { requests, promise };
+  }
+  pendingQuoteBatch.requests.set(symbol, request);
+  return pendingQuoteBatch.promise;
+}
+
+async function loadInlineQuotes(requests: Map<string, QuoteRequest>): Promise<void> {
+  const batch = [...requests.entries()];
+  if (batch.length === 0) return;
+  const coordinator = getSharedMarketDataCoordinator();
+
+  if (coordinator) {
+    const entries = await coordinator.loadQuotesBatch(batch.map(([, request]) => request.instrument));
+    batch.forEach(([symbol, request], index) => {
+      const entry = entries[index];
+      const quote = entry ? resolveEntryValue(entry) : null;
+      if (quote) {
+        inlineTickerQuoteFailures.clear(symbol);
+        request.context.dispatch({ type: "MERGE_QUOTE", symbol, quote });
+        return;
+      }
+      inlineTickerQuoteFailures.record(symbol, quoteFailureKind(entry));
+    });
+    return;
+  }
+
+  // Without a coordinator there is nothing to batch through, so each symbol
+  // asks the provider directly.
+  await Promise.all(batch.map(async ([symbol, { instrument, context }]) => {
+    const provider = context.registry?.marketData;
+    if (!provider) return;
+    try {
+      const quote = await provider.getQuote(
+        symbol,
+        instrument.exchange ?? "",
+        instrument.instrument
+          ? {
+            brokerId: instrument.brokerId,
+            brokerInstanceId: instrument.brokerInstanceId,
+            instrument: instrument.instrument,
+          }
+          : undefined,
+      );
+      inlineTickerQuoteFailures.clear(symbol);
+      context.dispatch({ type: "MERGE_QUOTE", symbol, quote });
+    } catch {
+      inlineTickerQuoteFailures.record(symbol, "error");
+    }
+  }));
+}
+
 export function useInlineTickerOpener(): (symbol: string) => void {
   const registry = getSharedRegistry();
   return useCallback((symbol: string) => {
@@ -45,43 +157,94 @@ export function useInlineTickers(
   openTicker: (symbol: string) => void;
 } {
   const liveQuotes = options.liveQuotes ?? true;
+  const settleMs = Math.max(0, options.settleMs ?? 0);
   const dispatch = useAppDispatch();
   const tickers = useAppSelector((state) => state.tickers);
   const financials = useAppSelector((state) => state.financials);
   const registry = getSharedRegistry();
   const [refreshVersion, setRefreshVersion] = useState(0);
+  const [settled, setSettled] = useState(settleMs <= 0);
   const textsKey = texts.join("\u0000");
   const symbols = useMemo(() => normalizeSymbols(texts), [textsKey]);
   const symbolsKey = symbols.join("|");
   const financialsEffectTarget = liveQuotes ? financials : null;
-  const latestRef = useRef({ tickers, financials, dispatch, registry });
+  const latestRef = useRef<InlineTickerContext>({ tickers, financials, dispatch, registry });
 
   latestRef.current = { tickers, financials, dispatch, registry };
 
   useEffect(() => {
+    if (settled) return;
+    const timer = setTimeout(() => setSettled(true), settleMs);
+    return () => clearTimeout(timer);
+  }, [settleMs, settled]);
+
+  const instruments = useMemo(() => {
+    if (!liveQuotes) return NO_INSTRUMENTS;
+    return symbols.flatMap((symbol) => {
+      const instrument = instrumentFromTicker(tickers.get(symbol) ?? null, symbol);
+      return instrument && tickers.has(symbol) ? [instrument] : [];
+    });
+  }, [liveQuotes, symbolsKey, tickers]);
+  const streamingTargets = useMemo(() => {
+    if (!settled) return [];
+    return instruments.map((instrument) => ({
+      symbol: instrument.symbol,
+      exchange: instrument.exchange,
+      surface: "inline" as const,
+      visible: true,
+      weight: 40,
+      context: instrument.instrument
+        ? {
+          brokerId: instrument.brokerId,
+          brokerInstanceId: instrument.brokerInstanceId,
+          instrument: instrument.instrument,
+        }
+        : undefined,
+    }));
+  }, [instruments, settled]);
+
+  useQuoteStreaming(streamingTargets);
+  // The stream fills the coordinator, so reading it here is what makes a badge
+  // tick with the market instead of freezing on its first snapshot.
+  const quoteEntries = useQuoteEntries(settled ? instruments : NO_INSTRUMENTS);
+  const readStreamedQuote = useCallback((symbol: string): Quote | null => {
+    const ticker = latestRef.current.tickers.get(symbol);
+    const instrument = ticker ? instrumentFromTicker(ticker, symbol) : null;
+    if (!instrument) return null;
+    const entry = quoteEntries.get(buildQuoteKey(instrument));
+    return entry ? resolveEntryValue(entry) : null;
+  }, [quoteEntries]);
+
+  useEffect(() => {
+    if (!settled) return;
+    // A rebound registry is a new provider, a reconnect, or a network that came
+    // back, and none of the old verdicts survive it.
+    inlineTickerResolutionFailures.scopeTo(registry);
+    inlineTickerQuoteFailures.scopeTo(registry);
+
     let mounted = true;
     const notify = () => {
       if (!mounted) return;
       setRefreshVersion((value) => value + 1);
     };
+    const now = Date.now();
+    const pendingQuotes = new Map<string, InstrumentRef>();
 
     for (const symbol of symbols) {
       const current = latestRef.current;
       const currentTicker = current.tickers.get(symbol) ?? null;
       const currentQuote = liveQuotes
-        ? current.financials.get(symbol)?.quote ?? null
+        ? readStreamedQuote(symbol) ?? current.financials.get(symbol)?.quote ?? null
         : null;
 
       if (currentTicker && (!liveQuotes || currentQuote)) {
-        missingSymbols.delete(symbol);
-        if (liveQuotes) {
-          quoteMissingSymbols.delete(symbol);
-          initialQuoteRequested.delete(symbol);
-        }
+        inlineTickerResolutionFailures.clear(symbol);
+        if (liveQuotes) inlineTickerQuoteFailures.clear(symbol);
         continue;
       }
 
-      if (!currentTicker && !missingSymbols.has(symbol)) {
+      if (!currentTicker) {
+        if (inlineTickerResolutionFailures.read(symbol, now)) continue;
         let resolution = resolutionInFlight.get(symbol);
         if (!resolution) {
           resolution = (async () => {
@@ -96,7 +259,7 @@ export function useInlineTickers(
             });
 
             if (!resolved) {
-              missingSymbols.add(symbol);
+              inlineTickerResolutionFailures.record(symbol, "unknown");
               return;
             }
 
@@ -107,10 +270,15 @@ export function useInlineTickers(
             if (created) {
               activeRegistry.events.emit("ticker:added", { symbol: ticker.metadata.ticker, ticker });
             }
-            missingSymbols.delete(symbol);
+            inlineTickerResolutionFailures.clear(symbol);
           })()
-            .catch(() => {
-              missingSymbols.add(symbol);
+            .catch((error: unknown) => {
+              // An ambiguous symbol resolved fine, it just named several
+              // listings. The badge stays, and clicking it asks which one.
+              inlineTickerResolutionFailures.record(
+                symbol,
+                error instanceof AmbiguousTickerError ? "ambiguous" : "error",
+              );
             })
             .finally(() => {
               resolutionInFlight.delete(symbol);
@@ -121,75 +289,66 @@ export function useInlineTickers(
         continue;
       }
 
-      if (!liveQuotes || !currentTicker || currentQuote || initialQuoteRequested.has(symbol)) continue;
-
-      let quoteRequest = quoteInFlight.get(symbol);
-      if (!quoteRequest) {
-        initialQuoteRequested.add(symbol);
-        quoteRequest = (async () => {
-          const current = latestRef.current;
-          const activeRegistry = current.registry;
-          if (!activeRegistry) return;
-
-          const latestTicker = current.tickers.get(symbol);
-          if (!latestTicker) return;
-
-          const instrument = latestTicker.metadata.broker_contracts?.[0] ?? null;
-          const quote = await activeRegistry.marketData.getQuote(
-            symbol,
-            latestTicker.metadata.exchange,
-            instrument
-              ? {
-                brokerId: instrument.brokerId,
-                brokerInstanceId: instrument.brokerInstanceId,
-                instrument,
-              }
-              : undefined,
-          );
-          quoteMissingSymbols.delete(symbol);
-          current.dispatch({ type: "MERGE_QUOTE", symbol, quote });
-        })()
-          .catch(() => {
-            quoteMissingSymbols.add(symbol);
-          })
-          .finally(() => {
-            quoteInFlight.delete(symbol);
-          });
-        quoteInFlight.set(symbol, quoteRequest);
+      if (!liveQuotes || quoteInFlight.has(symbol) || inlineTickerQuoteFailures.read(symbol, now)) continue;
+      const instrument = instrumentFromTicker(currentTicker, symbol);
+      if (instrument) pendingQuotes.set(symbol, instrument);
+    }
+
+    if (pendingQuotes.size > 0) {
+      const context = latestRef.current;
+      let batch: Promise<void> | undefined;
+      for (const [symbol, instrument] of pendingQuotes) {
+        batch = queueQuoteLoad(symbol, { instrument, context });
+      }
+      const request = batch!
+        .catch(() => {
+          for (const symbol of pendingQuotes.keys()) {
+            inlineTickerQuoteFailures.record(symbol, "error");
+          }
+        })
+        .finally(() => {
+          for (const symbol of pendingQuotes.keys()) {
+            if (quoteInFlight.get(symbol) === request) quoteInFlight.delete(symbol);
+          }
+        });
+      for (const symbol of pendingQuotes.keys()) {
+        quoteInFlight.set(symbol, request);
       }
-      void quoteRequest.finally(notify);
+      void request.finally(notify);
     }
 
     return () => {
       mounted = false;
     };
-  }, [dispatch, financialsEffectTarget, liveQuotes, registry, symbols, symbolsKey, tickers]);
-
-  const streamingTargets = useMemo(() => {
-    if (!liveQuotes) return [];
-    return symbols
-      .map((symbol) => tickers.get(symbol))
-      .filter((ticker): ticker is TickerRecord => ticker != null)
-      .map((ticker) => {
-        const instrument = ticker.metadata.broker_contracts?.[0] ?? null;
-        return {
-          symbol: ticker.metadata.ticker,
-          exchange: ticker.metadata.exchange,
-          surface: "inline" as const,
-          visible: true,
-          weight: 40,
-          context: instrument
-            ? {
-              brokerId: instrument.brokerId,
-              brokerInstanceId: instrument.brokerInstanceId,
-              instrument,
-            }
-            : undefined,
-        };
-      });
-  }, [liveQuotes, symbols, tickers]);
+  }, [
+    dispatch,
+    financialsEffectTarget,
+    liveQuotes,
+    readStreamedQuote,
+    refreshVersion,
+    registry,
+    settled,
+    symbols,
+    symbolsKey,
+    tickers,
+  ]);
 
-  useQuoteStreaming(streamingTargets);
+  // Nothing re-renders when a cached failure ages out, so the earliest retry
+  // wakes the effect that would otherwise wait for unrelated state to change.
+  useEffect(() => {
+    if (!settled) return;
+    const now = Date.now();
+    const deadlines = [
+      inlineTickerResolutionFailures.nextRetryAt(symbols, now),
+      liveQuotes ? inlineTickerQuoteFailures.nextRetryAt(symbols, now) : null,
+    ].filter((deadline): deadline is number => deadline != null);
+    if (deadlines.length === 0) return;
+    const timer = setTimeout(
+      () => setRefreshVersion((value) => value + 1),
+      Math.max(0, Math.min(...deadlines) - now) + 50,
+    );
+    return () => clearTimeout(timer);
+  }, [liveQuotes, refreshVersion, settled, symbols, symbolsKey]);
 
   const openTicker = useInlineTickerOpener();
 
@@ -197,16 +356,26 @@ export function useInlineTickers(
     const entries: Record<string, InlineTickerCatalogEntry> = {};
     for (const symbol of symbols) {
       const ticker = tickers.get(symbol) ?? null;
-      const quote = liveQuotes ? financials.get(symbol)?.quote ?? null : null;
+      const quote = liveQuotes
+        ? readStreamedQuote(symbol) ?? financials.get(symbol)?.quote ?? null
+        : null;
+      const resolutionFailure = ticker ? null : inlineTickerResolutionFailures.read(symbol);
+      // A ticker the provider cannot price is still a ticker: it keeps its
+      // badge and simply shows no change. `missing` is reserved for text that
+      // never named an instrument at all.
       const status: InlineTickerStatus = ticker
-        ? liveQuotes
-          ? (quote ? "ready" : quoteMissingSymbols.has(symbol) ? "missing" : "loading")
+        ? liveQuotes && !quote && !inlineTickerQuoteFailures.read(symbol)
+          ? "loading"
           : "ready"
-        : (missingSymbols.has(symbol) ? "missing" : "loading");
+        : resolutionFailure === "ambiguous"
+          ? "ambiguous"
+          : resolutionFailure
+            ? "missing"
+            : "loading";
       entries[symbol] = { status, ticker, quote };
     }
     return entries;
-  }, [financials, liveQuotes, refreshVersion, symbols, tickers]);
+  }, [financials, liveQuotes, readStreamedQuote, refreshVersion, symbols, tickers]);
 
   return { catalog, openTicker };
 }

package/src/state/hooks/quote-streaming.ts

@@ -8,7 +8,7 @@ import { getSharedMarketDataCoordinator, type MarketDataCoordinator } from "../.
 import { useQuoteEntries } from "../../market-data/hooks";
 import type { InstrumentRef } from "../../market-data/request-types";
 import type { QueryEntry } from "../../market-data/result-types";
-import { buildQuoteKey } from "../../market-data/selectors";
+import { buildInstrumentKey, buildQuoteKey } from "../../market-data/selectors";
 
 const quoteStreamLog = debugLog.createLogger("quote-stream");
 export const DEFAULT_QUOTE_POLL_INTERVAL_MS = 60_000;
@@ -34,18 +34,11 @@ export function normalizeQuoteStreamSubscriptionTarget(target: QuoteSubscription
 }
 
 export function buildQuoteStreamSubscriptionIdentityKey(target: QuoteSubscriptionTarget): string {
-  const contractKey = target.context?.instrument?.conId
-    ?? target.context?.instrument?.localSymbol
-    ?? target.context?.instrument?.symbol
-    ?? "";
-  return [
-    target.symbol,
-    target.exchange ?? "",
-    target.context?.brokerId ?? "",
-    target.context?.brokerInstanceId ?? "",
-    contractKey,
-    target.route ?? "auto",
-  ].join("|");
+  return `${buildInstrumentKey({
+    symbol: target.symbol, exchange: target.exchange,
+    brokerId: target.context?.brokerId, brokerInstanceId: target.context?.brokerInstanceId,
+    instrument: target.context?.instrument,
+  })}|${target.route ?? "auto"}`;
 }
 
 export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget): string {

package/src/state/hooks/session-snapshot.ts

@@ -30,17 +30,22 @@ export function usePersistSessionSnapshot(
     schemaVersion,
   };
 
-  const schedulerRef = useRef<ReturnType<typeof createPersistScheduler<AppSessionSnapshot>> | null>(null);
+  // The snapshot is built when the debounce fires, not on every state change
+  // that schedules it: a cursor move would otherwise pay for a full snapshot
+  // that the next move replaces before it is ever written.
+  const schedulerRef = useRef<ReturnType<typeof createPersistScheduler<() => AppSessionSnapshot | null>> | null>(null);
   if (!schedulerRef.current) {
-    schedulerRef.current = createPersistScheduler<AppSessionSnapshot>({
+    schedulerRef.current = createPersistScheduler<() => AppSessionSnapshot | null>({
       delayMs: SESSION_SAVE_DEBOUNCE_MS,
-      save: (snapshot) => {
+      save: (build) => {
         const {
           sessionStore: currentStore,
           sessionId: currentSessionId,
           schemaVersion: currentSchemaVersion,
         } = latestRef.current;
         if (!currentStore) return;
+        const snapshot = build();
+        if (!snapshot) return;
         measurePerf("persist.session.save", () => {
           currentStore.set(currentSessionId, snapshot, currentSchemaVersion);
         }, { sessionId: currentSessionId });
@@ -75,8 +80,7 @@ export function usePersistSessionSnapshot(
   useEffect(() => {
     if (!sessionStore) return;
     if (!state.initialized && state.tickers.size === 0) return;
-    const snapshot = buildSnapshot();
-    if (snapshot) schedulerRef.current?.schedule(snapshot);
+    schedulerRef.current?.schedule(buildSnapshot);
   }, [
     sessionStore,
     sessionId,

package/src/state/persist-scheduler.test.ts

@@ -1,11 +1,31 @@
 import { describe, expect, test } from "bun:test";
-import { createPersistScheduler } from "./persist-scheduler";
+import { createPersistScheduler, flushPendingPersistence } from "./persist-scheduler";
 
 function delay(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 describe("createPersistScheduler", () => {
+  test("page exit drains the latest config and session once, excluding cancelled writes", async () => {
+    const saved: string[] = [];
+    const config = createPersistScheduler<string>({ delayMs: 60_000, save: (value) => { saved.push(value); } });
+    const session = createPersistScheduler<string>({ delayMs: 60_000, save: (value) => { saved.push(value); } });
+    const cancelled = createPersistScheduler<string>({ delayMs: 60_000, save: (value) => { saved.push(value); } });
+    config.schedule("old chart");
+    config.schedule("percent chart");
+    session.schedule("selected pane");
+    cancelled.schedule("discarded");
+    cancelled.cancel();
+    await flushPendingPersistence();
+    await flushPendingPersistence();
+    expect(saved).toEqual(["percent chart", "selected pane"]);
+
+    // Returning from a background tab must allow subsequent changes to save.
+    config.schedule("index chart");
+    await flushPendingPersistence();
+    expect(saved).toEqual(["percent chart", "selected pane", "index chart"]);
+  });
+
   test("coalesces scheduled saves and writes the latest value", async () => {
     const saved: number[] = [];
     const scheduler = createPersistScheduler<number>({
@@ -96,3 +116,36 @@ describe("createPersistScheduler", () => {
     expect(errors[0]).toBeInstanceOf(Error);
   });
 });
+
+for (const mode of ["timer", "immediate"] as const) test(`exit waits for an in-flight ${mode} save and changes scheduled while it is running`, async () => {
+  let start!: () => void;
+  let release!: () => void;
+  const started = new Promise<void>(resolve => { start = resolve; });
+  const held = new Promise<void>(resolve => { release = resolve; });
+  const saved: string[] = [];
+  const scheduler = createPersistScheduler<string>({
+    delayMs: 0,
+    save: async value => {
+      if (value === "first") { start(); await held; }
+      saved.push(value);
+    },
+  });
+  if (mode === "timer") scheduler.schedule("first");
+  else void scheduler.saveImmediately("first");
+  await started;
+  let flushed = false;
+  const exit = flushPendingPersistence().then(() => { flushed = true; });
+  try {
+    await delay(1);
+    expect(flushed).toBe(false);
+    // This update was not in the initial snapshot of pending exit work.
+    scheduler.schedule("last");
+    release();
+    await exit;
+    expect(saved).toEqual(["first", "last"]);
+  } finally {
+    release();
+    await scheduler.flush();
+    await exit;
+  }
+});

package/src/state/persist-scheduler.ts

@@ -1,7 +1,20 @@
 export const CONFIG_SAVE_DEBOUNCE_MS = 500;
+/** For config fields that change on every cursor move (recent tickers, the live pane-state mirror). */
+export const LOW_PRIORITY_CONFIG_SAVE_DEBOUNCE_MS = 5_000;
 export const SESSION_SAVE_DEBOUNCE_MS = 1000;
 export const PLUGIN_STATE_SAVE_DEBOUNCE_MS = 500;
 
+const pendingFlushes = new Set<() => Promise<void>>();
+const inFlightSaves = new Set<Promise<void>>();
+
+/** Drain scheduled and running writes before a renderer suspends or exits. */
+export async function flushPendingPersistence(): Promise<void> {
+  while (pendingFlushes.size > 0 || inFlightSaves.size > 0) {
+    const flushing = [...pendingFlushes].map((flush) => flush());
+    await Promise.allSettled([...flushing, ...inFlightSaves]);
+  }
+}
+
 export interface PersistSchedulerOptions<T> {
   delayMs: number;
   save: (value: T) => Promise<void> | void;
@@ -9,7 +22,8 @@ export interface PersistSchedulerOptions<T> {
 }
 
 export interface PersistScheduler<T> {
-  schedule(value: T): void;
+  /** A shorter `delayMs` than the pending one brings the write forward. */
+  schedule(value: T, delayMs?: number): void;
   flush(): Promise<void>;
   cancel(): void;
   saveImmediately(value: T): Promise<void>;
@@ -21,6 +35,7 @@ export function createPersistScheduler<T>({
   onError,
 }: PersistSchedulerOptions<T>): PersistScheduler<T> {
   let timer: ReturnType<typeof setTimeout> | null = null;
+  let pendingDelayMs = Number.POSITIVE_INFINITY;
   let pendingValue: T | undefined;
   let hasPendingValue = false;
   let inFlight: Promise<void> = Promise.resolve();
@@ -40,6 +55,13 @@ export function createPersistScheduler<T>({
         throw error;
       }
     });
+    // A timer or immediate save may already have left the pending drain set
+    // when the renderer exits. Track queued saves until their writes settle.
+    inFlightSaves.add(saveTask);
+    void saveTask.then(
+      () => { inFlightSaves.delete(saveTask); },
+      () => { inFlightSaves.delete(saveTask); },
+    );
     // Keep the serialization chain usable after a failed immediate save while
     // still returning that failure to its caller.
     inFlight = saveTask.catch(() => {});
@@ -48,6 +70,8 @@ export function createPersistScheduler<T>({
 
   const drain = async () => {
     clearTimer();
+    pendingFlushes.delete(drain);
+    pendingDelayMs = Number.POSITIVE_INFINITY;
     if (!hasPendingValue) return inFlight;
     const value = pendingValue as T;
     pendingValue = undefined;
@@ -56,24 +80,33 @@ export function createPersistScheduler<T>({
   };
 
   return {
-    schedule(value: T): void {
+    schedule(value: T, requestedDelayMs = delayMs): void {
       pendingValue = value;
       hasPendingValue = true;
+      pendingFlushes.add(drain);
+      // Still a debounce, but the shortest delay asked for since the last
+      // write wins: a value scheduled with a long delay must not push back
+      // one that asked to be written sooner.
+      pendingDelayMs = Math.min(pendingDelayMs, Math.max(0, requestedDelayMs));
       clearTimer();
       timer = setTimeout(() => {
         void drain();
-      }, Math.max(0, delayMs));
+      }, pendingDelayMs);
     },
     flush(): Promise<void> {
       return drain();
     },
     cancel(): void {
       clearTimer();
+      pendingFlushes.delete(drain);
+      pendingDelayMs = Number.POSITIVE_INFINITY;
       pendingValue = undefined;
       hasPendingValue = false;
     },
     saveImmediately(value: T): Promise<void> {
       clearTimer();
+      pendingFlushes.delete(drain);
+      pendingDelayMs = Number.POSITIVE_INFINITY;
       pendingValue = undefined;
       hasPendingValue = false;
       return enqueueSave(value, false);