@spooky-sync/core 0.0.1-canary.221 → 0.0.1-canary.223

package/dist/index.d.ts

@@ -882,8 +882,21 @@ declare class DataModule<S extends SchemaStructure> {
    * rolls the mutation back and never reports it settled, so it vanishes at
    * once. This deadline only bounds the case where the write succeeded and its
    * membership never arrived at all.
+   *
+   * 30 s, up from 10 s. At 10 s every server hiccup longer than a scheduler
+   * drain plus one slow database commit showed up as the user's own chat
+   * message vanishing and coming back a minute later. 30 s covers a drain and
+   * a stalled commit end to end; a membership that takes longer than that is
+   * a server fault the admin heartbeat reports, not something to paper over.
    */
   private static readonly SETTLED_WRITE_GRACE_MS;
+  /**
+   * Whether any settled write or delete is still waiting for membership to
+   * catch up. The sync poll keeps its fast cadence while this is true, so a
+   * missed LIVE notification for the edge is picked up on the next poll tick
+   * rather than after the idle backoff.
+   */
+  hasSettledWritesPending(): boolean;
   /**
    * Report that a mutation was accepted by the server and its outbox row
    * removed. Called only on the SUCCESS path — a rolled-back mutation must

package/dist/index.js

@@ -3473,6 +3473,14 @@ function phaseStatOf(samples, lastMs) {
 		count: samples.length
 	};
 }
+/**
+* Fraction of a query's TTL after which the client refreshes `lastActiveAt`.
+*
+* Must leave room for at least one retry: the server sweeps a view — and its
+* `_00_list_ref` edges — the moment `lastActiveAt + ttl` passes, and the client
+* is LIVE on those edges, so a swept-but-still-watched view empties the UI.
+*/
+const TTL_HEARTBEAT_FRACTION = .5;
 var DataModule = class DataModule {
 	/** Tab identity baked into mutation ids (shared-tabs rollback routing);
 	*  undefined in solo mode, where mutation-id falls back to a session id. */
@@ -3855,8 +3863,24 @@ var DataModule = class DataModule {
 	* rolls the mutation back and never reports it settled, so it vanishes at
 	* once. This deadline only bounds the case where the write succeeded and its
 	* membership never arrived at all.
+	*
+	* 30 s, up from 10 s. At 10 s every server hiccup longer than a scheduler
+	* drain plus one slow database commit showed up as the user's own chat
+	* message vanishing and coming back a minute later. 30 s covers a drain and
+	* a stalled commit end to end; a membership that takes longer than that is
+	* a server fault the admin heartbeat reports, not something to paper over.
 	*/
-	static SETTLED_WRITE_GRACE_MS = 1e4;
+	static SETTLED_WRITE_GRACE_MS = 3e4;
+	/**
+	* Whether any settled write or delete is still waiting for membership to
+	* catch up. The sync poll keeps its fast cadence while this is true, so a
+	* missed LIVE notification for the edge is picked up on the next poll tick
+	* rather than after the idle backoff.
+	*/
+	hasSettledWritesPending() {
+		this.pruneSettled(Date.now());
+		return this.settledWrites.size > 0 || this.settledDeletes.size > 0;
+	}
 	/**
 	* Report that a mutation was accepted by the server and its outbox row
 	* removed. Called only on the SUCCESS path — a rolled-back mutation must
@@ -5023,7 +5047,7 @@ var DataModule = class DataModule {
 	}
 	startTTLHeartbeat(queryState, hash) {
 		if (queryState.ttlTimer) return;
-		const heartbeatTime = Math.floor(queryState.ttlDurationMs * .9);
+		const heartbeatTime = Math.floor(queryState.ttlDurationMs * TTL_HEARTBEAT_FRACTION);
 		queryState.ttlTimer = setTimeout(() => {
 			queryState.ttlTimer = null;
 			if ((this.subscriptions.get(hash)?.size ?? 0) === 0) {
@@ -6620,7 +6644,8 @@ var Sp00kySync = class Sp00kySync {
 				} finally {
 					this.listRefPollInFlight = null;
 					if (!this.listRefPollRunning) return;
-					this.listRefIdleStreak = changed ? 0 : this.listRefIdleStreak + 1;
+					const awaitingMembership = this.dataModule.hasSettledWritesPending();
+					this.listRefIdleStreak = changed || awaitingMembership ? 0 : this.listRefIdleStreak + 1;
 					schedule(listRefPollDelayMs({
 						idleStreak: this.listRefIdleStreak,
 						baseIntervalMs: this.refSyncIntervalMs
@@ -7735,8 +7760,8 @@ function selfAllowlistedVariant(flag, userId) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.221";
-const WASM_VERSION = "0.0.1-canary.221";
+const CORE_VERSION = "0.0.1-canary.223";
+const WASM_VERSION = "0.0.1-canary.223";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	eventsHistory = [];
@@ -12751,7 +12776,7 @@ var Sp00kyClient = class {
 		return new TabsCoordinator({
 			tabId,
 			fingerprint: computeTabsFingerprint({
-				coreVersion: "0.0.1-canary.221",
+				coreVersion: "0.0.1-canary.223",
 				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.221",
+  "version": "0.0.1-canary.223",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -60,8 +60,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.221",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.221",
+    "@spooky-sync/query-builder": "0.0.1-canary.223",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.223",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "blurhash": "^2.0.5",

package/src/modules/data/data.settled-writes.test.ts

@@ -169,9 +169,38 @@ describe('settled-write grace window', () => {
     });
     dm.noteWriteSettled('comment:new', 'create');
     expect(ids(await materialize(dm, state))).toContain('comment:new');
+    expect(dm.hasSettledWritesPending()).toBe(true);
 
+    // A scheduler drain plus one stalled database commit fit inside the
+    // window: at 11 s the row is still the user's own message, not a ghost.
     vi.advanceTimersByTime(11_000);
+    expect(ids(await materialize(dm, state))).toContain('comment:new');
+    expect(dm.hasSettledWritesPending()).toBe(true);
+
+    vi.advanceTimersByTime(20_000);
     expect(ids(await materialize(dm, state))).toEqual(['comment:old']);
+    expect(dm.hasSettledWritesPending()).toBe(false);
+  });
+
+  it('reports no pending settled write once membership has caught up', async () => {
+    const { dm, state } = setup({
+      remoteArray: [['comment:old', 1]],
+      localArray: [
+        ['comment:old', 1],
+        ['comment:new', 1],
+      ],
+    });
+    expect(dm.hasSettledWritesPending()).toBe(false);
+
+    dm.noteWriteSettled('comment:new', 'create');
+    expect(dm.hasSettledWritesPending()).toBe(true);
+
+    state.config.remoteArray = [
+      ['comment:old', 1],
+      ['comment:new', 1],
+    ];
+    await materialize(dm, state);
+    expect(dm.hasSettledWritesPending()).toBe(false);
   });
 
   it('keeps an accepted delete subtracted until membership drops the row', async () => {

package/src/modules/data/index.ts

@@ -90,6 +90,15 @@ export interface DurableMembership {
   confirmed: boolean;
 }
 
+/**
+ * Fraction of a query's TTL after which the client refreshes `lastActiveAt`.
+ *
+ * Must leave room for at least one retry: the server sweeps a view — and its
+ * `_00_list_ref` edges — the moment `lastActiveAt + ttl` passes, and the client
+ * is LIVE on those edges, so a swept-but-still-watched view empties the UI.
+ */
+const TTL_HEARTBEAT_FRACTION = 0.5;
+
 export class DataModule<S extends SchemaStructure> {
   /** Tab identity baked into mutation ids (shared-tabs rollback routing);
    *  undefined in solo mode, where mutation-id falls back to a session id. */
@@ -675,8 +684,25 @@ export class DataModule<S extends SchemaStructure> {
    * rolls the mutation back and never reports it settled, so it vanishes at
    * once. This deadline only bounds the case where the write succeeded and its
    * membership never arrived at all.
+   *
+   * 30 s, up from 10 s. At 10 s every server hiccup longer than a scheduler
+   * drain plus one slow database commit showed up as the user's own chat
+   * message vanishing and coming back a minute later. 30 s covers a drain and
+   * a stalled commit end to end; a membership that takes longer than that is
+   * a server fault the admin heartbeat reports, not something to paper over.
+   */
+  private static readonly SETTLED_WRITE_GRACE_MS = 30_000;
+
+  /**
+   * Whether any settled write or delete is still waiting for membership to
+   * catch up. The sync poll keeps its fast cadence while this is true, so a
+   * missed LIVE notification for the edge is picked up on the next poll tick
+   * rather than after the idle backoff.
    */
-  private static readonly SETTLED_WRITE_GRACE_MS = 10_000;
+  hasSettledWritesPending(): boolean {
+    this.pruneSettled(Date.now());
+    return this.settledWrites.size > 0 || this.settledDeletes.size > 0;
+  }
 
   /**
    * Report that a mutation was accepted by the server and its outbox row
@@ -2452,7 +2478,25 @@ export class DataModule<S extends SchemaStructure> {
   private startTTLHeartbeat(queryState: QueryState, hash: QueryHash): void {
     if (queryState.ttlTimer) return;
 
-    const heartbeatTime = Math.floor(queryState.ttlDurationMs * 0.9);
+    // Half the TTL, not 0.9 of it, so ONE failed beat is survivable.
+    //
+    // The timer re-arms after each beat, so expiry sits a full TTL after the
+    // last SUCCESSFUL refresh. At 0.9 a beat that fails — the SSP restarting,
+    // a reconnect, a slow database — left 10% of the TTL before the sweep
+    // deleted the row AND its `_00_list_ref` edges, with no second attempt in
+    // between. On a 10m TTL that is 60 seconds of slack against an SSP
+    // bootstrap that takes ~2 minutes on a large tenant, so the view lost a
+    // race it could not win.
+    //
+    // The user-visible form is content vanishing and coming back: the client
+    // is LIVE on those edges, so it sees the sweep's deletes immediately, and
+    // only restores them once its heartbeat notices the row is gone and
+    // re-registers. Reported as chat messages disappearing for 10+ seconds.
+    //
+    // At 0.5 a single failure still leaves another attempt and half the TTL.
+    // The cost is one extra beat per view per TTL, which is a single
+    // `UPDATE ... SET lastActiveAt`.
+    const heartbeatTime = Math.floor(queryState.ttlDurationMs * TTL_HEARTBEAT_FRACTION);
 
     queryState.ttlTimer = setTimeout(() => {
       queryState.ttlTimer = null;

package/src/modules/sync/sync.settled-poll.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { Sp00kySync } from './sync';
+
+// The list_ref poll backs off toward a 5s cap on a quiet page. A settled write
+// that is still waiting for its membership edge must hold the poll at its base
+// cadence instead: the row is rendered on the settled-write grace alone, so
+// the edge has to be found on the first poll after it lands, not after the
+// backoff has grown. Otherwise a missed LIVE notification during a server
+// stall turns into "my message vanished" even though the edge arrived.
+
+function makeSync(pending: () => boolean) {
+  const logger: any = {
+    child: () => logger,
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    trace: () => {},
+  };
+  const remote: any = { query: vi.fn().mockResolvedValue([true]) };
+  const dataModule: any = {
+    getActiveQueryHashes: () => ['h1'],
+    hasSettledWritesPending: pending,
+  };
+  const sync = new Sp00kySync({} as any, remote, {} as any, dataModule, {} as any, logger);
+  // A poll that never observes a change: the only thing driving the streak is
+  // the settled-write signal.
+  (sync as any).pollListRefForActiveQueries = vi.fn().mockResolvedValue(false);
+  return sync;
+}
+
+describe('list_ref poll cadence while a settled write awaits membership', () => {
+  afterEach(() => vi.useRealTimers());
+
+  it('stays at the base cadence while a write is pending, then backs off', async () => {
+    vi.useFakeTimers();
+    let pending = true;
+    const sync = makeSync(() => pending);
+    const base = sync.refSyncIntervalMs;
+
+    (sync as any).startListRefPoll();
+
+    // Three quiet ticks with a write outstanding: no backoff at all.
+    for (let i = 0; i < 3; i++) {
+      await vi.advanceTimersByTimeAsync(base);
+      expect((sync as any).listRefIdleStreak).toBe(0);
+    }
+
+    // Membership caught up: the ordinary idle backoff resumes.
+    pending = false;
+    await vi.advanceTimersByTimeAsync(base);
+    expect((sync as any).listRefIdleStreak).toBe(1);
+    await vi.advanceTimersByTimeAsync(base * 2);
+    expect((sync as any).listRefIdleStreak).toBe(2);
+
+    (sync as any).stopListRefPoll();
+  });
+});

package/src/modules/sync/sync.ts

@@ -877,8 +877,12 @@ export class Sp00kySync<S extends SchemaStructure> {
           // Reset the idle streak on any observed change so the poll snaps
           // back to the fast base cadence; otherwise grow it so a quiet page
           // backs off toward the cap. (`handleRemoteListRefChange` also resets
-          // it when a LIVE event lands.)
-          this.listRefIdleStreak = changed ? 0 : this.listRefIdleStreak + 1;
+          // it when a LIVE event lands.) A settled write still waiting for its
+          // membership also pins the fast cadence: the row is on borrowed time
+          // (the settled-write grace), so the edge must be found on the first
+          // poll after it lands, not after the backoff has grown to the cap.
+          const awaitingMembership = this.dataModule.hasSettledWritesPending();
+          this.listRefIdleStreak = changed || awaitingMembership ? 0 : this.listRefIdleStreak + 1;
           const next = listRefPollDelayMs({
             idleStreak: this.listRefIdleStreak,
             baseIntervalMs: this.refSyncIntervalMs,