@dcl/sdk 7.29.1-35901015152.commit-d1b7b96 → 7.29.1-36041177279.commit-502e633

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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

package/src/atom.ts

@@ -0,0 +1,98 @@
+import future, { IFuture } from './future'
+
+// atom value wrapper like in clojure
+
+// Simple Observable implementation to replace Babylon.js dependency
+class SimpleObservable<T> {
+  private observers: ((value: T) => void)[] = []
+  private onceObservers: ((value: T) => void)[] = []
+
+  add(callback: (value: T) => void): (value: T) => void {
+    this.observers.push(callback)
+    return callback
+  }
+
+  addOnce(callback: (value: T) => void): void {
+    this.onceObservers.push(callback)
+  }
+
+  remove(callback: (value: T) => void): void {
+    const index = this.observers.indexOf(callback)
+    if (index > -1) {
+      this.observers.splice(index, 1)
+    }
+  }
+
+  notifyObservers(value: T): void {
+    this.observers.forEach((observer) => observer(value))
+
+    if (this.onceObservers.length > 0) {
+      this.onceObservers.forEach((observer) => observer(value))
+      this.onceObservers.length = 0
+    }
+  }
+}
+
+const EMPTY = Symbol('empty')
+type EMPTY = typeof EMPTY
+
+export type Atom<T> = {
+  deref(): Promise<T>
+  getOrNull(): T | null
+  observable: SimpleObservable<T>
+  swap(value: T): T | void
+  pipe(fn: (value: T) => void | Promise<void>): Promise<void>
+}
+
+export function Atom<T>(initialValue: T | EMPTY = EMPTY): Atom<T> {
+  const observable = new SimpleObservable<T>()
+  let value: T | EMPTY = initialValue
+  const valueFutures: IFuture<T>[] = []
+
+  observable.addOnce((value) => {
+    valueFutures.forEach(($) => $.resolve(value))
+    valueFutures.length = 0
+  })
+
+  return {
+    async pipe(fn) {
+      observable.add(async (t) => {
+        try {
+          await fn(t)
+        } catch (err) {
+          console.error(err)
+        }
+      })
+      if (value !== EMPTY) {
+        try {
+          await fn(value)
+        } catch (err) {
+          console.error(err)
+        }
+      }
+    },
+    deref() {
+      if (value === EMPTY) {
+        const ret = future<T>()
+        valueFutures.push(ret)
+        return ret
+      }
+      return Promise.resolve(value)
+    },
+    getOrNull() {
+      if (value === EMPTY) {
+        return null
+      }
+      return value
+    },
+    observable,
+    swap(newValue) {
+      const oldValue = value
+      if (newValue !== value) {
+        value = newValue
+        observable.notifyObservers(value)
+      }
+      return oldValue === EMPTY ? undefined : oldValue
+    }
+  }
+}

package/src/future.ts

@@ -0,0 +1,38 @@
+export type IFuture<T> = Promise<T> & {
+  resolve: (x: T) => void
+  reject: (x: Error) => void
+  finally: (fn: () => void) => void
+  isPending: boolean
+}
+
+export function future<T = any>(): IFuture<T> {
+  let resolver: (x: T) => void
+  let rejecter: (x: Error) => void
+
+  const promise: any = new Promise((ok, err) => {
+    resolver = (x: T) => {
+      ok(x)
+      promise.isPending = false
+    }
+    rejecter = (x: Error) => {
+      err(x)
+      promise.isPending = false
+    }
+  }).catch((e) => Promise.reject(e))
+
+  promise.resolve = resolver!
+  promise.reject = rejecter!
+
+  if (!('finally' in promise)) {
+    promise.finally = (fn: any) => {
+      promise.then(fn)
+      promise.catch(fn)
+    }
+  }
+
+  promise.isPending = true
+
+  return promise as IFuture<T>
+}
+
+export default future

package/src/internal/language-events.ts

@@ -0,0 +1,8 @@
+import { Observable } from './Observable'
+
+/**
+ * @internal
+ * Raw `localeChanged` events drained from the renderer by `pollEvents`.
+ * Kept side-effect free so `observables` doesn't load `platform` for every scene.
+ */
+export const localeChangedEvents = new Observable<{ locale: string }>()

package/src/internal/transports/rendererTransport.ts

@@ -41,7 +41,10 @@ export function createRendererTransport(engineApi: EngineApiForTransport): Trans
       }
       return !!message
     },
-    type: 'renderer'
+    type: 'renderer',
+    // The renderer/host is the authority for reserved-range entities (avatars,
+    // root/player/camera): it is the only transport allowed to mutate or delete them.
+    allowReservedEntities: true
   }
 
   return rendererTransport

package/src/network/binary-message-bus.ts

@@ -1,9 +1,12 @@
 import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer'
 
 export enum CommsMessage {
-  CRDT = 1,
-  REQ_CRDT_STATE = 2,
-  RES_CRDT_STATE = 3
+  CRDT = 7,
+  REQ_CRDT_STATE = 8,
+  RES_CRDT_STATE = 9,
+  CRDT_SERVER = 4,
+  CRDT_AUTHORITATIVE = 5,
+  CUSTOM_EVENT = 6
 }
 
 export function BinaryMessageBus<T extends CommsMessage>(
@@ -20,7 +23,9 @@ export function BinaryMessageBus<T extends CommsMessage>(
     __processMessages: (messages: Uint8Array[]) => {
       for (const message of messages) {
         const commsMsg = decodeCommsMessage<T>(message)
-        if (!commsMsg) continue
+        if (!commsMsg) {
+          continue
+        }
         const { sender, messageType, data } = commsMsg
         const fn = mapping.get(messageType)
         if (fn) fn(data, sender)

package/src/network/chunking.ts

@@ -0,0 +1,45 @@
+import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer'
+import { readMessages } from './server/utils'
+
+/**
+ * Chunks CRDT messages from a Uint8Array buffer, respecting message boundaries
+ * Uses the comprehensive readMessages function that handles all message types
+ */
+export function chunkCrdtMessages(data: Uint8Array, maxSizeKB: number = 12): Uint8Array[] {
+  if (data.length === 0) {
+    return []
+  }
+
+  const networkBuffer = new ReadWriteByteBuffer()
+  const chunks: Uint8Array[] = []
+
+  for (const message of readMessages(data)) {
+    // Check if adding this message would exceed the size limit
+    const currentBufferSize = networkBuffer.toBinary().byteLength
+    const messageSize = message.messageBuffer.byteLength
+
+    if ((currentBufferSize + messageSize) / 1024 > maxSizeKB) {
+      // If the current buffer has content, save it as a chunk
+      if (currentBufferSize > 0) {
+        chunks.push(networkBuffer.toCopiedBinary())
+        networkBuffer.resetBuffer()
+      }
+
+      // If the message itself is larger than the limit, skip it
+      if (messageSize / 1024 > maxSizeKB) {
+        console.error(`Message too large (${messageSize} bytes), skipping CRDT message`)
+        continue
+      }
+    }
+
+    // Add message to current buffer
+    networkBuffer.writeBuffer(message.messageBuffer, false)
+  }
+
+  // Add any remaining data as the final chunk
+  if (networkBuffer.currentWriteOffset() > 0) {
+    chunks.push(networkBuffer.toBinary())
+  }
+
+  return chunks
+}