@spooky-sync/core 0.0.1-canary.233 → 0.0.1-canary.235

package/dist/index.d.ts

@@ -39,6 +39,13 @@ declare abstract class AbstractDatabaseService {
    * each link: on expiry this promise rejects and the chain moves on, even
    * though the underlying RPC is still parked in the SDK's pending map.
    */
+  /**
+   * Hook run inside the query queue, right before a statement is sent. The
+   * remote service uses it to hold statements while a connect is in flight,
+   * so a query never runs on a socket that is open but has not had its
+   * namespace and token applied yet. The default does nothing.
+   */
+  protected beforeQuery(): Promise<void>;
   query<T extends unknown[]>(query: string, vars?: Record<string, unknown>): Promise<T>;
   execute<T>(query: SealedQuery<T>, vars?: Record<string, unknown>): Promise<T>;
   close(): Promise<void>;
@@ -117,6 +124,19 @@ declare class RemoteDatabaseService extends AbstractDatabaseService {
    * `disconnected`, which is what drives the supervisor's revive loop.
    */
   forceClose(): Promise<void>;
+  /**
+   * Hold statements while a connect is in flight.
+   *
+   * `connect()` opens the socket, then selects the namespace/database, then
+   * authenticates - three round trips. The SDK considers the connection ready
+   * after the first, so a query queued during the other two ran on a socket
+   * with no namespace ("Specify a namespace to use") or, worse, no identity.
+   * Seen 2026-09-06 after the supervisor rebuilt a socket: a collection
+   * recount failed with exactly that error. Waiting on the in-flight connect
+   * costs nothing when no connect is running; a failed connect is not
+   * swallowed here - the query then fails on its own, as before.
+   */
+  protected beforeQuery(): Promise<void>;
   /**
    * Open (or re-open) the remote connection.
    *

package/dist/index.js

@@ -320,9 +320,17 @@ var AbstractDatabaseService = class {
 	* each link: on expiry this promise rejects and the chain moves on, even
 	* though the underlying RPC is still parked in the SDK's pending map.
 	*/
+	/**
+	* Hook run inside the query queue, right before a statement is sent. The
+	* remote service uses it to hold statements while a connect is in flight,
+	* so a query never runs on a socket that is open but has not had its
+	* namespace and token applied yet. The default does nothing.
+	*/
+	async beforeQuery() {}
 	async query(query, vars) {
 		return new Promise((resolve, reject) => {
 			this.queryQueue = this.queryQueue.then(async () => {
+				await this.beforeQuery();
 				const startTime = performance.now();
 				try {
 					this.logger.debug({
@@ -1121,6 +1129,25 @@ var RemoteDatabaseService = class extends AbstractDatabaseService {
 		}
 	}
 	/**
+	* Hold statements while a connect is in flight.
+	*
+	* `connect()` opens the socket, then selects the namespace/database, then
+	* authenticates - three round trips. The SDK considers the connection ready
+	* after the first, so a query queued during the other two ran on a socket
+	* with no namespace ("Specify a namespace to use") or, worse, no identity.
+	* Seen 2026-09-06 after the supervisor rebuilt a socket: a collection
+	* recount failed with exactly that error. Waiting on the in-flight connect
+	* costs nothing when no connect is running; a failed connect is not
+	* swallowed here - the query then fails on its own, as before.
+	*/
+	async beforeQuery() {
+		const inflight = this.connecting;
+		if (!inflight) return;
+		try {
+			await inflight;
+		} catch {}
+	}
+	/**
 	* Open (or re-open) the remote connection.
 	*
 	* Safe to call repeatedly: concurrent calls share the in-flight attempt, and
@@ -7764,8 +7791,8 @@ function selfAllowlistedVariant(flag, userId) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.233";
-const WASM_VERSION = "0.0.1-canary.233";
+const CORE_VERSION = "0.0.1-canary.235";
+const WASM_VERSION = "0.0.1-canary.235";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	eventsHistory = [];
@@ -12780,7 +12807,7 @@ var Sp00kyClient = class {
 		return new TabsCoordinator({
 			tabId,
 			fingerprint: computeTabsFingerprint({
-				coreVersion: "0.0.1-canary.233",
+				coreVersion: "0.0.1-canary.235",
 				schemaHash: hash53(this.config.schemaSurql),
 				endpoint: this.config.database.endpoint ?? "",
 				namespace: this.config.database.namespace,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.233",
+  "version": "0.0.1-canary.235",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -60,8 +60,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.233",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.233",
+    "@spooky-sync/query-builder": "0.0.1-canary.235",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.235",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "blurhash": "^2.0.5",

package/src/services/database/database.ts

@@ -60,11 +60,20 @@ export abstract class AbstractDatabaseService {
    * each link: on expiry this promise rejects and the chain moves on, even
    * though the underlying RPC is still parked in the SDK's pending map.
    */
+  /**
+   * Hook run inside the query queue, right before a statement is sent. The
+   * remote service uses it to hold statements while a connect is in flight,
+   * so a query never runs on a socket that is open but has not had its
+   * namespace and token applied yet. The default does nothing.
+   */
+  protected async beforeQuery(): Promise<void> {}
+
   async query<T extends unknown[]>(query: string, vars?: Record<string, unknown>): Promise<T> {
     return new Promise((resolve, reject) => {
       this.queryQueue = this.queryQueue
         // oxlint-disable-next-line promise/always-return
         .then(async () => {
+          await this.beforeQuery();
           const startTime = performance.now();
           try {
             this.logger.debug(

package/src/services/database/remote.ts

@@ -191,6 +191,28 @@ export class RemoteDatabaseService extends AbstractDatabaseService {
     }
   }
 
+  /**
+   * Hold statements while a connect is in flight.
+   *
+   * `connect()` opens the socket, then selects the namespace/database, then
+   * authenticates - three round trips. The SDK considers the connection ready
+   * after the first, so a query queued during the other two ran on a socket
+   * with no namespace ("Specify a namespace to use") or, worse, no identity.
+   * Seen 2026-09-06 after the supervisor rebuilt a socket: a collection
+   * recount failed with exactly that error. Waiting on the in-flight connect
+   * costs nothing when no connect is running; a failed connect is not
+   * swallowed here - the query then fails on its own, as before.
+   */
+  protected override async beforeQuery(): Promise<void> {
+    const inflight = this.connecting;
+    if (!inflight) return;
+    try {
+      await inflight;
+    } catch {
+      // The query that follows reports the failure itself.
+    }
+  }
+
   /**
    * Open (or re-open) the remote connection.
    *