gloomberb 0.10.5 → 0.11.1

package/src/api-client/index.test.ts

@@ -104,10 +104,53 @@ afterEach(() => {
   setCloudApiFetchTransport(null);
   apiClient.setSessionToken(null);
   apiClient.setWebSocketToken(null);
+  apiClient.setCookieSessionMode(false);
   jest.useRealTimers();
 });
 
 describe("apiClient auth cookies", () => {
+  test("accepts a browser-managed api.gloom.sh cookie without exposing its value", async () => {
+    apiClient.setCookieSessionMode(true);
+    setCloudApiFetchTransport(mockFetch(() => createResponse({ user: verifiedUser })));
+
+    await expect(apiClient.signIn("test@example.com", "password")).resolves.toEqual(verifiedUser);
+    expect(apiClient.getSessionToken()).toBeNull();
+    expect(apiClient.isVerified()).toBe(true);
+  });
+
+  test("reports signed-in from the restored user when the cookie hides the raw token", async () => {
+    apiClient.setCookieSessionMode(true);
+    setCloudApiFetchTransport(mockFetch(() => createResponse({ user: verifiedUser })));
+
+    expect(apiClient.isSignedIn()).toBe(false);
+    await apiClient.signIn("test@example.com", "password");
+    expect(apiClient.getSessionToken()).toBeNull();
+    expect(apiClient.isSignedIn()).toBe(true);
+  });
+
+  test("coalesces anonymous browser session checks and remembers the result", async () => {
+    apiClient.setCookieSessionMode(true);
+    let requests = 0;
+    let finishRequest!: () => void;
+    setCloudApiFetchTransport(async () => {
+      requests += 1;
+      await new Promise<void>((resolve) => { finishRequest = resolve; });
+      return createResponse({ user: null });
+    });
+
+    const checks = [
+      apiClient.ensureVerifiedSession(),
+      apiClient.ensureVerifiedSession(),
+      apiClient.ensureVerifiedSession(),
+    ];
+    expect(requests).toBe(1);
+    finishRequest();
+
+    await expect(Promise.all(checks)).resolves.toEqual([null, null, null]);
+    await expect(apiClient.ensureVerifiedSession()).resolves.toBeNull();
+    expect(requests).toBe(1);
+  });
+
   test("captures secure session cookies after login and reuses them on session refresh", async () => {
     const seenCookies: Array<string | null> = [];
 
@@ -185,6 +228,28 @@ describe("apiClient auth cookies", () => {
     ]);
   });
 
+  test("creates a browser handoff with the captured session instead of exposing it in the URL", async () => {
+    let requestedUrl = "";
+    let requestedCookie: string | null = null;
+    apiClient.setSessionToken("desktop-session-token");
+    globalThis.fetch = mockFetch(async (input: Request | string | URL, init?: RequestInit) => {
+      requestedUrl = String(input);
+      requestedCookie = new Headers(init?.headers).get("Cookie");
+      return createResponse({
+        url: "https://api.gloom.sh/cloud/auth/browser-handoff?token=opaque-one-time-token",
+      });
+    });
+
+    const handoff = await apiClient.createBrowserHandoff();
+
+    expect(new URL(requestedUrl).pathname).toBe("/cloud/auth/browser-handoff");
+    expect(requestedCookie).toBe(
+      "__Secure-gloomberb.session_token=desktop-session-token; gloomberb.session_token=desktop-session-token",
+    );
+    expect(handoff.url).toContain("token=opaque-one-time-token");
+    expect(handoff.url).not.toContain("desktop-session-token");
+  });
+
   test("keeps cached identity when session refresh is rejected without a hard account-missing response", async () => {
     apiClient.setSessionToken("persisted-token.value");
     apiClient.restoreCachedUser(verifiedUser);
@@ -583,6 +648,65 @@ describe("apiClient quote socket", () => {
   });
 });
 
+describe("apiClient scanner subscriptions", () => {
+  test("subscribes once for many panes, fans out, replays the snapshot, and unsubscribes last", () => {
+    const sockets = installTestWebSocket();
+    const first: unknown[] = [];
+    const second: unknown[] = [];
+
+    const unsubscribeFirst = apiClient.subscribeScanner("hilo", (event) => first.push(event));
+    const socket = sockets[0]!;
+    socket.open();
+    expect(socket.sent).toContainEqual({ type: "scanner.subscribe", scanner: "hilo" });
+
+    const payload = {
+      status: "live",
+      asOf: 1,
+      windows: { s30: { highs: 1, lows: 0 }, m1: { highs: 2, lows: 1 }, m5: { highs: 3, lows: 2 } },
+      highs: [],
+      lows: [],
+    };
+    socket.receive({ type: "scanner.hilo", ...payload });
+
+    // A second pane must not open a second upstream subscription, and must not
+    // wait a tick for its first frame.
+    const subscribeCount = () => socket.sent.filter((message: any) => message.type === "scanner.subscribe").length;
+    const before = subscribeCount();
+    const unsubscribeSecond = apiClient.subscribeScanner("hilo", (event) => second.push(event));
+    expect(subscribeCount()).toBe(before);
+    expect(second).toEqual([{ type: "data", payload }]);
+
+    socket.receive({ type: "scanner.hilo", ...payload, asOf: 2 });
+    expect(first).toHaveLength(2);
+    expect(second).toHaveLength(2);
+
+    unsubscribeFirst();
+    expect(socket.sent).not.toContainEqual({ type: "scanner.unsubscribe", scanner: "hilo" });
+    unsubscribeSecond();
+    expect(socket.sent).toContainEqual({ type: "scanner.unsubscribe", scanner: "hilo" });
+  });
+
+  test("replays scanner subscriptions after a reconnect and surfaces denials", () => {
+    const sockets = installTestWebSocket();
+    const seen: unknown[] = [];
+    const unsubscribe = apiClient.subscribeScanner("flow", (event) => seen.push(event));
+
+    const socket = sockets[0]!;
+    socket.open();
+    socket.receive({ type: "scanner.denied", scanner: "flow", reason: "pro_required" });
+    expect(seen).toEqual([{ type: "denied", reason: "pro_required" }]);
+
+    jest.useFakeTimers();
+    socket.closeWith({ code: 1006, reason: "network" });
+    jest.runAllTimers();
+    const reconnected = sockets[1]!;
+    reconnected.open();
+    expect(reconnected.sent).toContainEqual({ type: "scanner.subscribe", scanner: "flow" });
+
+    unsubscribe();
+  });
+});
+
 describe("apiClient chat timestamps", () => {
   test("sends the before cursor when loading older chat messages", async () => {
     let requestedUrl = "";
@@ -958,3 +1082,37 @@ describe("apiClient cloud news", () => {
     expect(story.id).toBe("story-1");
   });
 });
+
+describe("apiClient equity diagnostic", () => {
+  test("posts the symbol, exchange, and cache mode to the research route", async () => {
+    let seenUrl = "";
+    let seenInit: RequestInit | undefined;
+    globalThis.fetch = mockFetch(async (input: Request | string | URL, init?: RequestInit) => {
+      seenUrl = String(input);
+      seenInit = init;
+      return createResponse({ symbol: "AAPL", status: "complete" });
+    });
+
+    await apiClient.getCloudEquityDiagnostic(" aapl ", "NASDAQ", "refresh");
+
+    expect(new URL(seenUrl).pathname).toBe("/research/equity-diagnostic");
+    expect(seenInit?.method).toBe("POST");
+    expect(JSON.parse(String(seenInit?.body))).toEqual({
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+      mode: "refresh",
+    });
+  });
+
+  test("omits an unknown exchange and defaults to the cached answer", async () => {
+    let seenInit: RequestInit | undefined;
+    globalThis.fetch = mockFetch(async (_input: Request | string | URL, init?: RequestInit) => {
+      seenInit = init;
+      return createResponse({ symbol: "AAPL", status: "complete" });
+    });
+
+    await apiClient.getCloudEquityDiagnostic("AAPL");
+
+    expect(JSON.parse(String(seenInit?.body))).toEqual({ symbol: "AAPL", mode: "cache-first" });
+  });
+});

package/src/api-client/index.ts

@@ -8,6 +8,8 @@ import { CloudApiSocket } from "./socket";
 import type {
   CloudCongressHouseParams,
   CloudFredSeriesParams,
+  CloudSecFilingParams,
+  CloudSecFilingsParams,
   CloudHistoryParams,
   CloudNewsParams,
   CloudTickerTweetsParams,
@@ -35,23 +37,36 @@ import type {
   CloudFundamentals,
   CloudHoldersPayload,
   CloudAnalystResearchPayload,
+  CloudShortInterestPayload,
+  CloudBrowserHandoffResponse,
   CloudCorporateActionsPayload,
   CloudPricePointPayload,
   CloudEconEventPayload,
+  CloudEquityDiagnosticMode,
+  CloudEquityDiagnosticResult,
   CloudFredSeriesPayload,
   CloudYieldPointPayload,
   CloudCongressHousePayload,
   CloudNewsPayload,
+  CloudSecContentResponse,
+  CloudSecDocumentsResponse,
+  CloudSecFilingsResponse,
   CloudNewsListResponse,
   CloudTweetSearchResponse,
   CloudMarketResponse,
   CloudMarketBatchTarget,
   CloudMarketBatchPayload,
+  CloudMarketScreenerCategory,
+  CloudMarketScreenerPayload,
   CloudVerificationResponse,
+  DeviceAuthStartResponse,
+  DeviceAuthTokenResponse,
   CloudRoundupPreviewResponse,
   CloudSyncPushResponse,
   CloudSyncSnapshotResponse,
   QuoteStreamTarget,
+  ScannerFeedEvent,
+  ScannerKind,
 } from "./types";
 import type { SyncSettings, SyncSnapshot } from "../sync/types";
 
@@ -65,6 +80,8 @@ const ASSIST_REQUEST_TIMEOUT_MS = 6_000;
 
 class GloomApiClient {
   private currentUser: AuthUser | null = null;
+  private sessionChecked = false;
+  private sessionRequest: Promise<AuthUser | null> | null = null;
   private readonly currentUserListeners = new Set<() => void>();
   private readonly transport = new CloudApiRequestTransport();
   private readonly auth: CloudAuthApi;
@@ -76,6 +93,7 @@ class GloomApiClient {
     this.auth = new CloudAuthApi({
       getCurrentUser: () => this.currentUser,
       getSessionToken: () => this.transport.getSessionToken(),
+      hasSessionCredential: () => this.transport.hasSessionCredential(),
       request: (path, options) => this.request(path, options),
       requireCapturedSession: (message) => this.requireCapturedSession(message),
       setCurrentUser: (user) => this.setCurrentUser(user),
@@ -85,6 +103,7 @@ class GloomApiClient {
     this.socket = new CloudApiSocket({
       getBaseUrl: () => this.transport.baseUrl,
       getSocketAuthToken: () => this.getSocketAuthToken(),
+      hasSessionCredential: () => this.transport.hasSessionCredential(),
       hasVerifiedUser: () => this.currentUser?.emailVerified === true,
       isUsingWebSocketToken: () => !!this.transport.getWebSocketToken(),
       clearWebSocketTokenForFallback: () => this.transport.clearWebSocketTokenForFallback(),
@@ -115,8 +134,14 @@ class GloomApiClient {
     return this.transport.getWebSocketToken();
   }
 
+  setCookieSessionMode(enabled: boolean): void {
+    this.sessionChecked = false;
+    this.transport.setCookieSessionMode(enabled);
+  }
+
   setSessionToken(token: string | null): void {
     const changed = this.transport.getSessionToken() !== token;
+    this.sessionChecked = false;
     this.transport.setSessionToken(token);
     if (!token) {
       this.currentUser = null;
@@ -135,6 +160,15 @@ class GloomApiClient {
     return this.currentUser;
   }
 
+  /**
+   * Whether a signed-in session exists on this surface. Browser builds keep the
+   * session in an HttpOnly cookie, so the raw token is deliberately null there
+   * and the restored user is the only signal.
+   */
+  isSignedIn(): boolean {
+    return !!this.transport.getSessionToken() || !!this.currentUser;
+  }
+
   /** Notifies when the signed-in user changes, including plan and trial entitlement. */
   subscribeCurrentUser(listener: () => void): () => void {
     this.currentUserListeners.add(listener);
@@ -148,7 +182,7 @@ class GloomApiClient {
   }
 
   isVerified(): boolean {
-    return !!this.transport.getSessionToken() && !!this.currentUser?.emailVerified;
+    return this.transport.hasSessionCredential() && !!this.currentUser?.emailVerified;
   }
 
   private setCurrentUser(user: AuthUser | null): void {
@@ -179,7 +213,7 @@ class GloomApiClient {
   }
 
   private requireCapturedSession(message: string): void {
-    if (this.transport.getSessionToken()) return;
+    if (this.transport.hasSessionCredential()) return;
     this.transport.setWebSocketToken(null);
     this.setCurrentUser(null);
     throw new Error(message);
@@ -194,7 +228,9 @@ class GloomApiClient {
   }
 
   async ensureVerifiedSession(): Promise<AuthUser | null> {
-    return this.auth.ensureVerifiedSession();
+    if (!this.transport.hasSessionCredential()) return null;
+    if (!this.currentUser && !this.sessionChecked) await this.getSession();
+    return this.currentUser?.emailVerified ? this.currentUser : null;
   }
 
   async signUp(email: string, username: string, name: string, password: string): Promise<AuthUser> {
@@ -205,18 +241,52 @@ class GloomApiClient {
     return this.auth.signIn(email, password);
   }
 
+  async startDeviceSignIn(body: { clientName?: string; clientPlatform?: string }): Promise<DeviceAuthStartResponse> {
+    return this.auth.startDeviceSignIn(body);
+  }
+
+  async pollDeviceSignIn(deviceCode: string): Promise<DeviceAuthTokenResponse> {
+    return this.auth.pollDeviceSignIn(deviceCode);
+  }
+
   async signOut(): Promise<void> {
     return this.auth.signOut();
   }
 
   async getSession(): Promise<AuthUser | null> {
-    return this.auth.getSession();
+    if (this.sessionRequest) return this.sessionRequest;
+    this.sessionRequest = this.auth.getSession();
+    try {
+      const user = await this.sessionRequest;
+      this.sessionChecked = true;
+      return user;
+    } finally {
+      this.sessionRequest = null;
+    }
   }
 
   async sendVerification(): Promise<CloudVerificationResponse> {
     return this.auth.sendVerification();
   }
 
+  async requestPasswordReset(email: string): Promise<void> {
+    return this.auth.requestPasswordReset(email);
+  }
+
+  async createBrowserHandoff(): Promise<CloudBrowserHandoffResponse> {
+    return this.auth.createBrowserHandoff();
+  }
+
+  /** Creates a Stripe checkout session for Cloud Pro; the URL opens in a browser. */
+  async createCloudCheckout(): Promise<{ url: string }> {
+    return this.request<{ url: string }>("/stripe/checkout", { method: "POST", body: JSON.stringify({}) });
+  }
+
+  /** Stripe billing portal for an account that already has a subscription. */
+  async createBillingPortal(): Promise<{ url: string }> {
+    return this.request<{ url: string }>("/stripe/portal", { method: "POST", body: JSON.stringify({}) });
+  }
+
   async getAccountProfile(): Promise<AccountProfile> {
     return this.auth.getAccountProfile();
   }
@@ -394,6 +464,11 @@ class GloomApiClient {
     return this.socket.subscribeQuotes(targets, onQuote);
   }
 
+  /** Subscribes to a shared scanner feed; all panes of one kind share one upstream subscription. */
+  subscribeScanner(scanner: ScannerKind, listener: (event: ScannerFeedEvent) => void): () => void {
+    return this.socket.subscribeScanner(scanner, listener);
+  }
+
   dispose(): void {
     this.socket.dispose();
   }
@@ -413,6 +488,14 @@ class GloomApiClient {
     return this.data.getCloudQuotesBatch(targets, mode);
   }
 
+  async getCloudMarketScreener(
+    category: CloudMarketScreenerCategory,
+    count = 25,
+    mode: "cache-first" | "refresh" = "cache-first",
+  ): Promise<CloudMarketResponse<CloudMarketScreenerPayload>> {
+    return this.data.getCloudMarketScreener(category, count, mode);
+  }
+
   async getCloudOptionsChain(
     symbol: string,
     exchange?: string,
@@ -444,6 +527,10 @@ class GloomApiClient {
     return this.data.getCloudHolders(symbol, exchange);
   }
 
+  async getCloudShortInterest(symbol: string, years?: number): Promise<CloudMarketResponse<CloudShortInterestPayload>> {
+    return this.data.getCloudShortInterest(symbol, years);
+  }
+
   async getCloudAnalystResearch(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudAnalystResearchPayload>> {
     return this.data.getCloudAnalystResearch(symbol, exchange);
   }
@@ -476,6 +563,14 @@ class GloomApiClient {
     return this.data.getCloudEconomicCalendar();
   }
 
+  async getCloudEquityDiagnostic(
+    symbol: string,
+    exchange?: string,
+    mode: CloudEquityDiagnosticMode = "cache-first",
+  ): Promise<CloudEquityDiagnosticResult> {
+    return this.data.getCloudEquityDiagnostic(symbol, exchange, mode);
+  }
+
   async getCloudFredSeries(
     seriesId: string,
     params: CloudFredSeriesParams = {},
@@ -491,6 +586,22 @@ class GloomApiClient {
     return this.data.getCloudCongressHouse(params);
   }
 
+  async getCloudSecFilings(params: CloudSecFilingsParams): Promise<CloudSecFilingsResponse> {
+    return this.data.getCloudSecFilings(params);
+  }
+
+  async getCloudSecFilingDocuments(params: CloudSecFilingParams): Promise<CloudSecDocumentsResponse> {
+    return this.data.getCloudSecFilingDocuments(params);
+  }
+
+  async getCloudSecFilingContent(params: CloudSecFilingParams): Promise<CloudSecContentResponse> {
+    return this.data.getCloudSecFilingContent(params);
+  }
+
+  async getCloudSec13F(path: string, params: Record<string, string | number | undefined> = {}): Promise<unknown> {
+    return this.data.getCloudSec13F(path, params);
+  }
+
   async getCloudNews(params: CloudNewsParams = {}): Promise<CloudNewsListResponse> {
     return this.data.getCloudNews(params);
   }

package/src/api-client/paths.ts

@@ -19,7 +19,9 @@ export type CloudFredSeriesParams = {
 export type CloudCongressHouseParams = {
   year?: number;
   limit?: number;
+  offset?: number;
   filingLimit?: number;
+  filingOffset?: number;
   member?: string;
   ticker?: string;
   refresh?: boolean;
@@ -60,6 +62,23 @@ export type CloudTweetSearchParams = {
   hours?: number;
 };
 
+const LOGO_SYMBOL_RE = /^[A-Z0-9][A-Z0-9._^:-]{0,23}$/;
+const CRYPTO_QUOTE = /[-/](USD|USDT|USDC|EUR|GBP|BTC)$/;
+
+export type CloudLogoKind = "ticker" | "crypto";
+
+export function normalizeCloudLogoSymbol(kind: CloudLogoKind, symbol: string): string | null {
+  let normalized = symbol.trim().toUpperCase();
+  if (kind === "crypto") normalized = normalized.replace(CRYPTO_QUOTE, "");
+  return LOGO_SYMBOL_RE.test(normalized) ? normalized : null;
+}
+
+export function cloudLogoPath(kind: CloudLogoKind, symbol: string): string | null {
+  const normalized = normalizeCloudLogoSymbol(kind, symbol);
+  if (!normalized) return null;
+  return `/cloud/logos/${kind}/${encodeURIComponent(normalized)}`;
+}
+
 function appendQuery(path: string, search: URLSearchParams): string {
   const query = search.toString();
   return `${path}${query ? `?${query}` : ""}`;
@@ -118,17 +137,71 @@ export function cloudFredSeriesPath(seriesId: string, params: CloudFredSeriesPar
   return appendQuery(`/cloud/econ/series/${encodeURIComponent(seriesId)}`, search);
 }
 
+export type CloudSecFilingsParams = {
+  ticker: string;
+  limit?: number;
+  offset?: number;
+};
+
+export type CloudSecFilingParams = {
+  cik?: string;
+  accession?: string;
+  form?: string;
+  primaryDocument?: string;
+  primaryDocumentUrl?: string;
+  filingUrl?: string;
+};
+
 export function cloudCongressHousePath(params: CloudCongressHouseParams = {}): string {
   const search = new URLSearchParams();
   if (params.year != null) search.set("year", String(params.year));
   if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.offset != null) search.set("offset", String(params.offset));
   if (params.filingLimit != null) search.set("filingLimit", String(params.filingLimit));
+  if (params.filingOffset != null) search.set("filingOffset", String(params.filingOffset));
   if (params.member) search.set("member", params.member);
   if (params.ticker) search.set("ticker", params.ticker);
   if (params.refresh != null) search.set("refresh", String(params.refresh));
   return appendQuery("/cloud/congress/house", search);
 }
 
+export function cloudSecFilingsPath(params: CloudSecFilingsParams): string {
+  const search = new URLSearchParams({ ticker: params.ticker });
+  if (params.limit != null) search.set("limit", String(params.limit));
+  if (params.offset != null) search.set("offset", String(params.offset));
+  return appendQuery("/cloud/sec/filings", search);
+}
+
+export function cloudSecFilingDocumentsPath(params: CloudSecFilingParams): string {
+  const search = new URLSearchParams();
+  if (params.cik) search.set("cik", params.cik);
+  if (params.accession) search.set("accession", params.accession);
+  if (params.form) search.set("form", params.form);
+  if (params.primaryDocument) search.set("primaryDocument", params.primaryDocument);
+  if (params.filingUrl) search.set("filingUrl", params.filingUrl);
+  return appendQuery("/cloud/sec/filing/documents", search);
+}
+
+export function cloudSecFilingContentPath(params: CloudSecFilingParams): string {
+  const search = new URLSearchParams();
+  if (params.cik) search.set("cik", params.cik);
+  if (params.accession) search.set("accession", params.accession);
+  if (params.form) search.set("form", params.form);
+  if (params.primaryDocument) search.set("primaryDocument", params.primaryDocument);
+  if (params.primaryDocumentUrl) search.set("primaryDocumentUrl", params.primaryDocumentUrl);
+  if (params.filingUrl) search.set("filingUrl", params.filingUrl);
+  return appendQuery("/cloud/sec/filing/content", search);
+}
+
+export function cloudSec13FPath(path: string, params: Record<string, string | number | undefined> = {}): string {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined) search.set(key, String(value));
+  }
+  const normalized = path.startsWith("/") ? path.slice(1) : path;
+  return appendQuery(`/cloud/sec/13f/${normalized}`, search);
+}
+
 export function cloudNewsPath(params: CloudNewsParams = {}): string {
   const search = new URLSearchParams();
   if (params.feed) search.set("feed", params.feed);

package/src/api-client/request.test.ts

@@ -1,4 +1,8 @@
 import { describe, expect, test } from "bun:test";
+import {
+  ConnectionHealthRegistry,
+  registerGloomCloudConnectionSources,
+} from "../core/connection-health";
 import { CloudApiRequestTransport } from "./request";
 
 function responseWithBody(body: () => Promise<string>): Response {
@@ -10,6 +14,32 @@ function responseWithBody(body: () => Promise<string>): Response {
   } as Response;
 }
 
+describe("CloudApiRequestTransport connection reporting", () => {
+  test("reports real FRED requests to both Gloom and FRED sources", async () => {
+    const health = new ConnectionHealthRegistry();
+    const dispose = registerGloomCloudConnectionSources(health);
+    const transport = new CloudApiRequestTransport({
+      connectionHealth: health,
+      fetchTransport: async () => responseWithBody(async () => JSON.stringify({ observations: [], info: null })),
+    });
+
+    await transport.request("/cloud/econ/series/VIXCLS?limit=120&sortOrder=desc");
+
+    expect(health.getSnapshot().sources.map((source) => ({
+      id: source.id,
+      status: source.status,
+      operation: source.lastOperation,
+    }))).toEqual([
+      { id: "gloom-cloud-http", status: "connected", operation: "GET /cloud/econ/series/VIXCLS" },
+      { id: "gloom-cloud-socket", status: "idle", operation: null },
+      { id: "gloom-cloud-fred", status: "connected", operation: "GET /cloud/econ/series/VIXCLS" },
+    ]);
+
+    dispose();
+    expect(health.getSnapshot().sources).toEqual([]);
+  });
+});
+
 describe("CloudApiRequestTransport market deadlines", () => {
   test("aborts when response headers never arrive", async () => {
     let signal: AbortSignal | null | undefined;