@powersync/service-core 1.27.2 → 1.28.1

package/src/streams/merge.ts

@@ -1,200 +1,180 @@
-import { throwIfAborted } from 'ix/aborterror.js';
-import { AsyncIterableX } from 'ix/asynciterable/index.js';
-import { wrapWithAbort } from 'ix/asynciterable/operators/withabort.js';
 import { safeRace } from '../sync/safeRace.js';
+import type { IterableSource } from './BroadcastIterable.js';
+
+type ReadResult<T> = { index: number } & PromiseSettledResult<IteratorResult<T>>;
+type Failure = { error: unknown };
 
 /**
  * Merge multiple source AsyncIterables into one output AsyncIterable.
+ * The results from all iterables are interleaved. When any iterable is done, the output stops.
  *
- * The results from all iterables are interleaved.
+ * Sources receive a signal owned by this merge. They must use it to unblock pending reads:
+ * async generators queue return() behind next(), so closing an unabortable read can block forever.
+ * The signal is aborted before closing all source iterators, and completion waits for their cleanup.
+ * Cleanup failures propagate to the caller; multiple failures are combined in an AggregateError.
  *
- * When any iterable is done, the output stops.
+ * Loosely based on IxJS merge, with these differences:
+ * 1. Fix an issue with uncaught errors, partially fixed in https://github.com/ReactiveX/IxJS/pull/354.
+ *    Only call next() on inner iterators when next() is called on the outer one, and handle every
+ *    pending read immediately, including reads whose results are not consumed before shutdown.
+ * 2. Call return() on all inner iterators when the outer one returns.
+ * 3. Return when the first iterator returns.
+ * Original implementation: https://github.com/ReactiveX/IxJS/blob/f07b7ef4095120f1ef21a4023030c75b36335cd1/src/asynciterable/merge.ts
  *
- * @param source The source AsyncIterables.
+ * @param sources Factories for source iterables that observe the supplied abort signal.
  * @param signal Optional signal to abort iteration.
- * @returns The merged AsyncIterable.
  */
