sidekick-shared 0.26.1 → 0.26.3

package/dist/providers/claudeCode.js

@@ -136,6 +136,8 @@ class ClaudeCodeReader {
     sessionPath;
     parser;
     filePosition = 0;
+    /** Cursor after the last complete line, safe to persist across restarts. */
+    committedPosition = 0;
     events = [];
     _wasTruncated = false;
     decoder = new string_decoder_1.StringDecoder('utf8');
@@ -165,6 +167,7 @@ class ClaudeCodeReader {
             if (currentSize < this.filePosition) {
                 this._wasTruncated = true;
                 this.filePosition = 0;
+                this.committedPosition = 0;
                 this.parser.reset();
                 this.decoder = new string_decoder_1.StringDecoder('utf8');
             }
@@ -183,7 +186,11 @@ class ClaudeCodeReader {
             finally {
                 fs.closeSync(fd);
             }
-            const chunk = this.decoder.write(buffer.subarray(0, bytesRead));
+            const bytes = buffer.subarray(0, bytesRead);
+            const newline = bytes.lastIndexOf(0x0a);
+            if (newline >= 0)
+                this.committedPosition = this.filePosition + newline + 1;
+            const chunk = this.decoder.write(bytes);
             this.parser.processChunk(chunk);
             this.filePosition += bytesRead;
         }
@@ -198,6 +205,7 @@ class ClaudeCodeReader {
     }
     reset() {
         this.filePosition = 0;
+        this.committedPosition = 0;
         this.parser.reset();
         this.decoder = new string_decoder_1.StringDecoder('utf8');
         this._wasTruncated = false;
@@ -213,10 +221,11 @@ class ClaudeCodeReader {
         this.decoder = new string_decoder_1.StringDecoder('utf8');
     }
     getPosition() {
-        return this.filePosition;
+        return this.committedPosition;
     }
     seekTo(position) {
         this.filePosition = position;
+        this.committedPosition = position;
         this.parser.reset();
         this.decoder = new string_decoder_1.StringDecoder('utf8');
     }

package/dist/providers/codex.js

@@ -473,6 +473,8 @@ class CodexReader {
     onTokenUsage;
     parser;
     filePosition = 0;
+    /** Cursor after the last complete line, safe to persist across restarts. */
+    committedPosition = 0;
     lineBuffer = '';
     _wasTruncated = false;
     decoder = new string_decoder_1.StringDecoder('utf8');
@@ -487,18 +489,19 @@ class CodexReader {
     getSessionMeta() {
         return this.parser.getSessionMeta();
     }
-    readNew() {
+    readNew(endPosition) {
         this._wasTruncated = false;
         const events = [];
         try {
             if (!fs.existsSync(this.rolloutPath))
                 return [];
             const stats = fs.statSync(this.rolloutPath);
-            const currentSize = stats.size;
+            const currentSize = Math.min(stats.size, endPosition ?? stats.size);
             // Handle truncation
             if (currentSize < this.filePosition) {
                 this._wasTruncated = true;
                 this.filePosition = 0;
+                this.committedPosition = 0;
                 this.lineBuffer = '';
                 this.parser.reset();
                 this.decoder = new string_decoder_1.StringDecoder('utf8');
@@ -517,7 +520,11 @@ class CodexReader {
             finally {
                 fs.closeSync(fd);
             }
-            const chunk = this.decoder.write(buffer.subarray(0, bytesRead));
+            const bytes = buffer.subarray(0, bytesRead);
+            const newline = bytes.lastIndexOf(0x0a);
+            if (newline >= 0)
+                this.committedPosition = this.filePosition + newline + 1;
+            const chunk = this.decoder.write(bytes);
             this.filePosition += bytesRead;
             // Process lines
             const text = this.lineBuffer + chunk;
@@ -583,6 +590,7 @@ class CodexReader {
     }
     reset() {
         this.filePosition = 0;
+        this.committedPosition = 0;
         this.lineBuffer = '';
         this.parser.reset();
         this.decoder = new string_decoder_1.StringDecoder('utf8');
@@ -606,12 +614,14 @@ class CodexReader {
         this.decoder = new string_decoder_1.StringDecoder('utf8');
     }
     getPosition() {
-        return this.filePosition;
+        return this.committedPosition;
     }
     seekTo(position) {
-        this.filePosition = position;
-        this.lineBuffer = '';
-        this.decoder = new string_decoder_1.StringDecoder('utf8');
+        // Rebuild model, turn, and cumulative-token context before resuming.
+        // The prefix is parsed only; its events are already in the consumer snapshot.
+        this.reset();
+        if (position > 0)
+            this.readNew(position);
     }
     wasTruncated() {
         return this._wasTruncated;

package/dist/search/sessionSearch.d.ts

@@ -1,6 +1,4 @@
-/**
- * Provider-aware cross-session search.
- */
+/** Provider-aware cross-session search. */
 import type { SessionProviderBase, ProviderId } from '../providers/types';
 export interface SearchResult {
     providerId: ProviderId;
@@ -10,7 +8,13 @@ export interface SearchResult {
     eventType: string;
     timestamp: string;
 }
-export declare function searchSessions(provider: SessionProviderBase, query: string, opts?: {
+export interface SessionSearchOptions {
+    /** Workspace path, resolved canonically. Takes precedence over projectSlug. */
+    projectPath?: string;
+    /** Legacy provider-encoded project identifier. */
     projectSlug?: string;
     maxResults?: number;
-}): Promise<SearchResult[]>;
+    /** Stop obsolete interactive searches between session reads. */
+    signal?: AbortSignal;
+}
+export declare function searchSessions(provider: SessionProviderBase, query: string, options?: SessionSearchOptions): Promise<SearchResult[]>;

package/dist/search/sessionSearch.js

@@ -1,98 +1,69 @@
 "use strict";
-/**
- * Provider-aware cross-session search.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+/** Provider-aware cross-session search. */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.searchSessions = searchSessions;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-async function searchSessions(provider, query, opts) {
-    const maxResults = opts?.maxResults ?? 50;
+const paths_1 = require("../paths");
+async function enumerateSessions(provider, options) {
+    const workspace = options.projectPath
+        ? (0, paths_1.resolveProjectIdentity)(options.projectPath).resolvedCwd
+        : undefined;
+    if (!options.projectSlug || workspace) {
+        if (provider.listSessionFilesAsync)
+            return provider.listSessionFilesAsync(workspace);
+        if (workspace) {
+            return provider
+                .findAllSessions(workspace)
+                .map((path) => ({ path, mtime: new Date(0), workspacePath: workspace }));
+        }
+        if (provider.listAllSessionFiles)
+            return provider.listAllSessionFiles();
+    }
+    // Older/custom providers can expose virtual project directories. Let the
+    // provider enumerate them instead of assuming a particular on-disk layout.
+    const files = [];
+    for (const folder of provider.getAllProjectFolders()) {
+        if (options.signal?.aborted)
+            break;
+        if (options.projectSlug && folder.encodedName !== options.projectSlug)
+            continue;
+        const paths = provider.id === 'codex'
+            ? provider.findAllSessions(folder.name)
+            : provider.findSessionsInDirectory(folder.dir);
+        files.push(...paths.map((path) => ({ path, mtime: folder.lastModified, workspacePath: folder.name })));
+    }
+    return files;
+}
+async function searchSessions(provider, query, options = {}) {
+    const maxResults = options.maxResults ?? 50;
     const results = [];
-    const baseDir = provider.getProjectsBaseDir();
-    try {
-        if (!fs.existsSync(baseDir))
-            return results;
-        // Get all project folders
-        const folders = provider.getAllProjectFolders();
-        for (const folder of folders) {
-            if (results.length >= maxResults)
-                break;
-            // If projectSlug specified, filter by encoded name
-            if (opts?.projectSlug && folder.encodedName !== opts.projectSlug)
-                continue;
-            // Get session files in this folder
-            let sessionFiles = [];
-            try {
-                const dir = folder.dir;
-                if (fs.existsSync(dir)) {
-                    const entries = fs
-                        .readdirSync(dir)
-                        .filter((f) => f.endsWith('.jsonl') || f.endsWith('.json'));
-                    sessionFiles = entries.map((f) => path.join(dir, f));
-                }
-            }
-            catch {
-                /* skip */
-            }
-            // If no files found from dir scan, try findAllSessions with the folder name
-            if (sessionFiles.length === 0) {
-                // Let canonical directory discovery handle synthetic DB-backed paths.
-                sessionFiles = provider.findSessionsInDirectory(folder.dir);
-            }
-            for (const sessionPath of sessionFiles) {
-                if (results.length >= maxResults)
-                    break;
-                const remaining = maxResults - results.length;
-                const hits = provider.searchInSession(sessionPath, query, remaining);
-                for (const hit of hits) {
-                    results.push({
-                        providerId: provider.id,
-                        projectPath: hit.projectPath || folder.name,
-                        sessionPath: hit.sessionPath,
-                        snippet: hit.line,
-                        eventType: hit.eventType,
-                        timestamp: hit.timestamp,
-                    });
-                }
+    if (maxResults <= 0 || !query.trim() || options.signal?.aborted)
+        return results;
+    const files = await enumerateSessions(provider, options);
+    const seen = new Set();
+    files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    for (const file of files) {
+        if (results.length >= maxResults || options.signal?.aborted)
+            break;
+        if (seen.has(file.path))
+            continue;
+        seen.add(file.path);
+        try {
+            const hits = provider.searchInSession(file.path, query, maxResults - results.length);
+            for (const hit of hits.slice(0, maxResults - results.length)) {
+                results.push({
+                    providerId: provider.id,
+                    projectPath: hit.projectPath || file.workspacePath || '',
+                    sessionPath: hit.sessionPath,
+                    snippet: hit.line,
+                    eventType: hit.eventType,
+                    timestamp: hit.timestamp,
+                });
             }
         }
+        catch {
+            // An unreadable session must not hide matches in the remaining sessions.
+        }
+        await new Promise((resolve) => setImmediate(resolve));
     }
-    catch {
-        /* skip */
-    }
-    return results.slice(0, maxResults);
+    return results;
 }

package/dist/watchers/factory.js

@@ -38,17 +38,11 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveSessionPath = resolveSessionPath;
 exports.createWatcher = createWatcher;
-const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const openCode_1 = require("../providers/openCode");
 const jsonlWatcher_1 = require("./jsonlWatcher");
 const providerReaderWatcher_1 = require("./providerReaderWatcher");
 const sqliteWatcher_1 = require("./sqliteWatcher");
-function getOpenCodeDataDir() {
-    const xdg = process.env.XDG_DATA_HOME;
-    if (xdg)
-        return path.join(xdg, 'opencode');
-    return path.join(os.homedir(), '.local', 'share', 'opencode');
-}
 /**
  * Resolve the session a command should act on: an exact or unique-prefix
  * match of `sessionId` among the workspace's sessions, or the most recent
@@ -94,7 +88,7 @@ function createWatcherForProvider(provider, sessionPath, callbacks) {
         case 'codex':
             return new providerReaderWatcher_1.ProviderReaderSessionWatcher(provider, sessionPath, callbacks);
         case 'opencode': {
-            const dataDir = getOpenCodeDataDir();
+            const dataDir = (0, openCode_1.getOpenCodeDataDir)();
             const dbPath = path.join(dataDir, 'opencode.db');
             // Session ID is the basename without extension
             const sid = path.basename(sessionPath, '.json');

package/dist/watchers/jsonlTail.js

@@ -42,6 +42,26 @@ const fs = __importStar(require("fs"));
 const jsonl_1 = require("../parsers/jsonl");
 const DEFAULT_DEBOUNCE_MS = 100;
 const DEFAULT_CATCHUP_INTERVAL_MS = 30_000;
+/** Skip old complete events while retaining an in-progress final line. */
+function lastCompleteLineOffset(filePath) {
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        let end = fs.fstatSync(fd).size;
+        const buffer = Buffer.alloc(64 * 1024);
+        while (end > 0) {
+            const start = Math.max(0, end - buffer.length);
+            const count = fs.readSync(fd, buffer, 0, end - start, start);
+            const newline = buffer.subarray(0, count).lastIndexOf(0x0a);
+            if (newline >= 0)
+                return start + newline + 1;
+            end = start;
+        }
+        return 0;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
 function createJsonlTail(options) {
     return new JsonlTailReader(options);
 }
@@ -79,7 +99,7 @@ class JsonlTailReader {
         this.active = true;
         if (this.options.startAtEnd && this.options.startOffset === undefined) {
             try {
-                this.readOffset = fs.statSync(this.options.path).size;
+                this.readOffset = lastCompleteLineOffset(this.options.path);
             }
             catch {
                 this.readOffset = 0;
@@ -179,7 +199,11 @@ class JsonlTailReader {
             this.fsWatcher = fs.watch(this.options.path, { persistent: false }, () => {
                 this.debouncedRead();
             });
-            this.fsWatcher.on('error', (error) => this.options.onError?.(error));
+            this.fsWatcher.on('error', (error) => {
+                this.fsWatcher?.close();
+                this.fsWatcher = null;
+                this.options.onError?.(error);
+            });
         }
         catch {
             // Polling still covers filesystems where fs.watch is unavailable.

package/dist/watchers/jsonlWatcher.d.ts

@@ -5,26 +5,20 @@
 import type { ProviderId } from '../providers/types';
 import type { SessionWatcher, SessionWatcherCallbacks } from './types';
 export declare class JsonlSessionWatcher implements SessionWatcher {
-    private _isActive;
-    private filePosition;
-    private fsWatcher;
-    private catchupTimer;
-    private debounceTimer;
-    private codexInPlanMode;
-    private readonly parser;
     private readonly providerId;
     private readonly sessionPath;
     private readonly callbacks;
+    private tail;
+    private startOffset;
+    private codexInPlanMode;
     constructor(providerId: ProviderId, sessionPath: string, callbacks: SessionWatcherCallbacks);
     get isActive(): boolean;
-    /** Seek to a byte offset. Must be called before start(). */
+    /** Seek to a committed byte offset before starting replay. */
     seekTo(position: number): void;
-    /** Get the current byte position. */
+    /** Position after the last complete JSONL line. */
     getPosition(): number;
     start(replay: boolean): void;
     stop(): void;
-    private debouncedRead;
-    private readNewBytes;
     private handleRawEvent;
     private normalizeCodexEvent;
 }

package/dist/watchers/jsonlWatcher.js

@@ -3,47 +3,11 @@
  * JSONL session watcher for Claude Code and Codex.
  * Uses byte-offset tracking + fs.watch with debounce + catch-up polling.
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonlSessionWatcher = void 0;
-const fs = __importStar(require("fs"));
-const jsonl_1 = require("../parsers/jsonl");
+const jsonlTail_1 = require("./jsonlTail");
 const codexParser_1 = require("../parsers/codexParser");
 const toolSummary_1 = require("../formatters/toolSummary");
-const DEBOUNCE_MS = 100;
-const CATCHUP_INTERVAL_MS = 30_000;
 // ── Normalizers ──
 function normalizeClaudeCodeEvent(raw) {
     const events = [];
@@ -220,139 +184,46 @@ function truncate(text, maxLen) {
 }
 // ── Watcher ──
 class JsonlSessionWatcher {
-    _isActive = false;
-    filePosition = 0;
-    fsWatcher = null;
-    catchupTimer = null;
-    debounceTimer = null;
-    codexInPlanMode = false;
-    parser;
     providerId;
     sessionPath;
     callbacks;
+    tail;
+    startOffset;
+    codexInPlanMode = false;
     constructor(providerId, sessionPath, callbacks) {
         this.providerId = providerId;
         this.sessionPath = sessionPath;
         this.callbacks = callbacks;
-        this.parser = new jsonl_1.JsonlParser({
-            onEvent: (event) => this.handleRawEvent(event),
-            onError: (err) => callbacks.onError?.(err),
-        });
     }
     get isActive() {
-        return this._isActive;
+        return this.tail?.isActive ?? false;
     }
-    /** Seek to a byte offset. Must be called before start(). */
+    /** Seek to a committed byte offset before starting replay. */
     seekTo(position) {
-        this.filePosition = position;
-        this.parser.reset();
+        this.startOffset = Math.max(0, position);
+        this.tail?.seekTo(this.startOffset);
     }
-    /** Get the current byte position. */
+    /** Position after the last complete JSONL line. */
     getPosition() {
-        return this.filePosition;
+        return this.tail?.getOffset() ?? this.startOffset ?? 0;
     }
     start(replay) {
-        if (this._isActive)
+        if (this.isActive)
             return;
-        this._isActive = true;
-        if (replay) {
-            // Read entire file from offset 0
-            this.readNewBytes();
-        }
-        else {
-            // Skip to end of file
-            try {
-                const stat = fs.statSync(this.sessionPath);
-                this.filePosition = stat.size;
-            }
-            catch {
-                this.filePosition = 0;
-            }
-        }
-        // Watch for changes
-        try {
-            this.fsWatcher = fs.watch(this.sessionPath, { persistent: false }, () => {
-                this.debouncedRead();
-            });
-            this.fsWatcher.on('error', (error) => {
-                // Degrade to catch-up polling without killing the live session.
-                this.fsWatcher?.close();
-                this.fsWatcher = null;
-                this.callbacks.onError?.(error);
-            });
-        }
-        catch {
-            // fs.watch not available, rely on polling only
-        }
-        // Catch-up polling
-        this.catchupTimer = setInterval(() => {
-            if (this._isActive)
-                this.readNewBytes();
-        }, CATCHUP_INTERVAL_MS);
+        this.tail = (0, jsonlTail_1.createJsonlTail)({
+            path: this.sessionPath,
+            startOffset: replay ? this.getPosition() : undefined,
+            startAtEnd: !replay,
+            onEvent: (event) => this.handleRawEvent(event),
+            onBatchComplete: () => this.callbacks.onBatchComplete?.(),
+            onError: (error) => this.callbacks.onError?.(error),
+        });
+        this.tail.start();
     }
     stop() {
-        if (!this._isActive)
-            return;
-        this._isActive = false;
-        if (this.debounceTimer) {
-            clearTimeout(this.debounceTimer);
-            this.debounceTimer = null;
-        }
-        if (this.fsWatcher) {
-            this.fsWatcher.close();
-            this.fsWatcher = null;
-        }
-        if (this.catchupTimer) {
-            clearInterval(this.catchupTimer);
-            this.catchupTimer = null;
-        }
-        this.parser.flush();
+        this.tail?.stop();
         this.codexInPlanMode = false;
     }
-    debouncedRead() {
-        if (this.debounceTimer)
-            clearTimeout(this.debounceTimer);
-        this.debounceTimer = setTimeout(() => {
-            this.readNewBytes();
-        }, DEBOUNCE_MS);
-    }
-    readNewBytes() {
-        if (!this._isActive)
-            return;
-        let fd = null;
-        try {
-            const stat = fs.statSync(this.sessionPath);
-            // Handle file truncation (shouldn't happen with append-only, but be safe)
-            if (stat.size < this.filePosition) {
-                this.filePosition = 0;
-                this.parser.reset();
-            }
-            if (stat.size <= this.filePosition)
-                return;
-            fd = fs.openSync(this.sessionPath, 'r');
-            const bytesToRead = stat.size - this.filePosition;
-            const buffer = Buffer.alloc(bytesToRead);
-            const bytesRead = fs.readSync(fd, buffer, 0, bytesToRead, this.filePosition);
-            fs.closeSync(fd);
-            fd = null;
-            if (bytesRead > 0) {
-                this.filePosition += bytesRead;
-                const chunk = buffer.toString('utf-8', 0, bytesRead);
-                this.parser.processChunk(chunk);
-            }
-        }
-        catch (err) {
-            if (fd !== null) {
-                try {
-                    fs.closeSync(fd);
-                }
-                catch {
-                    /* ignore */
-                }
-            }
-            this.callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
-        }
-    }
     handleRawEvent(event) {
         // For codex, raw events don't match RawSessionEvent shape exactly, but
         // JsonlParser parses any JSON object. Cast to Record for codex normalizer.

package/dist/watchers/providerReaderWatcher.js

@@ -112,12 +112,13 @@ class ProviderReaderSessionWatcher {
             clearInterval(this.catchupTimer);
             this.catchupTimer = null;
         }
-        this.reader.flush();
+        // Keep unfinished input buffered so a later start can resume losslessly.
     }
     seekToEnd() {
         try {
-            const stat = fs.statSync(this.sessionPath);
-            this.reader.seekTo(stat.size);
+            // Consume existing complete records to retain parser context and any
+            // unfinished line, without emitting historical events.
+            this.reader.readNew();
         }
         catch {
             this.reader.reset();
@@ -143,6 +144,7 @@ class ProviderReaderSessionWatcher {
                     this.callbacks.onEvent(followEvent);
                 }
             }
+            this.callbacks.onBatchComplete?.();
         }
         catch (err) {
             this.callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));

package/dist/watchers/sqliteWatcher.js

@@ -312,6 +312,7 @@ class SqliteSessionWatcher {
                 if (part.time_updated > this.lastPartTime)
                     this.lastPartTime = part.time_updated;
             }
+            this.callbacks.onBatchComplete?.();
         }
         catch (err) {
             this.callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));

package/dist/watchers/types.d.ts

@@ -46,6 +46,8 @@ export interface FollowEvent {
 }
 export interface SessionWatcherCallbacks {
     onEvent: (event: FollowEvent) => void;
+    /** All events in this read have been delivered; the cursor can now be checkpointed. */
+    onBatchComplete?: () => void;
     onError?: (error: Error) => void;
 }
 export interface SessionWatcher {