@dcl/sdk 7.30.2-37804519171.commit-60e3717 → 7.30.2-37807847179.commit-24c42ea

package/server/storage/player.js

@@ -0,0 +1,244 @@
+import { getStorageServerUrl } from '../storage-url';
+import { assertIsServer, wrapSignedFetch } from '../utils';
+import { createStorageConfig, MODULE_NAME } from './constants';
+import { createValueCache } from './value-cache';
+import { errorMessage } from './error-message';
+import { assertPlayerAddress, assertStorageKey, serializeStorageValue } from './serialize';
+import { createWriteQueue, SupersedingWriteFailed } 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: a landed write detaches the pending GET so its stale response is not cached.
+    const inflightGets = new Map();
+    // Lowercased so checksummed callers share an entry.
+    const cacheKey = (address, key) => JSON.stringify([address.toLowerCase(), 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) {
+        let baseUrl;
+        try {
+            baseUrl = await getStorageServerUrl();
+        }
+        catch (error) {
+            cache.delete(ck);
+            console.error(`Failed to set player storage value '${key}' for '${address}': ${errorMessage(error)}`);
+            return false;
+        }
+        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);
+            return false;
+        }
+        cache.set(ck, { body });
+        return true;
+    }
+    async function executeDelete(address, key, ck) {
+        let baseUrl;
+        try {
+            baseUrl = await getStorageServerUrl();
+        }
+        catch (error) {
+            cache.delete(ck);
+            throw new Error(`Failed to delete player storage value '${key}' for '${address}': ${errorMessage(error)}`);
+        }
+        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);
+                return false;
+            }
+            // The DELETE may have reached the server, so the cached body is unreliable.
+            cache.delete(ck);
+            throw new Error(`Failed to delete player storage value '${key}' for '${address}': ${errorMessage(error)}`);
+        }
+        cache.setAbsent(ck);
+        return true;
+    }
+    return {
+        async get(address, key, options) {
+            assertIsServer(MODULE_NAME);
+            assertPlayerAddress(address, 'Storage.player.get()');
+            assertStorageKey(key, 'Storage.player.get()');
+            const ck = cacheKey(address, key);
+            if (writes.isPending(ck))
+                await writes.settled(ck);
+            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 {
+                    let baseUrl;
+                    try {
+                        baseUrl = await getStorageServerUrl();
+                    }
+                    catch (error) {
+                        throw new Error(`Failed to get player storage value '${key}' for '${address}': ${errorMessage(error)}`);
+                    }
+                    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;
+                        }
+                        throw new Error(`Failed to get player storage value '${key}' for '${address}': ${errorMessage(error)}`);
+                    }
+                    // wrapSignedFetch parses an empty 2xx body as {}: a missing value is a fault, not an absence.
+                    if (!data || data.value === undefined) {
+                        throw new Error(`Failed to get player storage value '${key}' for '${address}': response carried no value`);
+                    }
+                    // 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;
+                }
+                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);
+            assertPlayerAddress(address, 'Storage.player.set()');
+            assertStorageKey(key, 'Storage.player.set()');
+            const ck = cacheKey(address, key);
+            const body = serializeStorageValue(value, `Storage.player.set('${address}', '${key}')`);
+            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);
+            assertPlayerAddress(address, 'Storage.player.delete()');
+            assertStorageKey(key, 'Storage.player.delete()');
+            const ck = cacheKey(address, key);
+            return writes
+                .enqueue(ck, null, () => executeDelete(address, key, ck), true)
+                .catch((error) => {
+                if (error instanceof SupersedingWriteFailed) {
+                    throw new Error(`Failed to delete player storage value '${key}' for '${address}': ${error.message}`);
+                }
+                throw error;
+            });
+        },
+        async getValues(address, options) {
+            assertIsServer(MODULE_NAME);
+            assertPlayerAddress(address, 'Storage.player.getValues()');
+            const { prefix, limit, offset } = options ?? {};
+            let baseUrl;
+            try {
+                baseUrl = await getStorageServerUrl();
+            }
+            catch (error) {
+                throw new Error(`Failed to get player storage values for '${address}': ${errorMessage(error)}`);
+            }
+            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 watcher = cache.watch();
+            const [error, response] = await wrapSignedFetch({ url });
+            watcher.stop();
+            if (error) {
+                throw new Error(`Failed to get player storage values for '${address}': ${errorMessage(error)}`);
+            }
+            const data = response?.data;
+            if (!Array.isArray(data)) {
+                throw new Error(`Failed to get player storage values for '${address}': response carried no data array`);
+            }
+            if (data.some((entry) => typeof entry?.key !== 'string' || entry.value === undefined)) {
+                throw new Error(`Failed to get player storage values for '${address}': response carried a malformed entry`);
+            }
+            // 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 (watcher.mutated(ck) || writes.isPending(ck) || inflightGets.has(ck))
+                    continue;
+                if (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 { errorMessage } from './error-message'\nimport { assertPlayerAddress, assertStorageKey, serializeStorageValue } from './serialize'\nimport { createWriteQueue, SupersedingWriteFailed } 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   * A read first waits for writes to the same key that were pending when it was\n   * issued, so it reflects every write issued before it.\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   * @throws Error if the read fails, so a failure is never mistaken for a missing key\n   * @throws TypeError if the address or key is invalid\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 true once stored, or once a newer write that replaced this one lands\n   * (rapid writes coalesce); false if the write, or its replacement, fails\n   * @throws TypeError if the address or key is invalid, or the value cannot be stored unchanged: undefined,\n   * circular, a BigInt, or containing a function, a symbol, a non-finite number, an undefined array\n   * element or hole, a Map, Set, typed array or other built-in with no JSON form, or text with an\n   * unpaired surrogate or a NUL character. An undefined object property is dropped; a Date is\n   * stored as its ISO string and a class instance as its own enumerable data.\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 true once applied, or once a newer write that replaced it lands;\n   * false only for a confirmed 404\n   * @throws Error if the delete, or its replacement, fails; a failure is never reported as absence\n   * @throws TypeError if the address or key is invalid\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   * @throws Error if the read fails, so a failure is never mistaken for an empty page\n   * @throws TypeError if the address is invalid\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: a landed write detaches the pending GET so its stale response is not cached.\n  const inflightGets = new Map<string, { promise: Promise<unknown> }>()\n\n  // Lowercased so checksummed callers share an entry.\n  const cacheKey = (address: string, key: string) => JSON.stringify([address.toLowerCase(), 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    let baseUrl: string\n    try {\n      baseUrl = await getStorageServerUrl()\n    } catch (error) {\n      cache.delete(ck)\n      console.error(`Failed to set player storage value '${key}' for '${address}': ${errorMessage(error)}`)\n      return false\n    }\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      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    let baseUrl: string\n    try {\n      baseUrl = await getStorageServerUrl()\n    } catch (error) {\n      cache.delete(ck)\n      throw new Error(`Failed to delete player storage value '${key}' for '${address}': ${errorMessage(error)}`)\n    }\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) {\n        cache.setAbsent(ck)\n        return false\n      }\n      // The DELETE may have reached the server, so the cached body is unreliable.\n      cache.delete(ck)\n      throw new Error(`Failed to delete player storage value '${key}' for '${address}': ${errorMessage(error)}`)\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      assertPlayerAddress(address, 'Storage.player.get()')\n      assertStorageKey(key, 'Storage.player.get()')\n\n      const ck = cacheKey(address, key)\n\n      if (writes.isPending(ck)) await writes.settled(ck)\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          let baseUrl: string\n          try {\n            baseUrl = await getStorageServerUrl()\n          } catch (error) {\n            throw new Error(`Failed to get player storage value '${key}' for '${address}': ${errorMessage(error)}`)\n          }\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            throw new Error(`Failed to get player storage value '${key}' for '${address}': ${errorMessage(error)}`)\n          }\n\n          // wrapSignedFetch parses an empty 2xx body as {}: a missing value is a fault, not an absence.\n          if (!data || data.value === undefined) {\n            throw new Error(`Failed to get player storage value '${key}' for '${address}': response carried no value`)\n          }\n\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        } 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      assertPlayerAddress(address, 'Storage.player.set()')\n      assertStorageKey(key, 'Storage.player.set()')\n\n      const ck = cacheKey(address, key)\n      const body = serializeStorageValue(value, `Storage.player.set('${address}', '${key}')`)\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      assertPlayerAddress(address, 'Storage.player.delete()')\n      assertStorageKey(key, 'Storage.player.delete()')\n\n      const ck = cacheKey(address, key)\n\n      return writes\n        .enqueue(ck, null, () => executeDelete(address, key, ck), true)\n        .catch((error: unknown) => {\n          if (error instanceof SupersedingWriteFailed) {\n            throw new Error(`Failed to delete player storage value '${key}' for '${address}': ${error.message}`)\n          }\n          throw error\n        })\n    },\n\n    async getValues(address: string, options?: GetValuesOptions): Promise<GetValuesResult> {\n      assertIsServer(MODULE_NAME)\n      assertPlayerAddress(address, 'Storage.player.getValues()')\n\n      const { prefix, limit, offset } = options ?? {}\n      let baseUrl: string\n      try {\n        baseUrl = await getStorageServerUrl()\n      } catch (error) {\n        throw new Error(`Failed to get player storage values for '${address}': ${errorMessage(error)}`)\n      }\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 watcher = cache.watch()\n      const [error, response] = await wrapSignedFetch<GetValuesResult>({ url })\n      watcher.stop()\n\n      if (error) {\n        throw new Error(`Failed to get player storage values for '${address}': ${errorMessage(error)}`)\n      }\n\n      const data = response?.data\n      if (!Array.isArray(data)) {\n        throw new Error(`Failed to get player storage values for '${address}': response carried no data array`)\n      }\n      if (data.some((entry) => typeof entry?.key !== 'string' || entry.value === undefined)) {\n        throw new Error(`Failed to get player storage values for '${address}': response carried a malformed entry`)\n      }\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 (watcher.mutated(ck) || writes.isPending(ck) || inflightGets.has(ck)) continue\n        if (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,55 @@
+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.
+     * A read first waits for writes to the same key that were pending when it was
+     * issued, so it reflects every write issued before it.
+     * @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
+     * @throws Error if the read fails, so a failure is never mistaken for a missing key
+     * @throws TypeError if the key is invalid
+     */
+    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
+     * @returns true once stored, or once a newer write that replaced this one lands
+     * (rapid writes coalesce); false if the write, or its replacement, fails
+     * @throws TypeError if the key is invalid, or the value cannot be stored unchanged: undefined,
+     * circular, a BigInt, or containing a function, a symbol, a non-finite number, an undefined array
+     * element or hole, a Map, Set, typed array or other built-in with no JSON form, or text with an
+     * unpaired surrogate or a NUL character. An undefined object property is dropped; a Date is
+     * stored as its ISO string and a class instance as its own enumerable data.
+     */
+    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 true once applied, or once a newer write that replaced it lands;
+     * false only for a confirmed 404
+     * @throws Error if the delete, or its replacement, fails; a failure is never reported as absence
+     * @throws TypeError if the key is invalid
+     */
+    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
+     * @throws Error if the read fails, so a failure is never mistaken for an empty page
+     */
+    getValues(options?: GetValuesOptions): Promise<GetValuesResult>;
+}

package/server/storage/scene.js

@@ -0,0 +1,232 @@
+import { getStorageServerUrl } from '../storage-url';
+import { assertIsServer, wrapSignedFetch } from '../utils';
+import { createStorageConfig, MODULE_NAME } from './constants';
+import { createValueCache } from './value-cache';
+import { errorMessage } from './error-message';
+import { assertStorageKey, serializeStorageValue } from './serialize';
+import { createWriteQueue, SupersedingWriteFailed } from './write-queue';
+/**
+ * Creates scene-scoped storage that provides methods to interact with
+ * scene-specific key-value pairs from the Server Side Storage service.
+ * This module only works when running on server-side scenes.
+ * @internal
+ */
+export const createSceneStorage = (config = createStorageConfig()) => {
+    const cache = createValueCache(config);
+    // Each in-flight GET is tracked by a wrapper object whose identity marks
+    // ownership: a landed write detaches the pending GET so its stale response is not cached.
+    const inflightGets = new Map();
+    // Writes to the same 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.
+    const writes = createWriteQueue();
+    async function executeSet(key, body) {
+        let baseUrl;
+        try {
+            baseUrl = await getStorageServerUrl();
+        }
+        catch (error) {
+            cache.delete(key);
+            console.error(`Failed to set storage value '${key}': ${errorMessage(error)}`);
+            return false;
+        }
+        const url = `${baseUrl}/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(key);
+        if (error) {
+            // The PUT may have reached the server, so the cached body is no
+            // longer reliable.
+            cache.delete(key);
+            return false;
+        }
+        cache.set(key, { body });
+        return true;
+    }
+    async function executeDelete(key) {
+        let baseUrl;
+        try {
+            baseUrl = await getStorageServerUrl();
+        }
+        catch (error) {
+            cache.delete(key);
+            throw new Error(`Failed to delete storage value '${key}': ${errorMessage(error)}`);
+        }
+        const url = `${baseUrl}/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(key);
+        if (error) {
+            // A 404 still confirms the key is absent server-side.
+            if (status === 404) {
+                cache.setAbsent(key);
+                return false;
+            }
+            // The DELETE may have reached the server, so the cached body is unreliable.
+            cache.delete(key);
+            throw new Error(`Failed to delete storage value '${key}': ${errorMessage(error)}`);
+        }
+        cache.setAbsent(key);
+        return true;
+    }
+    return {
+        async get(key, options) {
+            assertIsServer(MODULE_NAME);
+            assertStorageKey(key, 'Storage.get()');
+            if (writes.isPending(key))
+                await writes.settled(key);
+            if (config.cacheReads && !options?.fresh) {
+                const entry = cache.get(key);
+                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(key);
+            if (joined)
+                return joined.promise;
+            const inflight = {};
+            inflight.promise = (async () => {
+                try {
+                    let baseUrl;
+                    try {
+                        baseUrl = await getStorageServerUrl();
+                    }
+                    catch (error) {
+                        throw new Error(`Failed to get storage value '${key}': ${errorMessage(error)}`);
+                    }
+                    const url = `${baseUrl}/values/${encodeURIComponent(key)}`;
+                    const [error, data, status] = await wrapSignedFetch({ url });
+                    const isOwner = inflightGets.get(key) === inflight;
+                    if (error) {
+                        // A confirmed 404 is a first-class "absent" outcome, not a failure.
+                        if (status === 404) {
+                            if (isOwner)
+                                cache.setAbsent(key);
+                            return null;
+                        }
+                        throw new Error(`Failed to get storage value '${key}': ${errorMessage(error)}`);
+                    }
+                    // wrapSignedFetch parses an empty 2xx body as {}: a missing value is a fault, not an absence.
+                    if (!data || data.value === undefined) {
+                        throw new Error(`Failed to get storage value '${key}': response carried no value`);
+                    }
+                    // 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(key, { body });
+                    return data.value;
+                }
+                finally {
+                    if (inflightGets.get(key) === inflight)
+                        inflightGets.delete(key);
+                }
+            })();
+            inflightGets.set(key, inflight);
+            return inflight.promise;
+        },
+        async set(key, value, options) {
+            assertIsServer(MODULE_NAME);
+            assertStorageKey(key, 'Storage.set()');
+            const body = serializeStorageValue(value, `Storage.set('${key}')`);
+            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(key) === undefined && cache.get(key)?.body === body) {
+                return true;
+            }
+            return writes.enqueue(key, body, (b) => executeSet(key, b), skipIfUnchanged);
+        },
+        async delete(key) {
+            assertIsServer(MODULE_NAME);
+            assertStorageKey(key, 'Storage.delete()');
+            return writes
+                .enqueue(key, null, () => executeDelete(key), true)
+                .catch((error) => {
+                if (error instanceof SupersedingWriteFailed) {
+                    throw new Error(`Failed to delete storage value '${key}': ${error.message}`);
+                }
+                throw error;
+            });
+        },
+        async getValues(options) {
+            assertIsServer(MODULE_NAME);
+            const { prefix, limit, offset } = options ?? {};
+            let baseUrl;
+            try {
+                baseUrl = await getStorageServerUrl();
+            }
+            catch (error) {
+                throw new Error(`Failed to get storage values: ${errorMessage(error)}`);
+            }
+            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}/values?${query}` : `${baseUrl}/values`;
+            const watcher = cache.watch();
+            const [error, response] = await wrapSignedFetch({ url });
+            watcher.stop();
+            if (error) {
+                throw new Error(`Failed to get storage values: ${errorMessage(error)}`);
+            }
+            const data = response?.data;
+            if (!Array.isArray(data)) {
+                throw new Error('Failed to get storage values: response carried no data array');
+            }
+            if (data.some((entry) => typeof entry?.key !== 'string' || entry.value === undefined)) {
+                throw new Error('Failed to get storage values: response carried a malformed entry');
+            }
+            // 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) {
+                if (watcher.mutated(entry.key) || writes.isPending(entry.key) || inflightGets.has(entry.key))
+                    continue;
+                if (cache.get(entry.key) === undefined) {
+                    cache.set(entry.key, { 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":"scene.js","sourceRoot":"","sources":["../../src/server/storage/scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AACpD,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC1D,OAAO,EACL,mBAAmB,EAInB,WAAW,EAGZ,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AACrE,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAA;AA4DxE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,SAA6B,mBAAmB,EAAE,EAAiB,EAAE;IACtG,MAAM,KAAK,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAA;IACtC,yEAAyE;IACzE,0FAA0F;IAC1F,MAAM,YAAY,GAAG,IAAI,GAAG,EAAyC,CAAA;IACrE,yEAAyE;IACzE,yEAAyE;IACzE,yEAAyE;IACzE,yBAAyB;IACzB,MAAM,MAAM,GAAG,gBAAgB,EAAE,CAAA;IAEjC,KAAK,UAAU,UAAU,CAAC,GAAW,EAAE,IAAY;QACjD,IAAI,OAAe,CAAA;QACnB,IAAI;YACF,OAAO,GAAG,MAAM,mBAAmB,EAAE,CAAA;SACtC;QAAC,OAAO,KAAK,EAAE;YACd,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;YACjB,OAAO,CAAC,KAAK,CAAC,gCAAgC,GAAG,MAAM,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;YAC7E,OAAO,KAAK,CAAA;SACb;QACD,MAAM,GAAG,GAAG,GAAG,OAAO,WAAW,kBAAkB,CAAC,GAAG,CAAC,EAAE,CAAA;QAE1D,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,eAAe,CAAC;YACpC,GAAG;YACH,IAAI,EAAE;gBACJ,MAAM,EAAE,KAAK;gBACb,OAAO,EAAE;oBACP,cAAc,EAAE,kBAAkB;iBACnC;gBACD,IAAI;aACL;SACF,CAAC,CAAA;QAEF,qEAAqE;QACrE,iEAAiE;QACjE,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QAExB,IAAI,KAAK,EAAE;YACT,gEAAgE;YAChE,mBAAmB;YACnB,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;YACjB,OAAO,KAAK,CAAA;SACb;QAED,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,CAAC,CAAA;QACxB,OAAO,IAAI,CAAA;IACb,CAAC;IAED,KAAK,UAAU,aAAa,CAAC,GAAW;QACtC,IAAI,OAAe,CAAA;QACnB,IAAI;YACF,OAAO,GAAG,MAAM,mBAAmB,EAAE,CAAA;SACtC;QAAC,OAAO,KAAK,EAAE;YACd,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;YACjB,MAAM,IAAI,KAAK,CAAC,mCAAmC,GAAG,MAAM,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;SACnF;QACD,MAAM,GAAG,GAAG,GAAG,OAAO,WAAW,kBAAkB,CAAC,GAAG,CAAC,EAAE,CAAA;QAE1D,MAAM,CAAC,KAAK,EAAE,AAAD,EAAG,MAAM,CAAC,GAAG,MAAM,eAAe,CAAC;YAC9C,GAAG;YACH,IAAI,EAAE;gBACJ,MAAM,EAAE,QAAQ;gBAChB,OAAO,EAAE,EAAE;aACZ;SACF,CAAC,CAAA;QAEF,uEAAuE;QACvE,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QAExB,IAAI,KAAK,EAAE;YACT,sDAAsD;YACtD,IAAI,MAAM,KAAK,GAAG,EAAE;gBAClB,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;gBACpB,OAAO,KAAK,CAAA;aACb;YACD,4EAA4E;YAC5E,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;YACjB,MAAM,IAAI,KAAK,CAAC,mCAAmC,GAAG,MAAM,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;SACnF;QAED,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;QACpB,OAAO,IAAI,CAAA;IACb,CAAC;IAED,OAAO;QACL,KAAK,CAAC,GAAG,CAAc,GAAW,EAAE,OAAoB;YACtD,cAAc,CAAC,WAAW,CAAC,CAAA;YAC3B,gBAAgB,CAAC,GAAG,EAAE,eAAe,CAAC,CAAA;YAEtC,IAAI,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC;gBAAE,MAAM,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;YAEpD,IAAI,MAAM,CAAC,UAAU,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE;gBACxC,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;gBAC5B,IAAI,KAAK,EAAE,MAAM;oBAAE,OAAO,IAAI,CAAA;gBAC9B,yEAAyE;gBACzE,IAAI,KAAK,EAAE,IAAI,KAAK,SAAS;oBAAE,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAU,CAAA;aACxE;YAED,sEAAsE;YACtE,kEAAkE;YAClE,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;YACpC,IAAI,MAAM;gBAAE,OAAO,MAAM,CAAC,OAA4B,CAAA;YAEtD,MAAM,QAAQ,GAAG,EAAoC,CAAA;YACrD,QAAQ,CAAC,OAAO,GAAG,CAAC,KAAK,IAAI,EAAE;gBAC7B,IAAI;oBACF,IAAI,OAAe,CAAA;oBACnB,IAAI;wBACF,OAAO,GAAG,MAAM,mBAAmB,EAAE,CAAA;qBACtC;oBAAC,OAAO,KAAK,EAAE;wBACd,MAAM,IAAI,KAAK,CAAC,gCAAgC,GAAG,MAAM,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;qBAChF;oBACD,MAAM,GAAG,GAAG,GAAG,OAAO,WAAW,kBAAkB,CAAC,GAAG,CAAC,EAAE,CAAA;oBAE1D,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,eAAe,CAAe,EAAE,GAAG,EAAE,CAAC,CAAA;oBAE1E,MAAM,OAAO,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,QAAQ,CAAA;oBAElD,IAAI,KAAK,EAAE;wBACT,oEAAoE;wBACpE,IAAI,MAAM,KAAK,GAAG,EAAE;4BAClB,IAAI,OAAO;gCAAE,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAA;4BACjC,OAAO,IAAI,CAAA;yBACZ;wBACD,MAAM,IAAI,KAAK,CAAC,gCAAgC,GAAG,MAAM,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;qBAChF;oBAED,8FAA8F;oBAC9F,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE;wBACrC,MAAM,IAAI,KAAK,CAAC,gCAAgC,GAAG,8BAA8B,CAAC,CAAA;qBACnF;oBAED,sEAAsE;oBACtE,qCAAqC;oBACrC,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAA;oBAClD,IAAI,OAAO;wBAAE,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,CAAC,CAAA;oBACrC,OAAO,IAAI,CAAC,KAAK,CAAA;iBAClB;wBAAS;oBACR,IAAI,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,QAAQ;wBAAE,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;iBACjE;YACH,CAAC,CAAC,EAAE,CAAA;YAEJ,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;YAC/B,OAAO,QAAQ,CAAC,OAAO,CAAA;QACzB,CAAC;QAED,KAAK,CAAC,GAAG,CAAc,GAAW,EAAE,KAAQ,EAAE,OAAoB;YAChE,cAAc,CAAC,WAAW,CAAC,CAAA;YAC3B,gBAAgB,CAAC,GAAG,EAAE,eAAe,CAAC,CAAA;YAEtC,MAAM,IAAI,GAAG,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAC,CAAA;YAClE,MAAM,eAAe,GAAG,OAAO,EAAE,eAAe,IAAI,MAAM,CAAC,eAAe,CAAA;YAE1E,mEAAmE;YACnE,uEAAuE;YACvE,kCAAkC;YAClC,IAAI,eAAe,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,SAAS,IAAI,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,IAAI,KAAK,IAAI,EAAE;gBACzF,OAAO,IAAI,CAAA;aACZ;YAED,OAAO,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,CAAW,CAAC,EAAE,eAAe,CAAC,CAAA;QACxF,CAAC;QAED,KAAK,CAAC,MAAM,CAAC,GAAW;YACtB,cAAc,CAAC,WAAW,CAAC,CAAA;YAC3B,gBAAgB,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAA;YAEzC,OAAO,MAAM;iBACV,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;iBAClD,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;gBACxB,IAAI,KAAK,YAAY,sBAAsB,EAAE;oBAC3C,MAAM,IAAI,KAAK,CAAC,mCAAmC,GAAG,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAA;iBAC7E;gBACD,MAAM,KAAK,CAAA;YACb,CAAC,CAAC,CAAA;QACN,CAAC;QAED,KAAK,CAAC,SAAS,CAAC,OAA0B;YACxC,cAAc,CAAC,WAAW,CAAC,CAAA;YAE3B,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,IAAI,EAAE,CAAA;YAC/C,IAAI,OAAe,CAAA;YACnB,IAAI;gBACF,OAAO,GAAG,MAAM,mBAAmB,EAAE,CAAA;aACtC;YAAC,OAAO,KAAK,EAAE;gBACd,MAAM,IAAI,KAAK,CAAC,iCAAiC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;aACxE;YACD,MAAM,KAAK,GAAa,EAAE,CAAA;YAE1B,IAAI,CAAC,CAAC,MAAM,EAAE;gBACZ,KAAK,CAAC,IAAI,CAAC,UAAU,kBAAkB,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;aACnD;YAED,IAAI,CAAC,CAAC,KAAK,EAAE;gBACX,KAAK,CAAC,IAAI,CAAC,SAAS,KAAK,EAAE,CAAC,CAAA;aAC7B;YAED,IAAI,CAAC,CAAC,MAAM,EAAE;gBACZ,KAAK,CAAC,IAAI,CAAC,UAAU,MAAM,EAAE,CAAC,CAAA;aAC/B;YAED,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;YAC7B,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO,WAAW,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,OAAO,SAAS,CAAA;YAEtE,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,EAAE,CAAA;YAC7B,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,MAAM,eAAe,CAAkB,EAAE,GAAG,EAAE,CAAC,CAAA;YACzE,OAAO,CAAC,IAAI,EAAE,CAAA;YAEd,IAAI,KAAK,EAAE;gBACT,MAAM,IAAI,KAAK,CAAC,iCAAiC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;aACxE;YAED,MAAM,IAAI,GAAG,QAAQ,EAAE,IAAI,CAAA;YAC3B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBACxB,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAA;aAChF;YACD,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,KAAK,EAAE,GAAG,KAAK,QAAQ,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,CAAC,EAAE;gBACrF,MAAM,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAA;aACpF;YAED,wEAAwE;YACxE,sEAAsE;YACtE,sEAAsE;YACtE,qEAAqE;YACrE,sEAAsE;YACtE,wEAAwE;YACxE,wCAAwC;YACxC,KAAK,MAAM,KAAK,IAAI,IAAI,EAAE;gBACxB,IAAI,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC;oBAAE,SAAQ;gBACtG,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE;oBACtC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAA;iBACvE;aACF;YAED,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,CAAA;YACnC,MAAM,UAAU,GAAG;gBACjB,MAAM,EAAE,QAAS,CAAC,UAAU,EAAE,MAAM,IAAI,eAAe;gBACvD,KAAK,EAAE,QAAS,CAAC,UAAU,EAAE,KAAK,IAAI,IAAI,CAAC,MAAM;aAClD,CAAA;YAED,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAA;QAC7B,CAAC;KACF,CAAA;AACH,CAAC,CAAA","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 { errorMessage } from './error-message'\nimport { assertStorageKey, serializeStorageValue } from './serialize'\nimport { createWriteQueue, SupersedingWriteFailed } from './write-queue'\n\n/**\n * Scene-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 ISceneStorage {\n  /**\n   * Retrieves a value from scene 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 key share one request.\n   * Out-of-band writers (e.g. CLI storage commands) may not be visible for up to\n   * cacheMaxAgeMs — pass { fresh: true } to force a network read.\n   * A read first waits for writes to the same key that were pending when it was\n   * issued, so it reflects every write issued before it.\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   * @throws Error if the read fails, so a failure is never mistaken for a missing key\n   * @throws TypeError if the key is invalid\n   */\n  get<T = unknown>(key: string, options?: GetOptions): Promise<T | null>\n\n  /**\n   * Stores a value in scene storage in the Server Side Storage service.\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 true once stored, or once a newer write that replaced this one lands\n   * (rapid writes coalesce); false if the write, or its replacement, fails\n   * @throws TypeError if the key is invalid, or the value cannot be stored unchanged: undefined,\n   * circular, a BigInt, or containing a function, a symbol, a non-finite number, an undefined array\n   * element or hole, a Map, Set, typed array or other built-in with no JSON form, or text with an\n   * unpaired surrogate or a NUL character. An undefined object property is dropped; a Date is\n   * stored as its ISO string and a class instance as its own enumerable data.\n   */\n  set<T = unknown>(key: string, value: T, options?: SetOptions): Promise<boolean>\n\n  /**\n   * Deletes a value from scene storage in the Server Side Storage service.\n   * @param key - The key to delete\n   * @returns true once applied, or once a newer write that replaced it lands;\n   * false only for a confirmed 404\n   * @throws Error if the delete, or its replacement, fails; a failure is never reported as absence\n   * @throws TypeError if the key is invalid\n   */\n  delete(key: string): Promise<boolean>\n\n  /**\n   * Returns key-value entries from scene storage, optionally filtered by prefix.\n   * Supports pagination via limit and offset.\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   * @throws Error if the read fails, so a failure is never mistaken for an empty page\n   */\n  getValues(options?: GetValuesOptions): Promise<GetValuesResult>\n}\n\n/**\n * Creates scene-scoped storage that provides methods to interact with\n * scene-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 createSceneStorage = (config: StorageConfigState = createStorageConfig()): ISceneStorage => {\n  const cache = createValueCache(config)\n  // Each in-flight GET is tracked by a wrapper object whose identity marks\n  // ownership: a landed write detaches the pending GET so its stale response is not cached.\n  const inflightGets = new Map<string, { promise: Promise<unknown> }>()\n  // Writes to the same key are serialized (and rapid ones coalesced to the\n  // 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.\n  const writes = createWriteQueue()\n\n  async function executeSet(key: string, body: string): Promise<boolean> {\n    let baseUrl: string\n    try {\n      baseUrl = await getStorageServerUrl()\n    } catch (error) {\n      cache.delete(key)\n      console.error(`Failed to set storage value '${key}': ${errorMessage(error)}`)\n      return false\n    }\n    const url = `${baseUrl}/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(key)\n\n    if (error) {\n      // The PUT may have reached the server, so the cached body is no\n      // longer reliable.\n      cache.delete(key)\n      return false\n    }\n\n    cache.set(key, { body })\n    return true\n  }\n\n  async function executeDelete(key: string): Promise<boolean> {\n    let baseUrl: string\n    try {\n      baseUrl = await getStorageServerUrl()\n    } catch (error) {\n      cache.delete(key)\n      throw new Error(`Failed to delete storage value '${key}': ${errorMessage(error)}`)\n    }\n    const url = `${baseUrl}/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(key)\n\n    if (error) {\n      // A 404 still confirms the key is absent server-side.\n      if (status === 404) {\n        cache.setAbsent(key)\n        return false\n      }\n      // The DELETE may have reached the server, so the cached body is unreliable.\n      cache.delete(key)\n      throw new Error(`Failed to delete storage value '${key}': ${errorMessage(error)}`)\n    }\n\n    cache.setAbsent(key)\n    return true\n  }\n\n  return {\n    async get<T = unknown>(key: string, options?: GetOptions): Promise<T | null> {\n      assertIsServer(MODULE_NAME)\n      assertStorageKey(key, 'Storage.get()')\n\n      if (writes.isPending(key)) await writes.settled(key)\n\n      if (config.cacheReads && !options?.fresh) {\n        const entry = cache.get(key)\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(key)\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          let baseUrl: string\n          try {\n            baseUrl = await getStorageServerUrl()\n          } catch (error) {\n            throw new Error(`Failed to get storage value '${key}': ${errorMessage(error)}`)\n          }\n          const url = `${baseUrl}/values/${encodeURIComponent(key)}`\n\n          const [error, data, status] = await wrapSignedFetch<{ value: T }>({ url })\n\n          const isOwner = inflightGets.get(key) === 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(key)\n              return null\n            }\n            throw new Error(`Failed to get storage value '${key}': ${errorMessage(error)}`)\n          }\n\n          // wrapSignedFetch parses an empty 2xx body as {}: a missing value is a fault, not an absence.\n          if (!data || data.value === undefined) {\n            throw new Error(`Failed to get storage value '${key}': response carried no value`)\n          }\n\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(key, { body })\n          return data.value\n        } finally {\n          if (inflightGets.get(key) === inflight) inflightGets.delete(key)\n        }\n      })()\n\n      inflightGets.set(key, inflight)\n      return inflight.promise\n    },\n\n    async set<T = unknown>(key: string, value: T, options?: SetOptions): Promise<boolean> {\n      assertIsServer(MODULE_NAME)\n      assertStorageKey(key, 'Storage.set()')\n\n      const body = serializeStorageValue(value, `Storage.set('${key}')`)\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(key) === undefined && cache.get(key)?.body === body) {\n        return true\n      }\n\n      return writes.enqueue(key, body, (b) => executeSet(key, b as string), skipIfUnchanged)\n    },\n\n    async delete(key: string): Promise<boolean> {\n      assertIsServer(MODULE_NAME)\n      assertStorageKey(key, 'Storage.delete()')\n\n      return writes\n        .enqueue(key, null, () => executeDelete(key), true)\n        .catch((error: unknown) => {\n          if (error instanceof SupersedingWriteFailed) {\n            throw new Error(`Failed to delete storage value '${key}': ${error.message}`)\n          }\n          throw error\n        })\n    },\n\n    async getValues(options?: GetValuesOptions): Promise<GetValuesResult> {\n      assertIsServer(MODULE_NAME)\n\n      const { prefix, limit, offset } = options ?? {}\n      let baseUrl: string\n      try {\n        baseUrl = await getStorageServerUrl()\n      } catch (error) {\n        throw new Error(`Failed to get storage values: ${errorMessage(error)}`)\n      }\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 ? `${baseUrl}/values?${query}` : `${baseUrl}/values`\n\n      const watcher = cache.watch()\n      const [error, response] = await wrapSignedFetch<GetValuesResult>({ url })\n      watcher.stop()\n\n      if (error) {\n        throw new Error(`Failed to get storage values: ${errorMessage(error)}`)\n      }\n\n      const data = response?.data\n      if (!Array.isArray(data)) {\n        throw new Error('Failed to get storage values: response carried no data array')\n      }\n      if (data.some((entry) => typeof entry?.key !== 'string' || entry.value === undefined)) {\n        throw new Error('Failed to get storage values: response carried a malformed entry')\n      }\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        if (watcher.mutated(entry.key) || writes.isPending(entry.key) || inflightGets.has(entry.key)) continue\n        if (cache.get(entry.key) === undefined) {\n          cache.set(entry.key, { 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"]}