gloomberb 0.15.2 → 0.15.3

package/src/types/financials.ts

@@ -302,10 +302,22 @@ export interface IncomeStatementSource {
   basis: "parent" | "consolidated" | "common";
 }
 
+/**
+ * Statement lines a source can declare unavailable for one period. A declared
+ * gap survives merges and caches, and charts never recompute it, for example
+ * as the full year minus the other quarters.
+ */
+export type StatementGapField = IncomeStatementField | "totalRevenue" | "operatingRevenue" | "pretaxIncome" | "taxProvision";
+
+/** Per-share earnings lines that can be declared unavailable. */
+export type EarningsField = "basicEps" | "eps";
+
+/** @deprecated Operating results no longer carry filing or provider provenance. */
 export type ReportedOperatingField = "grossProfit" | "operatingExpense" | "operatingIncome";
+/** @deprecated Operating results no longer carry filing or provider provenance. */
 export type ProviderOperatingField = ReportedOperatingField | "totalExpenses" | "ebitda";
 
-/** Direct reported operating result; every member belongs to one filing cohort. */
+/** @deprecated No longer populated. Operating income follows the provider's as-reported figure. */
 export interface ReportedOperatingCohort {
   cik: string;
   period: "annual" | "quarterly";
@@ -326,7 +338,7 @@ export interface ReportedOperatingCohort {
   };
 }
 
