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

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

@@ -0,0 +1,92 @@
+import { DEFAULT_STORAGE_CONFIG, StorageConfigState } from './constants'
+
+/**
+ * A cached fact about a key's server-side state.
+ * @internal
+ */
+export interface CacheEntry {
+  /**
+   * Serialized `{ value }` body; absent for negative entries. Parsed per read
+   * hit so callers never share object references, and compared verbatim for
+   * write dedup (exact equality — no hash-collision risk).
+   */
+  body?: string
+  /** True when the server confirmed the key does not exist (GET 404 or successful DELETE). */
+  absent?: boolean
+}
+
+/**
+ * Bounded, lazily-expiring cache of key states, backing both write dedup
+ * (skip storage writes whose value is already known to be stored) and read
+ * caching (serve get() without a network request within the TTL).
+ * @internal
+ */
+export interface ValueCache {
+  /** Returns the entry if present and fresh; lazily evicts expired entries. */
+  get(key: string): CacheEntry | undefined
+  /** Stores or refreshes a known value (serialized body); overwrites negative entries. */
+  set(key: string, entry: { body: string }): void
+  /** Stores a confirmed-absent (negative) entry, replacing any value entry. */
+  setAbsent(key: string): void
+  delete(key: string): void
+}
+
+/**
+ * Creates the bounded value cache shared by a storage scope.
+ * @internal
+ */
+export function createValueCache(config: StorageConfigState): ValueCache {
+  const entries = new Map<string, CacheEntry & { storedAt: number }>()
+
+  function insert(key: string, entry: CacheEntry): void {
+    // 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: string): CacheEntry | undefined {
+      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: string, entry: { body: string }): void {
+      insert(key, entry)
+    },
+
+    setAbsent(key: string): void {
+      insert(key, { absent: true })
+    },
+
+    delete(key: string): void {
+      entries.delete(key)
+    }
+  }
+}

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

