@spooky-sync/core 0.0.1-canary.135 → 0.0.1-canary.137

package/dist/index.js

@@ -1440,6 +1440,20 @@ function setPath(obj, path, value) {
 * full merged row is only materialized for a LET-wrapped upsert (see the 'let'
 * case). delete/deleteAll yield `[]`; noop yields `null`.
 */
+/**
+* The `_00_*` internal tables the client relies on. The LocalMigrator DEFINEs
+* them, but every DEFINE lowers to a noop on the SQLite engine, so they must be
+* created physically at open (see `openInternal`) or a read-before-first-write
+* on a fresh bucket throws "no such table". Keep in sync with the systemSchema
+* block in `local-migrator.ts`.
+*/
+const SYSTEM_TABLES = [
+	"_00_stream_processor_state",
+	"_00_query",
+	"_00_preload",
+	"_00_schema",
+	"_00_pending_mutations"
+];
 function pureWriteOpResult(op) {
 	switch (op.kind) {
 		case "upsert": return {
@@ -1594,9 +1608,11 @@ var SqliteCacheEngine = class {
 		this.worker = this.spawnWorker();
 		const { persisted } = await this.rawCall("open", {
 			dbName: bucketId,
-			useOpfs: this.useOpfs
+			useOpfs: this.useOpfs,
+			systemTables: SYSTEM_TABLES
 		});
 		this.knownTables.clear();
+		for (const t of SYSTEM_TABLES) this.knownTables.add(t);
 		this.bucketId = bucketId;
 		this.logger.info({
 			bucketId,
@@ -5073,8 +5089,8 @@ function parseBackendInfo(raw) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.135";
-const WASM_VERSION = "0.0.1-canary.135";
+const CORE_VERSION = "0.0.1-canary.137";
+const WASM_VERSION = "0.0.1-canary.137";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class {
 	eventsHistory = [];

package/dist/sqlite-worker.js

@@ -96,7 +96,7 @@ async function executeSelect(plan, params, db) {
 * hot path; the per-statement ops remain for the write/shim paths.
 */
 let db = null;
-async function open(dbName, useOpfs) {
+async function open(dbName, useOpfs, systemTables = []) {
 	const sqlite3 = await sqlite3InitModule();
 	let persisted = false;
 	if (useOpfs && sqlite3.installOpfsSAHPoolVfs) try {
@@ -104,6 +104,7 @@ async function open(dbName, useOpfs) {
 		persisted = true;
 	} catch {}
 	if (!db) db = new sqlite3.oo1.DB(":memory:", "c");
+	for (const t of systemTables) db.exec({ sql: `CREATE TABLE IF NOT EXISTS "${t}" (id TEXT PRIMARY KEY, data TEXT NOT NULL)` });
 	try {
 		db.exec({ sql: "PRAGMA busy_timeout = 5000; PRAGMA cache_size = -32000;" });
 	} catch {}
@@ -157,7 +158,8 @@ self.onmessage = async (ev) => {
 		switch (type) {
 			case "open":
 				selectDb.knownTables.clear();
-				result = await open(payload.dbName, payload.useOpfs);
+				result = await open(payload.dbName, payload.useOpfs, payload.systemTables);
+				for (const t of payload.systemTables ?? []) selectDb.knownTables.add(t);
 				break;
 			case "select":
 				result = await executeSelect(payload.plan, payload.params ?? {}, selectDb);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.135",
+  "version": "0.0.1-canary.137",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -59,8 +59,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.135",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.135",
+    "@spooky-sync/query-builder": "0.0.1-canary.137",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.137",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",

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

@@ -96,6 +96,45 @@ describe('SqliteCacheEngine.switchBucket serialization', () => {
   });
 });
 
+// Regression: DEFINE is a noop on this engine, so the `_00_*` internal tables
+// the migrator DEFINEs are never physically created — a fresh bucket that READS
+// one before any write (the sync layer selects `_00_query` at startup) threw
+// "no such table: _00_query" and wedged the client on "Loading database". The
+// fix seeds them inside `open`; assert the open message carries them.
+describe('SqliteCacheEngine system-table seeding', () => {
+  it('passes the _00_* system tables to the worker open (fresh-bucket safe)', async () => {
+    const msgs: any[] = [];
+    const engine = new SqliteCacheEngine({ namespace: 'n', database: 'd' } as any, makeLogger());
+    (engine as any).spawnWorker = () => {
+      const w: any = { onmessage: null, onerror: null, onmessageerror: null, terminate() {} };
+      w.postMessage = (msg: any) => {
+        msgs.push(msg);
+        Promise.resolve().then(() => {
+          const rest = msg.type === 'open' ? { persisted: true } : {};
+          w.onmessage?.({ data: { id: msg.id, ok: true, ...rest } });
+        });
+      };
+      // Wire pending resolution like the real spawnWorker.
+      const inner = w.onmessage;
+      w.onmessage = (ev: any) => {
+        const { id, ok, error, ...rest } = ev.data ?? {};
+        const p = (engine as any).pending.get(id);
+        if (!p) return;
+        (engine as any).pending.delete(id);
+        if (ok) p.resolve(rest);
+        else p.reject(new Error(error));
+        void inner;
+      };
+      return w as unknown as Worker;
+    };
+
+    await engine.connect('user:fresh');
+    const open = msgs.find((m) => m.type === 'open');
+    expect(open?.payload?.systemTables).toContain('_00_query');
+    expect(open?.payload?.systemTables).toContain('_00_pending_mutations');
+  });
+});
+
 // `pureWriteOpResult` is the single source of truth for what a pure-write op
 // contributes to a query's per-statement results. The batched fast path in
 // `query()` and the per-op `execOp` path BOTH route through it, so a caller that

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

@@ -34,6 +34,21 @@ import type { EngineTx, Id, LocalStore, OrderBy, RelationFetch, Row } from './ca
  * full merged row is only materialized for a LET-wrapped upsert (see the 'let'
  * case). delete/deleteAll yield `[]`; noop yields `null`.
  */
+/**
+ * The `_00_*` internal tables the client relies on. The LocalMigrator DEFINEs
+ * them, but every DEFINE lowers to a noop on the SQLite engine, so they must be
+ * created physically at open (see `openInternal`) or a read-before-first-write
+ * on a fresh bucket throws "no such table". Keep in sync with the systemSchema
+ * block in `local-migrator.ts`.
+ */
+const SYSTEM_TABLES = [
+  '_00_stream_processor_state',
+  '_00_query',
+  '_00_preload',
+  '_00_schema',
+  '_00_pending_mutations',
+] as const;
+
 export function pureWriteOpResult(op: SqlOp): unknown {
   switch (op.kind) {
     case 'upsert':
@@ -217,11 +232,22 @@ export class SqliteCacheEngine implements LocalStore {
    */
   private async openInternal(bucketId: string): Promise<void> {
     this.worker = this.spawnWorker();
+    // Seed the `_00_*` system tables as part of `open` (worker-side, one round
+    // trip). The LocalMigrator DEFINEs them, but `translateSurql` lowers every
+    // DEFINE to a noop on this engine (SQLite has no DDL vocabulary), so
+    // provisioning never actually creates them — they were only made lazily on
+    // first WRITE. A fresh bucket (e.g. right after signup) that READS one first
+    // (the sync layer selects `_00_query` before any row lands) hit
+    // "no such table: _00_query" and the client wedged on "Loading database".
+    // Creating them inside `open` guarantees any access order is safe without
+    // adding ops to the engine's queue.
     const { persisted } = await this.rawCall<{ persisted: boolean }>('open', {
       dbName: bucketId,
       useOpfs: this.useOpfs,
+      systemTables: SYSTEM_TABLES,
     });
     this.knownTables.clear();
+    for (const t of SYSTEM_TABLES) this.knownTables.add(t);
     this.bucketId = bucketId;
     this.logger.info(
       { bucketId, persisted, Category: 'sp00ky-client::SqliteCacheEngine::connect' },

package/src/services/database/sqlite-worker.ts

@@ -34,7 +34,11 @@ let db: {
   close: () => void;
 } | null = null;
 
-async function open(dbName: string, useOpfs: boolean): Promise<{ persisted: boolean }> {
+async function open(
+  dbName: string,
+  useOpfs: boolean,
+  systemTables: readonly string[] = []
+): Promise<{ persisted: boolean }> {
   const sqlite3: any = await sqlite3InitModule();
   let persisted = false;
   if (useOpfs && sqlite3.installOpfsSAHPoolVfs) {
@@ -47,6 +51,12 @@ async function open(dbName: string, useOpfs: boolean): Promise<{ persisted: bool
     }
   }
   if (!db) db = new sqlite3.oo1.DB(':memory:', 'c');
+  // Physically create the internal `_00_*` tables the client reads before any
+  // write (DEFINE is a noop on this engine, so the migrator can't). Prevents
+  // "no such table: _00_query" on a fresh bucket right after signup.
+  for (const t of systemTables) {
+    db!.exec({ sql: `CREATE TABLE IF NOT EXISTS "${t}" (id TEXT PRIMARY KEY, data TEXT NOT NULL)` });
+  }
   // Retry (rather than instantly failing with SQLITE_BUSY=5) if a lock is held.
   // Combined with the engine's single-flight op queue, overlap is avoided.
   // `cache_size` is negated → KiB (here 32 MiB) so SQLite's page cache can't
@@ -106,7 +116,10 @@ self.onmessage = async (ev: MessageEvent) => {
     switch (type) {
       case 'open':
         selectDb.knownTables.clear();
-        result = await open(payload.dbName, payload.useOpfs);
+        result = await open(payload.dbName, payload.useOpfs, payload.systemTables);
+        // The freshly seeded system tables exist — record them so the select
+        // path doesn't redundantly re-issue CREATE TABLE for each.
+        for (const t of (payload.systemTables ?? []) as string[]) selectDb.knownTables.add(t);
         break;
       case 'select':
         result = await executeSelect(payload.plan, payload.params ?? {}, selectDb);