castle-web-sdk 0.4.25 → 0.4.26

package/dist/server/storage.js

@@ -0,0 +1,218 @@
+import { chunked } from "../chunk";
+import { decodeStorageValue, encodeStorageValue, storageError, } from "../storageJson";
+// Deck storage for an author's session server.
+//
+// The same store the deck's clients use, reached over the platform channel instead of
+// the host bridge. Two differences follow from what a session server IS, and both are
+// enforced by the platform, not here:
+//
+//   - It owns `deck` scope. Once a deck has a session server, clients read that data
+//     but no longer write it, which is what makes server-validated state possible.
+//   - It can never touch `private` scope, not even for its own players. Private
+//     storage belongs to the player, so this API does not offer it at all.
+//
+// Writes are not coalesced, unlike the client's. A server's writes are deliberate
+// rather than one-per-frame, and every call resolving when the platform has the write
+// is what makes saving during `onShutdown` simply work: the author awaits, and the
+// host holds the session open until the request lands.
+/** The platform takes at most this many keys per call. */
+const MAX_KEYS_PER_CALL = 32;
+/**
+ * A storage request crosses the platform channel as one frame, so it has a size limit
+ * the client path does not. Batches are split to stay under it. A single value too
+ * large to fit at all is refused here with a typed error, which is the difference
+ * between a save the author can handle and a frame that closes the session.
+ */
+const MAX_REQUEST_BYTES = 320 * 1024;
+// Room for the operation name, the scope and the subject, all of which are bounded
+// below so this allowance is a real ceiling rather than an assumption.
+const REQUEST_OVERHEAD_BYTES = 4 * 1024;
+/**
+ * The platform's own limits, mirrored so an over-long key or user id fails here with a
+ * typed error. Sent instead, they would push the request past the channel's frame
+ * limit -- and past that the socket closes and the session ends, which is a far worse
+ * answer than "that key is too long".
+ */
+const MAX_KEY_BYTES = 128;
+const MAX_SUBJECT_BYTES = 256;
+export function createServerStorage(platformHandle) {
+    const call = async (op, args) => {
+        if (typeof platformHandle.storage !== "function") {
+            // An older host-agent that predates storage. Say so rather than hanging on a
+            // reply that is never coming.
+            throw storageError("CAULDRON_STORAGE_UNAVAILABLE", "This Castle host does not support session-server storage.", `session.storage.${op}`);
+        }
+        if (platformHandle.storageEnabled === false) {
+            throw storageError("CAULDRON_STORAGE_UNAVAILABLE", "Storage is not available to this session.", `session.storage.${op}`);
+        }
+        const result = await platformHandle.storage(op, JSON.stringify(args));
+        return JSON.parse(result);
+    };
+    return {
+        deck: createScope(call, "DECK", null),
+        user(userId) {
+            // A bad id poisons the scope rather than throwing here, so the failure arrives
+            // the same way every other failure does -- as a rejection the author can await.
+            // A server addresses other people's data, and an absent subject would be
+            // resolved by the platform to the deck's creator, quietly writing the wrong
+            // player's bucket, so nothing is sent either.
+            if (typeof userId !== "string" || userId.length === 0) {
+                return createScope(rejectMissingSubject, "USER", null);
+            }
+            if (utf8Length(userId) > MAX_SUBJECT_BYTES) {
+                return createScope(rejectOversizeSubject, "USER", null);
+            }
+            return createScope(call, "USER", userId);
+        },
+        board(name) {
+            return createBoard(call, name);
+        },
+    };
+}
+function createScope(call, scope, subject) {
+    return {
+        async get(keys) {
+            // A bare array, not a wrapper: the platform hands back exactly what the
+            // storage verb returns, and `get` returns its entries directly.
+            const entries = await call("get", {
+                scope,
+                subject,
+                keys: assertKeys(keys, "session.storage.get"),
+            });
+            const result = {};
+            for (const entry of entries ?? []) {
+                // defineProperty, not assignment: a stored key named "__proto__" would
+                // otherwise reach the prototype setter rather than becoming an own property.
+                Object.defineProperty(result, entry.key, {
+                    value: decodeStorageValue(entry.value, "session.storage.get"),
+                    writable: true,
+                    enumerable: true,
+                    configurable: true,
+                });
+            }
+            return result;
+        },
+        async set(values) {
+            const entries = Object.entries(values).map(([key, value]) => ({
+                key,
+                value: encodeStorageValue(value, "session.storage.set"),
+            }));
+            for (const chunk of batched(entries)) {
+                await call("set", { scope, subject, entries: chunk });
+            }
+        },
+        async remove(keys) {
+            for (const chunk of chunked(assertKeys(keys, "session.storage.remove"), MAX_KEYS_PER_CALL)) {
+                await call("delete", { scope, subject, keys: chunk });
+            }
+        },
+        async increment(key, delta = 1) {
+            const value = await call("increment", { scope, subject, key, delta });
+            return Number(value);
+        },
+        async list(options = {}) {
+            const page = await call("list", {
+                scope,
+                subject,
+                prefix: options.prefix ?? null,
+                limit: options.limit ?? null,
+                cursor: options.cursor ?? null,
+            });
+            return {
+                entries: (page?.entries ?? []).map((entry) => ({
+                    key: entry.key,
+                    value: decodeStorageValue(entry.value, "session.storage.list"),
+                })),
+                cursor: page?.cursor ?? null,
+            };
+        },
+    };
+}
+function createBoard(call, board) {
+    return {
+        async submit(userId, score) {
+            return call("boardSubmit", {
+                board,
+                subject: assertUserId(userId, "session.storage.board.submit"),
+                score,
+            });
+        },
+        async top(limit) {
+            const entries = await call("boardTop", {
+                board,
+                limit: limit ?? null,
+            });
+            return entries ?? [];
+        },
+        async get(userId) {
+            const entry = await call("boardGet", {
+                board,
+                subject: assertUserId(userId, "session.storage.board.get"),
+            });
+            return entry ?? null;
+        },
+    };
+}
+function assertKeys(keys, operation) {
+    if (!Array.isArray(keys) || keys.some((key) => typeof key !== "string")) {
+        throw storageError("CASTLE_STORE_INVALID_KEYS", "Storage keys must be an array of strings.", operation);
+    }
+    for (const key of keys) {
+        if (utf8Length(key) > MAX_KEY_BYTES) {
+            throw storageError("CAULDRON_STORAGE_INVALID_KEY", `Storage keys must be at most ${MAX_KEY_BYTES} bytes.`, operation);
+        }
+    }
+    return keys;
+}
+const rejectMissingSubject = (op) => Promise.reject(missingSubjectError(`session.storage.${op}`));
+const rejectOversizeSubject = (op) => Promise.reject(storageError("CASTLE_STORE_INVALID_SUBJECT", `A user id must be at most ${MAX_SUBJECT_BYTES} bytes.`, `session.storage.${op}`));
+function missingSubjectError(operation) {
+    return storageError("CASTLE_STORE_INVALID_SUBJECT", "A user id is required here; a session server has no storage of its own.", operation);
+}
+function assertUserId(userId, operation) {
+    if (typeof userId !== "string" || userId.length === 0) {
+        throw missingSubjectError(operation);
+    }
+    if (utf8Length(userId) > MAX_SUBJECT_BYTES) {
+        throw storageError("CASTLE_STORE_INVALID_SUBJECT", `A user id must be at most ${MAX_SUBJECT_BYTES} bytes.`, operation);
+    }
+    return userId;
+}
+/**
+ * Splits entries into requests that fit both limits: the platform's key count and the
+ * channel's frame size.
+ */
+function batched(entries) {
+    const budget = MAX_REQUEST_BYTES - REQUEST_OVERHEAD_BYTES;
+    const batches = [];
+    let current = [];
+    let currentBytes = 0;
+    for (const entry of entries) {
+        const bytes = entryBytes(entry);
+        if (bytes > budget) {
+            throw storageError("CAULDRON_STORAGE_INVALID_VALUE", `A single stored value must be under ${budget} bytes when written from a session server.`, "session.storage.set");
+        }
+        if (current.length === MAX_KEYS_PER_CALL || currentBytes + bytes > budget) {
+            batches.push(current);
+            current = [];
+            currentBytes = 0;
+        }
+        current.push(entry);
+        currentBytes += bytes;
+    }
+    if (current.length > 0)
+        batches.push(current);
+    return batches;
+}
+function entryBytes(entry) {
+    // The ENCODED size, not the string length. `value` is already JSON, so putting it
+    // in the request escapes it a second time -- every quote and backslash doubles.
+    // Budgeting on the raw length would let an escape-heavy value slip a batch past the
+    // channel's limit, and past the limit the socket closes and the session with it.
+    return utf8Length(JSON.stringify(entry));
+}
+function utf8Length(value) {
+    if (typeof TextEncoder !== "undefined")
+        return new TextEncoder().encode(value).length;
+    return value.length;
+}

