@usearete/sdk 0.20.4 → 0.22.0

package/README.md

@@ -432,20 +432,43 @@ It returns `{ success: true, data } | { success: false, error }` and never throw
 
 ```ts
 type Update<T> =
-  | { type: 'upsert'; key: string; data: T }
-  | { type: 'patch'; key: string; data: Partial<T> }
-  | { type: 'remove'; key: string }
-  | { type: 'delete'; key: string };
+  | { type: 'upsert'; key: string; data: T; cursor?: string }
+  | { type: 'patch'; key: string; data: Partial<T>; cursor?: string }
+  | { type: 'remove'; key: string; cursor?: string }
+  | { type: 'delete'; key: string; cursor?: string };
 
 type RichUpdate<T> =
-  | { type: 'created'; key: string; data: T }
-  | { type: 'updated'; key: string; before: T; after: T; patch?: unknown }
-  | { type: 'removed'; key: string; lastKnown?: T }
-  | { type: 'deleted'; key: string; lastKnown?: T };
+  | { type: 'created'; key: string; data: T; cursor?: string }
+  | { type: 'updated'; key: string; before: T; after: T; patch?: unknown; cursor?: string }
+  | { type: 'removed'; key: string; lastKnown?: T; cursor?: string }
+  | { type: 'deleted'; key: string; lastKnown?: T; cursor?: string };
 ```
 
 `remove` means an entity left only this query's filter or window. `delete` means the source entity was deleted and is removed from every query for that view.
 
+## Replay cursors
+
+Updates from an append view backed by the server's journal carry `cursor`, the
+`{epoch}:{offset}` position of the event. Store it with the data you derive
+from that update and pass it back as `after` to resume exactly where you
+stopped — `after` is exclusive, and it is never a `_seq` value. State and list
+views project membership rather than a tape, so their updates have no cursor.
+
+```ts
+for await (const update of session.stacks.myStack.views.Trade.list.watch()) {
+  await db.apply(update, update.cursor); // one transaction: data + position
+}
+```
+
+Reconnects resume from the last cursor delivered on each subscription. If a
+record is lost locally the stream ends with a `StreamGapError` carrying the
+last cursor delivered before the loss, rather than skipping records silently.
+Server-side refusals (`cursor-expired`, `cursor-epoch-changed`,
+`cursor-unknown`, `invalid-cursor`, `replay-gap`, `replay-lagged`) end the
+stream with their wire code; `isReplayErrorCode` identifies them, and the
+failing frame — including `replayWindow` and `recoverFrom` — is on the error's
+`details`.
+
 ## License
 
 MIT

package/dist/index.cjs

@@ -10,6 +10,17 @@ const DEFAULT_CONFIG = {
     maxReconnectAttempts: 5,
     maxEntriesPerView: DEFAULT_MAX_ENTRIES_PER_VIEW,
 };
+const REPLAY_ERROR_CODES = {
+    'cursor-expired': true,
+    'cursor-epoch-changed': true,
+    'cursor-unknown': true,
+    'invalid-cursor': true,
+    'replay-gap': true,
+    'replay-lagged': true,
+};
+function isReplayErrorCode(code) {
+    return REPLAY_ERROR_CODES[code] === true;
+}
 /**
  * Determines if the error indicates the client should fetch a new token
  */
