@imbingox/acex 0.4.0-beta.15 → 0.4.0-beta.17

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @imbingox/acex
 
+## 0.4.0-beta.17
+
+### Minor Changes
+
+- 35b8163: 事件流新增 `conflate` / `buffer` 与 `maxBuffer` 订阅选项：L1 Book 与 Funding Rate 默认改为 latest-wins，慢消费者只保留同一 `venue:symbol` 的最新事件；market status 事件按 activity/ready/freshness/reason 去重发布；buffer 溢出会丢弃最旧事件并通过 `EVENT_BUFFER_OVERFLOW` runtime error 告警。
+
+## 0.4.0-beta.16
+
+### Minor Changes
+
+- bdaf9ea: 订单生命周期增加 confirmed-missing 收尾与 pending claim TTL：`OrderStatus` 新增 `unknown` 终态，open 订单在 reconcile 单笔回查连续确认不存在后会移入 closed；`CreateClientOptions.order` 新增 `missingOrderEvictionThreshold` 与 `pendingClaimTtlMs`，用于配置幽灵 open 订单驱逐阈值和 `createOrder` timeout claim 回查 TTL。
+
 ## 0.4.0-beta.15
 
 ### Minor Changes

package/docs/api.md

@@ -372,6 +372,26 @@ console.log(time.serverTime, time.roundTripMs, time.estimatedOffsetMs);
 
 Funding Rate 当前通过 Binance mark price websocket 更新，仅支持永续合约（`MarketDefinition.type === "swap"`，包括 Binance TradFi Perps）。spot 或 future 订阅会抛 `MARKET_FUNDING_RATE_UNSUPPORTED`。
 
