gloomberb 0.14.0 → 0.15.0

package/src/api-client/socket-protocol.test.ts

@@ -0,0 +1,90 @@
+import { afterEach, expect, test } from "bun:test";
+import { CloudApiSocket } from "./socket";
+import { getServerClockOffsetMs, resetServerClockForTests } from "../market-data/quotes/clock";
+import type { CloudQuotePayload, QuoteStreamTarget } from "./types";
+
+const originalWebSocket = globalThis.WebSocket;
+const sockets: TestSocket[] = [];
+
+class TestSocket {
+  static readonly OPEN = 1;
+  readyState = 0;
+  sent: any[] = [];
+  onopen: (() => void) | null = null;
+  onclose: (() => void) | null = null;
+  onerror: (() => void) | null = null;
+  onmessage: ((event: { data: string }) => void) | null = null;
+  constructor(_url: string) { sockets.push(this); }
+  send(data: string) { this.sent.push(JSON.parse(data)); }
+  close() { this.readyState = 3; }
+  open() { this.readyState = 1; this.onopen?.(); }
+  receive(message: unknown) { this.onmessage?.({ data: JSON.stringify(message) }); }
+}
+
+afterEach(() => {
+  globalThis.WebSocket = originalWebSocket;
+  sockets.length = 0;
+  resetServerClockForTests();
+});
+
+function createSocket() {
+  globalThis.WebSocket = TestSocket as unknown as typeof WebSocket;
+  const socket = new CloudApiSocket({
+    getBaseUrl: () => "https://api.example.test",
+    getSocketAuthToken: () => null,
+    hasSessionCredential: () => false,
+    hasVerifiedUser: () => false,
+    isUsingWebSocketToken: () => false,
+    clearWebSocketTokenForFallback: () => false,
+    markCurrentUserUnverified: () => {},
+    updateCurrentUserFromSocket: () => {},
+  });
+  const received: Array<{ target: QuoteStreamTarget; quote: CloudQuotePayload }> = [];
+  socket.subscribeQuotes(
+    [{ symbol: "AAPL", exchange: "NASDAQ" }, { symbol: "MSFT", exchange: "NASDAQ" }],
+    (target, quote) => received.push({ target, quote }),
+  );
+  const ws = sockets.at(-1)!;
+  ws.open();
+  return { socket, ws, received };
+}
+
+test("opts into batched quotes only when the server offers them, once per connection", () => {
+  const { ws } = createSocket();
+  ws.receive({ type: "ready", user: null, marketTier: "anonymous" });
+  expect(ws.sent.some((message) => message.type === "client.features")).toBe(false);
+
+  ws.receive({ type: "ready", user: null, serverTime: Date.now(), features: ["market.batch", "future.thing"] });
+  ws.receive({ type: "ready", user: null, serverTime: Date.now(), features: ["market.batch"] });
+  expect(ws.sent.filter((message) => message.type === "client.features"))
+    .toEqual([{ type: "client.features", features: ["market.batch"] }]);
+});
+
+test("dispatches every item of a batched frame like a single quote frame", () => {
+  const { ws, received } = createSocket();
+  ws.receive({
+    type: "market.quotes",
+    at: Date.now(),
+    quotes: [
+      { symbol: "AAPL", exchange: "NASDAQ", quote: { symbol: "AAPL", price: 231 }, delivery: "stream", stale: false },
+      { symbol: "TSLA", exchange: "NASDAQ", quote: { symbol: "TSLA", price: 400 }, delivery: "stream", stale: false },
+      { symbol: "MSFT", exchange: "NASDAQ", quote: { symbol: "MSFT", price: 510 }, delivery: "poll", stale: true },
+      { symbol: "BROKEN" },
+    ],
+  });
+  ws.receive({ type: "market.quote", symbol: "AAPL", exchange: "NASDAQ", quote: { symbol: "AAPL", price: 232 }, delivery: "stream" });
+
+  expect(received.map(({ target, quote }) => [target.symbol, quote.price, quote.delivery, quote.stale])).toEqual([
+    ["AAPL", 231, "stream", false],
+    ["MSFT", 510, "poll", true],
+    ["AAPL", 232, "stream", undefined],
+  ]);
+});
+
+test("measures how far the server clock runs ahead from ready and batch stamps", () => {
+  const { ws } = createSocket();
+  ws.receive({ type: "ready", user: null, serverTime: Date.now() + 4_000, features: [] });
+  expect(getServerClockOffsetMs()).toBeGreaterThan(3_500);
+  ws.receive({ type: "market.quotes", at: Date.now() + 6_000, quotes: [] });
+  expect(getServerClockOffsetMs()).toBeGreaterThan(5_500);
+});

