mindoodb 0.0.88 → 0.0.90

package/dist/core/indexing/virtualviews/VirtualView.d.ts

@@ -6,6 +6,7 @@ import { CategorizationStyle } from "./types";
 import type { LocalCacheStore } from "../../cache/LocalCacheStore";
 import type { CacheManager } from "../../cache/CacheManager";
 import type { MindooDB } from "../../types";
+import { VirtualViewFilingJoin } from "./VirtualViewFilingJoin";
 /** Statistics passed to {@link VirtualView.onDidUpdate} listeners. */
 export interface VirtualViewUpdateStats {
     /** Entries added or replaced by the applied change batch. */
@@ -48,6 +49,11 @@ export declare class VirtualView {
     private readonly viewHasTotalColumns;
     /** Categorization style (categories before/after documents) */
     private categorizationStyle;
+    /**
+     * Shared child comparators (immutable): one per categorization style and
+     * category direction instead of one per entry.
+     */
+    private readonly comparators;
     /** Whether the index has been built */
     private indexBuilt;
     /** Root entry of the view tree */
@@ -58,6 +64,8 @@ export declare class VirtualView {
     private entriesByDocId;
     /** Data providers */
     private dataProviderByOrigin;
+    /** Filing stores joined into this view (`withFilingStore`), or null. */
+    private filingJoin;
     /** Build-time data-source decision per origin (only for builder `withDB` sources) */
     private dataSourceInfoByOrigin;
     /** Entries pending sibling index recalculation */
@@ -80,10 +88,24 @@ export declare class VirtualView {
     private lastCacheFlushAt;
     /** Whether the most recent flush attempt was deferred by the min interval. */
     private lastFlushDeferred;
+    private journalPending;
+    private journalEntriesSinceSnapshot;
+    /** Document entries in the last written/restored snapshot, `null` = none yet. */
+    private snapshotDocCount;
+    private nextJournalSegment;
+    /**
+     * Journal chain of this instance. Several VirtualView instances may
+     * cache under the same key (several navigators over one definition,
+     * several browser tabs); each writes its own chain and a snapshot names
+     * the chain that continues it, so chains never interleave.
+     */
+    private readonly journalWriterId;
+    private replayingJournal;
     private updateListeners;
     private liveUnsubscribes;
     private liveUpdateRunning;
     private liveUpdatePending;
+    private liveBoundDbs;
     constructor(columns: VirtualViewColumn[]);
     /**
      * Set the categorization style
@@ -132,6 +154,20 @@ export declare class VirtualView {
      *   forwarded to each data provider (see {@link VirtualViewUpdateOptions}).
      */
     update(options?: VirtualViewUpdateOptions): Promise<void>;
+    /**
+     * Attach the filing stores this view joins (`withFilingStore`). Called by
+     * the view builder before the first update; not intended for user code.
+     */
+    setFilingJoin(join: VirtualViewFilingJoin | null): this;
+    /** The filing stores joined into this view, or `null`. */
+    getFilingJoin(): VirtualViewFilingJoin | null;
+    /**
+     * Bring the joined filing indexes up to date FIRST (otherwise a fresh
+     * build would briefly show rows without their folders) and hand the
+     * membership delta to every provider; providers keep it until they have
+     * processed it, so an interrupted provider update loses nothing.
+     */
+    private refreshFilingJoin;
     /**
      * Update a specific data provider by origin
      *
@@ -139,6 +175,8 @@ export declare class VirtualView {
      *   forwarded to the data provider (see {@link VirtualViewUpdateOptions}).
      */
     updateOrigin(origin: string, options?: VirtualViewUpdateOptions): Promise<void>;
+    /** The (shared) comparator for an entry's children. */
+    private comparatorFor;
     /**
      * Get the root entry of the view
      */
@@ -229,16 +267,34 @@ export declare class VirtualView {
     hasDirtyState(): boolean;
     clearDirty(): void;
     /**
-     * Export the view state to the cache store.
+     * Export the view state to the cache store — as snapshot + change
+     * journal:
+     *
+     * - Normally only the change batches applied since the last flush are
+     *   appended as a small journal segment (`vvj` records), together with
+     *   the data providers' cursors. Cost: O(changes), not O(view).
+     * - The full tree snapshot (`vv`) is rewritten when there is none yet,
+     *   when the journal holds more than {@link JOURNAL_COMPACT_RATIO} of
+     *   the snapshot's entries (compaction), and on forced flushes
+     *   (shutdown/deregister — "on close"). Full snapshots are still
+     *   throttled by {@link minCacheFlushIntervalMs}; a throttled compaction
+     *   writes a journal segment instead.
      *
-     * Full-tree serialization is throttled by {@link minCacheFlushIntervalMs}
-     * so active editing sessions don't serialize the entire view on every
-     * periodic flush; `force: true` (shutdown/deregister) bypasses the
-     * throttle.
+     * Restoring loads the snapshot and replays the journal segments written
+     * after it.
      */
     flushToCache(store: LocalCacheStore, options?: {
         force?: boolean;
     }): Promise<number>;
+    /** Doc ids of the document entries an origin contributes to the view. */
+    private documentIdsOfOrigin;
+    private countDocumentEntries;
+    private exportProviderStates;
+    private journalSegmentId;
+    /** Journal segments of this view in the store (all writers). */
+    private listJournalSegments;
+    /** Drop every journal segment of this view (after a snapshot they are folded in or stale). */
+    private deleteJournalSegments;
     /**
      * Serialize the entire tree structure for caching (version 2).
      * Each node stores its sort key, column values, counts, totals,
@@ -254,6 +310,15 @@ export declare class VirtualView {
      * Attempt to restore the view from cache. Returns true on success.
      */
     restoreFromCache(store: LocalCacheStore): Promise<boolean>;
+    /**
+     * Replay the journal segments written after the snapshot (numbers >=
+     * `journalBase`), in order; the last segment's provider cursors and
+     * filing positions win. A missing or corrupt segment ends the replay:
+     * later segments would build on a state that never existed, and the
+     * providers' cursors of the last good segment make the next update catch
+     * up from there.
+     */
+    private replayJournal;
     /**
      * Restore the full tree structure directly from a version-2 snapshot.
      * O(n) — no re-sorting, no category re-creation, no count recalculation.

package/dist/core/indexing/virtualviews/VirtualView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VirtualView.d.ts","sourceRoot":"","sources":["../../../../src/core/indexing/virtualviews/VirtualView.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"VirtualView.d.ts","sourceRoot":"","sources":["../../../../src/core/indexing/virtualviews/VirtualView.ts"],"names":[],"mappings":"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"}

package/dist/core/indexing/virtualviews/VirtualView.js

@@ -6,6 +6,12 @@ const VirtualViewDataChange_1 = require("./VirtualViewDataChange");
 const ViewEntrySortKey_1 = require("./ViewEntrySortKey");
 const ViewEntrySortKeyComparator_1 = require("./ViewEntrySortKeyComparator");
 const types_1 = require("./types");
+const idGeneration_1 = require("../../utils/idGeneration");
+const VirtualViewFilingJoin_1 = require("./VirtualViewFilingJoin");
+/** Rewrite the snapshot once the journal holds more than this share of its entries. */
+const JOURNAL_COMPACT_RATIO = 0.1;
+/** ...but never for fewer journal entries than this (tiny views). */
+const JOURNAL_MIN_COMPACT_ENTRIES = 100;
 /**
  * VirtualView creates a hierarchical, sorted view of documents from one or more MindooDB instances.
  * Documents are organized into categories (tree structure) with sorting and optional totals.
@@ -14,6 +20,11 @@ class VirtualView {
     constructor(columns) {
         /** Categorization style (categories before/after documents) */
         this.categorizationStyle = types_1.CategorizationStyle.DOCUMENT_THEN_CATEGORY;
+        /**
+         * Shared child comparators (immutable): one per categorization style and
+         * category direction instead of one per entry.
+         */
+        this.comparators = new Map();
         /** Whether the index has been built */
         this.indexBuilt = false;
         /** Root entry of the view tree */
@@ -24,6 +35,8 @@ class VirtualView {
         this.entriesByDocId = new Map();
         /** Data providers */
         this.dataProviderByOrigin = new Map();
+        /** Filing stores joined into this view (`withFilingStore`), or null. */
+        this.filingJoin = null;
         /** Build-time data-source decision per origin (only for builder `withDB` sources) */
         this.dataSourceInfoByOrigin = new Map();
         /** Entries pending sibling index recalculation */
@@ -47,11 +60,29 @@ class VirtualView {
         this.lastCacheFlushAt = 0;
         /** Whether the most recent flush attempt was deferred by the min interval. */
         this.lastFlushDeferred = false;
+        // Change journal (see flushToCache): applied change batches since the
+        // last flush, appended to the cache as small segments instead of
+        // rewriting the whole tree; the snapshot is rewritten only when the
+        // journal outgrows JOURNAL_COMPACT_RATIO of it, or on forced flushes.
+        this.journalPending = [];
+        this.journalEntriesSinceSnapshot = 0;
+        /** Document entries in the last written/restored snapshot, `null` = none yet. */
+        this.snapshotDocCount = null;
+        this.nextJournalSegment = 0;
+        /**
+         * Journal chain of this instance. Several VirtualView instances may
+         * cache under the same key (several navigators over one definition,
+         * several browser tabs); each writes its own chain and a snapshot names
+         * the chain that continues it, so chains never interleave.
+         */
+        this.journalWriterId = (0, idGeneration_1.generateRandomUuid)().replace(/-/g, "").slice(0, 12);
+        this.replayingJournal = false;
         // Live-view support (see bindTo/onDidUpdate)
         this.updateListeners = new Set();
         this.liveUnsubscribes = [];
         this.liveUpdateRunning = false;
         this.liveUpdatePending = false;
+        this.liveBoundDbs = new Set();
         this.columns = [...columns];
         this.categoryColumns = [];
         this.sortColumns = [];
@@ -164,10 +195,44 @@ class VirtualView {
      *   forwarded to each data provider (see {@link VirtualViewUpdateOptions}).
      */
     async update(options) {
+        await this.refreshFilingJoin();
         for (const provider of this.dataProviderByOrigin.values()) {
             await provider.update(options);
         }
     }
+    /**
+     * Attach the filing stores this view joins (`withFilingStore`). Called by
+     * the view builder before the first update; not intended for user code.
+     */
+    setFilingJoin(join) {
+        this.filingJoin = join;
+        return this;
+    }
+    /** The filing stores joined into this view, or `null`. */
+    getFilingJoin() {
+        return this.filingJoin;
+    }
+    /**
+     * Bring the joined filing indexes up to date FIRST (otherwise a fresh
+     * build would briefly show rows without their folders) and hand the
+     * membership delta to every provider; providers keep it until they have
+     * processed it, so an interrupted provider update loses nothing.
+     */
+    async refreshFilingJoin() {
+        if (!this.filingJoin) {
+            return;
+        }
+        const changes = await this.filingJoin.refresh();
+        if (changes !== "all" && changes.size === 0) {
+            return;
+        }
+        for (const provider of this.dataProviderByOrigin.values()) {
+            if ((0, VirtualViewFilingJoin_1.isFilingAwareDataProvider)(provider)) {
+                provider.onFilingChanges(changes);
+            }
+        }
+        this.markViewDirty();
+    }
     /**
      * Update a specific data provider by origin
      *
@@ -177,9 +242,26 @@ class VirtualView {
     async updateOrigin(origin, options) {
         const provider = this.dataProviderByOrigin.get(origin);
         if (provider) {
+            await this.refreshFilingJoin();
             await provider.update(options);
         }
     }
+    /** The (shared) comparator for an entry's children. */
+    comparatorFor(categoryOrderDescending, docOrderDescending = this.docOrderDescending) {
+        const shareable = docOrderDescending === this.docOrderDescending ||
+            (docOrderDescending.length === this.docOrderDescending.length &&
+                docOrderDescending.every((value, index) => value === this.docOrderDescending[index]));
+        if (!shareable) {
+            return new ViewEntrySortKeyComparator_1.ViewEntrySortKeyComparator(this.categorizationStyle, categoryOrderDescending, docOrderDescending);
+        }
+        const key = `${this.categorizationStyle}|${categoryOrderDescending ? 1 : 0}`;
+        let comparator = this.comparators.get(key);
+        if (!comparator) {
+            comparator = new ViewEntrySortKeyComparator_1.ViewEntrySortKeyComparator(this.categorizationStyle, categoryOrderDescending, this.docOrderDescending);
+            this.comparators.set(key, comparator);
+        }
+        return comparator;
+    }
     /**
      * Get the root entry of the view
      */
@@ -188,10 +270,10 @@ class VirtualView {
             // Create root comparator
             let rootChildComparator;
             if (this.categoryColumns.length === 0) {
-                rootChildComparator = new ViewEntrySortKeyComparator_1.ViewEntrySortKeyComparator(this.categorizationStyle, false, this.docOrderDescending);
+                rootChildComparator = this.comparatorFor(false);
             }
             else {
-                rootChildComparator = new ViewEntrySortKeyComparator_1.ViewEntrySortKeyComparator(this.categorizationStyle, this.categoryColumns[0].sorting === types_1.ColumnSorting.DESCENDING, this.docOrderDescending);
+                rootChildComparator = this.comparatorFor(this.categoryColumns[0].sorting === types_1.ColumnSorting.DESCENDING);
             }
             const rootSortKey = ViewEntrySortKey_1.ViewEntrySortKey.createSortKey(true, [], types_1.ORIGIN_VIRTUALVIEW, "root");
             const rootDocId = this.createNewCategoryId();
@@ -220,6 +302,15 @@ class VirtualView {
     applyChanges(change) {
         this.indexBuilt = true;
         let indexChanged = false;
+        if (this.cacheManager && !this.replayingJournal && change.hasChanges()) {
+            this.journalPending.push({
+                o: change.origin,
+                r: Array.from(change.getRemovals()),
+                a: Array.from(change.getAdditions().values(), (entry) => entry.decryptionKeyId !== undefined
+                    ? [entry.docId, entry.values, entry.decryptionKeyId]
+                    : [entry.docId, entry.values]),
+            });
+        }
         const origin = change.origin;
         const categoryEntriesToCheck = [];
         // Collect all doc IDs to remove (both explicit removals and additions that need re-adding)
@@ -346,9 +437,32 @@ class VirtualView {
         if (!db.addChangeListener) {
             throw new Error("This MindooDB instance does not support change listeners.");
         }
-        const unsubscribe = db.addChangeListener(() => {
-            this.scheduleLiveUpdate();
-        });
+        const unsubscribes = [
+            db.addChangeListener(() => {
+                this.scheduleLiveUpdate();
+            }),
+        ];
+        // Filing changes live in the filing databases: bind those too (once
+        // per view), so filing/moving documents updates the view live.
+        for (const filingDb of this.filingJoin?.getDatabases() ?? []) {
+            if (filingDb === db || this.liveBoundDbs.has(filingDb) || !filingDb.addChangeListener) {
+                continue;
+            }
+            this.liveBoundDbs.add(filingDb);
+            const unsubscribeFiling = filingDb.addChangeListener(() => {
+                this.scheduleLiveUpdate();
+            });
+            unsubscribes.push(() => {
+                unsubscribeFiling();
+                this.liveBoundDbs.delete(filingDb);
+            });
+        }
+        this.liveBoundDbs.add(db);
+        const unsubscribe = () => {
+            for (const fn of unsubscribes)
+                fn();
+            this.liveBoundDbs.delete(db);
+        };
         this.liveUnsubscribes.push(unsubscribe);
         this.scheduleLiveUpdate();
         return () => {
@@ -435,7 +549,7 @@ class VirtualView {
                 docSortValues.push(this.getFirstListValue(value));
             }
             const sortKey = ViewEntrySortKey_1.ViewEntrySortKey.createSortKey(false, docSortValues, origin, docId);
-            const childComparator = new ViewEntrySortKeyComparator_1.ViewEntrySortKeyComparator(this.categorizationStyle, false, this.docOrderDescending);
+            const childComparator = this.comparatorFor(false);
             const newDocEntry = new VirtualViewEntryData_1.VirtualViewEntryData(this, targetParent, origin, docId, sortKey, childComparator, decryptionKeyId);
             newDocEntry.setColumnValues(columnValues);
             if (targetParent.addChildEntry(newDocEntry)) {
@@ -492,7 +606,7 @@ class VirtualView {
                             const nextCatColumn = remainingColumns.length > 0 ? remainingColumns[0] : null;
                             childCategoryDescending = nextCatColumn?.sorting === types_1.ColumnSorting.DESCENDING;
                         }
-                        const childComparator = new ViewEntrySortKeyComparator_1.ViewEntrySortKeyComparator(this.categorizationStyle, childCategoryDescending, this.docOrderDescending);
+                        const childComparator = this.comparatorFor(childCategoryDescending);
                         const newCategoryId = this.createNewCategoryId();
                         existingCategory = new VirtualViewEntryData_1.VirtualViewEntryData(this, currentParent, types_1.ORIGIN_VIRTUALVIEW, newCategoryId, categorySortKey, childComparator);
                         const catColValues = {};
@@ -526,7 +640,7 @@ class VirtualView {
                 if (!existingCategory) {
                     const nextCatColumn = remainingColumns.length > 0 ? remainingColumns[0] : null;
                     const childCategoryDescending = nextCatColumn?.sorting === types_1.ColumnSorting.DESCENDING;
-                    const childComparator = new ViewEntrySortKeyComparator_1.ViewEntrySortKeyComparator(this.categorizationStyle, childCategoryDescending, this.docOrderDescending);
+                    const childComparator = this.comparatorFor(childCategoryDescending);
                     const newCategoryId = this.createNewCategoryId();
                     existingCategory = new VirtualViewEntryData_1.VirtualViewEntryData(this, targetParent, types_1.ORIGIN_VIRTUALVIEW, newCategoryId, categorySortKey, childComparator);
                     const catColValues = {};
@@ -707,46 +821,151 @@ class VirtualView {
         this.isDirty = false;
     }
     /**
-     * Export the view state to the cache store.
+     * Export the view state to the cache store — as snapshot + change
+     * journal:
+     *
+     * - Normally only the change batches applied since the last flush are
+     *   appended as a small journal segment (`vvj` records), together with
+     *   the data providers' cursors. Cost: O(changes), not O(view).
+     * - The full tree snapshot (`vv`) is rewritten when there is none yet,
+     *   when the journal holds more than {@link JOURNAL_COMPACT_RATIO} of
+     *   the snapshot's entries (compaction), and on forced flushes
+     *   (shutdown/deregister — "on close"). Full snapshots are still
+     *   throttled by {@link minCacheFlushIntervalMs}; a throttled compaction
+     *   writes a journal segment instead.
      *
-     * Full-tree serialization is throttled by {@link minCacheFlushIntervalMs}
-     * so active editing sessions don't serialize the entire view on every
-     * periodic flush; `force: true` (shutdown/deregister) bypasses the
-     * throttle.
+     * Restoring loads the snapshot and replays the journal segments written
+     * after it.
      */
     async flushToCache(store, options) {
         const now = Date.now();
-        if (!options?.force
-            && this.lastCacheFlushAt > 0
-            && now - this.lastCacheFlushAt < this.minCacheFlushIntervalMs) {
+        const pending = this.journalPending;
+        const pendingCount = pending.reduce((sum, change) => sum + change.r.length + change.a.length, 0);
+        const journalTooLarge = this.snapshotDocCount !== null &&
+            this.journalEntriesSinceSnapshot + pendingCount >
+                Math.max(JOURNAL_MIN_COMPACT_ENTRIES, this.snapshotDocCount * JOURNAL_COMPACT_RATIO);
+        const wantSnapshot = options?.force === true || this.snapshotDocCount === null || journalTooLarge;
+        const throttled = !options?.force &&
+            this.lastCacheFlushAt > 0 &&
+            now - this.lastCacheFlushAt < this.minCacheFlushIntervalMs;
+        if (wantSnapshot && throttled && this.snapshotDocCount === null) {
+            // No snapshot to append to yet: defer as before.
             this.lastFlushDeferred = true;
             return 0;
         }
         this.lastFlushDeferred = false;
-        const state = this.exportCacheState();
-        await store.put("vv", this.getCachePrefix(), state);
-        this.lastCacheFlushAt = now;
+        if (wantSnapshot && !throttled) {
+            const journalBase = this.nextJournalSegment;
+            const state = this.exportCacheState(journalBase);
+            await store.put("vv", this.getCachePrefix(), state);
+            this.journalPending = [];
+            this.journalEntriesSinceSnapshot = 0;
+            this.snapshotDocCount = this.countDocumentEntries();
+            this.lastCacheFlushAt = now;
+            // Every existing segment is either folded into this snapshot or
+            // belongs to a chain this snapshot replaced (another instance, an
+            // older state).
+            await this.deleteJournalSegments(store);
+            return 1;
+        }
+        // Provider states without their `knownDocIds`: those equal the view's
+        // document entries of the provider's origin and are rebuilt from the
+        // tree on replay — writing them per segment would make every flush
+        // O(view) again.
+        const providerStates = this.exportProviderStates();
+        for (const [origin, state] of Object.entries(providerStates)) {
+            if (state && typeof state === "object" && Array.isArray(state.knownDocIds)) {
+                providerStates[origin] = { ...state, knownDocIds: undefined, knownDocIdsFromTree: true };
+            }
+        }
+        const segment = {
+            changes: pending,
+            providerStates,
+            filing: this.filingJoin?.exportState(),
+            categoryIdCounter: this.categoryIdCounter,
+        };
+        const segmentNo = this.nextJournalSegment;
+        await store.put("vvj", this.journalSegmentId(this.journalWriterId, segmentNo), new TextEncoder().encode(JSON.stringify(segment)));
+        this.nextJournalSegment = segmentNo + 1;
+        this.journalPending = this.journalPending.slice(pending.length);
+        this.journalEntriesSinceSnapshot += pendingCount;
         return 1;
     }
-    /**
-     * Serialize the entire tree structure for caching (version 2).
-     * Each node stores its sort key, column values, counts, totals,
-     * and children — so restoration is O(n) without re-sorting.
-     */
-    exportCacheState() {
-        const root = this.getRoot();
+    /** Doc ids of the document entries an origin contributes to the view. */
+    documentIdsOfOrigin(origin) {
+        const docIds = [];
+        for (const [scopedKey, entries] of this.entriesByDocId) {
+            const parsed = (0, types_1.parseScopedDocIdKey)(scopedKey);
+            if (parsed.origin === origin && entries.some((entry) => entry.isDocument())) {
+                docIds.push(parsed.docId);
+            }
+        }
+        return docIds;
+    }
+    countDocumentEntries() {
+        let count = 0;
+        for (const entries of this.entriesByDocId.values()) {
+            if (entries.some((entry) => entry.isDocument())) {
+                count++;
+            }
+        }
+        return count;
+    }
+    exportProviderStates() {
         const providerStates = {};
         for (const [origin, provider] of this.dataProviderByOrigin) {
             if ("exportCacheState" in provider && typeof provider.exportCacheState === "function") {
                 providerStates[origin] = provider.exportCacheState();
             }
         }
+        return providerStates;
+    }
+    journalSegmentId(writer, segment) {
+        return `${this.getCachePrefix()}/${writer}/${String(segment).padStart(10, "0")}`;
+    }
+    /** Journal segments of this view in the store (all writers). */
+    async listJournalSegments(store) {
+        const prefix = `${this.getCachePrefix()}/`;
+        const segments = [];
+        for (const id of await store.list("vvj")) {
+            if (!id.startsWith(prefix))
+                continue;
+            const [writer, number, ...rest] = id.slice(prefix.length).split("/");
+            const segment = Number(number);
+            if (writer && rest.length === 0 && Number.isInteger(segment)) {
+                segments.push({ writer, segment });
+            }
+        }
+        return segments.sort((a, b) => a.segment - b.segment);
+    }
+    /** Drop every journal segment of this view (after a snapshot they are folded in or stale). */
+    async deleteJournalSegments(store) {
+        try {
+            for (const { writer, segment } of await this.listJournalSegments(store)) {
+                await store.delete("vvj", this.journalSegmentId(writer, segment));
+            }
+        }
+        catch {
+            // Stale segments are ignored on restore (other chain or before the base).
+        }
+    }
+    /**
+     * Serialize the entire tree structure for caching (version 2).
+     * Each node stores its sort key, column values, counts, totals,
+     * and children — so restoration is O(n) without re-sorting.
+     */
+    exportCacheState(journalBase) {
+        const root = this.getRoot();
+        const providerStates = this.exportProviderStates();
         const snapshot = {
             version: 2,
+            journalWriter: this.journalWriterId,
+            journalBase,
             categoryIdCounter: this.categoryIdCounter,
             categorizationStyle: this.categorizationStyle,
             docOrderDescending: [...this.docOrderDescending],
             providerStates,
+            filing: this.filingJoin?.exportState(),
             tree: this.serializeNode(root),
         };
         return new TextEncoder().encode(JSON.stringify(snapshot));
@@ -812,7 +1031,11 @@ class VirtualView {
                 return false;
             const snapshot = JSON.parse(new TextDecoder().decode(bytes));
             if (snapshot.version === 2) {
-                return this.restoreFromTreeSnapshot(snapshot);
+                if (!this.restoreFromTreeSnapshot(snapshot)) {
+                    return false;
+                }
+                await this.replayJournal(store, typeof snapshot.journalWriter === "string" ? snapshot.journalWriter : null, typeof snapshot.journalBase === "number" ? snapshot.journalBase : 0);
+                return true;
             }
             return false;
         }
@@ -820,6 +1043,83 @@ class VirtualView {
             return false;
         }
     }
+    /**
+     * Replay the journal segments written after the snapshot (numbers >=
+     * `journalBase`), in order; the last segment's provider cursors and
+     * filing positions win. A missing or corrupt segment ends the replay:
+     * later segments would build on a state that never existed, and the
+     * providers' cursors of the last good segment make the next update catch
+     * up from there.
+     */
+    async replayJournal(store, writer, journalBase) {
+        // This instance continues with its OWN chain, so its first flush writes
+        // a fresh snapshot (another instance may have restored the same state
+        // and continue the restored chain concurrently otherwise).
+        this.snapshotDocCount = null;
+        this.journalEntriesSinceSnapshot = 0;
+        if (writer === null) {
+            return;
+        }
+        let segments;
+        try {
+            segments = (await this.listJournalSegments(store))
+                .filter((entry) => entry.writer === writer && entry.segment >= journalBase)
+                .map((entry) => entry.segment);
+        }
+        catch {
+            return;
+        }
+        let expected = journalBase;
+        this.replayingJournal = true;
+        // Only the last replayed segment's provider cursors matter.
+        const lastProviderStates = new Map();
+        try {
+            for (const segmentNo of segments) {
+                if (segmentNo !== expected) {
+                    break; // gap
+                }
+                const bytes = await store.get("vvj", this.journalSegmentId(writer, segmentNo));
+                if (!bytes)
+                    break;
+                const segment = JSON.parse(new TextDecoder().decode(bytes));
+                for (const serialized of segment.changes ?? []) {
+                    const change = new VirtualViewDataChange_1.VirtualViewDataChange(serialized.o);
+                    for (const docId of serialized.r)
+                        change.removeEntry(docId);
+                    for (const [docId, values, decryptionKeyId] of serialized.a) {
+                        change.addEntry(docId, values, decryptionKeyId);
+                    }
+                    this.applyChanges(change);
+                    this.journalEntriesSinceSnapshot += serialized.r.length + serialized.a.length;
+                }
+                for (const [origin, rawState] of Object.entries(segment.providerStates ?? {})) {
+                    lastProviderStates.set(origin, rawState);
+                }
+                this.filingJoin?.importState(segment.filing);
+                if (typeof segment.categoryIdCounter === "number") {
+                    this.categoryIdCounter = Math.max(this.categoryIdCounter, segment.categoryIdCounter);
+                }
+                expected = segmentNo + 1;
+            }
+        }
+        catch {
+            // Keep what was replayed; see above.
+        }
+        finally {
+            for (const [origin, rawState] of lastProviderStates) {
+                const provider = this.dataProviderByOrigin.get(origin);
+                let state = rawState;
+                if (state && typeof state === "object" && state.knownDocIdsFromTree) {
+                    state = { ...state, knownDocIds: this.documentIdsOfOrigin(origin) };
+                }
+                if (provider && "importCacheState" in provider && typeof provider.importCacheState === "function") {
+                    provider.importCacheState(state);
+                }
+            }
+            this.replayingJournal = false;
+            this.isDirty = false;
+        }
+    }
     /**
      * Restore the full tree structure directly from a version-2 snapshot.
      * O(n) — no re-sorting, no category re-creation, no count recalculation.
@@ -841,6 +1141,7 @@ class VirtualView {
         const treeData = snapshot.tree;
         if (!treeData)
             return false;
+        this.filingJoin?.importState(snapshot.filing);
         this.rootEntry = this.deserializeNode(treeData, null, docOrderDesc);
         this.indexBuilt = true;
         return true;
@@ -852,7 +1153,7 @@ class VirtualView {
     deserializeNode(data, parent, docOrderDesc) {
         const buildEntry = (nodeData, nodeParent) => {
             const sk = ViewEntrySortKey_1.ViewEntrySortKey.createSortKey(nodeData.sk.c, nodeData.sk.v, nodeData.sk.o, nodeData.sk.d);
-            const comparator = new ViewEntrySortKeyComparator_1.ViewEntrySortKeyComparator(this.categorizationStyle, nodeData.cod, docOrderDesc);
+            const comparator = this.comparatorFor(nodeData.cod === true, docOrderDesc);
             const entry = new VirtualViewEntryData_1.VirtualViewEntryData(this, nodeParent, nodeData.o, nodeData.d, sk, comparator, nodeData.dk);
             entry.setColumnValues(nodeData.cv ?? {});
             entry.setIndentLevels(nodeData.il ?? 0);