-/** A provider metric is independently owned, not a synonym for a reported subtotal. */
+/** @deprecated No longer populated. */
 export interface ProviderOperatingObservation {
   provider: "yahoo" | "twelvedata";
   sourceField: string;
@@ -336,6 +348,7 @@ export interface ProviderOperatingObservation {
   value: number;
 }
 
+/** @deprecated No longer populated. */
 export interface OperatingResult {
   version: 1;
   reported?: ReportedOperatingCohort;
@@ -343,6 +356,7 @@ export interface OperatingResult {
   derived?: { ebitda?: DerivedOperatingObservation };
 }
 
+/** @deprecated No longer populated. */
 export interface DerivedOperatingObservation {
   definition: "operating-income-plus-depreciation-amortization";
   period: "annual" | "quarterly";
@@ -352,16 +366,47 @@ export interface DerivedOperatingObservation {
   inputs: { operatingIncome: number; depreciationAndAmortization: number };
 }
 
+/** @deprecated No longer populated. */
+export interface OperatingResultAggregation {
+  kind: "trailing-four-quarters";
+  sourcePeriods: Array<Pick<FinancialStatement, "date" | "currency" | "operatingResult" | "depreciationAndAmortization" | ProviderOperatingField>>;
+  unavailableFields: ProviderOperatingField[];
+}
+
+/** @deprecated No longer populated. EPS that disagrees with its row's income and shares is listed in `unavailableEarnings` instead. */
+export interface ReportedEarningsCohort {
+  cik: string;
+  basis: "us-gaap";
+  shareBasis: "ordinary";
+  period: "annual";
+  startDate: string;
+  endDate: string;
+  currency: "EUR";
+  accessionNumber: string;
+  filed: string;
+  form: "20-F" | "20-F/A";
+  values: Record<EarningsField, number>;
+  anchors: Record<"netIncome" | "totalRevenue" | "operatingIncome" | "basicShares" | "dilutedShares", number> & { grossProfit?: number };
+  concepts: Record<EarningsField | "netIncome" | "totalRevenue" | "operatingIncome" | "basicShares" | "dilutedShares", { concept: string; unit: string }>
+    & { grossProfit?: { concept: string; unit: string } };
+}
+
+/** @deprecated No longer populated. */
+export interface EarningsResultProvenance { version: 1; reported: ReportedEarningsCohort }
+
 export interface FinancialStatement {
-  /** Directly reported annual EPS and its accounting/share-basis evidence. */
-  earningsResult?: import("../utils/reported-earnings-result").EarningsResultProvenance;
-  /** EPS whose claimed source ownership failed validation; sparse rows cannot restore it. */
-  unavailableEarnings?: import("../utils/reported-earnings-result").EarningsField[];
-  /** Operating concepts have ownership independent of net income and fiscal dates. */
+  /** @deprecated No longer populated. */
+  earningsResult?: EarningsResultProvenance;
+  /** EPS lines unavailable for this period, for example because they disagree with the row's own income and shares. */
+  unavailableEarnings?: EarningsField[];
+  /** @deprecated No longer populated. */
   operatingResult?: OperatingResult;
-  /** Derived operating sums retain their actual quarter inputs, not a single filing owner. */
-  operatingResultAggregation?: import("../utils/operating-result-aggregation").OperatingResultAggregation;
-  /** Unresolved, source-attested observation withdrawals; identifiers are validated on read. */
+  /** @deprecated No longer populated. */
+  operatingResultAggregation?: OperatingResultAggregation;
+  /**
+   * @deprecated No longer populated. Gloom Cloud withdrawal ids are read into
+   * `unavailableFields` and `unavailableEarnings` when a response arrives.
+   */
   withdrawnObservations?: string[];
   /** SEC EPS share basis; raw source values remain available in the evidence. */
   epsBasis?: import("../utils/sec-eps-basis").SecEpsBasis;
@@ -384,8 +429,8 @@ export interface FinancialStatement {
   fieldAvailability?: Record<string, string>;
   /** Income attribution belongs to each field, not to the row's date evidence. */
   fieldSources?: Partial<Record<IncomeStatementField, IncomeStatementSource>>;
-  /** Explicit source coverage gaps must not be filled by another income basis. */
-  unavailableFields?: IncomeStatementField[];
+  /** Lines unavailable for this period; another source or income basis must not fill them. */
+  unavailableFields?: StatementGapField[];
   // Income Statement
   totalRevenue?: number;
   costOfRevenue?: number;
@@ -528,17 +573,23 @@ export interface FinancialStatement {
   treasurySharesNumber?: number;
 }
 
-/** Verified provider identity retained with observations through cache/clipping. */
+/**
+ * Provider identity once attached to individual observations.
+ * @deprecated No longer populated. A source's coverage boundary is the
+ * `coverageStart` of the result `getPriceHistoryWithMetadata` and its
+ * siblings return.
+ */
 export interface PriceHistorySource {
-  provider: "yahoo" | "twelvedata";
-  symbol: "SHEL";
-  exchange: "LSE";
-  currency: "GBP";
+  provider: string;
+  symbol: string;
+  exchange: string;
+  currency: string;
   /** Source coverage restriction, not security inception or an adjustment ratio. */
-  verifiedLineageStart?: "2005-07-21";
+  verifiedLineageStart?: string;
 }
 
 export interface PricePoint {
+  /** @deprecated No longer populated; read the history result's `coverageStart` instead. */
   historySource?: PriceHistorySource;
   date: Date;
   open?: number;
@@ -603,9 +654,9 @@ export interface EpsEstimateHistory {
 
 export interface TickerFinancials {
   statementHistory?: StatementHistoryAttempt;
-  /** SEC operating-table retry deadline; cache eligibility, not a financial observation. */
+  /** @deprecated No longer populated. */
   operatingHistoryRetryAt?: number;
-  /** Optional annual EPS acquisition retry; independent of statement-history coverage. */
+  /** @deprecated No longer populated. */
   earningsHistoryRetryAt?: number;
   financialCurrency?: string;
   quote?: Quote;

package/src/types/instrument.ts

@@ -17,7 +17,8 @@ export type TickerInstrumentKind =
 
 /** Source price convention. Percent-of-par quantities are nominal face amounts;
  * prices are percentage points per 100 face, independently of contract multiplier. */
-export type PriceBasis = "per-unit" | "percent-of-par";
+/** "points": an index or volatility level, not money; "thirty-seconds": a Treasury future's percent of par, read in 32nds. */
+export type PriceBasis = "per-unit" | "percent-of-par" | "points" | "thirty-seconds";
 
 export interface BrokerContractRef {
   brokerId: string;

package/src/types/plugin.ts

@@ -52,15 +52,27 @@ import type { SyncContributor, SyncTransport } from "../sync/types";
 
 export type { TickerInstrumentKind } from "./instrument";
 
+/**
+ * Named render slots. The host renders only `status:widget`; the other names
+ * are never drawn and are kept so existing plugins still type-check.
+ */
 export interface GloomSlots {
+  /** @deprecated Never rendered. Use `ctx.registerTickerResearchTab`. */
   "ticker-research:tab": { ticker: TickerRecord; financials: TickerFinancials | null };
+  /** @deprecated Never rendered. Use `ctx.registerTickerResearchTab`. */
   "ticker-research:section": { ticker: TickerRecord; financials: TickerFinancials | null };
+  /** @deprecated Never rendered. Use `ctx.registerColumn`. */
   "list:column": { ticker: TickerRecord; financials: TickerFinancials | null };
+  /** @deprecated Never rendered. Use `ctx.registerCommandBarSearchProvider`. */
   "command:extra": { query: string };
+  /** @deprecated Never rendered. Use `ctx.registerCommand`. */
   "command:preset": Record<string, never>;
   "status:widget": Record<string, never>;
+  /** @deprecated Never rendered. Declare settings with `configSchema`. */
   "config:section": Record<string, never>;
+  /** @deprecated Never called. Subscribe with `ctx.on("ticker:refreshed")`. */
   "data:post-refresh": { ticker: string; financials: TickerFinancials };
+  /** @deprecated Never called. Contribute data with an `asset-data` capability. */
   "data:enricher": { ticker: TickerRecord };
 }
 
@@ -220,6 +232,12 @@ export interface PaneTemplateContext {
   activeCollectionId: string | null;
 }
 
+/** One value a shortcut argument accepts: `value` is typed after the prefix, `label` says what it is. */
+export interface ShortcutArgOption {
+  value: string;
+  label: string;
+}
+
 interface PaneTemplateShortcut {
   prefix: string;
   /** Other mnemonics for the same view (FFIP for WIRP). They open it when typed but are not listed as separate rows. */
@@ -227,6 +245,18 @@ interface PaneTemplateShortcut {
   argPlaceholder?: string;
   argKind?: "text" | "ticker" | "ticker-list";
   argOptional?: boolean;
+  /**
+   * With no argument typed and none to infer from the active ticker, open
+   * the pane without one instead of asking for it (ERN alone is the market
+   * board). Without it an optional argument still falls back to the form.
+   */
+  openWithoutArg?: boolean;
+  /**
+   * Named values the argument accepts, for an argument mostly drawn from a
+   * small set (a statistic, a futures root). The command-bar assistant picks
+   * from it instead of guessing the text; the command may accept others too.
+   */
+  argOptions?: () => readonly ShortcutArgOption[];
 }
 
 export interface PaneTemplateCreateOptions {

package/src/types/price-history.ts

@@ -24,4 +24,6 @@ export interface PriceHistoryResult {
   session?: HistorySession;
   /** Router-selected provider or broker, never its preferred/default source. */
   sourceKey?: string;
+  /** First date (YYYY-MM-DD) the source vouches for; it excluded earlier prices. */
+  coverageStart?: string;
 }

package/src/types/trading.ts

@@ -14,7 +14,8 @@ export interface BrokerAccount {
   accountId: string;
   name: string;
   currency?: string;
-  source?: "gateway" | "flex";
+  /** "cloud" is a connection held by the user's Gloom Cloud account. */
+  source?: "gateway" | "flex" | "cloud";
   updatedAt?: number;
   asOfDate?: string;
   netLiquidation?: number;
@@ -27,6 +28,10 @@ export interface BrokerAccount {
   initMarginReq?: number;
   maintMarginReq?: number;
   dailyPnl?: number;
+  /** Net liquidation at the previous close, when the broker reports its own day return. */
+  previousNetLiquidation?: number;
+  /** When the broker computed `dailyPnl`, if that differs from `updatedAt`. */
+  dailyPnlAsOf?: number;
   unrealizedPnl?: number;
   realizedPnl?: number;
   cashBalances?: BrokerCashBalance[];
@@ -36,11 +41,15 @@ export interface BrokerPortfolioPerformancePoint {
   date: string;
   value?: number;
   cumulativeReturn?: number;
+  /** This day's return alone, as a decimal fraction. */
+  dailyReturn?: number;
+  /** Deposits (positive) and withdrawals (negative) on this day, valued at its close. */
+  externalFlow?: number;
 }
 
 export interface BrokerPortfolioPerformance {
   accountId: string;
-  source: "flex";
+  source: "flex" | "cloud";
   period: string;
   currency?: string;
   fetchedAt: number;
@@ -48,6 +57,10 @@ export interface BrokerPortfolioPerformance {
   endDate?: string;
   lastSuccessfulUpdate?: string;
   stale?: boolean;
+  /** How the broker computes returns: time-weighted or money-weighted. */
+  measure?: "TWR" | "MWR";
+  /** Whether `externalFlow` was reported by the broker or implied from NAV and a time-weighted return. */
+  flowBasis?: "reported" | "derived";
   points: BrokerPortfolioPerformancePoint[];
 }
 
@@ -91,6 +104,8 @@ export interface BrokerOrder {
   stopPrice?: number;
   tif?: string;
   warningText?: string;
+  /** Set when the order is an instruction the user still reviews and submits at the broker. */
+  reviewUrl?: string;
   updatedAt: number;
   contract: BrokerContractRef;
 }
@@ -105,5 +120,9 @@ export interface BrokerExecution {
   price: number;
   time: number;
   exchange?: string;
+  commission?: number;
+  commissionCurrency?: string;
+  realizedPnl?: number;
+  netAmount?: number;
   contract: BrokerContractRef;
 }

package/src/ui/dialog-stack.ts

@@ -0,0 +1,80 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import type { DialogApi, DialogOptions, PromptContext } from "./dialog";
+
+/**
+ * The dialog stack both hosts share: open, close, settle, and settle anything
+ * left open when the host unmounts. Hosts own rendering and focus. Kept out of
+ * the public `gloomberb/dialog` module on purpose.
+ */
+
+export type DialogKind = "alert" | "prompt";
+
+interface DialogStackOptions<E extends { id: string }> {
+  idPrefix: string;
+  /** Builds the host's record. `stackWasEmpty` is true for the first dialog of a stack. */
+  createEntry(id: string, kind: DialogKind, options: DialogOptions<never>, stackWasEmpty: boolean): E;
+  /** Runs once a closed dialog's promise has settled. */
+  onClosed?(entry: E, remaining: readonly E[]): void;
+  /** Wraps the state update, e.g. to flush it synchronously. */
+  commit?(update: () => void): void;
+}
+
+let nextDialogId = 1;
+
+export function useDialogStack<E extends { id: string }>(options: DialogStackOptions<E>) {
+  const [dialogs, setDialogs] = useState<E[]>([]);
+  const dialogsRef = useRef<E[]>([]);
+  const settlersRef = useRef(new Map<string, (value: unknown) => void>());
+  const mountedRef = useRef(true);
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+
+  const publish = useCallback((next: E[]) => {
+    dialogsRef.current = next;
+    if (!mountedRef.current) return;
+    const { commit } = optionsRef.current;
+    if (commit) commit(() => setDialogs(next));
+    else setDialogs(next);
+  }, []);
+
+  const close = useCallback((id: string, value?: unknown) => {
+    const current = dialogsRef.current;
+    const target = current.find((dialog) => dialog.id === id);
+    if (!target) return;
+    const next = current.filter((dialog) => dialog.id !== id);
+    publish(next);
+    const settle = settlersRef.current.get(id);
+    settlersRef.current.delete(id);
+    settle?.(value);
+    optionsRef.current.onClosed?.(target, next);
+  }, [publish]);
+
+  const open = useCallback(<T,>(kind: DialogKind, dialogOptions: DialogOptions<never>) => (
+    new Promise<T | undefined>((resolve) => {
+      const { createEntry, idPrefix } = optionsRef.current;
+      const entry = createEntry(`${idPrefix}-${nextDialogId++}`, kind, dialogOptions, dialogsRef.current.length === 0);
+      settlersRef.current.set(entry.id, (value) => resolve(value as T | undefined));
+      publish([...dialogsRef.current, entry]);
+    })
+  ), [publish]);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      const settlers = [...settlersRef.current.values()];
+      settlersRef.current.clear();
+      dialogsRef.current = [];
+      for (const settle of settlers) settle(undefined);
+    };
+  }, []);
+
+  const api = useMemo<DialogApi>(() => ({
+    alert: async (dialogOptions) => {
+      await open<void>("alert", dialogOptions);
+    },
+    prompt: <T,>(dialogOptions: DialogOptions<PromptContext<T>>) => open<T>("prompt", dialogOptions),
+  }), [open]);
+
+  return { dialogs, close, api };
+}

package/src/ui/dialog.tsx

@@ -10,9 +10,40 @@ export interface PromptContext<T> extends AlertContext {
   resolve(value: T): void;
 }
 
+export type DialogSize = "small" | "medium" | "large" | "full";
+
+/** Box overrides for the terminal dialog: a fixed width, caps, border or padding. */
+export interface DialogStyle {
+  width?: number;
+  maxWidth?: number;
+  maxHeight?: number;
+  [key: string]: unknown;
+}
+
+/**
+ * What `alert` and `prompt` open. `content` is the dialog body, or a function
+ * of the dialog's context for a body that closes or answers it. `size` and
+ * `style` size the terminal box; the desktop sizes a dialog to its content.
+ */
+export interface DialogOptions<C = AlertContext> {
+  content?: ReactNode | ((context: C) => ReactNode);
+  /**
+   * Any string still compiles, so an options object built ahead (where "large"
+   * widens to string) keeps working; the terminal treats an unknown size as medium.
+   */
+  size?: DialogSize | (string & {});
+  style?: DialogStyle;
+  /** Terminal: Esc closes the dialog unless this is false. The desktop always closes on Esc. */
+  closeOnEscape?: boolean;
+  /** A click on the backdrop closes the dialog. Off by default. */
+  closeOnClickOutside?: boolean;
+  /** Hosts ignore options they do not know. */
+  [key: string]: unknown;
+}
+
 export interface DialogApi {
-  alert(options: Record<string, unknown>): Promise<void>;
-  prompt<T = string>(options: Record<string, unknown>): Promise<T | undefined>;
+  alert(options: DialogOptions<AlertContext>): Promise<void>;
+  prompt<T = string>(options: DialogOptions<PromptContext<T>>): Promise<T | undefined>;
 }
 
 interface DialogContextValue {

package/src/ui/host.tsx

@@ -197,6 +197,11 @@ export interface NativeRendererHost {
   isDestroyed?: boolean;
   currentFocusedRenderable?: unknown;
   currentFocusedEditor?: unknown;
+  /**
+   * @deprecated Plugins handle keys with `useShortcut` from `gloomberb/react`.
+   * The desktop and web renderers only emulate this terminal key stream, and
+   * that emulation will be removed; the field stays for the terminal host.
+   */
   keyInput?: {
     on(event: string, handler: (...args: any[]) => void): void;
     off(event: string, handler: (...args: any[]) => void): void;
@@ -217,6 +222,18 @@ export interface NativeRendererHost {
   copyToClipboardOSC52?(text: string): boolean;
   write?(data: string | Uint8Array): boolean;
   captureMouseRenderable?(renderable: unknown): void;
+  /**
+   * Terminal renderers only: whether kitty graphics can be drawn, `null` until
+   * the terminal answers. A host without it never draws kitty graphics.
+   */
+  getKittySupport?(): boolean | null;
+  /** Terminal renderers only: asks the terminal about kitty graphics once and keeps the answer. */
+  ensureKittySupport?(): Promise<boolean>;
+  /** Terminal renderers only: keeps kitty images clear of the panes, menus and dialogs drawn over them. */
+  nativeSurfaceManager?: Pick<
+    import("../components/chart/native/surface/manager").NativeSurfaceManager,
+    "setWindowState" | "upsertLocalOccluder" | "removeLocalOccluder"
+  >;
 }
 
 interface BoxProps {

package/src/ui/index.tsx

@@ -1,7 +1,8 @@
-import { createElement, forwardRef, useCallback, useRef, type ComponentProps, type ForwardedRef } from "react";
+import { createElement, forwardRef, useCallback, useRef, type ComponentProps } from "react";
 import { useForwardedScrollBoxRef, useRegisterPaneScrollBox } from "../state/pane-scroll-registry";
 import { useUiHost, type UiHost } from "./host";
 import { useRemoteUiNode } from "../remote/semantic-tree";
+import { assignRef } from "../react/assign-ref";
 import {
   remoteChartEvent,
   remoteEvent,
@@ -229,21 +230,13 @@ export const Textarea = forwardRef<any, ComponentProps<UiHost["Textarea"]>>((pro
 });
 Textarea.displayName = "Textarea";
 
-function assignForwardedRef(ref: ForwardedRef<any>, value: any): void {
-  if (typeof ref === "function") {
-    ref(value);
-  } else if (ref) {
-    ref.current = value;
-  }
-}
-
 export const ChartSurface = forwardRef<any, ComponentProps<UiHost["ChartSurface"]>>((props, ref) => {
   const { ChartSurface: HostChartSurface } = useUiHost();
   const rawProps = props as Record<string, unknown>;
   const localRef = useRef<any>(null);
   const setSurfaceRef = useCallback((value: any) => {
     localRef.current = value;
-    assignForwardedRef(ref, value);
+    assignRef(ref, value);
   }, [ref]);
   const onMouseMove = rawProps.onMouseMove as ((event?: unknown) => unknown) | undefined;
   const onMouseDown = rawProps.onMouseDown as ((event?: unknown) => unknown) | undefined;

package/src/ui/toast.tsx

@@ -26,6 +26,101 @@ export interface ToastHost {
   dismissNewest?(): boolean;
 }
 
+export type ToastTone = "success" | "error" | "info";
+
+interface ToastRecord {
+  id: number;
+  body: string;
+  tone: ToastTone;
+  options?: ToastOptions;
+}
+
+/** A host's toasts minus how they draw. Each renderer supplies its own `Viewport`. */
+export interface ToastStore extends Omit<ToastHost, "Viewport"> {
+  activateNewest(): boolean;
+  dismissNewest(): boolean;
+  subscribe(listener: () => void): () => void;
+  /** The toasts on screen, oldest first. The same array until something changes. */
+  getSnapshot(): readonly ToastRecord[];
+}
+
+const MAX_VISIBLE_TOASTS = 4;
+/** Small buffer above the visible cap so a dismissal can reveal a recent toast. */
+const MAX_RETAINED_TOASTS = 8;
+const DEFAULT_TOAST_DURATION_MS = 4_000;
+
+export function createToastStore(): ToastStore {
+  let nextToastId = 1;
+  let toasts: ToastRecord[] = [];
+  let visible: ToastRecord[] = [];
+  const listeners = new Set<() => void>();
+  const timers = new Map<number, ReturnType<typeof setTimeout>>();
+
+  const clearTimer = (id: number) => {
+    clearTimeout(timers.get(id));
+    timers.delete(id);
+  };
+  const publish = (next: ToastRecord[]) => {
+    toasts = next;
+    visible = next.slice(-MAX_VISIBLE_TOASTS);
+    for (const listener of listeners) listener();
+  };
+  const dismiss = (id: string | number) => {
+    const numericId = typeof id === "number" ? id : Number(id);
+    if (!Number.isFinite(numericId)) return;
+    clearTimer(numericId);
+    const next = toasts.filter((toast) => toast.id !== numericId);
+    if (next.length !== toasts.length) publish(next);
+  };
+  const add = (tone: ToastTone) => (body: string, options?: ToastOptions): number => {
+    const id = nextToastId++;
+    // Only the newest MAX_VISIBLE_TOASTS render, so anything past the cap is
+    // unreachable. Keeping it would let a dismissal resurface a stale toast.
+    const kept = [...toasts, { id, body, tone, options }].slice(-MAX_RETAINED_TOASTS);
+    for (const dropped of toasts) {
+      if (!kept.some((toast) => toast.id === dropped.id)) clearTimer(dropped.id);
+    }
+    publish(kept);
+    const duration = options?.duration ?? DEFAULT_TOAST_DURATION_MS;
+    // 0 and Infinity both mean "until dismissed".
+    if (Number.isFinite(duration) && duration > 0) {
+      timers.set(id, setTimeout(() => dismiss(id), duration));
+    }
+    return id;
+  };
+
+  return {
+    success: add("success"),
+    error: add("error"),
+    info: add("info"),
+    dismiss,
+    activateNewest() {
+      const toast = visible.findLast((entry) => entry.options?.action);
+      const action = toast?.options?.action;
+      if (!toast || !action) return false;
+      try {
+        action.onClick();
+      } finally {
+        dismiss(toast.id);
+      }
+      return true;
+    },
+    dismissNewest() {
+      const toast = visible.at(-1);
+      if (!toast) return false;
+      dismiss(toast.id);
+      return true;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot: () => visible,
+  };
+}
+
 const ToastContext = createContext<ToastHost | null>(null);
 
 export function ToastHostProvider({