castle-web-sdk 0.4.20 → 0.4.22

package/dist/commands.d.ts

@@ -62,6 +62,7 @@ export interface CommandParams {
     "deckStorage.load": Record<string, never>;
     "deckStorage.update": {
         updates: StorageUpdate[];
+        unload?: boolean;
     };
     "sharedDeckStorage.load": {
         scope: SharedScope;
@@ -71,6 +72,7 @@ export interface CommandParams {
     "sharedDeckStorage.update": {
         scope: SharedScope;
         updates: StorageUpdate[];
+        unload?: boolean;
     };
     "leaderboard.fetch": {
         variable: string;

package/dist/storage.js

@@ -1,6 +1,10 @@
 import { CastleError } from "./errors";
 import { hostRequest } from "./transport";
-const FLUSH_INTERVAL_MS = 2000;
+// The child coalesces writes -- a frame can set the same key many times -- and
+// hands them to the host on this interval. The host, not the deck, talks to the
+// server and owns retry: it lives in the page, so it is still alive to finish a
+// write while the deck's frame is being torn down.
+const FLUSH_INTERVAL_MS = 200;
 // Per-player private storage. The host stamps deckId/sessionId, so one deck
 // session = one stable blob: load once, then serve reads from cache and batch
 // writes on a 2s flush. Dirty writes overlay the server blob so an in-flight
@@ -38,16 +42,17 @@ class PrivateStorageImpl {
         this.cache = decodeStorageBlob(blob, "Storage.get");
         this.overlayDirty();
     }
-    async flush() {
+    async flush(unload = false) {
         if (this.dirty.size === 0)
             return;
         const snapshot = new Map(this.dirty);
-        const { blob } = await hostRequest("deckStorage.update", {
+        await hostRequest("deckStorage.update", {
             updates: updatesFromDirty(snapshot),
+            unload,
         });
-        this.cache = decodeStorageBlob(blob, "Storage.flush");
+        // Staged, not stored: the host has taken ownership, so these stop being the
+        // deck's problem. `cache` already carries them from the write.
         clearAcknowledgedDirty(this.dirty, snapshot);
-        this.overlayDirty();
     }
     overlayDirty() {
         for (const [key, encoded] of this.dirty) {
@@ -67,7 +72,7 @@ class PrivateStorageImpl {
         }, FLUSH_INTERVAL_MS);
     }
     flushNow() {
-        void this.flush();
+        void this.flush(true);
     }
 }
 // Cross-player storage. Writes always target the current player (the host
@@ -155,18 +160,19 @@ class SharedStorageImpl {
                 read.resolve(value);
         }
     }
-    async flush() {
+    async flush(unload = false) {
         if (this.dirtyBuckets.size === 0)
             return;
-        const tasks = Array.from(this.dirtyBuckets, ([bucketKey, dirty]) => this.flushBucket(bucketKey, new Map(dirty)));
+        const tasks = Array.from(this.dirtyBuckets, ([bucketKey, dirty]) => this.flushBucket(bucketKey, new Map(dirty), unload));
         await Promise.all(tasks);
     }
-    async flushBucket(bucketKey, snapshot) {
+    async flushBucket(bucketKey, snapshot, unload = false) {
         if (snapshot.size === 0)
             return;
         await hostRequest("sharedDeckStorage.update", {
             scope: scopeFromWriteKey(bucketKey),
             updates: updatesFromDirty(snapshot),
+            unload,
         });
         const dirty = this.dirtyBuckets.get(bucketKey);
         if (!dirty)
@@ -185,7 +191,7 @@ class SharedStorageImpl {
         }, FLUSH_INTERVAL_MS);
     }
     flushNow() {
-        void this.flush().catch(reportSharedStorageError);
+        void this.flush(true).catch(reportSharedStorageError);
     }
 }
 // Writes batch on a timer, so leaving the page inside that window would lose

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "castle-web-sdk",
-  "version": "0.4.20",
+  "version": "0.4.22",
   "type": "module",
   "main": "dist/castle.js",
   "types": "dist/castle.d.ts",