-export function mergeAsyncIterables<T>(source: AsyncIterable<T>[], signal?: AbortSignal): AsyncIterable<T> {
-  return mergeAsyncIterablesNew(source, signal);
-  // return mergeAsyncIterablesOld(source, signal);
-}
-
-export function mergeAsyncIterablesNew<T>(source: AsyncIterable<T>[], signal?: AbortSignal): AsyncIterable<T> {
-  return new MergedAsyncIterable(source, signal);
-}
-
-export function mergeAsyncIterablesOld<T>(source: AsyncIterable<T>[], signal?: AbortSignal): AsyncIterable<T> {
-  return wrapWithAbort(new FixedMergeAsyncIterable(source, { race: true }), signal);
-}
-
-const NEVER_PROMISE = new Promise<never>(() => {});
-
-type MergeResult<T> = { value: T; index: number };
-
-function wrapPromiseWithIndex<T>(promise: Promise<T>, index: number) {
-  return promise.then((value) => ({ value, index })) as Promise<MergeResult<T>>;
+export function mergeAsyncIterables<T>(sources: IterableSource<T>[], signal?: AbortSignal): AsyncIterable<T> {
+  return {
+    [Symbol.asyncIterator]() {
+      return new MergedAsyncIterator(sources, signal);
+    }
+  };
 }
 
-/**
- * Re-implementation of FixedMergeAsyncIterable, without using async generators.
- *
- * The functionality should be the same in most cases.
- */
-class MergedAsyncIterable<T> implements AsyncIterable<T> {
-  private _source: AsyncIterable<T>[];
-  private _signal?: AbortSignal;
+class MergedAsyncIterator<T> implements AsyncIterator<T> {
+  private readonly controller = new AbortController();
+  private readonly signal: AbortSignal;
+  private readonly iterators: AsyncIterator<T>[] = [];
+  private readonly pending: (Promise<ReadResult<T>> | null)[] = [];
+  private initialized = false;
+  private closing: Promise<unknown[]> | undefined;
+  private nextInFlight: Promise<void> = Promise.resolve();
+  private readonly onAbort = () => {
+    // Cleanup can start while the consumer is paused. Its settled errors remain available to next()/return().
+    void this.close({ error: this.parentSignal!.reason });
+  };
+
+  constructor(
+    private readonly sources: IterableSource<T>[],
+    private readonly parentSignal?: AbortSignal
+  ) {
+    this.signal = parentSignal ? AbortSignal.any([parentSignal, this.controller.signal]) : this.controller.signal;
+    if (parentSignal && !parentSignal.aborted) {
+      parentSignal.addEventListener('abort', this.onAbort, { once: true });
+    }
+  }
 
-  constructor(source: AsyncIterable<T>[], signal?: AbortSignal) {
-    this._source = source;
-    this._signal = signal;
+  next(): Promise<IteratorResult<T>> {
+    // Serialize next() calls, while allowing return()/throw() to abort an in-flight read immediately.
+    const next = this.nextInFlight.then(() => this.read());
+    this.nextInFlight = next.then(
+      () => {},
+      () => {}
+    );
+    return next;
   }
 
-  [Symbol.asyncIterator](): AsyncIterator<T> {
-    const signal = this._signal;
-    throwIfAborted(signal);
+  async return(): Promise<IteratorResult<T>> {
+    throwFailures(await this.close());
+    return { done: true, value: undefined };
+  }
 
-    const length = this._source.length;
-    const iterators = new Array<AsyncIterator<T>>(length);
-    const nexts = new Array<Promise<MergeResult<IteratorResult<T>>> | null>(length);
+  async throw(error: unknown): Promise<IteratorResult<T>> {
+    throwFailures(await this.close({ error }, true));
+    return { done: true, value: undefined };
+  }
 
-    for (let i = 0; i < length; i++) {
-      const iterator = wrapWithAbort(this._source[i], signal)[Symbol.asyncIterator]();
-      iterators[i] = iterator;
-      nexts[i] = null;
+  private async read(): Promise<IteratorResult<T>> {
+    if (this.closing) {
+      throwFailures(await this.closing);
+      return { done: true, value: undefined };
     }
-
-    const returnIterators = async (_value?: any): Promise<IteratorResult<T>> => {
-      for (let iter of iterators) {
-        // Do not wait for return() to complete, since it may block
-        iter.return?.();
-      }
-      return { value: undefined, done: true };
-    };
-
-    return {
-      next: async (): Promise<IteratorResult<T>> => {
-        for (let i = 0; i < length; i++) {
-          if (nexts[i] == null) {
-            nexts[i] = wrapPromiseWithIndex(iterators[i].next(), i);
-          }
-        }
-
-        try {
-          // IMPORTANT! safeRace here acts like Promise.race, but avoids major memory leaks.
-          const {
-            value: { done, value },
-            index
-          } = (await safeRace(nexts as Array<Promise<MergeResult<IteratorResult<T>>>>))!;
-          if (done) {
-            // One of the source iterators is done - return them all
-            await returnIterators();
-
-            return {
-              value: undefined,
-              done: true
-            };
-          } else {
-            // Consume the result, which will cause the next one to be requested on the
-            // next iteration.
-            nexts[index] = null;
-
-            return {
-              value: value,
-              done: false
-            };
-          }
-        } catch (e) {
-          // One of the source iterators raised an error - return all others
-          // and propagate the error
-          await returnIterators();
-          throw e;
+    try {
+      this.signal.throwIfAborted();
+      if (!this.initialized) {
+        this.initialized = true;
+        for (const source of this.sources) {
+          this.iterators.push(source(this.signal)[Symbol.asyncIterator]());
+          this.pending.push(null);
         }
-      },
-      return: () => {
-        return returnIterators();
-      },
-      throw: async (e) => {
-        for (let iter of iterators) {
-          // Do not wait for throw() to complete, since it may block
-          iter.throw?.(e);
+      }
+      for (const [index, iterator] of this.iterators.entries()) {
+        if (this.pending[index] == null) {
+          // Settle errors immediately, even if another source wins and the consumer stops reading.
+          this.pending[index] = Promise.resolve()
+            .then(() => iterator.next())
+            .then(
+              (value): ReadResult<T> => ({ index, status: 'fulfilled', value }),
+              (reason): ReadResult<T> => ({ index, status: 'rejected', reason })
+            );
         }
-        throw e;
       }
-    };
-  }
-}
-
-/**
- * Loosely based on IxJS merge, but with some changes:
- * 1. Fix an issue with uncaught errors.
- *      Partially fixed: https://github.com/ReactiveX/IxJS/pull/354
- *      Essentially, we only want to call next() on inner iterators when next() is called on the outer one.
- * 2. Call return() on all inner iterators when the outer one returns.
- * 3. Returning when the first iterator returns.
- *
- * https://github.com/ReactiveX/IxJS/blob/f07b7ef4095120f1ef21a4023030c75b36335cd1/src/asynciterable/merge.ts
- */
-export class FixedMergeAsyncIterable<T> extends AsyncIterableX<T> {
-  private _source: AsyncIterable<T>[];
-  private _race: boolean;
-
-  /**
-   *
-   * @param source
-   * @param options Specify `race: true` to stop the iterator when any inner one returns, instead of waiting for all.
-   */
-  constructor(source: AsyncIterable<T>[], options?: { race?: boolean }) {
-    super();
-    this._source = source;
-    this._race = options?.race ?? false;
+      if (this.pending.length === 0) {
+        return await this.return();
+      }
+      // Like Promise.race, but avoids retaining callbacks on long-lived pending reads.
+      const result = await safeRace(this.pending as Promise<ReadResult<T>>[]);
+      if (this.closing) {
+        throwFailures(await this.closing);
+        return { done: true, value: undefined };
+      }
+      if (result.status === 'rejected') {
+        throw result.reason;
+      }
+      if (result.value.done) {
+        return await this.return();
+      }
+      this.pending[result.index] = null;
+      return result.value;
+    } catch (error) {
+      throwFailures(await this.close({ error }));
+      throw error;
+    }
   }
 
-  async *[Symbol.asyncIterator](signal?: AbortSignal): AsyncIterator<T> {
-    throwIfAborted(signal);
-    const length = this._source.length;
-    const iterators = new Array<AsyncIterator<T>>(length);
-    const nexts = new Array<Promise<MergeResult<IteratorResult<T>>>>(length);
-    let active = length;
-    for (let i = 0; i < length; i++) {
-      const iterator = wrapWithAbort(this._source[i], signal)[Symbol.asyncIterator]();
-      iterators[i] = iterator;
-      nexts[i] = wrapPromiseWithIndex(iterator.next(), i);
+  private close(failure?: Failure, injectError = false): Promise<unknown[]> {
+    if (this.closing) {
+      return this.closing;
     }
-
-    try {
-      while (active > 0) {
-        // IMPORTANT! safeRace here acts like Promise.race, but avoids major memory leaks.
-        const {
-          value: { done, value },
-          index
-        } = await safeRace(nexts);
-        if (done) {
-          nexts[index] = NEVER_PROMISE;
-          active--;
-          if (this._race) {
-            break;
+    // Publish the closing state before invoking source code, including synchronous abort listeners.
+    this.closing = Promise.resolve().then(async () => {
+      this.parentSignal?.removeEventListener('abort', this.onAbort);
+      this.controller.abort(failure?.error);
+      const errors = failure ? [failure.error] : [];
+      const collect = (error: unknown) => {
+        // Aborting pending reads is expected. Do not hide the original failure or unrelated cleanup errors.
+        if (error !== this.signal.reason && !(error instanceof Error && error.name === 'AbortError')) {
+          if (!errors.includes(error)) {
+            errors.push(error);
           }
-        } else {
-          const iterator$ = iterators[index];
-          nexts[index] = NEVER_PROMISE;
-          try {
-            yield value;
-          } catch (e) {
-            // iter.throw() was called on the merged iterator
-            // Propagate the error to the source iterators
-            for (let iter of iterators) {
-              iter.throw?.(e);
+        }
+      };
+      const results = await Promise.allSettled(
+        this.iterators.map(async (iterator) => {
+          if (injectError && iterator.throw) {
+            try {
+              await iterator.throw(failure!.error);
+            } catch (error) {
+              collect(error);
             }
-            throw e;
           }
-          nexts[index] = wrapPromiseWithIndex(iterator$.next(), index);
+          // Even an iterator that catches throw() and yields again must be closed.
+          await iterator.return?.();
+        })
+      );
+      for (const result of results) {
+        if (result.status === 'rejected') {
+          collect(result.reason);
         }
       }
-    } finally {
-      for (let iter of iterators) {
-        // This may be an early return - return all inner iterators
-        iter.return?.();
+      // A source can fail while another source is finishing. Observe those pending reads as well.
+      for (const result of await Promise.all(this.pending)) {
+        if (result?.status === 'rejected') {
+          collect(result.reason);
+        }
       }
-    }
+      return errors;
+    });
+    return this.closing;
+  }
+}
+
+function throwFailures(errors: unknown[]): void {
+  if (errors.length === 1) {
+    throw errors[0];
+  }
+  if (errors.length > 1) {
+    throw new AggregateError(errors, 'Multiple errors while closing merged iterators', { cause: errors[0] });
   }
 }

package/src/sync/BucketChecksumState.ts

@@ -136,13 +136,15 @@ export class BucketChecksumState {
    *
    * When the checkpoint line is sent to the client, call `CheckpointLine.advance()` to update the internal state.
    * A line may be safely discarded (not sent to the client) if `advance()` is not called.
+   * Cancellation is checked between storage reads; in-flight reads are allowed to finish.
    *
    * @param next The updated checkpoint
    * @returns A {@link CheckpointLine} if any of the buckets watched by this connected was updated, or otherwise `null`.
    */
   async buildNextCheckpointLine(
     next: storage.StorageCheckpointUpdate,
-    tracer?: PerformanceTracer<SyncCheckpointTraceCategory>
+    tracer?: PerformanceTracer<SyncCheckpointTraceCategory>,
+    signal?: AbortSignal
   ): Promise<CheckpointLine | null> {
     tracer ??= new PerformanceTracer<SyncCheckpointTraceCategory>(`sync checkpoint ${next.base.checkpoint}`);
 
@@ -151,7 +153,8 @@ export class BucketChecksumState {
 
     const storage = this.bucketStorage;
 
-    const update = await this.parameterState.getCheckpointUpdate(next, tracer);
+    const update = await this.parameterState.getCheckpointUpdate(next, tracer, signal);
+    signal?.throwIfAborted();
     const { buckets: allBuckets, updatedBuckets, usedParameterResults } = update;
     const forceFullChecksum = this.forceFullChecksumForNextCheckpoint;
 
@@ -241,6 +244,8 @@ export class BucketChecksumState {
       checksumMap = await storage.getChecksums(base, bucketList, { requestHint });
     }
 
+    signal?.throwIfAborted();
+
     // Subset of buckets for which there may be new data in this batch.
     let bucketsToFetch: ResolvedBucket[];
     let bucketDataRequestHint: storage.BucketRequestHint;
@@ -584,13 +589,15 @@ export class BucketParameterState {
 
   async getCheckpointUpdate(
     checkpoint: storage.StorageCheckpointUpdate,
-    tracer: PerformanceTracer<SyncCheckpointTraceCategory>
+    tracer: PerformanceTracer<SyncCheckpointTraceCategory>,
+    signal?: AbortSignal
   ): Promise<CheckpointUpdate> {
+    signal?.throwIfAborted();
     const querier = this.querier;
     let update: CheckpointUpdate;
     if (querier.hasDynamicBuckets) {
       try {
-        update = await this.getCheckpointUpdateDynamic(checkpoint, tracer);
+        update = await this.getCheckpointUpdateDynamic(checkpoint, tracer, signal);
       } catch (e: unknown) {
         if (e instanceof ParameterSetLimitExceededError) {
           // Too many parameter results, create a breakdown of which streams are responsible for the most queries and
@@ -655,7 +662,8 @@ export class BucketParameterState {
    */
   private async getCheckpointUpdateDynamic(
     checkpoint: storage.StorageCheckpointUpdate,
-    tracer: PerformanceTracer<SyncCheckpointTraceCategory>
+    tracer: PerformanceTracer<SyncCheckpointTraceCategory>,
+    signal?: AbortSignal
   ): Promise<CheckpointUpdate> {
     const querier = this.querier;
     const staticBuckets = this.staticBuckets.values();
@@ -695,6 +703,7 @@ export class BucketParameterState {
 
       dynamicBuckets = await querier.queryDynamicBucketDescriptions({
         getParameterSets: async (lookups, definition) => {
+          signal?.throwIfAborted();
           if (lookups.length > parameterLimit) {
             // Sync Streams can chain parameter lookups, so a large output from an earlier call may become the input
             // here. We reuse the output limit as a generous upper bound; legitimate queries are much smaller.
@@ -714,6 +723,7 @@ export class BucketParameterState {
           try {
             using _ = tracer.span('parameters', definition);
             const results = await checkpoint.base.getParameterSets(lookups, remainingBudget);
+            signal?.throwIfAborted();
             const numRows = results.reduce((a, b) => a + b.rows.length, 0);
 
             lookupLog.push({ definition, resultsOrLimit: numRows, didExceedLimit: false });
@@ -731,6 +741,8 @@ export class BucketParameterState {
         }
       });
 
+      signal?.throwIfAborted();
+
       this.cachedDynamicBuckets = dynamicBuckets;
       this.cachedDynamicBucketSet = new Set<string>(dynamicBuckets.map((b) => b.bucket));
       this.lookupsFromPreviousCheckpoint = recordedLookups;

package/src/sync/sync.ts

@@ -21,6 +21,12 @@ interface ActiveCheckpointTrace {
   span: Span;
 }
 
+interface CheckpointAndLine {
+  checkpoint: storage.ReplicationCheckpoint;
+  line: CheckpointLine | null;
+  trace: ActiveCheckpointTrace | null;
+}
+
 export interface SyncStreamParameters {
   syncContext: SyncContext;
   bucketStorage: storage.SyncRulesBucketStorage;
@@ -54,47 +60,36 @@ export async function* streamResponse(
   } = options;
   const logger = options.logger ?? defaultLogger;
 
-  // We also need to be able to abort, so we create our own controller.
-  const controller = new AbortController();
-  if (signal) {
-    signal.addEventListener(
-      'abort',
-      () => {
-        controller.abort();
-      },
-      { once: true }
-    );
-    if (signal.aborted) {
-      controller.abort();
-    }
-  }
-  const ki = tokenStream(token, controller.signal, tokenStreamOptions);
-  const stream = streamResponseInner(
-    syncContext,
-    bucketStorage,
-    syncRules,
-    params,
-    token,
-    tracker,
-    controller.signal,
-    logger,
-    isEncodingAsBson
+  // Merge the two streams, and abort as soon as one of the streams ends or the consumer stops.
+  const merged = mergeAsyncIterables(
+    [
+      (signal) =>
+        streamResponseInner(
+          syncContext,
+          bucketStorage,
+          syncRules,
+          params,
+          token,
+          tracker,
+          signal,
+          logger,
+          isEncodingAsBson
+        ),
+      (signal) => tokenStream(token, signal, tokenStreamOptions)
+    ],
+    signal
   );
-  // Merge the two streams, and abort as soon as one of the streams end.
-  const merged = mergeAsyncIterables([stream, ki], controller.signal);
 
   try {
     yield* merged;
   } catch (e) {
-    if (isAbortError(e)) {
+    // Parent cancellation ends this response normally, even when its reason is not an AbortError.
+    // Match the reason itself so unrelated iteration or cleanup failures still propagate.
+    if (isAbortError(e) || (signal?.aborted && Object.is(e, signal.reason))) {
       return;
     } else {
       throw e;
     }
-  } finally {
-    // This ensures all the underlying streams are aborted as soon as possible if the
-    // parent loop stops.
-    controller.abort();
   }
 }
 
@@ -119,23 +114,18 @@ async function* streamResponseInner(
     syncRequest: params,
     logger: logger
   });
-  // The checkpoint iterator can have a pending next() while a data batch fails.
-  // Aborting this on cleanup makes that pending next() settle, so the watcher subscription
-  // is released instead of staying open until another checkpoint arrives. See the cleanup
-  // in the finally block below.
+  // A checkpoint read or calculation can be pending while a data batch fails.
+  // Aborting this on cleanup stops that work once in-flight storage reads finish, so the
+  // watcher subscription is released instead of waiting for another checkpoint to arrive.
+  // See the cleanup in the finally block below.
   const checkpointWatchController = new AbortController();
+  const checkpointSignal = AbortSignal.any([signal, checkpointWatchController.signal]);
   const stream = bucketStorage.watchCheckpointChanges({
     user_id: checkpointUserId,
-    signal: AbortSignal.any([signal, checkpointWatchController.signal])
+    signal: checkpointSignal
   });
   const newCheckpoints = stream[Symbol.asyncIterator]();
 
-  type CheckpointAndLine = {
-    checkpoint: storage.ReplicationCheckpoint;
-    line: CheckpointLine | null;
-    trace: ActiveCheckpointTrace | null;
-  };
-
   async function waitForNewCheckpointLine(): Promise<IteratorResult<CheckpointAndLine>> {
     const next = await newCheckpoints.next();
     if (next.done) {
@@ -150,7 +140,7 @@ async function* streamResponseInner(
     };
 
     try {
-      const line = await checksumState.buildNextCheckpointLine(next.value, trace.tracer);
+      const line = await checksumState.buildNextCheckpointLine(next.value, trace.tracer, checkpointSignal);
       return { done: false, value: { checkpoint: cp, line, trace: line == null ? null : trace } };
     } catch (e) {
       if (e instanceof storage.CheckpointChecksumInvalidatedError) {
@@ -184,10 +174,10 @@ async function* streamResponseInner(
   }
 
   let activeCheckpoint: { checkpoint: storage.ReplicationCheckpoint; trace: ActiveCheckpointTrace } | null = null;
+  let iterationFailure: { error: unknown } | undefined;
+  let nextCheckpointPromise: Promise<PromiseSettledResult<IteratorResult<CheckpointAndLine>>> | undefined;
 
   try {
-    let nextCheckpointPromise: Promise<PromiseSettledResult<IteratorResult<CheckpointAndLine>>> | undefined;
-
     do {
       if (!nextCheckpointPromise) {
         // Wrap in a settledPromise, so that abort errors after the parent stopped iterating
@@ -344,6 +334,9 @@ async function* streamResponseInner(
         await new Promise((resolve) => setTimeout(resolve, 10));
       }
     } while (!signal.aborted);
+  } catch (error) {
+    iterationFailure = { error };
+    throw error;
   } finally {
     if (activeCheckpoint != null) {
       const { checkpoint, trace } = activeCheckpoint;
@@ -353,17 +346,38 @@ async function* streamResponseInner(
       });
     }
 
-    // The abort makes a pending next() settle as soon as the storage watcher observes it,
-    // releasing the subscription. return() is still needed for the case where there is no
-    // pending next(): the watcher is then suspended at a yield and never observes the abort.
-    // Neither is awaited: async generators queue return() behind a pending next(), so
-    // awaiting it here would keep the connection open until the next checkpoint arrives.
-    checkpointWatchController.abort();
-    newCheckpoints.return?.().catch((e) => {
-      if (!isAbortError(e)) {
-        logger.warn('Error while closing the checkpoint watcher', e);
-      }
-    });
+    await closeCheckpointWatcher(checkpointWatchController, newCheckpoints, nextCheckpointPromise, iterationFailure);
+  }
+}
+
+async function closeCheckpointWatcher(
+  controller: AbortController,
+  watcher: AsyncIterator<unknown>,
+  pending: Promise<PromiseSettledResult<IteratorResult<CheckpointAndLine>>> | undefined,
+  iterationFailure?: { error: unknown }
+): Promise<void> {
+  // The abort makes a pending next() settle as soon as the storage watcher observes it,
+  // releasing the subscription. return() is still needed for the case where there is no
+  // pending next(): the watcher is then suspended at a yield and never observes the abort.
+  // Abort before awaiting return(): async generators queue it behind a pending next().
+  // This ordering prevents the connection stall fixed in #773, without detaching cleanup.
+  controller.abort(iterationFailure?.error);
+  // A pending read can fail in the watcher's finally block while its queued return() succeeds.
+  // Observe both results so that cleanup failures are not silently lost.
+  const [closed, read] = await Promise.all([settledPromise(Promise.resolve().then(() => watcher.return?.())), pending]);
+  const errors = iterationFailure ? [iterationFailure.error] : [];
+  for (const result of [closed, read]) {
+    if (result?.status === 'rejected' && !isAbortError(result.reason) && !errors.includes(result.reason)) {
+      errors.push(result.reason);
+    }
+  }
+  if (read?.status === 'fulfilled' && !read.value.done) {
+    read.value.value.trace?.span.end();
+  }
+  if (errors.length > 1) {
+    throw new AggregateError(errors, 'Checkpoint iteration and cleanup both failed', { cause: errors[0] });
+  } else if (errors.length === 1) {
+    throw errors[0];
   }
 }
 

package/src/sync/util.ts

@@ -2,7 +2,6 @@ import * as timers from 'timers/promises';
 
 import { SemaphoreInterface } from 'async-mutex';
 import { serialize } from 'bson';
-import { AbortError } from 'ix/aborterror.js';
 import * as util from '../util/util-index.js';
 import { RequestTracker } from './RequestTracker.js';
 
@@ -25,14 +24,10 @@ const DEFAULT_TOKEN_STREAM_OPTIONS: TokenStreamOptions = {
 };
 
 /**
- * Recognize both ix's AbortError and native abort errors, which Node represents
- * as DOMExceptions with the name "AbortError".
+ * Recognize DOM AbortErrors and Node's timer/stream abort errors by name.
  */
 export function isAbortError(error: unknown): boolean {
-  return (
-    error instanceof AbortError ||
-    (typeof error == 'object' && error != null && 'name' in error && error.name === 'AbortError')
-  );
+  return typeof error == 'object' && error != null && 'name' in error && error.name === 'AbortError';
 }
 
 /**