@vibes.diy/vibe-runtime 10.0.0 → 10.0.1

package/firefly-database.d.ts

@@ -36,18 +36,6 @@ export interface ChangeMeta {
     readonly ephemeral?: boolean;
 }
 export type ListenerFn<T extends DocTypes = DocTypes> = (changes: DocWithId<T>[], meta?: ChangeMeta) => void;
-export interface OfflineQueueStore {
-    put(doc: Record<string, unknown> & {
-        _id?: string;
-    }): Promise<DocResponse>;
-    del(id: string): Promise<DocResponse>;
-    snapshot<T extends DocTypes = DocTypes>(): DocWithId<T>[];
-}
-export interface AnonLedgerSource extends OfflineQueueStore {
-    clear(): void;
-    readonly size: number;
-}
-export type DrainMigrateFn = (doc: DocWithId, userHandle: string) => Record<string, unknown> | null | undefined | false;
 export interface IndexRow<T extends DocTypes = DocTypes> {
     key: string;
     value: DocWithId<T>;
@@ -114,46 +102,16 @@ export declare class FireflyDatabase {
     private readonly vibeApp;
     private readonly listeners;
     private readonly updateListeners;
-    private optimisticEnabled;
-    private readonly overlay;
-    private writeSeq;
-    private offlineQueue;
-    private anonFallback;
-    private queueGeneration;
-    private activeIdentity;
-    private readonly queueTokens;
-    private readonly liveWriteTokens;
-    private draining;
-    private drainTimer;
-    private drainBackoff;
-    private onlineHandler;
-    private readonly idChains;
     private readonly ephemeralOverlay;
     private readonly peerDocs;
     private ephemeralSeq;
     private ephemeralSweep;
     private grantedChannels;
     seedDocs?: DocWithId<DocTypes>[];
-    private retrySleep;
     constructor(name: string, vibeApi: FireflyTransport, acl?: DbAcl);
     resubscribe(): void;
     broadcastEphemeral(docId: string, doc: Record<string, unknown>): void;
     applyAcl(acl: DbAcl): void;
-    setOptimistic(enabled: boolean): void;
-    setOfflineQueue(store: OfflineQueueStore | undefined): void;
-    setAnonFallback(enabled: boolean): void;
-    setActiveIdentity(handle: string | undefined): void;
-    setRetrySleep(fn: (ms: number) => Promise<void>): void;
-    handoffAnonymousLedger(args: {
-        anonLedger: AnonLedgerSource;
-        handleLedger: OfflineQueueStore;
-        userHandle: string;
-        migrate?: DrainMigrateFn;
-    }): Promise<{
-        migrated: number;
-        dropped: number;
-    }>;
-    private foldQueueIntoOverlay;
     ready(): Promise<void>;
     close(): Promise<void>;
     destroy(): Promise<void>;
@@ -163,23 +121,6 @@ export declare class FireflyDatabase {
         _id?: string;
     }): Promise<DocResponse>;
     del(id: string): Promise<DocResponse>;
-    private clearOverlay;
-    private clearLiveWriteToken;
-    private rollback;
-    private classifyWriteError;
-    private retryNetworkWrite;
-    private canQueue;
-    private queueWrite;
-    private dropQueued;
-    private drainAfterSuccess;
-    private issueWrite;
-    private runExclusive;
-    private scheduleDrain;
-    private scheduleDrainBackoff;
-    private drain;
-    private settleDrained;
-    private installOnlineListener;
-    private removeOnlineListener;
     remove(id: string): Promise<DocResponse>;
     bulk<T extends DocTypes>(docs: (T & {
         _id?: string;
@@ -192,10 +133,8 @@ export declare class FireflyDatabase {
         serverDocs: DocWithId<T>[];
     }>;
     materializeLive<T extends DocTypes>(serverDocs: DocWithId<T>[], mapFn: MapFnArg<T>, opts?: QueryOpts): QueryResponse<T>;
-    private foldOverlays;
     private queryHint;
     private fetchServerDocs;
-    private applyOverlay;
     allDocs<T extends DocTypes>(opts?: {
         limit?: number;
         offset?: number;

package/firefly-database.js

@@ -1,4 +1,3 @@
-import { exception2Result, Result } from "@adviser/cement";
 import { isResPutDoc, isResGetDoc, isResQueryDocs, isResDeleteDoc, isEvtDocChanged, isEvtDocEphemeral, isEvtDocEphemeralDrop, } from "@vibes.diy/vibe-types";
 import { decorateFiles } from "./firefly-files-read.js";
 import { uploadFiles } from "./firefly-files-write.js";
@@ -43,21 +42,6 @@ export function newOptimisticId(now = Date.now()) {
     const hex = randomHex(10);
     return `${t.slice(0, 8)}-${t.slice(8)}-7${hex.slice(0, 3)}-${hex.slice(3, 7)}-${hex.slice(7, 19)}`;
 }
-const NETWORK_RETRY_LIMIT = 4;
-function hasRawFiles(doc) {
-    const files = doc._files;
-    if (files === null || typeof files !== "object")
-        return false;
-    const hasFile = typeof File !== "undefined";
-    const hasBlob = typeof Blob !== "undefined";
-    for (const v of Object.values(files)) {
-        if (hasFile && v instanceof File)
-            return true;
-        if (hasBlob && v instanceof Blob)
-            return true;
-    }
-    return false;
-}
 export function materializeQuery(allDocs, mapFn, opts) {
     let encodedRows;
     if (typeof mapFn === "string") {
@@ -184,30 +168,12 @@ export class FireflyDatabase {
     vibeApp;
     listeners = new Set();
     updateListeners = new Set();
-    optimisticEnabled = false;
-    overlay = new Map();
-    writeSeq = 0;
-    offlineQueue;
-    anonFallback = false;
-    queueGeneration = 0;
-    activeIdentity = undefined;
-    queueTokens = new Map();
-    liveWriteTokens = new Map();
-    draining = false;
-    drainTimer;
-    drainBackoff = 0;
-    onlineHandler;
-    idChains = new Map();
     ephemeralOverlay = new Map();
     peerDocs = new Map();
     ephemeralSeq = 0;
     ephemeralSweep;
     grantedChannels;
     seedDocs;
-    retrySleep = (ms) => new Promise((resolve) => {
-        const t = setTimeout(resolve, ms);
-        t.unref?.();
-    });
     constructor(name, vibeApi, acl) {
         this.name = name;
         this.vibeApi = vibeApi;
@@ -263,86 +229,6 @@ export class FireflyDatabase {
             }
         });
     }
-    setOptimistic(enabled) {
-        this.optimisticEnabled = enabled;
-        if (!enabled)
-            this.overlay.clear();
-    }
-    setOfflineQueue(store) {
-        if (store === this.offlineQueue)
-            return;
-        this.queueGeneration++;
-        for (const [id, token] of this.queueTokens)
-            this.rollback(id, token);
-        this.queueTokens.clear();
-        if (this.drainTimer !== undefined) {
-            clearTimeout(this.drainTimer);
-            this.drainTimer = undefined;
-        }
-        this.offlineQueue = store;
-        if (store !== undefined) {
-            this.foldQueueIntoOverlay(store);
-            this.installOnlineListener();
-            if (store.snapshot().length > 0)
-                this.scheduleDrain();
-        }
-        else {
-            this.removeOnlineListener();
-        }
-    }
-    setAnonFallback(enabled) {
-        this.anonFallback = enabled;
-    }
-    setActiveIdentity(handle) {
-        if (this.activeIdentity === handle)
-            return;
-        this.activeIdentity = handle;
-        this.queueGeneration++;
-    }
-    setRetrySleep(fn) {
-        this.retrySleep = fn;
-    }
-    async handoffAnonymousLedger(args) {
-        const { anonLedger, handleLedger, userHandle, migrate } = args;
-        const snap = anonLedger.snapshot();
-        let migrated = 0;
-        let dropped = 0;
-        for (const doc of snap) {
-            const isDel = doc._deleted === true;
-            const out = isDel || migrate === undefined ? doc : migrate(doc, userHandle);
-            if (out === false || out === null || out === undefined) {
-                dropped++;
-                continue;
-            }
-            await handleLedger.put({ ...out, _id: doc._id });
-            migrated++;
-        }
-        this.anonFallback = false;
-        this.setOfflineQueue(handleLedger);
-        anonLedger.clear();
-        return { migrated, dropped };
-    }
-    foldQueueIntoOverlay(store) {
-        const snap = store.snapshot();
-        if (snap.length === 0)
-            return;
-        const affected = [];
-        for (const doc of snap) {
-            const id = doc._id;
-            const token = ++this.writeSeq;
-            this.queueTokens.set(id, token);
-            if (doc._deleted === true) {
-                this.overlay.set(id, { kind: "del", token });
-                affected.push({ _id: id, _deleted: true });
-            }
-            else {
-                const optimisticDoc = decorateFiles({ ...doc });
-                this.overlay.set(id, { kind: "put", doc: optimisticDoc, token });
-                affected.push(optimisticDoc);
-            }
-        }
-        this.notifyListeners(affected, { optimistic: true });
-    }
     async ready() {
         return;
     }
@@ -351,11 +237,6 @@ export class FireflyDatabase {
             clearInterval(this.ephemeralSweep);
             this.ephemeralSweep = undefined;
         }
-        if (this.drainTimer !== undefined) {
-            clearTimeout(this.drainTimer);
-            this.drainTimer = undefined;
-        }
-        this.removeOnlineListener();
         return;
     }
     async destroy() {
@@ -365,12 +246,6 @@ export class FireflyDatabase {
         return;
     }
     async get(id) {
-        const pending = this.overlay.get(id);
-        if (pending) {
-            if (pending.kind === "del")
-                throw new Error(`Failed to get document: ${id} (optimistically deleted)`);
-            return pending.doc;
-        }
         this.pruneEphemeral();
         const eph = this.ephemeralOverlay.get(id);
         const rRes = await this.vibeApi.getDoc(id, this.name);
@@ -389,311 +264,35 @@ export class FireflyDatabase {
         throw new Error(`Failed to get document: ${JSON.stringify(res)}`);
     }
     async put(doc) {
-        const optimistic = this.optimisticEnabled;
-        const id = doc._id ?? (optimistic ? newOptimisticId() : undefined);
-        const token = ++this.writeSeq;
-        if (id !== undefined)
-            this.liveWriteTokens.set(id, token);
-        const queueGen = this.queueGeneration;
-        if (optimistic && id !== undefined) {
-            const optimisticDoc = decorateFiles({ ...doc, _id: id });
-            this.overlay.set(id, { kind: "put", doc: optimisticDoc, token });
-            this.notifyListeners([optimisticDoc], { optimistic: true });
-        }
-        try {
-            const docToPut = await uploadFiles(doc, this.vibeApi);
-            const issue = () => this.vibeApi.putDoc(docToPut, id, this.name);
-            const first = await this.issueWrite(id, issue);
-            const err0 = this.classifyWriteError(first, isResPutDoc, "put");
-            const settled = err0?.errClass === "network" && this.anonFallback === false
-                ? await this.retryNetworkWrite({ id, issue, isOk: isResPutDoc, label: "put", queueGen, token })
-                : { rRes: first, err: err0 };
-            const rRes = settled.rRes;
-            const err = settled.err;
-            if (err === undefined) {
-                const res = rRes.Ok();
-                if (id !== undefined)
-                    this.clearOverlay(id, token);
-                this.clearLiveWriteToken(id, token);
-                this.dropQueued(res.id);
-                const savedDoc = { ...docToPut, _id: res.id };
-                this.notifyListeners([savedDoc]);
-                this.drainAfterSuccess();
-                return { id: res.id, ok: true };
-            }
-            if (settled.superseded === true)
-                throw new Error("superseded by a newer write to the same document");
-            const queueable = this.anonFallback && (err.errClass === "network" || err.errClass === "access");
-            if (queueable && queueGen === this.queueGeneration) {
-                if (this.canQueue(id, doc)) {
-                    const res = await this.queueWrite(id, { ...docToPut, _id: id }, token);
-                    if (res.isErr())
-                        throw res.Err();
-                    this.vibeApi.notifyWriteOutcome?.({ outcome: "queued", docId: id });
-                    return res.Ok();
-                }
-                this.vibeApi.notifyWriteOutcome?.({ outcome: "failed", docId: id ?? "", message: err.message });
-            }
-            else if (err.errClass === "network" && queueGen === this.queueGeneration) {
-                this.vibeApi.notifyWriteOutcome?.({ outcome: "failed", docId: id ?? "", message: err.message });
-            }
-            throw new Error(err.message);
+        const id = doc._id;
+        const docToPut = await uploadFiles(doc, this.vibeApi);
+        const rRes = await this.vibeApi.putDoc(docToPut, id, this.name);
+        if (rRes.isErr()) {
+            const message = `Failed to put document: ${errMsg(rRes.Err())}`;
+            this.vibeApi.notifyWriteOutcome?.({ outcome: "failed", docId: id ?? "", message });
+            throw new Error(message);
         }
-        catch (err) {
-            this.rollback(id, token);
-            this.clearLiveWriteToken(id, token);
-            throw err;
+        const res = rRes.Ok();
+        if (!isResPutDoc(res)) {
+            const message = `Failed to put document: ${res.message ?? JSON.stringify(res)}`;
+            this.vibeApi.notifyWriteOutcome?.({ outcome: "failed", docId: id ?? "", message });
+            throw new Error(message);
         }
+        const savedDoc = { ...docToPut, _id: res.id };
+        this.notifyListeners([savedDoc]);
+        return { id: res.id, ok: true };
     }
     async del(id) {
-        const optimistic = this.optimisticEnabled;
-        const token = ++this.writeSeq;
-        this.liveWriteTokens.set(id, token);
-        const queueGen = this.queueGeneration;
-        if (optimistic) {
-            this.overlay.set(id, { kind: "del", token });
-            this.notifyListeners([{ _id: id, _deleted: true }], { optimistic: true });
-        }
-        try {
-            const issue = () => this.vibeApi.deleteDoc(id, this.name);
-            const first = await this.issueWrite(id, issue);
-            const err0 = this.classifyWriteError(first, isResDeleteDoc, "delete");
-            const settled = err0?.errClass === "network" && this.anonFallback === false
-                ? await this.retryNetworkWrite({ id, issue, isOk: isResDeleteDoc, label: "delete", queueGen, token })
-                : { rRes: first, err: err0 };
-            const rRes = settled.rRes;
-            const err = settled.err;
-            if (err === undefined) {
-                const res = rRes.Ok();
-                if (optimistic)
-                    this.clearOverlay(id, token);
-                this.clearLiveWriteToken(id, token);
-                this.dropQueued(res.id);
-                this.notifyListeners([{ _id: res.id, _deleted: true }]);
-                this.drainAfterSuccess();
-                return { id: res.id, ok: true };
-            }
-            if (settled.superseded === true)
-                throw new Error("superseded by a newer write to the same document");
-            const queueable = this.anonFallback && (err.errClass === "network" || err.errClass === "access");
-            if (queueable && queueGen === this.queueGeneration && this.canQueue(id, {})) {
-                const res = await this.queueWrite(id, { _id: id, _deleted: true }, token);
-                if (res.isErr())
-                    throw res.Err();
-                return res.Ok();
-            }
-            throw new Error(err.message);
-        }
-        catch (err) {
-            this.rollback(id, token);
-            this.clearLiveWriteToken(id, token);
-            throw err;
-        }
-    }
-    clearOverlay(id, token) {
-        if (this.overlay.get(id)?.token !== token)
-            return false;
-        this.overlay.delete(id);
-        return true;
-    }
-    clearLiveWriteToken(id, token) {
-        if (id !== undefined && this.liveWriteTokens.get(id) === token)
-            this.liveWriteTokens.delete(id);
-    }
-    rollback(id, token) {
-        if (id === undefined || !this.clearOverlay(id, token))
-            return;
-        this.notifyListeners([{ _id: id }], { optimistic: true });
-    }
-    classifyWriteError(rRes, isOk, label) {
+        const rRes = await this.vibeApi.deleteDoc(id, this.name);
         if (rRes.isErr()) {
-            return { errClass: "network", message: `Failed to ${label} document: ${errMsg(rRes.Err())}` };
+            throw new Error(`Failed to delete document: ${errMsg(rRes.Err())}`);
         }
         const res = rRes.Ok();
-        if (isOk(res))
-            return undefined;
-        const frame = res;
-        if (frame.code === "network") {
-            return { errClass: "network", message: `Failed to ${label} document: ${frame.message ?? "network error"}` };
-        }
-        if (frame.code === "access-denied") {
-            return { errClass: "access", message: `Failed to ${label} document: ${frame.message ?? "access denied"}` };
-        }
-        if (frame.code === "conflict") {
-            return { errClass: "conflict", message: `Failed to ${label} document: ${frame.message ?? "write conflict"}` };
+        if (!isResDeleteDoc(res)) {
+            throw new Error(`Failed to delete document: ${res.message ?? JSON.stringify(res)}`);
         }
-        return { errClass: "rejection", message: `Failed to ${label} document: ${frame.message ?? JSON.stringify(res)}` };
-    }
-    async retryNetworkWrite(args) {
-        const { id, issue, isOk, label, queueGen, token } = args;
-        let last = {
-            rRes: Result.Err(`Failed to ${label} document: retry abandoned`),
-            err: { errClass: "network", message: `Failed to ${label} document: retry abandoned` },
-        };
-        let backoff = 0;
-        for (let attempt = 0; attempt < NETWORK_RETRY_LIMIT; attempt++) {
-            backoff = backoff === 0 ? 500 : Math.min(backoff * 2, 4000);
-            await this.retrySleep(backoff);
-            if (this.queueGeneration !== queueGen)
-                return last;
-            if (id !== undefined && this.liveWriteTokens.get(id) !== token)
-                return { ...last, superseded: true };
-            const rRes = await this.issueWrite(id, issue);
-            if (this.queueGeneration !== queueGen)
-                return last;
-            const err = this.classifyWriteError(rRes, isOk, label);
-            last = { rRes, err };
-            if (err === undefined || err.errClass !== "network")
-                return last;
-        }
-        return last;
-    }
-    canQueue(id, doc) {
-        return this.offlineQueue !== undefined && id !== undefined && !hasRawFiles(doc);
-    }
-    async queueWrite(id, doc, token) {
-        const persisted = await exception2Result(async () => {
-            await this.offlineQueue?.put(doc);
-        });
-        if (persisted.isErr()) {
-            this.queueTokens.delete(id);
-            return Result.Err(persisted.Err());
-        }
-        this.queueTokens.set(id, token);
-        this.scheduleDrain();
-        return Result.Ok({ id, ok: true });
-    }
-    dropQueued(id) {
-        if (this.offlineQueue === undefined)
-            return;
-        this.queueTokens.delete(id);
-        void this.offlineQueue.del(id);
-    }
-    drainAfterSuccess() {
-        if (this.offlineQueue !== undefined && this.offlineQueue.snapshot().length > 0)
-            this.scheduleDrain();
-    }
-    issueWrite(id, fn) {
-        return id === undefined ? fn() : this.runExclusive(id, fn);
-    }
-    runExclusive(id, fn) {
-        const prev = this.idChains.get(id) ?? Promise.resolve();
-        const run = prev.then(() => fn());
-        const tail = run.then(() => undefined, () => undefined);
-        this.idChains.set(id, tail);
-        void tail.then(() => {
-            if (this.idChains.get(id) === tail)
-                this.idChains.delete(id);
-        });
-        return run;
-    }
-    scheduleDrain(delay = 0) {
-        if (this.anonFallback)
-            return;
-        if (this.drainTimer !== undefined)
-            return;
-        this.drainTimer = setTimeout(() => {
-            this.drainTimer = undefined;
-            void this.drain();
-        }, delay);
-        this.drainTimer.unref?.();
-    }
-    scheduleDrainBackoff() {
-        const delay = this.drainBackoff === 0 ? 500 : Math.min(this.drainBackoff * 2, 4000);
-        this.drainBackoff = delay;
-        if (this.drainTimer !== undefined) {
-            clearTimeout(this.drainTimer);
-            this.drainTimer = undefined;
-        }
-        this.scheduleDrain(delay);
-    }
-    async drain() {
-        const store = this.offlineQueue;
-        if (this.draining || store === undefined)
-            return;
-        this.draining = true;
-        const gen = this.queueGeneration;
-        let networkStalled = false;
-        try {
-            const snap = [...store.snapshot()].sort((a, b) => (a._id < b._id ? -1 : a._id > b._id ? 1 : 0));
-            for (const doc of snap) {
-                if (this.queueGeneration !== gen)
-                    break;
-                const id = doc._id;
-                const token = this.queueTokens.get(id);
-                const isDel = doc._deleted === true;
-                const outcome = await this.runExclusive(id, () => {
-                    if (token === undefined || this.queueTokens.get(id) !== token) {
-                        return Promise.resolve({ skipped: true });
-                    }
-                    const rReq = isDel
-                        ? this.vibeApi.deleteDoc(id, this.name)
-                        : this.vibeApi.putDoc(doc, id, this.name);
-                    return rReq.then((rRes) => ({ skipped: false, rRes }));
-                });
-                if (this.queueGeneration !== gen)
-                    break;
-                if (outcome.skipped)
-                    continue;
-                const err = this.classifyWriteError(outcome.rRes, isDel ? isResDeleteDoc : isResPutDoc, isDel ? "delete" : "put");
-                if (err === undefined) {
-                    await this.settleDrained({ store, id, token, isDel, denied: false, gen });
-                }
-                else if (err.errClass === "rejection" || err.errClass === "access") {
-                    await this.settleDrained({ store, id, token, isDel, denied: true, gen });
-                    this.vibeApi.notifyWriteOutcome?.({ outcome: "rejected", docId: id, message: err.message });
-                    console.error(`Offline queue: dropping rejected write "${id}" in db "${this.name}": ${err.message}`);
-                }
-                else {
-                    networkStalled = true;
-                    break;
-                }
-            }
-        }
-        finally {
-            this.draining = false;
-        }
-        if (networkStalled) {
-            this.scheduleDrainBackoff();
-        }
-        else {
-            this.drainBackoff = 0;
-            if (this.offlineQueue !== undefined && this.offlineQueue.snapshot().length > 0)
-                this.scheduleDrain();
-        }
-    }
-    async settleDrained(args) {
-        const { store, id, token, isDel, denied, gen } = args;
-        if (gen !== this.queueGeneration)
-            return;
-        if (token !== undefined && this.queueTokens.get(id) !== token)
-            return;
-        this.queueTokens.delete(id);
-        await store.del(id);
-        if (denied) {
-            if (token !== undefined)
-                this.rollback(id, token);
-            return;
-        }
-        if (token !== undefined)
-            this.clearOverlay(id, token);
-        this.notifyListeners([isDel ? { _id: id, _deleted: true } : { _id: id }]);
-    }
-    installOnlineListener() {
-        if (this.onlineHandler !== undefined)
-            return;
-        const g = globalThis;
-        if (typeof g.addEventListener !== "function")
-            return;
-        this.onlineHandler = () => this.scheduleDrain();
-        g.addEventListener("online", this.onlineHandler);
-    }
-    removeOnlineListener() {
-        if (this.onlineHandler === undefined)
-            return;
-        const g = globalThis;
-        g.removeEventListener?.("online", this.onlineHandler);
-        this.onlineHandler = undefined;
+        this.notifyListeners([{ _id: res.id, _deleted: true }]);
+        return { id: res.id, ok: true };
     }
     async remove(id) {
         return this.del(id);
@@ -708,17 +307,14 @@ export class FireflyDatabase {
     }
     async query(mapFn, opts = {}) {
         const serverDocs = await this.fetchServerDocs(this.queryHint(mapFn, opts));
-        return materializeQuery(this.foldOverlays(serverDocs), mapFn, opts);
+        return materializeQuery(this.mergeOverlayDocs(serverDocs), mapFn, opts);
     }
     async queryLive(mapFn, opts = {}) {
         const serverDocs = await this.fetchServerDocs(this.queryHint(mapFn, opts));
-        return { result: materializeQuery(this.foldOverlays(serverDocs), mapFn, opts), serverDocs };
+        return { result: materializeQuery(this.mergeOverlayDocs(serverDocs), mapFn, opts), serverDocs };
     }
     materializeLive(serverDocs, mapFn, opts = {}) {
-        return materializeQuery(this.foldOverlays(serverDocs), mapFn, opts);
-    }
-    foldOverlays(serverDocs) {
-        return this.applyOverlay(this.mergeOverlayDocs(serverDocs));
+        return materializeQuery(this.mergeOverlayDocs(serverDocs), mapFn, opts);
     }
     queryHint(mapFn, opts) {
         const isPrimitive = (v) => v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean";
@@ -745,18 +341,6 @@ export class FireflyDatabase {
         }
         return res.docs.map((d) => decorateFiles({ ...d, _id: d._id }));
     }
-    applyOverlay(serverDocs) {
-        if (this.overlay.size === 0)
-            return serverDocs;
-        const byId = new Map(serverDocs.map((d) => [d._id, d]));
-        for (const [id, entry] of this.overlay) {
-            if (entry.kind === "del")
-                byId.delete(id);
-            else
-                byId.set(id, entry.doc);
-        }
-        return [...byId.values()];
-    }
     async allDocs(opts = {}) {
         const rRes = await this.vibeApi.queryDocs(this.name);
         if (rRes.isErr()) {
@@ -769,7 +353,7 @@ export class FireflyDatabase {
         return this.materializeAllDocs(res.docs.map((d) => decorateFiles({ ...d, _id: d._id })), opts);
     }
     materializeAllDocs(serverDocs, opts = {}) {
-        let docs = this.foldOverlays(serverDocs);
+        let docs = this.mergeOverlayDocs(serverDocs);
         docs.sort((a, b) => (a._id < b._id ? -1 : a._id > b._id ? 1 : 0));
         if (opts.descending)
             docs.reverse();