@@ -0,0 +1,131 @@
+/**
+ * A pending write operation. `body` is the serialized PUT payload, or null
+ * for a DELETE. Callers coalesced into the op share its promise.
+ * @internal
+ */
+interface PendingOp {
+  body: string | null
+  execute: (body: string | null) => Promise<boolean>
+  promise: Promise<boolean>
+  resolve: (result: boolean) => void
+}
+
+interface KeyState {
+  /** The op currently on the network. */
+  active: PendingOp
+  /** At most one queued op; later writes replace its payload (latest wins). */
+  queued?: PendingOp
+}
+
+/**
+ * Serializes writes per key so the service commits them in issue order.
+ * Overlapping PUTs from the single scene server would otherwise race: the
+ * server keeps whichever request it processes last, while the local cache
+ * keeps whichever response arrives last — either can disagree with the last
+ * set() issued. With at most one in-flight op per key and a single queued
+ * "latest value" slot, the server's final state always matches the last
+ * write issued, and N rapid writes collapse into at most 2 network calls.
+ * @internal
+ */
+export interface WriteQueue {
+  /**
+   * Body of the latest issued write for the key (the queued op if present,
+   * else the in-flight one): a string for a PUT, null for a DELETE,
+   * undefined when no write is pending.
+   */
+  pending(key: string): string | null | undefined
+  /** True while any write for the key is in flight or queued. */
+  isPending(key: string): boolean
+  /**
+   * Issues a write. If one is in flight, the new op is queued — replacing any
+   * already-queued op, whose callers then follow this op's outcome (their
+   * value was superseded before it could ever be observed). An op identical
+   * to the queued one joins it; `joinActive` additionally allows joining an
+   * identical in-flight op (only valid for dedup-tolerant callers, since that
+   * op was issued before this call).
+   */
+  enqueue(
+    key: string,
+    body: string | null,
+    execute: (body: string | null) => Promise<boolean>,
+    joinActive: boolean
+  ): Promise<boolean>
+}
+
+/**
+ * Creates the per-key write serializer shared by a storage scope.
+ * @internal
+ */
+export function createWriteQueue(): WriteQueue {
+  const keys = new Map<string, KeyState>()
+
+  function makeOp(body: string | null, execute: PendingOp['execute']): PendingOp {
+    let resolve!: (result: boolean) => void
+    const promise = new Promise<boolean>((r) => (resolve = r))
+    return { body, execute, promise, resolve }
+  }
+
+  async function drain(key: string, state: KeyState): Promise<void> {
+    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: string): string | null | undefined {
+      const state = keys.get(key)
+      if (!state) return undefined
+      return (state.queued ?? state.active).body
+    },
+
+    isPending(key: string): boolean {
+      return keys.has(key)
+    },
+
+    enqueue(key: string, body: string | null, execute: PendingOp['execute'], joinActive: boolean): Promise<boolean> {
+      const state = keys.get(key)
+
+      if (!state) {
+        const op = makeOp(body, execute)
+        const newState: KeyState = { 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
+    }
+  }
+}

package/src/server/storage-url.ts

@@ -0,0 +1,49 @@
+import { getRealm } from '~system/Runtime'
+
+const STORAGE_SERVER_ORG = 'https://storage.decentraland.org'
+const STORAGE_SERVER_ZONE = 'https://storage.decentraland.zone'
+
+async function resolveStorageServerUrl(): Promise<string> {
+  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: Promise<string> | null = 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(): Promise<string> {
+  if (!memoizedUrl) {
+    memoizedUrl = resolveStorageServerUrl()
+    memoizedUrl.catch(() => {
+      memoizedUrl = null
+    })
+  }
+  return memoizedUrl
+}

package/src/server/utils.ts

@@ -0,0 +1,76 @@
+import { signedFetch, SignedFetchRequest } 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: string): void {
+  if (!isServer()) {
+    throw new Error(`${moduleName} is only available on server-side scenes`)
+  }
+}
+
+/**
+ * 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 async function tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>> {
+  try {
+    const data = await promise
+    return [null, data]
+  } catch (error) {
+    return [error as E, 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<T = unknown>(signedFetchBody: SignedFetchRequest): Promise<FetchResult<T>> {
+  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: T
+  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 ?? {}) as T, response.status]
+}

package/src/text-codec.ts

@@ -1,70 +1,23 @@
+import TextEncodingPolyfill from 'text-encoding'
 import { setGlobalPolyfill } from '@dcl/ecs'
-import { decodeUtf8, encodeUtf8, encodeUtf8Into } from './internal/utf8'
 
 /**
- * WHATWG-shaped `TextEncoder` / `TextDecoder` over the SDK's own UTF-8 codec.
+ * Install the `TextEncoder` / `TextDecoder` polyfill on `globalThis`.
  *
- * UTF-8 is the only supported encoding: the decoder throws a `RangeError` for
- * any other label instead of silently mis-decoding, and rejects `{ stream: true }`.
- */
-
-// Labels the WHATWG Encoding Standard maps to utf-8.
-const UTF8_LABELS = ['unicode-1-1-utf-8', 'unicode11utf8', 'unicode20utf8', 'utf-8', 'utf8', 'x-unicode20utf8']
-
-function toUint8Array(input?: ArrayBuffer | ArrayBufferView): Uint8Array {
-  if (input === undefined) return new Uint8Array(0)
-  if (input instanceof Uint8Array) return input
-  if (ArrayBuffer.isView(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength)
-  return new Uint8Array(input)
-}
-
-export class TextEncoder {
-  readonly encoding = 'utf-8'
-
-  encode(input: string = ''): Uint8Array {
-    return encodeUtf8(String(input))
-  }
-
-  encodeInto(source: string, destination: Uint8Array): { read: number; written: number } {
-    return encodeUtf8Into(String(source), destination)
-  }
-}
-
-export class TextDecoder {
-  readonly encoding = 'utf-8'
-  readonly fatal: boolean
-  readonly ignoreBOM: boolean
-
-  constructor(label: string = 'utf-8', options: { fatal?: boolean; ignoreBOM?: boolean } = {}) {
-    // the spec strips ASCII whitespace only, so String.prototype.trim is too wide
-    const normalized = String(label)
-      .replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, '')
-      .toLowerCase()
-    if (!UTF8_LABELS.includes(normalized)) {
-      throw new RangeError(`TextDecoder: only utf-8 is supported, got "${label}"`)
-    }
-    this.fatal = options.fatal === true
-    this.ignoreBOM = options.ignoreBOM === true
-  }
-
-  decode(input?: ArrayBuffer | ArrayBufferView, options: { stream?: boolean } = {}): string {
-    if (options.stream) throw new TypeError('TextDecoder: streaming is not supported')
-    return decodeUtf8(toUint8Array(input), { fatal: this.fatal, ignoreBOM: this.ignoreBOM })
-  }
-}
-
-/**
- * Install `TextEncoder` / `TextDecoder` on `globalThis` where the runtime does
- * not provide them (native implementations always win over these polyfills).
+ * The QuickJS scene runtime ships no native `TextEncoder` / `TextDecoder`, yet
+ * `compositeProvider.loadComposite` decodes `.composite` JSON file bytes via
+ * `TextDecoder`. Callers that load composites at runtime (e.g. `@dcl/asset-packs`'
+ * `SPAWN_ENTITY`) must install this first.
  *
  * Exposed from the lean `@dcl/sdk/text-codec` subpath so consumers can install
- * the polyfill without pulling in the ethereum provider.
+ * the polyfill without pulling in the ethereum provider, and without bundling
+ * `text-encoding` into scenes that never reach this module.
  */
 // NOTE: this function mutates globalThis — it is NOT pure. Do not annotate
 // with /* @__PURE__ */; minifiers would treat the call as dead code and drop
-// the polyfill installation, breaking third-party code that relies on
-// globalThis.TextDecoder.
+// the polyfill installation, breaking runtime callers like
+// compositeProvider.loadComposite that rely on globalThis.TextDecoder.
 export function polyfillTextEncoder() {
-  setGlobalPolyfill('TextEncoder', TextEncoder)
-  setGlobalPolyfill('TextDecoder', TextDecoder)
+  setGlobalPolyfill('TextEncoder', TextEncodingPolyfill.TextEncoder)
+  setGlobalPolyfill('TextDecoder', TextEncodingPolyfill.TextDecoder)
 }

package/text-codec.d.ts

@@ -1,28 +1,13 @@
-export declare class TextEncoder {
-    readonly encoding = "utf-8";
-    encode(input?: string): Uint8Array;
-    encodeInto(source: string, destination: Uint8Array): {
-        read: number;
-        written: number;
-    };
-}
-export declare class TextDecoder {
-    readonly encoding = "utf-8";
-    readonly fatal: boolean;
-    readonly ignoreBOM: boolean;
-    constructor(label?: string, options?: {
-        fatal?: boolean;
-        ignoreBOM?: boolean;
-    });
-    decode(input?: ArrayBuffer | ArrayBufferView, options?: {
-        stream?: boolean;
-    }): string;
-}
 /**
- * Install `TextEncoder` / `TextDecoder` on `globalThis` where the runtime does
- * not provide them (native implementations always win over these polyfills).
+ * Install the `TextEncoder` / `TextDecoder` polyfill on `globalThis`.
+ *
+ * The QuickJS scene runtime ships no native `TextEncoder` / `TextDecoder`, yet
+ * `compositeProvider.loadComposite` decodes `.composite` JSON file bytes via
+ * `TextDecoder`. Callers that load composites at runtime (e.g. `@dcl/asset-packs`'
+ * `SPAWN_ENTITY`) must install this first.
  *
  * Exposed from the lean `@dcl/sdk/text-codec` subpath so consumers can install
- * the polyfill without pulling in the ethereum provider.
+ * the polyfill without pulling in the ethereum provider, and without bundling
+ * `text-encoding` into scenes that never reach this module.
  */
 export declare function polyfillTextEncoder(): void;

package/text-codec.js

@@ -1,65 +1,23 @@
+import TextEncodingPolyfill from 'text-encoding';
 import { setGlobalPolyfill } from '@dcl/ecs';
-import { decodeUtf8, encodeUtf8, encodeUtf8Into } from './internal/utf8';
 /**
- * WHATWG-shaped `TextEncoder` / `TextDecoder` over the SDK's own UTF-8 codec.
+ * Install the `TextEncoder` / `TextDecoder` polyfill on `globalThis`.
  *
- * UTF-8 is the only supported encoding: the decoder throws a `RangeError` for
- * any other label instead of silently mis-decoding, and rejects `{ stream: true }`.
- */
-// Labels the WHATWG Encoding Standard maps to utf-8.
-const UTF8_LABELS = ['unicode-1-1-utf-8', 'unicode11utf8', 'unicode20utf8', 'utf-8', 'utf8', 'x-unicode20utf8'];
-function toUint8Array(input) {
-    if (input === undefined)
-        return new Uint8Array(0);
-    if (input instanceof Uint8Array)
-        return input;
-    if (ArrayBuffer.isView(input))
-        return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
-    return new Uint8Array(input);
-}
-export class TextEncoder {
-    constructor() {
-        this.encoding = 'utf-8';
-    }
-    encode(input = '') {
-        return encodeUtf8(String(input));
-    }
-    encodeInto(source, destination) {
-        return encodeUtf8Into(String(source), destination);
-    }
-}
-export class TextDecoder {
-    constructor(label = 'utf-8', options = {}) {
-        this.encoding = 'utf-8';
-        // the spec strips ASCII whitespace only, so String.prototype.trim is too wide
-        const normalized = String(label)
-            .replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, '')
-            .toLowerCase();
-        if (!UTF8_LABELS.includes(normalized)) {
-            throw new RangeError(`TextDecoder: only utf-8 is supported, got "${label}"`);
-        }
-        this.fatal = options.fatal === true;
-        this.ignoreBOM = options.ignoreBOM === true;
-    }
-    decode(input, options = {}) {
-        if (options.stream)
-            throw new TypeError('TextDecoder: streaming is not supported');
-        return decodeUtf8(toUint8Array(input), { fatal: this.fatal, ignoreBOM: this.ignoreBOM });
-    }
-}
-/**
- * Install `TextEncoder` / `TextDecoder` on `globalThis` where the runtime does
- * not provide them (native implementations always win over these polyfills).
+ * The QuickJS scene runtime ships no native `TextEncoder` / `TextDecoder`, yet
+ * `compositeProvider.loadComposite` decodes `.composite` JSON file bytes via
+ * `TextDecoder`. Callers that load composites at runtime (e.g. `@dcl/asset-packs`'
+ * `SPAWN_ENTITY`) must install this first.
  *
  * Exposed from the lean `@dcl/sdk/text-codec` subpath so consumers can install
- * the polyfill without pulling in the ethereum provider.
+ * the polyfill without pulling in the ethereum provider, and without bundling
+ * `text-encoding` into scenes that never reach this module.
  */
 // NOTE: this function mutates globalThis — it is NOT pure. Do not annotate
 // with /* @__PURE__ */; minifiers would treat the call as dead code and drop