package/dist/server/wrapper.d.ts

@@ -1,5 +1,7 @@
 import type { MultiplayerSessionMode, PlatformHandle, PlayerIdentity } from "./platformHandle";
+import { type ServerStorage } from "./storage";
 export type { MultiplayerSessionMode, PlatformHandle, PlatformSessionConfig, PlayerIdentity, } from "./platformHandle";
+export type { ServerStorage, ServerStorageBoard, ServerStorageBoardScore, ServerStorageListEntry, ServerStorageListOptions, ServerStorageListPage, ServerStorageScope, } from "./storage";
 export interface MultiplayerServerPlayer extends PlayerIdentity {
     playerId: string;
 }
@@ -11,13 +13,18 @@ export interface MultiplayerServerSession {
     readonly sessionId: string;
     readonly deckId: string;
     readonly mode: MultiplayerSessionMode;
+    /**
+     * Deck storage that outlives the session. Nothing else here does: a session ends
+     * when its last player leaves and its memory goes with it.
+     */
+    readonly storage: ServerStorage;
     /** Sends bytes as a binary message and all other payloads as JSON. */
     send(playerId: string, data: unknown): void;
     /** Broadcasts bytes as a binary message and all other payloads as JSON. */
     broadcast(data: unknown, options?: MultiplayerBroadcastOptions): void;
     disconnect(playerId: string, reason?: string): void;
 }
