@dcl/sdk 7.29.1-36591934525.commit-48aa9b5 → 7.29.1-36625469671.commit-2d5ffac

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":"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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 { 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"]}

package/server/storage/serialize.d.ts

@@ -0,0 +1 @@
+export {};

package/server/storage/serialize.js

@@ -0,0 +1,135 @@
+const LONE_SURROGATE = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
+const UNSTORABLE_TEXT = /\u0000/;
+const MAX_KEY_LENGTH = 255;
+/**
+ * JSON.stringify always writes NUL as `\u0000` and an unpaired surrogate as a `\udXXX` escape (ES2019),
+ * while paired surrogates stay raw; an escaped backslash in front means the text is literal.
+ */
+const ESCAPED_UNSTORABLE_TEXT = /(?<!\\)(?:\\\\)*\\u(?:0000|d[89a-f][0-9a-f]{2})/i;
+/** Raised from inside the replacer, so it is not mistaken for an engine error. */
+class UnstorableValueError extends TypeError {
+}
+/**
+ * The `{ value }` PUT body. Rejects, at any depth, what JSON would drop or change: functions,
+ * symbols, non-finite numbers, `undefined` array elements and holes, built-ins with no JSON form
+ * (Map, Set, typed arrays, RegExp, Error, ...), and text the service cannot store. An `undefined`
+ * object property is dropped, as it reads back the same.
+ * @internal
+ */
+export function serializeStorageValue(value, callSite) {
+    const body = stringify(value, callSite, fastReason);
+    // Text is checked once on the output; only a rejection pays for locating the offending item.
+    if (ESCAPED_UNSTORABLE_TEXT.test(body)) {
+        stringify(value, callSite, unstorable);
+        throw new TypeError(`${callSite}: value must not contain an unpaired surrogate or a NUL character.`);
+    }
+    if (body === '{}') {
+        throw new TypeError(`${callSite}: value must be JSON-serializable. Use delete() to remove a key.`);
+    }
+    return body;
+}
+function stringify(value, callSite, reason) {
+    const envelope = { value };
+    try {
+        return JSON.stringify(envelope, function (property, item) {
+            const why = reason(this, property, item);
+            if (why) {
+                const where = this === envelope ? 'the value' : `"${property}"`;
+                throw new UnstorableValueError(`${callSite}: value must be JSON-serializable, but ${where} ${why}. Use delete() to remove a key.`);
+            }
+            return item;
+        });
+    }
+    catch (error) {
+        if (error instanceof UnstorableValueError)
+            throw error;
+        const cause = error instanceof Error ? error.message.split('\n')[0] : String(error);
+        throw new TypeError(`${callSite}: value must be JSON-serializable (${cause}). Use delete() to remove a key.`);
+    }
+}
+/** Everything but the text checks, with plain objects and arrays skipping the built-in check. */
+function fastReason(holder, property, item) {
+    switch (typeof item) {
+        case 'function':
+        case 'symbol':
+            return `is a ${typeof item}`;
+        case 'number':
+            return Number.isFinite(item) ? undefined : `is the non-finite number ${item}`;
+        case 'undefined':
+            if (Array.isArray(holder))
+                return 'is undefined or a hole in an array';
+            return holder[property] !== undefined ? 'has a toJSON() that returns undefined' : undefined;
+        case 'object': {
+            if (item === null || Array.isArray(item))
+                return undefined;
+            const prototype = Object.getPrototypeOf(item);
+            return prototype === Object.prototype || prototype === null ? undefined : builtInReason(item);
+        }
+        default:
+            return undefined;
+    }
+}
+/** Every check, per item: used to name the item a text rejection comes from. */
+function unstorable(holder, property, item) {
+    const fast = fastReason(holder, property, item);
+    if (fast)
+        return fast;
+    if (typeof item === 'string' && (LONE_SURROGATE.test(item) || UNSTORABLE_TEXT.test(item))) {
+        return 'contains an unpaired surrogate or a NUL character';
+    }
+    if (!Array.isArray(holder) && (LONE_SURROGATE.test(property) || UNSTORABLE_TEXT.test(property))) {
+        return 'is a key with an unpaired surrogate or a NUL character';
+    }
+    return undefined;
+}
+function builtInReason(item) {
+    const builtIn = builtInName(item);
+    return builtIn ? `is ${/^[AEIO]/.test(builtIn) ? 'an' : 'a'} ${builtIn}, which has no JSON form` : undefined;
+}
+function builtInName(item) {
+    if (item === null || typeof item !== 'object')
+        return undefined;
+    if (item instanceof Map)
+        return 'Map';
+    if (item instanceof Set)
+        return 'Set';
+    if (item instanceof WeakMap)
+        return 'WeakMap';
+    if (item instanceof WeakSet)
+        return 'WeakSet';
+    if (item instanceof RegExp)
+        return 'RegExp';
+    if (item instanceof Error)
+        return 'Error';
+    if (item instanceof Promise)
+        return 'Promise';
+    if (item instanceof ArrayBuffer)
+        return 'ArrayBuffer';
+    if (ArrayBuffer.isView(item))
+        return item.constructor?.name ?? 'typed array';
+    return undefined;
+}
+/**
+ * Keys and player addresses go into the request path, where `.`, `..` and an empty segment are
+ * resolved away by URL parsing, so they would address a different resource.
+ * @internal
+ */
+export function assertStorageKey(key, callSite) {
+    if (typeof key !== 'string' || key === '' || key === '.' || key === '..') {
+        throw new TypeError(`${callSite}: key must be a non-empty string other than "." and "..".`);
+    }
+    if (LONE_SURROGATE.test(key) || UNSTORABLE_TEXT.test(key)) {
+        throw new TypeError(`${callSite}: key must not contain an unpaired surrogate or a NUL character.`);
+    }
+    // Counted in characters, as the service counts them.
+    if ([...key].length > MAX_KEY_LENGTH) {
+        throw new TypeError(`${callSite}: key must be at most ${MAX_KEY_LENGTH} characters.`);
+    }
+}
+/** @internal */
+export function assertPlayerAddress(address, callSite) {
+    if (typeof address !== 'string' || !/^0x[0-9a-fA-F]{40}$/.test(address)) {
+        throw new TypeError(`${callSite}: address must be a 0x-prefixed 20-byte hex address.`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serialize.js","sourceRoot":"","sources":["../../src/server/storage/serialize.ts"],"names":[],"mappings":"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","sourcesContent":["const LONE_SURROGATE = /[\\ud800-\\udbff](?![\\udc00-\\udfff])|(?<![\\ud800-\\udbff])[\\udc00-\\udfff]/\nconst UNSTORABLE_TEXT = /\\u0000/\nconst MAX_KEY_LENGTH = 255\n\n/**\n * JSON.stringify always writes NUL as `\\u0000` and an unpaired surrogate as a `\\udXXX` escape (ES2019),\n * while paired surrogates stay raw; an escaped backslash in front means the text is literal.\n */\nconst ESCAPED_UNSTORABLE_TEXT = /(?<!\\\\)(?:\\\\\\\\)*\\\\u(?:0000|d[89a-f][0-9a-f]{2})/i\n\n/** Raised from inside the replacer, so it is not mistaken for an engine error. */\nclass UnstorableValueError extends TypeError {}\n\ntype Reason = (holder: Record<string, unknown>, property: string, item: unknown) => string | undefined\n\n/**\n * The `{ value }` PUT body. Rejects, at any depth, what JSON would drop or change: functions,\n * symbols, non-finite numbers, `undefined` array elements and holes, built-ins with no JSON form\n * (Map, Set, typed arrays, RegExp, Error, ...), and text the service cannot store. An `undefined`\n * object property is dropped, as it reads back the same.\n * @internal\n */\nexport function serializeStorageValue(value: unknown, callSite: string): string {\n  const body = stringify(value, callSite, fastReason)\n  // Text is checked once on the output; only a rejection pays for locating the offending item.\n  if (ESCAPED_UNSTORABLE_TEXT.test(body)) {\n    stringify(value, callSite, unstorable)\n    throw new TypeError(`${callSite}: value must not contain an unpaired surrogate or a NUL character.`)\n  }\n  if (body === '{}') {\n    throw new TypeError(`${callSite}: value must be JSON-serializable. Use delete() to remove a key.`)\n  }\n  return body\n}\n\nfunction stringify(value: unknown, callSite: string, reason: Reason): string {\n  const envelope = { value }\n  try {\n    return JSON.stringify(envelope, function (this: Record<string, unknown>, property, item) {\n      const why = reason(this, property, item)\n      if (why) {\n        const where = this === envelope ? 'the value' : `\"${property}\"`\n        throw new UnstorableValueError(\n          `${callSite}: value must be JSON-serializable, but ${where} ${why}. Use delete() to remove a key.`\n        )\n      }\n      return item\n    })\n  } catch (error) {\n    if (error instanceof UnstorableValueError) throw error\n    const cause = error instanceof Error ? error.message.split('\\n')[0] : String(error)\n    throw new TypeError(`${callSite}: value must be JSON-serializable (${cause}). Use delete() to remove a key.`)\n  }\n}\n\n/** Everything but the text checks, with plain objects and arrays skipping the built-in check. */\nfunction fastReason(holder: Record<string, unknown>, property: string, item: unknown): string | undefined {\n  switch (typeof item) {\n    case 'function':\n    case 'symbol':\n      return `is a ${typeof item}`\n    case 'number':\n      return Number.isFinite(item) ? undefined : `is the non-finite number ${item}`\n    case 'undefined':\n      if (Array.isArray(holder)) return 'is undefined or a hole in an array'\n      return holder[property] !== undefined ? 'has a toJSON() that returns undefined' : undefined\n    case 'object': {\n      if (item === null || Array.isArray(item)) return undefined\n      const prototype = Object.getPrototypeOf(item)\n      return prototype === Object.prototype || prototype === null ? undefined : builtInReason(item)\n    }\n    default:\n      return undefined\n  }\n}\n\n/** Every check, per item: used to name the item a text rejection comes from. */\nfunction unstorable(holder: Record<string, unknown>, property: string, item: unknown): string | undefined {\n  const fast = fastReason(holder, property, item)\n  if (fast) return fast\n  if (typeof item === 'string' && (LONE_SURROGATE.test(item) || UNSTORABLE_TEXT.test(item))) {\n    return 'contains an unpaired surrogate or a NUL character'\n  }\n  if (!Array.isArray(holder) && (LONE_SURROGATE.test(property) || UNSTORABLE_TEXT.test(property))) {\n    return 'is a key with an unpaired surrogate or a NUL character'\n  }\n  return undefined\n}\n\nfunction builtInReason(item: unknown): string | undefined {\n  const builtIn = builtInName(item)\n  return builtIn ? `is ${/^[AEIO]/.test(builtIn) ? 'an' : 'a'} ${builtIn}, which has no JSON form` : undefined\n}\n\nfunction builtInName(item: unknown): string | undefined {\n  if (item === null || typeof item !== 'object') return undefined\n  if (item instanceof Map) return 'Map'\n  if (item instanceof Set) return 'Set'\n  if (item instanceof WeakMap) return 'WeakMap'\n  if (item instanceof WeakSet) return 'WeakSet'\n  if (item instanceof RegExp) return 'RegExp'\n  if (item instanceof Error) return 'Error'\n  if (item instanceof Promise) return 'Promise'\n  if (item instanceof ArrayBuffer) return 'ArrayBuffer'\n  if (ArrayBuffer.isView(item)) return item.constructor?.name ?? 'typed array'\n  return undefined\n}\n\n/**\n * Keys and player addresses go into the request path, where `.`, `..` and an empty segment are\n * resolved away by URL parsing, so they would address a different resource.\n * @internal\n */\nexport function assertStorageKey(key: unknown, callSite: string): void {\n  if (typeof key !== 'string' || key === '' || key === '.' || key === '..') {\n    throw new TypeError(`${callSite}: key must be a non-empty string other than \".\" and \"..\".`)\n  }\n  if (LONE_SURROGATE.test(key) || UNSTORABLE_TEXT.test(key)) {\n    throw new TypeError(`${callSite}: key must not contain an unpaired surrogate or a NUL character.`)\n  }\n  // Counted in characters, as the service counts them.\n  if ([...key].length > MAX_KEY_LENGTH) {\n    throw new TypeError(`${callSite}: key must be at most ${MAX_KEY_LENGTH} characters.`)\n  }\n}\n\n/** @internal */\nexport function assertPlayerAddress(address: unknown, callSite: string): void {\n  if (typeof address !== 'string' || !/^0x[0-9a-fA-F]{40}$/.test(address)) {\n    throw new TypeError(`${callSite}: address must be a 0x-prefixed 20-byte hex address.`)\n  }\n}\n"]}

package/server/storage/value-cache.d.ts

@@ -0,0 +1 @@
+export {};

package/server/storage/value-cache.js

@@ -0,0 +1,67 @@
+import { DEFAULT_STORAGE_CONFIG } from './constants';
+/**
+ * Creates the bounded value cache shared by a storage scope.
+ * @internal
+ */
+export function createValueCache(config) {
+    const entries = new Map();
+    const watchers = new Set();
+    function noteMutation(key) {
+        for (const seen of watchers)
+            seen.add(key);
+    }
+    function insert(key, entry) {
+        noteMutation(key);
+        // Delete + re-insert moves refreshed keys to the end of the Map's
+        // insertion order, so eviction below drops the least-recently-written.
+        entries.delete(key);
+        entries.set(key, { ...entry, storedAt: Date.now() });
+        // Guard against misconfiguration: a negative bound would loop forever on
+        // an empty map, and a NaN bound would silently disable eviction.
+        const maxEntries = !Number.isNaN(config.cacheMaxEntries)
+            ? Math.max(0, config.cacheMaxEntries)
+            : DEFAULT_STORAGE_CONFIG.cacheMaxEntries;
+        while (entries.size > maxEntries) {
+            entries.delete(entries.keys().next().value);
+        }
+    }
+    return {
+        get(key) {
+            const entry = entries.get(key);
+            if (!entry)
+                return undefined;
+            // Guard against misconfiguration, mirroring cacheMaxEntries: a NaN
+            // bound would silently disable expiry (NaN comparisons are false).
+            // Negative values need no guard — they just expire everything.
+            const maxAgeMs = !Number.isNaN(config.cacheMaxAgeMs) ? config.cacheMaxAgeMs : DEFAULT_STORAGE_CONFIG.cacheMaxAgeMs;
+            // Lazy max-age expiry: storedAt is never refreshed on hits, so the age
+            // bounds the time since the last actual network confirmation.
+            if (Date.now() - entry.storedAt > maxAgeMs) {
+                entries.delete(key);
+                return undefined;
+            }
+            return entry;
+        },
+        set(key, entry) {
+            insert(key, entry);
+        },
+        setAbsent(key) {
+            insert(key, { absent: true });
+        },
+        delete(key) {
+            noteMutation(key);
+            entries.delete(key);
+        },
+        watch() {
+            const seen = new Set();
+            watchers.add(seen);
+            return {
+                mutated: (key) => seen.has(key),
+                stop: () => {
+                    watchers.delete(seen);
+                }
+            };
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"value-cache.js","sourceRoot":"","sources":["../../src/server/storage/value-cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAsB,MAAM,aAAa,CAAA;AA4CxE;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAA0B;IACzD,MAAM,OAAO,GAAG,IAAI,GAAG,EAA6C,CAAA;IACpE,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAe,CAAA;IAEvC,SAAS,YAAY,CAAC,GAAW;QAC/B,KAAK,MAAM,IAAI,IAAI,QAAQ;YAAE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IAC5C,CAAC;IAED,SAAS,MAAM,CAAC,GAAW,EAAE,KAAiB;QAC5C,YAAY,CAAC,GAAG,CAAC,CAAA;QACjB,kEAAkE;QAClE,uEAAuE;QACvE,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACnB,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,GAAG,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;QAEpD,yEAAyE;QACzE,iEAAiE;QACjE,MAAM,UAAU,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,eAAe,CAAC;YACtD,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,eAAe,CAAC;YACrC,CAAC,CAAC,sBAAsB,CAAC,eAAe,CAAA;QAE1C,OAAO,OAAO,CAAC,IAAI,GAAG,UAAU,EAAE;YAChC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAM,CAAC,CAAA;SAC7C;IACH,CAAC;IAED,OAAO;QACL,GAAG,CAAC,GAAW;YACb,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;YAC9B,IAAI,CAAC,KAAK;gBAAE,OAAO,SAAS,CAAA;YAE5B,mEAAmE;YACnE,mEAAmE;YACnE,+DAA+D;YAC/D,MAAM,QAAQ,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,sBAAsB,CAAC,aAAa,CAAA;YAElH,uEAAuE;YACvE,8DAA8D;YAC9D,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,QAAQ,GAAG,QAAQ,EAAE;gBAC1C,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;gBACnB,OAAO,SAAS,CAAA;aACjB;YAED,OAAO,KAAK,CAAA;QACd,CAAC;QAED,GAAG,CAAC,GAAW,EAAE,KAAuB;YACtC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;QACpB,CAAC;QAED,SAAS,CAAC,GAAW;YACnB,MAAM,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAA;QAC/B,CAAC;QAED,MAAM,CAAC,GAAW;YAChB,YAAY,CAAC,GAAG,CAAC,CAAA;YACjB,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACrB,CAAC;QAED,KAAK;YACH,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAA;YAC9B,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;YAClB,OAAO;gBACL,OAAO,EAAE,CAAC,GAAW,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;gBACvC,IAAI,EAAE,GAAG,EAAE;oBACT,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;gBACvB,CAAC;aACF,CAAA;QACH,CAAC;KACF,CAAA;AACH,CAAC","sourcesContent":["import { DEFAULT_STORAGE_CONFIG, StorageConfigState } from './constants'\n\n/**\n * A cached fact about a key's server-side state.\n * @internal\n */\nexport interface CacheEntry {\n  /**\n   * Serialized `{ value }` body; absent for negative entries. Parsed per read\n   * hit so callers never share object references, and compared verbatim for\n   * write dedup (exact equality — no hash-collision risk).\n   */\n  body?: string\n  /** True when the server confirmed the key does not exist (GET 404 or successful DELETE). */\n  absent?: boolean\n}\n\n/**\n * Bounded, lazily-expiring cache of key states, backing both write dedup\n * (skip storage writes whose value is already known to be stored) and read\n * caching (serve get() without a network request within the TTL).\n * @internal\n */\nexport interface ValueCache {\n  /** Returns the entry if present and fresh; lazily evicts expired entries. */\n  get(key: string): CacheEntry | undefined\n  /** Stores or refreshes a known value (serialized body); overwrites negative entries. */\n  set(key: string, entry: { body: string }): void\n  /** Stores a confirmed-absent (negative) entry, replacing any value entry. */\n  setAbsent(key: string): void\n  delete(key: string): void\n  /** Starts recording mutated keys, so a read issued earlier can tell its snapshot went stale. */\n  watch(): CacheWatcher\n}\n\n/**\n * Keys mutated since the watch started. Always stop() it, or it keeps collecting.\n * @internal\n */\nexport interface CacheWatcher {\n  mutated(key: string): boolean\n  stop(): void\n}\n\n/**\n * Creates the bounded value cache shared by a storage scope.\n * @internal\n */\nexport function createValueCache(config: StorageConfigState): ValueCache {\n  const entries = new Map<string, CacheEntry & { storedAt: number }>()\n  const watchers = new Set<Set<string>>()\n\n  function noteMutation(key: string): void {\n    for (const seen of watchers) seen.add(key)\n  }\n\n  function insert(key: string, entry: CacheEntry): void {\n    noteMutation(key)\n    // Delete + re-insert moves refreshed keys to the end of the Map's\n    // insertion order, so eviction below drops the least-recently-written.\n    entries.delete(key)\n    entries.set(key, { ...entry, storedAt: Date.now() })\n\n    // Guard against misconfiguration: a negative bound would loop forever on\n    // an empty map, and a NaN bound would silently disable eviction.\n    const maxEntries = !Number.isNaN(config.cacheMaxEntries)\n      ? Math.max(0, config.cacheMaxEntries)\n      : DEFAULT_STORAGE_CONFIG.cacheMaxEntries\n\n    while (entries.size > maxEntries) {\n      entries.delete(entries.keys().next().value!)\n    }\n  }\n\n  return {\n    get(key: string): CacheEntry | undefined {\n      const entry = entries.get(key)\n      if (!entry) return undefined\n\n      // Guard against misconfiguration, mirroring cacheMaxEntries: a NaN\n      // bound would silently disable expiry (NaN comparisons are false).\n      // Negative values need no guard — they just expire everything.\n      const maxAgeMs = !Number.isNaN(config.cacheMaxAgeMs) ? config.cacheMaxAgeMs : DEFAULT_STORAGE_CONFIG.cacheMaxAgeMs\n\n      // Lazy max-age expiry: storedAt is never refreshed on hits, so the age\n      // bounds the time since the last actual network confirmation.\n      if (Date.now() - entry.storedAt > maxAgeMs) {\n        entries.delete(key)\n        return undefined\n      }\n\n      return entry\n    },\n\n    set(key: string, entry: { body: string }): void {\n      insert(key, entry)\n    },\n\n    setAbsent(key: string): void {\n      insert(key, { absent: true })\n    },\n\n    delete(key: string): void {\n      noteMutation(key)\n      entries.delete(key)\n    },\n\n    watch(): CacheWatcher {\n      const seen = new Set<string>()\n      watchers.add(seen)\n      return {\n        mutated: (key: string) => seen.has(key),\n        stop: () => {\n          watchers.delete(seen)\n        }\n      }\n    }\n  }\n}\n"]}

package/server/storage/write-queue.d.ts

@@ -0,0 +1 @@
+export {};