@koolbase/core 12.13.0 → 12.14.0

package/dist/cjs/cache-store.d.ts

@@ -58,3 +58,17 @@ export declare function addToWriteQueue(userId: string, write: Omit<LegacyPendin
 export declare function removeFromWriteQueue(userId: string, writeId: string): Promise<void>;
 export declare function incrementWriteRetry(userId: string, writeId: string): Promise<void>;
 export declare function optimisticallyInsert(userId: string, collection: string, record: KoolbaseRecord): Promise<void>;
+/**
+ * The reverse of optimisticallyInsert: takes one record out of every cached
+ * result of a collection.
+ *
+ * Precise on purpose. Dropping the collection's cached results instead would
+ * leave a device that is still offline with no saved lists to show at all,
+ * to get rid of one record.
+ */
+export declare function removeFromCachedQueries(userId: string, collection: string, recordId: string): Promise<void>;
+/**
+ * Applies an offline edit to the record wherever a cached result holds it, so
+ * a saved list shows what the user just changed rather than what it was.
+ */
+export declare function updateInCachedQueries(userId: string, collection: string, recordId: string, data: Record<string, unknown>): Promise<void>;

package/dist/cjs/cache-store.js

@@ -13,6 +13,8 @@ exports.addToWriteQueue = addToWriteQueue;
 exports.removeFromWriteQueue = removeFromWriteQueue;
 exports.incrementWriteRetry = incrementWriteRetry;
 exports.optimisticallyInsert = optimisticallyInsert;
+exports.removeFromCachedQueries = removeFromCachedQueries;
+exports.updateInCachedQueries = updateInCachedQueries;
 const platform_js_1 = require("./platform.js");
 const CACHE_VERSION = 'v1';
 function cacheKey(userId, collection, queryHash) {
@@ -211,3 +213,65 @@ async function optimisticallyInsert(userId, collection, record) {
         // ignore
     }
 }
+/**
+ * The reverse of optimisticallyInsert: takes one record out of every cached
+ * result of a collection.
+ *
+ * Precise on purpose. Dropping the collection's cached results instead would
+ * leave a device that is still offline with no saved lists to show at all,
+ * to get rid of one record.
+ */
+async function removeFromCachedQueries(userId, collection, recordId) {
+    try {
+        const keys = await (0, platform_js_1.getPlatform)().storage.getAllKeys();
+        const prefix = `koolbase:${CACHE_VERSION}:${userId}:${collection}:`;
+        for (const key of keys.filter(k => k.startsWith(prefix))) {
+            const raw = await (0, platform_js_1.getPlatform)().storage.getItem(key);
+            if (!raw)
+                continue;
+            const cached = JSON.parse(raw);
+            if (!Array.isArray(cached.records))
+                continue;
+            const kept = cached.records.filter(r => r.id !== recordId);
+            const removed = cached.records.length - kept.length;
+            if (removed === 0)
+                continue;
+            cached.records = kept;
+            cached.total = Math.max(0, cached.total - removed);
+            await (0, platform_js_1.getPlatform)().storage.setItem(key, JSON.stringify(cached));
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+/**
+ * Applies an offline edit to the record wherever a cached result holds it, so
+ * a saved list shows what the user just changed rather than what it was.
+ */
+async function updateInCachedQueries(userId, collection, recordId, data) {
+    try {
+        const keys = await (0, platform_js_1.getPlatform)().storage.getAllKeys();
+        const prefix = `koolbase:${CACHE_VERSION}:${userId}:${collection}:`;
+        for (const key of keys.filter(k => k.startsWith(prefix))) {
+            const raw = await (0, platform_js_1.getPlatform)().storage.getItem(key);
+            if (!raw)
+                continue;
+            const cached = JSON.parse(raw);
+            if (!Array.isArray(cached.records))
+                continue;
+            let changed = false;
+            cached.records = cached.records.map(r => {
+                if (r.id !== recordId)
+                    return r;
+                changed = true;
+                return { ...r, data: { ...(r.data ?? {}), ...data } };
+            });
+            if (changed)
+                await (0, platform_js_1.getPlatform)().storage.setItem(key, JSON.stringify(cached));
+        }
+    }
+    catch {
+        // ignore
+    }
+}

package/dist/cjs/connectivity.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Whether the device reports a network connection. A hint, not a promise that
+ * Koolbase is reachable: requests can still fail while online.
+ *
+ * 'unknown' until the platform first answers -- a real state, not a guess. An
+ * app should neither show "offline" nor run online-only logic on it.
+ */
+export type ConnectivityState = 'unknown' | 'online' | 'offline';
+/**
+ * The device's connectivity, as state an app can render: getState() for now,
+ * subscribe() for changes (the shape React's useSyncExternalStore takes).
+ */
+export declare class KoolbaseConnectivity {
+    private state;
+    private readonly listeners;
+    private stop;
+    private heard;
+    /** Starts following the platform. Called once by Koolbase.initialize. */
+    start(): void;
+    getState(): ConnectivityState;
+    /** Called on every change. Returns the unsubscribe. */
+    subscribe(listener: () => void): () => void;
+    dispose(): void;
+    private set;
+}

package/dist/cjs/connectivity.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoolbaseConnectivity = void 0;
+const platform_js_1 = require("./platform.js");
+/**
+ * The device's connectivity, as state an app can render: getState() for now,
+ * subscribe() for changes (the shape React's useSyncExternalStore takes).
+ */
+class KoolbaseConnectivity {
+    constructor() {
+        this.state = 'unknown';
+        this.listeners = new Set();
+        this.stop = null;
+        // A change event is fresher than the first read: once one arrives, a late
+        // answer to that read is ignored.
+        this.heard = false;
+    }
+    /** Starts following the platform. Called once by Koolbase.initialize. */
+    start() {
+        if (this.stop)
+            return;
+        const network = (0, platform_js_1.getPlatform)().network;
+        this.stop = network.onChange((online) => {
+            this.heard = true;
+            this.set(online ? 'online' : 'offline');
+        });
+        if (network.current) {
+            network.current().then((online) => {
+                if (!this.heard && online !== null && online !== undefined)
+                    this.set(online ? 'online' : 'offline');
+            }, () => { });
+        }
+    }
+    getState() {
+        return this.state;
+    }
+    /** Called on every change. Returns the unsubscribe. */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+    dispose() {
+        this.stop?.();
+        this.stop = null;
+        this.listeners.clear();
+    }
+    set(next) {
+        if (next === this.state)
+            return;
+        this.state = next;
+        for (const listener of [...this.listeners]) {
+            try {
+                listener();
+            }
+            catch { /* one broken listener must not stop the rest */ }
+        }
+    }
+}
+exports.KoolbaseConnectivity = KoolbaseConnectivity;

package/dist/cjs/database.d.ts

@@ -119,6 +119,16 @@ export declare class KoolbaseDatabase {
      */
     batch(operations: BatchOp[]): Promise<BatchResult[]>;
     get(recordId: string): Promise<KoolbaseRecord>;
+    /**
+     * The device's saved copy of a record: what this device last read, with the
+     * changes queued on it applied. Never contacts the server. Null when there is
+     * none: never read here, or deleted on this device.
+     *
+     * For showing something at once while get() asks the server -- saved-first,
+     * never saved-only. Kept data and revision, not createdAt or createdBy, which
+     * the saved copy does not hold (empty strings here).
+     */
+    getSaved(recordId: string): Promise<KoolbaseRecord | null>;
     /**
      * Writes that could not be applied, waiting for a decision.
      *
@@ -134,6 +144,28 @@ export declare class KoolbaseDatabase {
      * moment matters. Snapshot, not a live handle; per-user.
      */
     pendingWrites(): Promise<PendingWrite[]>;
+    /**
+     * The pending writes now, and again whenever they change -- here, in another
+     * tab, or because the signed-in user changed. For a sync badge that reflects
+     * reality. null while signed out: per-user state has no answer then, and a
+     * fake empty list is how a badge says "all synced" while a user's changes
+     * sit queued. Returns the unsubscribe.
+     */
+    watchPendingWrites(listener: (writes: PendingWrite[] | null) => void): () => void;
+    /** The unresolved conflicts now, and again whenever they change. null while signed out. */
+    watchConflicts(listener: (conflicts: KoolbaseConflict[] | null) => void): () => void;
+    /**
+     * The signed-in user changed: every watcher reads again, for the new user
+     * (or null, signed out). Koolbase.initialize wires it to auth changes.
+     */
+    sessionChanged(): void;
+    private readonly stateWatchers;
+    private offStateChange;
+    /**
+     * One watcher: reads at once, then on every change to the signed-in user's
+     * offline state. Reads can finish out of order; only the latest delivers.
+     */
+    private watchState;
     /**
      * Count and total over a whole collection, with the read rule applied
      * inside the query.
@@ -173,6 +205,15 @@ export declare class KoolbaseDatabase {
      */
     private requireUserId;
     private requireConflict;
+    /**
+     * Removes a decided conflict and points the writes held behind it at the
+     * state the record is now in -- in one transaction, so the conflict can
+     * never be gone while its held writes still describe the old world.
+     *
+     * Without a known state (a refused add, a delete) there is nothing to
+     * rebase onto: the conflict is removed and the held writes stay as they are.
+     */
+    private settleConflict;
     private dropConflict;
     /**
      * Issues the resolving write, conditional on the revision the refusal

package/dist/cjs/database.js

@@ -7,9 +7,10 @@ const database_errors_js_1 = require("./database-errors.js");
 const errors_js_1 = require("./errors.js");
 const cache_store_js_1 = require("./cache-store.js");
 const offline_state_js_1 = require("./offline-state.js");
+const cache_store_js_2 = require("./cache-store.js");
 const conflict_js_1 = require("./conflict.js");
 const pending_write_js_1 = require("./pending-write.js");
-const cache_store_js_2 = require("./cache-store.js");
+const cache_store_js_3 = require("./cache-store.js");
 const sync_engine_js_1 = require("./sync-engine.js");
 const record_js_1 = require("./record.js");
 const database_errors_js_2 = require("./database-errors.js");
@@ -45,6 +46,8 @@ function batchOpToWire(op) {
 }
 class KoolbaseDatabase {
     constructor(config, getUserId, getToken, onSessionExpired) {
+        this.stateWatchers = new Set();
+        this.offStateChange = null;
         /**
          * Resolves by id, reloading the stored conflict first.
          *
@@ -65,12 +68,15 @@ class KoolbaseDatabase {
             resolveWithServer: async (id) => {
                 const c = await this.requireConflict(id);
                 // The server's version stands. Recorded as a decision by removing the
-                // conflict, rather than the change quietly disappearing.
-                await this.dropConflict(c.id);
+                // conflict, rather than the change quietly disappearing -- and what
+                // stands is what the writes held behind it now build on.
+                await this.settleConflict(c, c.server, c.serverRevision);
             },
             abandon: async (id) => {
                 const c = await this.requireConflict(id);
-                await this.dropConflict(c.id);
+                // Neither version claimed to win, so the record stands as the server
+                // has it: what anything still queued must build on.
+                await this.settleConflict(c, c.server, c.serverRevision);
             },
         };
         this.config = config;
@@ -204,12 +210,12 @@ class KoolbaseDatabase {
         // query's identity, so both policies share one cache entry. onRefresh is
         // who to tell, not what to read, so it stays out the same way.
         const { cache: cachePolicy, onRefresh, ...queryOptions } = options;
-        const queryHash = (0, cache_store_js_2.hashQuery)(collection, queryOptions);
-        const cached = cachePolicy === 'network-only' ? null : await (0, cache_store_js_2.getCached)(userId, collection, queryHash);
+        const queryHash = (0, cache_store_js_3.hashQuery)(collection, queryOptions);
+        const cached = cachePolicy === 'network-only' ? null : await (0, cache_store_js_3.getCached)(userId, collection, queryHash);
         if (cached) {
             this.runQuery(collection, queryOptions)
                 .then(async (result) => {
-                await (0, cache_store_js_2.setCached)(userId, collection, queryHash, result);
+                await (0, cache_store_js_3.setCached)(userId, collection, queryHash, result);
                 // Told outside the catch below, which is for the network: an
                 // exception from the caller's callback is the caller's to see.
                 if (onRefresh)
@@ -221,7 +227,7 @@ class KoolbaseDatabase {
             return { ...cached, isFromCache: true };
         }
         const result = await this.runQuery(collection, queryOptions);
-        await (0, cache_store_js_2.setCached)(userId, collection, queryHash, result);
+        await (0, cache_store_js_3.setCached)(userId, collection, queryHash, result);
         return { ...result, isFromCache: false };
     }
     /**
@@ -230,7 +236,7 @@ class KoolbaseDatabase {
      * a server, or another user. The SDK's own writes already do this.
      */
     async invalidate(collection) {
-        await (0, cache_store_js_2.invalidateCache)(this.getUserId() ?? 'anonymous', collection);
+        await (0, cache_store_js_3.invalidateCache)(this.getUserId() ?? 'anonymous', collection);
         void (0, query_refresh_js_1.refreshCollectionQueries)(collection);
     }
     // ─── Insert (online-first with offline fallback) ───────────────────────────
@@ -254,7 +260,7 @@ class KoolbaseDatabase {
             // next query sees real data instead of a stale optimistic copy.
             const raw = await this.request('POST', '/v1/sdk/db/insert', { collection, data });
             const record = (0, record_js_1.recordFromWire)(raw);
-            await (0, cache_store_js_2.invalidateCache)(userId, collection);
+            await (0, cache_store_js_3.invalidateCache)(userId, collection);
             void (0, query_refresh_js_1.refreshCollectionQueries)(collection);
             // The response carries a fresh revision, so caching it keeps the
             // baseline current for whatever edits this record next.
@@ -290,7 +296,7 @@ class KoolbaseDatabase {
                 createdAt: new Date().toISOString(),
                 updatedAt: new Date().toISOString(),
             };
-            await (0, cache_store_js_2.optimisticallyInsert)(userId, collection, optimisticRecord);
+            await (0, cache_store_js_3.optimisticallyInsert)(userId, collection, optimisticRecord);
             // No baseline: an insert has no prior state, and the record does not
             // exist on the server yet, so there is nothing to be conditional against.
             // An offline edit to it composes against this queued write instead.
@@ -329,7 +335,7 @@ class KoolbaseDatabase {
         const record = (0, record_js_1.recordFromWire)(body);
         // Keep the cache fresh, same intent as insert's post-success invalidate.
         const userId = this.getUserId() ?? 'anonymous';
-        await (0, cache_store_js_2.invalidateCache)(userId, collection);
+        await (0, cache_store_js_3.invalidateCache)(userId, collection);
         void (0, query_refresh_js_1.refreshCollectionQueries)(collection);
         await (0, cache_store_js_1.cacheRecord)(userId, collection, record.id, record.data, record.revision);
         return { record, created };
@@ -349,7 +355,7 @@ class KoolbaseDatabase {
     async deleteWhere(collection, filters) {
         const body = await this.request('POST', '/v1/sdk/db/delete-where', { collection, filters });
         const userId = this.getUserId() ?? 'anonymous';
-        await (0, cache_store_js_2.invalidateCache)(userId, collection);
+        await (0, cache_store_js_3.invalidateCache)(userId, collection);
         void (0, query_refresh_js_1.refreshCollectionQueries)(collection);
         return body.deleted ?? 0;
     }
@@ -413,7 +419,7 @@ class KoolbaseDatabase {
             }
         }
         for (const col of touched) {
-            await (0, cache_store_js_2.invalidateCache)(userId, col);
+            await (0, cache_store_js_3.invalidateCache)(userId, col);
             void (0, query_refresh_js_1.refreshCollectionQueries)(col);
         }
         return results;
@@ -430,6 +436,29 @@ class KoolbaseDatabase {
         }
         return record;
     }
+    /**
+     * The device's saved copy of a record: what this device last read, with the
+     * changes queued on it applied. Never contacts the server. Null when there is
+     * none: never read here, or deleted on this device.
+     *
+     * For showing something at once while get() asks the server -- saved-first,
+     * never saved-only. Kept data and revision, not createdAt or createdBy, which
+     * the saved copy does not hold (empty strings here).
+     */
+    async getSaved(recordId) {
+        const userId = this.getUserId() ?? 'anonymous';
+        const base = await this.resolveBaseline(userId, recordId);
+        if (!base)
+            return null;
+        return {
+            id: recordId,
+            collection: base.collection,
+            data: { ...base.baseline },
+            createdAt: '',
+            updatedAt: '',
+            revision: base.revision,
+        };
+    }
     // ─── Conflicts ──────────────────────────────────────────────────────────────
     /**
      * Writes that could not be applied, waiting for a decision.
@@ -450,6 +479,69 @@ class KoolbaseDatabase {
         const { pending } = await (0, offline_state_js_1.readOfflineState)(userId);
         return pending.map(pending_write_js_1.toPendingWrite);
     }
+    /**
+     * The pending writes now, and again whenever they change -- here, in another
+     * tab, or because the signed-in user changed. For a sync badge that reflects
+     * reality. null while signed out: per-user state has no answer then, and a
+     * fake empty list is how a badge says "all synced" while a user's changes
+     * sit queued. Returns the unsubscribe.
+     */
+    watchPendingWrites(listener) {
+        return this.watchState(async (userId) => {
+            if (!userId)
+                return () => listener(null);
+            const { pending } = await (0, offline_state_js_1.readOfflineState)(userId);
+            const writes = pending.map(pending_write_js_1.toPendingWrite);
+            return () => listener(writes);
+        });
+    }
+    /** The unresolved conflicts now, and again whenever they change. null while signed out. */
+    watchConflicts(listener) {
+        return this.watchState(async (userId) => {
+            if (!userId)
+                return () => listener(null);
+            const list = await this.conflicts();
+            return () => listener(list);
+        });
+    }
+    /**
+     * The signed-in user changed: every watcher reads again, for the new user
+     * (or null, signed out). Koolbase.initialize wires it to auth changes.
+     */
+    sessionChanged() {
+        for (const emit of [...this.stateWatchers])
+            emit();
+    }
+    /**
+     * One watcher: reads at once, then on every change to the signed-in user's
+     * offline state. Reads can finish out of order; only the latest delivers.
+     */
+    watchState(read) {
+        let latest = 0;
+        let active = true;
+        const emit = () => {
+            const mine = ++latest;
+            read(this.getUserId()).then((deliver) => { if (active && mine === latest)
+                deliver(); }, () => { });
+        };
+        this.stateWatchers.add(emit);
+        if (!this.offStateChange) {
+            this.offStateChange = (0, offline_state_js_1.onOfflineStateChange)((userId) => {
+                if (userId === this.getUserId())
+                    for (const w of [...this.stateWatchers])
+                        w();
+            });
+        }
+        emit();
+        return () => {
+            active = false;
+            this.stateWatchers.delete(emit);
+            if (this.stateWatchers.size === 0 && this.offStateChange) {
+                this.offStateChange();
+                this.offStateChange = null;
+            }
+        };
+    }
     /**
      * Count and total over a whole collection, with the read rule applied
      * inside the query.
@@ -540,6 +632,25 @@ class KoolbaseDatabase {
         }
         return found;
     }
+    /**
+     * Removes a decided conflict and points the writes held behind it at the
+     * state the record is now in -- in one transaction, so the conflict can
+     * never be gone while its held writes still describe the old world.
+     *
+     * Without a known state (a refused add, a delete) there is nothing to
+     * rebase onto: the conflict is removed and the held writes stay as they are.
+     */
+    async settleConflict(c, resolved, revision) {
+        if (!resolved || !c.recordId) {
+            await this.dropConflict(c.id);
+            return;
+        }
+        const userId = this.requireUserId('conflict resolution');
+        await (0, offline_state_js_1.mutateOfflineState)(userId, (s) => {
+            s.conflicts = s.conflicts.filter((x) => x.id !== c.id);
+            (0, offline_state_js_1.rebaseHeldWrites)(s, c.recordId, resolved, revision);
+        });
+    }
     async dropConflict(id) {
         const userId = this.requireUserId('conflict resolution');
         await (0, offline_state_js_1.mutateOfflineState)(userId, (s) => {
@@ -554,6 +665,8 @@ class KoolbaseDatabase {
      */
     async applyResolution(c, payload) {
         const rev = c.serverRevision;
+        // What the server now holds, from its answer: the state held writes build on.
+        let landed = null;
         try {
             if (c.operation === 'insert') {
                 // Resolving a rejected insert IS the insert, retried — with amended
@@ -564,7 +677,7 @@ class KoolbaseDatabase {
                 // original on retry rather than duplicating — the queue's own
                 // lost-response discipline, extended to the one insert path that
                 // lacked it.
-                await this.request('POST', '/v1/sdk/db/insert', {
+                landed = await this.request('POST', '/v1/sdk/db/insert', {
                     collection: c.collection,
                     data: payload,
                     idempotency_key: c.id,
@@ -575,7 +688,7 @@ class KoolbaseDatabase {
                 await this.request('DELETE', `/v1/sdk/db/records/${c.recordId}${q}`);
             }
             else {
-                await this.request('PATCH', `/v1/sdk/db/records/${c.recordId}`, { data: payload, ...(rev !== undefined ? { expected_revision: rev } : {}) });
+                landed = await this.request('PATCH', `/v1/sdk/db/records/${c.recordId}`, { data: payload, ...(rev !== undefined ? { expected_revision: rev } : {}) });
             }
         }
         catch (e) {
@@ -604,8 +717,9 @@ class KoolbaseDatabase {
             }
             throw e;
         }
-        await this.dropConflict(c.id);
-        await (0, cache_store_js_2.invalidateCache)(this.getUserId() ?? 'anonymous', c.collection);
+        const landedRevision = landed && typeof landed.$revision === 'number' ? landed.$revision : undefined;
+        await this.settleConflict(c, landed ?? undefined, landedRevision);
+        await (0, cache_store_js_3.invalidateCache)(this.getUserId() ?? 'anonymous', c.collection);
         void (0, query_refresh_js_1.refreshCollectionQueries)(c.collection);
     }
     // ─── Update (online-first with offline fallback) ───────────────────────────
@@ -642,8 +756,11 @@ class KoolbaseDatabase {
             for (const w of queued) {
                 if (w.operation === 'insert')
                     projected = { ...(w.data ?? {}) };
+                // An edit applies to the record as it was: the queued add's state, or
+                // -- first in a chain with no add -- the baseline the edit was made
+                // against. Starting from nothing dropped every field it did not touch.
                 else if (w.operation === 'update')
-                    projected = { ...(projected ?? {}), ...(w.data ?? {}) };
+                    projected = { ...(projected ?? w.baseline ?? {}), ...(w.data ?? {}) };
                 else if (w.operation === 'delete')
                     projected = null;
             }
@@ -712,6 +829,8 @@ class KoolbaseDatabase {
             });
             const merged = { ...base.baseline, ...data };
             await (0, cache_store_js_1.cacheRecord)(userId, base.collection, recordId, merged, base.revision);
+            // And in the saved lists, so they show what the user just changed.
+            await (0, cache_store_js_2.updateInCachedQueries)(userId, base.collection, recordId, data);
             // Optimistic: durable locally and queued to send, not yet accepted.
             return {
                 id: recordId,
@@ -772,8 +891,9 @@ class KoolbaseDatabase {
             });
             // The queued write holds its own copy of the baseline, so removing the
             // cached record costs nothing and keeps local reads consistent with what
-            // the user just did.
+            // the user just did -- saved lists included.
             await (0, cache_store_js_1.removeCachedRecord)(userId, recordId);
+            await (0, cache_store_js_2.removeFromCachedQueries)(userId, base.collection, recordId);
         }
     }
     // ─── Vectors ────────────────────────────────────────────────────────────────

package/dist/cjs/index.d.ts

@@ -17,6 +17,8 @@ export type { RecordState, RecordStatus } from './record-controller.js';
 export { KoolbaseFlags } from './flags.js';
 export { KoolbaseFunctions } from './functions.js';
 export { KoolbaseRealtime } from './realtime.js';
+export { KoolbaseConnectivity } from './connectivity.js';
+export type { ConnectivityState } from './connectivity.js';
 export { KoolbaseStorage } from './storage.js';
 export { KoolbaseAnalytics, disabledAnalytics } from './analytics.js';
 export { KoolbaseFiscal, KoolbaseFiscalError, decodeFiscalResponse, isFiscalized, isPending } from './fiscal.js';
@@ -27,4 +29,4 @@ export { getOrCreateDeviceId } from './device-id.js';
 export { koolbaseSdkVersion } from './device-metadata.js';
 export { RestoreResult } from './types.js';
 export type { AuthStateListener, FetchLike, KoolbaseAuthStorage, ResendVerificationResult } from './types.js';
-export { setPlatform, getPlatform, memoryPlatform, type PlatformAdapter, type PlatformStorage, type PlatformNetwork, type PlatformLifecycle, type PlatformLocks, type PlatformInfo, } from './platform.js';
+export { setPlatform, getPlatform, memoryPlatform, type PlatformAdapter, type PlatformBroadcast, type PlatformStorage, type PlatformNetwork, type PlatformLifecycle, type PlatformLocks, type PlatformInfo, } from './platform.js';

package/dist/cjs/index.js

@@ -19,7 +19,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.memoryPlatform = exports.getPlatform = exports.setPlatform = exports.RestoreResult = exports.koolbaseSdkVersion = exports.getOrCreateDeviceId = exports.KoolbaseMessaging = exports.isPending = exports.isFiscalized = exports.decodeFiscalResponse = exports.KoolbaseFiscalError = exports.KoolbaseFiscal = exports.disabledAnalytics = exports.KoolbaseAnalytics = exports.KoolbaseStorage = exports.KoolbaseRealtime = exports.KoolbaseFunctions = exports.KoolbaseFlags = exports.initialRecordState = exports.KoolbaseRecordController = exports.initialCollectionState = exports.collectionQueryKey = exports.KoolbaseCollectionController = exports.KoolbaseDatabase = exports.KoolbaseAuth = void 0;
+exports.memoryPlatform = exports.getPlatform = exports.setPlatform = exports.RestoreResult = exports.koolbaseSdkVersion = exports.getOrCreateDeviceId = exports.KoolbaseMessaging = exports.isPending = exports.isFiscalized = exports.decodeFiscalResponse = exports.KoolbaseFiscalError = exports.KoolbaseFiscal = exports.disabledAnalytics = exports.KoolbaseAnalytics = exports.KoolbaseStorage = exports.KoolbaseConnectivity = exports.KoolbaseRealtime = exports.KoolbaseFunctions = exports.KoolbaseFlags = exports.initialRecordState = exports.KoolbaseRecordController = exports.initialCollectionState = exports.collectionQueryKey = exports.KoolbaseCollectionController = exports.KoolbaseDatabase = exports.KoolbaseAuth = void 0;
 __exportStar(require("./types.js"), exports);
 __exportStar(require("./errors.js"), exports);
 __exportStar(require("./network.js"), exports);
@@ -47,6 +47,8 @@ var functions_js_1 = require("./functions.js");
 Object.defineProperty(exports, "KoolbaseFunctions", { enumerable: true, get: function () { return functions_js_1.KoolbaseFunctions; } });
 var realtime_js_1 = require("./realtime.js");
 Object.defineProperty(exports, "KoolbaseRealtime", { enumerable: true, get: function () { return realtime_js_1.KoolbaseRealtime; } });
+var connectivity_js_1 = require("./connectivity.js");
+Object.defineProperty(exports, "KoolbaseConnectivity", { enumerable: true, get: function () { return connectivity_js_1.KoolbaseConnectivity; } });
 var storage_js_1 = require("./storage.js");
 Object.defineProperty(exports, "KoolbaseStorage", { enumerable: true, get: function () { return storage_js_1.KoolbaseStorage; } });
 var analytics_js_1 = require("./analytics.js");

package/dist/cjs/offline-state.d.ts

@@ -103,3 +103,23 @@ export declare function queueWrite(userId: string, write: Omit<QueuedWrite, 'ret
  * and nothing is written on a guess.
  */
 export declare function migrateLegacyQueue(userId: string): Promise<void>;
+/**
+ * Points the writes still queued for a record at the state it is now in.
+ *
+ * When a conflict is decided, the writes held behind it carry baselines
+ * describing the state the conflicted write would have produced -- a state
+ * that no longer exists, and may never have. Released unchanged they would
+ * replay against a revision that has moved on, and each would conflict in
+ * turn: one disagreement multiplying into as many conflicts as the user had
+ * queued. The same rule as the Flutter SDK's rebaseAfterResolution.
+ *
+ * Refreshing the baseline is enough because every operation is an absolute
+ * assignment: a patch says what a field becomes, not what to do to it. If a
+ * relative operation is ever added (an increment, an append), the chain must
+ * be replayed through its projected states instead.
+ */
+export declare function rebaseHeldWrites(state: OfflineState, recordId: string, resolved: Record<string, unknown>, revision: number | undefined): void;
+type StateListener = (userId: string) => void;
+/** Called with the user id whenever that user's offline state changes. */
+export declare function onOfflineStateChange(listener: StateListener): () => void;
+export {};