@spooky-sync/core 0.0.1-canary.85 → 0.0.1-canary.87

package/dist/index.d.ts

@@ -638,6 +638,10 @@ declare class Sp00kySync<S extends SchemaStructure> {
   private syncHealthStatus;
   private lastSyncErrorKind;
   private lastSyncErrorMessage;
+  private selfHealTimer;
+  private selfHealAttempts;
+  private static readonly SELF_HEAL_BASE_MS;
+  private static readonly SELF_HEAL_MAX_MS;
   /** Current sync-health snapshot. */
   get syncHealth(): SyncHealth;
   /**
@@ -655,6 +659,13 @@ declare class Sp00kySync<S extends SchemaStructure> {
    * is 0).
    */
   private recordSyncOutcome;
+  /**
+   * Begin self-heal retries (no-op if already running). Started on the
+   * healthy→degraded transition; {@link recordSyncOutcome} stops it on recovery.
+   */
+  private startSelfHeal;
+  private scheduleSelfHeal;
+  private stopSelfHeal;
   constructor(local: LocalDatabaseService, remote: RemoteDatabaseService, cache: CacheModule, dataModule: DataModule<S>, schema: S, logger: Logger$1, options?: Sp00kySyncOptions);
   /**
    * Initializes the synchronization system.

package/dist/index.js

@@ -2626,7 +2626,7 @@ function listRefTableFor(mode, userId) {
 * Uses a queue-based architecture with 'up' (local to remote) and 'down' (remote to local) queues.
 * @template S The schema structure type.
 */
-var Sp00kySync = class {
+var Sp00kySync = class Sp00kySync {
 	upQueue;
 	downQueue;
 	isInit = false;
@@ -2675,6 +2675,10 @@ var Sp00kySync = class {
 	syncHealthStatus = "healthy";
 	lastSyncErrorKind;
 	lastSyncErrorMessage;
+	selfHealTimer = null;
+	selfHealAttempts = 0;
+	static SELF_HEAL_BASE_MS = 2e3;
+	static SELF_HEAL_MAX_MS = 3e4;
 	/** Current sync-health snapshot. */
 	get syncHealth() {
 		return {
@@ -2713,6 +2717,7 @@ var Sp00kySync = class {
 				this.syncHealthStatus = "healthy";
 				this.lastSyncErrorKind = void 0;
 				this.lastSyncErrorMessage = void 0;
+				this.stopSelfHeal();
 				this.logger.info({ Category: "sp00ky-client::Sp00kySync::syncHealth" }, "Sync recovered; health back to healthy");
 				this.emitSyncHealth();
 			}
@@ -2730,8 +2735,58 @@ var Sp00kySync = class {
 				Category: "sp00ky-client::Sp00kySync::syncHealth"
 			}, "Sync degraded after sustained failures");
 			this.emitSyncHealth();
+			this.startSelfHeal();
 		}
 	}
+	/**
+	* Begin self-heal retries (no-op if already running). Started on the
+	* healthy→degraded transition; {@link recordSyncOutcome} stops it on recovery.
+	*/
+	startSelfHeal() {
+		if (this.selfHealTimer !== null) return;
+		this.selfHealAttempts = 0;
+		this.scheduleSelfHeal();
+	}
+	scheduleSelfHeal() {
+		const delay = Math.min(Sp00kySync.SELF_HEAL_MAX_MS, Sp00kySync.SELF_HEAL_BASE_MS * 2 ** this.selfHealAttempts);
+		this.selfHealTimer = setTimeout(async () => {
+			this.selfHealTimer = null;
+			if (this.syncHealthStatus !== "degraded") return;
+			this.selfHealAttempts++;
+			this.logger.debug({
+				attempt: this.selfHealAttempts,
+				delayMs: delay,
+				Category: "sp00ky-client::Sp00kySync::selfHeal"
+			}, "Self-heal: re-driving sync while degraded");
+			try {
+				if (this.upQueue.size > 0) await this.scheduler.syncUp();
+				else if (this.downQueue.size > 0) await this.scheduler.syncDown();
+				else {
+					const hashes = this.dataModule.getActiveQueryHashes();
+					if (hashes.length > 0) {
+						for (const hash of hashes) this.scheduler.enqueueDownEvent({
+							type: "register",
+							payload: { hash }
+						});
+						await this.scheduler.syncDown();
+					} else {
+						await this.remote.query("RETURN true");
+						this.recordSyncOutcome(true);
+					}
+				}
+			} catch (err) {
+				this.recordSyncOutcome(false, err);
+			}
+			if (this.syncHealthStatus === "degraded") this.scheduleSelfHeal();
+		}, delay);
+	}
+	stopSelfHeal() {
+		if (this.selfHealTimer !== null) {
+			clearTimeout(this.selfHealTimer);
+			this.selfHealTimer = null;
+		}
+		this.selfHealAttempts = 0;
+	}
 	constructor(local, remote, cache, dataModule, schema, logger, options) {
 		this.local = local;
 		this.remote = remote;
@@ -3429,14 +3484,15 @@ function parseBackendInfo(raw) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.85";
-const WASM_VERSION = "0.0.1-canary.85";
+const CORE_VERSION = "0.0.1-canary.87";
+const WASM_VERSION = "0.0.1-canary.87";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class {
 	eventsHistory = [];
 	eventIdCounter = 0;
 	version = CORE_VERSION;
 	backendInfo = emptyBackendInfo();
+	enabled = false;
 	constructor(databaseService, remoteDatabaseService, logger, schema, authService, dataManager) {
 		this.databaseService = databaseService;
 		this.remoteDatabaseService = remoteDatabaseService;
@@ -3445,6 +3501,14 @@ var DevToolsService = class {
 		this.authService = authService;
 		this.dataManager = dataManager;
 		this.exposeToWindow();
+		if (typeof window !== "undefined") window.addEventListener("message", (e) => {
+			if (e.source !== window) return;
+			const type = e.data?.type;
+			if (type === "SP00KY_DEVTOOLS_CONNECT") {
+				this.enabled = true;
+				this.notifyDevTools();
+			} else if (type === "SP00KY_DEVTOOLS_DISCONNECT") this.enabled = false;
+		});
 		this.authService.eventSystem.subscribe(AuthEventTypes.AuthStateChanged, () => {
 			this.notifyDevTools();
 		});
@@ -3551,6 +3615,7 @@ var DevToolsService = class {
 		this.notifyDevTools();
 	}
 	addEvent(eventType, payload) {
+		if (!this.enabled) return;
 		this.eventsHistory.push({
 			id: this.eventIdCounter++,
 			timestamp: Date.now(),
@@ -3584,6 +3649,7 @@ var DevToolsService = class {
 		});
 	}
 	notifyDevTools() {
+		if (!this.enabled) return;
 		if (typeof window !== "undefined") window.postMessage({
 			type: "SP00KY_STATE_CHANGED",
 			source: "sp00ky-devtools-page",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.85",
+  "version": "0.0.1-canary.87",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -59,8 +59,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.85",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.85",
+    "@spooky-sync/query-builder": "0.0.1-canary.87",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.87",
     "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",
     "loro-crdt": "^1.5.6",

package/src/modules/devtools/index.ts

@@ -42,6 +42,12 @@ export class DevToolsService implements StreamUpdateReceiver {
   // Backend stack info (versions + per-entity status), read via the
   // `fn::spooky::info()` SurrealQL function; empty/'unavailable' until resolved.
   private backendInfo: BackendInfo = emptyBackendInfo();
+  // Dormant until a devtools consumer (extension panel or MCP) handshakes via
+  // `SP00KY_DEVTOOLS_CONNECT`. While false, `notifyDevTools()`/`addEvent()` do no
+  // work, so prod pays zero serialization/postMessage cost for an unwatched panel.
+  // `window.__00__.getState()` stays live regardless, so the panel's first paint
+  // (the on-demand GET_STATE pull) still works before the push channel turns on.
+  private enabled = false;
 
   constructor(
     private databaseService: LocalDatabaseService,
@@ -53,6 +59,22 @@ export class DevToolsService implements StreamUpdateReceiver {
   ) {
     this.exposeToWindow();
 
+    // Stay dormant until a devtools consumer announces itself. The extension's
+    // page-script posts this once it detects `window.__00__`; the panel can also
+    // disconnect to return us to dormant. Until then we skip all serialization.
+    if (typeof window !== 'undefined') {
+      window.addEventListener('message', (e) => {
+        if (e.source !== window) return;
+        const type = (e.data as { type?: string } | undefined)?.type;
+        if (type === 'SP00KY_DEVTOOLS_CONNECT') {
+          this.enabled = true;
+          this.notifyDevTools();
+        } else if (type === 'SP00KY_DEVTOOLS_DISCONNECT') {
+          this.enabled = false;
+        }
+      });
+    }
+
     // Subscribe to auth events
     this.authService.eventSystem.subscribe(AuthEventTypes.AuthStateChanged, () => {
       this.notifyDevTools();
@@ -197,6 +219,8 @@ export class DevToolsService implements StreamUpdateReceiver {
   }
 
   private addEvent(eventType: string, payload: any) {
+    // No consumer attached → skip recording (and the recursive serialize it does).
+    if (!this.enabled) return;
     this.eventsHistory.push({
       id: this.eventIdCounter++,
       timestamp: Date.now(),
@@ -232,6 +256,8 @@ export class DevToolsService implements StreamUpdateReceiver {
   }
 
   private notifyDevTools() {
+    // No consumer attached → no getState() serialization, no postMessage broadcast.
+    if (!this.enabled) return;
     if (typeof window !== 'undefined') {
       window.postMessage(
         {

package/src/modules/sync/sync.ts

@@ -169,6 +169,16 @@ export class Sp00kySync<S extends SchemaStructure> {
   private lastSyncErrorKind: 'network' | 'application' | undefined;
   private lastSyncErrorMessage: string | undefined;
 
+  // Self-heal: while degraded, re-drive sync on an exponential backoff so the
+  // app recovers on its own — even when the socket never actually dropped (in
+  // that case no `connected` event fires, so this re-registration is the ONLY
+  // thing that re-probes the server). Started on the degrade transition,
+  // cleared on recovery. Capped cadence so a long outage doesn't busy-loop.
+  private selfHealTimer: ReturnType<typeof setTimeout> | null = null;
+  private selfHealAttempts = 0;
+  private static readonly SELF_HEAL_BASE_MS = 2_000;
+  private static readonly SELF_HEAL_MAX_MS = 30_000;
+
   /** Current sync-health snapshot. */
   get syncHealth(): SyncHealth {
     return {
@@ -212,6 +222,7 @@ export class Sp00kySync<S extends SchemaStructure> {
         this.syncHealthStatus = 'healthy';
         this.lastSyncErrorKind = undefined;
         this.lastSyncErrorMessage = undefined;
+        this.stopSelfHeal();
         this.logger.info(
           { Category: 'sp00ky-client::Sp00kySync::syncHealth' },
           'Sync recovered; health back to healthy'
@@ -238,7 +249,74 @@ export class Sp00kySync<S extends SchemaStructure> {
         'Sync degraded after sustained failures'
       );
       this.emitSyncHealth();
+      this.startSelfHeal();
+    }
+  }
+
+  /**
+   * Begin self-heal retries (no-op if already running). Started on the
+   * healthy→degraded transition; {@link recordSyncOutcome} stops it on recovery.
+   */
+  private startSelfHeal(): void {
+    if (this.selfHealTimer !== null) return;
+    this.selfHealAttempts = 0;
+    this.scheduleSelfHeal();
+  }
+
+  private scheduleSelfHeal(): void {
+    const delay = Math.min(
+      Sp00kySync.SELF_HEAL_MAX_MS,
+      Sp00kySync.SELF_HEAL_BASE_MS * 2 ** this.selfHealAttempts
+    );
+    this.selfHealTimer = setTimeout(async () => {
+      this.selfHealTimer = null;
+      if (this.syncHealthStatus !== 'degraded') return;
+      this.selfHealAttempts++;
+      this.logger.debug(
+        { attempt: this.selfHealAttempts, delayMs: delay, Category: 'sp00ky-client::Sp00kySync::selfHeal' },
+        'Self-heal: re-driving sync while degraded'
+      );
+      try {
+        // Retry whatever is still queued first; the failing op (register or
+        // mutation) was re-queued by the queue, so this re-probes the server
+        // and reports the outcome through the scheduler → recordSyncOutcome.
+        if (this.upQueue.size > 0) {
+          await this.scheduler.syncUp();
+        } else if (this.downQueue.size > 0) {
+          await this.scheduler.syncDown();
+        } else {
+          // Nothing queued (e.g. the failing op was rolled back + dropped):
+          // re-register active queries — mirroring the reconnect handler — so
+          // there's a concrete op whose success flips health. If there are no
+          // active queries either, probe connectivity directly.
+          const hashes = this.dataModule.getActiveQueryHashes();
+          if (hashes.length > 0) {
+            for (const hash of hashes) {
+              this.scheduler.enqueueDownEvent({ type: 'register', payload: { hash } });
+            }
+            await this.scheduler.syncDown();
+          } else {
+            await this.remote.query('RETURN true');
+            this.recordSyncOutcome(true);
+          }
+        }
+      } catch (err) {
+        // Only the direct connectivity probe can throw here (syncUp/syncDown
+        // swallow + self-report); treat a probe failure as another failed round.
+        this.recordSyncOutcome(false, err);
+      }
+      // Keep retrying until recovery. recordSyncOutcome(true) calls stopSelfHeal
+      // (clearing any pending timer), so only continue while still degraded.
+      if (this.syncHealthStatus === 'degraded') this.scheduleSelfHeal();
+    }, delay);
+  }
+
+  private stopSelfHeal(): void {
+    if (this.selfHealTimer !== null) {
+      clearTimeout(this.selfHealTimer);
+      this.selfHealTimer = null;
     }
+    this.selfHealAttempts = 0;
   }
 
   constructor(