@dcl/sdk 7.24.6-30098879609.commit-e704246 → 7.25.1-30310486734.commit-5ffe873

package/server/storage/constants.d.ts

@@ -0,0 +1,79 @@
+export declare const MODULE_NAME = "Storage";
+/**
+ * Options for getValues pagination and filtering.
+ */
+export interface GetValuesOptions {
+    prefix?: string;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Result of getValues with pagination metadata.
+ */
+export interface GetValuesResult {
+    /** Key-value entries for the current page. */
+    data: Array<{
+        key: string;
+        value: unknown;
+    }>;
+    pagination: {
+        offset: number;
+        total: number;
+    };
+}
+/**
+ * Per-call options for Storage get().
+ */
+export interface GetOptions {
+    /**
+     * When true, bypasses the read cache and forces a network read (the result
+     * still refreshes the cache). Concurrent gets for the same key still share
+     * one in-flight request. Default: false.
+     */
+    fresh?: boolean;
+}
+/**
+ * Per-call options for Storage set().
+ */
+export interface SetOptions {
+    /**
+     * When true, skips the network write if the serialized value matches the
+     * last value known to be stored for this key (from a previous successful
+     * set() or get()). Overrides the configured default. Default: true.
+     */
+    skipIfUnchanged?: boolean;
+}
+/**
+ * Module-wide configuration for Storage, applied to both scene-scoped and
+ * player-scoped storage via Storage.configure().
+ */
+export interface StorageOptions {
+    /**
+     * Default for set()'s skipIfUnchanged when not passed per call. A skip only
+     * suppresses a proven no-op: the exact serialized value was confirmed stored
+     * by a previous network round-trip within cacheMaxAgeMs. Default: true.
+     */
+    skipIfUnchanged?: boolean;
+    /**
+     * When true, get() serves values from the local cache within cacheMaxAgeMs,
+     * including confirmed "not found" results, without a network request.
+     * Out-of-band writers (e.g. CLI storage commands) may not be visible for up
+     * to cacheMaxAgeMs; pass { fresh: true } per call to force a network read.
+     * Default: true.
+     */
+    cacheReads?: boolean;
+    /**
+     * Max cache entries per scope (scene / player) before oldest entries are
+     * evicted. Entries hold the serialized value body, so memory scales with
+     * value size — this bounds entry count, not bytes. Default: 512.
+     */
+    cacheMaxEntries?: number;
+    /**
+     * Max age of a cache entry in milliseconds, bounding both read-cache
+     * staleness and write-dedup trust; older entries are treated as unknown.
+     * The default is deliberately short so out-of-band writers (CLI storage
+     * commands, dashboards) become visible within a minute, while still
+     * absorbing hot per-frame reads. Default: 60000 (1 minute).
+     */
+    cacheMaxAgeMs?: number;
+}

package/server/storage/constants.js

@@ -0,0 +1,19 @@
+export const MODULE_NAME = 'Storage';
+/**
+ * Default values for the resolved storage configuration.
+ * @internal
+ */
+export const DEFAULT_STORAGE_CONFIG = {
+    skipIfUnchanged: true,
+    cacheReads: true,
+    cacheMaxEntries: 512,
+    cacheMaxAgeMs: 60 * 1000
+};
+/**
+ * Creates a mutable config object, later mutated by Storage.configure().
+ * @internal
+ */
+export function createStorageConfig(overrides) {
+    return { ...DEFAULT_STORAGE_CONFIG, ...overrides };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/server/storage/index.d.ts

@@ -0,0 +1,45 @@
+import { StorageOptions } from './constants';
+import { ISceneStorage } from './scene';
+import { IPlayerStorage } from './player';
+export { GetOptions, GetValuesOptions, GetValuesResult, SetOptions, StorageOptions } from './constants';
+export { ISceneStorage } from './scene';
+export { IPlayerStorage } from './player';
+/**
+ * Storage interface with methods for scene-scoped and player-scoped storage.
+ */
+export interface IStorage extends ISceneStorage {
+    /** Player-scoped storage for key-value pairs */
+    player: IPlayerStorage;
+    /**
+     * Sets module-wide defaults for both scene-scoped and player-scoped storage.
+     * Merges the given partial options into the current configuration.
+     * Note: cacheMaxEntries applies per scope (scene and player each keep their
+     * own cache) and bounds entry count, not bytes (entries hold serialized
+     * value bodies).
+     */
+    configure(options: StorageOptions): void;
+}
+/**
+ * Storage provides methods to store and retrieve key-value data from the
+ * Server Side Storage service.
+ *
+ * - Use Storage.get/set/delete/getValues for scene-scoped storage
+ * - Use Storage.player.get/set/delete/getValues for player-scoped storage
+ * - Use Storage.configure to change module-wide defaults (e.g. skipIfUnchanged, cacheReads)
+ *
+ * Reads are cached by default: get() serves values known from a network
+ * round-trip within the last cacheMaxAgeMs (including confirmed "not found"
+ * results) without hitting the service, and concurrent gets for the same key
+ * share one request. Overlapping writes to the same key are serialized so the
+ * service commits them in issue order, and rapid writes coalesce to the
+ * latest value; every set()/delete() resolves once its value (or the newer
+ * value that superseded it) is durably applied. By default (skipIfUnchanged)
+ * an unchanged set is skipped, but only when a previous confirmed round-trip
+ * proved the exact value is already stored. Out-of-band writers (e.g. CLI storage commands)
+ * may not be visible for up to cacheMaxAgeMs; use get(key, { fresh: true })
+ * for an authoritative read or Storage.configure({ cacheReads: false }) to
+ * disable read caching.
+ *
+ * This module only works when running on server-side scenes.
+ */
+export declare const Storage: IStorage;

package/server/storage/index.js

@@ -0,0 +1,51 @@
+import { createStorageConfig } from './constants';
+import { createSceneStorage } from './scene';
+import { createPlayerStorage } from './player';
+/**
+ * Creates the Storage module with scene-scoped and player-scoped storage.
+ */
+const createStorage = () => {
+    const config = createStorageConfig();
+    const sceneStorage = createSceneStorage(config);
+    const playerStorage = createPlayerStorage(config);
+    return {
+        // Spread scene storage methods at top level
+        get: sceneStorage.get,
+        set: sceneStorage.set,
+        delete: sceneStorage.delete,
+        getValues: sceneStorage.getValues,
+        // Keep player as nested property
+        player: playerStorage,
+        configure(options) {
+            for (const [key, value] of Object.entries(options)) {
+                if (value !== undefined)
+                    config[key] = value;
+            }
+        }
+    };
+};
+/**
+ * Storage provides methods to store and retrieve key-value data from the
+ * Server Side Storage service.
+ *
+ * - Use Storage.get/set/delete/getValues for scene-scoped storage
+ * - Use Storage.player.get/set/delete/getValues for player-scoped storage
+ * - Use Storage.configure to change module-wide defaults (e.g. skipIfUnchanged, cacheReads)
+ *
+ * Reads are cached by default: get() serves values known from a network
+ * round-trip within the last cacheMaxAgeMs (including confirmed "not found"
+ * results) without hitting the service, and concurrent gets for the same key
+ * share one request. Overlapping writes to the same key are serialized so the
+ * service commits them in issue order, and rapid writes coalesce to the
+ * latest value; every set()/delete() resolves once its value (or the newer
+ * value that superseded it) is durably applied. By default (skipIfUnchanged)
+ * an unchanged set is skipped, but only when a previous confirmed round-trip
+ * proved the exact value is already stored. Out-of-band writers (e.g. CLI storage commands)
+ * may not be visible for up to cacheMaxAgeMs; use get(key, { fresh: true })
+ * for an authoritative read or Storage.configure({ cacheReads: false }) to
+ * disable read caching.
+ *
+ * This module only works when running on server-side scenes.
+ */
+export const Storage = createStorage();
+//# sourceMappingURL=data:application/json;base64,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

package/server/storage/player.d.ts

@@ -0,0 +1,45 @@
+import { GetOptions, GetValuesOptions, GetValuesResult, SetOptions } from './constants';
+/**
+ * Player-scoped storage interface for key-value pairs from the Server Side Storage service.
+ * This is NOT filesystem storage - data is stored in the remote storage service.
+ */
+export interface IPlayerStorage {
+    /**
+     * Retrieves a value from a player's storage by key from the Server Side Storage service.
+     *
+     * By default (cacheReads), values read or written during the last cacheMaxAgeMs
+     * are served from a local cache without a network request, including confirmed
+     * "not found" results. Concurrent gets for the same player and key share one
+     * request. Out-of-band writers (e.g. CLI storage commands) may not be visible
+     * for up to cacheMaxAgeMs — pass { fresh: true } to force a network read.
+     * @param address - The player's wallet address
+     * @param key - The key to retrieve
+     * @param options - Optional { fresh } to bypass the read cache
+     * @returns A promise that resolves to the parsed JSON value, or null if not found
+     */
+    get<T = unknown>(address: string, key: string, options?: GetOptions): Promise<T | null>;
+    /**
+     * Stores a value in a player's storage in the Server Side Storage service.
+     * @param address - The player's wallet address
+     * @param key - The key to store the value under
+     * @param value - The value to store (will be JSON serialized)
+     * @param options - Optional { skipIfUnchanged } to skip the network write when the value is already stored
+     * @returns A promise that resolves to true if successful, false otherwise
+     */
+    set<T = unknown>(address: string, key: string, value: T, options?: SetOptions): Promise<boolean>;
+    /**
+     * Deletes a value from a player's storage in the Server Side Storage service.
+     * @param address - The player's wallet address
+     * @param key - The key to delete
+     * @returns A promise that resolves to true if deleted, false if not found
+     */
+    delete(address: string, key: string): Promise<boolean>;
+    /**
+     * Returns key-value entries from a player's storage, optionally filtered by prefix.
+     * Supports pagination via limit and offset.
+     * @param address - The player's wallet address
+     * @param options - Optional { prefix, limit, offset } for filtering and pagination.
+     * @returns A promise that resolves to { data, pagination: { offset, total } } for pagination UI
+     */
+    getValues(address: string, options?: GetValuesOptions): Promise<GetValuesResult>;
+}

package/server/storage/player.js

@@ -0,0 +1,198 @@
+import { getStorageServerUrl } from '../storage-url';
+import { assertIsServer, wrapSignedFetch } from '../utils';
+import { createStorageConfig, MODULE_NAME } from './constants';
+import { createValueCache } from './value-cache';
+import { createWriteQueue } from './write-queue';
+/**
+ * Creates player-scoped storage that provides methods to interact with
+ * player-specific key-value pairs from the Server Side Storage service.
+ * This module only works when running on server-side scenes.
+ * @internal
+ */
+export const createPlayerStorage = (config = createStorageConfig()) => {
+    const cache = createValueCache(config);
+    // Each in-flight GET is tracked by a wrapper object whose identity marks
+    // ownership: set()/delete() drop the wrapper, detaching the pending GET so
+    // its stale response cannot overwrite the newer cache entry.
+    const inflightGets = new Map();
+    // Ethereum addresses are case-insensitive (checksum casing only), so
+    // mixed-case callers must share the same cache entry. The NUL separator
+    // cannot appear in an address, making the pair unambiguous.
+    const cacheKey = (address, key) => `${address.toLowerCase()}\u0000${key}`;
+    // Writes to the same player key are serialized (and rapid ones coalesced to
+    // the latest value) so the service commits them in issue order — overlapping
+    // PUTs would otherwise leave both the kept value and the cached value to
+    // response-order chance. Keyed by the same case-insensitive cache key.
+    const writes = createWriteQueue();
+    async function executeSet(address, key, ck, body) {
+        const baseUrl = await getStorageServerUrl();
+        const url = `${baseUrl}/players/${encodeURIComponent(address)}/values/${encodeURIComponent(key)}`;
+        const [error] = await wrapSignedFetch({
+            url,
+            init: {
+                method: 'PUT',
+                headers: {
+                    'content-type': 'application/json'
+                },
+                body
+            }
+        });
+        // Either way the entry changed server-side (or may have): detach any
+        // overlapping in-flight GET so its stale response is not cached.
+        inflightGets.delete(ck);
+        if (error) {
+            // The PUT may have reached the server, so the cached body is no
+            // longer reliable.
+            cache.delete(ck);
+            console.error(`Failed to set player storage value '${key}' for '${address}': ${error}`);
+            return false;
+        }
+        cache.set(ck, { body });
+        return true;
+    }
+    async function executeDelete(address, key, ck) {
+        const baseUrl = await getStorageServerUrl();
+        const url = `${baseUrl}/players/${encodeURIComponent(address)}/values/${encodeURIComponent(key)}`;
+        const [error, , status] = await wrapSignedFetch({
+            url,
+            init: {
+                method: 'DELETE',
+                headers: {}
+            }
+        });
+        // Detach again: a GET may have started while the DELETE was in flight.
+        inflightGets.delete(ck);
+        if (error) {
+            // A 404 still confirms the key is absent server-side.
+            if (status === 404)
+                cache.setAbsent(ck);
+            console.error(`Failed to delete player storage value '${key}' for '${address}': ${error}`);
+            return false;
+        }
+        cache.setAbsent(ck);
+        return true;
+    }
+    return {
+        async get(address, key, options) {
+            assertIsServer(MODULE_NAME);
+            const ck = cacheKey(address, key);
+            if (config.cacheReads && !options?.fresh) {
+                const entry = cache.get(ck);
+                if (entry?.absent)
+                    return null;
+                // Parse per hit so each caller gets a fresh object (no shared mutation).
+                if (entry?.body !== undefined)
+                    return JSON.parse(entry.body).value;
+            }
+            // Coalesce concurrent gets (even fresh ones: an in-flight response is
+            // milliseconds old, not TTL-stale) into a single network request.
+            const joined = inflightGets.get(ck);
+            if (joined)
+                return joined.promise;
+            const inflight = {};
+            inflight.promise = (async () => {
+                try {
+                    const baseUrl = await getStorageServerUrl();
+                    const url = `${baseUrl}/players/${encodeURIComponent(address)}/values/${encodeURIComponent(key)}`;
+                    const [error, data, status] = await wrapSignedFetch({ url });
+                    const isOwner = inflightGets.get(ck) === inflight;
+                    if (error) {
+                        // A confirmed 404 is a first-class "absent" outcome, not a failure.
+                        if (status === 404) {
+                            if (isOwner)
+                                cache.setAbsent(ck);
+                            return null;
+                        }
+                        console.error(`Failed to get player storage value '${key}' for '${address}': ${error}`);
+                        return null;
+                    }
+                    if (data && data.value !== undefined) {
+                        // Same serialization shape as set()'s PUT body, so a read followed by
+                        // an unchanged write can be skipped.
+                        const body = JSON.stringify({ value: data.value });
+                        if (isOwner)
+                            cache.set(ck, { body });
+                        return data.value;
+                    }
+                    // 200 with a missing value is ambiguous: neither a confirmed value
+                    // nor a confirmed absence, so cache nothing.
+                    return null;
+                }
+                finally {
+                    if (inflightGets.get(ck) === inflight)
+                        inflightGets.delete(ck);
+                }
+            })();
+            inflightGets.set(ck, inflight);
+            return inflight.promise;
+        },
+        async set(address, key, value, options) {
+            assertIsServer(MODULE_NAME);
+            const ck = cacheKey(address, key);
+            const body = JSON.stringify({ value });
+            const skipIfUnchanged = options?.skipIfUnchanged ?? config.skipIfUnchanged;
+            // Dedup against confirmed state only while no write is pending — a
+            // pending write makes the cache momentarily stale; enqueue() coalesces
+            // against pending writes instead.
+            if (skipIfUnchanged && writes.pending(ck) === undefined && cache.get(ck)?.body === body) {
+                return true;
+            }
+            return writes.enqueue(ck, body, (b) => executeSet(address, key, ck, b), skipIfUnchanged);
+        },
+        async delete(address, key) {
+            assertIsServer(MODULE_NAME);
+            const ck = cacheKey(address, key);
+            // Invalidate immediately — even while the DELETE waits behind other
+            // writes, reads must not serve the doomed value, and a stale
+            // "unchanged" skip would lose a future write.
+            cache.delete(ck);
+            inflightGets.delete(ck);
+            return writes.enqueue(ck, null, () => executeDelete(address, key, ck), true);
+        },
+        async getValues(address, options) {
+            assertIsServer(MODULE_NAME);
+            const { prefix, limit, offset } = options ?? {};
+            const baseUrl = await getStorageServerUrl();
+            const parts = [];
+            if (!!prefix) {
+                parts.push(`prefix=${encodeURIComponent(prefix)}`);
+            }
+            if (!!limit) {
+                parts.push(`limit=${limit}`);
+            }
+            if (!!offset) {
+                parts.push(`offset=${offset}`);
+            }
+            const query = parts.join('&');
+            const url = query
+                ? `${baseUrl}/players/${encodeURIComponent(address)}/values?${query}`
+                : `${baseUrl}/players/${encodeURIComponent(address)}/values`;
+            const [error, response] = await wrapSignedFetch({ url });
+            if (error) {
+                console.error(`Failed to get player storage values for '${address}': ${error}`);
+                return { data: [], pagination: { offset: 0, total: 0 } };
+            }
+            const data = response?.data ?? [];
+            // Seed the per-key cache so subsequent get()/set() on returned keys can
+            // skip the network. Only keys with no live entry and no pending write
+            // are seeded: existing per-key state comes from a confirmed operation
+            // that this page snapshot — whose request started earlier — must not
+            // clobber with stale data. Absence is never seeded (prefix/pagination
+            // make it non-authoritative). A page larger than cacheMaxEntries churns
+            // the cache; entries repopulate lazily.
+            for (const entry of data) {
+                const ck = cacheKey(address, entry.key);
+                if (entry.value !== undefined && !writes.isPending(ck) && cache.get(ck) === undefined) {
+                    cache.set(ck, { body: JSON.stringify({ value: entry.value }) });
+                }
+            }
+            const requestedOffset = offset ?? 0;
+            const pagination = {
+                offset: response?.pagination?.offset ?? requestedOffset,
+                total: response?.pagination?.total ?? data.length
+            };
+            return { data, pagination };
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"player.js","sourceRoot":"","sources":["../../src/server/storage/player.ts"],"names":[],"mappings":"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","sourcesContent":["import { getStorageServerUrl } from '../storage-url'\nimport { assertIsServer, wrapSignedFetch } from '../utils'\nimport {\n  createStorageConfig,\n  GetOptions,\n  GetValuesOptions,\n  GetValuesResult,\n  MODULE_NAME,\n  SetOptions,\n  StorageConfigState\n} from './constants'\nimport { createValueCache } from './value-cache'\nimport { createWriteQueue } from './write-queue'\n\n/**\n * Player-scoped storage interface for key-value pairs from the Server Side Storage service.\n * This is NOT filesystem storage - data is stored in the remote storage service.\n */\nexport interface IPlayerStorage {\n  /**\n   * Retrieves a value from a player's storage by key from the Server Side Storage service.\n   *\n   * By default (cacheReads), values read or written during the last cacheMaxAgeMs\n   * are served from a local cache without a network request, including confirmed\n   * \"not found\" results. Concurrent gets for the same player and key share one\n   * request. Out-of-band writers (e.g. CLI storage commands) may not be visible\n   * for up to cacheMaxAgeMs — pass { fresh: true } to force a network read.\n   * @param address - The player's wallet address\n   * @param key - The key to retrieve\n   * @param options - Optional { fresh } to bypass the read cache\n   * @returns A promise that resolves to the parsed JSON value, or null if not found\n   */\n  get<T = unknown>(address: string, key: string, options?: GetOptions): Promise<T | null>\n\n  /**\n   * Stores a value in a player's storage in the Server Side Storage service.\n   * @param address - The player's wallet address\n   * @param key - The key to store the value under\n   * @param value - The value to store (will be JSON serialized)\n   * @param options - Optional { skipIfUnchanged } to skip the network write when the value is already stored\n   * @returns A promise that resolves to true if successful, false otherwise\n   */\n  set<T = unknown>(address: string, key: string, value: T, options?: SetOptions): Promise<boolean>\n\n  /**\n   * Deletes a value from a player's storage in the Server Side Storage service.\n   * @param address - The player's wallet address\n   * @param key - The key to delete\n   * @returns A promise that resolves to true if deleted, false if not found\n   */\n  delete(address: string, key: string): Promise<boolean>\n\n  /**\n   * Returns key-value entries from a player's storage, optionally filtered by prefix.\n   * Supports pagination via limit and offset.\n   * @param address - The player's wallet address\n   * @param options - Optional { prefix, limit, offset } for filtering and pagination.\n   * @returns A promise that resolves to { data, pagination: { offset, total } } for pagination UI\n   */\n  getValues(address: string, options?: GetValuesOptions): Promise<GetValuesResult>\n}\n\n/**\n * Creates player-scoped storage that provides methods to interact with\n * player-specific key-value pairs from the Server Side Storage service.\n * This module only works when running on server-side scenes.\n * @internal\n */\nexport const createPlayerStorage = (config: StorageConfigState = createStorageConfig()): IPlayerStorage => {\n  const cache = createValueCache(config)\n  // Each in-flight GET is tracked by a wrapper object whose identity marks\n  // ownership: set()/delete() drop the wrapper, detaching the pending GET so\n  // its stale response cannot overwrite the newer cache entry.\n  const inflightGets = new Map<string, { promise: Promise<unknown> }>()\n\n  // Ethereum addresses are case-insensitive (checksum casing only), so\n  // mixed-case callers must share the same cache entry. The NUL separator\n  // cannot appear in an address, making the pair unambiguous.\n  const cacheKey = (address: string, key: string) => `${address.toLowerCase()}\\u0000${key}`\n\n  // Writes to the same player key are serialized (and rapid ones coalesced to\n  // the latest value) so the service commits them in issue order — overlapping\n  // PUTs would otherwise leave both the kept value and the cached value to\n  // response-order chance. Keyed by the same case-insensitive cache key.\n  const writes = createWriteQueue()\n\n  async function executeSet(address: string, key: string, ck: string, body: string): Promise<boolean> {\n    const baseUrl = await getStorageServerUrl()\n    const url = `${baseUrl}/players/${encodeURIComponent(address)}/values/${encodeURIComponent(key)}`\n\n    const [error] = await wrapSignedFetch({\n      url,\n      init: {\n        method: 'PUT',\n        headers: {\n          'content-type': 'application/json'\n        },\n        body\n      }\n    })\n\n    // Either way the entry changed server-side (or may have): detach any\n    // overlapping in-flight GET so its stale response is not cached.\n    inflightGets.delete(ck)\n\n    if (error) {\n      // The PUT may have reached the server, so the cached body is no\n      // longer reliable.\n      cache.delete(ck)\n      console.error(`Failed to set player storage value '${key}' for '${address}': ${error}`)\n      return false\n    }\n\n    cache.set(ck, { body })\n    return true\n  }\n\n  async function executeDelete(address: string, key: string, ck: string): Promise<boolean> {\n    const baseUrl = await getStorageServerUrl()\n    const url = `${baseUrl}/players/${encodeURIComponent(address)}/values/${encodeURIComponent(key)}`\n\n    const [error, , status] = await wrapSignedFetch({\n      url,\n      init: {\n        method: 'DELETE',\n        headers: {}\n      }\n    })\n\n    // Detach again: a GET may have started while the DELETE was in flight.\n    inflightGets.delete(ck)\n\n    if (error) {\n      // A 404 still confirms the key is absent server-side.\n      if (status === 404) cache.setAbsent(ck)\n      console.error(`Failed to delete player storage value '${key}' for '${address}': ${error}`)\n      return false\n    }\n\n    cache.setAbsent(ck)\n    return true\n  }\n\n  return {\n    async get<T = unknown>(address: string, key: string, options?: GetOptions): Promise<T | null> {\n      assertIsServer(MODULE_NAME)\n\n      const ck = cacheKey(address, key)\n\n      if (config.cacheReads && !options?.fresh) {\n        const entry = cache.get(ck)\n        if (entry?.absent) return null\n        // Parse per hit so each caller gets a fresh object (no shared mutation).\n        if (entry?.body !== undefined) return JSON.parse(entry.body).value as T\n      }\n\n      // Coalesce concurrent gets (even fresh ones: an in-flight response is\n      // milliseconds old, not TTL-stale) into a single network request.\n      const joined = inflightGets.get(ck)\n      if (joined) return joined.promise as Promise<T | null>\n\n      const inflight = {} as { promise: Promise<T | null> }\n      inflight.promise = (async () => {\n        try {\n          const baseUrl = await getStorageServerUrl()\n          const url = `${baseUrl}/players/${encodeURIComponent(address)}/values/${encodeURIComponent(key)}`\n\n          const [error, data, status] = await wrapSignedFetch<{ value: T }>({ url })\n\n          const isOwner = inflightGets.get(ck) === inflight\n\n          if (error) {\n            // A confirmed 404 is a first-class \"absent\" outcome, not a failure.\n            if (status === 404) {\n              if (isOwner) cache.setAbsent(ck)\n              return null\n            }\n            console.error(`Failed to get player storage value '${key}' for '${address}': ${error}`)\n            return null\n          }\n\n          if (data && data.value !== undefined) {\n            // Same serialization shape as set()'s PUT body, so a read followed by\n            // an unchanged write can be skipped.\n            const body = JSON.stringify({ value: data.value })\n            if (isOwner) cache.set(ck, { body })\n            return data.value\n          }\n\n          // 200 with a missing value is ambiguous: neither a confirmed value\n          // nor a confirmed absence, so cache nothing.\n          return null\n        } finally {\n          if (inflightGets.get(ck) === inflight) inflightGets.delete(ck)\n        }\n      })()\n\n      inflightGets.set(ck, inflight)\n      return inflight.promise\n    },\n\n    async set<T = unknown>(address: string, key: string, value: T, options?: SetOptions): Promise<boolean> {\n      assertIsServer(MODULE_NAME)\n\n      const ck = cacheKey(address, key)\n      const body = JSON.stringify({ value })\n      const skipIfUnchanged = options?.skipIfUnchanged ?? config.skipIfUnchanged\n\n      // Dedup against confirmed state only while no write is pending — a\n      // pending write makes the cache momentarily stale; enqueue() coalesces\n      // against pending writes instead.\n      if (skipIfUnchanged && writes.pending(ck) === undefined && cache.get(ck)?.body === body) {\n        return true\n      }\n\n      return writes.enqueue(ck, body, (b) => executeSet(address, key, ck, b as string), skipIfUnchanged)\n    },\n\n    async delete(address: string, key: string): Promise<boolean> {\n      assertIsServer(MODULE_NAME)\n\n      const ck = cacheKey(address, key)\n\n      // Invalidate immediately — even while the DELETE waits behind other\n      // writes, reads must not serve the doomed value, and a stale\n      // \"unchanged\" skip would lose a future write.\n      cache.delete(ck)\n      inflightGets.delete(ck)\n\n      return writes.enqueue(ck, null, () => executeDelete(address, key, ck), true)\n    },\n\n    async getValues(address: string, options?: GetValuesOptions): Promise<GetValuesResult> {\n      assertIsServer(MODULE_NAME)\n\n      const { prefix, limit, offset } = options ?? {}\n      const baseUrl = await getStorageServerUrl()\n      const parts: string[] = []\n\n      if (!!prefix) {\n        parts.push(`prefix=${encodeURIComponent(prefix)}`)\n      }\n\n      if (!!limit) {\n        parts.push(`limit=${limit}`)\n      }\n\n      if (!!offset) {\n        parts.push(`offset=${offset}`)\n      }\n\n      const query = parts.join('&')\n      const url = query\n        ? `${baseUrl}/players/${encodeURIComponent(address)}/values?${query}`\n        : `${baseUrl}/players/${encodeURIComponent(address)}/values`\n\n      const [error, response] = await wrapSignedFetch<GetValuesResult>({ url })\n\n      if (error) {\n        console.error(`Failed to get player storage values for '${address}': ${error}`)\n        return { data: [], pagination: { offset: 0, total: 0 } }\n      }\n\n      const data = response?.data ?? []\n\n      // Seed the per-key cache so subsequent get()/set() on returned keys can\n      // skip the network. Only keys with no live entry and no pending write\n      // are seeded: existing per-key state comes from a confirmed operation\n      // that this page snapshot — whose request started earlier — must not\n      // clobber with stale data. Absence is never seeded (prefix/pagination\n      // make it non-authoritative). A page larger than cacheMaxEntries churns\n      // the cache; entries repopulate lazily.\n      for (const entry of data) {\n        const ck = cacheKey(address, entry.key)\n        if (entry.value !== undefined && !writes.isPending(ck) && cache.get(ck) === undefined) {\n          cache.set(ck, { body: JSON.stringify({ value: entry.value }) })\n        }\n      }\n\n      const requestedOffset = offset ?? 0\n      const pagination = {\n        offset: response?.pagination?.offset ?? requestedOffset,\n        total: response?.pagination?.total ?? data.length\n      }\n\n      return { data, pagination }\n    }\n  }\n}\n"]}

package/server/storage/scene.d.ts

@@ -0,0 +1,40 @@
+import { GetOptions, GetValuesOptions, GetValuesResult, SetOptions } from './constants';
+/**
+ * Scene-scoped storage interface for key-value pairs from the Server Side Storage service.
+ * This is NOT filesystem storage - data is stored in the remote storage service.
+ */
+export interface ISceneStorage {
+    /**
+     * Retrieves a value from scene storage by key from the Server Side Storage service.
+     *
+     * By default (cacheReads), values read or written during the last cacheMaxAgeMs
+     * are served from a local cache without a network request, including confirmed
+     * "not found" results. Concurrent gets for the same key share one request.
+     * Out-of-band writers (e.g. CLI storage commands) may not be visible for up to
+     * cacheMaxAgeMs — pass { fresh: true } to force a network read.
+     * @param key - The key to retrieve
+     * @param options - Optional { fresh } to bypass the read cache
+     * @returns A promise that resolves to the parsed JSON value, or null if not found
+     */
+    get<T = unknown>(key: string, options?: GetOptions): Promise<T | null>;
+    /**
+     * Stores a value in scene storage in the Server Side Storage service.
+     * @param key - The key to store the value under
+     * @param value - The value to store (will be JSON serialized)
+     * @param options - Optional { skipIfUnchanged } to skip the network write when the value is already stored
+     */
+    set<T = unknown>(key: string, value: T, options?: SetOptions): Promise<boolean>;
+    /**
+     * Deletes a value from scene storage in the Server Side Storage service.
+     * @param key - The key to delete
+     * @returns A promise that resolves to true if deleted, false if not found
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Returns key-value entries from scene storage, optionally filtered by prefix.
+     * Supports pagination via limit and offset.
+     * @param options - Optional { prefix, limit, offset } for filtering and pagination.
+     * @returns A promise that resolves to { data, pagination: { offset, total } } for pagination UI
+     */
+    getValues(options?: GetValuesOptions): Promise<GetValuesResult>;
+}