@pmate/chat-sdk 0.11.8 → 0.12.0-next.0

package/lib/runtime/messageClient.js

@@ -0,0 +1,225 @@
+import { WindowedTasks } from "./coalescer.js";
+import { IndexedDbMessageStore, messageScopeKey, mergeStoredMessage } from "./messageStore.js";
+/** Local-first message facade; hosts never select a cache or network source. */
+export class MessageClient {
+    options;
+    storage;
+    watches = new Map();
+    reads = new Map();
+    syncing = new Map();
+    writes = new Map();
+    activeWrites = new Set();
+    writeTasks;
+    syncTasks;
+    abort = new AbortController();
+    channel;
+    closed = false;
+    closing = false;
+    revoked = new Set();
+    batchSize;
+    constructor(options) {
+        this.options = options;
+        this.storage = options.storage ?? new IndexedDbMessageStore(options.scope, options.merge ?? mergeStoredMessage);
+        this.batchSize = options.batchSize ?? 128;
+        if (!Number.isSafeInteger(this.batchSize) || this.batchSize < 1 || this.batchSize > 1000)
+            throw new Error("INVALID_MESSAGE_BATCH_SIZE");
+        this.writeTasks = new WindowedTasks(options.writeWindowMs ?? 16, (error, thread) => options.onError?.(error, thread));
+        this.syncTasks = new WindowedTasks(options.syncWindowMs ?? 1000, (error, thread) => options.onError?.(error, thread));
+        if (typeof BroadcastChannel !== "undefined") {
+            this.channel = new BroadcastChannel(`pmate-chat:${messageScopeKey(options.scope)}`);
+            this.channel.onmessage = event => { if (typeof event.data === "string" && this.watches.has(event.data))
+                void this.reload(event.data).catch(error => options.onError?.(error, event.data)); };
+        }
+    }
+    getSnapshot(thread) { return this.watches.get(thread)?.snapshot; }
+    subscribe(thread, listener) {
+        let watch = this.watches.get(thread);
+        if (!watch) {
+            watch = { limit: 100, snapshot: { messages: [], hasEarlier: false }, listeners: new Set() };
+            this.watches.set(thread, watch);
+        }
+        watch.listeners.add(listener);
+        return () => { watch.listeners.delete(listener); };
+    }
+    read(thread, limit = 100) {
+        if (this.closed || this.closing || this.revoked.has(thread))
+            return Promise.reject(new Error("MESSAGE_CLIENT_UNAVAILABLE"));
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
+            return Promise.reject(new Error("INVALID_MESSAGE_LIMIT"));
+        const key = JSON.stringify([thread, limit]), running = this.reads.get(key);
+        if (running)
+            return running;
+        const task = (async () => {
+            const local = await this.storage.read(thread, limit);
+            if (!local.coverage?.complete)
+                await this.synchronize(thread);
+            if (this.closed)
+                throw new Error("MESSAGE_CLIENT_CLOSED");
+            return this.reload(thread, limit);
+        })().finally(() => { if (this.reads.get(key) === task)
+            this.reads.delete(key); });
+        this.reads.set(key, task);
+        return task;
+    }
+    /** Application connection/wake events invalidate, rather than fetching directly. */
+    invalidate(thread) {
+        if (!this.closed && !this.closing && !this.revoked.has(thread))
+            this.syncTasks.schedule(thread, () => this.synchronize(thread));
+    }
+    async reload(thread, limit = this.watches.get(thread)?.limit ?? 100) {
+        const page = await this.storage.read(thread, limit);
+        if (this.closed)
+            throw new Error("MESSAGE_CLIENT_CLOSED");
+        let watch = this.watches.get(thread);
+        const oldById = new Map(watch?.snapshot.messages.map(message => [message.id, message]));
+        const messages = page.messages.map(message => {
+            const old = oldById.get(message.id);
+            return old && JSON.stringify(old) === JSON.stringify(message) ? old : message;
+        });
+        const old = watch?.snapshot;
+        if (old && old.hasEarlier === (page.hasEarlier || Boolean(page.coverage?.nextBefore)) && old.messages.length === messages.length && old.messages.every((message, index) => message === messages[index]))
+            return old;
+        const snapshot = { messages, hasEarlier: page.hasEarlier || Boolean(page.coverage?.nextBefore) };
+        if (!watch) {
+            watch = { limit, snapshot, listeners: new Set() };
+            this.watches.set(thread, watch);
+        }
+        watch.limit = limit;
+        watch.snapshot = snapshot;
+        watch.listeners.forEach(listener => listener());
+        return snapshot;
+    }
+    /** Events are visible only after their atomic batch commits. */
+    receive(thread, messages) {
+        if (this.closed || this.closing || this.revoked.has(thread))
+            return Promise.reject(new Error("MESSAGE_CLIENT_UNAVAILABLE"));
+        const queue = this.writes.get(thread) ?? [];
+        if (messages.length > 1000 || queue.reduce((count, write) => count + write.messages.length, messages.length) > 4096)
+            return Promise.reject(new Error("MESSAGE_STORAGE_BACKPRESSURE"));
+        const promise = new Promise((resolve, reject) => queue.push({ messages, resolve, reject }));
+        this.writes.set(thread, queue);
+        this.writeTasks.schedule(thread, () => this.flushWrites(thread));
+        return promise;
+    }
+    async persist(thread, messages, checkpoint, complete, nextBefore) {
+        let changed = 0;
+        // Coverage advances only after all bounded batches have durably committed.
+        for (let offset = 0; offset < messages.length; offset += this.batchSize) {
+            if (this.closed || this.revoked.has(thread))
+                throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
+            changed += await this.storage.commit(thread, messages.slice(offset, offset + this.batchSize));
+        }
+        if (complete !== undefined || checkpoint !== undefined) {
+            const old = (await this.storage.read(thread, 1)).coverage;
+            if (this.closed || this.revoked.has(thread))
+                throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
+            await this.storage.commit(thread, [], { complete: complete ?? old?.complete ?? false, checkpoint: checkpoint ?? old?.checkpoint, nextBefore: nextBefore === undefined ? old?.nextBefore : nextBefore });
+        }
+        if (changed) {
+            await this.reload(thread);
+            this.channel?.postMessage(thread);
+        }
+    }
+    flushWrites(thread) {
+        const task = this.runWrites(thread).finally(() => this.activeWrites.delete(task));
+        this.activeWrites.add(task);
+        return task;
+    }
+    async runWrites(thread) {
+        const queue = this.writes.get(thread);
+        if (!queue?.length)
+            return;
+        this.writes.delete(thread);
+        try {
+            await this.persist(thread, queue.flatMap(write => write.messages));
+            queue.forEach(write => write.resolve());
+        }
+        catch (error) {
+            queue.forEach(write => write.reject(error));
+            throw error;
+        }
+    }
+    synchronize(thread) {
+        if (this.closed || this.closing || this.revoked.has(thread))
+            return Promise.reject(new Error("MESSAGE_CLIENT_UNAVAILABLE"));
+        const running = this.syncing.get(thread);
+        if (running)
+            return running;
+        const task = (async () => {
+            const coverage = (await this.storage.read(thread, 1)).coverage;
+            let after = coverage?.complete ? coverage.checkpoint : undefined;
+            let page = after && this.options.transport.changes
+                ? await this.options.transport.changes(thread, after, this.abort.signal)
+                : await this.options.transport.load(thread, this.abort.signal);
+            if (page.resetRequired) {
+                if (this.closed || this.revoked.has(thread))
+                    throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
+                await this.storage.removeThread(thread);
+                after = undefined;
+                page = await this.options.transport.load(thread, this.abort.signal);
+            }
+            for (;;) {
+                if (this.closed || this.revoked.has(thread))
+                    throw new Error("MESSAGE_ACCESS_REVOKED");
+                if (page.resetRequired)
+                    throw new Error("MESSAGE_SYNC_RESET_REQUIRED");
+                await this.persist(thread, page.messages, page.checkpoint, true, after ? undefined : page.nextBefore);
+                if (!page.hasMoreChanges)
+                    break;
+                if (!page.checkpoint || page.checkpoint === after || !this.options.transport.changes)
+                    throw new Error("MESSAGE_SYNC_NO_PROGRESS");
+                after = page.checkpoint;
+                page = await this.options.transport.changes(thread, after, this.abort.signal);
+            }
+        })().finally(() => { if (this.syncing.get(thread) === task)
+            this.syncing.delete(thread); });
+        this.syncing.set(thread, task);
+        return task;
+    }
+    async earlier(thread, before, limit = 100) {
+        if (this.closed)
+            throw new Error("MESSAGE_CLIENT_CLOSED");
+        if (this.revoked.has(thread))
+            throw new Error("MESSAGE_ACCESS_REVOKED");
+        if (!(await this.storage.read(thread, 1)).coverage?.complete)
+            await this.synchronize(thread);
+        let page = await this.storage.read(thread, limit, before);
+        while (page.messages.length < limit && page.coverage?.nextBefore && this.options.transport.older) {
+            const token = page.coverage.nextBefore;
+            const remote = await this.options.transport.older(thread, token, this.abort.signal);
+            if (this.closed || this.revoked.has(thread))
+                throw new Error("MESSAGE_CLIENT_UNAVAILABLE");
+            if (remote.resetRequired) {
+                await this.storage.removeThread(thread);
+                throw new Error("MESSAGE_SYNC_RESET_REQUIRED");
+            }
+            if (remote.nextBefore === token)
+                throw new Error("MESSAGE_SYNC_NO_PROGRESS");
+            await this.persist(thread, remote.messages, undefined, true, remote.nextBefore ?? null);
+            page = await this.storage.read(thread, limit, before);
+        }
+        return { messages: page.messages, hasEarlier: page.hasEarlier || Boolean(page.coverage?.nextBefore) };
+    }
+    async revoke(thread) {
+        this.revoked.add(thread);
+        const queue = this.writes.get(thread);
+        this.writes.delete(thread);
+        queue?.forEach(write => write.reject(new Error("MESSAGE_ACCESS_REVOKED")));
+        await this.storage.removeThread(thread);
+        await this.reload(thread);
+        this.channel?.postMessage(thread);
+    }
+    async close() {
+        // Flush accepted event batches before closing; new requests are rejected afterwards.
+        this.closing = true;
+        this.syncTasks.close();
+        this.writeTasks.close();
+        await Promise.all([...this.writes.keys()].map(thread => this.flushWrites(thread)));
+        await Promise.all([...this.activeWrites]);
+        this.closed = true;
+        this.abort.abort();
+        this.channel?.close();
+        this.watches.clear();
+        this.storage.close();
+    }
+}

