@dcl/sdk 7.26.1-32785242405.commit-c8d1817 → 7.26.1-32860802198.commit-dae48fb

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

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/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
+}