gloomberb 0.18.3 → 0.18.5

package/src/api-client/hiring.ts

@@ -108,3 +108,304 @@ export interface HiringBoard {
   locked: number
   companies: HiringSummary[]
 }
+
+/**
+ * Why a company's week is not measured: the collection changed, so its new
+ * roles say nothing about hiring (docs/hiring-app-attention.md, Moves).
+ */
+export type HiringMoveExclusion =
+  | "first_read" | "source_added" | "identity_reset" | "catch_up" | "retired" | "truncated" | "rediscovered"
+  | "recipe_restored" | "careers_url_dropped" | "read_gap" | "collapsed" | "no_read" | "vendor_wide"
+
+export interface HiringMoveWeek {
+  week: string
+  newRoles: number | null
+  closedRoles: number | null
+  openRoles: number | null
+  reads: number
+  measured: boolean
+  excluded: HiringMoveExclusion[]
+}
+
+/**
+ * Why a move is held from alerts and ranked after the others: one day carried
+ * most of its new roles, its boards were read too seldom to tell a steady
+ * rise from a batch, or it is more roles than the boards ever held open.
+ */
+export type HiringMoveFlag = "one_day_batch" | "few_reads" | "outsized"
+
+/** A company's new roles in one UTC week against its own measured weeks before and its peers'. */
+export interface HiringMove {
+  symbol: string
+  name: string
+  sector: string | null
+  industry: string | null
+  sourceTickers: string[]
+  week: string
+  newRoles: number
+  closedRoles: number
+  openRoles: number
+  /** `values` is empty in a free read: the weeks are history. */
+  baseline: { weeks: number; mean: number; sd: number; values: Array<{ week: string; newRoles: number }> }
+  ratio: number | null
+  zScore: number
+  peers: { group: "industry" | "sector" | "universe"; label: string; companies: number; medianRatio: number | null }
+  peerRelative: number | null
+  direction: "accelerating" | "slowing" | null
+  /** `with_peers`: the company moved, and so did its peers. */
+  signal: "accelerating" | "slowing" | "with_peers" | null
+  /** Role families behind the move, each scaled to the week's measured new roles. */
+  drivers: Array<{ id: string; label: string; newRoles: number; baselineMean: number }>
+  topTitles: Array<{ title: string; count: number }>
+  /** Absent from a server before flags. */
+  flags?: HiringMoveFlag[]
+  /** The day with the most new roles that week, and how many. */
+  peakDay?: { day: string; newRoles: number } | null
+  /** A board that cannot place its new roles on a day: its reads that week and the days they counted. */
+  unplacedRead?: { reads: number; days: number | null } | null
+  /** The most roles the company's boards held open in a week before. */
+  priorMaxOpen?: number | null
+  why: string
+  firstComputedAt: string
+  computedAt: string
+  /** Since when the current signal has held; it alerts once a pass 12 hours on keeps it. */
+  signalSince?: string
+  confirmed?: boolean
+}
+
+export interface HiringMovePosting {
+  id: string
+  title: string
+  url: string | null
+  location: string | null
+  country: string | null
+  jobFunction: string | null
+  seniority: string | null
+  firstSeenAt: string
+  closedAt: string | null
+  sourceTicker: string
+}
+
+export type HiringMovesFilter = "all" | "moves" | "accelerating" | "slowing"
+
+export interface HiringMovesBoard {
+  generatedAt: string
+  proRequired: true
+  preview: boolean
+  week: string | null
+  /** A free read is always the own moves, whatever was asked. */
+  filter?: HiringMovesFilter
+  total: number
+  locked: number
+  coverage: {
+    measured: number
+    signals: { accelerating: number; slowing: number; withPeers: number }
+    unmeasured: number
+    unmeasuredReasons: Partial<Record<HiringMoveExclusion, number>>
+    computedAt: string | null
+    baselineWeeks: number
+  }
+  moves: HiringMove[]
+}
+
+export interface HiringCompanyMoves {
+  generatedAt: string
+  proRequired: true
+  preview: boolean
+  symbol: string
+  requestedSymbol?: string
+  name: string | null
+  latest: HiringMove | null
+  /** The latest week, measured or not. */
+  week: HiringMoveWeek | null
+  weeks: HiringMoveWeek[]
+  history: Array<Pick<HiringMove, "week" | "newRoles" | "ratio" | "zScore" | "peerRelative" | "direction" | "signal" | "computedAt">>
+  evidence: { added: HiringMovePosting[]; closed: HiringMovePosting[] }
+  evidenceTotals: { added: number; closed: number }
+  /** `move`: a free read of a company off the free board keeps its week, not its move. */
+  locked: { history: number; added: number; closed: number; move?: number }
+}
+
+/**
+ * HIRE's Expansion and Anomalies tabs: a company's first roles in a country
+ * or city, one place or role family far above its own weeks, and role
+ * families it never posted, in the latest complete week.
+ */
+export type HiringSignalGroup = "expansion" | "anomalies"
+export type HiringSignalKind = "new_country" | "new_city" | "location_spike" | "function_spike" | "new_role_type"
+export type HiringSignalsFilter = "all" | HiringSignalKind
+/** Why a company's week gives no signal at all. */
+export type HiringSignalHold = "unmeasured" | "short_watch" | "recounted"
+/** Why a kind was not looked for at a company, or a first or a spike was dropped. */
+export type HiringSignalSkip = "thin_history" | "unplaced_history" | "unplaced_cities" | "unclassified_history" | "reformatted" | "posted_before_watch" | "similar_city" | "one_day"
+/** A spike shown last: a seldom-read board, or a week Moves flagged. */
+export type HiringSignalFlag = "few_reads" | "one_day_batch"
+
+export interface HiringWeekSignal {
+  symbol: string
+  name: string
+  sector: string | null
+  industry: string | null
+  sourceTickers: string[]
+  week: string
+  kind: HiringSignalKind
+  group: HiringSignalGroup
+  dimension: "country" | "city" | "function"
+  /** `MX`, `austin|US`, `data_ai`. */
+  key: string
+  /** `Mexico`, `Austin, TX, US`, `Data & AI`. */
+  label: string
+  country: string | null
+  newRoles: number
+  titles: number
+  /** How far back "never" goes: every board read since `watchedSince`, and the postings seen before the week. */
+  history: { watchedSince: string; priorPostings: number; priorShare: number | null }
+  /** A spike's weeks before; `values` is empty in a free read. */
+  baseline: { weeks: number; mean: number; values: Array<{ week: string; newRoles: number }> } | null
+  ratio: number | null
+  zScore: number | null
+  /** The company's own pace in the same terms, for a spike. */
+  companyRatio: number | null
+  flags: HiringSignalFlag[]
+  reads: number | null
+  topTitles: Array<{ title: string; count: number }>
+  places: Array<{ label: string; count: number }>
+  postings: HiringMovePosting[]
+  why: string
+  firstComputedAt: string
+  computedAt: string
+}
+
+export interface HiringSignalsBoard {
+  generatedAt: string
+  proRequired: true
+  preview: boolean
+  group: HiringSignalGroup
+  /** A free read is always the group's first three, whatever was asked. */
+  filter: HiringSignalsFilter
+  week: string | null
+  total: number
+  locked: number
+  coverage: {
+    measured: number
+    counts: Partial<Record<HiringSignalKind, number>>
+    held: Partial<Record<HiringSignalHold, number>>
+    skipped: Partial<Record<HiringSignalSkip, number>>
+    /** The earliest and latest first read of a measured company: how far back "never" goes. */
+    watchedFrom: string | null
+    watchedTo: string | null
+    computedAt: string | null
+  }
+  signals: HiringWeekSignal[]
+}
+
+export interface HiringCompanySignals {
+  generatedAt: string
+  proRequired: true
+  preview: boolean
+  symbol: string
+  requestedSymbol?: string
+  name: string | null
+  week: string | null
+  watchedSince: string | null
+  held: HiringSignalHold | null
+  skipped: HiringSignalSkip[]
+  /** The latest week's signals, both groups. */
+  signals: HiringWeekSignal[]
+  history: HiringWeekSignal[]
+  /** What a free read holds back: this week's, earlier weeks', and both by tab. Absent by tab from a server before it. */
+  locked: { signals: number; history: number } & Partial<Record<HiringSignalGroup, number>>
+}
+
+/**
+ * HIRE's Building tab: the role families and themes whose share of a
+ * company's new roles rose against its own weeks before, and each company's
+ * whole mix, recent weeks against the weeks before.
+ */
+type HiringBuildingDimension = "function" | "theme"
+export type HiringBuildingFilter = "all" | HiringBuildingDimension
+/** Why a company has no mix to compare. */
+export type HiringBuildingHold = "shared_board" | "unmeasured" | "recounted" | "rescoped" | "short_watch" | "thin"
+/** Compared in part: no family mix, or some themes not yet read. */
+export type HiringBuildingSkip = "unclassified" | "unread_titles"
+
+export interface HiringMixRow {
+  dimension: HiringBuildingDimension
+  /** `sales`, `ai_ml`. */
+  key: string
+  /** `Sales`, `AI & machine learning`. */
+  label: string
+  recentRoles: number
+  /** Of the recent weeks' roles with a role family (a family), or of all of them (a theme). */
+  recentShare: number
+  beforeRoles: number
+  beforeShare: number
+  change: number
+  /** A theme whose titles have all been read; a family always is. */
+  read: boolean
+}
+
+interface HiringBuildingWeek { week: string; roles: number; classified: number }
+
+export interface HiringBuildingShift {
+  symbol: string
+  name: string
+  sector: string | null
+  industry: string | null
+  sourceTickers: string[]
+  week: string
+  dimension: HiringBuildingDimension
+  key: string
+  label: string
+  /** `values` is empty in a free read. */
+  recent: { weeks: number; roles: number; total: number; share: number; values: Array<{ week: string; roles: number; total: number }> }
+  before: { weeks: number; roles: number; total: number; share: number; values: Array<{ week: string; roles: number; total: number }> }
+  change: number
+  ratio: number | null
+  zScore: number
+  titles: number
+  topTitles: Array<{ title: string; count: number }>
+  postings: HiringMovePosting[]
+  why: string
+  firstComputedAt: string
+  computedAt: string
+}
+
+export interface HiringBuildingBoard {
+  generatedAt: string
+  proRequired: true
+  preview: boolean
+  /** A free read is always the first three, whatever was asked. */
+  filter: HiringBuildingFilter
+  week: string | null
+  total: number
+  locked: number
+  coverage: {
+    measured: number
+    counts: Partial<Record<HiringBuildingDimension, number>>
+    held: Partial<Record<HiringBuildingHold, number>>
+    skipped: Partial<Record<HiringBuildingSkip, number>>
+    /** Theme titles in the weeks compared, and how many the model has read. */
+    themeTitles: { titles: number; read: number }
+    computedAt: string | null
+  }
+  shifts: HiringBuildingShift[]
+}
+
+export interface HiringCompanyBuilding {
+  generatedAt: string
+  proRequired: true
+  preview: boolean
+  symbol: string
+  requestedSymbol?: string
+  name: string | null
+  week: string | null
+  held: HiringBuildingHold | null
+  skipped: HiringBuildingSkip[]
+  window: { recent: HiringBuildingWeek[]; before: HiringBuildingWeek[] } | null
+  functions: HiringMixRow[]
+  themes: HiringMixRow[]
+  shifts: HiringBuildingShift[]
+  history: HiringBuildingShift[]
+  locked: { functions: number; themes: number; shifts: number; history: number }
+}

