@spooky-sync/core 0.0.1-canary.328 → 0.0.1-canary.329

package/dist/index.js

@@ -2188,8 +2188,8 @@ function trimHistory(history, cap) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.328";
-const WASM_VERSION = "0.0.1-canary.328";
+const CORE_VERSION = "0.0.1-canary.329";
+const WASM_VERSION = "0.0.1-canary.329";
 const SURREAL_VERSION = "3.1.0";
 var DevToolsService = class DevToolsService {
 	version = CORE_VERSION;
@@ -9895,7 +9895,8 @@ function pureWriteOpResult(op) {
 * shared {@link resolveRelations} — identical to the SurrealDB backend.
 *
 * Value normalization (JSON round-trip):
-* - `Uint8Array`/bytes → `{ "__u8": <base64> }` (CRDT snapshots survive).
+* - Bytes in any shape (`Uint8Array`, the SDK's `ArrayBuffer`) →
+*   `{ "__u8": <base64> }`, read back as `Uint8Array` (CRDT data survives).
 * - Record links / ids → their `table:id` string form (so `json_extract`
 *   comparisons and `IN` matching are consistent). NOTE: link fields therefore
 *   read back as strings, not `RecordId` instances — the one shape difference
@@ -15392,7 +15393,7 @@ function createTabsCoordinator(config, s, host) {
 	return new TabsCoordinator({
 		tabId: s.tabId,
 		fingerprint: computeTabsFingerprint({
-			coreVersion: "0.0.1-canary.328",
+			coreVersion: "0.0.1-canary.329",
 			schemaHash: hash53(config.schemaSurql),
 			endpoint: config.database.endpoint ?? "",
 			namespace: config.database.namespace,

package/dist/sqlite-open.js

@@ -194,9 +194,10 @@ function scalar(value) {
 }
 function serializeRow(row) {
 	return JSON.stringify(row, function(k, v) {
-		if (v instanceof Uint8Array) return { __u8: toBase64(v) };
 		const raw = this[k];
 		if (raw && typeof raw === "object") {
+			const bytes = bytesOf(raw);
+			if (bytes) return { __u8: toBase64(bytes) };
 			const key = recordIdKey(raw);
 			if (key !== null) return key;
 		}
@@ -204,6 +205,18 @@ function serializeRow(row) {
 	});
 }
 /**
+* The bytes of a binary value, whatever shape it arrived in. Rows from the
+* server carry a `bytes` column as an `ArrayBuffer` (the surrealdb SDK's CBOR
+* decode), not a `Uint8Array`, and `JSON.stringify` turns an `ArrayBuffer`
+* into `{}`: every synced CRDT log row and presence state was stored empty.
+*/
+function bytesOf(value) {
+	if (value instanceof Uint8Array) return value;
+	if (value instanceof ArrayBuffer) return new Uint8Array(value);
+	if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+	return null;
+}
+/**
 * Serialize a MERGE row ONCE for both halves of the merge upsert: the row a
 * fresh INSERT stores and the RFC 7396 delta `json_patch` applies on conflict.
 *

package/dist/tabs-broker-worker.js

@@ -81,7 +81,10 @@ function clearLeader(ns, opts) {
 		brokerInstanceId,
 		leadershipId: leader.leadershipId
 	});
-	if (opts.removeTab && tab) removeTab(ns, leader.tabId, { notifyLeader: false });
+	if (opts.removeTab && tab) removeTab(ns, leader.tabId, {
+		notifyLeader: false,
+		closePort: false
+	});
 	for (const t of ns.tabs.values()) if (t.tabId !== leader.tabId) post(t.port, {
 		type: "close-follower-ports",
 		brokerInstanceId,
@@ -131,8 +134,9 @@ function failPromotion(ns, tabId, leadershipId, opts) {
 /**
 * Fast crash detection: queue a Web Lock request on the leader's tab lock.
 * Locks release the instant their holder's tab dies, so being GRANTED means
-* the leader is gone; release immediately (return from the callback) and
-* re-elect. The leadershipId guard drops stale grants after a normal handoff.
+* the leader is gone from this bucket (dead, or moved to another bucket on
+* sign-in/out); release immediately (return from the callback) and re-elect.
+* The leadershipId guard drops stale grants after a normal handoff.
 */
 function startTabLockMonitor(ns, leadershipId) {
 	const locks = navigator.locks;
@@ -344,8 +348,9 @@ function handleTabMessage(port, msg, ports) {
 			});
 			return;
 		}
-		const ns = getNamespace(msg.fingerprint, msg.bucketId);
 		for (const other of [...namespaces.values()]) if (other.tabs.has(msg.tabId)) evictTab(other, msg.tabId, "rehello", { closePort: false });
+		canonicalFingerprint ??= msg.fingerprint;
+		const ns = getNamespace(msg.fingerprint, msg.bucketId);
 		const tab = {
 			port,
 			tabId: msg.tabId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.328",
+  "version": "0.0.1-canary.329",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -75,8 +75,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.328",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.328",
+    "@spooky-sync/query-builder": "0.0.1-canary.329",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.329",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.1.0",
     "@surrealdb/wasm-native": "^3.3.4",

package/src/services/database/sqlite-cache-engine.ts

@@ -102,7 +102,8 @@ export function pureWriteOpResult(op: SqlOp): unknown {
  * shared {@link resolveRelations} — identical to the SurrealDB backend.
  *
  * Value normalization (JSON round-trip):
- * - `Uint8Array`/bytes → `{ "__u8": <base64> }` (CRDT snapshots survive).
+ * - Bytes in any shape (`Uint8Array`, the SDK's `ArrayBuffer`) →
+ *   `{ "__u8": <base64> }`, read back as `Uint8Array` (CRDT data survives).
  * - Record links / ids → their `table:id` string form (so `json_extract`
  *   comparisons and `IN` matching are consistent). NOTE: link fields therefore
  *   read back as strings, not `RecordId` instances — the one shape difference

package/src/services/database/sqlite-plan-sql.test.ts

@@ -93,6 +93,25 @@ describe('serializeRow / reviveRow round-trip', () => {
     expect([...(back.blob as Uint8Array)]).toEqual([0, 128, 255]);
   });
 
+  // The surrealdb SDK decodes a `bytes` column as an ArrayBuffer, which
+  // JSON.stringify writes as `{}`: synced CRDT log rows (and presence states)
+  // landed with no data, so every other client's edit was refused as empty.
+  it('keeps the bytes of every binary shape: an SDK ArrayBuffer, a view into a larger buffer', () => {
+    const backing = new Uint8Array([9, 9, 1, 2, 250, 9]);
+    const json = serializeRow({
+      id: 'thread__crdt_log:1',
+      data: backing.slice(2, 5).buffer,
+      window: backing.subarray(2, 5),
+      dv: new DataView(backing.buffer, 2, 3),
+      nested: { state: [new Int8Array([1, 2, -6]).buffer] },
+    });
+    const back = reviveRow(json) as any;
+    for (const bytes of [back.data, back.window, back.dv, back.nested.state[0]]) {
+      expect(bytes).toBeInstanceOf(Uint8Array);
+      expect([...bytes]).toEqual([1, 2, 250]);
+    }
+  });
+
   it('serializes RecordId-shaped links to strings and takes the fast parse path otherwise', () => {
     const json = serializeRow({ id: 't:1', author: { tb: 'user', id: 'u1' }, n: 2 });
     expect(reviveRow(json)).toEqual({ id: 't:1', author: 'user:u1', n: 2 });

package/src/services/database/sqlite-plan-sql.ts

@@ -61,11 +61,12 @@ export function scalar(value: unknown): unknown {
 
 export function serializeRow(row: Row): string {
   return JSON.stringify(row, function (this: Record<string, unknown>, k, v) {
-    if (v instanceof Uint8Array) return { __u8: toBase64(v) };
     // `v` has already been through `toJSON()`, and a RecordId's is escaped
     // SurrealQL (`game:⟨476g…⟩`), so key the original value instead.
     const raw = this[k];
     if (raw && typeof raw === 'object') {
+      const bytes = bytesOf(raw);
+      if (bytes) return { __u8: toBase64(bytes) };
       const key = recordIdKey(raw);
       if (key !== null) return key;
     }
@@ -73,6 +74,19 @@ export function serializeRow(row: Row): string {
   });
 }
 
+/**
+ * The bytes of a binary value, whatever shape it arrived in. Rows from the
+ * server carry a `bytes` column as an `ArrayBuffer` (the surrealdb SDK's CBOR
+ * decode), not a `Uint8Array`, and `JSON.stringify` turns an `ArrayBuffer`
+ * into `{}`: every synced CRDT log row and presence state was stored empty.
+ */
+function bytesOf(value: object): Uint8Array | null {
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  return null;
+}
+
 /**
  * Serialize a MERGE row ONCE for both halves of the merge upsert: the row a
  * fresh INSERT stores and the RFC 7396 delta `json_patch` applies on conflict.

package/src/services/tabs/broker.test.ts

@@ -324,4 +324,58 @@ describe('tabs broker: namespaces', () => {
     // and a is offered leadership of the new bucket.
     expect(a.ofType('become-leader').length).toBeGreaterThan(1);
   });
+
+  it('keeps the port of a leader whose released tab lock means it left the bucket, not that it died', async () => {
+    // The broker's crash detector queues a request on the leader's tab lock;
+    // here it is granted the moment the tab releases it, as on sign-in.
+    const grants: Array<() => void> = [];
+    vi.stubGlobal('navigator', {
+      locks: {
+        request: (_name: string, opts: { ifAvailable?: boolean; steal?: boolean }, cb: (lock: unknown) => unknown) =>
+          new Promise((resolve) => {
+            if (opts.ifAvailable || opts.steal) resolve(cb({}));
+            else grants.push(() => resolve(cb({})));
+          }),
+      },
+    });
+    try {
+      const a = connectTab('tab-a');
+      await ackLeadership(a);
+      expect(grants).toHaveLength(1);
+      grants[0]();
+      await flush();
+      a.send({
+        type: 'hello',
+        tabId: 'tab-a',
+        fingerprint: 'fp-test',
+        bucketId: 'user1',
+        visibility: 'visible',
+        heldLeadership: null,
+      });
+      await flush();
+      expect(a.ofType('become-leader').map((m) => m.leadershipId)).toEqual([1, 2]);
+    } finally {
+      vi.unstubAllGlobals();
+    }
+  });
+
+  it('elects the only tab in its new bucket when it signs in alone', async () => {
+    const a = connectTab('tab-a');
+    await ackLeadership(a);
+    a.send({
+      type: 'hello',
+      tabId: 'tab-a',
+      fingerprint: 'fp-test',
+      bucketId: 'user1',
+      visibility: 'visible',
+      heldLeadership: null,
+    });
+    await flush();
+    expect(a.ofType('become-leader').map((m) => m.leadershipId)).toEqual([1, 2]);
+    await ackLeadership(a, 'user1');
+    // Still pinged in the new bucket, so the client's watchdog stays quiet.
+    const pings = a.ofType('ping').length;
+    await vi.advanceTimersByTimeAsync(10_000);
+    expect(a.ofType('ping').length).toBeGreaterThan(pings);
+  });
 });

package/src/services/tabs/tabs-broker-worker.ts

@@ -183,7 +183,12 @@ function clearLeader(
   if (tab && opts.demote) {
     post(tab.port, { type: 'demote', brokerInstanceId, leadershipId: leader.leadershipId });
   }
-  if (opts.removeTab && tab) removeTab(ns, leader.tabId, { notifyLeader: false });
+  // Its port stays open: the only caller is the tab-lock monitor, and a lock
+  // released is not always a dead tab. A leader that signs in or out drops
+  // its lock before re-helloing into the new bucket, and closing the port
+  // here swallowed that hello, leaving the tab roleless until its watchdog
+  // reconnected. A dead tab's port is gone anyway.
+  if (opts.removeTab && tab) removeTab(ns, leader.tabId, { notifyLeader: false, closePort: false });
   // Followers must drop their ports; new ones are minted after re-election.
   for (const t of ns.tabs.values()) {
     if (t.tabId !== leader.tabId) {
@@ -250,8 +255,9 @@ function failPromotion(
 /**
  * Fast crash detection: queue a Web Lock request on the leader's tab lock.
  * Locks release the instant their holder's tab dies, so being GRANTED means
- * the leader is gone; release immediately (return from the callback) and
- * re-elect. The leadershipId guard drops stale grants after a normal handoff.
+ * the leader is gone from this bucket (dead, or moved to another bucket on
+ * sign-in/out); release immediately (return from the callback) and re-elect.
+ * The leadershipId guard drops stale grants after a normal handoff.
  */
 function startTabLockMonitor(ns: Namespace, leadershipId: number): void {
   const locks = (navigator as { locks?: LockManager }).locks;
@@ -489,7 +495,6 @@ function handleTabMessage(port: MessagePort, msg: TabToBrokerMessage, ports: rea
       post(port, { type: 'unsupported', brokerInstanceId, reason: 'fingerprint-mismatch' });
       return;
     }
-    const ns = getNamespace(msg.fingerprint, msg.bucketId);
     // Drop stale state for this tab EVERYWHERE first. A re-hello is either a
     // reconnect (same namespace) or a bucket switch (leave old namespace,
     // join the new one); in both cases exactly one entry may remain, and if
@@ -498,6 +503,13 @@ function handleTabMessage(port: MessagePort, msg: TabToBrokerMessage, ports: rea
     for (const other of [...namespaces.values()]) {
       if (other.tabs.has(msg.tabId)) evictTab(other, msg.tabId, 'rehello', { closePort: false });
     }
+    // Only now look the namespace up: evicting the broker's last tab resets it
+    // as idle (all namespaces and the fingerprint dropped), and a namespace
+    // fetched before that would be orphaned, never pinged or found again. A
+    // lone tab signing in lost its leader that way until its watchdog
+    // reconnected.
+    canonicalFingerprint ??= msg.fingerprint;
+    const ns = getNamespace(msg.fingerprint, msg.bucketId);
     const tab: BrokerTab = {
       port,
       tabId: msg.tabId,