package/lib/runtime/messageStore.d.ts

@@ -0,0 +1,51 @@
+export type StoredMessage = {
+    id: string;
+    threadId: string;
+    timestamp: number;
+    revision?: number;
+    recalled?: boolean;
+};
+export type MessageScope = {
+    appId: string;
+    accountId: string;
+    profileId: string;
+    teamId: string;
+};
+export type MessageCoverage = {
+    checkpoint?: string;
+    complete: boolean;
+    nextBefore?: string | null;
+};
+type CoverageRow = MessageCoverage & {
+    scope: string;
+    thread: string;
+};
+export declare const messageScopeKey: (scope: MessageScope) => string;
+/** Normalized browser cache. Data and coverage advance together in each commit.
+ * Merge runs inside the write transaction against the latest cross-tab state. */
+export declare class IndexedDbMessageStore<T extends StoredMessage> {
+    private merge;
+    private db;
+    private rows;
+    private coverage;
+    private key;
+    constructor(scope: MessageScope, merge: (previous: T | undefined, incoming: T) => T, options?: {
+        indexedDB?: IDBFactory;
+        name?: string;
+    });
+    read(thread: string, limit?: number, before?: {
+        timestamp: number;
+        id: string;
+    }): Promise<{
+        messages: T[];
+        hasEarlier: boolean;
+        coverage: CoverageRow | undefined;
+    }>;
+    commit(thread: string, messages: T[], coverage?: MessageCoverage): Promise<number>;
+    removeThread(thread: string): Promise<void>;
+    clear(): Promise<void>;
+    close(): void;
+}
+/** Keep tombstones monotonic; applications can supply stricter domain reducers. */
+export declare function mergeStoredMessage<T extends StoredMessage>(previous: T | undefined, incoming: T): T;
+export {};

