@spooky-sync/core 0.0.1-canary.208 → 0.0.1-canary.209

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

@@ -128,13 +128,16 @@ export class WorkerSqliteTransport extends BaseTransport {
       this.handleMessage(ev.data);
     };
     // Surface a worker crash (wasm abort / OOM) instead of leaving every
-    // pending call hung forever — reject them all with a clear error.
+    // pending call hung forever — reject them all with a clear error, AND
+    // close: `failAll` alone left `connected` true, so every later call was
+    // posted to the dead worker and parked in `pending` for good. Closed, the
+    // engine sees `!connected` and spawns a fresh worker on its next open.
     const crash = (msg: string) => {
       this.logger.error(
         { err: this.makeError(msg), Category: 'sp00ky-client::SqliteCacheEngine::worker' },
         'Worker error'
       );
-      this.failAll(msg);
+      this.close(msg);
     };
     this.worker.onerror = (e: ErrorEvent) => crash(e.message || 'onerror');
     this.worker.onmessageerror = () => crash('messageerror');

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

@@ -47,6 +47,7 @@
  * hot path; the per-statement ops remain for the write/shim paths.
  */
 import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
+import { verifyLockStillHeld as verifyLockStillHeldBounded } from './sqlite-lock-verify';
 import {
   openDb,
   type OpenDbOptions,
@@ -201,17 +202,16 @@ function noteTick(): void {
 }
 setInterval(noteTick, 1000);
 
-async function verifyLockStillHeld(): Promise<void> {
-  const locks = workerLocks();
-  const name = currentLock?.name;
-  if (!locks || !name || typeof locks.query !== 'function') return;
-  try {
-    const state = await locks.query();
-    const stillHeld = (state.held ?? []).some((l) => l.name === name);
-    if (!stillHeld) await fence('lock missing after suspected freeze');
-  } catch {
-    /* query unavailable: fall back to the steal callback */
-  }
+// Bounded (see sqlite-lock-verify.ts): every op on the chain awaits this, and
+// a `locks.query()` that never answered stopped every reply to every client.
+function verifyLockStillHeld(): Promise<void> {
+  return verifyLockStillHeldBounded(
+    workerLocks() as any,
+    currentLock?.name,
+    (reason) => fence(reason),
+    undefined,
+    (msg) => console.warn(`[sqlite-worker] ${msg}`)
+  );
 }
 
 // ==================== db ops ====================

package/src/services/stream-processor/index.ts

@@ -29,6 +29,14 @@ export interface StreamUpdate {
   queryHash: string;
   localArray: RecordVersionArray;
   op?: 'CREATE' | 'UPDATE' | 'DELETE'; // Operation type for conditional debouncing
+  /**
+   * Client-internal: not from the circuit. A membership-only change that
+   * needed no fetch is re-materialized through this same path so it cannot
+   * race a real update (DataModule.scheduleRematerialize). Carries the last
+   * known `localArray`; consumers that describe an INGEST (persist, metrics,
+   * devtools events) skip it.
+   */
+  synthetic?: boolean;
   /**
    * End-to-end ingest latency for the WASM call that produced this update,
    * in milliseconds. Populated by StreamProcessorService.ingest. Undefined

package/src/types.ts

@@ -140,6 +140,16 @@ export interface Sp00kyConfig<S extends SchemaStructure> {
      * failure the queue retries. `0` disables. Defaults to `60_000`.
      */
     queryTimeoutMs?: number;
+    /**
+     * Deadline (ms) for every LOCAL store operation (a SQLite worker round trip,
+     * or a query on the in-process surrealdb engine). Local ops are serialized
+     * too, and one that never answered - a worker starved behind a long select,
+     * a lock verification with no clock - left every `db.create`/`db.update`
+     * promise pending for the tab's lifetime. On expiry the call rejects with
+     * `LocalOpTimeoutError` (the op itself keeps running in the engine and is
+     * not retried). `0` disables. Defaults to `30_000`.
+     */
+    localOpTimeoutMs?: number;
   };
   /** The schema definition. */
   schema: S;

package/src/utils/index.ts

@@ -176,6 +176,9 @@ export async function withRetry<T>(
       return await operation();
     } catch (err: any) {
       lastError = err;
+      // A deadline expiry is explicitly not retryable: the op is still running
+      // in the engine, and a retry only queues a second copy behind it.
+      if (err?.retryable === false) throw err;
       if (
         err?.message?.includes('Can not open transaction') ||
         err?.message?.includes('transaction') ||
@@ -220,11 +223,14 @@ export async function withRetry<T>(
 export function withTimeout<T>(
   promise: Promise<T>,
   timeoutMs: number,
-  message: string
+  message: string | (() => Error)
 ): Promise<T> {
   if (!(timeoutMs > 0)) return promise;
   return new Promise<T>((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    const timer = setTimeout(
+      () => reject(typeof message === 'function' ? message() : new Error(message)),
+      timeoutMs
+    );
     promise.then(
       (value) => {
         clearTimeout(timer);