@spooky-sync/core 0.0.1-canary.197 → 0.0.1-canary.198

package/dist/index.js

@@ -6746,7 +6746,18 @@ var Sp00kySync = class Sp00kySync {
 			}, "Query to register not found");
 			throw new Error("Query to register not found");
 		}
-		await this.remote.query("fn::query::heartbeat($id)", { id: queryState.config.id });
+		const result = await this.remote.query("fn::query::heartbeat($id)", { id: queryState.config.id });
+		const updated = Array.isArray(result) ? result[0] : void 0;
+		if (!(Array.isArray(updated) && updated.length === 0)) return;
+		this.logger.warn({
+			queryHash,
+			id: String(queryState.config.id),
+			Category: "sp00ky-client::Sp00kySync::heartbeatQuery"
+		}, "Query row was reclaimed while still in use; re-registering");
+		this.enqueueDownEvent({
+			type: "register",
+			payload: { hash: queryHash }
+		});
 	}
 	async cleanupQuery(queryHash) {
 		const queryState = this.dataModule.getQueryByHash(queryHash);
@@ -7081,8 +7092,8 @@ function selfAllowlistedVariant(flag, userId) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.197";
-const WASM_VERSION = "0.0.1-canary.197";
+const CORE_VERSION = "0.0.1-canary.198";
+const WASM_VERSION = "0.0.1-canary.198";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	eventsHistory = [];
@@ -11513,7 +11524,7 @@ var Sp00kyClient = class {
 		return new TabsCoordinator({
 			tabId,
 			fingerprint: computeTabsFingerprint({
-				coreVersion: "0.0.1-canary.197",
+				coreVersion: "0.0.1-canary.198",
 				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.197",
+  "version": "0.0.1-canary.198",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -60,8 +60,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.197",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.197",
+    "@spooky-sync/query-builder": "0.0.1-canary.198",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.198",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",

package/src/modules/sync/sync.heartbeat.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RecordId } from 'surrealdb';
+import { Sp00kySync } from './sync';
+
+/**
+ * `fn::query::heartbeat` is an `UPDATE $id SET ...`. Against a record that no
+ * longer exists it matches nothing and returns an empty array — it does NOT
+ * recreate the row. Verified against the deployed function:
+ *
+ *     RETURN fn::query::heartbeat(_00_query:definitely_not_a_real_row_xyz);
+ *     -- (0 rows)
+ *
+ * So an unchecked heartbeat cannot tell "refreshed" from "the row I am
+ * refreshing is gone", and a client whose row was reclaimed by the TTL sweep
+ * beats against nothing forever: no membership, no edges, no re-registration.
+ * The page then renders as though the data had been deleted — reported as
+ * "Game not found" on a game that was open and working.
+ *
+ * This is reachable in ordinary use: the sweep expires on `lastActiveAt + ttl`
+ * while the heartbeat runs on a timer browsers throttle hard in background
+ * tabs, so a second window left idle past its TTL is the normal way in.
+ */
+
+function makeSync(heartbeatResult: unknown) {
+  const logger: any = {
+    child: () => logger,
+    debug: () => {}, info: () => {}, warn: () => {}, error: () => {}, trace: () => {},
+  };
+  const remote: any = { query: vi.fn().mockResolvedValue(heartbeatResult) };
+  const queryState: any = { config: { id: new RecordId('_00_query', 'h1') } };
+  const dataModule: any = { getQueryByHash: vi.fn().mockReturnValue(queryState) };
+
+  const sync = new Sp00kySync({} as any, remote, {} as any, dataModule, {} as any, logger);
+  const enqueueDownEvent = vi.fn();
+  (sync as any).enqueueDownEvent = enqueueDownEvent;
+
+  return { sync, remote, dataModule, enqueueDownEvent };
+}
+
+describe('heartbeatQuery — noticing a reclaimed row', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('re-registers when the row it beat against is gone', async () => {
+    // `UPDATE` on a deleted record: one statement, zero updated records.
+    const { sync, enqueueDownEvent } = makeSync([[]]);
+
+    await sync.heartbeatQuery('h1');
+
+    expect(enqueueDownEvent).toHaveBeenCalledWith({
+      type: 'register',
+      payload: { hash: 'h1' },
+    });
+  });
+
+  it('does nothing extra on a healthy heartbeat', async () => {
+    const { sync, enqueueDownEvent } = makeSync([[{ id: 'x', lastActiveAt: 'now' }]]);
+
+    await sync.heartbeatQuery('h1');
+
+    expect(enqueueDownEvent).not.toHaveBeenCalled();
+  });
+
+  it('does not re-register on an unrecognised result shape', async () => {
+    // Only an explicitly EMPTY update result means "the row is gone". Anything
+    // else — a driver returning null, a shape change — must not be read as
+    // deletion, or every heartbeat would re-register the whole working set.
+    for (const shape of [null, undefined, [], [null], ['unexpected']]) {
+      const { sync, enqueueDownEvent } = makeSync(shape);
+      await sync.heartbeatQuery('h1');
+      expect(enqueueDownEvent, `shape ${JSON.stringify(shape)}`).not.toHaveBeenCalled();
+    }
+  });
+
+  it('still throws for a query that is no longer registered locally', async () => {
+    const { sync, dataModule } = makeSync([[]]);
+    dataModule.getQueryByHash.mockReturnValue(undefined);
+
+    await expect(sync.heartbeatQuery('gone')).rejects.toThrow();
+  });
+});

package/src/modules/sync/sync.ts

@@ -1768,9 +1768,40 @@ export class Sp00kySync<S extends SchemaStructure> {
       );
       throw new Error('Query to register not found');
     }
-    await this.remote.query('fn::query::heartbeat($id)', {
+    // `fn::query::heartbeat` is an `UPDATE $id SET ...`. On a record that no
+    // longer exists that matches nothing and returns an empty array — it does
+    // NOT recreate the row. So an unchecked heartbeat is indistinguishable from
+    // a successful one, and a client whose row was reclaimed keeps beating
+    // against nothing forever: no membership, no edges, no re-registration.
+    // The page renders as if the data were deleted ("Game not found").
+    //
+    // A live query's row is reclaimed more easily than it looks. The sweep
+    // expires on `lastActiveAt + ttl`, and this heartbeat runs on a timer that
+    // browsers throttle hard in background tabs — so a second window left idle
+    // past its TTL is the ordinary way to get here, not an edge case. Until
+    // canary.194 the sweep could not actually remove the in-memory view (it
+    // looked it up under the other of the two query-id spellings), which masked
+    // this: the view survived its own row. Now reclamation is real, so the
+    // client has to notice and rebuild.
+    const result = await this.remote.query('fn::query::heartbeat($id)', {
       id: queryState.config.id,
     });
+    const updated = Array.isArray(result) ? result[0] : undefined;
+    const rowGone = Array.isArray(updated) && updated.length === 0;
+    if (!rowGone) return;
+
+    this.logger.warn(
+      {
+        queryHash,
+        id: String(queryState.config.id),
+        Category: 'sp00ky-client::Sp00kySync::heartbeatQuery',
+      },
+      'Query row was reclaimed while still in use; re-registering'
+    );
+    // Re-register rather than recreate the row here: the row alone is useless
+    // without the SSP view behind it, and only registration rebuilds the view,
+    // republishes `_00_list_ref` and writes `rowCount`.
+    this.enqueueDownEvent({ type: 'register', payload: { hash: queryHash } });
   }
 
   // Eager teardown of a deregistered query's remote `_00_query` view (opt-in,