package/lib/runtime/messageStore.js

@@ -0,0 +1,81 @@
+import { Dexie } from "dexie";
+export const messageScopeKey = (scope) => JSON.stringify([scope.appId, scope.accountId, scope.profileId, scope.teamId]);
+/** Normalized browser cache. Data and coverage advance together in each commit.
+ * Merge runs inside the write transaction against the latest cross-tab state. */
+export class IndexedDbMessageStore {
+    merge;
+    db;
+    rows;
+    coverage;
+    key;
+    constructor(scope, merge, options = {}) {
+        this.merge = merge;
+        this.key = messageScopeKey(scope);
+        this.db = new Dexie(options.name ?? "pmate-chat-messages", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
+        this.db.version(1).stores({ messages: "[scope+thread+id],[scope+thread+time+id],[scope+thread],scope", coverage: "[scope+thread],scope" });
+        this.rows = this.db.table("messages");
+        this.coverage = this.db.table("coverage");
+        this.db.on("versionchange", () => { this.db.close({ disableAutoOpen: false }); return false; });
+    }
+    async read(thread, limit = 100, before) {
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
+            throw new Error("INVALID_MESSAGE_LIMIT");
+        return this.db.transaction("r", this.rows, this.coverage, async () => {
+            const range = this.rows.where("[scope+thread+time+id]").between([this.key, thread, Dexie.minKey, Dexie.minKey], [this.key, thread, before?.timestamp ?? Dexie.maxKey, before?.id ?? Dexie.maxKey], true, !before);
+            const records = await range.reverse().limit(limit + 1).toArray();
+            return { messages: records.slice(0, limit).reverse().map(row => row.value), hasEarlier: records.length > limit, coverage: await this.coverage.get([this.key, thread]) };
+        });
+    }
+    async commit(thread, messages, coverage) {
+        for (const message of messages)
+            if (message.threadId !== thread || !message.id || !Number.isFinite(message.timestamp))
+                throw new Error("MESSAGE_SCOPE_MISMATCH");
+        if (messages.length > 1000)
+            throw new Error("MESSAGE_BATCH_TOO_LARGE");
+        return this.db.transaction("rw", this.rows, this.coverage, async () => {
+            const ids = [...new Set(messages.map(message => message.id))];
+            const previous = await this.rows.bulkGet(ids.map(id => [this.key, thread, id]));
+            const latest = new Map(previous.flatMap(row => row ? [[row.id, row.value]] : []));
+            const changed = new Map();
+            for (const message of messages) {
+                const old = latest.get(message.id), value = this.merge(old, message);
+                if (value.id !== message.id || value.threadId !== thread || !Number.isFinite(value.timestamp))
+                    throw new Error("MESSAGE_SCOPE_MISMATCH");
+                latest.set(message.id, value);
+                if (JSON.stringify(old) !== JSON.stringify(value))
+                    changed.set(message.id, { scope: this.key, thread, id: value.id, time: value.timestamp, value });
+            }
+            if (changed.size)
+                await this.rows.bulkPut([...changed.values()]);
+            if (coverage) {
+                const old = await this.coverage.get([this.key, thread]), next = { ...coverage, scope: this.key, thread };
+                if (JSON.stringify(old) !== JSON.stringify(next))
+                    await this.coverage.put(next);
+            }
+            return changed.size;
+        });
+    }
+    async removeThread(thread) {
+        await this.db.transaction("rw", this.rows, this.coverage, async () => {
+            await this.rows.where("[scope+thread]").equals([this.key, thread]).delete();
+            await this.coverage.delete([this.key, thread]);
+        });
+    }
+    async clear() {
+        await this.db.transaction("rw", this.rows, this.coverage, async () => {
+            await this.rows.where("scope").equals(this.key).delete();
+            await this.coverage.where("scope").equals(this.key).delete();
+        });
+    }
+    close() { this.db.close(); }
+}
+/** Keep tombstones monotonic; applications can supply stricter domain reducers. */
+export function mergeStoredMessage(previous, incoming) {
+    if (!previous)
+        return incoming;
+    if (previous.recalled && !incoming.recalled)
+        return previous;
+    if ((previous.revision ?? 0) > (incoming.revision ?? 0))
+        return previous;
+    return incoming;
+}

package/lib/runtime/readIndex.js

@@ -206,10 +206,12 @@ export class IndexedDbReadIndex {
     }
     async update(appId, profileId, transform) {
         return this.transaction("rw", async () => {
-            const next = transform(await this.profiles.get([appId, profileId]) ?? createReadIndex(appId, profileId));
+            const previous = await this.profiles.get([appId, profileId]);
+            const next = transform(previous ?? createReadIndex(appId, profileId));
             if (next.appId !== appId || next.profileId !== profileId || next.schemaVersion !== 1)
                 throw new Error("READ_IDENTITY_MISMATCH");
-            await this.profiles.put(next, [appId, profileId]);
+            if (JSON.stringify(next) !== JSON.stringify(previous))
+                await this.profiles.put(next, [appId, profileId]);
             return next;
         });
     }

package/lib/runtime/readingClient.d.ts

@@ -0,0 +1,40 @@
+import { type ReadIndexPersistence, type ReadIndexState } from "./readIndex.js";
+export type ReadingClientOptions = {
+    appId: string;
+    profileId: string;
+    sessionToken: string;
+    hubHttpUrl: string;
+    persistence?: ReadIndexPersistence;
+    fetch?: typeof fetch;
+    onError?: (error: unknown) => void;
+    onRecovered?: () => void;
+};
+/** Owns durable local reads, network coalescing, retries and state notifications.
+ * Hosts report actual visibility; loading or subscribing never marks messages read. */
+export declare class ReadingClient {
+    private options;
+    private storage;
+    private persistence;
+    private sync;
+    private tasks;
+    private listeners;
+    private state?;
+    private closed;
+    private retry?;
+    private retryDelay;
+    private offWake?;
+    private generation;
+    constructor(options: ReadingClientOptions);
+    getSnapshot: () => ReadIndexState | undefined;
+    subscribe: (listener: () => void) => () => void;
+    private publish;
+    private failed;
+    start(): Promise<void>;
+    refresh: () => void;
+    synchronize(targetCursor?: string, profileId?: string): Promise<ReadIndexState>;
+    update(transform: (state: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;
+    recordVisible(threadId: string, messageIds: string[]): Promise<ReadIndexState>;
+    recordExplicit(threadId: string, messageIds: string[]): Promise<ReadIndexState>;
+    private record;
+    close(): Promise<void>;
+}

package/lib/runtime/readingClient.js

@@ -0,0 +1,115 @@
+import { BatchedReadIndex } from "./batchedReadIndex.js";
+import { WindowedTasks } from "./coalescer.js";
+import { IndexedDbReadIndex, recordReadIntent } from "./readIndex.js";
+import { ReadSyncClient } from "./readSync.js";
+/** Owns durable local reads, network coalescing, retries and state notifications.
+ * Hosts report actual visibility; loading or subscribing never marks messages read. */
+export class ReadingClient {
+    options;
+    storage;
+    persistence;
+    sync;
+    tasks;
+    listeners = new Set();
+    state;
+    closed = false;
+    retry;
+    retryDelay = 1000;
+    offWake;
+    generation = 0;
+    constructor(options) {
+        this.options = options;
+        const storage = options.persistence ?? (this.storage = new IndexedDbReadIndex());
+        this.persistence = new BatchedReadIndex(storage);
+        this.tasks = new WindowedTasks(1000, error => this.failed(error));
+        this.sync = new ReadSyncClient({ ...options, persistence: this.persistence, onChange: state => this.publish(state) });
+    }
+    getSnapshot = () => this.state;
+    subscribe = (listener) => { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; };
+    publish(state) {
+        if (this.closed || JSON.stringify(state) === JSON.stringify(this.state))
+            return;
+        this.state = state;
+        this.listeners.forEach(listener => listener());
+    }
+    failed(error) {
+        if (this.closed)
+            return;
+        this.options.onError?.(error);
+        if (/HTTP_(400|401|403)/.test(String(error)) || (typeof navigator !== "undefined" && !navigator.onLine) || this.retry)
+            return;
+        this.retry = setTimeout(() => { this.retry = undefined; this.refresh(); }, this.retryDelay);
+        this.retryDelay = Math.min(this.retryDelay * 2, 30_000);
+    }
+    async start() {
+        if (this.closed)
+            throw new Error("READING_CLIENT_CLOSED");
+        this.publish(await this.sync.loadLocal());
+        if (this.closed)
+            return;
+        if (typeof window !== "undefined" && !this.offWake) {
+            const wake = () => this.refresh();
+            window.addEventListener("online", wake);
+            window.addEventListener("focus", wake);
+            this.offWake = () => { window.removeEventListener("online", wake); window.removeEventListener("focus", wake); };
+        }
+        this.refresh();
+    }
+    refresh = () => {
+        if (!this.closed)
+            this.tasks.schedule("reading", async () => { await this.synchronize(); });
+    };
+    async synchronize(targetCursor, profileId) {
+        if (this.closed)
+            throw new Error("READING_CLIENT_CLOSED");
+        if (profileId !== undefined && profileId !== this.options.profileId)
+            throw new Error("Reading reach identity mismatch");
+        if (targetCursor !== undefined && !/^v1:\d+$/.test(targetCursor))
+            throw new Error("Invalid reading reach cursor");
+        const generation = this.generation;
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const next = await this.sync.synchronize();
+            if (this.closed || generation !== this.generation)
+                throw new Error("READING_CLIENT_CLOSED");
+            const cursor = /^(?:teams:[0-9a-f]{64}:)?v1:(\d+)$/.exec(next.syncCursor);
+            if (targetCursor === undefined || (cursor && BigInt(cursor[1]) >= BigInt(targetCursor.slice(3)))) {
+                clearTimeout(this.retry);
+                this.retry = undefined;
+                this.retryDelay = 1000;
+                this.options.onRecovered?.();
+                if (next.pending.length)
+                    this.refresh();
+                return next;
+            }
+        }
+        throw new Error("Reading projection has not reached the announced version");
+    }
+    async update(transform) {
+        if (this.closed)
+            throw new Error("READING_CLIENT_CLOSED");
+        const next = await this.persistence.update(this.options.appId, this.options.profileId, transform);
+        if (!this.closed) {
+            this.publish(next);
+            if (next.pending.length || next.observedReadIntents?.length)
+                this.refresh();
+        }
+        return next;
+    }
+    recordVisible(threadId, messageIds) { return this.record(threadId, messageIds, "visible"); }
+    recordExplicit(threadId, messageIds) { return this.record(threadId, messageIds, "explicit"); }
+    record(threadId, ids, readPolicy) {
+        const messageIds = [...new Set(ids)];
+        return this.update(state => messageIds.reduce((next, messageId) => recordReadIntent(next, { threadId, messageId, readPolicy, operationId: crypto.randomUUID() }), state));
+    }
+    async close() {
+        this.closed = true;
+        this.generation++;
+        this.offWake?.();
+        this.tasks.close();
+        clearTimeout(this.retry);
+        this.sync.stop();
+        this.listeners.clear();
+        await this.persistence.close();
+        await this.storage?.close();
+    }
+}

package/lib/runtime/recordCache.d.ts

@@ -0,0 +1,41 @@
+export type RecordCacheOptions<T> = {
+    scope: string;
+    key: (value: T) => string;
+    merge: (previous: T | undefined, incoming: T) => T;
+    indexedDB?: IDBFactory;
+    name?: string;
+    onError?: (error: unknown) => void;
+};
+/** In-memory control-event index backed by bounded asynchronous IndexedDB batches.
+ * Legacy storage is read only during open; the hot path never uses localStorage. */
+export declare class IndexedDbRecordCache<T> {
+    private options;
+    private db;
+    private records;
+    private metadata;
+    private values;
+    private snapshotValue;
+    private pending;
+    private waiters;
+    private tasks;
+    private ready?;
+    private closed;
+    private closing;
+    private initialized;
+    private running?;
+    private channel?;
+    private listeners;
+    constructor(options: RecordCacheOptions<T>);
+    open(legacy?: () => {
+        values: T[];
+        clear: () => void;
+    }): Promise<void>;
+    snapshot(): readonly T[];
+    subscribe(listener: () => void): () => void;
+    private reload;
+    upsert(incoming: T[]): Promise<void>;
+    private write;
+    flush(): Promise<void>;
+    private runFlush;
+    close(): Promise<void>;
+}