@spooky-sync/core 0.0.1-canary.224 → 0.0.1-canary.226

package/dist/index.d.ts

@@ -814,7 +814,7 @@ declare class DataModule<S extends SchemaStructure> {
    * No-op when nothing is pending. The pending entry is removed before the
    * await so a concurrently-firing timer can't process it twice.
    */
-  flushPendingStreamUpdate(queryHash: string): Promise<void>;
+  flushPendingStreamUpdate(queryHash: string): Promise<boolean>;
   /**
    * Materialize a query's result rows from the local store.
    *

package/dist/index.js

@@ -3753,9 +3753,10 @@ var DataModule = class DataModule {
 			this.debounceTimers.delete(queryHash);
 		}
 		const pending = this.pendingStreamUpdates.get(queryHash);
-		if (!pending) return;
+		if (!pending) return false;
 		this.pendingStreamUpdates.delete(queryHash);
 		await this.processStreamUpdate(pending);
+		return true;
 	}
 	/**
 	* Materialize a query's result rows from the local store.
@@ -7244,7 +7245,10 @@ var Sp00kySync = class Sp00kySync {
 		} finally {
 			if (fetching) {
 				try {
-					await this.dataModule.flushPendingStreamUpdate(hash);
+					if (!await this.dataModule.flushPendingStreamUpdate(hash)) {
+						this.dataModule.scheduleRematerialize(hash);
+						await this.dataModule.flushPendingStreamUpdate(hash);
+					}
 				} catch (err) {
 					this.logger.warn({
 						err,
@@ -7760,8 +7764,8 @@ function selfAllowlistedVariant(flag, userId) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.224";
-const WASM_VERSION = "0.0.1-canary.224";
+const CORE_VERSION = "0.0.1-canary.226";
+const WASM_VERSION = "0.0.1-canary.226";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	eventsHistory = [];
@@ -12776,7 +12780,7 @@ var Sp00kyClient = class {
 		return new TabsCoordinator({
 			tabId,
 			fingerprint: computeTabsFingerprint({
-				coreVersion: "0.0.1-canary.224",
+				coreVersion: "0.0.1-canary.226",
 				schemaHash: hash53(this.config.schemaSurql),
 				endpoint: this.config.database.endpoint ?? "",
 				namespace: this.config.database.namespace,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.224",
+  "version": "0.0.1-canary.226",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -60,8 +60,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.224",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.224",
+    "@spooky-sync/query-builder": "0.0.1-canary.226",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.226",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "blurhash": "^2.0.5",

package/src/modules/data/index.ts

@@ -492,16 +492,17 @@ export class DataModule<S extends SchemaStructure> {
    * No-op when nothing is pending. The pending entry is removed before the
    * await so a concurrently-firing timer can't process it twice.
    */
-  async flushPendingStreamUpdate(queryHash: string): Promise<void> {
+  async flushPendingStreamUpdate(queryHash: string): Promise<boolean> {
     const timer = this.debounceTimers.get(queryHash);
     if (timer) {
       clearTimeout(timer);
       this.debounceTimers.delete(queryHash);
     }
     const pending = this.pendingStreamUpdates.get(queryHash);
-    if (!pending) return;
+    if (!pending) return false;
     this.pendingStreamUpdates.delete(queryHash);
     await this.processStreamUpdate(pending);
+    return true;
   }
 
   /**

package/src/modules/sync/sync.rematerialize-after-fetch.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect, vi } from 'vitest';
+import { RecordId } from 'surrealdb';
+import { Sp00kySync } from './sync';
+
+// A LIVE (or poll) UPDATE for a row already in membership fetches the new body
+// into the local store — and that can be the end of it: the circuit sees the
+// same id-set and emits no stream update, and nothing else re-reads the query.
+// Measured on staging: a `conversation` row reached the store at `_00_rv` 8
+// while the query kept rendering version 2 for minutes. `runSyncForQuery`
+// must therefore land a synthetic re-materialize whenever a fetch produced
+// no stream update of its own.
+
+function makeSync(opts: { streamUpdatePending: boolean }) {
+  const logger: any = {
+    child: () => logger,
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    trace: () => {},
+  };
+  const queryState: any = {
+    config: {
+      id: new RecordId('_00_query', 'h1'),
+      // Membership already knows the newer version; the circuit still holds 1.
+      localArray: [['conversation:c1', 1]],
+      remoteArray: [['conversation:c1', 8]],
+      membershipKnown: true,
+    },
+  };
+  const calls: string[] = [];
+  const dataModule: any = {
+    getQueryByHash: vi.fn().mockReturnValue(queryState),
+    getPendingRecordIds: async () => ({ writes: new Set(), deletes: new Set() }),
+    beginFetching: vi.fn(() => calls.push('beginFetching')),
+    endFetching: vi.fn(() => calls.push('endFetching')),
+    recordRemoteFetch: vi.fn(),
+    updateQueryLocalArray: vi.fn(),
+    scheduleRematerialize: vi.fn(() => calls.push('scheduleRematerialize')),
+    // First flush reports whether a real stream update was pending; a second
+    // flush (after the synthetic schedule) always lands something.
+    flushPendingStreamUpdate: vi
+      .fn()
+      .mockImplementationOnce(async () => {
+        calls.push('flush');
+        return opts.streamUpdatePending;
+      })
+      .mockImplementation(async () => {
+        calls.push('flush');
+        return true;
+      }),
+  };
+  const sync = new Sp00kySync({} as any, { query: vi.fn() } as any, {} as any, dataModule, {} as any, logger);
+  (sync as any).syncEngine = {
+    syncRecords: vi.fn(async () => {
+      calls.push('syncRecords');
+      return { remoteFetchMs: 3, stillRemoteIds: [] };
+    }),
+  };
+  const run = () =>
+    (sync as any).runSyncForQuery('h1', {
+      added: [],
+      updated: [{ id: 'conversation:c1', version: 8 }],
+      removed: [],
+    }) as Promise<void>;
+  return { run, dataModule, calls };
+}
+
+describe('runSyncForQuery re-materializes a fetched row the circuit stayed silent about', () => {
+  it('schedules and lands a synthetic re-materialize before going idle', async () => {
+    const { run, dataModule, calls } = makeSync({ streamUpdatePending: false });
+    await run();
+    expect(dataModule.scheduleRematerialize).toHaveBeenCalledWith('h1');
+    expect(dataModule.flushPendingStreamUpdate).toHaveBeenCalledTimes(2);
+    // The re-render lands BEFORE `endFetching`, so `idle` never races ahead
+    // of the rows it describes.
+    expect(calls).toEqual([
+      'beginFetching',
+      'syncRecords',
+      'flush',
+      'scheduleRematerialize',
+      'flush',
+      'endFetching',
+    ]);
+  });
+
+  it('leaves a real stream update alone', async () => {
+    const { run, dataModule } = makeSync({ streamUpdatePending: true });
+    await run();
+    expect(dataModule.scheduleRematerialize).not.toHaveBeenCalled();
+    expect(dataModule.flushPendingStreamUpdate).toHaveBeenCalledTimes(1);
+  });
+});

package/src/modules/sync/sync.ts

@@ -1803,8 +1803,21 @@ export class Sp00kySync<S extends SchemaStructure> {
         // Land the coalesced result BEFORE flipping to idle: the final stream
         // update sits on a debounce timer, and an `idle` that races ahead of it
         // would let consumers treat a partially-filled window as authoritative.
+        //
+        // A fetch that changed a row already in membership can come with no
+        // stream update at all: the body lands in the local store, but the
+        // circuit sees the same id-set and stays silent (measured: a peer's
+        // UPDATE to a `conversation` row reached the store at `_00_rv` 8 while
+        // the query kept rendering version 2 indefinitely). Nothing else
+        // re-reads the query then, so ask for a synthetic re-materialize and
+        // land it here too. It is one local select, and a no-op when a real
+        // update was pending, which the first flush already processed.
         try {
-          await this.dataModule.flushPendingStreamUpdate(hash);
+          const landed = await this.dataModule.flushPendingStreamUpdate(hash);
+          if (!landed) {
+            this.dataModule.scheduleRematerialize(hash);
+            await this.dataModule.flushPendingStreamUpdate(hash);
+          }
         } catch (err) {
           this.logger.warn(
             { err, hash, Category: 'sp00ky-client::Sp00kySync::runSyncForQuery' },