package/src/api-client/socket.ts

@@ -1,3 +1,4 @@
+import type { TapeFeedEvent } from "./tape";
 import type {
   AuthUser,
   ChatMessage,
@@ -16,6 +17,7 @@ import {
 import { debugLog } from "../utils/debug-log";
 import { canonicalExchange, normalizeSymbol } from "../utils/exchanges";
 import { mergeQuoteSubscriptionTargets } from "../market-data/quote-subscription-target";
+import { recordServerClockSample } from "../market-data/quotes/clock";
 import {
   connectionHealth,
   GLOOM_CLOUD_SOCKET_CONNECTION_ID,
@@ -23,6 +25,13 @@ import {
 } from "../core/connection-health";
 
 const QUOTE_SUBSCRIPTION_FLUSH_MS = 25;
+/**
+ * Protocol features this client can read. A server lists the ones it offers
+ * in "ready"; the client opts into the shared ones, so an older server never
+ * sees a request it does not understand.
+ */
+const MARKET_BATCH_FEATURE = "market.batch";
+const CLIENT_SOCKET_FEATURES = [MARKET_BATCH_FEATURE] as const;
 const cloudApiLog = debugLog.createLogger("cloud-api");
 
 type ChannelListener = (message: ChatMessage) => void;
@@ -112,6 +121,9 @@ export class CloudApiSocket {
   >();
   private quoteSubscriptionFlushTimer: ReturnType<typeof setTimeout> | null =
     null;
+  /** The connection that already opted into server features; a reconnect negotiates again. */
+  private featuresRequestedFor: WebSocket | null = null;
+  private readonly tapeListeners = new Map<string, { symbol: string; exchange: string; listeners: Set<(event: TapeFeedEvent) => void> }>();
   private readonly scannerListeners = new Map<
     ScannerKind,
     Set<ScannerListener>
@@ -136,6 +148,7 @@ export class CloudApiSocket {
   }
 
   teardown(): void {
+    this.emitTapeStatus({ type: "reset", reason: "Stream session changed" });
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
@@ -301,6 +314,30 @@ export class CloudApiSocket {
     };
   }
 
+  subscribeTape(symbol: string, exchange: string, listener: (event: TapeFeedEvent) => void): () => void {
+    const target = { symbol: normalizeSymbol(symbol), exchange: canonicalExchange(exchange) };
+    const key = marketKey(target.symbol, target.exchange);
+    const existing = this.tapeListeners.get(key);
+    const entry = existing ?? { ...target, listeners: new Set<(event: TapeFeedEvent) => void>() };
+    entry.listeners.add(listener);
+    this.tapeListeners.set(key, entry);
+    this.ensureSocket();
+    if (!existing) this.sendSocketMessage({ type: "tape.subscribe", ...target });
+    return () => {
+      const current = this.tapeListeners.get(key);
+      if (!current?.listeners.delete(listener)) return;
+      if (!current.listeners.size) {
+        this.tapeListeners.delete(key);
+        this.sendSocketMessage({ type: "tape.unsubscribe", ...target });
+      }
+      if (!this.shouldKeepSocketOpen()) this.teardown();
+    };
+  }
+
+  private emitTapeStatus(event: Exclude<TapeFeedEvent, { type: "data" }>): void {
+    for (const entry of this.tapeListeners.values()) for (const listener of entry.listeners) listener(event);
+  }
+
   subscribeQuotes(
     targets: QuoteStreamTarget[],
     onQuote: (target: QuoteStreamTarget, quote: CloudQuotePayload) => void,
@@ -427,6 +464,7 @@ export class CloudApiSocket {
     this.quoteTargets.clear();
     this.pendingQuoteSubscribes.clear();
     this.pendingQuoteUnsubscribes.clear();
+    this.tapeListeners.clear();
     this.scannerListeners.clear();
     this.scannerSnapshots.clear();
     if (this.quoteSubscriptionFlushTimer) {
@@ -445,7 +483,10 @@ export class CloudApiSocket {
       return;
     }
 
-    if (parsed?.type === "ready" && parsed.user) {
+    if (parsed?.type === "ready") {
+      recordServerClockSample(parsed.serverTime);
+      this.negotiateSocketFeatures(parsed.features);
+      if (!parsed.user) return;
       cloudApiLog.info("websocket ready", {
         emailVerified: parsed.user.emailVerified === true,
       });
@@ -470,7 +511,7 @@ export class CloudApiSocket {
         return;
       }
       this.delegate.markCurrentUserUnverified();
-      if (this.quoteTargets.size > 0 || this.scannerListeners.size > 0) {
+      if (this.quoteTargets.size > 0 || this.scannerListeners.size > 0 || this.tapeListeners.size > 0) {
         return;
       }
       this.teardown();
@@ -520,6 +561,12 @@ export class CloudApiSocket {
       return;
     }
 
+    if (parsed?.type === "tape.snapshot" && parsed.data && typeof parsed.data.symbol === "string" && typeof parsed.data.exchange === "string") {
+      const entry = this.tapeListeners.get(marketKey(parsed.data.symbol, parsed.data.exchange));
+      for (const listener of entry?.listeners ?? []) listener({ type: "data", payload: parsed.data });
+      return;
+    }
+
     const scannerKind =
       typeof parsed?.type === "string"
         ? SCANNER_MESSAGE_KINDS[parsed.type]
@@ -542,23 +589,16 @@ export class CloudApiSocket {
       return;
     }
 
-    if (
-      parsed?.type === "market.quote" &&
-      parsed.quote &&
-      typeof parsed.symbol === "string"
-    ) {
-      const key = marketKey(parsed.symbol, parsed.exchange);
-      const quote: CloudQuotePayload = {
-        ...(parsed.quote as CloudQuotePayload),
-        ...(parsed.delivery === "stream" || parsed.delivery === "poll"
-          ? { delivery: parsed.delivery }
-          : {}),
-        ...(typeof parsed.stale === "boolean" ? { stale: parsed.stale } : {}),
-      };
-      for (const subscription of this.quoteSubscriptions.get(key)?.values() ??
-        []) {
-        subscription.listener(subscription.target, quote);
-      }
+    if (parsed?.type === "market.quote") {
+      this.dispatchMarketQuote(parsed);
+      return;
+    }
+
+    if (parsed?.type === "market.quotes") {
+      recordServerClockSample(parsed.at);
+      if (!Array.isArray(parsed.quotes)) return;
+      // One synchronous pass: every item lands before the next data frame.
+      for (const item of parsed.quotes) this.dispatchMarketQuote(item);
       return;
     }
 
@@ -573,6 +613,31 @@ export class CloudApiSocket {
     }
   }
 
+  /** Delivers one market.quote frame, or one item of a market.quotes batch, to its listeners. */
+  private dispatchMarketQuote(frame: any): void {
+    if (!frame?.quote || typeof frame.symbol !== "string") return;
+    const subscriptions = this.quoteSubscriptions.get(marketKey(frame.symbol, frame.exchange));
+    if (!subscriptions) return;
+    const quote: CloudQuotePayload = {
+      ...(frame.quote as CloudQuotePayload),
+      ...(frame.delivery === "stream" || frame.delivery === "poll"
+        ? { delivery: frame.delivery }
+        : {}),
+      ...(typeof frame.stale === "boolean" ? { stale: frame.stale } : {}),
+    };
+    for (const subscription of subscriptions.values()) {
+      subscription.listener(subscription.target, quote);
+    }
+  }
+
+  private negotiateSocketFeatures(offered: unknown): void {
+    if (!Array.isArray(offered) || this.featuresRequestedFor === this.ws) return;
+    const features = CLIENT_SOCKET_FEATURES.filter((feature) => offered.includes(feature));
+    if (features.length === 0) return;
+    this.featuresRequestedFor = this.ws;
+    this.sendSocketMessage({ type: "client.features", features });
+  }
+
   private getWebSocketBaseUrl(): string {
     const baseUrl = this.delegate.getBaseUrl();
     const wsProtocol = baseUrl.startsWith("https") ? "wss" : "ws";
@@ -590,7 +655,7 @@ export class CloudApiSocket {
   }
 
   private shouldKeepSocketOpen(): boolean {
-    if (this.quoteTargets.size > 0 || this.scannerListeners.size > 0)
+    if (this.quoteTargets.size > 0 || this.scannerListeners.size > 0 || this.tapeListeners.size > 0)
       return true;
     return (
       this.delegate.hasSessionCredential() &&
@@ -642,6 +707,9 @@ export class CloudApiSocket {
         this.getWebSocketBaseUrl(),
       );
       this.reconnectDelayMs = 1000;
+      // The full set goes out now; queued diffs from before the open are part of it.
+      this.pendingQuoteSubscribes.clear();
+      this.pendingQuoteUnsubscribes.clear();
       this.flushSubscriptions();
     };
 
@@ -654,6 +722,7 @@ export class CloudApiSocket {
       const activeSocket = this.ws === ws;
       if (this.ws === ws) {
         this.ws = null;
+      this.emitTapeStatus({ type: "disconnected", reason: "Stream disconnected; observed window may contain gaps" });
       }
       const closeEvent = event as CloseEvent | undefined;
       cloudApiLog.warn("websocket closed", {
@@ -696,7 +765,9 @@ export class CloudApiSocket {
 
   private scheduleReconnect(): void {
     if (this.reconnectTimer || !this.shouldKeepSocketOpen()) return;
-    const delay = this.reconnectDelayMs;
+    // Jittered so clients dropped together by a server restart do not all
+    // come back in the same instant.
+    const delay = Math.round(this.reconnectDelayMs * (0.5 + Math.random()));
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.reconnectDelayMs = Math.min(this.reconnectDelayMs * 2, 10_000);
@@ -733,6 +804,10 @@ export class CloudApiSocket {
       this.sendSocketMessage({ type: "chat.subscribe", channelId });
     }
 
+    for (const entry of this.tapeListeners.values()) {
+      this.sendSocketMessage({ type: "tape.subscribe", symbol: entry.symbol, exchange: entry.exchange });
+    }
+
     for (const scanner of this.scannerListeners.keys()) {
       this.sendSocketMessage({ type: "scanner.subscribe", scanner });
     }

package/src/api-client/tape-socket.test.ts

@@ -0,0 +1,44 @@
+import { expect, test } from "bun:test";
+import { CloudApiSocket } from "./socket";
+import type { TapeFeedEvent } from "./tape";
+
+async function until(predicate: () => boolean) {
+  const deadline = Date.now() + 2500;
+  while (!predicate()) {
+    if (Date.now() >= deadline) throw new Error("Tape socket did not settle");
+    await Bun.sleep(10);
+  }
+}
+test("tape subscriptions share a socket, replay after auth reset and release the last listener", async () => {
+  const frames: Array<{ type: string; symbol: string; exchange: string }> = [];
+  const peers: Array<{ send(value: string): unknown; close(): unknown }> = [];
+  const server = Bun.serve({ hostname: "127.0.0.1", port: 0,
+    fetch(request, server) { return server.upgrade(request) ? undefined : new Response("Upgrade required", { status: 426 }); },
+    websocket: { open(peer) { peers.push(peer); }, message(_peer, raw) { frames.push(JSON.parse(String(raw))); } },
+  });
+  const socket = new CloudApiSocket({ getBaseUrl: () => `http://127.0.0.1:${server.port}`, getSocketAuthToken: () => null,
+    hasSessionCredential: () => false, hasVerifiedUser: () => false, isUsingWebSocketToken: () => false,
+    clearWebSocketTokenForFallback: () => false, markCurrentUserUnverified() {}, updateCurrentUserFromSocket() {} });
+  const first: TapeFeedEvent[] = [], second: TapeFeedEvent[] = [];
+  try {
+    const closeFirst = socket.subscribeTape("aapl", "NASDAQ", (event) => first.push(event));
+    const closeSecond = socket.subscribeTape("AAPL", "NASDAQ", (event) => second.push(event));
+    await until(() => frames.length === 1);
+    expect(frames[0]).toEqual({ type: "tape.subscribe", symbol: "AAPL", exchange: "NASDAQ" });
+    peers[0]!.send(JSON.stringify({ type: "tape.snapshot", data: { symbol: "MSFT", exchange: "NASDAQ" } }));
+    peers[0]!.send(JSON.stringify({ type: "tape.snapshot", data: { symbol: "AAPL", exchange: "NASDAQ" } }));
+    await until(() => first.length > 0 && second.length > 0);
+    expect(first).toHaveLength(1); expect(second).toHaveLength(1);
+    closeFirst();
+    socket.syncAuthState({ reconnect: true });
+    await until(() => frames.filter((frame) => frame.type === "tape.subscribe").length === 2);
+    expect(second.at(-1)?.type).toBe("reset");
+    expect(first).toHaveLength(1);
+    peers.at(-1)!.close();
+    await until(() => second.at(-1)?.type === "disconnected");
+    closeSecond();
+    const count = peers.length;
+    await Bun.sleep(1100);
+    expect(peers).toHaveLength(count);
+  } finally { socket.dispose(); server.stop(true); }
+});

package/src/api-client/tape.ts

@@ -0,0 +1,44 @@
+export interface TapeTrade {
+  id: string;
+  timestamp: string;
+  price: number;
+  size: number;
+  exchange: string;
+  conditions: string[];
+  tape: string;
+}
+export interface TapeQuote {
+  timestamp: string;
+  bid: number | null;
+  ask: number | null;
+  /** Alpaca quote sizes are round lots. */
+  bidSize: number;
+  askSize: number;
+  bidExchange: string;
+  askExchange: string;
+  conditions: string[];
+  tape: string;
+}
+export interface TapeSnapshot {
+  source: "Alpaca";
+  symbol: string;
+  exchange: string;
+  access: "realtime" | "delayed";
+  feed: "sip" | "delayed_sip";
+  delaySeconds: 0 | 900;
+  status: "available" | "partial" | "unavailable";
+  generatedAt: string;
+  asOf: string | null;
+  observedFrom: string | null;
+  trades: TapeTrade[];
+  quotes: TapeQuote[];
+  session: { date: string | null; high: number | null; low: number | null; asOf: string | null };
+  gaps: string[];
+  capacity: { trades: number; quotes: number };
+  dropped: { trades: number; quotes: number };
+  corrections: number;
+  cancels: number;
+  connected: boolean;
+}
+export type TapeFeedEvent = { type: "data"; payload: TapeSnapshot }
+  | { type: "reset" | "disconnected"; reason: string };

package/src/api-client/types.ts

@@ -450,7 +450,7 @@ type CloudCongressTradeSide = "BUY" | "SELL" | "EXCHANGE" | "OTHER";
 
 export interface CloudCongressTradePayload {
   id: string;
-  chamber: "house";
+  chamber: "house" | "senate";
   filingId: string;
   docId: string;
   memberName: string;
@@ -474,6 +474,11 @@ export interface CloudCongressTradePayload {
   subholdingOf: string | null;
   description: string | null;
   sourceUrl: string;
+  returnSinceTx?: number | null;
+  returnSinceFiling?: number | null;
+  returnAsOf?: string | null;
+  party?: string | null;
+  committees?: string[];
 }
 
 export interface CloudCongressMemberPayload {
@@ -489,12 +494,33 @@ export interface CloudCongressMemberPayload {
   estimatedHigh: number | null;
   lastFilingDate: string | null;
   avgLagDays: number | null;
+  medianReturn?: number | null;
+  buyHitRate?: number | null;
+  pricedTradeCount?: number;
+  pricedBuyCount?: number;
+  party?: string | null;
+  committees?: string[];
+}
+
+export interface CloudCongressTickerPayload {
+  ticker: string;
+  tradeCount: number;
+  buyCount: number;
+  sellCount: number;
+  exchangeCount: number;
+  otherCount: number;
+  memberCount: number;
+  memberIds: string[];
+  estimatedLow: number | null;
+  estimatedHigh: number | null;
+  lastFilingDate: string | null;
 }
 
 export interface CloudCongressHousePayload {
   asOf: string;
-  chamber: "house";
-  source: "house-clerk";
+  /** "all" pages both chambers' filings as one date-ordered index. */
+  chamber: "house" | "senate" | "all";
+  source: "house-clerk" | "senate-efd" | "congress";
   year: number;
   indexUpdatedAt: string | null;
   filingsScanned: number;
@@ -504,6 +530,10 @@ export interface CloudCongressHousePayload {
   filingsFailed?: number;
   /** Filings left unread because the server's daily document budget is spent. */
   filingsPending?: number;
+  /** Scanned Senate paper filings: listed and linked, not read. */
+  filingsPaper?: number;
+  /** The merged feed could not reach the Senate source; this window is House only. */
+  senateUnavailable?: boolean;
   filingCount: number;
   filingOffset?: number;
   hasMore?: boolean;
@@ -512,6 +542,7 @@ export interface CloudCongressHousePayload {
   nextFilingOffset?: number;
   trades: CloudCongressTradePayload[];
   members: CloudCongressMemberPayload[];
+  tickers?: CloudCongressTickerPayload[];
 }
 
 export interface CloudEarningsCallPayload {
@@ -533,8 +564,13 @@ export interface CloudEarningsCallPayload {
 export interface CloudJobsSeriesPoint {
   day: string;
   open: number;
-  new: number;
+  /** Null on the first observed day, when the whole board is seen for the first time. */
+  new: number | null;
   closed: number;
+  /** Open standing roles the company hires for continuously. */
+  evergreen?: number;
+  /** Open contract and temporary roles. */
+  contract?: number;
 }
 
 export interface CloudJobsBucket {
@@ -554,6 +590,9 @@ export interface CloudJobsPosting {
   location: string | null;
   country: string | null;
   remote: boolean | null;
+  employmentKind?: string | null;
+  /** A standing posting for a continuous-hiring role; null when unjudged. */
+  evergreen?: boolean | null;
   postedAt: string | null;
   postedPrecision: "exact" | "approximate" | "floor" | null;
   firstSeenAt: string;
@@ -595,6 +634,16 @@ export interface CloudJobsSummaryPayload {
   /** Open postings the system dates within the last 30 days. */
   posted30d?: number | null;
   remoteShare: number | null;
+  /**
+   * Open roles that are standing postings for continuous-hiring positions
+   * (baristas, servers, store associates, nurses). One more of those says
+   * nothing about the company's plans; open minus evergreen is the count of
+   * specific roles.
+   */
+  evergreenCount?: number;
+  evergreenShare?: number | null;
+  /** Share of open roles that are contract or temporary, among those known. */
+  contractShare?: number | null;
   medianAgeDays: number | null;
   series: CloudJobsSeriesPoint[];
   /** The current backlog by how long each role has been posted. */
@@ -795,6 +844,8 @@ export interface CloudFilingEventPayload {
   filedAt: string;
   /** Verified SEC filing calendar date; filedAt may instead be an acceptance instant. */
   filingDate?: string | null;
+  /** "8-K", or "8-K/A" for an amendment. Older servers omit it. */
+  form?: string;
   docUrl: string;
   items: string[];
   labels: string[];
@@ -1185,6 +1236,10 @@ export interface CloudMarketResponse<T> {
   staleAt?: string;
   stale?: boolean;
   currency?: string;
+  /** Untrusted history-only failure evidence, validated by the history adapter. */
+  historyRetention?: unknown;
+  /** Source-declared history semantics; validated separately from quote metadata. */
+  historySession?: unknown;
   coverage?: {
     inceptionDate: string;
     firstAllowedBarDate: string;
@@ -1434,6 +1489,25 @@ export interface ScannerFlowPayload extends ScannerAccessInfo {
   events: ScannerFlowEvent[];
 }
 
+/** Filters for recorded flow prints, matching the FLOW pane's own. */
+export interface ScannerFlowHistoryQuery {
+  /** Page before this print (newest first); omit for the latest prints. */
+  before?: { at: number; id: string };
+  limit?: number;
+  minPremium?: number;
+  right?: "C" | "P";
+  kind?: "sweep" | "block";
+  minVolOi?: number;
+  maxExpiryDays?: number;
+  /** Only these listed symbols (the pane's "mine" universe). */
+  symbols?: string[];
+}
+
+export interface ScannerFlowHistoryPage {
+  events: ScannerFlowEvent[];
+  hasMore: boolean;
+}
+
 export type ScannerPayload = ScannerHiloPayload | ScannerFlowPayload;
 
 /** What a scanner subscriber receives: data, or the entitlement refusal. */