@gloom-sh/terminal 0.18.5 → 0.19.0

package/src/components/ui/choice-dialog.tsx

@@ -6,10 +6,13 @@ import { t } from "../../i18n";
 import { DialogFrame, fitDialogWidth } from "./frame";
 import { ListView, listCursorMove, type ListViewItem } from "./list-view";
 import { clampIndex } from "../../utils/math";
+import { withChoiceGroupHeadings } from "./choice-groups";
 
 export interface ChoiceDialogChoice {
   id: string;
   label: string;
+  /** Heading for consecutive choices in the same group. */
+  group?: string;
   description?: string;
   detail?: string;
   disabled?: boolean;
@@ -31,10 +34,10 @@ function getChoiceDescription(choice: ChoiceDialogChoice | undefined): string {
   return choice?.description ?? "";
 }
 
-function getInitialChoiceIndex(choices: ChoiceDialogChoice[], selectedChoiceId: string | undefined): number {
+function getInitialChoiceIndex(choices: ListViewItem[], selectedChoiceId: string | undefined): number {
   if (!selectedChoiceId) return choices.findIndex((choice) => !choice.disabled);
-  const selectedIndex = choices.findIndex((choice) => choice.id === selectedChoiceId);
-  return selectedIndex >= 0 ? selectedIndex : 0;
+  const selectedIndex = choices.findIndex((choice) => choice.id === selectedChoiceId && choice.kind !== "heading");
+  return selectedIndex >= 0 ? selectedIndex : choices.findIndex((choice) => choice.kind !== "heading");
 }
 
 function choiceDialogWidth(title: string, choices: ChoiceDialogChoice[]): number {
@@ -42,6 +45,7 @@ function choiceDialogWidth(title: string, choices: ChoiceDialogChoice[]): number
     title.length,
     ...choices.map((choice) => choice.label.length + (choice.detail ? choice.detail.length + 4 : 0)),
     ...choices.map((choice) => getChoiceDescription(choice).length),
+    ...choices.map((choice) => choice.group?.length ?? 0),
   );
   return Math.max(34, Math.min(76, contentWidth + 4));
 }
@@ -56,27 +60,28 @@ export function ChoiceDialog({
 }: ChoiceDialogProps) {
   const colors = useThemeColors();
   const desktop = useUiHost().kind === "desktop-web";
-  const [index, setIndex] = useState(() =>
-    clampIndex(getInitialChoiceIndex(choices, selectedChoiceId), choices.length, -1)
-  );
-  const selectedIndex = clampIndex(index, choices.length, -1);
-  const selectedChoice = selectedIndex >= 0 ? choices[selectedIndex] : undefined;
-  // Terminal input can deliver navigation and Enter before React renders.
-  const cursor = useRef(selectedIndex);
-  const selectIndex = (next: number) => { cursor.current = next; setIndex(next); };
-  const items = useMemo<ListViewItem[]>(() => choices.map((choice) => ({
+  const items = useMemo<ListViewItem[]>(() => withChoiceGroupHeadings(choices.map((choice) => ({
     id: choice.id,
     label: choice.label,
+    group: choice.group,
     description: getChoiceDescription(choice),
     detail: choice.detail,
     disabled: choice.disabled,
     color: choice.color,
-  })), [choices]);
+  }))), [choices]);
+  const [index, setIndex] = useState(() =>
+    clampIndex(getInitialChoiceIndex(items, selectedChoiceId), items.length, -1)
+  );
+  const selectedIndex = clampIndex(index, items.length, -1);
+  const selectedChoice = selectedIndex >= 0 ? items[selectedIndex] : undefined;
+  // Terminal input can deliver navigation and Enter before React renders.
+  const cursor = useRef(selectedIndex);
+  const selectIndex = (next: number) => { cursor.current = next; setIndex(next); };
   const width = useMemo(() => choiceDialogWidth(title, choices), [choices, title]);
 
   useEffect(() => {
-    selectIndex(clampIndex(cursor.current, choices.length, -1));
-  }, [choices.length]);
+    selectIndex(clampIndex(cursor.current, items.length, -1));
+  }, [items.length]);
 
   const activateChoice = (choice: ChoiceDialogChoice | undefined) => {
     if (!choice || choice.disabled) return;
@@ -87,9 +92,9 @@ export function ChoiceDialog({
     event.stopPropagation();
     const move = listCursorMove(event, MAX_VISIBLE_CHOICE_ROWS - 1);
     if (move) {
-      selectIndex(move(choices, cursor.current));
+      selectIndex(move(items, cursor.current));
     } else if (event.name === "enter" || event.name === "return") {
-      activateChoice(choices[clampIndex(cursor.current, choices.length, -1)]);
+      activateChoice(items[clampIndex(cursor.current, items.length, -1)]);
     } else if (event.name === "escape") {
       resolve("");
     }
@@ -110,7 +115,7 @@ export function ChoiceDialog({
           scrollable={items.length > MAX_VISIBLE_CHOICE_ROWS}
           selectOnHover
           onSelect={selectIndex}
-          onActivate={(_, nextIndex) => activateChoice(choices[nextIndex])}
+          onActivate={activateChoice}
         />
         <Box height={1} />
         <Text fg={colors.textDim} wrapText>{getChoiceDescription(selectedChoice)}</Text>

package/src/components/ui/choice-groups.ts

@@ -0,0 +1,18 @@
+interface ChoiceGroupHeading {
+  id: string;
+  label: string;
+  kind: "heading";
+  disabled: true;
+}
+
+/** Label each contiguous group without changing the order or identity of its choices. */
+export function withChoiceGroupHeadings<T extends { group?: string }>(choices: readonly T[]): Array<T | ChoiceGroupHeading> {
+  let previousGroup: string | undefined;
+  return choices.flatMap((choice, index): Array<T | ChoiceGroupHeading> => {
+    const heading = choice.group && choice.group !== previousGroup
+      ? { id: `\u0000group:${index}`, label: choice.group, kind: "heading" as const, disabled: true as const }
+      : null;
+    previousGroup = choice.group;
+    return heading ? [heading, choice] : [choice];
+  });
+}

package/src/components/ui/data-table/opentui/index.tsx

@@ -1,5 +1,5 @@
 import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { Box, ScrollBox, Text, TextAttributes, useNativeRenderer } from "../../../../ui";
+import { Box, ScrollBox, Span, Text, TextAttributes, useNativeRenderer } from "../../../../ui";
 import { hoverBg } from "../../../../theme/colors";
 import { useThemeColors } from "../../../../theme/theme-context";
 import { usePaneInstance } from "../../../../state/app/context";
@@ -12,7 +12,6 @@ import { EmptyState } from "../../status";
 import { observeScrollBoxContentSize, observeScrollBoxViewportSize } from "../../../../renderers/opentui/scrollbox-layout";
 import {
   expandTableColumns,
-  fitTableCellText,
   fitTableHeaderText,
   getTableWidth,
   hasMeaningfulTableHorizontalOverflow,
@@ -30,6 +29,7 @@ import { useFocusOwningPane, useVisibleRangeEmitter } from "../hooks";
 import { useStableColumns } from "../stable-columns";
 import {
   cutColumnText,
+  fitColumnCellText,
   resolveDataTableColumnClips,
   resolveDataTableVisibleWindow,
   resolveMoreColumnsHint,
@@ -212,10 +212,8 @@ function OpenTuiDataTableRowInner<
         const shownWidth = clip ? clip.width : column.width - inset;
         // Cut text is fitted to what shows; a number the edge cuts stays blank in its own place,
         // and its cell keeps its background and its press.
-        const shownText = clip
-          ? cutColumnText(cell.text, column.align, column.width, clip, (text, width) => fitTableCellText(text, width, column.align))
-          : shownWidth > 0 ? fitTableCellText(cell.text, shownWidth, column.align) : "";
-        const contentCut = clip !== null && column.align === "right" && shownText.trim() === "";
+        const fitted = fitColumnCellText(cell.text, clip ? column.width : shownWidth, column.align, clip, cell.note);
+        const contentCut = clip !== null && column.align === "right" && fitted.text.trim() === "";
         return (
           <Box
             key={column.id}
@@ -255,7 +253,11 @@ function OpenTuiDataTableRowInner<
                   ? colors.selectedText
                   : cell.color ?? colors.text}
               >
-                {`${frozen ? " ".repeat(horizontalPadding) : ""}${" ".repeat(inset)}${shownText}${frozen ? " ".repeat(columnGap) : ""}`}
+                {fitted.note ? <>
+                  {`${frozen ? " ".repeat(horizontalPadding) : ""}${" ".repeat(inset)}${fitted.text}`}
+                  <Span fg={colors.textDim} attributes={TextAttributes.NONE}>{fitted.note}</Span>
+                  {`${fitted.padding ?? ""}${frozen ? " ".repeat(columnGap) : ""}`}
+                </> : `${frozen ? " ".repeat(horizontalPadding) : ""}${" ".repeat(inset)}${fitted.text}${frozen ? " ".repeat(columnGap) : ""}`}
               </Text>
             )}
           </Box>

package/src/components/ui/data-table/opentui/model.ts

@@ -1,5 +1,5 @@
 import { displayWidth } from "../../../../utils/format";
-import { tableColumnLeadGap } from "../../table-layout";
+import { fitTableCellText, tableColumnLeadGap } from "../../table-layout";
 
 /**
  * Where the viewport cuts a column: `inset` cells hidden on its left (past the
@@ -46,6 +46,31 @@ export function cutColumnText(
   return `${" ".repeat(start - clip.inset)}${body}${" ".repeat(shownEnd - end)}`;
 }
 
+/** A note uses only spare room: neither the label nor part of the note is cut to fit it. */
+export function fitColumnCellText(
+  text: string,
+  width: number,
+  align: string | undefined,
+  clip: DataTableColumnClip | null,
+  note?: string,
+): { text: string; note?: string; padding?: string } {
+  const fit = (value: string) => clip
+    ? cutColumnText(value, align, width, clip, (body, shown) => fitTableCellText(body, shown, align))
+    : width > 0 ? fitTableCellText(value, width, align) : "";
+  const combined = note ? `${text} ${note}` : "";
+  if (combined && displayWidth(combined) <= (clip?.width ?? width)) {
+    const fitted = fit(combined);
+    const start = fitted.indexOf(combined);
+    // A right-aligned value may fit the visible width but sit beyond its edge.
+    if (start >= 0) return {
+      text: fitted.slice(0, start + text.length + 1),
+      note,
+      padding: fitted.slice(start + combined.length),
+    };
+  }
+  return { text: fit(text) };
+}
+
 function sameClip(a: DataTableColumnClip | null, b: DataTableColumnClip | null): boolean {
   return a === b || (a !== null && b !== null && a.inset === b.inset && a.width === b.width);
 }

package/src/components/ui/data-table/types.ts

@@ -24,6 +24,8 @@ export type DataTableColumn = Pick<
 
 export interface DataTableCell {
   text: string;
+  /** Muted context after `text`, shown whole only when both fit on one line. Does not change the exported value. */
+  note?: string;
   /**
    * What CSV export writes instead of `text`: the full-precision number behind
    * it (3.45 for +3.45%, 1234567890 for 1.23B), or a date as an ISO string or

package/src/components/ui/list-view.tsx

@@ -15,6 +15,7 @@ export interface ListViewItem {
   description?: string;
   detail?: string;
   category?: string;
+  /** `heading` draws a muted group label; pair it with `disabled: true`. */
   kind?: string;
   right?: string;
   checked?: boolean;
@@ -148,6 +149,7 @@ function DefaultRow({
   selected: boolean;
 }) {
   const colors = useThemeColors();
+  if (item.kind === "heading") return <Text fg={colors.textMuted}>{t(item.label)}</Text>;
   // The label gives way to the detail: a long label is cut with an ellipsis
   // instead of wrapping under the row or running into the right column.
   return (
@@ -289,6 +291,7 @@ export function ListView({
   const rowHoverBg = hoverBgColor ?? hoverBg(colors);
   const selectedItem = selectedIndex >= 0 ? items[selectedIndex] : undefined;
   const activeScrollIndex = scrollIndex ?? selectedIndex;
+  const headingAboveSelection = items[activeScrollIndex - 1]?.kind === "heading";
   const terminalRowHeight = rowHeight ?? 1;
   const terminalRowGap = rowGap ?? 0;
   const rowStride = terminalRowHeight + terminalRowGap;
@@ -299,13 +302,14 @@ export function ListView({
     if (!sb) return;
     const safeIndex = Math.min(activeScrollIndex, items.length - 1);
     const viewportH = Math.max(sb.viewport?.height ?? 1, 1);
-    const rowTop = safeIndex * rowStride;
+    const rowTop = Math.max(0, safeIndex - (headingAboveSelection ? 1 : 0)) * rowStride;
+    const rowBottom = safeIndex * rowStride + terminalRowHeight;
     if (rowTop < sb.scrollTop) {
       sb.scrollTo(rowTop);
-    } else if (rowTop + terminalRowHeight > sb.scrollTop + viewportH) {
-      sb.scrollTo(rowTop + terminalRowHeight - viewportH);
+    } else if (rowBottom > sb.scrollTop + viewportH) {
+      sb.scrollTo(rowBottom - viewportH);
     }
-  }, [activeScrollIndex, autoScrollToIndex, items.length, rowStride, scrollable, terminalRowHeight]);
+  }, [activeScrollIndex, autoScrollToIndex, headingAboveSelection, items.length, rowStride, scrollable, terminalRowHeight]);
   useEffect(revealActiveRow, [revealActiveRow]);
   // A list that opens on a row past the fold has nothing to scroll until its
   // first computed layout sizes the viewport and the rows.

package/src/components/ui/query-bar-keys.tsx

@@ -12,6 +12,7 @@ import type { QueryBarFilter, QueryBarSearch, QueryBarView } from "./query-bar";
 interface ChoiceOption {
   value: string;
   label: string;
+  group?: string;
   description?: string;
   disabled?: boolean;
   color?: string;
@@ -70,6 +71,7 @@ export function useQueryBarKeys({
           choices={options.map((option) => ({
             id: option.value,
             label: option.label,
+            group: option.group,
             description: option.description,
             disabled: option.disabled,
             color: option.color,

package/src/components/ui/query-bar.tsx

@@ -417,6 +417,7 @@ export function QueryBar({ width, search, filters = [], view, meta: given, asOf,
       options: filter.options.map((option) => ({
         value: option.value,
         label: option.label,
+        group: option.group,
         description: option.description,
         disabled: option.disabled,
         selected: option.value === filter.value,

package/src/components/ui/select-button.tsx

@@ -18,6 +18,8 @@ export interface SelectControl {
 export interface SelectButtonOption<T extends string = string> {
   value: T;
   label: string;
+  /** Heading for a contiguous group of choices; never selectable itself. */
+  group?: string;
   /** Trigger wording when the full label is too wide for a pane header. */
   short?: string;
   description?: string;
@@ -130,6 +132,7 @@ export function SelectButton<T extends string = string>({
           choices={options.map((option) => ({
             id: option.value,
             label: option.label,
+            group: option.group,
             description: option.description,
             disabled: option.disabled,
             color: option.color,
@@ -158,7 +161,7 @@ export function SelectButton<T extends string = string>({
           selectRef={(element) => { selectFieldRef.current = element; }}
           onFocus={onFocus}
           value={value}
-          options={options.map((option) => ({ value: option.value, label: option.label, disabled: option.disabled }))}
+          options={options.map((option) => ({ value: option.value, label: option.label, group: option.group, disabled: option.disabled }))}
           disabled={disabled}
           onChange={selectValue}
         />
@@ -180,6 +183,7 @@ export function SelectButton<T extends string = string>({
           options={options.map((option) => ({
             value: option.value,
             label: option.label,
+            group: option.group,
             disabled: option.disabled,
           }))}
           disabled={disabled}

package/src/components/ui/select-field.tsx

@@ -9,6 +9,7 @@ export interface SelectFieldHandle {
 
 interface SelectFieldOption {
   label: string;
+  group?: string;
   value: string;
   description?: string;
   disabled?: boolean;

package/src/components/ui/table-layout.ts

@@ -106,18 +106,21 @@ export function getTableWidth(
  * The columns that fit in `width` cells: whole columns in `dropOrder` (least
  * needed first) give way until the rest fit, rather than the table's right
  * edge cutting a value, so a narrow pane drops a name that repeats its ticker
- * before it cuts a date. Columns not listed stay at every width. A table that
- * scrolls vertically passes its width less the scrollbar's cell.
+ * before it cuts a date. An entry that lists several ids drops them together,
+ * for columns that mean little apart (a bid's venue and an ask's). Columns not
+ * listed stay at every width. A table that scrolls vertically passes its width
+ * less the scrollbar's cell.
  */
 export function dropColumnsToFit<C extends TableWidthColumn & { id: string }>(
   columns: readonly C[],
   width: number,
-  dropOrder: readonly string[],
+  dropOrder: readonly (string | readonly string[])[],
 ): C[] {
   let shown = [...columns];
-  for (const id of dropOrder) {
+  for (const step of dropOrder) {
     if (getTableWidth(shown) <= width) break;
-    shown = shown.filter((column) => column.id !== id);
+    const ids = typeof step === "string" ? [step] : step;
+    shown = shown.filter((column) => !ids.includes(column.id));
   }
   return shown;
 }

package/src/core/app-runtime.ts

@@ -1,5 +1,6 @@
 import { MarketDataCoordinator, getSharedMarketDataCoordinator, setSharedMarketDataCoordinator } from "../market-data/coordinator";
 import { NewsService, type NewsServiceOptions } from "../news/aggregator";
+import { cloudNewsSession } from "../news/cloud-session";
 import { getSharedNewsService, setSharedNewsService } from "../news/hooks";
 import { PluginRegistry } from "../plugins/registry";
 import { releaseSharedRegistry } from "../plugins/registry/shared";
@@ -61,6 +62,7 @@ export function createAppRuntime({
   const newsService = new NewsService({
     connectionHealth: pluginRegistry.connectionHealth,
     pollIntervalMs: () => Math.max(1, config.refreshIntervalMinutes) * 60_000,
+    session: cloudNewsSession,
     ...newsOptions,
   });
   const modules = { pluginRegistry, marketData, newsService };

package/src/core/app-services.ts

@@ -27,8 +27,8 @@ export function createAppServices({ config, plugins, externalPlugins }: AppServi
           provider: {
             fetchNews: async (query) => (await newsService.load(query)).articles,
             fetchNewsPage: async (query) => {
-              const { articles, error, nextCursor } = await newsService.load(query);
-              return { articles, error, nextCursor };
+              const { articles, error, nextCursor, access } = await newsService.load(query);
+              return { articles, error, nextCursor, access };
             },
             getCachedNews: (query) => newsService.getQueryState(query).articles,
           },

package/src/data/config/chart-settings.ts

@@ -20,7 +20,7 @@ import {
 import { recordOrNull } from "../../utils/guards";
 
 const CHART_RANGES = new Set<TimeRange>(TIME_RANGES);
-const PRICE_RENDER_MODES = new Set<SeriesStyle>(["area", "line", "candles", "ohlc", "hlc"]);
+const PRICE_RENDER_MODES = new Set<SeriesStyle>(["area", "line", "candles", "hollow", "heikin-ashi", "ohlc", "hlc"]);
 const LEGACY_INDICATOR_IDS = new Set<LegacyChartIndicatorId>([
   "volume",
   "sma20",

package/src/data/json-ticker-repository.ts

@@ -4,6 +4,7 @@ import { hydrateTickerMetadata } from "../tickers/metadata";
 import type { TickerMetadata, TickerRecord } from "../types/ticker";
 import { BROWSER_STORAGE_KEYS, SafeJsonStorage, type StorageLike } from "./json-storage";
 import { isRecord } from "../utils/guards";
+import { runTickerWrite } from "./ticker-writes";
 
 type StoredTickers = Record<string, TickerMetadata>;
 
@@ -39,20 +40,28 @@ export class JsonTickerRepository implements AppTickerRepositoryPort {
     return metadata ? hydrate(metadata) : null;
   }
 
-  async saveTicker(ticker: TickerRecord): Promise<void> {
+  private writeTicker(ticker: TickerRecord): void {
     const symbol = normalizeSymbol(ticker.metadata.ticker);
     this.data.set({ ...this.data.get(), [symbol]: ticker.metadata });
   }
 
-  async createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
+  saveTicker(ticker: TickerRecord): Promise<void> {
+    return runTickerWrite(this, ticker.metadata.ticker, () => this.writeTicker(ticker));
+  }
+
+  createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
     const ticker = { metadata };
-    await this.saveTicker(ticker);
-    return ticker;
+    return runTickerWrite(this, metadata.ticker, () => {
+      this.writeTicker(ticker);
+      return ticker;
+    });
   }
 
-  async deleteTicker(symbol: string): Promise<void> {
-    const tickers = { ...this.data.get() };
-    delete tickers[normalizeSymbol(symbol)];
-    this.data.set(tickers);
+  deleteTicker(symbol: string): Promise<void> {
+    return runTickerWrite(this, symbol, () => {
+      const tickers = { ...this.data.get() };
+      delete tickers[normalizeSymbol(symbol)];
+      this.data.set(tickers);
+    });
   }
 }

package/src/data/ticker-repository.ts

@@ -2,6 +2,7 @@ import { logFailure } from "../utils/log-failure";
 import type { TickerRecord, TickerMetadata } from "../types/ticker";
 import type { TickerStore } from "./ticker-store";
 import { hydrateTickerMetadata } from "../tickers/metadata";
+import { runTickerWrite } from "./ticker-writes";
 
 function parseTickerMetadata(json: string): TickerMetadata {
   return hydrateTickerMetadata(JSON.parse(json) as Record<string, unknown>);
@@ -32,22 +33,28 @@ export class TickerRepository {
     }
   }
 
-  async saveTicker(ticker: TickerRecord): Promise<void> {
-    this.tickers.save(ticker.metadata.ticker, ticker.metadata);
+  saveTicker(ticker: TickerRecord): Promise<void> {
+    return runTickerWrite(this, ticker.metadata.ticker, () => {
+      this.tickers.save(ticker.metadata.ticker, ticker.metadata);
+    });
   }
 
   /** Saves several tickers in one write. */
-  async saveTickers(tickers: readonly TickerRecord[]): Promise<void> {
-    this.tickers.saveMany(tickers.map((ticker) => ({ symbol: ticker.metadata.ticker, metadata: ticker.metadata })));
+  saveTickers(tickers: readonly TickerRecord[]): Promise<void> {
+    return runTickerWrite(this, tickers.map((ticker) => ticker.metadata.ticker), () => {
+      this.tickers.saveMany(tickers.map((ticker) => ({ symbol: ticker.metadata.ticker, metadata: ticker.metadata })));
+    });
   }
 
-  async createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
+  createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
     const ticker: TickerRecord = { metadata };
-    await this.saveTicker(ticker);
-    return ticker;
+    return runTickerWrite(this, metadata.ticker, () => {
+      this.tickers.save(metadata.ticker, metadata);
+      return ticker;
+    });
   }
 
-  async deleteTicker(symbol: string): Promise<void> {
-    this.tickers.delete(symbol);
+  deleteTicker(symbol: string): Promise<void> {
+    return runTickerWrite(this, symbol, () => this.tickers.delete(symbol));
   }
 }

package/src/data/ticker-writes.ts

@@ -0,0 +1,81 @@
+interface TickerWrites {
+  revisions: Map<string, number>;
+  tails: Map<string, Promise<unknown>>;
+  pending: Set<Promise<unknown>>;
+}
+
+const repositories = new WeakMap<object, TickerWrites>();
+
+function writesFor(repository: object): TickerWrites {
+  let writes = repositories.get(repository);
+  if (!writes) {
+    writes = { revisions: new Map(), tails: new Map(), pending: new Set() };
+    repositories.set(repository, writes);
+  }
+  return writes;
+}
+
+function tickerKey(symbol: string): string {
+  return symbol.trim().toUpperCase();
+}
+
+/** Reserve writes when requested, including ones waiting for an earlier acknowledgement. */
+export function runTickerWrite<Result>(
+  repository: object,
+  symbols: string | readonly string[],
+  write: () => Result | PromiseLike<Result>,
+): Promise<Result> {
+  const writes = writesFor(repository);
+  const keys = [...new Set((typeof symbols === "string" ? [symbols] : symbols).map(tickerKey))];
+  const previous = [...new Set(keys.flatMap((key) => {
+    const tail = writes.tails.get(key);
+    return tail ? [tail] : [];
+  }))];
+  let resolve!: (value: Result | PromiseLike<Result>) => void;
+  let reject!: (error: unknown) => void;
+  const result = new Promise<Result>((accept, fail) => {
+    resolve = accept;
+    reject = fail;
+  });
+  for (const key of keys) {
+    writes.revisions.set(key, (writes.revisions.get(key) ?? 0) + 1);
+    writes.tails.set(key, result);
+  }
+  writes.pending.add(result);
+  const finished = () => {
+    writes.pending.delete(result);
+    for (const key of keys) {
+      if (writes.tails.get(key) === result) writes.tails.delete(key);
+    }
+  };
+  void result.then(finished, finished);
+  const start = () => {
+    try {
+      resolve(write());
+    } catch (error) {
+      reject(error);
+    }
+  };
+  if (previous.length) void Promise.allSettled(previous).then(start);
+  else start();
+  return result;
+}
+
+/** Changes immediately when a save or deletion is requested, before its acknowledgement. */
+export function tickerWriteRevision(repository: object, symbol: string): number {
+  return repositories.get(repository)?.revisions.get(tickerKey(symbol)) ?? 0;
+}
+
+/** Whether a write arrived after a caller last waited for acknowledgements. */
+export function hasPendingTickerWrites(repository: object): boolean {
+  return (repositories.get(repository)?.pending.size ?? 0) > 0;
+}
+
+/** Let save-await callers publish their edits before cleanup reads the current rows. */
+export async function settleTickerWrites(repository: object): Promise<void> {
+  const writes = writesFor(repository);
+  do {
+    // Each writer handles its own failure; cleanup still needs the last published row.
+    await Promise.allSettled([...writes.pending]);
+  } while (writes.pending.size);
+}