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

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @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

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
@@ -456,7 +478,7 @@ Order 事件用于消费订单状态变化和 open orders 快照校准。Binance
 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. 数据类型速查
 

package/package.json

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

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,
+      },
+    );
   }
 }
 
@@ -149,7 +167,11 @@ export class AcexClientImpl implements AcexClient, ClientContext {
     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 ---
@@ -421,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,
+      });
+    };
+  }
 }

package/src/managers/market-manager.ts

@@ -19,10 +19,15 @@ import {
   buildAcexErrorDetails,
   formatAcexErrorMessage,
 } from "../errors.ts";
+import type {
+  AsyncEventBusOverflowInfo,
+  AsyncEventBusStreamOptions,
+} from "../internal/async-event-bus.ts";
 import { AsyncEventBus } from "../internal/async-event-bus.ts";
 import { toCanonical } from "../internal/decimal.ts";
 import { matchesMarketFilter } from "../internal/filters.ts";
 import type {
+  EventStreamOptions,
   FundingRateSnapshot,
   FundingRateUpdatedEvent,
   L1Book,
@@ -67,6 +72,14 @@ interface MarketRecord {
   status: MarketDataStatus;
   l1BookStream?: StreamHandle;
   fundingRateStream?: StreamHandle;
+  lastPublishedStatusKey?: MarketStatusPublicationKey;
+}
+
+interface MarketStatusPublicationKey {
+  activity: MarketDataStatus["activity"];
+  ready: MarketDataStatus["ready"];
+  freshness: MarketDataStatus["freshness"];
+  reason: MarketDataStatus["reason"];
 }
 
 interface CatalogFetchResult {
@@ -85,10 +98,38 @@ function marketKey(input: MarketKeyInput): string {
   return `${input.venue}:${input.symbol}`;
 }
 
+function marketEventConflateKey(event: MarketEvent): string {
+  return `${event.type}:${marketKey(event)}`;
+}
+
 function cloneMarketStatus(status: MarketDataStatus): MarketDataStatus {
   return { ...status };
 }
 
+function statusPublicationKey(
+  status: MarketDataStatus,
+): MarketStatusPublicationKey {
+  return {
+    activity: status.activity,
+    ready: status.ready,
+    freshness: status.freshness,
+    reason: status.reason,
+  };
+}
+
+function sameStatusPublicationKey(
+  current: MarketStatusPublicationKey,
+  previous: MarketStatusPublicationKey | undefined,
+): boolean {
+  return (
+    previous !== undefined &&
+    current.activity === previous.activity &&
+    current.ready === previous.ready &&
+    current.freshness === previous.freshness &&
+    current.reason === previous.reason
+  );
+}
+
 function cloneStreamStatus(
   status: MarketDataStreamStatus,
 ): MarketDataStreamStatus {
@@ -153,23 +194,49 @@ export class MarketManagerImpl
       options.l1ReconnectMaxDelayMs ?? DEFAULT_L1_RECONNECT_MAX_DELAY_MS;
 
     this.events = {
-      all: (filter) =>
-        this.marketBus.stream((event) => matchesMarketFilter(event, filter)),
-      fundingRateUpdates: (filter) =>
+      all: (filter, options) =>
+        this.marketBus.stream(
+          (event) => matchesMarketFilter(event, filter),
+          this.createStreamOptions(
+            "market.all",
+            options,
+            "buffer",
+            marketEventConflateKey,
+          ),
+        ),
+      fundingRateUpdates: (filter, options) =>
         this.marketBus.stream(
           (event): event is FundingRateUpdatedEvent =>
             event.type === "funding_rate.updated" &&
             matchesMarketFilter(event, filter),
+          this.createStreamOptions(
+            "market.fundingRateUpdates",
+            options,
+            "conflate",
+            marketKey,
+          ),
         ),
-      l1BookUpdates: (filter) =>
+      l1BookUpdates: (filter, options) =>
         this.marketBus.stream(
           (event): event is L1BookUpdatedEvent =>
             event.type === "l1_book.updated" &&
             matchesMarketFilter(event, filter),
+          this.createStreamOptions(
+            "market.l1BookUpdates",
+            options,
+            "conflate",
+            marketKey,
+          ),
         ),
-      status: (filter) =>
-        this.marketStatusBus.stream((event) =>
-          matchesMarketFilter(event, filter),
+      status: (filter, options) =>
+        this.marketStatusBus.stream(
+          (event) => matchesMarketFilter(event, filter),
+          this.createStreamOptions(
+            "market.status",
+            options,
+            "buffer",
+            marketKey,
+          ),
         ),
     };
   }
@@ -1064,6 +1131,14 @@ export class MarketManagerImpl
       record.status.lastReadyAt = this.resolveLastReadyAt(record);
     }
 
+    const publicationKey = statusPublicationKey(record.status);
+    if (
+      sameStatusPublicationKey(publicationKey, record.lastPublishedStatusKey)
+    ) {
+      return;
+    }
+
+    record.lastPublishedStatusKey = publicationKey;
     this.publishStatus(record);
   }
 
@@ -1184,6 +1259,35 @@ export class MarketManagerImpl
     this.context.publishHealthEvent(event);
   }
 