-// the polyfill installation, breaking third-party code that relies on
-// globalThis.TextDecoder.
+// the polyfill installation, breaking runtime callers like
+// compositeProvider.loadComposite that rely on globalThis.TextDecoder.
 export function polyfillTextEncoder() {
-    setGlobalPolyfill('TextEncoder', TextEncoder);
-    setGlobalPolyfill('TextDecoder', TextDecoder);
+    setGlobalPolyfill('TextEncoder', TextEncodingPolyfill.TextEncoder);
+    setGlobalPolyfill('TextDecoder', TextEncodingPolyfill.TextDecoder);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/internal/utf8.d.ts

@@ -1,15 +0,0 @@
-/**
- * Self-contained UTF-8 codec implementing the WHATWG Encoding Standard
- * algorithms (https://encoding.spec.whatwg.org/), so SDK code never depends
- * on the host providing `TextEncoder` / `TextDecoder` globals.
- */
-export type DecodeUtf8Options = {
-    fatal?: boolean;
-    ignoreBOM?: boolean;
-};
-export declare function decodeUtf8(input: Uint8Array, options?: DecodeUtf8Options): string;
-export declare function encodeUtf8(input: string): Uint8Array;
-export declare function encodeUtf8Into(source: string, destination: Uint8Array): {
-    read: number;
-    written: number;
-};