@dcl/sdk 7.25.0 → 7.25.1-30310486734.commit-5ffe873

package/server/storage/scene.js

@@ -0,0 +1,188 @@
+import { getStorageServerUrl } from '../storage-url';
+import { assertIsServer, wrapSignedFetch } from '../utils';
+import { createStorageConfig, MODULE_NAME } from './constants';
+import { createValueCache } from './value-cache';
+import { createWriteQueue } from './write-queue';
+/**
+ * Creates 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: set()/delete() drop the wrapper, detaching the pending GET so
+    // its stale response cannot overwrite the newer cache entry.
+    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) {
+        const baseUrl = await getStorageServerUrl();
+        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);
+            console.error(`Failed to set storage value '${key}': ${error}`);
+            return false;
+        }
+        cache.set(key, { body });
+        return true;
+    }
+    async function executeDelete(key) {
+        const baseUrl = await getStorageServerUrl();
+        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);
+            console.error(`Failed to delete storage value '${key}': ${error}`);
+            return false;
+        }
+        cache.setAbsent(key);
+        return true;
+    }
+    return {
+        async get(key, options) {
+            assertIsServer(MODULE_NAME);
+            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 {
+                    const baseUrl = await getStorageServerUrl();
+                    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;
+                        }
+                        console.error(`Failed to get storage value '${key}': ${error}`);
+                        return null;
+                    }
+                    if (data && data.value !== undefined) {
+                        // Same serialization shape as set()'s PUT body, so a read followed by
+                        // an unchanged write can be skipped.
+                        const body = JSON.stringify({ value: data.value });
+                        if (isOwner)
+                            cache.set(key, { body });
+                        return data.value;
+                    }
+                    // 200 with a missing value is ambiguous: neither a confirmed value
+                    // nor a confirmed absence, so cache nothing.
+                    return null;
+                }
+                finally {
+                    if (inflightGets.get(key) === inflight)
+                        inflightGets.delete(key);
+                }
+            })();
+            inflightGets.set(key, inflight);
+            return inflight.promise;
+        },
+        async set(key, value, options) {
+            assertIsServer(MODULE_NAME);
+            const body = JSON.stringify({ value });
+            const skipIfUnchanged = options?.skipIfUnchanged ?? config.skipIfUnchanged;
+            // Dedup against confirmed state only while no write is pending — a
+            // pending write makes the cache momentarily stale; enqueue() coalesces
+            // against pending writes instead.
+            if (skipIfUnchanged && writes.pending(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);
+            // Invalidate immediately — even while the DELETE waits behind other
+            // writes, reads must not serve the doomed value, and a stale
+            // "unchanged" skip would lose a future write.
+            cache.delete(key);
+            inflightGets.delete(key);
+            return writes.enqueue(key, null, () => executeDelete(key), true);
+        },
+        async getValues(options) {
+            assertIsServer(MODULE_NAME);
+            const { prefix, limit, offset } = options ?? {};
+            const baseUrl = await getStorageServerUrl();
+            const parts = [];
+            if (!!prefix) {
+                parts.push(`prefix=${encodeURIComponent(prefix)}`);
+            }
+            if (!!limit) {
+                parts.push(`limit=${limit}`);
+            }
+            if (!!offset) {
+                parts.push(`offset=${offset}`);
+            }
+            const query = parts.join('&');
+            const url = query ? `${baseUrl}/values?${query}` : `${baseUrl}/values`;
+            const [error, response] = await wrapSignedFetch({ url });
+            if (error) {
+                console.error(`Failed to get storage values: ${error}`);
+                return { data: [], pagination: { offset: 0, total: 0 } };
+            }
+            const data = response?.data ?? [];
+            // Seed the per-key cache so subsequent get()/set() on returned keys can
+            // skip the network. Only keys with no live entry and no pending write
+            // are seeded: existing per-key state comes from a confirmed operation
+            // that this page snapshot — whose request started earlier — must not
+            // clobber with stale data. Absence is never seeded (prefix/pagination
+            // make it non-authoritative). A page larger than cacheMaxEntries churns
+            // the cache; entries repopulate lazily.
+            for (const entry of data) {
+                if (entry.value !== undefined && !writes.isPending(entry.key) && 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 { createWriteQueue } 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   * @param key - The key to retrieve\n   * @param options - Optional { fresh } to bypass the read cache\n   * @returns A promise that resolves to the parsed JSON value, or null if not found\n   */\n  get<T = unknown>(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   */\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 A promise that resolves to true if deleted, false if not found\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   */\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: set()/delete() drop the wrapper, detaching the pending GET so\n  // its stale response cannot overwrite the newer cache entry.\n  const inflightGets = new Map<string, { promise: Promise<unknown> }>()\n  // 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    const baseUrl = await getStorageServerUrl()\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      console.error(`Failed to set storage value '${key}': ${error}`)\n      return false\n    }\n\n    cache.set(key, { body })\n    return true\n  }\n\n  async function executeDelete(key: string): Promise<boolean> {\n    const baseUrl = await getStorageServerUrl()\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) cache.setAbsent(key)\n      console.error(`Failed to delete storage value '${key}': ${error}`)\n      return false\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\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          const baseUrl = await getStorageServerUrl()\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            console.error(`Failed to get storage value '${key}': ${error}`)\n            return null\n          }\n\n          if (data && data.value !== undefined) {\n            // Same serialization shape as set()'s PUT body, so a read followed by\n            // an unchanged write can be skipped.\n            const body = JSON.stringify({ value: data.value })\n            if (isOwner) cache.set(key, { body })\n            return data.value\n          }\n\n          // 200 with a missing value is ambiguous: neither a confirmed value\n          // nor a confirmed absence, so cache nothing.\n          return null\n        } finally {\n          if (inflightGets.get(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\n      const body = JSON.stringify({ value })\n      const skipIfUnchanged = options?.skipIfUnchanged ?? config.skipIfUnchanged\n\n      // Dedup against confirmed state only while no write is pending — a\n      // pending write makes the cache momentarily stale; enqueue() coalesces\n      // against pending writes instead.\n      if (skipIfUnchanged && writes.pending(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\n      // Invalidate immediately — even while the DELETE waits behind other\n      // writes, reads must not serve the doomed value, and a stale\n      // \"unchanged\" skip would lose a future write.\n      cache.delete(key)\n      inflightGets.delete(key)\n\n      return writes.enqueue(key, null, () => executeDelete(key), true)\n    },\n\n    async getValues(options?: GetValuesOptions): Promise<GetValuesResult> {\n      assertIsServer(MODULE_NAME)\n\n      const { prefix, limit, offset } = options ?? {}\n      const baseUrl = await getStorageServerUrl()\n      const parts: string[] = []\n\n      if (!!prefix) {\n        parts.push(`prefix=${encodeURIComponent(prefix)}`)\n      }\n\n      if (!!limit) {\n        parts.push(`limit=${limit}`)\n      }\n\n      if (!!offset) {\n        parts.push(`offset=${offset}`)\n      }\n\n      const query = parts.join('&')\n      const url = query ? `${baseUrl}/values?${query}` : `${baseUrl}/values`\n\n      const [error, response] = await wrapSignedFetch<GetValuesResult>({ url })\n\n      if (error) {\n        console.error(`Failed to get storage values: ${error}`)\n        return { data: [], pagination: { offset: 0, total: 0 } }\n      }\n\n      const data = response?.data ?? []\n\n      // Seed the per-key cache so subsequent get()/set() on returned keys can\n      // skip the network. Only keys with no live entry and no pending write\n      // are seeded: existing per-key state comes from a confirmed operation\n      // that this page snapshot — whose request started earlier — must not\n      // clobber with stale data. Absence is never seeded (prefix/pagination\n      // make it non-authoritative). A page larger than cacheMaxEntries churns\n      // the cache; entries repopulate lazily.\n      for (const entry of data) {\n        if (entry.value !== undefined && !writes.isPending(entry.key) && 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/value-cache.d.ts

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

package/server/storage/value-cache.js

@@ -0,0 +1,52 @@
+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();
+    function insert(key, entry) {
+        // 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.isFinite(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.isFinite(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) {
+            entries.delete(key);
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/server/storage/write-queue.js

@@ -0,0 +1,71 @@
+/**
+ * Creates the per-key write serializer shared by a storage scope.
+ * @internal
+ */
+export function createWriteQueue() {
+    const keys = new Map();
+    function makeOp(body, execute) {
+        let resolve;
+        const promise = new Promise((r) => (resolve = r));
+        return { body, execute, promise, resolve };
+    }
+    async function drain(key, state) {
+        for (;;) {
+            const op = state.active;
+            let result = false;
+            try {
+                result = await op.execute(op.body);
+            }
+            catch {
+                // Executors report failures via their boolean result; a throw is
+                // unexpected but must not wedge the queue.
+            }
+            op.resolve(result);
+            if (state.queued) {
+                state.active = state.queued;
+                state.queued = undefined;
+            }
+            else {
+                keys.delete(key);
+                return;
+            }
+        }
+    }
+    return {
+        pending(key) {
+            const state = keys.get(key);
+            if (!state)
+                return undefined;
+            return (state.queued ?? state.active).body;
+        },
+        isPending(key) {
+            return keys.has(key);
+        },
+        enqueue(key, body, execute, joinActive) {
+            const state = keys.get(key);
+            if (!state) {
+                const op = makeOp(body, execute);
+                const newState = { active: op };
+                keys.set(key, newState);
+                void drain(key, newState);
+                return op.promise;
+            }
+            if (state.queued) {
+                // A queued op has not started, so it is issued "after" this caller
+                // either way: join it when identical, supersede it otherwise.
+                if (state.queued.body !== body) {
+                    state.queued.body = body;
+                    state.queued.execute = execute;
+                }
+                return state.queued.promise;
+            }
+            if (joinActive && state.active.body === body) {
+                return state.active.promise;
+            }
+            const op = makeOp(body, execute);
+            state.queued = op;
+            return op.promise;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"write-queue.js","sourceRoot":"","sources":["../../src/server/storage/write-queue.ts"],"names":[],"mappings":"AAsDA;;;GAGG;AACH,MAAM,UAAU,gBAAgB;IAC9B,MAAM,IAAI,GAAG,IAAI,GAAG,EAAoB,CAAA;IAExC,SAAS,MAAM,CAAC,IAAmB,EAAE,OAA6B;QAChE,IAAI,OAAmC,CAAA;QACvC,MAAM,OAAO,GAAG,IAAI,OAAO,CAAU,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAA;QAC1D,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAA;IAC5C,CAAC;IAED,KAAK,UAAU,KAAK,CAAC,GAAW,EAAE,KAAe;QAC/C,SAAS;YACP,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAA;YACvB,IAAI,MAAM,GAAG,KAAK,CAAA;YAClB,IAAI;gBACF,MAAM,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,CAAA;aACnC;YAAC,MAAM;gBACN,iEAAiE;gBACjE,2CAA2C;aAC5C;YACD,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;YAElB,IAAI,KAAK,CAAC,MAAM,EAAE;gBAChB,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAA;gBAC3B,KAAK,CAAC,MAAM,GAAG,SAAS,CAAA;aACzB;iBAAM;gBACL,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;gBAChB,OAAM;aACP;SACF;IACH,CAAC;IAED,OAAO;QACL,OAAO,CAAC,GAAW;YACjB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;YAC3B,IAAI,CAAC,KAAK;gBAAE,OAAO,SAAS,CAAA;YAC5B,OAAO,CAAC,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAA;QAC5C,CAAC;QAED,SAAS,CAAC,GAAW;YACnB,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QACtB,CAAC;QAED,OAAO,CAAC,GAAW,EAAE,IAAmB,EAAE,OAA6B,EAAE,UAAmB;YAC1F,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;YAE3B,IAAI,CAAC,KAAK,EAAE;gBACV,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;gBAChC,MAAM,QAAQ,GAAa,EAAE,MAAM,EAAE,EAAE,EAAE,CAAA;gBACzC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;gBACvB,KAAK,KAAK,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;gBACzB,OAAO,EAAE,CAAC,OAAO,CAAA;aAClB;YAED,IAAI,KAAK,CAAC,MAAM,EAAE;gBAChB,mEAAmE;gBACnE,8DAA8D;gBAC9D,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE;oBAC9B,KAAK,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,CAAA;oBACxB,KAAK,CAAC,MAAM,CAAC,OAAO,GAAG,OAAO,CAAA;iBAC/B;gBACD,OAAO,KAAK,CAAC,MAAM,CAAC,OAAO,CAAA;aAC5B;YAED,IAAI,UAAU,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE;gBAC5C,OAAO,KAAK,CAAC,MAAM,CAAC,OAAO,CAAA;aAC5B;YAED,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;YAChC,KAAK,CAAC,MAAM,GAAG,EAAE,CAAA;YACjB,OAAO,EAAE,CAAC,OAAO,CAAA;QACnB,CAAC;KACF,CAAA;AACH,CAAC","sourcesContent":["/**\n * A pending write operation. `body` is the serialized PUT payload, or null\n * for a DELETE. Callers coalesced into the op share its promise.\n * @internal\n */\ninterface PendingOp {\n  body: string | null\n  execute: (body: string | null) => Promise<boolean>\n  promise: Promise<boolean>\n  resolve: (result: boolean) => void\n}\n\ninterface KeyState {\n  /** The op currently on the network. */\n  active: PendingOp\n  /** At most one queued op; later writes replace its payload (latest wins). */\n  queued?: PendingOp\n}\n\n/**\n * Serializes writes per key so the service commits them in issue order.\n * Overlapping PUTs from the single scene server would otherwise race: the\n * server keeps whichever request it processes last, while the local cache\n * keeps whichever response arrives last — either can disagree with the last\n * set() issued. With at most one in-flight op per key and a single queued\n * \"latest value\" slot, the server's final state always matches the last\n * write issued, and N rapid writes collapse into at most 2 network calls.\n * @internal\n */\nexport interface WriteQueue {\n  /**\n   * Body of the latest issued write for the key (the queued op if present,\n   * else the in-flight one): a string for a PUT, null for a DELETE,\n   * undefined when no write is pending.\n   */\n  pending(key: string): string | null | undefined\n  /** True while any write for the key is in flight or queued. */\n  isPending(key: string): boolean\n  /**\n   * Issues a write. If one is in flight, the new op is queued — replacing any\n   * already-queued op, whose callers then follow this op's outcome (their\n   * value was superseded before it could ever be observed). An op identical\n   * to the queued one joins it; `joinActive` additionally allows joining an\n   * identical in-flight op (only valid for dedup-tolerant callers, since that\n   * op was issued before this call).\n   */\n  enqueue(\n    key: string,\n    body: string | null,\n    execute: (body: string | null) => Promise<boolean>,\n    joinActive: boolean\n  ): Promise<boolean>\n}\n\n/**\n * Creates the per-key write serializer shared by a storage scope.\n * @internal\n */\nexport function createWriteQueue(): WriteQueue {\n  const keys = new Map<string, KeyState>()\n\n  function makeOp(body: string | null, execute: PendingOp['execute']): PendingOp {\n    let resolve!: (result: boolean) => void\n    const promise = new Promise<boolean>((r) => (resolve = r))\n    return { body, execute, promise, resolve }\n  }\n\n  async function drain(key: string, state: KeyState): Promise<void> {\n    for (;;) {\n      const op = state.active\n      let result = false\n      try {\n        result = await op.execute(op.body)\n      } catch {\n        // Executors report failures via their boolean result; a throw is\n        // unexpected but must not wedge the queue.\n      }\n      op.resolve(result)\n\n      if (state.queued) {\n        state.active = state.queued\n        state.queued = undefined\n      } else {\n        keys.delete(key)\n        return\n      }\n    }\n  }\n\n  return {\n    pending(key: string): string | null | undefined {\n      const state = keys.get(key)\n      if (!state) return undefined\n      return (state.queued ?? state.active).body\n    },\n\n    isPending(key: string): boolean {\n      return keys.has(key)\n    },\n\n    enqueue(key: string, body: string | null, execute: PendingOp['execute'], joinActive: boolean): Promise<boolean> {\n      const state = keys.get(key)\n\n      if (!state) {\n        const op = makeOp(body, execute)\n        const newState: KeyState = { active: op }\n        keys.set(key, newState)\n        void drain(key, newState)\n        return op.promise\n      }\n\n      if (state.queued) {\n        // A queued op has not started, so it is issued \"after\" this caller\n        // either way: join it when identical, supersede it otherwise.\n        if (state.queued.body !== body) {\n          state.queued.body = body\n          state.queued.execute = execute\n        }\n        return state.queued.promise\n      }\n\n      if (joinActive && state.active.body === body) {\n        return state.active.promise\n      }\n\n      const op = makeOp(body, execute)\n      state.queued = op\n      return op.promise\n    }\n  }\n}\n"]}

package/server/storage-url.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Determines the correct storage server URL based on the current realm.
+ *
+ * - If `isPreview` is true, uses the realm's baseUrl (localhost)
+ * - If the realm's baseUrl contains `.zone`, uses storage.decentraland.zone
+ * - Otherwise, uses storage.decentraland.org (production)
+ *
+ * The realm never changes mid-session, so the result is memoized; a failed
+ * resolution is not memoized so transient getRealm errors can be retried.
+ *
+ * @returns The storage server base URL
+ */
+export declare function getStorageServerUrl(): Promise<string>;

package/server/storage-url.js

@@ -0,0 +1,42 @@
+import { getRealm } from '~system/Runtime';
+const STORAGE_SERVER_ORG = 'https://storage.decentraland.org';
+const STORAGE_SERVER_ZONE = 'https://storage.decentraland.zone';
+async function resolveStorageServerUrl() {
+    const { realmInfo } = await getRealm({});
+    if (!realmInfo) {
+        throw new Error('Unable to retrieve realm information');
+    }
+    // Local development / preview mode
+    if (realmInfo.isPreview) {
+        return realmInfo.baseUrl;
+    }
+    // Staging / testing environment
+    if (realmInfo.baseUrl.includes('.zone')) {
+        return STORAGE_SERVER_ZONE;
+    }
+    // Production environment
+    return STORAGE_SERVER_ORG;
+}
+let memoizedUrl = null;
+/**
+ * Determines the correct storage server URL based on the current realm.
+ *
+ * - If `isPreview` is true, uses the realm's baseUrl (localhost)
+ * - If the realm's baseUrl contains `.zone`, uses storage.decentraland.zone
+ * - Otherwise, uses storage.decentraland.org (production)
+ *
+ * The realm never changes mid-session, so the result is memoized; a failed
+ * resolution is not memoized so transient getRealm errors can be retried.
+ *
+ * @returns The storage server base URL
+ */
+export function getStorageServerUrl() {
+    if (!memoizedUrl) {
+        memoizedUrl = resolveStorageServerUrl();
+        memoizedUrl.catch(() => {
+            memoizedUrl = null;
+        });
+    }
+    return memoizedUrl;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/server/utils.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="@dcl/js-runtime" />
+import { SignedFetchRequest } from '~system/SignedFetch';
+/**
+ * Validates that the code is running on a server-side scene.
+ * Throws an error if called from a client-side context.
+ *
+ * @param moduleName - The name of the module for the error message
+ * @throws Error if not running on a server-side scene
+ */
+export declare function assertIsServer(moduleName: string): void;
+/**
+ * Result type for operations that can fail.
+ * Returns a tuple of [error, null] on failure or [null, data] on success.
+ */
+export type Result<T, E = string> = [E, null] | [null, T];
+/**
+ * Extended result type that includes HTTP status code information.
+ */
+export type FetchResult<T> = [string, null, number?] | [null, T, number];
+/**
+ * Wraps a promise to catch errors and return a Result tuple.
+ * This allows for cleaner error handling without try-catch blocks.
+ *
+ * @param promise - The promise to wrap
+ * @returns A tuple of [error, null] on failure or [null, data] on success
+ */
+export declare function tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>>;
+/**
+ * Wraps signedFetch with automatic error handling and JSON parsing.
+ * Returns a FetchResult tuple with parsed JSON data or error message and status code.
+ *
+ * @param signedFetchBody - The signedFetch request configuration
+ * @returns A tuple of [error, null, statusCode?] on failure or [null, data, statusCode] on success
+ */
+export declare function wrapSignedFetch<T = unknown>(signedFetchBody: SignedFetchRequest): Promise<FetchResult<T>>;

package/server/utils.js

@@ -0,0 +1,61 @@
+import { signedFetch } from '~system/SignedFetch';
+import { isServer } from '../network';
+/**
+ * Validates that the code is running on a server-side scene.
+ * Throws an error if called from a client-side context.
+ *
+ * @param moduleName - The name of the module for the error message
+ * @throws Error if not running on a server-side scene
+ */
+export function assertIsServer(moduleName) {
+    if (!isServer()) {
+        throw new Error(`${moduleName} is only available on server-side scenes`);
+    }
+}
+/**
+ * Wraps a promise to catch errors and return a Result tuple.
+ * This allows for cleaner error handling without try-catch blocks.
+ *
+ * @param promise - The promise to wrap
+ * @returns A tuple of [error, null] on failure or [null, data] on success
+ */
+export async function tryCatch(promise) {
+    try {
+        const data = await promise;
+        return [null, data];
+    }
+    catch (error) {
+        return [error, null];
+    }
+}
+/**
+ * Wraps signedFetch with automatic error handling and JSON parsing.
+ * Returns a FetchResult tuple with parsed JSON data or error message and status code.
+ *
+ * @param signedFetchBody - The signedFetch request configuration
+ * @returns A tuple of [error, null, statusCode?] on failure or [null, data, statusCode] on success
+ */
+export async function wrapSignedFetch(signedFetchBody) {
+    const [error, response] = await tryCatch(signedFetch(signedFetchBody));
+    if (error) {
+        console.error(`Error in ${signedFetchBody.url} endpoint`, { error });
+        return [error.message, null, undefined];
+    }
+    if (!response.ok) {
+        const errorMessage = `${response.status} ${response.statusText}`;
+        console.error(`Error in ${signedFetchBody.url} endpoint`, { response });
+        return [errorMessage, null, response.status];
+    }
+    let body;
+    try {
+        // JSON.parse throws synchronously, so it can't be wrapped with tryCatch (the
+        // throw would happen while evaluating the argument, rejecting this promise).
+        body = JSON.parse(response.body || '{}');
+    }
+    catch {
+        console.error(`Failed to parse response from ${signedFetchBody.url}`);
+        return ['Failed to parse response', null, response.status];
+    }
+    return [null, (body ?? {}), response.status];
+}
+//# sourceMappingURL=data:application/json;base64,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