+  private createStreamOptions<U extends { venue: Venue; symbol: string }>(
+    stream: string,
+    options: EventStreamOptions | undefined,
+    defaultMode: "buffer" | "conflate",
+    conflateKey: (event: U) => string,
+  ): AsyncEventBusStreamOptions<U> {
+    return {
+      mode: options?.mode ?? defaultMode,
+      maxBuffer: options?.maxBuffer,
+      conflateKey,
+      onOverflow: this.createOverflowHandler(stream),
+    };
+  }
+
+  private createOverflowHandler(
+    stream: string,
+  ): (info: AsyncEventBusOverflowInfo) => void {
+    return ({ maxBuffer }) => {
+      const error = new AcexError(
+        "EVENT_BUFFER_OVERFLOW",
+        `Event stream buffer overflow: ${stream}`,
+      );
+      this.context.publishRuntimeError("market", error, {
+        stream,
+        maxBuffer,
+      });
+    };
+  }
+
   private async resumeStreams(): Promise<void> {
     for (const record of this.records.values()) {
       const market = record.market;

package/src/managers/order-manager.ts

@@ -17,6 +17,7 @@ import {
   buildAcexErrorDetails,
   formatAcexErrorMessage,
 } from "../errors.ts";
+import type { AsyncEventBusOverflowInfo } from "../internal/async-event-bus.ts";
 import { AsyncEventBus } from "../internal/async-event-bus.ts";
 import { matchesOrderFilter } from "../internal/filters.ts";
 import { isTransportError } from "../internal/http-client.ts";
@@ -116,23 +117,33 @@ export class OrderManagerImpl
     );
 
     this.events = {
-      status: (filter) =>
-        this.orderStatusBus.stream((event) =>
-          matchesOrderFilter(
-            { accountId: event.accountId, venue: event.venue },
-            filter,
-          ),
+      status: (filter, options) =>
+        this.orderStatusBus.stream(
+          (event) =>
+            matchesOrderFilter(
+              { accountId: event.accountId, venue: event.venue },
+              filter,
+            ),
+          {
+            maxBuffer: options?.maxBuffer,
+            onOverflow: this.createOverflowHandler("order.status"),
+          },
         ),
-      updates: (filter) =>
-        this.orderBus.stream((event) =>
-          matchesOrderFilter(
-            {
-              accountId: event.accountId,
-              venue: event.venue,
-              symbol: "symbol" in event ? event.symbol : undefined,
-            },
-            filter,
-          ),
+      updates: (filter, options) =>
+        this.orderBus.stream(
+          (event) =>
+            matchesOrderFilter(
+              {
+                accountId: event.accountId,
+                venue: event.venue,
+                symbol: "symbol" in event ? event.symbol : undefined,
+              },
+              filter,
+            ),
+          {
+            maxBuffer: options?.maxBuffer,
+            onOverflow: this.createOverflowHandler("order.updates"),
+          },
         ),
     };
   }
@@ -1270,6 +1281,21 @@ export class OrderManagerImpl
       },
     };
   }
