@spooky-sync/core 0.0.1-canary.159 → 0.0.1-canary.160

package/dist/index.js

@@ -3466,6 +3466,7 @@ var DataModule = class {
 		const target = await withRetry(this.logger, () => this.local.execute(query, {
 			id: rid,
 			mid: mutationId,
+			data: params,
 			...prefixedParams
 		}));
 		const parsedRecord = parseParams(tableSchema.columns, target);
@@ -5799,8 +5800,8 @@ async function walkOpfs(maxEntries = 2e3, maxDepth = 8) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.159";
-const WASM_VERSION = "0.0.1-canary.159";
+const CORE_VERSION = "0.0.1-canary.160";
+const WASM_VERSION = "0.0.1-canary.160";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	eventsHistory = [];
@@ -9044,7 +9045,7 @@ var Sp00kyClient = class {
 		return new TabsCoordinator({
 			tabId,
 			fingerprint: computeTabsFingerprint({
-				coreVersion: "0.0.1-canary.159",
+				coreVersion: "0.0.1-canary.160",
 				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.159",
+  "version": "0.0.1-canary.160",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -60,8 +60,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.159",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.159",
+    "@spooky-sync/query-builder": "0.0.1-canary.160",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.160",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",

package/src/modules/data/index.ts

@@ -27,7 +27,8 @@ import type {
   QueryTimings,
   PhaseStat,
   RegistrationTimings,
-  RunOptions} from '../../types';
+  RunOptions,
+} from '../../types';
 import { MATERIALIZATION_SAMPLE_WINDOW } from '../../types';
 import {
   parseRecordIdString,
@@ -228,7 +229,15 @@ export class DataModule<S extends SchemaStructure> {
     );
 
     // Create the query and track the pending promise
-    const promise = this.createAndRegisterQuery<T>(hash, recordId, surqlString, params, ttl, tableName, plan);
+    const promise = this.createAndRegisterQuery<T>(
+      hash,
+      recordId,
+      surqlString,
+      params,
+      ttl,
+      tableName,
+      plan
+    );
     this.pendingQueries.set(hash, promise);
     try {
       await promise;
@@ -641,7 +650,7 @@ export class DataModule<S extends SchemaStructure> {
       const idx = Math.min(sorted.length - 1, Math.floor(q * sorted.length));
       return sorted[idx]!;
     };
-    return { p55: pick(0.55), p90: pick(0.90), p99: pick(0.99) };
+    return { p55: pick(0.55), p90: pick(0.9), p99: pick(0.99) };
   }
 
   /** Record a per-phase timing sample (ms) on a query's rolling window. */
@@ -836,10 +845,7 @@ export class DataModule<S extends SchemaStructure> {
    * Shared by `applyHydration` (live registration) and `persistSnapshot`
    * (preload).
    */
-  private async buildAndSaveCacheBatch(
-    tableName: string,
-    rows: RecordWithId[]
-  ): Promise<void> {
+  private async buildAndSaveCacheBatch(tableName: string, rows: RecordWithId[]): Promise<void> {
     const tableSchema = this.schema.tables.find((t) => t.name === tableName);
     const batch: CacheRecord[] = rows.map((record) => ({
       table: tableName,
@@ -882,9 +888,7 @@ export class DataModule<S extends SchemaStructure> {
    * data also clears the marker — a stale marker can't claim "warm" when the
    * rows are gone. Any read error is treated as cold.
    */
-  async getPreloadMarker(
-    hash: string
-  ): Promise<{ fetchedAt: number; rowCount: number } | null> {
+  async getPreloadMarker(hash: string): Promise<{ fetchedAt: number; rowCount: number } | null> {
     try {
       // Pass a real RecordId: a bare string id hits the SurrealDB engine's
       // `FROM ONLY $__id` as a plain string, which "selects" the string itself
@@ -1274,6 +1278,12 @@ export class DataModule<S extends SchemaStructure> {
       this.local.execute(query, {
         id: rid,
         mid: mutationId,
+        // The record itself is written with per-key `data_<field>` vars
+        // (`createSet`), but the OUTBOX row needs the whole payload in one
+        // `data` field so the mutation can be replayed later. Without this the
+        // row is written with `data` unbound: the create becomes unsendable and
+        // blocks the queue behind it.
+        data: params,
         ...prefixedParams,
       })
     );
@@ -1485,9 +1495,7 @@ export class DataModule<S extends SchemaStructure> {
     const id = encodeRecordId(recordId);
 
     try {
-      await withRetry(this.logger, () =>
-        this.local.query('DELETE $id', { id: recordId })
-      );
+      await withRetry(this.logger, () => this.local.query('DELETE $id', { id: recordId }));
       await this.cache.delete(tableName, id, true);
       this.removeRecordFromQueries(recordId);
 
@@ -1765,9 +1773,7 @@ export class DataModule<S extends SchemaStructure> {
         ? (configRecord as any).updateCount
         : 0;
     const persistedErrorCount =
-      typeof (configRecord as any)?.errorCount === 'number'
-        ? (configRecord as any).errorCount
-        : 0;
+      typeof (configRecord as any)?.errorCount === 'number' ? (configRecord as any).errorCount : 0;
 
     return {
       config,

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

@@ -131,7 +131,10 @@ describe('SqliteCacheEngine storage health', () => {
   });
 
   it('publishes the fallback, its reason, and an error log when OPFS is lost', async () => {
-    const { engine, logs } = makeEngine({ persisted: false, opfsError: 'NoModificationAllowedError: locked' });
+    const { engine, logs } = makeEngine({
+      persisted: false,
+      opfsError: 'NoModificationAllowedError: locked',
+    });
     await engine.connect('user:abc');
 
     expect(engine.storageHealth).toEqual({
@@ -178,11 +181,7 @@ describe('SqliteCacheEngine.getStorageDiagnostics', () => {
     logger.child = () => logger;
     const engine = new SqliteCacheEngine({ namespace: 'n', database: 'd' } as any, logger);
     stubTransport(engine, (type, payload) =>
-      type === 'open'
-        ? { persisted: true }
-        : type === 'exec'
-          ? { rows: execRows(payload.sql) }
-          : {}
+      type === 'open' ? { persisted: true } : type === 'exec' ? { rows: execRows(payload.sql) } : {}
     );
     return engine;
   }
@@ -235,11 +234,10 @@ describe('SqliteCacheEngine.getStorageDiagnostics', () => {
 describe('SqliteCacheEngine role modes', () => {
   function makeSharedEngine() {
     const log: string[] = [];
-    const engine = new SqliteCacheEngine(
-      { namespace: 'n', database: 'd' } as any,
-      makeLogger(),
-      { shared: true, useOpfs: true }
-    );
+    const engine = new SqliteCacheEngine({ namespace: 'n', database: 'd' } as any, makeLogger(), {
+      shared: true,
+      useOpfs: true,
+    });
     stubTransport(engine, lifecycleHandler(log));
     return { engine, log };
   }
@@ -287,11 +285,9 @@ describe('SqliteCacheEngine role modes', () => {
   });
 
   it('adoptAttached serves reads over the leader port and reports follower role', async () => {
-    const engine = new SqliteCacheEngine(
-      { namespace: 'n', database: 'd' } as any,
-      makeLogger(),
-      { shared: true }
-    );
+    const engine = new SqliteCacheEngine({ namespace: 'n', database: 'd' } as any, makeLogger(), {
+      shared: true,
+    });
     const port = fakeLeaderPort();
     await engine.adoptAttached(
       port,
@@ -428,4 +424,41 @@ describe('create() tx result shaping (fast path parity)', () => {
     expect(created.id).toBe('connection:CONN_abc');
     expect(created.provider).toBe('chesscom');
   });
+
+  // The outbox row is the ONLY copy of a pending create once the in-memory
+  // UpEvent is gone (reload, or a shared-tabs follower whose row the leader
+  // replays). It must carry the payload: `processUpEvent` does
+  // `Object.keys(event.data)`, so a row written with `data` unbound produces a
+  // create that can never be sent AND blocks every later mutation behind it.
+  //
+  // Note the vars: the RECORD is written from per-key `data_<field>` vars, so
+  // it is easy to emit `data = $data` and never bind `data` at the call site.
+  // That is exactly the bug this asserts against.
+  it('the outbox row carries the whole payload, not just the record id', () => {
+    const payload = { provider: 'chesscom', username: 'hikaru' };
+    const vars = {
+      id: new RecordId('connection', 'CONN_abc'),
+      mid: new RecordId('_00_pending_mutations', '1'),
+      data: payload,
+      data_provider: 'chesscom',
+      data_username: 'hikaru',
+    };
+
+    const sealed = surql.seal(
+      surql.tx([
+        surql.createSet('id', [
+          { key: 'provider', variable: 'data_provider' },
+          { key: 'username', variable: 'data_username' },
+        ]),
+        surql.createMutation('create', 'mid', 'id', 'data'),
+      ]),
+      { resultIndex: 0 }
+    );
+
+    const { ops } = translateSurql(sealed.sql, vars);
+    const outboxRow = pureWriteOpResult(ops[1]) as Record<string, unknown>;
+
+    expect(outboxRow.mutationType).toBe('create');
+    expect(outboxRow.data).toEqual(payload);
+  });
 });