@@ -32,7 +43,9 @@ class AreteError extends Error {
     }
 }
 /**
- * Parse a kebab-case error code string (from X-Error-Code header) to AuthErrorCode
+ * Parse a kebab-case error code string (from X-Error-Code header) to AuthErrorCode.
+ * Replay refusals keep their wire code: each needs a different recovery, so
+ * collapsing them into a generic failure would destroy the only distinction.
  */
 function parseErrorCode(errorCode) {
     const codeMap = {
@@ -65,7 +78,10 @@ function parseErrorCode(errorCode) {
         'deployment-access-denied': 'DEPLOYMENT_ACCESS_DENIED',
         'quota-exceeded': 'QUOTA_EXCEEDED',
     };
-    return codeMap[errorCode.toLowerCase()] || 'INTERNAL_ERROR';
+    const normalized = errorCode.toLowerCase();
+    if (isReplayErrorCode(normalized))
+        return normalized;
+    return codeMap[normalized] || 'INTERNAL_ERROR';
 }
 
 const GZIP_MAGIC_0 = 0x1f;
@@ -98,6 +114,17 @@ function isSubscriptionId(value) {
 function isMode(value) {
     return typeof value === 'string' && FRAME_MODES.has(value);
 }
+function isOffset(value) {
+    return Number.isInteger(value) && value >= 0;
+}
+function isReplayWindow(value) {
+    return isRecord(value)
+        && typeof value['epoch'] === 'string'
+        && value['epoch'].length > 0
+        && isOffset(value['earliest'])
+        && isOffset(value['next'])
+        && (value['gapAfter'] === undefined || isOffset(value['gapAfter']));
+}
 function isSort(value) {
     if (!isRecord(value))
         return false;
@@ -172,7 +199,9 @@ function isValidFrame(frame) {
             && typeof frame['fatal'] === 'boolean'
             && (frame['message'] === undefined || typeof frame['message'] === 'string')
             && (frame['error'] === undefined || typeof frame['error'] === 'string')
-            && (frame['retryable'] === undefined || typeof frame['retryable'] === 'boolean');
+            && (frame['retryable'] === undefined || typeof frame['retryable'] === 'boolean')
+            && (frame['replayWindow'] === undefined || isReplayWindow(frame['replayWindow']))
+            && (frame['recoverFrom'] === undefined || typeof frame['recoverFrom'] === 'string');
     }
     if (!hasV2Identity(frame) || typeof frame['op'] !== 'string')
         return false;
@@ -181,7 +210,8 @@ function isValidFrame(frame) {
     if (frame['op'] === 'subscribed') {
         return isQuery(frame['query'])
             && isMode(frame['mode'])
-            && (frame['sort'] === undefined || isSort(frame['sort']));
+            && (frame['sort'] === undefined || isSort(frame['sort']))
+            && (frame['replayWindow'] === undefined || isReplayWindow(frame['replayWindow']));
     }
     if (!isMode(frame['mode']) || typeof frame['entity'] !== 'string')
         return false;
@@ -198,10 +228,49 @@ function isValidFrame(frame) {
         && typeof frame['key'] === 'string'
         && 'data' in frame
         && (frame['seq'] === undefined || typeof frame['seq'] === 'string')
+        && (frame['offset'] === undefined || isOffset(frame['offset']))
         && (frame['append'] === undefined
             || (Array.isArray(frame['append'])
                 && frame['append'].every((entry) => typeof entry === 'string')));
 }
+/**
+ * Builds the `{epoch}:{offset}` cursor a consumer stores and sends back as
+ * `query.after`. An offset only means something inside the epoch the
+ * acknowledgement named, so the epoch has to be carried across frames.
+ */
+class CursorTracker {
+    constructor() {
+        this.epochs = new Map();
+        this.cursors = new Map();
+    }
+    /** Records the frame and returns the cursor it carries, if any. */
+    observe(frame) {
+        if (isSubscribedFrame(frame)) {
+            const epoch = frame.replayWindow?.epoch;
+            if (epoch === undefined)
+                this.epochs.delete(frame.subscriptionId);
+            else
+                this.epochs.set(frame.subscriptionId, epoch);
+            return undefined;
+        }
+        if (!isEntityFrame(frame) || frame.offset === undefined)
+            return undefined;
+        const epoch = this.epochs.get(frame.subscriptionId);
+        if (epoch === undefined)
+            return undefined;
+        const cursor = `${epoch}:${frame.offset}`;
+        this.cursors.set(frame.subscriptionId, cursor);
+        return cursor;
+    }
+    /** The last cursor delivered on a subscription, for resuming after a drop. */
+    last(subscriptionId) {
+        return this.cursors.get(subscriptionId);
+    }
+    forget(subscriptionId) {
+        this.epochs.delete(subscriptionId);
+        this.cursors.delete(subscriptionId);
+    }
+}
 
 let fallbackId = 0;
 const QUERY_FIELDS = new Set([
@@ -446,6 +515,7 @@ class SubscriptionRegistry {
             onChange: (callback) => this.queryStore.onChange(subscriptionId, callback),
             onUpdate: (callback) => this.queryStore.onUpdate(subscriptionId, callback),
             onRichUpdate: (callback) => this.queryStore.onRichUpdate(subscriptionId, callback),
+            getError: () => this.queryStore.getError(subscriptionId),
             refresh: () => this.refreshTracker(tracker),
             release: () => {
                 if (released)
@@ -707,6 +777,12 @@ class ConnectionManager {
         this.currentState = 'disconnected';
         this.subscriptionQueue = new Map();
         this.activeSubscriptions = new Map();
+        /**
+         * Replay positions per subscription. Shared with the frame processor rather
+         * than duplicated: both observe the same frame stream, and this one is
+         * pruned on unsubscribe, so the processor gets that pruning for free.
+         */
+        this.cursors = new CursorTracker();
         this.socketGeneration = 0;
         this.pendingConnect = null;
         this.frameHandlers = new Set();
@@ -1518,6 +1594,7 @@ class ConnectionManager {
     }
     unsubscribe(subscriptionId) {
         this.subscriptionQueue.delete(subscriptionId);
+        this.cursors.forget(subscriptionId);
         if (this.activeSubscriptions.has(subscriptionId)) {
             this.activeSubscriptions.delete(subscriptionId);
             if (this.ws?.readyState === WebSocket.OPEN) {
@@ -1562,9 +1639,14 @@ class ConnectionManager {
     }
     resubscribeActive() {
         for (const subscription of this.activeSubscriptions.values()) {
-            if (this.ws?.readyState === WebSocket.OPEN) {
-                this.ws.send(JSON.stringify(subscription));
-            }
+            if (this.ws?.readyState !== WebSocket.OPEN)
+                continue;
+            // Re-sending the original `after` would replay what was already
+            // delivered; sending none would skip whatever the drop cost us.
+            const after = this.cursors.last(subscription.subscriptionId);
+            this.ws.send(JSON.stringify(after === undefined
+                ? subscription
+                : { ...subscription, query: { ...subscription.query, after } }));
         }
     }
     addQueuedSubscription(subscription) {
@@ -1585,6 +1667,7 @@ class ConnectionManager {
         }
     }
     notifyFrameHandlers(frame) {
+        this.cursors.observe(frame);
         for (const handler of this.frameHandlers) {
             handler(frame);
         }
@@ -1706,12 +1789,23 @@ function toCamelCaseSegment(value) {
     return pascal[0].toLowerCase() + pascal.slice(1);
 }
 class FrameProcessor {
+    /**
+     * Observe the connection's cursor tracker instead of a private one.
+     *
+     * The connection prunes on unsubscribe; this processor never sees an
+     * `unsubscribed` frame, so its own tracker would grow for the life of the
+     * page as a React app mounts and unmounts components with different queries.
+     */
+    useCursorTracker(cursors) {
+        this.cursors = cursors;
+    }
     constructor(storage, config = {}) {
         this.pendingUpdates = [];
         this.flushTimer = null;
         this.isProcessing = false;
         this.latestProcessedSlot = null;
         this.processedSlotWaiters = new Set();
+        this.cursors = new CursorTracker();
         this.storage = storage;
         this.maxEntriesPerView = config.maxEntriesPerView === undefined
             ? DEFAULT_MAX_ENTRIES_PER_VIEW
@@ -2056,6 +2150,7 @@ class FrameProcessor {
         return null;
     }
     handleSubscribedFrame(frame) {
+        this.cursors.observe(frame);
         const viewPath = frame.query.view;
         if (this.storage.setViewConfig && frame.sort) {
             this.storage.setViewConfig(viewPath, {
@@ -2101,7 +2196,11 @@ class FrameProcessor {
         const viewPath = frame.entity;
         const previousValue = this.storage.get(viewPath, frame.key);
         const previousSequence = this.getInternalSeq(previousValue);
-        const duplicateOrStaleSequence = frame.seq !== undefined
+        const cursor = this.cursors.observe(frame);
+        // On a tape the offset is the identity: two events decoded from one
+        // transaction share a seq, so the seq guard would discard the second.
+        const duplicateOrStaleSequence = frame.offset === undefined
+            && frame.seq !== undefined
             && previousSequence !== undefined
             && this.compareSeq(frame.seq, previousSequence) <= 0;
         switch (frame.op) {
@@ -2138,9 +2237,10 @@ class FrameProcessor {
                         type: 'upsert',
                         key: frame.key,
                         data: nextValue,
+                        cursor,
                     };
                     this.storage.notifyUpdate(viewPath, frame.key, update);
-                    const richUpdate = this.createRichUpdate(frame.key, previousValue, nextValue);
+                    const richUpdate = this.createRichUpdate(frame.key, previousValue, nextValue, undefined, cursor);
                     this.storage.notifyRichUpdate(viewPath, frame.key, richUpdate);
                     this.queryStore?.applyLive(frame.subscriptionId, frame.key, update, richUpdate, frame.seq ?? this.extractSeq(frame.data));
                     break;
@@ -2176,27 +2276,34 @@ class FrameProcessor {
                     type: 'patch',
                     key: frame.key,
                     data: normalizedPatch,
+                    cursor,
                 };
                 this.storage.notifyUpdate(viewPath, frame.key, update);
-                const richUpdate = this.createRichUpdate(frame.key, previousValue, nextValue, normalizedPatch);
+                const richUpdate = this.createRichUpdate(frame.key, previousValue, nextValue, normalizedPatch, cursor);
                 this.storage.notifyRichUpdate(viewPath, frame.key, richUpdate);
                 this.queryStore?.applyLive(frame.subscriptionId, frame.key, update, richUpdate, frame.seq ?? this.extractSeq(frame.data));
                 break;
             }
             case 'remove':
-                this.queryStore?.applyLive(frame.subscriptionId, frame.key, { type: 'remove', key: frame.key });
+                this.queryStore?.applyLive(frame.subscriptionId, frame.key, { type: 'remove', key: frame.key, cursor });
                 break;
             case 'delete':
                 this.storage.delete(viewPath, frame.key);
                 this.storage.notifyUpdate(viewPath, frame.key, {
                     type: 'delete',
                     key: frame.key,
+                    cursor,
                 });
                 if (previousValue !== null) {
-                    const richUpdate = { type: 'deleted', key: frame.key, lastKnown: previousValue };
+                    const richUpdate = {
+                        type: 'deleted',
+                        key: frame.key,
+                        lastKnown: previousValue,
+                        cursor,
+                    };
                     this.storage.notifyRichUpdate(viewPath, frame.key, richUpdate);
                 }
-                this.queryStore?.deleteGlobal(viewPath, frame.key, previousValue ?? undefined);
+                this.queryStore?.deleteGlobal(viewPath, frame.key, previousValue ?? undefined, frame.subscriptionId, cursor);
                 break;
         }
     }
@@ -2206,10 +2313,10 @@ class FrameProcessor {
             : { type: 'updated', key, before, after, patch };
         this.storage.notifyRichUpdate(viewPath, key, richUpdate);
     }
-    createRichUpdate(key, before, after, patch) {
+    createRichUpdate(key, before, after, patch, cursor) {
         return before === null
-            ? { type: 'created', key, data: after }
-            : { type: 'updated', key, before, after, patch };
+            ? { type: 'created', key, data: after, cursor }
+            : { type: 'updated', key, before, after, patch, cursor };
     }
     enforceMaxEntries(viewPath) {
         if (this.maxEntriesPerView === null)
@@ -2647,6 +2754,10 @@ class QueryStore {
     getQueryKey(subscriptionId) {
         return this.records.get(subscriptionId)?.queryKey;
     }
+    /** The current failure without rebuilding the snapshot's data. */
+    getError(subscriptionId) {
+        return this.records.get(subscriptionId)?.error;
+    }
     getSnapshot(subscriptionId) {
         const record = this.records.get(subscriptionId);
         if (!record)
@@ -2665,6 +2776,7 @@ class QueryStore {
             data,
             isLoading: record.isLoading,
             isRefreshing: record.isRefreshing,
+            ...(record.cursor ? { cursor: record.cursor } : {}),
             ...(record.error ? { error: record.error } : {}),
         };
         record.cachedSnapshot = snapshot;
@@ -2760,13 +2872,15 @@ class QueryStore {
         const record = this.records.get(subscriptionId);
         if (!record)
             return;
+        if (update.cursor !== undefined)
+            record.cursor = update.cursor;
         if (update.type === 'remove') {
             const lastKnown = this.storage.get(record.subscription.query.view, key) ?? undefined;
             record.keys = record.keys.filter((entry) => entry !== key);
             record.sequences.delete(key);
             this.touch(record);
             this.emitUpdate(record, update);
-            this.emitRichUpdate(record, { type: 'removed', key, lastKnown });
+            this.emitRichUpdate(record, { type: 'removed', key, lastKnown, cursor: update.cursor });
             return;
         }
         if (!record.keys.includes(key))
@@ -2785,15 +2899,22 @@ class QueryStore {
         if (richUpdate)
             this.emitRichUpdate(record, richUpdate);
     }
-    deleteGlobal(view, key, lastKnown) {
+    deleteGlobal(view, key, lastKnown, subscriptionId, cursor) {
         for (const record of this.records.values()) {
             if (record.subscription.query.view !== view || !record.keys.includes(key))
                 continue;
             record.keys = record.keys.filter((entry) => entry !== key);
             record.sequences.delete(key);
+            // A delete fans out to every subscription on the view, but only the one
+            // the frame named read it at this offset. Handing the position to the
+            // others would let a consumer still replaying checkpoint past events it
+            // has not been given.
+            const owned = cursor !== undefined && record.subscription.subscriptionId === subscriptionId;
+            if (owned)
+                record.cursor = cursor;
             this.touch(record);
-            this.emitUpdate(record, { type: 'delete', key });
-            this.emitRichUpdate(record, { type: 'deleted', key, lastKnown });
+            this.emitUpdate(record, owned ? { type: 'delete', key, cursor } : { type: 'delete', key });
+            this.emitRichUpdate(record, owned ? { type: 'deleted', key, lastKnown, cursor } : { type: 'deleted', key, lastKnown });
         }
     }
     evict(view, key) {
@@ -2934,43 +3055,112 @@ class QueryStore {
 }
 
 const MAX_QUEUE_SIZE = 1000;
-function enqueue(queue, value) {
-    if (queue.length >= MAX_QUEUE_SIZE)
-        queue.shift();
-    queue.push(value);
+/**
+ * A replayable record was dropped locally before the consumer read it.
+ * `cursor` is the last one delivered, so the stream can be resumed from it
+ * with `after` rather than silently skipping the lost records.
+ */
+class StreamGapError extends AreteError {
+    constructor(cursor) {
+        super(`Update stream dropped a replayable record; resume after ${cursor ?? 'the start of the window'}`, 'stream-gap', { cursor });
+        this.cursor = cursor;
+        this.name = 'StreamGapError';
+    }
+}
+/** Terminate the stream when a replay refusal makes further delivery impossible. */
+function watchRefusals(lease, fail) {
+    return lease.onChange(() => {
+        const error = lease.getError();
+        if (error && isReplayErrorCode(String(error.code)))
+            fail(error);
+    });
 }
 function createIterator(start) {
     const queue = [];
-    let waitingResolve = null;
+    let waiting = null;
     let done = false;
-    const push = (value) => {
-        if (waitingResolve) {
-            const resolve = waitingResolve;
-            waitingResolve = null;
-            resolve({ value, done: false });
-        }
-        else {
-            enqueue(queue, value);
-        }
-    };
-    const stop = start(push);
+    let failure = null;
+    let lastCursor;
+    let stop = () => { };
     const cleanup = () => {
         if (done)
             return;
         done = true;
         stop();
-        waitingResolve?.({ value: undefined, done: true });
-        waitingResolve = null;
+        waiting?.resolve({ value: undefined, done: true });
+        waiting = null;
+    };
+    const deliver = (item) => {
+        if (item.cursor !== undefined)
+            lastCursor = item.cursor;
+        return { value: item.value, done: false };
+    };
+    /**
+     * End the stream at `error`, after whatever is already queued.
+     *
+     * `discardQueued` is for a local overflow only: there the hole is at the
+     * front of the queue, so everything behind it is no longer contiguous with
+     * what the consumer has read. A server refusal is the opposite — it reports
+     * records skipped *after* everything already sent, so the queue is real data
+     * that arrived before the gap. Dropping it would lose records the consumer
+     * was never told about and leave `recoverFrom` pointing past them.
+     */
+    const fail = (error, discardQueued = false) => {
+        if (done || failure)
+            return;
+        failure = error;
+        if (discardQueued)
+            queue.length = 0;
+        const pending = waiting;
+        waiting = null;
+        // A waiter means the queue was empty, so there is nothing to drain first.
+        if (pending && queue.length === 0) {
+            failure = null;
+            cleanup();
+            pending.reject(error);
+            return;
+        }
+        if (pending) {
+            const item = queue.shift();
+            pending.resolve(deliver(item));
+        }
     };
+    const push = (value, cursor) => {
+        if (done || failure)
+            return;
+        if (waiting) {
+            const pending = waiting;
+            waiting = null;
+            pending.resolve(deliver({ value, cursor }));
+            return;
+        }
+        if (queue.length >= MAX_QUEUE_SIZE) {
+            const dropped = queue.shift();
+            if (dropped?.cursor !== undefined) {
+                fail(new StreamGapError(lastCursor), true);
+                return;
+            }
+        }
+        queue.push({ value, cursor });
+    };
+    stop = start(push, fail);
+    if (done)
+        stop();
     return {
         async next() {
+            const item = queue.shift();
+            if (item !== undefined)
+                return deliver(item);
+            if (failure) {
+                const error = failure;
+                failure = null;
+                cleanup();
+                throw error;
+            }
             if (done)
                 return { value: undefined, done: true };
-            const value = queue.shift();
-            if (value !== undefined)
-                return { value, done: false };
-            return new Promise((resolve) => {
-                waitingResolve = resolve;
+            return new Promise((resolve, reject) => {
+                waiting = { resolve, reject };
             });
         },
         async return() {
@@ -2989,14 +3179,16 @@ function acquire(registry, query, snapshotEnabled) {
 function createUpdateStream(_storage, subscriptionRegistry, query, keyFilter, snapshotEnabled = true) {
     return {
         [Symbol.asyncIterator]() {
-            return createIterator((push) => {
+            return createIterator((push, fail) => {
                 const lease = acquire(subscriptionRegistry, query, snapshotEnabled);
                 const unsubscribe = lease.onUpdate((update) => {
                     if (keyFilter === undefined || update.key === keyFilter)
-                        push(update);
+                        push(update, update.cursor);
                 });
+                const stopRefusals = watchRefusals(lease, fail);
                 return () => {
                     unsubscribe();
+                    stopRefusals();
                     lease.release();
                 };
             });
@@ -3007,16 +3199,16 @@ function createEntityStream(_storage, subscriptionRegistry, query, options, keyF
     const schema = options?.schema;
     return {
         [Symbol.asyncIterator]() {
-            return createIterator((push) => {
+            return createIterator((push, fail) => {
                 const lease = acquire(subscriptionRegistry, query, options?.withSnapshot ?? true);
-                const emit = (entity) => {
+                const emit = (entity, cursor) => {
                     if (!schema) {
-                        push(entity);
+                        push(entity, cursor);
                         return;
                     }
                     const parsed = schema.safeParse(entity);
                     if (parsed.success)
-                        push(parsed.data);
+                        push(parsed.data, cursor);
                 };
                 for (const [index, entity] of lease.getSnapshot().data.entries()) {
                     const key = lease.getSnapshot().keys[index];
@@ -3027,12 +3219,14 @@ function createEntityStream(_storage, subscriptionRegistry, query, options, keyF
                     if (keyFilter !== undefined && update.key !== keyFilter)
                         return;
                     if (update.type === 'created')
-                        emit(update.data);
+                        emit(update.data, update.cursor);
                     if (update.type === 'updated')
-                        emit(update.after);
+                        emit(update.after, update.cursor);
                 });
+                const stopRefusals = watchRefusals(lease, fail);
                 return () => {
                     unsubscribe();
+                    stopRefusals();
                     lease.release();
                 };
             });
@@ -3042,14 +3236,16 @@ function createEntityStream(_storage, subscriptionRegistry, query, options, keyF
 function createRichUpdateStream(_storage, subscriptionRegistry, query, keyFilter, snapshotEnabled = true) {
     return {
         [Symbol.asyncIterator]() {
-            return createIterator((push) => {
+            return createIterator((push, fail) => {
                 const lease = acquire(subscriptionRegistry, query, snapshotEnabled);
                 const unsubscribe = lease.onRichUpdate((update) => {
                     if (keyFilter === undefined || update.key === keyFilter)
-                        push(update);
+                        push(update, update.cursor);
                 });
+                const stopRefusals = watchRefusals(lease, fail);
                 return () => {
                     unsubscribe();
+                    stopRefusals();
                     lease.release();
                 };
             });
@@ -6837,6 +7033,7 @@ let Arete$1 = class Arete {
             auth: options.auth,
             fetch: this.fetchImpl,
         });
+        this.processor.useCursorTracker(this.connection.cursors);
         this.subscriptionRegistry = new SubscriptionRegistry(this.connection, this.queryStore);
         this.connection.onFrame((frame) => {
             this.processor.handleFrame(frame);
@@ -7747,6 +7944,7 @@ exports.ReadRequestError = ReadRequestError;
 exports.SPL_TOKEN_PROGRAM_ADDRESS = SPL_TOKEN_PROGRAM_ADDRESS;
 exports.STACK_RUNTIME_EXTENSIONS = STACK_RUNTIME_EXTENSIONS;
 exports.SYSTEM_PROGRAM_ADDRESS = SYSTEM_PROGRAM_ADDRESS;
+exports.StreamGapError = StreamGapError;
 exports.SubscriptionRegistry = SubscriptionRegistry;
 exports.TOKEN_2022_PROGRAM_ADDRESS = TOKEN_2022_PROGRAM_ADDRESS;
 exports.TRANSACTION_RESOURCE_OPTION_KEYS = TRANSACTION_RESOURCE_OPTION_KEYS;
@@ -7813,6 +8011,7 @@ exports.instructionOperation = instructionOperation;
 exports.isEntityFrame = isEntityFrame;
 exports.isErrorFrame = isErrorFrame;
 exports.isHostedAreteEndpoint = isHostedAreteEndpoint;
+exports.isReplayErrorCode = isReplayErrorCode;
 exports.isSnapshotFrame = isSnapshotFrame;
 exports.isSubscribedFrame = isSubscribedFrame;
 exports.isUnsubscribedFrame = isUnsubscribedFrame;