+
+  private createOverflowHandler(
+    stream: string,
+  ): (info: AsyncEventBusOverflowInfo) => void {
+    return ({ maxBuffer }) => {
+      const error = new AcexError(
+        "EVENT_BUFFER_OVERFLOW",
+        `Event stream buffer overflow: ${stream}`,
+      );
+      this.context.publishRuntimeError("order", error, {
+        stream,
+        maxBuffer,
+      });
+    };
+  }
 }
 
 function isOrderErrorCode(

package/src/types/account.ts

@@ -1,4 +1,5 @@
 import type {
+  BufferedEventStreamOptions,
   PrivateRuntimeReason,
   PrivateRuntimeStatus,
   SubscriptionActivity,
@@ -158,8 +159,14 @@ export type AccountEvent =
   | AccountSnapshotReplacedEvent;
 
 export interface AccountEventStreams {
-  updates(filter?: AccountEventFilter): AsyncIterable<AccountEvent>;
-  status(filter?: AccountEventFilter): AsyncIterable<AccountStatusChangedEvent>;
+  updates(
+    filter?: AccountEventFilter,
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<AccountEvent>;
+  status(
+    filter?: AccountEventFilter,
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<AccountStatusChangedEvent>;
 }
 
 export interface AccountManager {

package/src/types/client.ts

@@ -18,6 +18,7 @@ import type {
 import type {
   AccountCredentials,
   AcexInternalError,
+  BufferedEventStreamOptions,
   ClientStatus,
   CreateClientOptions,
   RegisterAccountInput,
@@ -54,8 +55,13 @@ export interface HealthEventFilter {
 }
 
 export interface ClientEventStreams {
-  health(filter?: HealthEventFilter): AsyncIterable<HealthEvent>;
-  errors(): AsyncIterable<AcexInternalError>;
+  health(
+    filter?: HealthEventFilter,
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<HealthEvent>;
+  errors(
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<AcexInternalError>;
 }
 
 export type VenueRuntimeStatus = "available" | "type_only" | "reserved";

package/src/types/market.ts

@@ -1,6 +1,11 @@
 import type BigNumber from "bignumber.js";
 import type { AcexError } from "../errors.ts";
-import type { MarketFreshness, SubscriptionActivity, Venue } from "./shared.ts";
+import type {
+  EventStreamOptions,
+  MarketFreshness,
+  SubscriptionActivity,
+  Venue,
+} from "./shared.ts";
 
 export type MarketType = "spot" | "swap" | "future";
 
@@ -170,12 +175,22 @@ export type MarketEvent =
   | MarketStatusChangedEvent;
 
 export interface MarketEventStreams {
-  l1BookUpdates(filter?: MarketEventFilter): AsyncIterable<L1BookUpdatedEvent>;
+  l1BookUpdates(
+    filter?: MarketEventFilter,
+    options?: EventStreamOptions,
+  ): AsyncIterable<L1BookUpdatedEvent>;
   fundingRateUpdates(
     filter?: MarketEventFilter,
+    options?: EventStreamOptions,
   ): AsyncIterable<FundingRateUpdatedEvent>;
-  status(filter?: MarketEventFilter): AsyncIterable<MarketStatusChangedEvent>;
-  all(filter?: MarketEventFilter): AsyncIterable<MarketEvent>;
+  status(
+    filter?: MarketEventFilter,
+    options?: EventStreamOptions,
+  ): AsyncIterable<MarketStatusChangedEvent>;
+  all(
+    filter?: MarketEventFilter,
+    options?: EventStreamOptions,
+  ): AsyncIterable<MarketEvent>;
 }
 
 export interface MarketManager {

package/src/types/order.ts

@@ -1,5 +1,6 @@
 import type { PositionSide } from "./account.ts";
 import type {
+  BufferedEventStreamOptions,
   PrivateRuntimeReason,
   PrivateRuntimeStatus,
   SubscriptionActivity,
@@ -160,8 +161,14 @@ export type OrderEvent =
   | OrderSnapshotReplacedEvent;
 
 export interface OrderEventStreams {
-  updates(filter?: OrderEventFilter): AsyncIterable<OrderEvent>;
-  status(filter?: OrderEventFilter): AsyncIterable<OrderStatusChangedEvent>;
+  updates(
+    filter?: OrderEventFilter,
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<OrderEvent>;
+  status(
+    filter?: OrderEventFilter,
+    options?: BufferedEventStreamOptions,
+  ): AsyncIterable<OrderStatusChangedEvent>;
 }
 
 export interface OrderManager {

package/src/types/shared.ts

@@ -175,11 +175,24 @@ export interface StopOptions {
   timeoutMs?: number;
 }
 
+export type EventStreamMode = "buffer" | "conflate";
+
+export interface EventStreamOptions {
+  mode?: EventStreamMode;
+  maxBuffer?: number;
+}
+
+export interface BufferedEventStreamOptions {
+  maxBuffer?: number;
+}
+
 export interface AcexInternalError {
   source: "client" | "market" | "account" | "order" | "adapter" | "runtime";
   venue?: Venue;
   accountId?: string;
   symbol?: string;
+  stream?: string;
+  maxBuffer?: number;
   error: Error;
   ts: number;
 }