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

package/dist/adapters/base-redis.mjs

@@ -0,0 +1,106 @@
+import { RPCJsonSerializer } from '@orpc/client';
+import { stringifyJSON, once, parseEmptyableJSON } from '@orpc/shared';
+import { unwrapEvent, withEventMeta, getEventMeta } from '@standard-server/core';
+import { P as Publisher } from '../shared/publisher.DcPG7zl6.mjs';
+
+const PUBLISH_SCRIPT = `local id=redis.call('XADD',KEYS[1],'*','data',ARGV[1]) if ARGV[2] then redis.call('XTRIM',KEYS[1],'MINID',ARGV[2],ARGV[3]) redis.call('EXPIRE',KEYS[1],ARGV[4]) end redis.call('PUBLISH',KEYS[1],'{"data":'..ARGV[1]..',"id":"'..id..'"}')`;
+class BaseRedisPublisher extends Publisher {
+  prefix;
+  serializer;
+  resumeEnabled;
+  resumeSeconds;
+  /**
+   * Tests switch this to `=` for deterministic trimming.
+   */
+  xTrimExactness = "~";
+  lastTrimTimes = /* @__PURE__ */ new Map();
+  constructor({ prefix, serializer, resume, ...options } = {}) {
+    super(options);
+    this.prefix = prefix ?? "";
+    this.serializer = serializer ?? new RPCJsonSerializer();
+    this.resumeEnabled = resume?.enabled ?? false;
+    this.resumeSeconds = resume?.seconds ?? 300;
+  }
+  async publish(event, payload) {
+    const channel = `${this.prefix}${event}`;
+    const data = this.serializePayload(payload);
+    if (!this.resumeEnabled) {
+      await this.publishMessage(channel, stringifyJSON({ data }));
+      return;
+    }
+    const now = Date.now();
+    const windowMs = this.resumeSeconds * 1e3;
+    for (const [trimmedChannel, trimTime] of this.lastTrimTimes) {
+      if (trimTime + windowMs >= now) {
+        break;
+      }
+      this.lastTrimTimes.delete(trimmedChannel);
+    }
+    const args = [stringifyJSON(data)];
+    if (!this.lastTrimTimes.has(channel)) {
+      this.lastTrimTimes.set(channel, now);
+      args.push(
+        this.xTrimExactness,
+        `${now - windowMs}-0`,
+        // 2x so entries added late in a window outlive it until the next trim refreshes the TTL.
+        String(this.resumeSeconds * 2)
+      );
+    }
+    await this.evalScript(PUBLISH_SCRIPT, [channel], args);
+  }
+  async subscribeListener(event, listener, { lastEventId, onError } = {}) {
+    const channel = `${this.prefix}${event}`;
+    let pendingPayloads = [];
+    const resumedIds = /* @__PURE__ */ new Set();
+    const deduplicatingListener = (payload) => {
+      if (pendingPayloads) {
+        pendingPayloads.push(payload);
+        return;
+      }
+      const id = getEventMeta(payload)?.id;
+      if (id === void 0 || !resumedIds.has(id)) {
+        listener(payload);
+      }
+    };
+    const messageListener = (message) => {
+      try {
+        const { id, data } = parseIfText(message);
+        deduplicatingListener(this.deserializePayload(id, data));
+      } catch (error) {
+        onError?.(error);
+      }
+    };
+    const unsubscribe = await this.subscribeChannel(channel, messageListener, onError);
+    try {
+      if (this.resumeEnabled && lastEventId !== void 0) {
+        for (const { id, data } of await this.readStreamEntries(channel, lastEventId)) {
+          resumedIds.add(id);
+          listener(this.deserializePayload(id, parseIfText(data)));
+        }
+      }
+      const pending = pendingPayloads;
+      pendingPayloads = void 0;
+      pending.forEach(deduplicatingListener);
+    } catch (error) {
+      await unsubscribe();
+      throw error;
+    }
+    return once(unsubscribe);
+  }
+  serializePayload(payload) {
+    const [original, meta] = unwrapEvent(payload);
+    const { json, meta: jsonMeta } = this.serializer.serialize(original);
+    return { payload: { json, meta: jsonMeta }, meta };
+  }
+  deserializePayload(id, { payload, meta }) {
+    return withEventMeta(
+      this.serializer.deserialize(payload),
+      id === void 0 ? { ...meta } : { ...meta, id }
+    );
+  }
+}
+function parseIfText(value) {
+  return typeof value === "string" ? parseEmptyableJSON(value) : value;
+}
+
+export { BaseRedisPublisher };

