@koolbase/core 12.13.0 → 12.14.0

package/dist/esm/database.js

@@ -3,7 +3,8 @@ import { refreshCollectionQueries } from './query-refresh.js';
 import { KoolbaseRevisionMismatchError } from './database-errors.js';
 import { KoolbaseError, KoolbaseOfflineBaselineUnavailableError, KoolbaseUnauthenticatedError, } from './errors.js';
 import { cacheRecord, getCachedRecord, removeCachedRecord } from './cache-store.js';
-import { readOfflineState, mutateOfflineState, queueWrite, } from './offline-state.js';
+import { readOfflineState, mutateOfflineState, queueWrite, rebaseHeldWrites, onOfflineStateChange, } from './offline-state.js';
+import { removeFromCachedQueries, updateInCachedQueries } from './cache-store.js';
 import { KoolbaseConflict } from './conflict.js';
 import { toPendingWrite } from './pending-write.js';
 import { getCached, setCached, invalidateCache, optimisticallyInsert, hashQuery, } from './cache-store.js';
@@ -42,6 +43,8 @@ function batchOpToWire(op) {
 }
 export class KoolbaseDatabase {
     constructor(config, getUserId, getToken, onSessionExpired) {
+        this.stateWatchers = new Set();
+        this.offStateChange = null;
         /**
          * Resolves by id, reloading the stored conflict first.
          *
@@ -62,12 +65,15 @@ export 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;
@@ -427,6 +433,29 @@ export 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.
@@ -447,6 +476,69 @@ export class KoolbaseDatabase {
         const { pending } = await readOfflineState(userId);
         return pending.map(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 readOfflineState(userId);
+            const writes = pending.map(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 = 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.
@@ -537,6 +629,25 @@ export 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 mutateOfflineState(userId, (s) => {
+            s.conflicts = s.conflicts.filter((x) => x.id !== c.id);
+            rebaseHeldWrites(s, c.recordId, resolved, revision);
+        });
+    }
     async dropConflict(id) {
         const userId = this.requireUserId('conflict resolution');
         await mutateOfflineState(userId, (s) => {
@@ -551,6 +662,8 @@ export 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
@@ -561,7 +674,7 @@ export 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,
@@ -572,7 +685,7 @@ export 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) {
@@ -601,7 +714,8 @@ export class KoolbaseDatabase {
             }
             throw e;
         }
-        await this.dropConflict(c.id);
+        const landedRevision = landed && typeof landed.$revision === 'number' ? landed.$revision : undefined;
+        await this.settleConflict(c, landed ?? undefined, landedRevision);
         await invalidateCache(this.getUserId() ?? 'anonymous', c.collection);
         void refreshCollectionQueries(c.collection);
     }
@@ -639,8 +753,11 @@ export 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;
             }
@@ -709,6 +826,8 @@ export class KoolbaseDatabase {
             });
             const merged = { ...base.baseline, ...data };
             await cacheRecord(userId, base.collection, recordId, merged, base.revision);
+            // And in the saved lists, so they show what the user just changed.
+            await updateInCachedQueries(userId, base.collection, recordId, data);
             // Optimistic: durable locally and queued to send, not yet accepted.
             return {
                 id: recordId,
@@ -769,8 +888,9 @@ export 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 removeCachedRecord(userId, recordId);
+            await removeFromCachedQueries(userId, base.collection, recordId);
         }
     }
     // ─── Vectors ────────────────────────────────────────────────────────────────

package/dist/esm/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/esm/index.js

@@ -20,6 +20,7 @@ export { KoolbaseRecordController, initialRecordState } from './record-controlle
 export { KoolbaseFlags } from './flags.js';
 export { KoolbaseFunctions } from './functions.js';
 export { KoolbaseRealtime } from './realtime.js';
+export { KoolbaseConnectivity } from './connectivity.js';
 export { KoolbaseStorage } from './storage.js';
 export { KoolbaseAnalytics, disabledAnalytics } from './analytics.js';
 export { KoolbaseFiscal, KoolbaseFiscalError, decodeFiscalResponse, isFiscalized, isPending } from './fiscal.js';

package/dist/esm/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 {};

package/dist/esm/offline-state.js

@@ -130,6 +130,7 @@ export async function mutateOfflineState(userId, mutate) {
         }
         await getPlatform().storage.setItem(stateKey(userId), serialised);
     });
+    announce(userId);
 }
 /** Adds a write to the queue, under the user's lock. */
 export async function queueWrite(userId, write) {
@@ -202,3 +203,70 @@ export async function migrateLegacyQueue(userId) {
     });
     await getPlatform().storage.removeItem(legacyQueueKey(userId));
 }
+/**
+ * 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 function rebaseHeldWrites(state, recordId, resolved, revision) {
+    let current = {};
+    for (const [k, v] of Object.entries(resolved)) {
+        if (!k.startsWith('$'))
+            current[k] = v;
+    }
+    for (const w of state.pending) {
+        if (w.recordId !== recordId)
+            continue;
+        w.baseline = { ...current };
+        w.baseRevision = revision;
+        // Each write is composed against the one before it.
+        if (w.operation === 'update')
+            current = { ...current, ...(w.data ?? {}) };
+        else if (w.operation === 'delete')
+            break;
+    }
+}
+// ─── Change notification ─────────────────────────────────────────────────────
+const ANNOUNCE_PREFIX = 'koolbase:offline-state:';
+function stateListeners() {
+    return shared('offlineStateListeners', () => new Set());
+}
+/**
+ * Tells whoever is watching that a user's offline state changed -- here, and
+ * in every other copy of the SDK sharing this storage (other tabs). A badge in
+ * one tab must move when another tab's sync drains the queue.
+ */
+function announce(userId) {
+    for (const listener of [...stateListeners()]) {
+        try {
+            listener(userId);
+        }
+        catch { /* one broken listener must not stop the rest */ }
+    }
+    try {
+        getPlatform().broadcast?.post(ANNOUNCE_PREFIX + userId);
+    }
+    catch { /* best effort */ }
+}
+/** Called with the user id whenever that user's offline state changes. */
+export function onOfflineStateChange(listener) {
+    stateListeners().add(listener);
+    const off = getPlatform().broadcast?.on((message) => {
+        if (message.startsWith(ANNOUNCE_PREFIX))
+            listener(message.slice(ANNOUNCE_PREFIX.length));
+    });
+    return () => {
+        stateListeners().delete(listener);
+        off?.();
+    };
+}

package/dist/esm/platform.d.ts

@@ -12,6 +12,21 @@ export interface PlatformNetwork {
      * Koolbase is unreachable is handled the same as any failed request.
      */
     onChange(callback: (online: boolean) => void): () => void;
+    /**
+     * What the host believes right now: true online, false offline, null when
+     * it cannot tell. Optional: a host without it reports nothing until its
+     * first change, and connectivity stays 'unknown' until then.
+     */
+    current?(): Promise<boolean | null>;
+}
+/**
+ * A message to every other copy of the SDK sharing this storage -- other tabs
+ * of the same origin in a browser. Optional: one process (React Native) has no
+ * other copies to tell.
+ */
+export interface PlatformBroadcast {
+    post(message: string): void;
+    on(callback: (message: string) => void): () => void;
 }
 export interface PlatformLifecycle {
     /** Subscribe to the app moving to the background. Used to flush analytics. */
@@ -54,6 +69,7 @@ export interface PlatformAdapter {
     lifecycle: PlatformLifecycle;
     info: PlatformInfo;
     locks: PlatformLocks;
+    broadcast?: PlatformBroadcast;
     /**
      * The host's best persistent store for the auth session, or null if it has
      * none worth the name. Used only when the app injects nothing through

package/dist/esm/react/use-record.d.ts

@@ -3,6 +3,6 @@ export interface UseRecordResult extends RecordState {
     /** The record again, from the server. What is shown stays while it runs, and stays if it fails. */
     refresh: () => Promise<void>;
 }
-export declare function createUseRecord(getDb: () => Pick<KoolbaseDatabase, 'get'>): (collection: string, id: string | null | undefined, options?: {
+export declare function createUseRecord(getDb: () => Pick<KoolbaseDatabase, 'get'> & Partial<Pick<KoolbaseDatabase, 'getSaved'>>): (collection: string, id: string | null | undefined, options?: {
     live?: boolean;
 }) => UseRecordResult;

package/dist/esm/record-controller.d.ts

@@ -8,9 +8,14 @@ export interface RecordState {
     readonly error: unknown;
     /** True while refresh() runs. */
     readonly refreshing: boolean;
+    /**
+     * True while the record shown is the device's saved copy and the server has
+     * not confirmed it on this load. Stays true if the server cannot be reached.
+     */
+    readonly isSaved: boolean;
 }
 export declare const initialRecordState: RecordState;
-type RecordReader = Pick<KoolbaseDatabase, 'get'>;
+type RecordReader = Pick<KoolbaseDatabase, 'get'> & Partial<Pick<KoolbaseDatabase, 'getSaved'>>;
 export declare class KoolbaseRecordController {
     readonly collection: string;
     readonly id: string;
@@ -31,6 +36,8 @@ export declare class KoolbaseRecordController {
     subscribe(listener: () => void): () => void;
     /** The first load. Call once; refresh() for later loads. */
     load(): Promise<void>;
+    /** The device's saved copy, shown at once while the server is asked. */
+    private showSaved;
     /** The record again, from the server. What is shown stays while it runs, and stays if it fails. */
     refresh(): Promise<void>;
     /** Stops all updates. A result still in flight is dropped when it lands. */

package/dist/esm/record-controller.js

@@ -14,8 +14,10 @@
 //    or landing after dispose(), is dropped.
 //  - live (the option): realtime events for THIS record only. An update
 //    re-reads it silently, once per burst; a delete is notFound at once.
-// Not yet: an offline fallback from the record cache, which keeps data and
-// revision but not createdAt or createdBy.
+//  - saved-first, never saved-only: the device's saved copy (db.getSaved)
+//    shows at once with isSaved true while the server is asked. Success
+//    replaces it (isSaved false); failure keeps it (isSaved stays true); not
+//    found is notFound. No saved copy: the ordinary loading/error states.
 import { KoolbaseNotFoundError } from './database-errors.js';
 import { liveSource } from './live-source.js';
 export const initialRecordState = Object.freeze({
@@ -23,6 +25,7 @@ export const initialRecordState = Object.freeze({
     record: null,
     error: null,
     refreshing: false,
+    isSaved: false,
 });
 export class KoolbaseRecordController {
     constructor(db, collection, id, options = {}) {
@@ -58,8 +61,27 @@ export class KoolbaseRecordController {
         if (this.live && this.id) {
             this.unlive ?? (this.unlive = liveSource()?.subscribe(this.collection, (event) => this.onLive(event)) ?? null);
         }
+        await this.showSaved();
         await this.fetch();
     }
+    /** The device's saved copy, shown at once while the server is asked. */
+    async showSaved() {
+        if (!this.id || !this.db.getSaved)
+            return;
+        const gen = this.generation;
+        let saved = null;
+        try {
+            saved = await this.db.getSaved(this.id);
+        }
+        catch {
+            return;
+        }
+        if (!saved || this.isStale(gen) || this.state.status !== 'loading')
+            return;
+        if (saved.collection !== undefined && saved.collection !== this.collection)
+            return;
+        this.set({ status: 'loaded', record: saved, error: null, isSaved: true });
+    }
     /** The record again, from the server. What is shown stays while it runs, and stays if it fails. */
     async refresh() {
         if (this.disposed)
@@ -99,7 +121,7 @@ export class KoolbaseRecordController {
                 this.liveTimer = null;
             }
             this.generation += 1;
-            this.set({ status: 'notFound', record: null, error: null, refreshing: false });
+            this.set({ status: 'notFound', record: null, error: null, refreshing: false, isSaved: false });
             return;
         }
         if (this.liveTimer)
@@ -114,7 +136,7 @@ export class KoolbaseRecordController {
     async fetch() {
         const gen = ++this.generation;
         if (!this.id) {
-            this.set({ status: 'notFound', record: null, error: null });
+            this.set({ status: 'notFound', record: null, error: null, isSaved: false });
             return gen;
         }
         try {
@@ -122,17 +144,17 @@ export class KoolbaseRecordController {
             if (this.isStale(gen))
                 return gen;
             if (record.collection !== undefined && record.collection !== this.collection) {
-                this.set({ status: 'notFound', record: null, error: null });
+                this.set({ status: 'notFound', record: null, error: null, isSaved: false });
             }
             else {
-                this.set({ status: 'loaded', record, error: null });
+                this.set({ status: 'loaded', record, error: null, isSaved: false });
             }
         }
         catch (error) {
             if (this.isStale(gen))
                 return gen;
             if (error instanceof KoolbaseNotFoundError) {
-                this.set({ status: 'notFound', record: null, error: null });
+                this.set({ status: 'notFound', record: null, error: null, isSaved: false });
             }
             else if (this.state.record === null) {
                 this.set({ status: 'error', error });

package/dist/esm/shared.d.ts

@@ -1,4 +1,5 @@
 interface Slot {
+    offlineStateListeners: Set<(userId: string) => void>;
     platform?: unknown;
     locks?: Map<string, Promise<unknown>>;
 }

package/dist/esm/sync-engine.js

@@ -2,7 +2,7 @@ import { koolbaseFetch } from './network.js';
 import { readOfflineState, mutateOfflineState, migrateLegacyQueue, flushLockName, } from './offline-state.js';
 import { KoolbaseUnauthenticatedError } from './errors.js';
 import { getPlatform } from './platform.js';
-import { invalidateCache, removeCachedRecord, } from './cache-store.js';
+import { invalidateCache, removeCachedRecord, removeFromCachedQueries, } from './cache-store.js';
 /**
  * Internal signal that the server refused a write because the record moved.
  *
@@ -98,13 +98,21 @@ export class SyncEngine {
             // being online — would give the same input different outcomes. It clears
             // the old key when done, so later calls find nothing and return.
             await migrateLegacyQueue(userId);
-            const { pending } = await readOfflineState(userId);
+            const { pending, conflicts } = await readOfflineState(userId);
             if (pending.length === 0)
                 return;
             // Records whose chain stopped this pass. Writes queued after a conflicted
             // one were composed against the state it would have produced, so applying
             // them now would write against a state their baseline never described.
             const blocked = new Set();
+            // And records whose chain stopped in an EARLIER pass: a conflict waits
+            // for a decision across restarts, and so must the writes behind it.
+            // Seeded only from this pass's finds, the next pass replayed them
+            // against a state their baselines never described -- each becoming its
+            // own conflict. Deciding the conflict rebases and releases them.
+            for (const c of conflicts)
+                if (c.recordId)
+                    blocked.add(c.recordId);
             for (const queued of pending) {
                 if (queued.recordId && blocked.has(queued.recordId))
                     continue;
@@ -199,10 +207,15 @@ export class SyncEngine {
                         // — cached at enqueue for a record the server refused to create.
                         // Left alone it is a phantom: it renders as saved, and an offline
                         // edit against it queues a write to a record that does not exist.
-                        // Evict it, and invalidate the collection so cached queries stop
-                        // serving it. The conflict above keeps the user's data and the
-                        // server's verdict; the cache stops testifying to a fiction.
-                        // MUTATION: phantom eviction removed
+                        // Evict it from the record cache and from every cached query that
+                        // holds it -- precisely, not by dropping the collection's saved
+                        // results, which a device still offline needs. The conflict above
+                        // keeps the user's data and the server's verdict; the cache stops
+                        // testifying to a fiction.
+                        if (write.operation === 'insert' && write.recordId) {
+                            await removeCachedRecord(userId, write.recordId);
+                            await removeFromCachedQueries(userId, write.collection, write.recordId);
+                        }
                         if (write.recordId)
                             blocked.add(write.recordId);
                         continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koolbase/core",
-  "version": "12.13.0",
+  "version": "12.14.0",
   "description": "Koolbase SDK core \u2014 shared behaviour behind @koolbase/react-native and @koolbase/js. Install one of those, not this.",
   "main": "./dist/cjs/index.js",
   "types": "./dist/esm/index.d.ts",