@spooky-sync/core 0.0.1-canary.101 → 0.0.1-canary.103

package/dist/index.d.ts

@@ -638,6 +638,7 @@ declare class Sp00kySync<S extends SchemaStructure> {
   private syncHealthStatus;
   private lastSyncErrorKind;
   private lastSyncErrorMessage;
+  private hasSyncedOnce;
   private selfHealTimer;
   private selfHealAttempts;
   private static readonly SELF_HEAL_BASE_MS;

package/dist/index.js

@@ -2678,6 +2678,7 @@ var Sp00kySync = class Sp00kySync {
 	syncHealthStatus = "healthy";
 	lastSyncErrorKind;
 	lastSyncErrorMessage;
+	hasSyncedOnce = false;
 	selfHealTimer = null;
 	selfHealAttempts = 0;
 	static SELF_HEAL_BASE_MS = 2e3;
@@ -2688,7 +2689,8 @@ var Sp00kySync = class Sp00kySync {
 			status: this.syncHealthStatus,
 			consecutiveFailures: this.consecutiveSyncFailures,
 			kind: this.syncHealthStatus === "degraded" ? this.lastSyncErrorKind : void 0,
-			error: this.syncHealthStatus === "degraded" ? this.lastSyncErrorMessage : void 0
+			error: this.syncHealthStatus === "degraded" ? this.lastSyncErrorMessage : void 0,
+			everConnected: this.hasSyncedOnce
 		};
 	}
 	/**
@@ -2714,6 +2716,7 @@ var Sp00kySync = class Sp00kySync {
 	recordSyncOutcome(ok, error) {
 		if (this.degradeAfterFailures <= 0) return;
 		if (ok) {
+			this.hasSyncedOnce = true;
 			if (this.consecutiveSyncFailures === 0) return;
 			this.consecutiveSyncFailures = 0;
 			if (this.syncHealthStatus !== "healthy") {
@@ -3512,8 +3515,8 @@ function parseBackendInfo(raw) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.101";
-const WASM_VERSION = "0.0.1-canary.101";
+const CORE_VERSION = "0.0.1-canary.103";
+const WASM_VERSION = "0.0.1-canary.103";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class {
 	eventsHistory = [];
@@ -3521,6 +3524,9 @@ var DevToolsService = class {
 	version = CORE_VERSION;
 	backendInfo = emptyBackendInfo();
 	enabled = false;
+	localTables = [];
+	localTablesFetching = false;
+	localTablesAt = 0;
 	constructor(databaseService, remoteDatabaseService, logger, schema, authService, dataManager) {
 		this.databaseService = databaseService;
 		this.remoteDatabaseService = remoteDatabaseService;
@@ -3574,6 +3580,7 @@ var DevToolsService = class {
 				createdAt: q.config.lastActiveAt instanceof Date ? q.config.lastActiveAt.getTime() : new Date(q.config.lastActiveAt || Date.now()).getTime(),
 				lastUpdate: Date.now(),
 				updateCount: q.updateCount,
+				ttl: q.config.ttl,
 				query: q.config.surql,
 				variables: q.config.params || {},
 				dataSize: q.records?.length || 0,
@@ -3652,7 +3659,38 @@ var DevToolsService = class {
 		});
 		if (this.eventsHistory.length > 100) this.eventsHistory.shift();
 	}
+	/** Unwrap a SurrealDB `INFO FOR DB` result to its `{ tables, ... }` object. */
+	unwrapInfo(res) {
+		if (!Array.isArray(res) || !res[0]) return null;
+		const first = res[0];
+		if (first && typeof first === "object" && "result" in first) return first.result;
+		if (Array.isArray(first)) return first[0];
+		return first;
+	}
+	/**
+	* Refresh the cached full local-table list from `INFO FOR DB`. Fire-and-forget
+	* and throttled — called from getState() so the panel gets every table
+	* (including internal `_00_*`) without running its own (flaky) queries.
+	*/
+	refreshLocalTables() {
+		if (this.localTablesFetching) return;
+		if (Date.now() - this.localTablesAt < 3e3) return;
+		this.localTablesFetching = true;
+		this.databaseService.query("INFO FOR DB").then((res) => {
+			const info = this.unwrapInfo(res);
+			this.localTablesAt = Date.now();
+			if (info && info.tables) {
+				const names = Object.keys(info.tables);
+				const changed = names.length !== this.localTables.length || names.some((n, i) => n !== this.localTables[i]);
+				this.localTables = names;
+				if (changed) this.notifyDevTools();
+			}
+		}).catch(() => {}).finally(() => {
+			this.localTablesFetching = false;
+		});
+	}
 	getState() {
+		this.refreshLocalTables();
 		return this.serializeForDevTools({
 			eventsHistory: [...this.eventsHistory],
 			activeQueries: Object.fromEntries(this.getActiveQueries()),
@@ -3671,7 +3709,7 @@ var DevToolsService = class {
 				entities: this.backendInfo.entities
 			},
 			database: {
-				tables: this.schema.tables.map((t) => t.name),
+				tables: this.localTables.length ? this.localTables : this.schema.tables.map((t) => t.name),
 				tableData: {}
 			}
 		});

package/dist/types.d.ts

@@ -340,6 +340,13 @@ interface SyncHealth {
   kind?: 'network' | 'application';
   /** Message of the most recent failure (only set while `degraded`). */
   error?: string;
+  /**
+   * `true` once at least one sync round has succeeded this session. Lets a UI
+   * distinguish a first-time "connecting" phase (never reached the server yet,
+   * so a cold-start failure run is expected) from a real lost connection after
+   * a working session. Never resets back to `false` once set.
+   */
+  everConnected: boolean;
 }
 type QueryHash = string;
 type RecordVersionArray = Array<[string, number]>;

package/package.json

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

package/src/modules/devtools/index.ts

@@ -49,6 +49,13 @@ export class DevToolsService implements StreamUpdateReceiver {
   // (the on-demand GET_STATE pull) still works before the push channel turns on.
   private enabled = false;
 
+  // Full local table list (incl. internal `_00_*`), enumerated from the local DB
+  // via our own reliable `service.query` — the DevTools panel's page-eval query
+  // bridge is unreliable under load, so the panel relies on this instead.
+  private localTables: string[] = [];
+  private localTablesFetching = false;
+  private localTablesAt = 0;
+
   constructor(
     private databaseService: LocalDatabaseService,
     private remoteDatabaseService: RemoteDatabaseService,
@@ -130,6 +137,7 @@ export class DevToolsService implements StreamUpdateReceiver {
             : new Date(q.config.lastActiveAt || Date.now()).getTime(),
         lastUpdate: Date.now(),
         updateCount: q.updateCount,
+        ttl: q.config.ttl,
         query: q.config.surql,
         variables: q.config.params || {},
         dataSize: q.records?.length || 0,
@@ -230,7 +238,50 @@ export class DevToolsService implements StreamUpdateReceiver {
     if (this.eventsHistory.length > 100) this.eventsHistory.shift();
   }
 
+  /** Unwrap a SurrealDB `INFO FOR DB` result to its `{ tables, ... }` object. */
+  private unwrapInfo(res: any): any {
+    if (!Array.isArray(res) || !res[0]) return null;
+    const first = res[0];
+    if (first && typeof first === 'object' && 'result' in first) return first.result;
+    if (Array.isArray(first)) return first[0];
+    return first;
+  }
+
+  /**
+   * Refresh the cached full local-table list from `INFO FOR DB`. Fire-and-forget
+   * and throttled — called from getState() so the panel gets every table
+   * (including internal `_00_*`) without running its own (flaky) queries.
+   */
+  private refreshLocalTables(): void {
+    if (this.localTablesFetching) return;
+    const now = Date.now();
+    if (now - this.localTablesAt < 3000) return;
+    this.localTablesFetching = true;
+    void this.databaseService
+      .query<any>('INFO FOR DB')
+      .then((res) => {
+        const info = this.unwrapInfo(res);
+        this.localTablesAt = Date.now();
+        if (info && info.tables) {
+          const names = Object.keys(info.tables);
+          const changed =
+            names.length !== this.localTables.length ||
+            names.some((n, i) => n !== this.localTables[i]);
+          this.localTables = names;
+          if (changed) this.notifyDevTools();
+        }
+      })
+      .catch(() => {
+        // Ignore — fall back to the declared app schema below.
+      })
+      .finally(() => {
+        this.localTablesFetching = false;
+      });
+  }
+
   private getState() {
+    // Keep the full local-table list fresh (throttled, non-blocking).
+    this.refreshLocalTables();
     return this.serializeForDevTools({
       eventsHistory: [...this.eventsHistory],
       activeQueries: Object.fromEntries(this.getActiveQueries()),
@@ -249,7 +300,11 @@ export class DevToolsService implements StreamUpdateReceiver {
         entities: this.backendInfo.entities,
       },
       database: {
-        tables: this.schema.tables.map((t) => t.name),
+        // Prefer the live local-table list (includes internal `_00_*`); fall
+        // back to the declared app schema until the first enumeration lands.
+        tables: this.localTables.length
+          ? this.localTables
+          : this.schema.tables.map((t) => t.name),
         tableData: {},
       },
     });

package/src/modules/sync/sync.health.test.ts

@@ -113,4 +113,37 @@ describe('sync health via idle poll', () => {
     await poll();
     expect(sync.syncHealth.status).toBe('healthy');
   });
+
+  it('leaves everConnected false through a cold-start failure run', async () => {
+    const { sync, refetch, poll } = makeSync(['h1']);
+    expect(sync.syncHealth.everConnected).toBe(false);
+
+    // Server never reached: 3 failed cycles degrade, but this is the initial
+    // "connecting" phase, not a lost connection — everConnected stays false.
+    refetch.mockRejectedValue(new Error(CONNECTION_UNAVAILABLE));
+    await poll();
+    await poll();
+    await poll();
+    expect(sync.syncHealth.status).toBe('degraded');
+    expect(sync.syncHealth.everConnected).toBe(false);
+  });
+
+  it('latches everConnected on the first success and keeps it through a later degrade', async () => {
+    const { sync, refetch, poll } = makeSync(['h1']);
+
+    // First successful round reaches the server: connecting phase is over.
+    refetch.mockResolvedValue(true);
+    await poll();
+    expect(sync.syncHealth.status).toBe('healthy');
+    expect(sync.syncHealth.everConnected).toBe(true);
+
+    // Connection later drops: degraded now reflects a REAL lost connection.
+    refetch.mockReset();
+    refetch.mockRejectedValue(new Error(CONNECTION_UNAVAILABLE));
+    await poll();
+    await poll();
+    await poll();
+    expect(sync.syncHealth.status).toBe('degraded');
+    expect(sync.syncHealth.everConnected).toBe(true);
+  });
 });

package/src/modules/sync/sync.ts

@@ -168,6 +168,10 @@ export class Sp00kySync<S extends SchemaStructure> {
   private syncHealthStatus: SyncHealthStatus = 'healthy';
   private lastSyncErrorKind: 'network' | 'application' | undefined;
   private lastSyncErrorMessage: string | undefined;
+  // Latched `true` on the first successful sync round; never reset. Lets a UI
+  // tell a cold-start "connecting" phase (never reached the server) apart from
+  // a real lost connection after a working session.
+  private hasSyncedOnce = false;
 
   // 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
@@ -186,6 +190,7 @@ export class Sp00kySync<S extends SchemaStructure> {
       consecutiveFailures: this.consecutiveSyncFailures,
       kind: this.syncHealthStatus === 'degraded' ? this.lastSyncErrorKind : undefined,
       error: this.syncHealthStatus === 'degraded' ? this.lastSyncErrorMessage : undefined,
+      everConnected: this.hasSyncedOnce,
     };
   }
 
@@ -216,6 +221,9 @@ export class Sp00kySync<S extends SchemaStructure> {
   private recordSyncOutcome(ok: boolean, error?: unknown): void {
     if (this.degradeAfterFailures <= 0) return;
     if (ok) {
+      // Latch first-ever success so a UI can drop the connecting phase. Set
+      // before the early return so a clean cold start (0 prior failures) counts.
+      this.hasSyncedOnce = true;
       if (this.consecutiveSyncFailures === 0) return;
       this.consecutiveSyncFailures = 0;
       if (this.syncHealthStatus !== 'healthy') {

package/src/types.ts

@@ -193,6 +193,13 @@ export interface SyncHealth {
   kind?: 'network' | 'application';
   /** Message of the most recent failure (only set while `degraded`). */
   error?: string;
+  /**
+   * `true` once at least one sync round has succeeded this session. Lets a UI
+   * distinguish a first-time "connecting" phase (never reached the server yet,
+   * so a cold-start failure run is expected) from a real lost connection after
+   * a working session. Never resets back to `false` once set.
+   */
+  everConnected: boolean;
 }
 
 export type QueryHash = string;