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

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,8 +3484,8 @@ 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.86";
+const WASM_VERSION = "0.0.1-canary.86";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class {
 	eventsHistory = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.85",
+  "version": "0.0.1-canary.86",
   "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.86",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.86",
     "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",
     "loro-crdt": "^1.5.6",

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(