+### 5.5 事件流 options
+
+Market 事件流支持可选第二参：
+
+```ts
+type EventStreamOptions = {
+  mode?: "conflate" | "buffer";
+  maxBuffer?: number;
+};
+
+client.market.events.l1BookUpdates(
+  { venue: "binance", symbol: "BTC/USDT:USDT" },
+  { mode: "buffer", maxBuffer: 50_000 },
+);
+```
+
+`l1BookUpdates()` 与 `fundingRateUpdates()` 默认使用 `conflate`，同一 `venue:symbol` 慢消费者只保留最新事件，适合策略热路径。需要录制每个 tick 时显式传 `{ mode: "buffer" }`。`market.events.all()` 与 `market.events.status()` 默认使用 `buffer`；显式传 `{ mode: "conflate" }` 时，`all()` 按 `type:venue:symbol` 合并，`status()` 按 `venue:symbol` 合并。
+
+`buffer` 模式默认每个订阅者最多积压 `10_000` 条事件，超过后丢弃最旧事件。每次积压 episode 只会向 `client.events.errors()` 发布一次 `EVENT_BUFFER_OVERFLOW` runtime error，事件 metadata 包含 `stream` 与 `maxBuffer`；队列排空后再次溢出会再次告警。`conflate` 模式天然有界，不使用 `maxBuffer`。
+
 ## 6. AccountManager
 
 ```ts
@@ -400,7 +420,7 @@ Account 事件用于消费余额、仓位、风险或全量快照替换：
 ```ts
 for await (const event of client.account.events.updates({
   accountId: "main-binance",
-})) {
+}, { maxBuffer: 20_000 })) {
   if (event.type === "risk.updated") {
     console.log(event.snapshot.riskRatio);
   }
@@ -408,6 +428,8 @@ for await (const event of client.account.events.updates({
 }
 ```
 
+Account 事件流只支持 `{ maxBuffer?: number }`，不提供 conflate；余额、仓位、风险和状态事件默认按 buffer 语义保留顺序。
+
 ## 7. OrderManager
 
 ```ts
@@ -442,7 +464,7 @@ interface OrderManager {
 
 ### 7.3 本地缓存与查询
 
-- OrderManager 内部按 open / closed 分层缓存订单。**closed（filled / canceled / rejected / expired）订单按 symbol 各保留最近 N 个**，`N = CreateClientOptions.order.maxClosedOrdersPerSymbol`（默认 500，非正或非整数回退默认），超限按 FIFO 裁剪最旧；**open 订单不受此上限限制**。`getOpenOrders()` 查询复杂度与历史终态订单数量无关。
+- OrderManager 内部按 open / closed 分层缓存订单。**closed（filled / canceled / rejected / expired / unknown）订单按 symbol 各保留最近 N 个**，`N = CreateClientOptions.order.maxClosedOrdersPerSymbol`（默认 500，非正或非整数回退默认），超限按 FIFO 裁剪最旧；**open 订单不受此上限限制**。`getOpenOrders()` 查询复杂度与历史终态订单数量无关。
 - `getOrder(input)` 需带 `orderId` 或 `clientOrderId`（否则返回 `undefined`），`symbol` 可选：
   - **精确查单推荐传 `symbol + orderId`**（O(1) 精确索引、唯一命中）。
   - 仅 `clientOrderId` 查询可命中 open 与未被裁剪的 closed；当 `clientOrderId` 唯一（你自定义的或 SDK 生成的 `acex-*`）时可精确命中，但同一 `clientOrderId` 命中多笔时返回**最新一笔**（精确定位历史某一笔请用 `symbol + orderId`）。
@@ -450,13 +472,13 @@ interface OrderManager {
   - 同时给 `orderId` 与 `clientOrderId` 时，两者都匹配才命中。
   - 已超出保留上限被裁剪的 closed 订单将查不到（返回 `undefined`）。
 
-Order 事件用于消费订单状态变化和 open orders 快照校准。Binance private reconcile 会先用 `/papi/v1/um/openOrders` 校验当前 open set；本地 open order 从 open set 消失时，SDK 会优先查询单笔订单终态并发布 `order.filled` / `order.canceled` 等事件。若 Binance retention / not found 导致无法证明终态，SDK 不会合成 filled/canceled，而是保留原 snapshot 并把 order status 标记为 `degraded`，下一轮继续尝试。
+Order 事件用于消费订单状态变化和 open orders 快照校准。Binance private reconcile 会先用 `/papi/v1/um/openOrders` 校验当前 open set；本地 open order 从 open set 消失时，SDK 会优先查询单笔订单终态并发布 `order.filled` / `order.canceled` 等事件。若单笔查询连续确认订单不存在（默认 3 次，`CreateClientOptions.order.missingOrderEvictionThreshold` 可配置），SDK 会把该订单终态化为 `status: "unknown"`、移出 open 缓存并发布一次 runtime error；网络/超时/限流等 transport 错误不会计入该阈值。`createOrder()` 超时保留的 pending claim 会在 reconcile 周期里按 `CreateClientOptions.order.pendingClaimTtlMs`（默认 90s）过期回查：查到订单则正常入库，确认不存在则清理 claim 并发布 runtime error；无 `fetchOrder` 能力的 venue 会保守保留 claim。
 
 ```ts
 for await (const event of client.order.events.updates({
   accountId: "main-binance",
   symbol: "BTC/USDT:USDT",
-})) {
+}, { maxBuffer: 20_000 })) {
   if (event.type === "order.filled") {
     console.log(event.snapshot.filled);
   }
@@ -464,23 +486,28 @@ for await (const event of client.order.events.updates({
 }
 ```
 
+Order 事件流只支持 `{ maxBuffer?: number }`，不提供 conflate；订单中间状态和错误恢复信号默认按 buffer 语义保留顺序。
+
 ## 8. 健康与错误事件
 
 ```ts
 const health = client.getHealth();
 
-for await (const event of client.events.health({ venue: "binance" })) {
+for await (const event of client.events.health(
+  { venue: "binance" },
+  { maxBuffer: 20_000 },
+)) {
   console.log(event.type);
   break;
 }
 
-for await (const error of client.events.errors()) {
+for await (const error of client.events.errors({ maxBuffer: 20_000 })) {
   console.error(error.source, error.error);
   break;
 }
 ```
 
-`getHealth()` 聚合 client、market、account、order 的当前状态。`events.health(filter)` 只返回满足 filter 的事件；如果事件没有 filter 请求的字段，会被过滤掉。
+`getHealth()` 聚合 client、market、account、order 的当前状态。`events.health(filter, options?)` 只返回满足 filter 的事件；如果事件没有 filter 请求的字段，会被过滤掉。`events.health()` 与 `events.errors()` 只支持 `{ maxBuffer?: number }`，默认 buffer 上限同样是 `10_000`；`errors()` 自身溢出时只丢弃最旧错误事件，不再发布新的 overflow 错误，避免递归。
 
 ## 9. 数据类型速查
 
@@ -499,7 +526,8 @@ type OrderStatus =
   | "filled"
   | "canceled"
   | "rejected"
-  | "expired";
+  | "expired"
+  | "unknown";
 
 type PrivateRuntimeReason =
   | "credentials_missing"
@@ -597,6 +625,8 @@ interface CreateClientOptions {
   };
   order?: {
     maxClosedOrdersPerSymbol?: number;
+    missingOrderEvictionThreshold?: number;
+    pendingClaimTtlMs?: number;
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imbingox/acex",
-  "version": "0.4.0-beta.15",
+  "version": "0.4.0-beta.17",
   "description": "Multi-exchange trading SDK for market data, account, and order management",
   "repository": {
     "type": "git",

package/src/client/context.ts

@@ -73,6 +73,13 @@ export interface PrivateSubscriptionState {
   lastReadyAt?: number;
 }
 
+export interface ExpiredPendingOrderClaim {
+  venueClientOrderId: string;
+  localOrderId: string;
+  symbol: string;
+  claimedAt: number;
+}
+
 export interface PrivateAccountDataConsumer {
   onPrivateAccountPending(accountId: string, venue: Venue): void;
   onPrivateAccountBootstrap(
@@ -119,7 +126,22 @@ export interface PrivateOrderDataConsumer {
     update: RawOrderUpdate,
     options?: { requestStartedAt?: number; preserveStatus?: boolean },
   ): void;
+  onPrivateOrderConfirmedMissing(
+    accountId: string,
+    venue: Venue,
+    order: OrderSnapshot,
+  ): void;
   getPrivateOpenOrders(accountId: string): OrderSnapshot[];
+  getExpiredPrivateOrderClaims(
+    accountId: string,
+    now: number,
+    ttlMs: number,
+  ): ExpiredPendingOrderClaim[];
+  onPrivateOrderClaimNotFound(
+    accountId: string,
+    venue: Venue,
+    claim: ExpiredPendingOrderClaim,
+  ): void;
   onPrivateOrderStreamState(
     accountId: string,
     venue: Venue,

package/src/client/private-subscription-coordinator.ts

@@ -12,12 +12,14 @@ import {
 import { isTransportError } from "../internal/http-client.ts";
 import type {
   AccountRuntimeOptions,
+  OrderRuntimeOptions,
   OrderSnapshot,
   PrivateRuntimeReason,
   Venue,
 } from "../types/index.ts";
 import type {
   ClientContext,
+  ExpiredPendingOrderClaim,
   PrivateAccountDataConsumer,
   PrivateOrderDataConsumer,
   RegisteredAccountRecord,
@@ -50,6 +52,7 @@ const DEFAULT_LISTEN_KEY_KEEPALIVE_MS = 30 * 60 * 1_000;
 const DEFAULT_PRIVATE_STREAM_STALE_AFTER_MS = 65 * 60_000;
 const DEFAULT_BINANCE_RISK_POLL_INTERVAL_MS = 5_000;
 const DEFAULT_BINANCE_PRIVATE_RECONCILE_INTERVAL_MS = 60_000;
+const DEFAULT_PENDING_CLAIM_TTL_MS = 90_000;
 const MAX_ORDER_TERMINAL_BACKFILLS_PER_RECONCILE = 20;
 const MAX_ORDER_TERMINAL_BACKFILL_CONCURRENCY = 4;
 
@@ -94,6 +97,7 @@ export class PrivateSubscriptionCoordinator {
   private readonly binancePrivateStreamStaleAfterMs: number;
   private readonly binanceRiskPollIntervalMs: number;
   private readonly binancePrivateReconcileIntervalMs: number | undefined;
+  private readonly pendingClaimTtlMs: number;
   private readonly records = new Map<string, PrivateSubscriptionRecord>();
 
   constructor(
@@ -102,6 +106,7 @@ export class PrivateSubscriptionCoordinator {
     accountConsumer: PrivateAccountDataConsumer,
     orderConsumer: PrivateOrderDataConsumer,
     options: AccountRuntimeOptions = {},
+    orderOptions: OrderRuntimeOptions = {},
   ) {
     this.context = context;
     this.adapters = new Map(
@@ -130,6 +135,10 @@ export class PrivateSubscriptionCoordinator {
       options.binance?.privateReconcileIntervalMs,
       DEFAULT_BINANCE_PRIVATE_RECONCILE_INTERVAL_MS,
     );
+    this.pendingClaimTtlMs = normalizePositiveInterval(
+      orderOptions.pendingClaimTtlMs,
+      DEFAULT_PENDING_CLAIM_TTL_MS,
+    );
   }
 
   async subscribeAccountFeed(accountId: string): Promise<void> {
@@ -940,6 +949,12 @@ export class PrivateSubscriptionCoordinator {
         orderGeneration,
         disappeared,
       );
+      await this.reconcileExpiredPendingOrderClaims(
+        record,
+        account,
+        generation,
+        orderGeneration,
+      );
     } catch (error) {
       if (
         !this.shouldContinueOrderBootstrap(record, generation, orderGeneration)
@@ -1054,11 +1069,104 @@ export class PrivateSubscriptionCoordinator {
       }
 
       if (!update) {
-        this.handleOrderReconcileError(
-          record,
-          new Error(
-            `Failed to backfill disappeared ${record.venue} order terminal state`,
-          ),
+        this.orderConsumer.onPrivateOrderConfirmedMissing(
+          record.accountId,
+          record.venue,
+          order,
+        );
+        return;
+      }
+
+      this.orderConsumer.onPrivateOrderUpdate(
+        record.accountId,
+        record.venue,
+        update,
+        {
+          requestStartedAt,
+        },
+      );
+    } catch (error) {
+      if (
+        !this.shouldContinueOrderBootstrap(record, generation, orderGeneration)
+      ) {
+        return;
+      }
+
+      this.handleOrderReconcileError(record, error);
+    }
+  }
+
+  private async reconcileExpiredPendingOrderClaims(
+    record: PrivateSubscriptionRecord,
+    account: RegisteredAccountRecord,
+    generation: number,
+    orderGeneration: number,
+  ): Promise<void> {
+    const adapter = this.getAdapter(record.venue);
+    if (
+      !this.shouldContinueOrderBootstrap(record, generation, orderGeneration)
+    ) {
+      return;
+    }
+
+    if (!adapter.fetchOrder) {
+      // Pending createOrder claims can only be retired after the venue confirms
+      // the clientOrderId is absent. Adapters without fetchOrder keep claims.
+      return;
+    }
+
+    const expiredClaims = this.orderConsumer.getExpiredPrivateOrderClaims(
+      record.accountId,
+      this.context.now(),
+      this.pendingClaimTtlMs,
+    );
+    for (const claim of expiredClaims) {
+      await this.reconcileExpiredPendingOrderClaim(
+        record,
+        account,
+        generation,
+        orderGeneration,
+        claim,
+      );
+    }
+  }
+
+  private async reconcileExpiredPendingOrderClaim(
+    record: PrivateSubscriptionRecord,
+    account: RegisteredAccountRecord,
+    generation: number,
+    orderGeneration: number,
+    claim: ExpiredPendingOrderClaim,
+  ): Promise<void> {
+    const adapter = this.getAdapter(record.venue);
+    if (
+      !adapter.fetchOrder ||
+      !this.shouldContinueOrderBootstrap(record, generation, orderGeneration)
+    ) {
+      return;
+    }
+
+    const requestStartedAt = this.context.now();
+    try {
+      const update = await adapter.fetchOrder(
+        account.credentials ?? {},
+        {
+          symbol: claim.symbol,
+          clientOrderId: claim.venueClientOrderId,
+        },
+        { ...account.options, accountId: account.accountId },
+      );
+      if (
+        !this.shouldContinueOrderBootstrap(record, generation, orderGeneration)
+      ) {
+        return;
+      }
+
+      if (!update) {
+        this.orderConsumer.onPrivateOrderClaimNotFound(
+          record.accountId,
+          record.venue,
+          claim,
         );
         return;
       }

package/src/client/runtime.ts

@@ -15,6 +15,7 @@ import {
   buildAcexErrorDetails,
   type VenueErrorReason,
 } from "../errors.ts";
+import type { AsyncEventBusOverflowInfo } from "../internal/async-event-bus.ts";
 import { AsyncEventBus } from "../internal/async-event-bus.ts";
 import { matchesHealthFilter } from "../internal/filters.ts";
 import { ReactiveRateLimiter } from "../internal/rate-limiter.ts";
@@ -26,6 +27,7 @@ import type {
   AccountManager,
   AcexClient,
   AcexInternalError,
+  BufferedEventStreamOptions,
   CancelAllOrdersInput,
   CancelOrderInput,
   ClientEventStreams,
@@ -75,14 +77,30 @@ class ClientEventStreamsImpl implements ClientEventStreams {
   constructor(
     private readonly healthBus: AsyncEventBus<HealthEvent>,
     private readonly errorBus: AsyncEventBus<AcexInternalError>,
+    private readonly onHealthOverflow: (
+      info: AsyncEventBusOverflowInfo,
+    ) => void,
   ) {}
 
-  errors(): AsyncIterable<AcexInternalError> {
-    return this.errorBus.stream();
+  errors(
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<AcexInternalError> {
+    return this.errorBus.stream(() => true, {
+      maxBuffer: options?.maxBuffer,
+    });
   }
 
-  health(filter?: HealthEventFilter): AsyncIterable<HealthEvent> {
-    return this.healthBus.stream((event) => matchesHealthFilter(event, filter));
+  health(
+    filter?: HealthEventFilter,
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<HealthEvent> {
+    return this.healthBus.stream(
+      (event) => matchesHealthFilter(event, filter),
+      {
+        maxBuffer: options?.maxBuffer,
+        onOverflow: this.onHealthOverflow,
+      },
+    );
   }
 }
 
@@ -143,12 +161,17 @@ export class AcexClientImpl implements AcexClient, ClientContext {
       this.accountManager as PrivateAccountDataConsumer,
       this.orderManager as PrivateOrderDataConsumer,
       options.account,
+      options.order,
     );
 
     this.market = this.marketManager;
     this.account = this.accountManager;
     this.order = this.orderManager;
-    this.events = new ClientEventStreamsImpl(this.healthBus, this.errorBus);
+    this.events = new ClientEventStreamsImpl(
+      this.healthBus,
+      this.errorBus,
+      this.createOverflowHandler("client.health"),
+    );
   }
 
   // --- AcexClient public API ---
@@ -420,6 +443,21 @@ export class AcexClientImpl implements AcexClient, ClientContext {
     this.healthBus.publish(event);
   }
 
+  private createOverflowHandler(
+    stream: string,
+  ): (info: AsyncEventBusOverflowInfo) => void {
+    return ({ maxBuffer }) => {
+      const error = new AcexError(
+        "EVENT_BUFFER_OVERFLOW",
+        `Event stream buffer overflow: ${stream}`,
+      );
+      this.publishRuntimeError("runtime", error, {
+        stream,
+        maxBuffer,
+      });
+    };
+  }
+
   // --- Private ---
 
   private setClientStatus(status: ClientStatus): void {

package/src/errors.ts

@@ -7,6 +7,7 @@ export type AcexErrorCode =
   | "ACCOUNT_NOT_FOUND"
   | "CLIENT_NOT_STARTED"
   | "CREDENTIALS_MISSING"
+  | "EVENT_BUFFER_OVERFLOW"
   | "VENUE_NOT_SUPPORTED"
   | "MARKET_CATALOG_LOAD_FAILED"
   | "MARKET_SERVER_TIME_FETCH_FAILED"

package/src/internal/async-event-bus.ts

@@ -1,10 +1,25 @@
 type EventPredicate<T> = (event: T) => boolean;
 
+export type AsyncEventBusStreamMode = "buffer" | "conflate";
+
+export interface AsyncEventBusOverflowInfo {
+  maxBuffer: number;
+}
+
+export interface AsyncEventBusStreamOptions<T> {
+  mode?: AsyncEventBusStreamMode;
+  maxBuffer?: number;
+  conflateKey?: (event: T) => string;
+  onOverflow?: (info: AsyncEventBusOverflowInfo) => void;
+}
+
 interface BusListener<T> {
   close(): void;
   dispatch(event: T): void;
 }
 
+const DEFAULT_MAX_BUFFER = 10_000;
+
 function doneResult<T>(): IteratorResult<T> {
   return { done: true, value: undefined as T };
 }
@@ -20,11 +35,67 @@ export class AsyncEventBus<T> {
 
   stream<U extends T = T>(
     filter: ((event: T) => event is U) | EventPredicate<T> = () => true,
+    options: AsyncEventBusStreamOptions<U> = {},
   ): AsyncIterable<U> {
     let closed = false;
-    const queue: U[] = [];
+    const mode = options.mode ?? "buffer";
+    const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
+    const bufferQueue: U[] = [];
+    const conflateQueue =
+      mode === "conflate" ? new Map<string, U>() : undefined;
+    let overflowNotified = false;
     let pendingResolve: ((result: IteratorResult<U>) => void) | undefined;
 
+    if (mode === "conflate" && !options.conflateKey) {
+      throw new Error("AsyncEventBus conflate mode requires conflateKey");
+    }
+
+    const resetOverflowIfDrained = () => {
+      if (bufferQueue.length === 0) {
+        overflowNotified = false;
+      }
+    };
+
+    const enqueue = (event: U) => {
+      if (conflateQueue) {
+        const key = options.conflateKey?.(event);
+        if (key === undefined) {
+          throw new Error("AsyncEventBus conflate mode requires conflateKey");
+        }
+        conflateQueue.set(key, event);
+        return;
+      }
+
+      bufferQueue.push(event);
+
+      if (bufferQueue.length <= maxBuffer) {
+        return;
+      }
+
+      bufferQueue.shift();
+      if (!overflowNotified) {
+        overflowNotified = true;
+        options.onOverflow?.({ maxBuffer });
+      }
+    };
+
+    const dequeue = (): U | undefined => {
+      if (conflateQueue) {
+        const first = conflateQueue.entries().next();
+        if (first.done) {
+          return undefined;
+        }
+
+        const [key, event] = first.value;
+        conflateQueue.delete(key);
+        return event;
+      }
+
+      const event = bufferQueue.shift();
+      resetOverflowIfDrained();
+      return event;
+    };
+
     const close = () => {
       if (closed) {
         return;
@@ -55,7 +126,7 @@ export class AsyncEventBus<T> {
           return;
         }
 
-        queue.push(typedEvent);
+        enqueue(typedEvent);
       },
     };
 
@@ -70,11 +141,12 @@ export class AsyncEventBus<T> {
           return doneResult<U>();
         }
 
-        const queued = queue.shift();
+        const queued = dequeue();
         if (queued !== undefined) {
           return { done: false, value: queued };
         }
 
+        resetOverflowIfDrained();
         return await new Promise<IteratorResult<U>>((resolve) => {
           pendingResolve = resolve;
         });

package/src/managers/account-manager.ts

@@ -14,6 +14,8 @@ import type {
   PrivateAccountDataConsumer,
   PrivateSubscriptionState,
 } from "../client/context.ts";
+import { AcexError } from "../errors.ts";
+import type { AsyncEventBusOverflowInfo } from "../internal/async-event-bus.ts";
 import { AsyncEventBus } from "../internal/async-event-bus.ts";
 import { toCanonical } from "../internal/decimal.ts";
 import { matchesAccountFilter } from "../internal/filters.ts";
@@ -125,23 +127,33 @@ export class AccountManagerImpl
     this.context = context;
 
     this.events = {
-      status: (filter) =>
-        this.accountStatusBus.stream((event) =>
-          matchesAccountFilter(
-            { accountId: event.accountId, venue: event.venue },
-            filter,
-          ),
+      status: (filter, options) =>
+        this.accountStatusBus.stream(
+          (event) =>
+            matchesAccountFilter(
+              { accountId: event.accountId, venue: event.venue },
+              filter,
+            ),
+          {
+            maxBuffer: options?.maxBuffer,
+            onOverflow: this.createOverflowHandler("account.status"),
+          },
         ),
-      updates: (filter) =>
-        this.accountBus.stream((event) =>
-          matchesAccountFilter(
-            {
-              accountId: event.accountId,
-              venue: event.venue,
-              symbol: "symbol" in event ? event.symbol : undefined,
-            },
-            filter,
-          ),
+      updates: (filter, options) =>
+        this.accountBus.stream(
+          (event) =>
+            matchesAccountFilter(
+              {
+                accountId: event.accountId,
+                venue: event.venue,
+                symbol: "symbol" in event ? event.symbol : undefined,
+              },
+              filter,
+            ),
+          {
+            maxBuffer: options?.maxBuffer,
+            onOverflow: this.createOverflowHandler("account.updates"),
+          },
         ),
     };
   }
@@ -872,4 +884,19 @@ export class AccountManagerImpl
     this.accountStatusBus.publish(event);
     this.context.publishHealthEvent(event);
   }
+
+  private createOverflowHandler(
+    stream: string,
+  ): (info: AsyncEventBusOverflowInfo) => void {
+    return ({ maxBuffer }) => {
+      const error = new AcexError(
+        "EVENT_BUFFER_OVERFLOW",
+        `Event stream buffer overflow: ${stream}`,
+      );
+      this.context.publishRuntimeError("account", error, {
+        stream,
+        maxBuffer,
+      });
+    };
+  }
 }