@thru/replay 0.2.20 → 0.2.22

package/dist/index.cjs

@@ -3,20 +3,49 @@
 var protobuf = require('@bufbuild/protobuf');
 var connect = require('@connectrpc/connect');
 var connectNode = require('@connectrpc/connect-node');
-var proto = require('@thru/proto');
+var proto = require('@thru/sdk/proto');
 
 // src/chain-client.ts
 var ChainClient = class {
   constructor(options) {
     this.options = options;
-    const transport = options.transport ?? this.createTransport();
-    this.query = connect.createClient(proto.QueryService, transport);
-    this.streaming = connect.createClient(proto.StreamingService, transport);
+    if (options.transport) {
+      this.sessionManager = null;
+      this.query = connect.createClient(proto.QueryService, options.transport);
+      this.streaming = connect.createClient(proto.StreamingService, options.transport);
+    } else {
+      const { transport, sessionManager } = this.createOwnedTransport();
+      this.sessionManager = sessionManager;
+      this.query = connect.createClient(proto.QueryService, transport);
+      this.streaming = connect.createClient(proto.StreamingService, transport);
+    }
     this.callOptions = options.callOptions;
   }
+  options;
   query;
   streaming;
   callOptions;
+  /**
+   * The HTTP/2 session manager owned by this client. Only set when the client
+   * created its own gRPC transport (i.e., `options.transport` was not provided).
+   * `close()` uses this to tear down the underlying persistent connection.
+   */
+  sessionManager;
+  closed = false;
+  /**
+   * Close the underlying HTTP/2 session, if this client owns one. Idempotent.
+   *
+   * Callers are responsible for ensuring that no in-flight RPCs or streams
+   * are still being awaited on this client — pending requests will fail.
+   *
+   * If the client was constructed with an externally-supplied `transport`,
+   * `close()` is a no-op; the caller owns the transport's lifecycle.
+   */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.sessionManager?.abort();
+  }
   getAccount(request) {
     return this.query.getAccount(protobuf.create(proto.GetAccountRequestSchema, request), this.callOptions);
   }