package/src/api-client/index.ts

@@ -62,11 +62,13 @@ export type {
 /** Server-side caps for `/assist/command`; enforced here so a 422 is never sent. */
 const ASSIST_QUERY_MAX_LENGTH = 200;
 const ASSIST_COMMAND_LIMIT = 150;
-/** The futures curve's root list is the longest a command sends: 76 since GLO-783. */
+/** The futures curve's root list is the longest a command sends: 76. */
 export const ASSIST_ARG_OPTION_LIMIT = 128;
 const ASSIST_ARG_OPTION_VALUE_MAX_LENGTH = 40;
 const ASSIST_ARG_OPTION_LABEL_MAX_LENGTH = 60;
 const ASSIST_REQUEST_TIMEOUT_MS = 6_000;
+const SESSION_REVALIDATION_INITIAL_MS = 1_000;
+const SESSION_REVALIDATION_MAX_MS = 30_000;
 
 /**
  * Fits a command's argument values inside the server caps. The value is what
@@ -94,8 +96,15 @@ interface PendingSessionRequest {
 
 class GloomApiClient {
   private currentUser: AuthUser | null = null;
-  /** Local identity of a verified user/credential pair, never serialized. */
+  /** Local user/credential binding, masked until verified and never serialized. */
   private verifiedSessionIdentity: object | null = null;
+  private verifiedSessionCredential: string | null = null;
+  private sessionTransitions = 0;
+  private sessionTransition: Promise<void> | null = null;
+  /** Device adoption and external session installs supersede pending email auth. */
+  private sessionInstallationGeneration = 0;
+  private sessionRevalidationGeneration = 0;
+  private sessionRevalidationTimer: ReturnType<typeof setTimeout> | null = null;
   private sessionChecked = false;
   /** Last few session transitions, content-free, for app://auth. */
   private authTrace: Array<{ at: number; event: string; token: boolean; user: string }> = [];
@@ -110,7 +119,7 @@ class GloomApiClient {
     request: (path, options, canApplySession) => this.request(path, options, canApplySession),
     requireCapturedSession: (message) => this.requireCapturedSession(message),
     setCurrentUser: (user) => this.setCurrentUser(user),
-    setSessionToken: (token) => this.setSessionToken(token),
+    setSessionToken: (token) => this.installSessionToken(token),
     updateCurrentUser: (updater) => this.updateCurrentUser(updater),
   });
   private readonly socket: CloudApiSocket = new CloudApiSocket({
@@ -123,7 +132,6 @@ class GloomApiClient {
     markCurrentUserUnverified: () => {
       if (this.currentUser) {
         this.currentUser = { ...this.currentUser, emailVerified: false };
-        this.verifiedSessionIdentity = null;
         this.emitCurrentUserChange();
       }
     },
@@ -165,6 +173,8 @@ class GloomApiClient {
   }
 
   setCookieSessionMode(enabled: boolean): void {
+    this.cancelSessionRevalidation();
+    this.sessionInstallationGeneration += 1;
     this.sessionChecked = false;
     this.verifiedSessionIdentity = null;
     this.transport.setCookieSessionMode(enabled);
@@ -172,12 +182,21 @@ class GloomApiClient {
   }
 
   setSessionToken(token: string | null): void {
+    if (this.transport.getSessionToken() !== token || !token) {
+      this.cancelSessionRevalidation();
+      this.sessionInstallationGeneration += 1;
+    }
+    this.installSessionToken(token);
+  }
+
+  private installSessionToken(token: string | null): void {
     const changed = this.transport.getSessionToken() !== token;
     this.sessionChecked = false;
     this.transport.setSessionToken(token);
     if (changed) this.verifiedSessionIdentity = null;
     this.traceAuth(changed ? "setSessionToken:changed" : "setSessionToken:same");
     if (!token) {
+      this.cancelSessionRevalidation();
       this.currentUser = null;
       this.verifiedSessionIdentity = null;
     }
@@ -224,7 +243,9 @@ class GloomApiClient {
 
   /** Null while a replacement credential still awaits its matching user. */
   getVerifiedSessionIdentity(): object | null {
-    return this.isVerified() ? this.verifiedSessionIdentity : null;
+    return this.sessionTransitions === 0 && this.isVerified()
+      && this.verifiedSessionCredential === this.transport.getSessionToken()
+      ? this.verifiedSessionIdentity : null;
   }
 
   /**
@@ -276,11 +297,18 @@ class GloomApiClient {
     if (this.authTrace.length > 24) this.authTrace.shift();
   }
 
-  private setCurrentUser(user: AuthUser | null): void {
+  private setCurrentUser(user: AuthUser | null, confirmSession = true): void {
+    const sameAccount = this.currentUser?.id === user?.id;
     const changed = this.socketEntitlementKey(this.currentUser) !== this.socketEntitlementKey(user);
     this.traceAuth("setCurrentUser", user);
     this.currentUser = user;
-    this.verifiedSessionIdentity = this.isVerified() ? {} : null;
+    if (confirmSession) {
+      this.clearSessionRevalidationTimer();
+      this.verifiedSessionIdentity = user ? {} : null;
+      this.verifiedSessionCredential = this.transport.getSessionToken();
+    } else if (!sameAccount || !user) {
+      this.verifiedSessionIdentity = null;
+    }
     this.socket.syncAuthState({ reconnect: changed });
     this.emitCurrentUserChange();
   }
@@ -291,7 +319,9 @@ class GloomApiClient {
 
   private updateCurrentUser(updater: (user: AuthUser) => AuthUser): void {
     if (!this.currentUser) return;
-    this.setCurrentUser(updater(this.currentUser));
+    // A socket/profile update is metadata, not proof that a replacement
+    // credential belongs to this user. Keep its existing binding, even null.
+    this.setCurrentUser(updater(this.currentUser), false);
   }
 
   private socketEntitlementKey(user: AuthUser | null): string {
@@ -326,11 +356,123 @@ class GloomApiClient {
     return this.currentUser?.emailVerified ? this.currentUser : null;
   }
 
-  signUp = this.auth.signUp.bind(this.auth);
-  signIn = this.auth.signIn.bind(this.auth);
+  signUp = (email: string, username: string, name: string, password: string) =>
+    this.withSessionTransition((isCurrent) => this.auth.signUp(email, username, name, password, isCurrent));
+  signIn = (email: string, password: string) =>
+    this.withSessionTransition((isCurrent) => this.auth.signIn(email, password, isCurrent));
   startDeviceSignIn = this.auth.startDeviceSignIn.bind(this.auth);
   pollDeviceSignIn = this.auth.pollDeviceSignIn.bind(this.auth);
-  signOut = this.auth.signOut.bind(this.auth);
+  signOut = () => this.withSessionTransition((isCurrent) => this.auth.signOut(isCurrent), false);
+
+  /** Cookies can change before an auth response's body arrives, including ones the browser hides. */
+  private withSessionTransition<T>(run: (isCurrent: () => boolean) => Promise<T>, reconcileFailure = true): Promise<T> {
+    const previous = this.sessionTransition;
+    this.cancelSessionRevalidation();
+    let revalidationGeneration = this.sessionRevalidationGeneration;
+    const generation = this.sessionInstallationGeneration;
+    const isCurrent = () => generation === this.sessionInstallationGeneration;
+    this.sessionTransitions += 1;
+    this.sessionChecked = false;
+    this.verifiedSessionIdentity = null;
+    this.sessionRequestGeneration += 1;
+    this.emitCurrentUserChange();
+    let needsRevalidation = false;
+    const operation = (async () => {
+      // Serialize credential-changing requests so a late response cannot pair
+      // one account's user with another request's installed cookie.
+      if (previous) await previous;
+      try {
+        if (!isCurrent()) throw new Error("Another sign-in replaced this request.");
+        // An earlier queued sign-out may have retired retries while clearing its token.
+        revalidationGeneration = this.sessionRevalidationGeneration;
+        this.sessionRequestGeneration += 1;
+        const result = await run(isCurrent);
+        if (!isCurrent()) throw new Error("Another sign-in replaced this request.");
+        return result;
+      } catch (error) {
+        if (isCurrent()) {
+          this.verifiedSessionIdentity = null;
+          this.sessionChecked = false;
+        }
+        if (isCurrent() && reconcileFailure && this.transport.hasSessionCredential()) {
+          // A failed body may already have changed the cookie. A fresh session
+          // check is the only way to resume; retry if it cannot validate yet.
+          needsRevalidation = true;
+          this.sessionRequestGeneration += 1;
+          await this.revalidateSession(() => isCurrent()
+            && revalidationGeneration === this.sessionRevalidationGeneration).catch((failure) => {
+            if (!isCurrent()) return;
+            this.verifiedSessionIdentity = null;
+            logFailure("cloud.auth", "Restore session after failed sign-in failed")(failure);
+          });
+        }
+        throw error;
+      } finally {
+        if (isCurrent()) this.sessionRequestGeneration += 1;
+        this.sessionTransitions -= 1;
+        if (isCurrent() && needsRevalidation) this.scheduleSessionRevalidation(revalidationGeneration);
+        this.emitCurrentUserChange();
+      }
+    })();
+    const settled = operation.then(() => {}, () => {
+      // Intentional ignore: the caller receives the error while the auth queue continues.
+    });
+    this.sessionTransition = settled;
+    void settled.then(() => { if (this.sessionTransition === settled) this.sessionTransition = null; });
+    return operation;
+  }
+
+  private clearSessionRevalidationTimer(): void {
+    if (this.sessionRevalidationTimer !== null) clearTimeout(this.sessionRevalidationTimer);
+    this.sessionRevalidationTimer = null;
+  }
+
+  private cancelSessionRevalidation(): void {
+    this.sessionRevalidationGeneration += 1;
+    this.clearSessionRevalidationTimer();
+  }
+
+  /** A failed auth response can replace a cookie even when its recovery read is offline. */
+  private scheduleSessionRevalidation(generation: number, delay = SESSION_REVALIDATION_INITIAL_MS): void {
+    const isCurrent = () => generation === this.sessionRevalidationGeneration;
+    const needsRevalidation = () => isCurrent() && this.sessionTransitions === 0
+      && !this.sessionChecked && this.verifiedSessionIdentity === null && this.transport.hasSessionCredential();
+    if (!needsRevalidation() || this.sessionRevalidationTimer !== null) return;
+    this.sessionRevalidationTimer = setTimeout(() => {
+      this.sessionRevalidationTimer = null;
+      if (!needsRevalidation()) return;
+      void this.revalidateSession(isCurrent).catch((error) => {
+        if (isCurrent()) logFailure("cloud.auth", "Retry session validation failed")(error);
+      }).finally(() => {
+        this.scheduleSessionRevalidation(generation, Math.min(delay * 2, SESSION_REVALIDATION_MAX_MS));
+      });
+    }, delay);
+    this.sessionRevalidationTimer.unref?.();
+  }
+
+  private async revalidateSession(isCurrent: () => boolean): Promise<void> {
+    const user = await this.getSession(isCurrent);
+    const credential = this.getSessionToken();
+    if (user || !credential || !isCurrent()) return;
+    // A native null-session response can retain a usable token. Validate it
+    // through the account endpoint, without pairing it with a cached user.
+    this.sessionChecked = false;
+    const previousUser = this.currentUser;
+    const canApply = () => isCurrent() && this.getSessionToken() === credential && this.currentUser === previousUser;
+    try {
+      const profile = await this.auth.getAccountProfile(canApply);
+      if (!canApply()) return;
+      this.sessionChecked = true;
+      this.auth.restoreCachedUser({ ...profile, updatedAt: profile.updatedAt ?? undefined });
+    } catch (error) {
+      if (!canApply()) return;
+      if (error instanceof ApiRequestError && error.status === 401) {
+        this.installSessionToken(null);
+        return;
+      }
+      throw error;
+    }
+  }
 
   async getSession(isCurrent: () => boolean = () => true): Promise<AuthUser | null> {
     if (!isCurrent()) return this.currentUser;
@@ -353,7 +495,10 @@ class GloomApiClient {
       credential: this.getSessionToken(),
       promise: this.auth.getSession(canApply)
         .then(({ user, validated }) => {
-          if (validated && canApply()) this.sessionChecked = true;
+          if (validated && canApply()) {
+            this.sessionChecked = true;
+            this.clearSessionRevalidationTimer();
+          }
           this.traceAuth(validated ? "getSession:done" : "getSession:retained", user);
           return user;
         })
@@ -373,9 +518,13 @@ class GloomApiClient {
   requestPasswordReset = this.auth.requestPasswordReset.bind(this.auth);
   createBrowserHandoff = this.auth.createBrowserHandoff.bind(this.auth);
 
-  /** Creates a Stripe checkout session for Cloud Pro; the URL opens in a browser. */
-  async createCloudCheckout(returnTo?: string, interval: "month" | "year" = "month"): Promise<{ url: string }> {
-    return this.request<{ url: string }>("/stripe/checkout", { method: "POST", body: JSON.stringify({ returnTo, interval }) });
+  /**
+   * Creates a Stripe checkout session for Cloud Pro; the URL opens in a browser.
+   * `link` is a short link to the same checkout, to read or scan on another
+   * device. Older servers send none.
+   */
+  async createCloudCheckout(returnTo?: string, interval: "month" | "year" = "month"): Promise<{ url: string; link?: string }> {
+    return this.request<{ url: string; link?: string }>("/stripe/checkout", { method: "POST", body: JSON.stringify({ returnTo, interval }) });
   }
 
   async recordResearchActivity(payload: {
@@ -404,7 +553,7 @@ class GloomApiClient {
   async brokerRequest<T>(
     broker: string,
     path: string,
-    options: { method?: "GET" | "POST" | "DELETE"; body?: unknown; signal?: AbortSignal } = {},
+    options: { method?: "GET" | "POST" | "PUT" | "DELETE"; body?: unknown; signal?: AbortSignal } = {},
   ): Promise<T> {
     if (!/^[a-z][a-z0-9-]{0,31}$/.test(broker)) throw new Error(`Invalid broker id "${broker}".`);
     if (path !== "" && (!/^\/[A-Za-z0-9/_.~%?=&-]*$/.test(path) || path.includes(".."))) {
@@ -749,6 +898,8 @@ class GloomApiClient {
   subscribeScanner = this.socket.subscribeScanner.bind(this.socket);
 
   dispose(): void {
+    this.cancelSessionRevalidation();
+    this.sessionInstallationGeneration += 1;
     this.sessionRequestGeneration += 1;
     this.sessionRequest = null;
     this.socket.dispose();
@@ -782,6 +933,7 @@ class GloomApiClient {
   getCloudEconomicCalendar = this.data.getCloudEconomicCalendar.bind(this.data);
   getCloudEconomicCalendarFrom = this.data.getCloudEconomicCalendarFrom.bind(this.data);
   getCloudMacroReleaseDays = this.data.getCloudMacroReleaseDays.bind(this.data);
+  getCloudShortRates = this.data.getCloudShortRates.bind(this.data);
   getCloudEquityDiagnostic = this.data.getCloudEquityDiagnostic.bind(this.data);
   getCloudEarningsCalendar = this.data.getCloudEarningsCalendar.bind(this.data);
   getCloudEarningsHistory = this.data.getCloudEarningsHistory.bind(this.data);
@@ -790,16 +942,20 @@ class GloomApiClient {
   getCloudCryptoMarkets = this.data.getCloudCryptoMarkets.bind(this.data);
   getCloudStablecoinSupply = this.data.getCloudStablecoinSupply.bind(this.data);
   getCloudStablecoinSupplyHistory = this.data.getCloudStablecoinSupplyHistory.bind(this.data);
+  getCloudDefiTvl = this.data.getCloudDefiTvl.bind(this.data);
   getCloudCentralBankRates = this.data.getCloudCentralBankRates.bind(this.data);
   getMobileAlertHistory = this.data.getMobileAlertHistory.bind(this.data);
   getScannerFlowHistory = this.data.getScannerFlowHistory.bind(this.data);
+  getLiveScan = this.data.getLiveScan.bind(this.data);
   getCloudEstimateRevisions = this.data.getCloudEstimateRevisions.bind(this.data);
   getCloudMoneyMarkets = this.data.getCloudMoneyMarkets.bind(this.data);
   equityScreener = this.data.equityScreener.bind(this.data);
   getMemberFunds = this.data.getMemberFunds.bind(this.data);
   getFundMembers = this.data.getFundMembers.bind(this.data);
+  getFundBreadth = this.data.getFundBreadth.bind(this.data);
   getFundChanges = this.data.getFundChanges.bind(this.data);
   getFundFacts = this.data.getFundFacts.bind(this.data);
+  getCloudExchangeAnnouncements = this.data.getCloudExchangeAnnouncements.bind(this.data);
   getCloudThemes = this.data.getCloudThemes.bind(this.data);
   getCloudThemeMembers = this.data.getCloudThemeMembers.bind(this.data);
   impliedVolatility = this.data.impliedVolatility.bind(this.data);
@@ -815,7 +971,10 @@ class GloomApiClient {
   getPublicInsolvencyNotices = this.data.getPublicInsolvencyNotices.bind(this.data);
   getPublicLetters = this.data.getPublicLetters.bind(this.data);
   getCloudIpoCalendar = this.data.getCloudIpoCalendar.bind(this.data);
+  getCloudFailsToDeliver = this.data.getCloudFailsToDeliver.bind(this.data);
+  getCloudOtcVolume = this.data.getCloudOtcVolume.bind(this.data);
   getCloudShortVolume = this.data.getCloudShortVolume.bind(this.data);
+  getCloudCryptoEtfFlows = this.data.getCloudCryptoEtfFlows.bind(this.data);
   getCloudSocialMentions = this.data.getCloudSocialMentions.bind(this.data);
   getCloudSocialMentionPosts = this.data.getCloudSocialMentionPosts.bind(this.data);
   getCloudFuturesCurve = this.data.getCloudFuturesCurve.bind(this.data);
@@ -828,6 +987,11 @@ class GloomApiClient {
   creditDocuments = this.data.creditDocuments.bind(this.data);
   geo = this.data.geo.bind(this.data);
   getCloudHiring = this.data.getCloudHiring.bind(this.data);
+  getCloudHiringMoves = this.data.getCloudHiringMoves.bind(this.data);
+  getCloudHiringSignals = this.data.getCloudHiringSignals.bind(this.data);
+  getCloudHiringCompanySignals = this.data.getCloudHiringCompanySignals.bind(this.data);
+  getCloudHiringBuilding = this.data.getCloudHiringBuilding.bind(this.data);
+  getCloudHiringCompanyBuilding = this.data.getCloudHiringCompanyBuilding.bind(this.data);
   getCloudAppRankHistory = this.data.getCloudAppRankHistory.bind(this.data);
   getCloudAppAttention = this.data.getCloudAppAttention.bind(this.data);
   getCloudCatalystChanges = this.data.getCloudCatalystChanges.bind(this.data);
@@ -872,6 +1036,7 @@ class GloomApiClient {
   getCloudTape = this.data.getCloudTape.bind(this.data);
   getCloudYieldCurve = this.data.getCloudYieldCurve.bind(this.data);
   getCloudCurve = this.data.getCloudCurve.bind(this.data);
+  getCloudSwapCurve = this.data.getCloudSwapCurve.bind(this.data);
   getCloudCurveHistory = this.data.getCloudCurveHistory.bind(this.data);
   getCloudWorldCurves = this.data.getCloudWorldCurves.bind(this.data);
   getCloudCds = this.data.getCloudCds.bind(this.data);
@@ -882,6 +1047,7 @@ class GloomApiClient {
   getCloudCongressHouse = this.data.getCloudCongressHouse.bind(this.data);
   getCloudJobs = this.data.getCloudJobs.bind(this.data);
   getCloudJobsPostings = this.data.getCloudJobsPostings.bind(this.data);
+  getCloudJobsPosting = this.data.getCloudJobsPosting.bind(this.data);
   getCloudJobsMovers = this.data.getCloudJobsMovers.bind(this.data);
   getCloudEarningsCalls = this.data.getCloudEarningsCalls.bind(this.data);
   getCloudEarningsTranscript = this.data.getCloudEarningsTranscript.bind(this.data);