@spooky-sync/core 0.0.1-canary.219 → 0.0.1-canary.220

package/dist/index.d.ts

@@ -1692,6 +1692,30 @@ declare class Sp00kySync<S extends SchemaStructure> {
    * @param mutations Array of UpEvents (create/update/delete) to enqueue.
    */
   enqueueMutation(mutations: UpEvent[]): Promise<void>;
+  /**
+   * Best-effort release of THIS tab's views as the page goes away.
+   *
+   * Without it a closed tab's views stay materialized on the SSP for a full
+   * TTL (10 minutes by default), because nothing else tears them down:
+   * `releaseQueriesEagerly` is off, so the TTL sweep is the only reclaim path.
+   * On a busy tenant that is a generation of live views per reload, each still
+   * being stepped by every ingest, for ten minutes after the last human left.
+   *
+   * This is NOT `releaseQueriesEagerly` re-enabled. That released views
+   * mid-session on a viewport change and tore the window out from under a live
+   * page (see `cleanupQuery`); this runs only when the page itself is going
+   * away and nothing is left to render.
+   *
+   * Safe against other tabs by construction: `fn::query::unsubscribe` drops
+   * only this session from `subscribers` and deletes the row solely when it
+   * was the last one, so a second tab of the same user keeps its view.
+   *
+   * One statement, not one per id: an unload handler gets a few milliseconds,
+   * and N round trips would not survive it. Fire-and-forget — if the frame
+   * does not make it out, the TTL sweep still reclaims exactly as before, so
+   * the worst case is today's behaviour.
+   */
+  releaseViewsOnUnload(): void;
   private registerQuery;
   private createRemoteQuery;
   /**
@@ -2565,6 +2589,8 @@ declare class Sp00kyClient<S extends SchemaStructure> {
    * outbox, and every query re-registered remotely to refill from the server.
    */
   private doSwitchBucket;
+  /** Removes the `pagehide` listener installed in `init`; see `close`. */
+  private detachUnloadRelease;
   close(): Promise<void>;
   /**
    * Subscribe to a feature flag for the current user. Returns a

package/dist/index.js

@@ -7215,6 +7215,41 @@ var Sp00kySync = class Sp00kySync {
 		}
 		this.scheduler.enqueueMutation(mutations);
 	}
+	/**
+	* Best-effort release of THIS tab's views as the page goes away.
+	*
+	* Without it a closed tab's views stay materialized on the SSP for a full
+	* TTL (10 minutes by default), because nothing else tears them down:
+	* `releaseQueriesEagerly` is off, so the TTL sweep is the only reclaim path.
+	* On a busy tenant that is a generation of live views per reload, each still
+	* being stepped by every ingest, for ten minutes after the last human left.
+	*
+	* This is NOT `releaseQueriesEagerly` re-enabled. That released views
+	* mid-session on a viewport change and tore the window out from under a live
+	* page (see `cleanupQuery`); this runs only when the page itself is going
+	* away and nothing is left to render.
+	*
+	* Safe against other tabs by construction: `fn::query::unsubscribe` drops
+	* only this session from `subscribers` and deletes the row solely when it
+	* was the last one, so a second tab of the same user keeps its view.
+	*
+	* One statement, not one per id: an unload handler gets a few milliseconds,
+	* and N round trips would not survive it. Fire-and-forget — if the frame
+	* does not make it out, the TTL sweep still reclaims exactly as before, so
+	* the worst case is today's behaviour.
+	*/
+	releaseViewsOnUnload() {
+		let ids;
+		try {
+			ids = this.dataModule.getActiveQueryHashes().map((hash) => this.dataModule.getQueryByHash(hash)?.config.id).filter((id) => id != null);
+		} catch {
+			return;
+		}
+		if (ids.length === 0) return;
+		try {
+			this.remote.query("FOR $id IN $ids { LET $_released = fn::query::unsubscribe($id); };", { ids }).catch(() => {});
+		} catch {}
+	}
 	async registerQuery(queryHash) {
 		this.dataModule.beginFetching(queryHash);
 		try {
@@ -7664,8 +7699,8 @@ function selfAllowlistedVariant(flag, userId) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.219";
-const WASM_VERSION = "0.0.1-canary.219";
+const CORE_VERSION = "0.0.1-canary.220";
+const WASM_VERSION = "0.0.1-canary.220";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class DevToolsService {
 	eventsHistory = [];
@@ -12680,7 +12715,7 @@ var Sp00kyClient = class {
 		return new TabsCoordinator({
 			tabId,
 			fingerprint: computeTabsFingerprint({
-				coreVersion: "0.0.1-canary.219",
+				coreVersion: "0.0.1-canary.220",
 				schemaHash: hash53(this.config.schemaSurql),
 				endpoint: this.config.database.endpoint ?? "",
 				namespace: this.config.database.namespace,
@@ -12874,6 +12909,14 @@ var Sp00kyClient = class {
 			});
 			await this.sync.init();
 			this.logger.debug({ Category: "sp00ky-client::Sp00kyClient::init" }, "Sync initialized");
+			if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+				const onPageHide = (event) => {
+					if (event.persisted) return;
+					this.sync.releaseViewsOnUnload();
+				};
+				window.addEventListener("pagehide", onPageHide);
+				this.detachUnloadRelease = () => window.removeEventListener("pagehide", onPageHide);
+			}
 			this.featureFlags.init();
 			this.logger.debug({ Category: "sp00ky-client::Sp00kyClient::init" }, "FeatureFlagModule initialized");
 			this.appReleases.init();
@@ -13033,6 +13076,8 @@ var Sp00kyClient = class {
 			Category: "sp00ky-client::Sp00kyClient::doSwitchBucket"
 		}, "Local bucket switch complete");
 	}
+	/** Removes the `pagehide` listener installed in `init`; see `close`. */
+	detachUnloadRelease = null;
 	async close() {
 		this.connectionSupervisor.dispose();
 		await this.featureFlags.closeAll();
@@ -13042,6 +13087,8 @@ var Sp00kyClient = class {
 		await this.blobs.close().catch(() => {});
 		await this.streamProcessor.checkpoint("close").catch(() => {});
 		if (this.tabsCoordinator) await this.tabsCoordinator.stop();
+		this.detachUnloadRelease?.();
+		this.detachUnloadRelease = null;
 		await this.local.close();
 		await this.remote.close();
 		this.streamProcessor.dispose();

package/package.json

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

package/src/modules/sync/sync.ts

@@ -1843,6 +1843,50 @@ export class Sp00kySync<S extends SchemaStructure> {
     this.scheduler.enqueueMutation(mutations);
   }
 
+  /**
+   * Best-effort release of THIS tab's views as the page goes away.
+   *
+   * Without it a closed tab's views stay materialized on the SSP for a full
+   * TTL (10 minutes by default), because nothing else tears them down:
+   * `releaseQueriesEagerly` is off, so the TTL sweep is the only reclaim path.
+   * On a busy tenant that is a generation of live views per reload, each still
+   * being stepped by every ingest, for ten minutes after the last human left.
+   *
+   * This is NOT `releaseQueriesEagerly` re-enabled. That released views
+   * mid-session on a viewport change and tore the window out from under a live
+   * page (see `cleanupQuery`); this runs only when the page itself is going
+   * away and nothing is left to render.
+   *
+   * Safe against other tabs by construction: `fn::query::unsubscribe` drops
+   * only this session from `subscribers` and deletes the row solely when it
+   * was the last one, so a second tab of the same user keeps its view.
+   *
+   * One statement, not one per id: an unload handler gets a few milliseconds,
+   * and N round trips would not survive it. Fire-and-forget — if the frame
+   * does not make it out, the TTL sweep still reclaims exactly as before, so
+   * the worst case is today's behaviour.
+   */
+  releaseViewsOnUnload(): void {
+    let ids: unknown[];
+    try {
+      ids = this.dataModule
+        .getActiveQueryHashes()
+        .map((hash) => this.dataModule.getQueryByHash(hash)?.config.id)
+        .filter((id): id is NonNullable<typeof id> => id != null);
+    } catch {
+      return;
+    }
+    if (ids.length === 0) return;
+
+    try {
+      void this.remote
+        .query('FOR $id IN $ids { LET $_released = fn::query::unsubscribe($id); };', { ids })
+        .catch(() => {});
+    } catch {
+      // Socket already gone: the TTL sweep is the fallback, as before.
+    }
+  }
+
   private async registerQuery(queryHash: string) {
     // Hold `fetching` across the WHOLE registration (remote view creation +
     // initial sync + post-sync notify). A query is born `fetching` in

package/src/sp00ky.ts

@@ -981,6 +981,24 @@ export class Sp00kyClient<S extends SchemaStructure> {
       await this.sync.init();
       this.logger.debug({ Category: 'sp00ky-client::Sp00kyClient::init' }, 'Sync initialized');
 
+      // Hand this tab's views back when the page goes away. Without it they
+      // stay materialized on the SSP for a whole TTL after the tab is gone —
+      // see `Sp00kySync.releaseViewsOnUnload`.
+      //
+      // `pagehide` rather than `beforeunload`: it is the one teardown event
+      // that also fires on mobile, where tabs are discarded rather than
+      // closed. `persisted` means the page went into the bfcache and can come
+      // BACK, so releasing there would tear down views a live page still
+      // needs.
+      if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
+        const onPageHide = (event: PageTransitionEvent) => {
+          if (event.persisted) return;
+          this.sync.releaseViewsOnUnload();
+        };
+        window.addEventListener('pagehide', onPageHide);
+        this.detachUnloadRelease = () => window.removeEventListener('pagehide', onPageHide);
+      }
+
       this.featureFlags.init();
       this.logger.debug(
         { Category: 'sp00ky-client::Sp00kyClient::init' },
@@ -1229,6 +1247,9 @@ export class Sp00kyClient<S extends SchemaStructure> {
     );
   }
 
+  /** Removes the `pagehide` listener installed in `init`; see `close`. */
+  private detachUnloadRelease: (() => void) | null = null;
+
   async close() {
     // Before anything else: a live supervisor would read the intentional
     // `remote.close()` below as a failure and immediately reconnect.
@@ -1245,6 +1266,8 @@ export class Sp00kyClient<S extends SchemaStructure> {
     // Leaving the broker first hands leadership to another tab (and releases
     // the OPFS handles via the worker shutdown) before the store closes.
     if (this.tabsCoordinator) await this.tabsCoordinator.stop();
+    this.detachUnloadRelease?.();
+    this.detachUnloadRelease = null;
     await this.local.close();
     await this.remote.close();
     // Free the wasm circuit explicitly. V8 cannot see wasm-internal bytes, so