package/dist/adapters/memory.d.mts

@@ -3,16 +3,16 @@ import '@orpc/shared';
 
 interface MemoryPublisherOptions extends PublisherOptions {
     /**
-     * Configuration for event replay support.
+     * Configuration for event resume support.
      *
      * When enabled, published events are temporarily stored so new
      * subscribers can resume from a previous position using `lastEventId`.
      *
      * @default { enabled: false }
      */
-    replay?: {
+    resume?: {
         /**
-         * Whether event replay support is enabled.
+         * Whether event resume support is enabled.
          *
          * When enabled, published events are temporarily stored so new
          * subscribers can resume from a previous position using `lastEventId`.
@@ -21,7 +21,7 @@ interface MemoryPublisherOptions extends PublisherOptions {
          */
         enabled: boolean;
         /**
-         * How long (in seconds) to retain events for replay.
+         * How long (in seconds) to retain events for resume.
          *
          * Expired events are cleaned up lazily for performance reasons, so
          * some events may remain available slightly longer than this period.
@@ -31,13 +31,19 @@ interface MemoryPublisherOptions extends PublisherOptions {
         seconds?: number;
     };
 }
+/**
+ * Publisher adapter backed by in-memory storage, with optional resume support.
+ * Events are delivered to subscribers within the same process only.
+ *
+ * @see {@link https://orpc.dev/docs/helpers/publisher#adapters | Publisher Helpers - Adapters}
+ */
 declare class MemoryPublisher<T extends Record<string, object>> extends Publisher<T> {
     private readonly listenersMap;
     private readonly idGenerator;
     private readonly eventsMap;
-    private readonly replayEnabled;
-    private readonly replaySeconds;
-    constructor({ replay, ...options }?: MemoryPublisherOptions);
+    private readonly resumeEnabled;
+    private readonly resumeSeconds;
+    constructor({ resume, ...options }?: MemoryPublisherOptions);
     publish<K extends keyof T & string>(event: K, payload: T[K]): Promise<void>;
     protected subscribeListener<K extends keyof T & string>(event: K, listener: (payload: T[K]) => void, options?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
     private lastCleanupTime;

package/dist/adapters/memory.d.ts

@@ -3,16 +3,16 @@ import '@orpc/shared';
 
 interface MemoryPublisherOptions extends PublisherOptions {
     /**
-     * Configuration for event replay support.
+     * Configuration for event resume support.
      *
      * When enabled, published events are temporarily stored so new
      * subscribers can resume from a previous position using `lastEventId`.
      *
      * @default { enabled: false }
      */
-    replay?: {
+    resume?: {
         /**
-         * Whether event replay support is enabled.
+         * Whether event resume support is enabled.
          *
          * When enabled, published events are temporarily stored so new
          * subscribers can resume from a previous position using `lastEventId`.
@@ -21,7 +21,7 @@ interface MemoryPublisherOptions extends PublisherOptions {
          */
         enabled: boolean;
         /**
-         * How long (in seconds) to retain events for replay.
+         * How long (in seconds) to retain events for resume.
          *
          * Expired events are cleaned up lazily for performance reasons, so
          * some events may remain available slightly longer than this period.
@@ -31,13 +31,19 @@ interface MemoryPublisherOptions extends PublisherOptions {
         seconds?: number;
     };
 }
+/**
+ * Publisher adapter backed by in-memory storage, with optional resume support.
+ * Events are delivered to subscribers within the same process only.
+ *
+ * @see {@link https://orpc.dev/docs/helpers/publisher#adapters | Publisher Helpers - Adapters}
+ */
 declare class MemoryPublisher<T extends Record<string, object>> extends Publisher<T> {
     private readonly listenersMap;
     private readonly idGenerator;
     private readonly eventsMap;
-    private readonly replayEnabled;
-    private readonly replaySeconds;
-    constructor({ replay, ...options }?: MemoryPublisherOptions);
+    private readonly resumeEnabled;
+    private readonly resumeSeconds;
+    constructor({ resume, ...options }?: MemoryPublisherOptions);
     publish<K extends keyof T & string>(event: K, payload: T[K]): Promise<void>;
     protected subscribeListener<K extends keyof T & string>(event: K, listener: (payload: T[K]) => void, options?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
     private lastCleanupTime;

package/dist/adapters/memory.mjs

@@ -1,22 +1,22 @@
 import { SequentialIdGenerator, once, compareSequentialIds } from '@orpc/shared';
-import { unwrapEvent, withEventMeta, getEventMeta } from '@standardserver/core';
-import { P as Publisher } from '../shared/publisher.BSQf8ybR.mjs';
+import { unwrapEvent, withEventMeta, getEventMeta } from '@standard-server/core';
+import { P as Publisher } from '../shared/publisher.DcPG7zl6.mjs';
 
 class MemoryPublisher extends Publisher {
   listenersMap = /* @__PURE__ */ new Map();
   idGenerator = new SequentialIdGenerator();
   eventsMap = /* @__PURE__ */ new Map();
-  replayEnabled;
-  replaySeconds;
-  constructor({ replay, ...options } = {}) {
+  resumeEnabled;
+  resumeSeconds;
+  constructor({ resume, ...options } = {}) {
     super(options);
-    this.replayEnabled = replay?.enabled ?? false;
-    this.replaySeconds = replay?.seconds ?? 300;
+    this.resumeEnabled = resume?.enabled ?? false;
+    this.resumeSeconds = resume?.seconds ?? 300;
   }
   async publish(event, payload) {
     this.cleanup();
-    if (this.replayEnabled) {
-      const expiresAt = Date.now() + this.replaySeconds * 1e3;
+    if (this.resumeEnabled) {
+      const expiresAt = Date.now() + this.resumeSeconds * 1e3;
       let bucket = this.eventsMap.get(event);
       if (!bucket) {
         this.eventsMap.set(event, bucket = []);
@@ -25,15 +25,14 @@ class MemoryPublisher extends Publisher {
       payload = withEventMeta(original, { ...meta, id: this.idGenerator.generate() });
       bucket.push({ expiresAt, payload });
     }
-    const listeners = this.listenersMap.get(event);
-    listeners?.forEach((listener) => listener(payload));
+    this.listenersMap.get(event)?.forEach((listener) => listener(payload));
   }
   async subscribeListener(event, listener, options) {
     this.cleanup();
-    if (this.replayEnabled && options?.lastEventId !== void 0) {
+    if (this.resumeEnabled && options?.lastEventId !== void 0) {
       const bucket = this.eventsMap.get(event);
       if (bucket?.length) {
-        const startIdx = findReplayStartIndex(bucket, options.lastEventId);
+        const startIdx = findResumeStartIndex(bucket, options.lastEventId);
         for (let i = startIdx; i < bucket.length; i++) {
           listener(bucket[i].payload);
         }
@@ -45,19 +44,23 @@ class MemoryPublisher extends Publisher {
     }
     listeners.push(listener);
     return once(async () => {
-      listeners.splice(listeners.indexOf(listener), 1);
-      if (listeners.length === 0) {
+      const current = this.listenersMap.get(event);
+      const index = current.indexOf(listener);
+      const remaining = current.filter((_, i) => i !== index);
+      if (remaining.length === 0) {
         this.listenersMap.delete(event);
+      } else {
+        this.listenersMap.set(event, remaining);
       }
     });
   }
   lastCleanupTime = 0;
   cleanup() {
-    if (!this.replayEnabled) {
+    if (!this.resumeEnabled) {
       return;
     }
     const now = Date.now();
-    if (now - this.lastCleanupTime < this.replaySeconds * 1e3) {
+    if (now - this.lastCleanupTime < this.resumeSeconds * 1e3) {
       return;
     }
     this.lastCleanupTime = now;
@@ -69,7 +72,7 @@ class MemoryPublisher extends Publisher {
     }
   }
 }
-function findReplayStartIndex(bucket, lastEventId) {
+function findResumeStartIndex(bucket, lastEventId) {
   let lo = 0;
   let hi = bucket.length;
   while (lo < hi) {

package/dist/adapters/redis.d.mts

@@ -1,9 +1,10 @@
 import { RedisClientType } from 'redis';
-import { Publisher, PublisherOptions, PublisherSubscribeListenerOptions } from '../index.mjs';
-import { RPCSerializer } from '@orpc/client';
+import { BaseRedisPublisher, BaseRedisPublisherOptions, RedisStreamEntry } from './base-redis.mjs';
 import '@orpc/shared';
+import '../index.mjs';
+import '@orpc/client';
 
-interface RedisPublisherOptions extends PublisherOptions {
+interface RedisPublisherOptions extends BaseRedisPublisherOptions {
     /**
      * Redis subscriber instance.
      * Pub/Sub takes over the connection, so a client with subscriptions
@@ -12,63 +13,26 @@ interface RedisPublisherOptions extends PublisherOptions {
      * @default redis.duplicate()
      */
     subscriber?: undefined | RedisClientType<any, any, any, any, any>;
-    /**
-     * 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;
-    };
 }
-declare class RedisPublisher<T extends Record<string, object>> extends Publisher<T> {
+/**
+ * Publisher adapter for Redis. Distributes events across processes via
+ * Redis Pub/Sub, with optional resume support backed by Redis Streams.
+ *
+ * @see {@link https://orpc.dev/docs/helpers/publisher#adapters | Publisher Helpers - Adapters}
+ */
+declare class RedisPublisher<T extends Record<string, object>> extends BaseRedisPublisher<T> {
     private readonly redis;
     private readonly subscriber;
-    private readonly prefix;
-    private readonly serializer;
-    private readonly replayEnabled;
-    private readonly replaySeconds;
     /**
-     * The exactness of the `XTRIM` command.
-     * Used for testing purpose.
+     * node-redis applies `keyPrefix` to keys but not channels, while the publish script
+     * publishes on its key, so channels need the same prefix.
      */
-    private readonly xTrimExactness;
-    constructor(redis: RedisClientType<any, any, any, any, any>, options?: RedisPublisherOptions);
-    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 serializePayload;
-    private deserializePayload;
+    private readonly channelPrefix;
+    constructor(redis: RedisClientType<any, any, any, any, any>, { subscriber, ...options }?: RedisPublisherOptions);
+    protected publishMessage(channel: string, message: string): Promise<void>;
+    protected subscribeChannel(channel: string, listener: (message: unknown) => void): Promise<() => Promise<void>>;
+    protected evalScript(script: string, keys: string[], args: string[]): Promise<unknown>;
+    protected readStreamEntries(key: string, lastId: string): Promise<RedisStreamEntry[]>;
 }
 
 export { RedisPublisher };

package/dist/adapters/redis.d.ts

@@ -1,9 +1,10 @@
 import { RedisClientType } from 'redis';
-import { Publisher, PublisherOptions, PublisherSubscribeListenerOptions } from '../index.js';
-import { RPCSerializer } from '@orpc/client';
+import { BaseRedisPublisher, BaseRedisPublisherOptions, RedisStreamEntry } from './base-redis.js';
 import '@orpc/shared';
+import '../index.js';
+import '@orpc/client';
 
-interface RedisPublisherOptions extends PublisherOptions {
+interface RedisPublisherOptions extends BaseRedisPublisherOptions {
     /**
      * Redis subscriber instance.
      * Pub/Sub takes over the connection, so a client with subscriptions
@@ -12,63 +13,26 @@ interface RedisPublisherOptions extends PublisherOptions {
      * @default redis.duplicate()
      */
     subscriber?: undefined | RedisClientType<any, any, any, any, any>;
-    /**
-     * 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;
-    };
 }
-declare class RedisPublisher<T extends Record<string, object>> extends Publisher<T> {
+/**
+ * Publisher adapter for Redis. Distributes events across processes via
+ * Redis Pub/Sub, with optional resume support backed by Redis Streams.
+ *
+ * @see {@link https://orpc.dev/docs/helpers/publisher#adapters | Publisher Helpers - Adapters}
+ */
+declare class RedisPublisher<T extends Record<string, object>> extends BaseRedisPublisher<T> {
     private readonly redis;
     private readonly subscriber;
-    private readonly prefix;
-    private readonly serializer;
-    private readonly replayEnabled;
-    private readonly replaySeconds;
     /**
-     * The exactness of the `XTRIM` command.
-     * Used for testing purpose.
+     * node-redis applies `keyPrefix` to keys but not channels, while the publish script
+     * publishes on its key, so channels need the same prefix.
      */
-    private readonly xTrimExactness;
-    constructor(redis: RedisClientType<any, any, any, any, any>, options?: RedisPublisherOptions);
-    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 serializePayload;
-    private deserializePayload;
+    private readonly channelPrefix;
+    constructor(redis: RedisClientType<any, any, any, any, any>, { subscriber, ...options }?: RedisPublisherOptions);
+    protected publishMessage(channel: string, message: string): Promise<void>;
+    protected subscribeChannel(channel: string, listener: (message: unknown) => void): Promise<() => Promise<void>>;
+    protected evalScript(script: string, keys: string[], args: string[]): Promise<unknown>;
+    protected readStreamEntries(key: string, lastId: string): Promise<RedisStreamEntry[]>;
 }
 
 export { RedisPublisher };

package/dist/adapters/redis.mjs

@@ -1,124 +1,52 @@
-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.DcPG7zl6.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();
+    const keyPrefix = redis.options?.keyPrefix;
+    if (keyPrefix !== void 0 && typeof keyPrefix !== "string") {
+      throw new TypeError("RedisPublisher only supports a string keyPrefix on the Redis client.");
+    }
+    this.subscriber = subscriber ?? redis.duplicate();
+    this.channelPrefix = keyPrefix ?? "";
   }
   subscriber;
-  prefix;
-  serializer;
-  replayEnabled;
-  replaySeconds;
   /**
-   * The exactness of the `XTRIM` command.
-   * Used for testing purpose.
+   * node-redis applies `keyPrefix` to keys but not channels, while the publish script
+   * publishes on its key, so channels need the same prefix.
    */
-  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 }));
+  channelPrefix;
+  async publishMessage(channel, message) {
+    await connectIfNeeded(this.redis);
+    await this.redis.publish(`${this.channelPrefix}${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) {
+    const prefixedChannel = `${this.channelPrefix}${channel}`;
+    await connectIfNeeded(this.subscriber);
+    await this.subscriber.subscribe(prefixedChannel, listener);
+    return async () => {
+      await this.subscriber.unsubscribe(prefixedChannel, 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;
-    }
-    return once(async () => {
-      await this.subscriber.unsubscribe(redisKey, redisListener);
-    });
   }
-  serializePayload(payload) {
-    const [original, meta] = unwrapEvent(payload);
-    return { payload: this.serializer.serialize(original, { useFormDataForBlobFields: false }), meta };
+  async evalScript(script, keys, args) {
+    await connectIfNeeded(this.redis);
+    return await this.redis.eval(script, { keys, arguments: args });
   }
-  deserializePayload(id, { payload, meta }) {
-    return withEventMeta(
-      this.serializer.deserialize(payload),
-      id === void 0 ? { ...meta } : { ...meta, id }
-    );
+  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 }));
+  }
+}
+async function connectIfNeeded(client) {
+  if (!client.isOpen) {
+    await client.connect();
   }
 }