@dcl/sdk 7.22.6-25007982108.commit-83012ab → 7.22.6-25321038582.commit-63ddb3f

package/server/utils.js

@@ -0,0 +1,56 @@
+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];
+    }
+    const [parseError, body] = await tryCatch(JSON.parse(response.body || '{}'));
+    if (parseError) {
+        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/index.ts

@@ -1,7 +1,7 @@
 /** @alpha THIS FILE INITIALIZES THE DECENTRALAND RUNTIME. WILL CHANGE SOON */
 import { Composite, engine } from '@dcl/ecs'
 import { crdtGetState, crdtSendToRenderer, sendBatch } from '~system/EngineApi'
-import { createRendererTransport, EngineApiRendererInspector } from './internal/transports/rendererTransport'
+import { createRendererTransport } from './internal/transports/rendererTransport'
 import { pollEvents } from './observables'
 import { compositeProvider } from './composite-provider'
 
@@ -21,7 +21,6 @@ export async function onUpdate(deltaTime: number) {
  * Function that is called before the first update and after the evaluation of the code.
  */
 export async function onStart() {
-  const rendererMessageInspector: EngineApiRendererInspector = (globalThis as any).rendererMessageInspector
   const response = await crdtGetState({ data: new Uint8Array() })
 
   // when this condition is true something like `main.crdt` was pre-loaded from the runtime, we don't need to instance the main.composite
@@ -39,9 +38,6 @@ export async function onStart() {
 
   if (!!rendererTransport.onmessage) {
     if (response && response.data && response.data.length) {
-      if (rendererMessageInspector) {
-        rendererMessageInspector({ message: response.data, type: 'first-receive' })
-      }
       for (const byteArray of response.data) {
         rendererTransport.onmessage(byteArray)
       }

package/src/internal/transports/rendererTransport.ts

@@ -2,29 +2,16 @@ import { Transport, TransportMessage } from '@dcl/ecs'
 import { MAX_STATIC_COMPONENT } from '@dcl/ecs/dist/components/component-number'
 import type { CrdtSendToRendererRequest, CrdtSendToResponse } from '~system/EngineApi'
 
-export type EngineApiRendererInspector =
-  | ((data: { message: Uint8Array[]; type: 'send' | 'receive' | 'first-receive' }) => void)
-  | undefined
-
 export type EngineApiForTransport = {
   crdtSendToRenderer(body: CrdtSendToRendererRequest): Promise<CrdtSendToResponse>
 }
 
 export function createRendererTransport(engineApi: EngineApiForTransport): Transport {
   async function sendToRenderer(message: Uint8Array) {
-    const rendererMessageInspector: EngineApiRendererInspector = (globalThis as any).rendererMessageInspector
-
-    if (rendererMessageInspector) {
-      rendererMessageInspector({ message: [message], type: 'send' })
-    }
     const response = await engineApi.crdtSendToRenderer({
       data: new Uint8Array(message)
     })
     if (response && response.data && response.data.length) {
-      if (rendererMessageInspector) {
-        rendererMessageInspector({ message: response.data, type: 'receive' })
-      }
-
       if (rendererTransport.onmessage) {
         for (const byteArray of response.data) {
           rendererTransport.onmessage(byteArray)

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

package/src/network/entities.ts

@@ -112,8 +112,16 @@ export function entityUtils(engine: IEngine, profile: IProfile) {
     if (!Transform.getOrNull(entity)) {
       Transform.create(entity)
     } else {
-      // We force to send a tick update of the transform so we can send the NEW parent to the renderer
-      Transform.getMutable(entity)
+      // Force a tick update of the transform so the renderer receives the NEW parent.
+      // createOrReplace bypasses the CRDT unchanged-data suppression optimization,
+      // ensuring the renderer transport can inject the network parent into the message.
+      const t = Transform.get(entity)
+      Transform.createOrReplace(entity, {
+        position: { x: t.position.x, y: t.position.y, z: t.position.z },
+        rotation: { x: t.rotation.x, y: t.rotation.y, z: t.rotation.z, w: t.rotation.w },
+        scale: { x: t.scale.x, y: t.scale.y, z: t.scale.z },
+        parent: t.parent
+      })
     }
   }
 

package/src/network/events/implementation.ts

@@ -0,0 +1,271 @@
+import { IEngine } from '@dcl/ecs'
+import { CommsMessage } from '../binary-message-bus'
+import { AUTH_SERVER_PEER_ID } from '../message-bus-sync'
+import { EventTypes, EventSchemaRegistry } from './registry'
+import { encodeEvent, decodeEvent } from './protocol'
+import { Atom } from '../../atom'
+import { future, IFuture } from '../../future'
+
+// Context provided to server-side event handlers
+export type EventContext = {
+  from: string
+}
+
+// Event callback type - server gets context, client doesn't
+export type EventCallback<T> = (data: T, context?: EventContext) => void
+
+// Options for sending events
+export type SendOptions = {
+  to?: string[] // Target specific peers (server only)
+}
+
+/**
+ * Room provides type-safe communication between clients and server
+ * Uses binary serialization with Schema definitions for efficiency
+ */
+type QueuedMessage<T extends EventSchemaRegistry = EventSchemaRegistry> = {
+  [K in keyof T]: {
+    eventType: K
+    data: EventTypes<T>[K]
+    options?: SendOptions
+  }
+}[keyof T]
+
+export class Room<T extends EventSchemaRegistry = EventSchemaRegistry> {
+  private listeners = new Map<keyof T, Set<EventCallback<any>>>()
+  private binaryMessageBus: any
+  private isServerFuture: IFuture<boolean> = future()
+  private isRoomReadyAtom: Atom<boolean>
+  private messageQueue: QueuedMessage<T>[] = []
+  private isProcessingQueue = false
+
+  constructor(_engine: IEngine, binaryMessageBus: any, isServerFn: Atom<boolean>, isRoomReadyAtom: Atom<boolean>) {
+    void isServerFn.deref().then(($) => this.isServerFuture.resolve($))
+
+    this.binaryMessageBus = binaryMessageBus
+    this.isRoomReadyAtom = isRoomReadyAtom
+
+    // Subscribe to room readiness changes to flush queue
+    this.isRoomReadyAtom.observable.add((isReady) => {
+      if (isReady && this.messageQueue.length > 0) {
+        void this.flushMessageQueue()
+      }
+    })
+    // Listen for CUSTOM_EVENT messages
+    binaryMessageBus.on(CommsMessage.CUSTOM_EVENT, (data: Uint8Array, sender: string) => {
+      try {
+        const { eventType, payload } = decodeEvent(data, globalEventRegistry)
+        const callbacks = this.listeners.get(eventType)
+
+        if (callbacks) {
+          callbacks.forEach(async (cb) => {
+            if (await this.isServerFuture) {
+              // Server handlers receive sender context
+              cb(payload, { from: sender })
+            } else if (sender === AUTH_SERVER_PEER_ID) {
+              // Client only processes events from authoritative server
+              cb(payload)
+            }
+          })
+        }
+      } catch (error) {
+        console.error('[EventBus] Failed to decode event:', error)
+      }
+    })
+  }
+
+  /**
+   * Flush queued messages when room becomes ready
+   */
+  private async flushMessageQueue(): Promise<void> {
+    if (this.isProcessingQueue || this.messageQueue.length === 0) return
+
+    this.isProcessingQueue = true
+
+    // Copy and clear the queue to avoid mutation during iteration
+    const messages = [...this.messageQueue]
+    this.messageQueue.length = 0
+
+    // Re-send all queued messages
+    for (const message of messages) {
+      await this.send(message.eventType, message.data, message.options)
+    }
+
+    this.isProcessingQueue = false
+  }
+
+  /**
+   * Send an event
+   * @param eventType - The type of event from the registry
+   * @param data - The event data matching the schema
+   * @param options - Optional send options (server only)
+   *
+   * Messages are automatically queued if the room is not ready and sent once connected.
+   */
+  async send<K extends keyof T>(eventType: K, data: EventTypes<T>[K], options?: SendOptions): Promise<void> {
+    try {
+      const isRoomReady = this.isRoomReadyAtom.getOrNull() ?? false
+
+      // If room is not ready, queue the message with original params
+      if (!isRoomReady) {
+        this.messageQueue.push({
+          eventType,
+          data,
+          options
+        })
+        return
+      }
+
+      // Room is ready, send immediately
+      const buffer = encodeEvent(eventType as string, data, globalEventRegistry)
+
+      if (await this.isServerFuture) {
+        // Server can send to specific clients or broadcast
+        this.binaryMessageBus.emit(CommsMessage.CUSTOM_EVENT, buffer, options?.to)
+      } else {
+        // Client always sends to authoritative server
+        this.binaryMessageBus.emit(CommsMessage.CUSTOM_EVENT, buffer)
+      }
+    } catch (error) {
+      console.error(`[EventBus] Failed to send event '${String(eventType)}':`, error)
+    }
+  }
+
+  /**
+   * Listen for an event
+   * @param eventType - The type of event to listen for
+   * @param callback - Callback to handle the event
+   * @returns Unsubscribe function
+   */
+  onMessage<K extends keyof T>(eventType: K, callback: EventCallback<EventTypes<T>[K]>): () => void {
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, new Set())
+    }
+
+    const callbacks = this.listeners.get(eventType)!
+    callbacks.add(callback)
+
+    // Return unsubscribe function
+    return () => {
+      callbacks.delete(callback)
+      if (callbacks.size === 0) {
+        this.listeners.delete(eventType)
+      }
+    }
+  }
+
+  /**
+   * Remove all listeners for a specific event type
+   * @param eventType - The type of event to clear listeners for
+   */
+  clear<K extends keyof T>(eventType?: K): void {
+    if (eventType) {
+      this.listeners.delete(eventType)
+    } else {
+      this.listeners.clear()
+    }
+  }
+
+  /**
+   * Get the number of listeners for an event type
+   * @param eventType - The type of event to check
+   * @returns Number of registered listeners
+   */
+  listenerCount<K extends keyof T>(eventType: K): number {
+    return this.listeners.get(eventType)?.size ?? 0
+  }
+
+  /**
+   * Check if the room is ready to send messages
+   * @returns true if messages will be sent immediately, false if they will be queued
+   */
+  isReady(): boolean {
+    return this.isRoomReadyAtom.getOrNull() ?? false
+  }
+
+  /**
+   * Subscribe to room readiness changes
+   * @param callback - Called when room becomes ready or disconnected
+   * @returns Unsubscribe function
+   *
+   * @example
+   * ```ts
+   * const unsubscribe = room.onReady((isReady) => {
+   *   if (isReady) {
+   *     console.log('Room connected!')
+   *   } else {
+   *     console.log('Room disconnected')
+   *   }
+   * })
+   *
+   * // Later: unsubscribe()
+   * ```
+   */
+  onReady(callback: (isReady: boolean) => void): () => void {
+    const observer = this.isRoomReadyAtom.observable.add((isReady) => {
+      callback(isReady)
+    })
+
+    return () => {
+      if (observer) {
+        this.isRoomReadyAtom.observable.remove(observer)
+      }
+    }
+  }
+}
+
+// Global registry for user-defined events
+const globalEventRegistry: EventSchemaRegistry = {}
+
+/**
+ * Get the global event registry (internal use)
+ * @internal
+ */
+export function getEventRegistry(): EventSchemaRegistry {
+  return globalEventRegistry
+}
+
+// Global room instance (created by addSyncTransport)
+let globalRoom: Room | null = null
+
+/**
+ * Set the global room instance (internal use)
+ * @internal
+ */
+export function setGlobalRoom(roomInstance: Room): void {
+  globalRoom = roomInstance
+}
+
+/**
+ * Register message schemas for use with the room
+ * Call this before main() to define your custom messages
+ * @param messages - Object containing your message schemas
+ * @returns Typed room instance for your registered messages
+ */
+export function registerMessages<T extends EventSchemaRegistry>(messages: T): Room<T> {
+  Object.assign(globalEventRegistry, messages)
+  if (!globalRoom) {
+    throw new Error('Room not initialized. Make sure the SDK network transport is initialized.')
+  }
+  // Update the room registry
+  ;(globalRoom as any).registry = globalEventRegistry
+  return globalRoom as unknown as Room<T>
+}
+
+/**
+ * Get a typed version of the global room
+ * Use this when you want the room with your specific message types
+ *
+ * @example
+ * ```typescript
+ * const MyMessages = { ... }
+ * registerMessages(MyMessages) // Register first
+ * const room = getRoom<typeof MyMessages>() // Then get typed version
+ * ```
+ */
+export function getRoom<T extends EventSchemaRegistry>(): Room<T> {
+  if (!globalRoom) {
+    throw new Error('Room not initialized. Make sure the SDK network transport is initialized.')
+  }
+  return globalRoom as unknown as Room<T>
+}

package/src/network/events/index.ts

@@ -0,0 +1,48 @@
+/**
+ * Room - Multiplayer messaging for SDK7
+ *
+ * Simple room-based communication system for multiplayer scenes.
+ *
+ * @example Basic usage:
+ * ```typescript
+ * import { registerMessages, getRoom, isServer } from '@dcl/sdk/network/events'
+ *
+ * const MyMessages = {
+ *   playerJump: Schemas.Map({ playerId: Schemas.String, position: Schemas.Vector3 }),
+ *   gameUpdate: Schemas.Map({ message: Schemas.String })
+ * }
+ *
+ * // Option 1: Register and get typed room
+ * const room = registerMessages(MyMessages)
+ *
+ * // Option 2: Register first, then get typed room
+ * // registerMessages(MyMessages)
+ * // const room = getRoom<typeof MyMessages>()
+ *
+ * export function main() {
+ *   if (isServer()) {
+ *     room.onMessage('playerJump', (data, context) => {
+ *       console.log(`Player ${context?.from} jumped`)
+ *       room.send('gameUpdate', { message: 'Player jumped!' })
+ *     })
+ *   } else {
+ *     room.send('playerJump', { playerId: 'me', position: { x: 1, y: 2, z: 3 } })
+ *     room.onMessage('gameUpdate', (data) => {
+ *       console.log('Server says:', data.message)
+ *     })
+ *   }
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+// Import public API and types
+import { registerMessages, getRoom, EventContext } from './implementation'
+import { EventSchemaRegistry } from './registry'
+
+// Re-export public API - only what users need
+export { registerMessages, getRoom }
+
+// Re-export types that users need
+export type { EventContext, EventSchemaRegistry }