-type CallbackResult = unknown | Promise<unknown>;
+type CallbackResult = unknown;
 export interface MultiplayerServerCallbacks {
     onStart?: (session: MultiplayerServerSession) => CallbackResult;
     onPlayerJoin?: (session: MultiplayerServerSession, player: MultiplayerServerPlayer) => CallbackResult;
@@ -26,6 +33,12 @@ export interface MultiplayerServerCallbacks {
     onMessage?: (session: MultiplayerServerSession, player: MultiplayerServerPlayer, data: unknown) => CallbackResult;
     onTick?: (session: MultiplayerServerSession) => CallbackResult;
     onReplaced?: (session: MultiplayerServerSession) => CallbackResult;
+    /**
+     * The session is ending. Awaited, so a save made here lands before the runtime is
+     * stopped. Not a guarantee: an out-of-memory kill or a host dying sends no shutdown
+     * at all, so save as things change and treat this as the last chance, not the plan.
+     */
+    onShutdown?: (session: MultiplayerServerSession) => CallbackResult;
 }
 export type CastleSessionBoot = (platformHandle: PlatformHandle) => Promise<void>;
 export declare function createCastleSessionBoot(callbacks: MultiplayerServerCallbacks): CastleSessionBoot;

package/dist/server/wrapper.js

@@ -1,4 +1,5 @@
 import { isBinaryPayload, toUint8Array, } from "../multiplayerProtocol";
+import { createServerStorage } from "./storage";
 // The publish bundler binds the author's default callbacks export once and
 // exports the returned one-argument function as `__castleBootSession`.
 export function createCastleSessionBoot(callbacks) {
@@ -44,10 +45,11 @@ async function bootSession(platformHandle, callbacks) {
     platformHandle.on("replaced", async () => {
         await callbacks.onReplaced?.(session);
     });
-    platformHandle.on("shutdown", () => {
+    platformHandle.on("shutdown", async () => {
         if (tickTimer !== null)
             clearInterval(tickTimer);
         tickTimer = null;
+        await callbacks.onShutdown?.(session);
     });
     await callbacks.onStart?.(session);
     const onTick = callbacks.onTick;
@@ -65,6 +67,7 @@ function createAuthorSession(platformHandle, players) {
         sessionId: platformHandle.config.sessionId,
         deckId: platformHandle.config.deckId,
         mode: platformHandle.config.mode,
+        storage: createServerStorage(platformHandle),
         send(playerId, data) {
             if (isBinaryPayload(data)) {
                 requireSendBinary(platformHandle);

package/dist/storage.d.ts

@@ -12,5 +12,20 @@ export interface SharedStorageApi {
     set(scope: SharedScope, key: string, value: Json): void;
     remove(scope: SharedScope, key: string): void;
 }
+/**
+ * Per-player private storage.
+ *
+ * @deprecated Use `Store.private` instead. This keeps one document per player
+ * and rewrites all of it on every change, so it is capped at 2 MB and loses
+ * concurrent writes. It stays supported for decks already using it.
+ */
 export declare const Storage: StorageApi;
+/**
+ * Storage other players can read.
+ *
+ * @deprecated Use `Store.deck`, `Store.me` and `Store.user(id)` instead. This
+ * has no ownership rule on `'deck'` scope -- any player can overwrite any key --
+ * and two players writing at once lose one of the writes. It stays supported
+ * for decks already using it.
+ */
 export declare const SharedStorage: SharedStorageApi;

package/dist/storage.js

@@ -1,5 +1,6 @@
-import { CastleError } from "./errors";
+import { decodeStorageValue, encodeStorageValue, storageError, } from "./storageJson";
 import { hostRequest } from "./transport";
+import { onUnloadFlush } from "./unloadFlush";
 // Writes coalesce by key as they are made, so setting the same key repeatedly
 // costs one entry; this is how often the result is handed to the host. 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
@@ -194,27 +195,32 @@ class SharedStorageImpl {
         void this.flush(true).catch(reportSharedStorageError);
     }
 }
-// Writes batch on a timer, so leaving the page inside that window would lose
-// them -- a deck saving progress as someone quits is exactly when it matters.
-// `pagehide` is the reliable signal on iOS, where unload often never fires, and
-// visibilitychange covers backgrounding without a navigation. Hooked on the
-// first write so a deck that never stores anything registers nothing.
-let unloadFlushHooked = false;
+// Hoisted, not built per call: handlers are deduplicated by identity, so a fresh
+// closure on every write would register one handler per write and fire them all
+// at unload.
+const flushStorageOnUnload = () => {
+    Storage.flushNow();
+    SharedStorage.flushNow();
+};
 function hookUnloadFlush() {
-    if (unloadFlushHooked || typeof window === "undefined")
-        return;
-    unloadFlushHooked = true;
-    const flush = () => {
-        Storage.flushNow();
-        SharedStorage.flushNow();
-    };
-    window.addEventListener("pagehide", flush);
-    document.addEventListener("visibilitychange", () => {
-        if (document.visibilityState === "hidden")
-            flush();
-    });
+    onUnloadFlush(flushStorageOnUnload);
 }
+/**
+ * Per-player private storage.
+ *
+ * @deprecated Use `Store.private` instead. This keeps one document per player
+ * and rewrites all of it on every change, so it is capped at 2 MB and loses
+ * concurrent writes. It stays supported for decks already using it.
+ */
 export const Storage = new PrivateStorageImpl();
+/**
+ * Storage other players can read.
+ *
+ * @deprecated Use `Store.deck`, `Store.me` and `Store.user(id)` instead. This
+ * has no ownership rule on `'deck'` scope -- any player can overwrite any key --
+ * and two players writing at once lose one of the writes. It stays supported
+ * for decks already using it.
+ */
 export const SharedStorage = new SharedStorageImpl();
 // 'user'-scope writes/self-reads share one bucket (the host resolves the
 // current player); a 'user' read of someone else keys by their id.
@@ -244,71 +250,6 @@ function decodeStorageBlob(blob, operation) {
         decodeStorageValue(value, operation),
     ]));
 }
-function decodeStorageValue(encoded, operation) {
-    try {
-        return JSON.parse(encoded);
-    }
-    catch {
-        throw storageError("CASTLE_STORAGE_PARSE_FAILED", "Stored Castle value is not valid JSON.", operation);
-    }
-}
-function encodeStorageValue(value, operation) {
-    try {
-        assertJsonValue(value, new Set(), operation);
-        return JSON.stringify(value);
-    }
-    catch (error) {
-        if (error instanceof CastleError)
-            throw error;
-        throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage values must be JSON.", operation);
-    }
-}
-function assertJsonValue(value, seen, operation) {
-    if (value === null || typeof value === "boolean" || typeof value === "string")
-        return;
-    if (typeof value === "number") {
-        if (Number.isFinite(value))
-            return;
-        throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage numbers must be finite.", operation);
-    }
-    if (Array.isArray(value)) {
-        assertJsonArray(value, seen, operation);
-        return;
-    }
-    if (typeof value === "object") {
-        assertJsonObject(value, seen, operation);
-        return;
-    }
-    throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage values must be JSON.", operation);
-}
-function assertJsonArray(values, seen, operation) {
-    assertNotCyclic(values, seen, operation);
-    seen.add(values);
-    for (const value of values)
-        assertJsonValue(value, seen, operation);
-    seen.delete(values);
-}
-function assertJsonObject(value, seen, operation) {
-    assertNotCyclic(value, seen, operation);
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
-        throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage objects must be plain JSON.", operation);
-    }
-    seen.add(value);
-    for (const child of Object.values(value))
-        assertJsonValue(child, seen, operation);
-    seen.delete(value);
-}
-function assertNotCyclic(value, seen, operation) {
-    if (seen.has(value)) {
-        throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage values cannot be cyclic.", operation);
-    }
-}
-function assertScope(scope, operation) {
-    if (scope !== "deck" && scope !== "user") {
-        throw storageError("CASTLE_STORAGE_INVALID_SCOPE", 'SharedStorage scope must be "deck" or "user".', operation);
-    }
-}
 function rejectReadBatch(batch, error) {
     for (const reads of batch.reads.values()) {
         for (const read of reads)
@@ -318,6 +259,8 @@ function rejectReadBatch(batch, error) {
 function reportSharedStorageError(error) {
     console.warn("Castle shared storage write failed", error);
 }
-function storageError(code, message, operation) {
-    return new CastleError({ code, message, operation });
+function assertScope(scope, operation) {
+    if (scope !== "deck" && scope !== "user") {
+        throw storageError("CASTLE_STORAGE_INVALID_SCOPE", 'SharedStorage scope must be "deck" or "user".', operation);
+    }
 }

package/dist/storageJson.d.ts

@@ -0,0 +1,5 @@
+import { CastleError } from "./errors";
+import type { Json } from "./types";
+export declare function storageError(code: string, message: string, operation: string): CastleError;
+export declare function decodeStorageValue(encoded: string, operation: string): Json;
+export declare function encodeStorageValue(value: Json, operation: string): string;

package/dist/storageJson.js

@@ -0,0 +1,69 @@
+// The JSON contract shared by both deck-storage APIs: the whole-document
+// Storage/SharedStorage and the per-key Store. Values cross the wire as strings,
+// so this is where a deck's value becomes one and where a stored string becomes
+// a value again. Kept apart from either API so neither owns the rules and the
+// two cannot drift.
+import { CastleError } from "./errors";
+export function storageError(code, message, operation) {
+    return new CastleError({ code, message, operation });
+}
+export function decodeStorageValue(encoded, operation) {
+    try {
+        return JSON.parse(encoded);
+    }
+    catch {
+        throw storageError("CASTLE_STORAGE_PARSE_FAILED", "Stored Castle value is not valid JSON.", operation);
+    }
+}
+export function encodeStorageValue(value, operation) {
+    try {
+        assertJsonValue(value, new Set(), operation);
+        return JSON.stringify(value);
+    }
+    catch (error) {
+        if (error instanceof CastleError)
+            throw error;
+        throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage values must be JSON.", operation);
+    }
+}
+function assertJsonValue(value, seen, operation) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return;
+    if (typeof value === "number") {
+        if (Number.isFinite(value))
+            return;
+        throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage numbers must be finite.", operation);
+    }
+    if (Array.isArray(value)) {
+        assertJsonArray(value, seen, operation);
+        return;
+    }
+    if (typeof value === "object") {
+        assertJsonObject(value, seen, operation);
+        return;
+    }
+    throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage values must be JSON.", operation);
+}
+function assertJsonArray(values, seen, operation) {
+    assertNotCyclic(values, seen, operation);
+    seen.add(values);
+    for (const value of values)
+        assertJsonValue(value, seen, operation);
+    seen.delete(values);
+}
+function assertJsonObject(value, seen, operation) {
+    assertNotCyclic(value, seen, operation);
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage objects must be plain JSON.", operation);
+    }
+    seen.add(value);
+    for (const child of Object.values(value))
+        assertJsonValue(child, seen, operation);
+    seen.delete(value);
+}
+function assertNotCyclic(value, seen, operation) {
+    if (seen.has(value)) {
+        throw storageError("CASTLE_STORAGE_SERIALIZE_FAILED", "Castle storage values cannot be cyclic.", operation);
+    }
+}

package/dist/store.d.ts

@@ -0,0 +1,67 @@
+import type { Json } from "./types";
+export interface StoreListOptions {
+    /** Only keys beginning with this. Omit for every key in the scope. */
+    prefix?: string;
+    /** Rows per page. The platform caps both the row count and the page's size. */
+    limit?: number;
+    /** The `cursor` from the previous page. Omit for the first page. */
+    cursor?: string | null;
+}
+export interface StoreListEntry<T extends Json = Json> {
+    key: string;
+    value: T;
+}
+export interface StoreListPage<T extends Json = Json> {
+    entries: StoreListEntry<T>[];
+    /**
+     * Pass to the next `list` call to continue. Null means there is nothing left,
+     * and is the only reliable end-of-range signal: a page can come back short
+     * because it hit its size cap rather than because the keys ran out.
+     */
+    cursor: string | null;
+}
+export interface StoreScopeApi {
+    /** Reads keys. Keys with no value are absent from the result. */
+    get<T extends Json = Json>(keys: string[]): Promise<Record<string, T>>;
+    /**
+     * Writes keys. Resolves once the platform has the write, so a deck can tell
+     * whether saving worked; the write itself is coalesced with nearby ones.
+     */
+    set(values: Record<string, Json>): Promise<void>;
+    remove(keys: string[]): Promise<void>;
+    /**
+     * Adds to a numeric key and returns the new total, creating the key at `delta`
+     * if it is absent. Atomic: simultaneous callers each see their own increment
+     * applied, which a read-modify-write cannot promise.
+     */
+    increment(key: string, delta?: number): Promise<number>;
+    /** A page of keys under a prefix, ordered by key. */
+    list<T extends Json = Json>(options?: StoreListOptions): Promise<StoreListPage<T>>;
+}
+export interface StoreBoardScore {
+    /** The user id whose score this is. */
+    subject: string;
+    score: number;
+    updatedAt: string;
+}
+export interface StoreBoardApi {
+    /** Records the current player's score. Later submissions replace earlier ones. */
+    submit(score: number): Promise<StoreBoardScore>;
+    /** The highest scores, best first. */
+    top(limit?: number): Promise<StoreBoardScore[]>;
+    /** One player's score, defaulting to the current player. Null if unset. */
+    get(userId?: string): Promise<StoreBoardScore | null>;
+}
+export interface CastleStoreApi {
+    /** Shared by everyone playing the deck. */
+    readonly deck: StoreScopeApi;
+    /** The current player's data, which other players can read. */
+    readonly me: StoreScopeApi;
+    /** Another player's public data. Readable by anyone; writable only by them. */
+    user(userId: string): StoreScopeApi;
+    /** The current player's own data. Nobody else can read it, not even a session server. */
+    readonly private: StoreScopeApi;
+    /** A leaderboard. */
+    board(name: string): StoreBoardApi;
+}
+export declare const Store: CastleStoreApi;