@orpc/publisher 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/adapters/redis.mjs

@@ -1,124 +1,45 @@
-import { RPCSerializer } from '@orpc/client';
-import { stringifyJSON, parseEmptyableJSON, once } from '@orpc/shared';
-import { unwrapEvent, withEventMeta, getEventMeta } from '@standardserver/core';
-import { P as Publisher } from '../shared/publisher.BSQf8ybR.mjs';
+import { BaseRedisPublisher } from './base-redis.mjs';
+import '@orpc/client';
+import '@orpc/shared';
+import '@standard-server/core';
+import '../shared/publisher.BSQf8ybR.mjs';
 
-class RedisPublisher extends Publisher {
-  constructor(redis, options = {}) {
+class RedisPublisher extends BaseRedisPublisher {
+  constructor(redis, { subscriber, ...options } = {}) {
     super(options);
     this.redis = redis;
-    this.prefix = options.prefix ?? "";
-    this.serializer = options.serializer ?? new RPCSerializer();
-    this.replayEnabled = options.replay?.enabled ?? false;
-    this.replaySeconds = options.replay?.seconds ?? 300;
-    this.subscriber = options.subscriber ?? redis.duplicate();
+    this.subscriber = subscriber ?? redis.duplicate();
   }
   subscriber;
-  prefix;
-  serializer;
-  replayEnabled;
-  replaySeconds;
-  /**
-   * The exactness of the `XTRIM` command.
-   * Used for testing purpose.
-   */
-  xTrimExactness = "~";
-  firstPublishTimeMap = /* @__PURE__ */ new Map();
-  async publish(event, payload) {
-    const redisKey = `${this.prefix}${event}`;
-    const data = this.serializePayload(payload);
-    let id;
-    if (!this.redis.isOpen) {
-      await this.redis.connect();
-    }
-    if (this.replayEnabled) {
-      const now = Date.now();
-      for (const [event2, firstPublishTime] of this.firstPublishTimeMap) {
-        if (firstPublishTime + this.replaySeconds * 1e3 < now) {
-          this.firstPublishTimeMap.delete(event2);
-        }
-      }
-      if (!this.firstPublishTimeMap.has(event)) {
-        this.firstPublishTimeMap.set(event, now);
-        const result = await this.redis.multi().xAdd(redisKey, "*", { data: stringifyJSON(data) }).xTrim(redisKey, "MINID", `${now - this.replaySeconds * 1e3}-0`, { strategyModifier: this.xTrimExactness }).expire(redisKey, this.replaySeconds * 2).exec();
-        id = result[0];
-      } else {
-        id = await this.redis.xAdd(redisKey, "*", { data: stringifyJSON(data) });
-      }
-    }
-    await this.redis.publish(redisKey, stringifyJSON({ data, id }));
+  async publishMessage(channel, message) {
+    await connectIfNeeded(this.redis);
+    await this.redis.publish(channel, message);
   }
-  async subscribeListener(event, originalListener, { lastEventId, onError } = {}) {
-    const redisKey = `${this.prefix}${event}`;
-    if (!this.subscriber.isOpen) {
-      await this.subscriber.connect();
-    }
-    let pendingPayloads = [];
-    const replayedIds = /* @__PURE__ */ new Set();
-    const deduplicatingListener = (payload) => {
-      if (pendingPayloads) {
-        pendingPayloads.push(payload);
-        return;
-      }
-      const id = getEventMeta(payload)?.id;
-      if (id !== void 0 && replayedIds.has(id)) {
-        return;
-      }
-      originalListener(payload);
+  async subscribeChannel(channel, listener) {
+    await connectIfNeeded(this.subscriber);
+    await this.subscriber.subscribe(channel, listener);
+    return async () => {
+      await this.subscriber.unsubscribe(channel, listener);
     };
-    const redisListener = (message) => {
-      try {
-        const { id, data } = parseEmptyableJSON(message);
-        const payload = this.deserializePayload(id, data);
-        deduplicatingListener(payload);
-      } catch (error) {
-        onError?.(error);
-      }
-    };
-    try {
-      const subscribePromise = this.subscriber.subscribe(redisKey, redisListener);
-      try {
-        if (this.replayEnabled && lastEventId !== void 0) {
-          if (!this.redis.isOpen) {
-            await this.redis.connect();
-          }
-          const results = await this.redis.xRead({ key: redisKey, id: lastEventId });
-          if (results && results[0]) {
-            const { messages } = results[0];
-            for (const { id, message } of messages) {
-              const rawData = message.data;
-              const data = parseEmptyableJSON(rawData);
-              const payload = this.deserializePayload(id, data);
-              replayedIds.add(id);
-              originalListener(payload);
-            }
-          }
-        }
-      } finally {
-        const pending = pendingPayloads;
-        pendingPayloads = void 0;
-        for (const payload of pending) {
-          deduplicatingListener(payload);
-        }
-      }
-      await subscribePromise;
-    } catch (error) {
-      await this.subscriber.unsubscribe(redisKey, redisListener);
-      throw error;
+  }
+  async addStreamEntry(key, data, trim) {
+    await connectIfNeeded(this.redis);
+    if (!trim) {
+      return await this.redis.xAdd(key, "*", { data });
     }
-    return once(async () => {
-      await this.subscriber.unsubscribe(redisKey, redisListener);
-    });
+    const [id] = await this.redis.multi().xAdd(key, "*", { data }).xTrim(key, "MINID", trim.minId, { strategyModifier: trim.exactness }).expire(key, trim.expireSeconds).exec();
+    return id;
   }
-  serializePayload(payload) {
-    const [original, meta] = unwrapEvent(payload);
-    return { payload: this.serializer.serialize(original, { useFormDataForBlobFields: false }), meta };
+  async readStreamEntries(key, lastId) {
+    await connectIfNeeded(this.redis);
+    const results = await this.redis.xRead({ key, id: lastId });
+    const entries = results?.[0]?.messages ?? [];
+    return entries.map(({ id, message }) => ({ id, data: message.data }));
   }
-  deserializePayload(id, { payload, meta }) {
-    return withEventMeta(
-      this.serializer.deserialize(payload),
-      id === void 0 ? { ...meta } : { ...meta, id }
-    );
+}
+async function connectIfNeeded(client) {
+  if (!client.isOpen) {
+    await client.connect();
   }
 }
 

package/dist/adapters/upstash.d.mts

@@ -1,71 +1,30 @@
+import { ThrowableError } from '@orpc/shared';
 import { Redis } from '@upstash/redis';
-import { Publisher, PublisherOptions, PublisherSubscribeListenerOptions } from '../index.mjs';
-import { RPCSerializer } from '@orpc/client';
-import '@orpc/shared';
+import { BaseRedisPublisher, BaseRedisPublisherOptions, RedisStreamTrimOptions, RedisStreamEntry } from './base-redis.mjs';
+import '../index.mjs';
+import '@orpc/client';
 
-interface UpstashPublisherOptions extends PublisherOptions {
-    /**
-     * The prefix to use for Redis keys.
-     */
-    prefix?: string;
-    /**
-     * Serializer for serialize and deserialize payloads.
-     *
-     * @default RPCSerializer
-     */
-    serializer?: undefined | Pick<RPCSerializer, keyof RPCSerializer>;
-    /**
-     * Configuration for event replay support.
-     *
-     * When enabled, published events are temporarily stored so new
-     * subscribers can resume from a previous position using `lastEventId`.
-     *
-     * @default { enabled: false }
-     */
-    replay?: {
-        /**
-         * Whether event replay support is enabled.
-         *
-         * When enabled, published events are temporarily stored so new
-         * subscribers can resume from a previous position using `lastEventId`.
-         *
-         * @default false
-         */
-        enabled: boolean;
-        /**
-         * How long (in seconds) to retain events for replay.
-         *
-         * Expired events are cleaned up lazily for performance reasons, so
-         * some events may remain available slightly longer than this period.
-         *
-         * @default 300 (5 min)
-         */
-        seconds?: number;
-    };
+interface UpstashPublisherOptions extends BaseRedisPublisherOptions {
 }
-declare class UpstashPublisher<T extends Record<string, object>> extends Publisher<T> {
+/**
+ * Publisher adapter for Upstash Redis. Distributes events across processes via
+ * Upstash Pub/Sub, with optional resume support backed by Redis Streams.
+ *
+ * @see {@link https://orpc.dev/docs/helpers/publisher#adapters | Publisher Helpers - Adapters}
+ */
+declare class UpstashPublisher<T extends Record<string, object>> extends BaseRedisPublisher<T> {
     private readonly redis;
-    private readonly prefix;
-    private readonly serializer;
     private readonly listenersMap;
     private readonly onErrorsMap;
     private readonly subscriptionMap;
-    private readonly replayEnabled;
-    private readonly replaySeconds;
-    /**
-     * The exactness of the `XTRIM` command.
-     * Used for testing purpose.
-     */
-    private readonly xTrimExactness;
-    constructor(redis: Redis, { replay, prefix, serializer, ...options }?: UpstashPublisherOptions);
-    private readonly firstPublishTimeMap;
-    publish<K extends keyof T & string>(event: K, payload: T[K]): Promise<void>;
-    protected subscribeListener<K extends keyof T & string>(event: K, originalListener: (payload: T[K]) => void, { lastEventId, onError }?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
     private readonly pendingSubscriptionsMap;
-    private subscribeEvent;
-    private unsubscribeEvent;
-    private serializePayload;
-    private deserializePayload;
+    constructor(redis: Redis, options?: UpstashPublisherOptions);
+    protected publishMessage(channel: string, message: string): Promise<void>;
+    protected subscribeChannel(channel: string, listener: (message: unknown) => void, onError?: (error: ThrowableError) => void): Promise<() => Promise<void>>;
+    protected addStreamEntry(key: string, data: string, trim?: RedisStreamTrimOptions): Promise<string>;
+    protected readStreamEntries(key: string, lastId: string): Promise<RedisStreamEntry[]>;
+    private subscribeIfNeeded;
+    private unsubscribeIfUnused;
 }
 
 export { UpstashPublisher };

package/dist/adapters/upstash.d.ts

@@ -1,71 +1,30 @@
+import { ThrowableError } from '@orpc/shared';
 import { Redis } from '@upstash/redis';
-import { Publisher, PublisherOptions, PublisherSubscribeListenerOptions } from '../index.js';
-import { RPCSerializer } from '@orpc/client';
-import '@orpc/shared';
+import { BaseRedisPublisher, BaseRedisPublisherOptions, RedisStreamTrimOptions, RedisStreamEntry } from './base-redis.js';
+import '../index.js';
+import '@orpc/client';
 
-interface UpstashPublisherOptions extends PublisherOptions {
-    /**
-     * The prefix to use for Redis keys.
-     */
-    prefix?: string;
-    /**
-     * Serializer for serialize and deserialize payloads.
-     *
-     * @default RPCSerializer
-     */
-    serializer?: undefined | Pick<RPCSerializer, keyof RPCSerializer>;
-    /**
-     * Configuration for event replay support.
-     *
-     * When enabled, published events are temporarily stored so new
-     * subscribers can resume from a previous position using `lastEventId`.
-     *
-     * @default { enabled: false }
-     */
-    replay?: {
-        /**
-         * Whether event replay support is enabled.
-         *
-         * When enabled, published events are temporarily stored so new
-         * subscribers can resume from a previous position using `lastEventId`.
-         *
-         * @default false
-         */
-        enabled: boolean;
-        /**
-         * How long (in seconds) to retain events for replay.
-         *
-         * Expired events are cleaned up lazily for performance reasons, so
-         * some events may remain available slightly longer than this period.
-         *
-         * @default 300 (5 min)
-         */
-        seconds?: number;
-    };
+interface UpstashPublisherOptions extends BaseRedisPublisherOptions {
 }
-declare class UpstashPublisher<T extends Record<string, object>> extends Publisher<T> {
+/**
+ * Publisher adapter for Upstash Redis. Distributes events across processes via
+ * Upstash Pub/Sub, with optional resume support backed by Redis Streams.
+ *
+ * @see {@link https://orpc.dev/docs/helpers/publisher#adapters | Publisher Helpers - Adapters}
+ */
+declare class UpstashPublisher<T extends Record<string, object>> extends BaseRedisPublisher<T> {
     private readonly redis;
-    private readonly prefix;
-    private readonly serializer;
     private readonly listenersMap;
     private readonly onErrorsMap;
     private readonly subscriptionMap;
-    private readonly replayEnabled;
-    private readonly replaySeconds;
-    /**
-     * The exactness of the `XTRIM` command.
-     * Used for testing purpose.
-     */
-    private readonly xTrimExactness;
-    constructor(redis: Redis, { replay, prefix, serializer, ...options }?: UpstashPublisherOptions);
-    private readonly firstPublishTimeMap;
-    publish<K extends keyof T & string>(event: K, payload: T[K]): Promise<void>;
-    protected subscribeListener<K extends keyof T & string>(event: K, originalListener: (payload: T[K]) => void, { lastEventId, onError }?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
     private readonly pendingSubscriptionsMap;
-    private subscribeEvent;
-    private unsubscribeEvent;
-    private serializePayload;
-    private deserializePayload;
+    constructor(redis: Redis, options?: UpstashPublisherOptions);
+    protected publishMessage(channel: string, message: string): Promise<void>;
+    protected subscribeChannel(channel: string, listener: (message: unknown) => void, onError?: (error: ThrowableError) => void): Promise<() => Promise<void>>;
+    protected addStreamEntry(key: string, data: string, trim?: RedisStreamTrimOptions): Promise<string>;
+    protected readStreamEntries(key: string, lastId: string): Promise<RedisStreamEntry[]>;
+    private subscribeIfNeeded;
+    private unsubscribeIfUnused;
 }
 
 export { UpstashPublisher };

package/dist/adapters/upstash.mjs

@@ -1,199 +1,104 @@
-import { RPCSerializer } from '@orpc/client';
-import { once } from '@orpc/shared';
-import { unwrapEvent, withEventMeta, getEventMeta } from '@standardserver/core';
-import { P as Publisher } from '../shared/publisher.BSQf8ybR.mjs';
+import { promiseWithResolvers } from '@orpc/shared';
+import { BaseRedisPublisher } from './base-redis.mjs';
+import '@orpc/client';
+import '@standard-server/core';
+import '../shared/publisher.BSQf8ybR.mjs';
 
-class UpstashPublisher extends Publisher {
-  constructor(redis, { replay, prefix, serializer, ...options } = {}) {
+class UpstashPublisher extends BaseRedisPublisher {
+  constructor(redis, options = {}) {
     super(options);
     this.redis = redis;
-    this.prefix = prefix ?? "";
-    this.replayEnabled = replay?.enabled ?? false;
-    this.replaySeconds = replay?.seconds ?? 300;
-    this.serializer = serializer ?? new RPCSerializer();
   }
-  prefix;
-  serializer;
   listenersMap = /* @__PURE__ */ new Map();
   onErrorsMap = /* @__PURE__ */ new Map();
   subscriptionMap = /* @__PURE__ */ new Map();
-  // Upstash subscription objects
-  replayEnabled;
-  replaySeconds;
-  /**
-   * The exactness of the `XTRIM` command.
-   * Used for testing purpose.
-   */
-  xTrimExactness = "~";
-  firstPublishTimeMap = /* @__PURE__ */ new Map();
-  async publish(event, payload) {
-    const redisKey = `${this.prefix}${event}`;
-    const data = this.serializePayload(payload);
-    let id;
-    if (this.replayEnabled) {
-      const now = Date.now();
-      for (const [event2, firstPublishTime] of this.firstPublishTimeMap) {
-        if (firstPublishTime + this.replaySeconds * 1e3 < now) {
-          this.firstPublishTimeMap.delete(event2);
-        }
-      }
-      if (!this.firstPublishTimeMap.has(event)) {
-        this.firstPublishTimeMap.set(event, now);
-        const results = await this.redis.multi().xadd(redisKey, "*", { data }).xtrim(redisKey, { strategy: "MINID", exactness: this.xTrimExactness, threshold: `${now - this.replaySeconds * 1e3}-0` }).expire(redisKey, this.replaySeconds * 2).exec();
-        id = results[0];
-      } else {
-        id = await this.redis.xadd(redisKey, "*", { data });
-      }
-    }
-    await this.redis.publish(redisKey, { id, data });
+  pendingSubscriptionsMap = /* @__PURE__ */ new Map();
+  async publishMessage(channel, message) {
+    await this.redis.publish(channel, message);
   }
-  async subscribeListener(event, originalListener, { lastEventId, onError } = {}) {
-    const redisKey = `${this.prefix}${event}`;
-    let pendingPayloads = [];
-    const replayedIds = /* @__PURE__ */ new Set();
-    const deduplicatingListener = (payload) => {
-      if (pendingPayloads) {
-        pendingPayloads.push(payload);
-        return;
-      }
-      const id = getEventMeta(payload)?.id;
-      if (id !== void 0 && replayedIds.has(id)) {
-        return;
-      }
-      originalListener(payload);
-    };
-    let listeners = this.listenersMap.get(event);
-    if (!listeners) {
-      this.listenersMap.set(event, listeners = []);
-    }
-    listeners.push(deduplicatingListener);
+  async subscribeChannel(channel, listener, onError) {
+    push(this.listenersMap, channel, listener);
     try {
-      const subscribeEventPromise = this.subscribeEvent(event);
-      try {
-        if (this.replayEnabled && lastEventId !== void 0) {
-          const results = await this.redis.xread(redisKey, lastEventId);
-          if (results && results[0]) {
-            const [_, items] = results[0];
-            for (const [id, fields] of items) {
-              const data = fields[1];
-              const payload = this.deserializePayload(id, data);
-              replayedIds.add(id);
-              originalListener(payload);
-            }
-          }
-        }
-      } finally {
-        const pending = pendingPayloads;
-        pendingPayloads = void 0;
-        for (const payload of pending) {
-          deduplicatingListener(payload);
-        }
-      }
-      await subscribeEventPromise;
+      await this.subscribeIfNeeded(channel);
     } catch (error) {
-      listeners.splice(listeners.indexOf(deduplicatingListener), 1);
-      if (listeners.length === 0) {
-        this.listenersMap.delete(event);
-      }
-      await this.unsubscribeEvent(event);
+      remove(this.listenersMap, channel, listener);
+      await this.unsubscribeIfUnused(channel);
       throw error;
     }
     if (onError) {
-      let onErrors = this.onErrorsMap.get(event);
-      if (!onErrors) {
-        this.onErrorsMap.set(event, onErrors = []);
-      }
-      onErrors.push(onError);
+      push(this.onErrorsMap, channel, onError);
     }
-    return once(async () => {
-      listeners.splice(listeners.indexOf(deduplicatingListener), 1);
+    return async () => {
+      remove(this.listenersMap, channel, listener);
       if (onError) {
-        const onErrors = this.onErrorsMap.get(event);
-        if (onErrors) {
-          onErrors.splice(onErrors.indexOf(onError), 1);
-        }
-      }
-      if (listeners.length === 0) {
-        this.listenersMap.delete(event);
-        this.onErrorsMap.delete(event);
+        remove(this.onErrorsMap, channel, onError);
       }
-      await this.unsubscribeEvent(event);
-    });
+      await this.unsubscribeIfUnused(channel);
+    };
   }
-  pendingSubscriptionsMap = /* @__PURE__ */ new Map();
-  async subscribeEvent(event) {
-    const redisKey = `${this.prefix}${event}`;
-    const pending = this.pendingSubscriptionsMap.get(event);
-    if (pending) {
-      try {
-        await pending;
-      } catch {
-      }
+  async addStreamEntry(key, data, trim) {
+    if (!trim) {
+      return this.redis.xadd(key, "*", { data });
     }
-    if (this.subscriptionMap.has(event)) {
+    const [id] = await this.redis.multi().xadd(key, "*", { data }).xtrim(key, { strategy: "MINID", exactness: trim.exactness, threshold: trim.minId }).expire(key, trim.expireSeconds).exec();
+    return id;
+  }
+  async readStreamEntries(key, lastId) {
+    const results = await this.redis.xread(key, lastId);
+    return results?.[0]?.[1].map(([id, fields]) => ({ id, data: fields[1] })) ?? [];
+  }
+  async subscribeIfNeeded(channel) {
+    while (this.pendingSubscriptionsMap.has(channel)) {
+      await this.pendingSubscriptionsMap.get(channel).catch(() => {
+      });
+    }
+    if (this.subscriptionMap.has(channel)) {
       return;
     }
-    const dispatchErrorForEvent = (error) => {
-      const onErrors = this.onErrorsMap.get(event);
-      onErrors?.forEach((onError) => onError(error));
-    };
-    const subscription = this.redis.subscribe(redisKey);
-    subscription.on("message", (message) => {
-      try {
-        const listeners = this.listenersMap.get(event);
-        if (listeners) {
-          const { id, data } = message.message;
-          const payload = this.deserializePayload(id, data);
-          listeners.forEach((listener) => listener(payload));
-        }
-      } catch (error) {
-        dispatchErrorForEvent(error);
-      }
-    });
-    let resolvePromise;
-    let rejectPromise;
-    const promise = new Promise((resolve, reject) => {
-      resolvePromise = resolve;
-      rejectPromise = reject;
-    });
+    const { promise, resolve, reject } = promiseWithResolvers();
+    const subscription = this.redis.subscribe(channel);
+    subscription.on("subscribe", () => resolve());
     subscription.on("error", (error) => {
-      rejectPromise(error);
-      dispatchErrorForEvent(error);
+      reject(error);
+      this.onErrorsMap.get(channel)?.slice().forEach((onError) => onError(error));
     });
-    subscription.on("subscribe", () => {
-      resolvePromise();
+    subscription.on("message", ({ message }) => {
+      this.listenersMap.get(channel)?.slice().forEach((listener) => listener(message));
     });
+    this.pendingSubscriptionsMap.set(channel, promise);
     try {
-      this.pendingSubscriptionsMap.set(event, promise);
       await promise;
-      this.subscriptionMap.set(event, subscription);
+      this.subscriptionMap.set(channel, subscription);
+    } catch (error) {
+      await subscription.unsubscribe();
+      throw error;
     } finally {
-      this.pendingSubscriptionsMap.delete(event);
+      this.pendingSubscriptionsMap.delete(channel);
     }
   }
-  async unsubscribeEvent(event) {
-    const pending = this.pendingSubscriptionsMap.get(event);
-    if (pending) {
-      try {
-        await pending;
-      } catch {
-      }
-    }
-    const subscription = this.subscriptionMap.get(event);
-    if (!this.listenersMap.has(event) && subscription) {
-      this.subscriptionMap.delete(event);
+  async unsubscribeIfUnused(channel) {
+    const subscription = this.subscriptionMap.get(channel);
+    if (subscription && !this.listenersMap.has(channel)) {
+      this.subscriptionMap.delete(channel);
       await subscription.unsubscribe();
     }
   }
-  serializePayload(payload) {
-    const [original, meta] = unwrapEvent(payload);
-    return { payload: this.serializer.serialize(original, { useFormDataForBlobFields: false }), meta };
+}
+function push(map, key, value) {
+  let values = map.get(key);
+  if (!values) {
+    map.set(key, values = []);
+  }
+  values.push(value);
+}
+function remove(map, key, value) {
+  const values = map.get(key);
+  const index = values?.indexOf(value) ?? -1;
+  if (index !== -1) {
+    values.splice(index, 1);
   }
-  deserializePayload(id, { payload, meta }) {
-    return withEventMeta(
-      this.serializer.deserialize(payload),
-      id === void 0 ? { ...meta } : { ...meta, id }
-    );
+  if (values?.length === 0) {
+    map.delete(key);
   }
 }
 

package/dist/index.d.mts

@@ -2,7 +2,7 @@ import { ThrowableError, AsyncIteratorClass } from '@orpc/shared';
 
 interface PublisherOptions {
     /**
-     * Maximum number of events to buffer for async iterator subscribers.
+     * Maximum number of events to buffer for AsyncIteratorObject subscribers.
      *
      * If the buffer exceeds this limit, the oldest event is dropped.
      * This prevents unbounded memory growth if consumers process events slowly.
@@ -68,7 +68,7 @@ declare abstract class Publisher<T extends Record<string, object>> {
      */
     subscribe<K extends keyof T & string>(event: K, listener: (payload: T[K]) => void, options?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
     /**
-     * Subscribes to a specific event using an async iterator.
+     * Subscribes to a specific event using an AsyncIteratorObject.
      * Useful for `for await...of` loops with optional buffering and abort support.
      *
      * @example

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import { ThrowableError, AsyncIteratorClass } from '@orpc/shared';
 
 interface PublisherOptions {
     /**
-     * Maximum number of events to buffer for async iterator subscribers.
+     * Maximum number of events to buffer for AsyncIteratorObject subscribers.
      *
      * If the buffer exceeds this limit, the oldest event is dropped.
      * This prevents unbounded memory growth if consumers process events slowly.
@@ -68,7 +68,7 @@ declare abstract class Publisher<T extends Record<string, object>> {
      */
     subscribe<K extends keyof T & string>(event: K, listener: (payload: T[K]) => void, options?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
     /**
-     * Subscribes to a specific event using an async iterator.
+     * Subscribes to a specific event using an AsyncIteratorObject.
      * Useful for `for await...of` loops with optional buffering and abort support.
      *
      * @example