@@ -41,7 +70,7 @@ var ChainClient = class {
   streamEvents(request) {
     return this.streaming.streamEvents(protobuf.create(proto.StreamEventsRequestSchema, request), this.callOptions);
   }
-  createTransport() {
+  createOwnedTransport() {
     if (!this.options.baseUrl) {
       throw new Error("ChainClient requires baseUrl when no transport is provided");
     }
@@ -51,15 +80,19 @@ var ChainClient = class {
       ...userInterceptors,
       ...headerInterceptor ? [headerInterceptor] : []
     ];
-    return connectNode.createGrpcTransport({
-      baseUrl: this.options.baseUrl,
-      useBinaryFormat: this.options.useBinaryFormat ?? true,
-      interceptors: mergedInterceptors.length ? mergedInterceptors : void 0,
+    const sessionManager = new connectNode.Http2SessionManager(this.options.baseUrl, {
       pingIntervalMs: 3e4,
       pingIdleConnection: true,
       pingTimeoutMs: 1e4,
       idleConnectionTimeoutMs: 0
     });
+    const transport = connectNode.createGrpcTransport({
+      baseUrl: this.options.baseUrl,
+      useBinaryFormat: this.options.useBinaryFormat ?? true,
+      interceptors: mergedInterceptors.length ? mergedInterceptors : void 0,
+      sessionManager
+    });
+    return { transport, sessionManager };
   }
   createHeaderInterceptor() {
     const headers = {};
@@ -77,6 +110,9 @@ var ChainClient = class {
   getHeight() {
     return this.query.getHeight(protobuf.create(proto.GetHeightRequestSchema, {}), this.callOptions);
   }
+  getChainInfo(request = {}) {
+    return this.query.getChainInfo(protobuf.create(proto.GetChainInfoRequestSchema, request), this.callOptions);
+  }
 };
 
 // src/async-queue.ts
@@ -239,15 +275,16 @@ var LivePump = class {
   buffer;
   slotOf;
   keyOf;
-  source;
+  sourceIterator;
   logger;
   mode;
   minSlotSeen = null;
   maxSlotSeen = null;
   minEmitSlot = null;
   pumpPromise;
+  closing = false;
   constructor(options) {
-    this.source = options.source;
+    this.sourceIterator = options.source[Symbol.asyncIterator]();
     this.slotOf = options.slotOf;
     this.keyOf = options.keyOf ?? ((item) => options.slotOf(item).toString());
     this.logger = options.logger ?? NOOP_LOGGER;
@@ -291,12 +328,19 @@ var LivePump = class {
     return this.queue.next();
   }
   async close() {
+    this.closing = true;
     this.queue.close();
-    await this.pumpPromise;
+    await Promise.allSettled([
+      this.closeSourceIterator(),
+      this.pumpPromise
+    ]);
   }
   async start() {
     try {
-      for await (const item of this.source) {
+      while (!this.closing) {
+        const next = await this.sourceIterator.next();
+        if (next.done || this.closing) break;
+        const item = next.value;
         const slot = this.slotOf(item);
         if (this.minSlotSeen === null || slot < this.minSlotSeen) this.minSlotSeen = slot;
         if (this.maxSlotSeen === null || slot > this.maxSlotSeen) this.maxSlotSeen = slot;
@@ -306,9 +350,21 @@ var LivePump = class {
           this.queue.push(item);
         }
       }
-      this.queue.close();
     } catch (err) {
-      this.queue.fail(err);
+      if (!this.closing) {
+        this.queue.fail(err);
+      }
+    } finally {
+      this.queue.close();
+    }
+  }
+  async closeSourceIterator() {
+    if (typeof this.sourceIterator.return !== "function") {
+      return;
+    }
+    try {
+      await this.sourceIterator.return();
+    } catch {
     }
   }
 };
@@ -328,6 +384,7 @@ function withTimeout(promise, timeoutMs) {
     const timer = setTimeout(() => {
       reject(new TimeoutError(`Operation timed out after ${timeoutMs}ms`));
     }, timeoutMs);
+    timer.unref?.();
     promise.then((value) => {
       clearTimeout(timer);
       resolve(value);
@@ -346,6 +403,37 @@ var TimeoutError = class extends Error {
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function abortableDelay(ms, signal) {
+  if (ms <= 0 || signal?.aborted) {
+    return Promise.resolve();
+  }
+  const abortSignal = signal;
+  return new Promise((resolve) => {
+    if (!abortSignal) {
+      const timer2 = setTimeout(resolve, ms);
+      timer2.unref?.();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      abortSignal.removeEventListener("abort", onAbort);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      abortSignal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    timer.unref?.();
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function isAbortError(err) {
+  if (!err || typeof err !== "object") return false;
+  const name = typeof err.name === "string" ? err.name.toLowerCase() : "";
+  const message = typeof err.message === "string" ? err.message.toLowerCase() : "";
+  const code = String(err.code ?? "").toLowerCase();
+  return name.includes("abort") || name.includes("cancel") || code === "canceled" || code === "cancelled" || message.includes("aborted") || message.includes("canceled") || message.includes("cancelled");
+}
 
 // src/replay-stream.ts
 var DEFAULT_METRICS = {
@@ -359,6 +447,27 @@ function compareBigint(a, b) {
   if (a === b) return 0;
   return a < b ? -1 : 1;
 }
+function isNonDecreasing(items, extractSlot) {
+  for (let idx = 1; idx < items.length; idx += 1) {
+    if (extractSlot(items[idx]) < extractSlot(items[idx - 1])) return false;
+  }
+  return true;
+}
+function assertBackfillPageOrder(previousPage, currentPage, extractSlot) {
+  if (!isNonDecreasing(currentPage, extractSlot)) {
+    throw new Error(
+      "backfill source returned a page that is not ordered by ascending slot"
+    );
+  }
+  if (!previousPage?.length || !currentPage.length) return;
+  const previousMaxSlot = extractSlot(previousPage[previousPage.length - 1]);
+  const currentMinSlot = extractSlot(currentPage[0]);
+  if (currentMinSlot < previousMaxSlot) {
+    throw new Error(
+      `backfill source returned pages out of ascending slot order: page minimum slot ${currentMinSlot} is before previous page maximum slot ${previousMaxSlot}`
+    );
+  }
+}
 var ReplayStream = class {
   config;
   logger;
@@ -382,12 +491,17 @@ var ReplayStream = class {
       extractKey,
       safetyMargin,
       resubscribeOnEnd,
-      onReconnect
+      onReconnect,
+      signal,
+      dispose
     } = this.config;
     const shouldResubscribeOnEnd = resubscribeOnEnd ?? true;
     const keyOf = extractKey ?? ((item) => extractSlot(item).toString());
+    const shouldStop = (err) => signal?.aborted === true || isAbortError(err);
     let currentSubscribeLive = subscribeLive;
     let currentFetchBackfill = fetchBackfill;
+    let currentDispose = dispose ?? (() => {
+    });
     const createLivePump = (slot, startStreaming = false, emitFloor) => new LivePump({
       source: currentSubscribeLive(slot),
       slotOf: extractSlot,
@@ -419,91 +533,103 @@ var ReplayStream = class {
     this.logger.info(
       `replay entering BACKFILLING state (startSlot=${startSlot}, safetyMargin=${safetyMargin})`
     );
-    let emptyPageRetries = 0;
-    const MAX_EMPTY_PAGE_RETRIES = 10;
-    while (!backfillDone) {
-      const page = await currentFetchBackfill({ startSlot, cursor });
-      if (!page.items.length && !page.cursor && !page.done) {
-        emptyPageRetries++;
-        if (emptyPageRetries > MAX_EMPTY_PAGE_RETRIES) {
-          this.logger.error(
-            `backfill returned ${MAX_EMPTY_PAGE_RETRIES} consecutive empty pages; treating as done`
-          );
-          break;
-        }
-        const backoffMs = calculateBackoff(emptyPageRetries - 1, DEFAULT_RETRY_CONFIG);
-        this.logger.warn(
-          `empty backfill page without cursor; retrying in ${backoffMs}ms (${emptyPageRetries}/${MAX_EMPTY_PAGE_RETRIES})`
-        );
-        await delay(backoffMs);
-        continue;
-      }
-      emptyPageRetries = 0;
-      const sorted = [...page.items].sort(
-        (a, b) => compareBigint(extractSlot(a), extractSlot(b))
-      );
-      for (const item of sorted) {
+    let pendingOrderedPage = null;
+    const emitBackfillItems = async function* (self, items) {
+      for (const item of items) {
         const slot = extractSlot(item);
         const key = keyOf(item);
         if (slot < startSlot) continue;
         if (seenItem(slot, key)) {
-          this.metrics.discardedDuplicates += 1;
+          self.metrics.discardedDuplicates += 1;
           continue;
         }
         currentSlot = slot;
         recordEmission(slot, key);
-        this.metrics.emittedBackfill += 1;
+        self.metrics.emittedBackfill += 1;
+        yield item;
+      }
+    };
+    const flushPendingBackfill = async function* (self) {
+      if (!pendingOrderedPage) return;
+      for await (const item of emitBackfillItems(self, pendingOrderedPage)) {
         yield item;
       }
-      const duplicatesTrimmed = livePump.discardBufferedUpTo(currentSlot);
-      this.metrics.discardedDuplicates += duplicatesTrimmed;
-      cursor = page.cursor;
-      const maxStreamSlot = livePump.maxSlot();
-      if (maxStreamSlot !== null) {
-        const catchUpSlot = maxStreamSlot > safetyMargin ? maxStreamSlot - safetyMargin : 0n;
-        if (currentSlot >= catchUpSlot) {
-          this.logger.info(
-            `replay reached SWITCHING threshold (currentSlot=${currentSlot}, maxStreamSlot=${maxStreamSlot}, catchUpSlot=${catchUpSlot})`
+      pendingOrderedPage = null;
+    };
+    let emptyPageRetries = 0;
+    const MAX_EMPTY_PAGE_RETRIES = 10;
+    try {
+      while (!backfillDone) {
+        if (shouldStop()) return;
+        let page;
+        try {
+          page = await currentFetchBackfill({ startSlot, cursor });
+        } catch (err) {
+          if (shouldStop(err)) return;
+          throw err;
+        }
+        if (!page.items.length && !page.cursor && !page.done) {
+          emptyPageRetries++;
+          if (emptyPageRetries > MAX_EMPTY_PAGE_RETRIES) {
+            this.logger.error(
+              `backfill returned ${MAX_EMPTY_PAGE_RETRIES} consecutive empty pages; treating as done`
+            );
+            for await (const item of flushPendingBackfill(this)) {
+              yield item;
+            }
+            break;
+          }
+          const backoffMs = calculateBackoff(emptyPageRetries - 1, DEFAULT_RETRY_CONFIG);
+          this.logger.warn(
+            `empty backfill page without cursor; retrying in ${backoffMs}ms (${emptyPageRetries}/${MAX_EMPTY_PAGE_RETRIES})`
           );
-          backfillDone = true;
+          await abortableDelay(backoffMs, signal);
+          continue;
         }
-      }
-      if (page.done || cursor === void 0) backfillDone = true;
-    }
-    this.logger.info(`replay entering SWITCHING state (currentSlot=${currentSlot})`);
-    const { drained, discarded } = livePump.enableStreaming(currentSlot);
-    this.metrics.bufferedItems = drained.length;
-    this.metrics.discardedDuplicates += discarded;
-    for (const item of drained) {
-      const slot = extractSlot(item);
-      const key = keyOf(item);
-      if (seenItem(slot, key)) {
-        this.metrics.discardedDuplicates += 1;
-        continue;
-      }
-      currentSlot = slot;
-      recordEmission(slot, key);
-      this.metrics.emittedLive += 1;
-      yield item;
-      livePump.updateEmitFloor(currentSlot);
-    }
-    if (!drained.length) livePump.updateEmitFloor(currentSlot);
-    this.logger.info("replay entering STREAMING state");
-    const retryConfig = DEFAULT_RETRY_CONFIG;
-    let retryAttempt = 0;
-    while (true) {
-      try {
-        const next = await withTimeout(
-          livePump.next(),
-          retryConfig.connectionTimeoutMs
-        );
-        retryAttempt = 0;
-        if (next.done) {
-          if (!shouldResubscribeOnEnd) break;
-          throw new Error("stream ended");
+        emptyPageRetries = 0;
+        assertBackfillPageOrder(pendingOrderedPage, page.items, extractSlot);
+        if (pendingOrderedPage !== null) {
+          for await (const item of flushPendingBackfill(this)) {
+            if (shouldStop()) return;
+            yield item;
+          }
+        }
+        pendingOrderedPage = [...page.items];
+        const reachedEnd = page.done || page.cursor === void 0;
+        if (reachedEnd) {
+          for await (const item of flushPendingBackfill(this)) {
+            if (shouldStop()) return;
+            yield item;
+          }
         }
-        const slot = extractSlot(next.value);
-        const key = keyOf(next.value);
+        const duplicatesTrimmed = livePump.discardBufferedUpTo(currentSlot);
+        this.metrics.discardedDuplicates += duplicatesTrimmed;
+        cursor = page.cursor;
+        const maxStreamSlot = livePump.maxSlot();
+        if (maxStreamSlot !== null) {
+          const catchUpSlot = maxStreamSlot > safetyMargin ? maxStreamSlot - safetyMargin : 0n;
+          if (currentSlot >= catchUpSlot) {
+            for await (const item of flushPendingBackfill(this)) {
+              if (shouldStop()) return;
+              yield item;
+            }
+            this.logger.info(
+              `replay reached SWITCHING threshold (currentSlot=${currentSlot}, maxStreamSlot=${maxStreamSlot}, catchUpSlot=${catchUpSlot})`
+            );
+            backfillDone = true;
+          }
+        }
+        if (reachedEnd) backfillDone = true;
+      }
+      if (shouldStop()) return;
+      this.logger.info(`replay entering SWITCHING state (currentSlot=${currentSlot})`);
+      const { drained, discarded } = livePump.enableStreaming(currentSlot);
+      this.metrics.bufferedItems = drained.length;
+      this.metrics.discardedDuplicates += discarded;
+      for (const item of drained) {
+        if (shouldStop()) return;
+        const slot = extractSlot(item);
+        const key = keyOf(item);
         if (seenItem(slot, key)) {
           this.metrics.discardedDuplicates += 1;
           continue;
@@ -511,57 +637,97 @@ var ReplayStream = class {
         currentSlot = slot;
         recordEmission(slot, key);
         this.metrics.emittedLive += 1;
-        yield next.value;
+        yield item;
         livePump.updateEmitFloor(currentSlot);
-      } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        const backoffMs = calculateBackoff(retryAttempt, retryConfig);
-        this.logger.warn(
-          `live stream disconnected (${errMsg}); reconnecting in ${backoffMs}ms from slot ${currentSlot} (attempt ${retryAttempt + 1})`
-        );
-        await delay(backoffMs);
-        await safeClose(livePump);
-        retryAttempt++;
-        if (onReconnect) {
-          try {
-            const fresh = onReconnect();
-            currentSubscribeLive = fresh.subscribeLive;
-            if (fresh.fetchBackfill) {
-              currentFetchBackfill = fresh.fetchBackfill;
+      }
+      if (!drained.length) livePump.updateEmitFloor(currentSlot);
+      this.logger.info("replay entering STREAMING state");
+      const retryConfig = DEFAULT_RETRY_CONFIG;
+      let retryAttempt = 0;
+      while (true) {
+        if (shouldStop()) return;
+        try {
+          const next = await withTimeout(
+            livePump.next(),
+            retryConfig.connectionTimeoutMs
+          );
+          retryAttempt = 0;
+          if (next.done) {
+            if (shouldStop()) return;
+            if (!shouldResubscribeOnEnd) break;
+            throw new Error("stream ended");
+          }
+          const slot = extractSlot(next.value);
+          const key = keyOf(next.value);
+          if (seenItem(slot, key)) {
+            this.metrics.discardedDuplicates += 1;
+            continue;
+          }
+          currentSlot = slot;
+          recordEmission(slot, key);
+          this.metrics.emittedLive += 1;
+          yield next.value;
+          livePump.updateEmitFloor(currentSlot);
+        } catch (err) {
+          if (shouldStop(err)) return;
+          const errMsg = err instanceof Error ? err.message : String(err);
+          const backoffMs = calculateBackoff(retryAttempt, retryConfig);
+          this.logger.warn(
+            `live stream disconnected (${errMsg}); reconnecting in ${backoffMs}ms from slot ${currentSlot} (attempt ${retryAttempt + 1})`
+          );
+          await abortableDelay(backoffMs, signal);
+          if (shouldStop()) return;
+          currentDispose();
+          await safeClose(livePump);
+          retryAttempt++;
+          if (onReconnect) {
+            try {
+              const fresh = onReconnect();
+              currentSubscribeLive = fresh.subscribeLive;
+              if (fresh.fetchBackfill) {
+                currentFetchBackfill = fresh.fetchBackfill;
+              }
+              currentDispose = fresh.dispose ?? (() => {
+              });
+              this.logger.info("created fresh client for reconnection");
+            } catch (factoryErr) {
+              this.logger.error(
+                `failed to create fresh client: ${factoryErr instanceof Error ? factoryErr.message : String(factoryErr)}; using existing`
+              );
             }
-            this.logger.info("created fresh client for reconnection");
-          } catch (factoryErr) {
-            this.logger.error(
-              `failed to create fresh client: ${factoryErr instanceof Error ? factoryErr.message : String(factoryErr)}; using existing`
-            );
           }
-        }
-        if (onReconnect && currentSlot > 0n) {
-          for await (const item of this.miniBackfill(
-            currentSlot,
-            currentFetchBackfill,
-            extractSlot,
-            keyOf,
-            seenItem,
-            recordEmission
-          )) {
-            const itemSlot = extractSlot(item);
-            if (itemSlot > currentSlot) {
-              currentSlot = itemSlot;
+          if (onReconnect && currentSlot > 0n) {
+            for await (const item of this.miniBackfill(
+              currentSlot,
+              currentFetchBackfill,
+              extractSlot,
+              keyOf,
+              seenItem,
+              recordEmission,
+              signal
+            )) {
+              if (shouldStop()) return;
+              const itemSlot = extractSlot(item);
+              if (itemSlot > currentSlot) {
+                currentSlot = itemSlot;
+              }
+              yield item;
             }
-            yield item;
           }
+          const resumeSlot = currentSlot > 0n ? currentSlot : 0n;
+          livePump = createLivePump(resumeSlot, true, currentSlot);
         }
-        const resumeSlot = currentSlot > 0n ? currentSlot : 0n;
-        livePump = createLivePump(resumeSlot, true, currentSlot);
       }
+    } finally {
+      currentDispose();
+      await safeClose(livePump);
     }
   }
   /**
    * Perform mini-backfill from lastProcessedSlot to catch up after reconnection.
    * Ensures no data gaps from events that occurred during disconnection.
    */
-  async *miniBackfill(fromSlot, fetchBackfill, extractSlot, keyOf, seenItem, recordEmission) {
+  async *miniBackfill(fromSlot, fetchBackfill, extractSlot, keyOf, seenItem, recordEmission, signal) {
     this.logger.info(`mini-backfill starting from slot ${fromSlot}`);
     const MINI_BACKFILL_TIMEOUT = 3e4;
     let lastProgressTime = Date.now();
@@ -569,6 +735,7 @@ var ReplayStream = class {
     let itemsYielded = 0;
     try {
       while (true) {
+        if (signal?.aborted) return;
         if (Date.now() - lastProgressTime > MINI_BACKFILL_TIMEOUT) {
           this.logger.warn(`mini-backfill timed out after ${MINI_BACKFILL_TIMEOUT}ms with no progress`);
           break;
@@ -579,6 +746,7 @@ var ReplayStream = class {
         );
         let pageYielded = 0;
         for (const item of sorted) {
+          if (signal?.aborted) return;
           const slot = extractSlot(item);
           const key = keyOf(item);
           if (seenItem(slot, key)) {
@@ -597,6 +765,9 @@ var ReplayStream = class {
       }
       this.logger.info(`mini-backfill complete: ${itemsYielded} items yielded`);
     } catch (err) {
+      if (signal?.aborted || isAbortError(err)) {
+        return;
+      }
       this.logger.warn(
         `mini-backfill failed: ${err instanceof Error ? err.message : String(err)}; proceeding with live stream`
       );
@@ -604,14 +775,22 @@ var ReplayStream = class {
   }
 };
 async function safeClose(pump) {
+  let timeoutId;
   try {
+    const timeout = new Promise((resolve) => {
+      timeoutId = setTimeout(() => resolve("timeout"), 5e3);
+    });
     const result = await Promise.race([
       pump.close().then(() => "closed"),
-      new Promise((resolve) => setTimeout(() => resolve("timeout"), 5e3))
+      timeout
     ]);
     if (result === "timeout") {
     }
   } catch {
+  } finally {
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+    }
   }
 }
 function combineFilters(base, user) {
@@ -707,15 +886,38 @@ function createBlockReplay(options) {
     subscribeLive,
     extractSlot: (block) => block.header?.slot ?? 0n,
     logger: options.logger,
-    resubscribeOnEnd: options.resubscribeOnEnd
+    resubscribeOnEnd: options.resubscribeOnEnd,
+    signal: options.signal
   });
 }
+
+// src/types.ts
+function resolveClient(opts, optionsName) {
+  if (opts.clientFactory) {
+    return opts.clientFactory();
+  }
+  if (!opts.client) {
+    throw new Error(`${optionsName} requires either client or clientFactory`);
+  }
+  return opts.client;
+}
+function closeIfCloseable(value) {
+  if (value && typeof value.close === "function") {
+    try {
+      value.close();
+    } catch {
+    }
+  }
+}
+
+// src/replay/transaction-replay.ts
 var DEFAULT_PAGE_SIZE2 = 256;
 var DEFAULT_SAFETY_MARGIN2 = 64n;
 var PAGE_ORDER_ASC2 = "slot asc";
 function createTransactionReplay(options) {
   const safetyMargin = options.safetyMargin ?? DEFAULT_SAFETY_MARGIN2;
-  const fetchBackfill = async ({
+  let currentClient = resolveClient(options, "TransactionReplayOptions");
+  const createFetchBackfill = (client) => async ({
     startSlot,
     cursor
   }) => {
@@ -725,7 +927,7 @@ function createTransactionReplay(options) {
       pageToken: cursor
     });
     const mergedFilter = combineFilters(slotLiteralFilter("transaction.slot", startSlot), options.filter);
-    const response = await options.client.listTransactions(
+    const response = await client.listTransactions(
       protobuf.create(proto.ListTransactionsRequestSchema, {
         filter: mergedFilter,
         page,
@@ -735,26 +937,38 @@ function createTransactionReplay(options) {
     );
     return backfillPage(response.transactions, response.page);
   };
-  const subscribeLive = (startSlot) => {
+  const createSubscribeLive = (client) => (startSlot) => {
     const mergedFilter = combineFilters(slotLiteralFilter("transaction.slot", startSlot), options.filter);
     const request = protobuf.create(proto.StreamTransactionsRequestSchema, {
       filter: mergedFilter,
       minConsensus: options.minConsensus
     });
     return mapAsyncIterable(
-      options.client.streamTransactions(request),
+      client.streamTransactions(request),
       (resp) => resp.transaction
     );
   };
+  const onReconnect = options.clientFactory ? () => {
+    const newClient = options.clientFactory();
+    currentClient = newClient;
+    return {
+      subscribeLive: createSubscribeLive(currentClient),
+      fetchBackfill: createFetchBackfill(currentClient),
+      dispose: () => closeIfCloseable(newClient)
+    };
+  } : void 0;
   return new ReplayStream({
     startSlot: options.startSlot,
     safetyMargin,
-    fetchBackfill,
-    subscribeLive,
+    fetchBackfill: createFetchBackfill(currentClient),
+    subscribeLive: createSubscribeLive(currentClient),
     extractSlot: (tx) => tx.slot ?? 0n,
     extractKey: transactionKey,
     logger: options.logger,
-    resubscribeOnEnd: options.resubscribeOnEnd
+    resubscribeOnEnd: options.resubscribeOnEnd,
+    signal: options.signal,
+    onReconnect,
+    dispose: options.clientFactory ? () => closeIfCloseable(currentClient) : void 0
   });
 }
 function transactionKey(tx) {
@@ -769,19 +983,6 @@ function bytesToHex(bytes) {
   for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
   return hex;
 }
-
-// src/types.ts
-function resolveClient(opts, optionsName) {
-  if (opts.clientFactory) {
-    return opts.clientFactory();
-  }
-  if (!opts.client) {
-    throw new Error(`${optionsName} requires either client or clientFactory`);
-  }
-  return opts.client;
-}
-
-// src/replay/event-replay.ts
 var DEFAULT_PAGE_SIZE3 = 512;
 var DEFAULT_SAFETY_MARGIN3 = 64n;
 var PAGE_ORDER_ASC3 = "slot asc";
@@ -824,10 +1025,12 @@ function createEventReplay(options) {
     );
   };
   const onReconnect = options.clientFactory ? () => {
-    currentClient = options.clientFactory();
+    const newClient = options.clientFactory();
+    currentClient = newClient;
     return {
       subscribeLive: createSubscribeLive(currentClient),
-      fetchBackfill: createFetchBackfill(currentClient)
+      fetchBackfill: createFetchBackfill(currentClient),
+      dispose: () => closeIfCloseable(newClient)
     };
   } : void 0;
   return new ReplayStream({
@@ -839,7 +1042,9 @@ function createEventReplay(options) {
     extractKey: eventKey,
     logger: options.logger,
     resubscribeOnEnd: options.resubscribeOnEnd,
-    onReconnect
+    signal: options.signal,
+    onReconnect,
+    dispose: options.clientFactory ? () => closeIfCloseable(currentClient) : void 0
   });
 }
 function streamResponseToEvent(resp) {
@@ -864,7 +1069,7 @@ function eventBackfillFilter(startSlot, resumeAfter) {
     return slotLiteralFilter("event.slot", startSlot);
   }
   return protobuf.create(proto.FilterSchema, {
-    expression: `event.slot > uint(${boundary.slot.toString()}) || (event.slot == uint(${boundary.slot.toString()}) && (event.block_offset > uint(${boundary.blockOffset.toString()}) || (event.block_offset == uint(${boundary.blockOffset.toString()}) && event.call_idx > uint(${boundary.callIdx.toString()}))))`
+    expression: `event.slot > uint(${boundary.slot.toString()}) || (event.slot == uint(${boundary.slot.toString()}) && (event.block_offset > uint(${boundary.blockOffset.toString()}) || (event.block_offset == uint(${boundary.blockOffset.toString()}) && event.call_idx >= uint(${boundary.callIdx.toString()}))))`
   });
 }
 function parseEventId(resumeAfter) {
@@ -873,23 +1078,27 @@ function parseEventId(resumeAfter) {
 }
 function parseCanonicalEventId(eventId, expectedSlot) {
   if (!eventId) return null;
-  const match = /^ts(\d+)_(\d+)_(\d+)$/.exec(eventId);
-  if (!match) return null;
-  const [slotPart, blockOffsetPart, callIdxPart] = match.slice(1);
-  const slot = BigInt(slotPart);
-  if (slot !== expectedSlot) return null;
-  return {
-    slot,
-    blockOffset: BigInt(blockOffsetPart),
-    callIdx: BigInt(callIdxPart)
-  };
+  const parts = eventId.split(":");
+  if (parts.length === 5) {
+    const [, slotPart, blockOffsetPart, callIdxPart, eventIdxPart] = parts;
+    const slot = BigInt(slotPart);
+    if (slot !== expectedSlot) return null;
+    return {
+      slot,
+      blockOffset: BigInt(blockOffsetPart),
+      callIdx: BigInt(callIdxPart),
+      eventIdx: BigInt(eventIdxPart)
+    };
+  }
+  return null;
 }
 function isAfterBoundary(event, boundary) {
   if (event.slot !== boundary.slot) return event.slot > boundary.slot;
   if (event.blockOffset !== boundary.blockOffset) {
     return event.blockOffset > boundary.blockOffset;
   }
-  return event.callIdx > boundary.callIdx;
+  if (event.callIdx !== boundary.callIdx) return event.callIdx > boundary.callIdx;
+  return event.eventIdx > boundary.eventIdx;
 }
 function shouldEmitLiveEvent(event, startSlot, resumeAfter) {
   const boundary = parseEventId(resumeAfter);
@@ -1060,6 +1269,15 @@ var PageAssembler = class {
 };
 
 // src/account-replay.ts
+async function closeAsyncIterator(iterator) {
+  if (!iterator || typeof iterator.return !== "function") {
+    return;
+  }
+  try {
+    await iterator.return();
+  } catch {
+  }
+}
 function bytesToHex2(bytes) {
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
@@ -1134,9 +1352,12 @@ async function* createAccountsByOwnerReplay(options) {
     cleanupInterval = 1e4,
     onBackfillComplete,
     clientFactory,
-    logger = NOOP_LOGGER
+    logger = NOOP_LOGGER,
+    signal
   } = options;
+  const shouldStop = (err) => signal?.aborted === true || isAbortError(err);
   let client = resolveClient(options, "AccountsByOwnerReplayOptions");
+  const ownsClient = Boolean(clientFactory);
   const seenFromStream = /* @__PURE__ */ new Set();
   const fetchQueue = [];
   let highestSlotSeen = minUpdatedSlot ?? 0n;
@@ -1146,15 +1367,24 @@ async function* createAccountsByOwnerReplay(options) {
   let streamDone = false;
   let streamError = null;
   let lastActivityTime = Date.now();
+  let activeStreamIterator = null;
+  let activeStreamProcessor = null;
   try {
+    if (shouldStop()) return;
     cleanupTimer = setInterval(() => {
       assembler.cleanup();
     }, cleanupInterval);
+    cleanupTimer.unref?.();
     const streamFilter = buildOwnerFilterWithMinSlot(owner, dataSizes, minUpdatedSlot);
     const stream = client.streamAccountUpdates({ view, filter: streamFilter });
-    const streamProcessor = (async () => {
+    const streamIterator = stream[Symbol.asyncIterator]();
+    activeStreamIterator = streamIterator;
+    activeStreamProcessor = (async () => {
       try {
-        for await (const response of stream) {
+        while (true) {
+          const next = await streamIterator.next();
+          if (next.done) break;
+          const response = next.value;
           lastActivityTime = Date.now();
           const event = processResponseMulti(response, assembler);
           if (event) {
@@ -1185,6 +1415,7 @@ async function* createAccountsByOwnerReplay(options) {
     const backfillFilter = buildListAccountsOwnerFilter(owner, dataSizes, minUpdatedSlot);
     let pageToken;
     do {
+      if (shouldStop()) return;
       const request = {
         view: proto.AccountView.META_ONLY,
         // Address + metadata only, no data
@@ -1194,7 +1425,13 @@ async function* createAccountsByOwnerReplay(options) {
           pageToken
         })
       };
-      const response = await client.listAccounts(request);
+      let response;
+      try {
+        response = await client.listAccounts(request);
+      } catch (err) {
+        if (shouldStop(err)) return;
+        throw err;
+      }
       for (const account of response.accounts) {
         if (account.address?.value) {
           fetchQueue.push(account.address.value);
@@ -1204,6 +1441,7 @@ async function* createAccountsByOwnerReplay(options) {
       yield* yieldStreamBuffer();
     } while (pageToken);
     for (const address of fetchQueue) {
+      if (shouldStop()) return;
       const addressHex = bytesToHex2(address);
       if (seenFromStream.has(addressHex)) {
         continue;
@@ -1221,10 +1459,11 @@ async function* createAccountsByOwnerReplay(options) {
           });
           break;
         } catch (err) {
+          if (shouldStop(err)) return;
           if (attempt === maxRetries - 1) {
             logger.error(`[backfill] failed to fetch account ${addressHex} after ${maxRetries} attempts`, { error: err });
           } else {
-            await new Promise((resolve) => setTimeout(resolve, 100 * (attempt + 1)));
+            await abortableDelay(100 * (attempt + 1), signal);
           }
         }
       }
@@ -1243,13 +1482,13 @@ async function* createAccountsByOwnerReplay(options) {
     }
     const retryConfig = DEFAULT_RETRY_CONFIG;
     let retryAttempt = 0;
-    let currentStream = stream;
-    let currentStreamProcessor = streamProcessor;
     lastActivityTime = Date.now();
     const createStreamProcessor = () => {
       if (clientFactory) {
         try {
-          client = clientFactory();
+          const newClient = clientFactory();
+          closeIfCloseable(client);
+          client = newClient;
           logger.info("[account-stream] created fresh client for reconnection");
         } catch (err) {
           logger.error("[account-stream] failed to create fresh client", { error: err });
@@ -1257,9 +1496,14 @@ async function* createAccountsByOwnerReplay(options) {
       }
       const newStreamFilter = buildOwnerFilterWithMinSlot(owner, dataSizes, highestSlotSeen > 0n ? highestSlotSeen : minUpdatedSlot);
       const newStream = client.streamAccountUpdates({ view, filter: newStreamFilter });
+      const newStreamIterator = newStream[Symbol.asyncIterator]();
+      activeStreamIterator = newStreamIterator;
       const newProcessor = (async () => {
         try {
-          for await (const response of newStream) {
+          while (true) {
+            const next = await newStreamIterator.next();
+            if (next.done) break;
+            const response = next.value;
             retryAttempt = 0;
             lastActivityTime = Date.now();
             const event = processResponseMulti(response, assembler);
@@ -1279,9 +1523,10 @@ async function* createAccountsByOwnerReplay(options) {
           streamDone = true;
         }
       })();
-      return { stream: newStream, processor: newProcessor };
+      return { iterator: newStreamIterator, processor: newProcessor };
     };
     while (true) {
+      if (shouldStop()) return;
       const hadEvents = streamBuffer.length > 0;
       yield* yieldStreamBuffer();
       if (hadEvents) {
@@ -1296,36 +1541,56 @@ async function* createAccountsByOwnerReplay(options) {
       }
       if (streamDone) {
         if (streamError) {
+          if (shouldStop(streamError)) return;
           const backoffMs = calculateBackoff(retryAttempt, retryConfig);
           logger.warn(
             `[account-stream] disconnected (${streamError.message}); reconnecting in ${backoffMs}ms (attempt ${retryAttempt + 1})`
           );
-          await delay(backoffMs);
+          await abortableDelay(backoffMs, signal);
+          if (shouldStop()) return;
           retryAttempt++;
           streamDone = false;
           streamError = null;
           streamBuffer.length = 0;
           lastActivityTime = Date.now();
-          const { stream: newStream, processor: newProcessor } = createStreamProcessor();
-          currentStream = newStream;
-          currentStreamProcessor = newProcessor;
+          await closeAsyncIterator(activeStreamIterator);
+          if (activeStreamProcessor) {
+            await Promise.allSettled([activeStreamProcessor]);
+          }
+          const { iterator: newIterator, processor: newProcessor } = createStreamProcessor();
+          activeStreamIterator = newIterator;
+          activeStreamProcessor = newProcessor;
           continue;
         } else {
+          if (shouldStop()) return;
           logger.warn("[account-stream] stream ended unexpectedly; reconnecting...");
           streamDone = false;
           lastActivityTime = Date.now();
-          const { stream: newStream, processor: newProcessor } = createStreamProcessor();
-          currentStream = newStream;
-          currentStreamProcessor = newProcessor;
+          await closeAsyncIterator(activeStreamIterator);
+          if (activeStreamProcessor) {
+            await Promise.allSettled([activeStreamProcessor]);
+          }
+          const { iterator: newIterator, processor: newProcessor } = createStreamProcessor();
+          activeStreamIterator = newIterator;
+          activeStreamProcessor = newProcessor;
           continue;
         }
       }
-      await delay(10);
+      await abortableDelay(10, signal);
     }
   } finally {
     if (cleanupTimer) {
       clearInterval(cleanupTimer);
     }
+    const closeIteratorPromise = closeAsyncIterator(activeStreamIterator);
+    if (ownsClient) {
+      closeIfCloseable(client);
+    }
+    if (activeStreamProcessor) {
+      await Promise.allSettled([closeIteratorPromise, activeStreamProcessor]);
+    } else {
+      await closeIteratorPromise;
+    }
     assembler.clear();
   }
 }
@@ -1361,6 +1626,7 @@ async function* createAccountReplay(options) {
     cleanupTimer = setInterval(() => {
       assembler.cleanup();
     }, cleanupInterval);
+    cleanupTimer.unref?.();
     const filterParams = {
       address: protobuf.create(proto.FilterParamValueSchema, { kind: { case: "bytesValue", value: new Uint8Array(address) } })
     };
@@ -1567,6 +1833,7 @@ var ConsoleSink = class {
   constructor(prefix = "ReplaySink") {
     this.prefix = prefix;
   }
+  prefix;
   open(meta) {
     const suffix = meta?.stream ? ` (${meta.stream})` : "";
     console.info(`${this.prefix}${suffix} opened`, meta?.label ?? "");