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

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 {};

package/server/storage/write-queue.js

@@ -0,0 +1,113 @@
+/**
+ * Rejection of a superseded delete when the write that replaced it did not apply.
+ * @internal
+ */
+export class SupersedingWriteFailed extends Error {
+    constructor() {
+        super('a write that replaced it did not apply');
+        this.name = 'SupersedingWriteFailed';
+    }
+}
+/**
+ * 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;
+        let reject;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        return { body, execute, promise, resolve, reject };
+    }
+    /**
+     * A replaced op resolves true when its replacement lands. On failure a set
+     * resolves false and a delete rejects, in its own terms.
+     */
+    function settleSuperseded(superseded, by) {
+        by.promise.then((result) => {
+            const applied = by.body === null || result;
+            if (superseded.body !== null)
+                superseded.resolve(applied);
+            else if (applied)
+                superseded.resolve(true);
+            else
+                superseded.reject(new SupersedingWriteFailed());
+        }, (error) => {
+            if (superseded.body === null)
+                superseded.reject(error);
+            else
+                superseded.resolve(false);
+        });
+    }
+    async function drain(key, state) {
+        for (;;) {
+            const op = state.active;
+            try {
+                op.resolve(await op.execute(op.body));
+            }
+            catch (error) {
+                op.reject(error);
+            }
+            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);
+        },
+        async settled(key) {
+            const state = keys.get(key);
+            if (!state)
+                return;
+            const hadQueued = state.queued !== undefined;
+            await state.active.promise.catch(() => undefined);
+            // drain() promotes the queued op (or its replacement) in place before this resumes.
+            if (hadQueued)
+                await state.active.promise.catch(() => undefined);
+        },
+        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)
+                    return state.queued.promise;
+                const op = makeOp(body, execute);
+                settleSuperseded(state.queued, op);
+                state.queued = op;
+                return op.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":"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","sourcesContent":["/**\n * Rejection of a superseded delete when the write that replaced it did not apply.\n * @internal\n */\nexport class SupersedingWriteFailed extends Error {\n  constructor() {\n    super('a write that replaced it did not apply')\n    this.name = 'SupersedingWriteFailed'\n  }\n}\n\n/**\n * A pending write operation. `body` is the serialized PUT payload, or null\n * for a DELETE. Callers that join the op share its promise.\n */\ninterface PendingOp {\n  body: string | null\n  execute: (body: string | null) => Promise<boolean>\n  promise: Promise<boolean>\n  resolve: (result: boolean) => void\n  reject: (error: unknown) => void\n}\n\ninterface KeyState {\n  /** The op currently on the network. */\n  active: PendingOp\n  /** At most one queued op; a later write replaces it (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   * Resolves once the in-flight op settles and, if one was queued at call time,\n   * the op that runs next. At most two, so writes cannot starve a waiter. Never rejects.\n   */\n  settled(key: string): Promise<void>\n  /**\n   * Issues a write, queued behind any in-flight one and replacing any queued one\n   * (see settleSuperseded). An identical queued op is joined; `joinActive` also\n   * joins an identical in-flight op, which only dedup-tolerant callers may do.\n   * Rejects with the executor's error; see settleSuperseded for replaced ops.\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    let reject!: (error: unknown) => void\n    const promise = new Promise<boolean>((res, rej) => {\n      resolve = res\n      reject = rej\n    })\n    return { body, execute, promise, resolve, reject }\n  }\n\n  /**\n   * A replaced op resolves true when its replacement lands. On failure a set\n   * resolves false and a delete rejects, in its own terms.\n   */\n  function settleSuperseded(superseded: PendingOp, by: PendingOp): void {\n    by.promise.then(\n      (result) => {\n        const applied = by.body === null || result\n        if (superseded.body !== null) superseded.resolve(applied)\n        else if (applied) superseded.resolve(true)\n        else superseded.reject(new SupersedingWriteFailed())\n      },\n      (error) => {\n        if (superseded.body === null) superseded.reject(error)\n        else superseded.resolve(false)\n      }\n    )\n  }\n\n  async function drain(key: string, state: KeyState): Promise<void> {\n    for (;;) {\n      const op = state.active\n      try {\n        op.resolve(await op.execute(op.body))\n      } catch (error) {\n        op.reject(error)\n      }\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    async settled(key: string): Promise<void> {\n      const state = keys.get(key)\n      if (!state) return\n      const hadQueued = state.queued !== undefined\n      await state.active.promise.catch(() => undefined)\n      // drain() promotes the queued op (or its replacement) in place before this resumes.\n      if (hadQueued) await state.active.promise.catch(() => undefined)\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) return state.queued.promise\n        const op = makeOp(body, execute)\n        settleSuperseded(state.queued, op)\n        state.queued = op\n        return op.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. Never rejects.
+ * 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,69 @@
+import { signedFetch } from '~system/SignedFetch';
+import { isServer } from '../network';
+import { errorMessage } from './storage/error-message';
+/**
+ * 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. Never rejects.
+ * 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) {
+    let response;
+    try {
+        response = await signedFetch(signedFetchBody);
+    }
+    catch (error) {
+        console.error(`Error in ${signedFetchBody.url} endpoint`, { error });
+        return [errorMessage(error, 'signedFetch failed'), null, undefined];
+    }
+    if (!response) {
+        console.error(`Error in ${signedFetchBody.url} endpoint: no response`);
+        return ['signedFetch returned no response', 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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