@dcl/sdk 7.24.6-29505165911.commit-d270434 → 7.24.6-29580060460.commit-06f0b7e

package/src/internal/utf8.ts

@@ -0,0 +1,167 @@
+/**
+ * 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.
+ */
+
+const REPLACEMENT_CHARACTER = 0xfffd
+
+export type DecodeUtf8Options = {
+  fatal?: boolean
+  ignoreBOM?: boolean
+}
+
+export function decodeUtf8(input: Uint8Array, options: DecodeUtf8Options = {}): string {
+  const fatal = options.fatal === true
+  const start =
+    !options.ignoreBOM && input.length >= 3 && input[0] === 0xef && input[1] === 0xbb && input[2] === 0xbf ? 3 : 0
+
+  let result = ''
+  let pending: number[] = []
+  let codePoint = 0
+  let bytesNeeded = 0
+  let bytesSeen = 0
+  let lowerBoundary = 0x80
+  let upperBoundary = 0xbf
+
+  function emit(value: number) {
+    if (value <= 0xffff) {
+      pending.push(value)
+    } else {
+      const offset = value - 0x10000
+      pending.push(0xd800 + (offset >> 10), 0xdc00 + (offset & 0x3ff))
+    }
+    if (pending.length >= 4096) {
+      result += String.fromCharCode(...pending)
+      pending = []
+    }
+  }
+
+  function malformed() {
+    if (fatal) throw new TypeError('decodeUtf8: the encoded data is not valid utf-8')
+    emit(REPLACEMENT_CHARACTER)
+  }
+
+  for (let i = start; i < input.length; i++) {
+    const byte = input[i]
+    if (bytesNeeded === 0) {
+      if (byte <= 0x7f) {
+        emit(byte)
+      } else if (byte >= 0xc2 && byte <= 0xdf) {
+        bytesNeeded = 1
+        codePoint = byte & 0x1f
+      } else if (byte >= 0xe0 && byte <= 0xef) {
+        if (byte === 0xe0) lowerBoundary = 0xa0
+        if (byte === 0xed) upperBoundary = 0x9f
+        bytesNeeded = 2
+        codePoint = byte & 0xf
+      } else if (byte >= 0xf0 && byte <= 0xf4) {
+        if (byte === 0xf0) lowerBoundary = 0x90
+        if (byte === 0xf4) upperBoundary = 0x8f
+        bytesNeeded = 3
+        codePoint = byte & 0x7
+      } else {
+        malformed()
+      }
+    } else if (byte < lowerBoundary || byte > upperBoundary) {
+      codePoint = 0
+      bytesNeeded = 0
+      bytesSeen = 0
+      lowerBoundary = 0x80
+      upperBoundary = 0xbf
+      malformed()
+      // the spec prepends the byte back to the stream: it starts a new sequence
+      i--
+    } else {
+      lowerBoundary = 0x80
+      upperBoundary = 0xbf
+      codePoint = (codePoint << 6) | (byte & 0x3f)
+      if (++bytesSeen === bytesNeeded) {
+        emit(codePoint)
+        codePoint = 0
+        bytesNeeded = 0
+        bytesSeen = 0
+      }
+    }
+  }
+  if (bytesNeeded !== 0) malformed()
+
+  if (pending.length > 0) result += String.fromCharCode(...pending)
+  return result
+}
+
+export function encodeUtf8(input: string): Uint8Array {
+  const output = new Uint8Array(utf8ByteLength(input))
+  let offset = 0
+  for (let i = 0; i < input.length; i++) {
+    const codePoint = codePointAt(input, i)
+    if (codePoint > 0xffff) i++
+    offset = writeCodePoint(output, offset, codePoint)
+  }
+  return output
+}
+
+export function encodeUtf8Into(source: string, destination: Uint8Array): { read: number; written: number } {
+  let read = 0
+  let written = 0
+  for (let i = 0; i < source.length; i++) {
+    const codePoint = codePointAt(source, i)
+    const size = byteSize(codePoint)
+    if (written + size > destination.length) break
+    written = writeCodePoint(destination, written, codePoint)
+    if (codePoint > 0xffff) {
+      i++
+      read += 2
+    } else {
+      read += 1
+    }
+  }
+  return { read, written }
+}
+
+// Reads the code point at index, replacing unpaired surrogates with U+FFFD
+// (the USVString conversion `TextEncoder` mandates).
+function codePointAt(input: string, index: number): number {
+  const first = input.charCodeAt(index)
+  if (first >= 0xd800 && first <= 0xdbff) {
+    const second = index + 1 < input.length ? input.charCodeAt(index + 1) : 0
+    if (second >= 0xdc00 && second <= 0xdfff) return 0x10000 + ((first - 0xd800) << 10) + (second - 0xdc00)
+    return REPLACEMENT_CHARACTER
+  }
+  if (first >= 0xdc00 && first <= 0xdfff) return REPLACEMENT_CHARACTER
+  return first
+}
+
+function byteSize(codePoint: number): number {
+  return codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4
+}
+
+function utf8ByteLength(input: string): number {
+  let length = 0
+  for (let i = 0; i < input.length; i++) {
+    const codePoint = codePointAt(input, i)
+    if (codePoint > 0xffff) i++
+    length += byteSize(codePoint)
+  }
+  return length
+}
+
+function writeCodePoint(output: Uint8Array, offset: number, codePoint: number): number {
+  let next = offset
+  if (codePoint <= 0x7f) {
+    output[next++] = codePoint
+  } else if (codePoint <= 0x7ff) {
+    output[next++] = 0xc0 | (codePoint >> 6)
+    output[next++] = 0x80 | (codePoint & 0x3f)
+  } else if (codePoint <= 0xffff) {
+    output[next++] = 0xe0 | (codePoint >> 12)
+    output[next++] = 0x80 | ((codePoint >> 6) & 0x3f)
+    output[next++] = 0x80 | (codePoint & 0x3f)
+  } else {
+    output[next++] = 0xf0 | (codePoint >> 18)
+    output[next++] = 0x80 | ((codePoint >> 12) & 0x3f)
+    output[next++] = 0x80 | ((codePoint >> 6) & 0x3f)
+    output[next++] = 0x80 | (codePoint & 0x3f)
+  }
+  return next
+}

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

@@ -1,12 +1,9 @@
 import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer'
 
 export enum CommsMessage {
-  CRDT = 7,
-  REQ_CRDT_STATE = 8,
-  RES_CRDT_STATE = 9,
-  CRDT_SERVER = 4,
-  CRDT_AUTHORITATIVE = 5,
-  CUSTOM_EVENT = 6
+  CRDT = 1,
+  REQ_CRDT_STATE = 2,
+  RES_CRDT_STATE = 3
 }
 
 export function BinaryMessageBus<T extends CommsMessage>(
@@ -23,9 +20,7 @@ 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/index.ts

@@ -2,46 +2,9 @@ import { sendBinary } from '~system/CommunicationsController'
 import { engine } from '@dcl/ecs'
 import { addSyncTransport } from './message-bus-sync'
 import { getUserData } from '~system/UserIdentity'
-import { isServer as isServerApi } from '~system/EngineApi'
-import { Atom } from '../atom'
-
-// Create isServer atom for consistent state
-const isServerAtom = Atom<boolean>(false)
-void isServerApi({}).then((response) => {
-  isServerAtom.swap(!!response.isServer)
-})
-
-// Helper function to check if running on server
-export function isServer(): boolean {
-  return isServerAtom.getOrNull() ?? false
-}
 
 // initialize sync transport for sdk engine
-const {
-  getChildren,
-  syncEntity,
-  parentEntity,
-  getParent,
-  myProfile,
-  removeParent,
-  getFirstChild,
-  isStateSyncronized,
-  binaryMessageBus,
-  eventBus
-} = addSyncTransport(engine, sendBinary, getUserData, isServerApi, 'network')
-
-// Re-export the room messaging system
-export { registerMessages, getRoom } from './events'
+const { getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, getFirstChild, isStateSyncronized } =
+  addSyncTransport(engine, sendBinary, getUserData)
 
-export {
-  getFirstChild,
-  getChildren,
-  syncEntity,
-  parentEntity,
-  getParent,
-  myProfile,
-  removeParent,
-  isStateSyncronized,
-  binaryMessageBus,
-  eventBus
-}
+export { getFirstChild, getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, isStateSyncronized }

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

@@ -1,53 +1,27 @@
-import { IEngine, Transport, RealmInfo } from '@dcl/ecs'
+import { IEngine, Transport, RealmInfo, PlayerIdentityData } from '@dcl/ecs'
 import { type SendBinaryRequest, type SendBinaryResponse } from '~system/CommunicationsController'
 
 import { syncFilter } from './filter'
 import { engineToCrdt } from './state'
-import { BinaryMessageBus, CommsMessage } from './binary-message-bus'
+import { BinaryMessageBus, CommsMessage, decodeString, encodeString } from './binary-message-bus'
 import { fetchProfile } from './utils'
 import { entityUtils } from './entities'
-import { createServerValidator } from './server'
 import { GetUserDataRequest, GetUserDataResponse } from '~system/UserIdentity'
 import { definePlayerHelper } from '../players'
 import { serializeCrdtMessages } from '../internal/transports/logger'
-import { IsServerRequest, IsServerResponse } from '~system/EngineApi'
-import { Atom } from '../atom'
-import { setGlobalRoom, Room } from './events/implementation'
 
 export type IProfile = { networkId: number; userId: string }
 // user that we asked for the inital crdt state
-export const AUTH_SERVER_PEER_ID = 'authoritative-server'
-export const DEBUG_NETWORK_MESSAGES = () => (globalThis as any).DEBUG_NETWORK_MESSAGES ?? false
-
-// Test environment detection without 'as any'
-const isTestEnvironment = (): boolean => {
-  try {
-    if (typeof globalThis === 'undefined') return false
-    const globalWithProcess = globalThis as unknown as { process?: { env?: { NODE_ENV?: string } } }
-    return globalWithProcess.process?.env?.NODE_ENV === 'test'
-  } catch {
-    return false
-  }
-}
-
 export function addSyncTransport(
   engine: IEngine,
   sendBinary: (msg: SendBinaryRequest) => Promise<SendBinaryResponse>,
-  getUserData: (value: GetUserDataRequest) => Promise<GetUserDataResponse>,
-  isServerFn: (request: IsServerRequest) => Promise<IsServerResponse>,
-  name: string
+  getUserData: (value: GetUserDataRequest) => Promise<GetUserDataResponse>
 ) {
+  const DEBUG_NETWORK_MESSAGES = () => (globalThis as any).DEBUG_NETWORK_MESSAGES ?? false
   // Profile Info
   const myProfile: IProfile = {} as IProfile
   fetchProfile(myProfile!, getUserData)
 
-  const isServerAtom = Atom<boolean>()
-  const isRoomReadyAtom = Atom<boolean>(false)
-
-  void isServerFn({}).then(($: IsServerResponse) => {
-    return isServerAtom.swap(!!$.isServer)
-  })
-
   // Entity utils
   const entityDefinitions = entityUtils(engine, myProfile)
 
@@ -66,190 +40,108 @@ export function addSyncTransport(
   const players = definePlayerHelper(engine)
 
   let stateIsSyncronized = false
+  let transportInitialzed = false
 
-  /**
-   * We need to wait till 2 ticks that is when the engine is ready to send new messages.
-   * The first tick is for the client engine processing the CRDT messages,
-   * and the second one are the messages created by the main() function.
-   * So to avoid sending those messages, that all the clients have, through the network we put this validation here.
-   */
-  let tick = 0
-  const TRANSPORT_INITIALIZED_NUMBER = isTestEnvironment() ? 0 : 2
   // Add Sync Transport
   const transport: Transport = {
     filter: syncFilter(engine),
     send: async (messages) => {
-      if (tick <= TRANSPORT_INITIALIZED_NUMBER) tick++
-      for (const message of tick > TRANSPORT_INITIALIZED_NUMBER ? [messages].flat() : []) {
-        if (message.byteLength) {
+      for (const message of [messages].flat()) {
+        if (message.byteLength && transportInitialzed) {
           DEBUG_NETWORK_MESSAGES() &&
             console.log(...Array.from(serializeCrdtMessages('[NetworkMessage sent]:', message, engine)))
-
-          // Convert regular messages to network messages for broadcasting with chunking
-          for (const chunk of serverValidator.convertRegularToNetworkMessage(message)) {
-            binaryMessageBus.emit(CommsMessage.CRDT, chunk)
-          }
+          binaryMessageBus.emit(CommsMessage.CRDT, message)
         }
       }
       const peerMessages = getMessagesToSend()
+      let totalSize = 0
+      for (const message of peerMessages) {
+        for (const data of message.data) {
+          totalSize += data.byteLength
+        }
+      }
+      if (totalSize) {
+        DEBUG_NETWORK_MESSAGES() && console.log('Sending network messages: ', totalSize / 1024, 'KB')
+      }
       const response = await sendBinary({ data: [], peerData: peerMessages })
       binaryMessageBus.__processMessages(response.data)
+      transportInitialzed = true
     },
-    type: name
+    type: 'network'
   }
-
-  // Server validation setup
-  const serverValidator = createServerValidator({
-    engine,
-    binaryMessageBus
-  })
-
-  // Initialize Event Bus with registered schemas
-  const eventBus = new Room(engine, binaryMessageBus, isServerAtom, isRoomReadyAtom)
-
-  // Set global eventBus instance
-  setGlobalRoom(eventBus)
-
   engine.addTransport(transport)
   // End add sync transport
 
   // Receive & Process CRDT_STATE
-  binaryMessageBus.on(CommsMessage.REQ_CRDT_STATE, async (data, sender) => {
-    DEBUG_NETWORK_MESSAGES() && console.log('[REQ_CRDT_STATE]', sender, Date.now())
-    const chunks = engineToCrdt(engine)
-    if (chunks.length === 0) {
-      DEBUG_NETWORK_MESSAGES() && console.log('[Emiting empty state:]', sender, Date.now())
-      binaryMessageBus.emit(CommsMessage.RES_CRDT_STATE, new Uint8Array(), [sender])
-    } else {
-      for (const chunk of chunks) {
-        DEBUG_NETWORK_MESSAGES() && console.log('[Emiting:]', sender, Date.now())
-        binaryMessageBus.emit(CommsMessage.RES_CRDT_STATE, chunk, [sender])
-      }
-    }
-  })
-  binaryMessageBus.on(CommsMessage.RES_CRDT_STATE, async (data, sender) => {
-    requestingState = false
-    elapsedTimeSinceRequest = 0
-    if (isServerAtom.getOrNull() || sender !== AUTH_SERVER_PEER_ID) return
+  binaryMessageBus.on(CommsMessage.RES_CRDT_STATE, (value) => {
+    const { sender, data } = decodeCRDTState(value)
+    if (sender !== myProfile.userId) return
     DEBUG_NETWORK_MESSAGES() && console.log('[Processing CRDT State]', data.byteLength / 1024, 'KB')
-    if (data.byteLength > 0) {
-      transport.onmessage!(serverValidator.processClientMessages(data, sender))
-    }
+    transport.onmessage!(data)
     stateIsSyncronized = true
+  })
+
+  // Answer to REQ_CRDT_STATE
+  binaryMessageBus.on(CommsMessage.REQ_CRDT_STATE, async (_, userId) => {
+    DEBUG_NETWORK_MESSAGES() && console.log(`Sending CRDT State to: ${userId}`)
 
-    // IMPORTANT: Only mark room as ready AFTER state is synchronized
-    // This ensures comms is truly connected and working
-    const realmInfo = RealmInfo.getOrNull(engine.RootEntity)
-    if (realmInfo) {
-      DEBUG_NETWORK_MESSAGES() && console.log('[isRoomReady] Marking room as ready after state sync')
-      isRoomReadyAtom.swap(true)
+    for (const chunk of engineToCrdt(engine)) {
+      binaryMessageBus.emit(CommsMessage.RES_CRDT_STATE, encodeCRDTState(userId, chunk), [userId])
     }
   })
 
-  // received message from the network
-  binaryMessageBus.on(CommsMessage.CRDT, (value, sender) => {
-    const isServer = isServerAtom.getOrNull()
+  // Process CRDT messages here
+  binaryMessageBus.on(CommsMessage.CRDT, (value) => {
     DEBUG_NETWORK_MESSAGES() &&
-      console.log(
-        transport.type,
-        ...Array.from(serializeCrdtMessages('[NetworkMessage received]:', value, engine)),
-        isServer
-      )
-    if (isServer) {
-      transport.onmessage!(serverValidator.processServerMessages(value, sender))
-    } else if (sender === AUTH_SERVER_PEER_ID) {
-      // Process network messages from server and convert to regular messages
-      transport.onmessage!(serverValidator.processClientMessages(value, sender))
-    }
+      console.log(Array.from(serializeCrdtMessages('[NetworkMessage received]:', value, engine)))
+    transport.onmessage!(value)
   })
 
-  // received authoritative message from server - force apply to fix invalid local state
-  binaryMessageBus.on(CommsMessage.CRDT_AUTHORITATIVE, (value, sender) => {
-    // Only accept authoritative messages from authoritative server
-    if (sender !== AUTH_SERVER_PEER_ID) return
+  async function requestState(retryCount: number = 1) {
+    let players = Array.from(engine.getEntitiesWith(PlayerIdentityData))
+    DEBUG_NETWORK_MESSAGES() && console.log(`Requesting state. Players connected: ${players.length - 1}`)
+
+    if (!RealmInfo.getOrNull(engine.RootEntity)?.isConnectedSceneRoom) {
+      DEBUG_NETWORK_MESSAGES() && console.log(`Aborting Requesting state?. Disconnected`)
+      return
+    }
 
-    // DEBUG_NETWORK_MESSAGES() &&
-    console.log('[AUTHORITATIVE] Received authoritative message from server:', value.byteLength, 'bytes')
+    binaryMessageBus.emit(CommsMessage.REQ_CRDT_STATE, new Uint8Array())
 
-    // Process authoritative messages by forcing them through normal CRDT processing
-    // but with a timestamp that's guaranteed to be accepted
-    const authoritativeBuffer = serverValidator.processClientMessages(value, sender, true)
-    if (authoritativeBuffer.byteLength > 0) {
-      // Apply authoritative message through normal transport, but the server's messages
-      // should be processed as authoritative with special timestamp handling
-      transport.onmessage!(authoritativeBuffer)
+    // Wait ~5s for the response.
+    await sleep(5000)
 
-      DEBUG_NETWORK_MESSAGES() && console.log('[AUTHORITATIVE] Applied server authoritative message to local state')
+    players = Array.from(engine.getEntitiesWith(PlayerIdentityData))
+
+    if (!stateIsSyncronized) {
+      if (players.length > 1 && retryCount <= 2) {
+        DEBUG_NETWORK_MESSAGES() &&
+          console.log(`Requesting state again ${retryCount} (no response). Players connected: ${players.length - 1}`)
+        void requestState(retryCount + 1)
+      } else {
+        DEBUG_NETWORK_MESSAGES() && console.log('No active players. State syncronized')
+        stateIsSyncronized = true
+      }
     }
-  })
+  }
 
   players.onEnterScene((player) => {
     DEBUG_NETWORK_MESSAGES() && console.log('[onEnterScene]', player.userId)
-    if (!isServerAtom.getOrNull() && myProfile.userId === player.userId) {
-      requestState()
-    }
   })
 
   // Asks for the REQ_CRDT_STATE when its connected to comms
   RealmInfo.onChange(engine.RootEntity, (value) => {
-    const isServer = isServerAtom.getOrNull()
-
     if (!value?.isConnectedSceneRoom) {
-      // Only react when actually transitioning from ready to not ready
-      if (isRoomReadyAtom.getOrNull() === true) {
-        DEBUG_NETWORK_MESSAGES() && console.log('Disconnected from comms')
-        isRoomReadyAtom.swap(false)
-        if (!isServer) {
-          stateIsSyncronized = false
-        }
-      }
+      DEBUG_NETWORK_MESSAGES() && console.log('Disconnected from comms')
+      stateIsSyncronized = false
     }
 
     if (value?.isConnectedSceneRoom) {
-      requestState()
-
-      // For servers, mark as ready immediately when connected
-      // (servers don't need to sync state from anyone)
-      if (isServer && isRoomReadyAtom.getOrNull() === false) {
-        DEBUG_NETWORK_MESSAGES() && console.log('[isRoomReady] Server marking room as ready')
-        isRoomReadyAtom.swap(true)
-      }
-      // For clients, room will be marked ready after receiving CRDT state (above)
-    }
-  })
-
-  let requestingState = false
-  let elapsedTimeSinceRequest = 0
-  const STATE_REQUEST_RETRY_INTERVAL = 2.0 // seconds
-
-  /**
-   * Why we have to request the state if we have a server that can send us the state when we joined?
-   * The thing is that when the server detects a new JOIN_PARTICIPANT on livekit room, it sends automatically the state to that peer.
-   * But in unity, it takes more time, so that message is not being delivered to the client.
-   * So instead, when we are finally connected to the room, we request the state, and then the server answers with the state :)
-   *
-   * If no response is received within 2 seconds, the request is automatically retried.
-   */
-  function requestState() {
-    if (isServerAtom.getOrNull()) return
-    if (RealmInfo.getOrNull(engine.RootEntity)?.isConnectedSceneRoom && !requestingState) {
-      requestingState = true
-      elapsedTimeSinceRequest = 0
-      DEBUG_NETWORK_MESSAGES() && console.log('Requesting state...')
-      binaryMessageBus.emit(CommsMessage.REQ_CRDT_STATE, new Uint8Array())
+      DEBUG_NETWORK_MESSAGES() && console.log('Connected to comms')
     }
-  }
 
-  // System to retry state request if no response is received within the retry interval
-  engine.addSystem((dt: number) => {
-    if (requestingState && !stateIsSyncronized) {
-      elapsedTimeSinceRequest += dt
-      if (elapsedTimeSinceRequest >= STATE_REQUEST_RETRY_INTERVAL) {
-        DEBUG_NETWORK_MESSAGES() && console.log('State request timed out, retrying...')
-        elapsedTimeSinceRequest = 0
-        requestingState = false
-        requestState()
-      }
+    if (value?.isConnectedSceneRoom && !stateIsSyncronized) {
+      void requestState()
     }
   })
 
@@ -261,12 +153,56 @@ export function addSyncTransport(
     return stateIsSyncronized
   }
 
+  function sleep(ms: number) {
+    return new Promise<void>((resolve) => {
+      let timer = 0
+      function sleepSystem(dt: number) {
+        timer += dt
+        if (timer * 1000 >= ms) {
+          engine.removeSystem(sleepSystem)
+          resolve()
+        }
+      }
+      engine.addSystem(sleepSystem)
+    })
+  }
+
   return {
     ...entityDefinitions,
     myProfile,
-    isStateSyncronized,
-    binaryMessageBus,
-    eventBus,
-    isRoomReadyAtom
+    isStateSyncronized
   }
 }
+
+/**
+ * Messages Protocol Encoding
+ *
+ * CRDT: Plain Uint8Array
+ *
+ * CRDT_STATE_RES { sender: string, data: Uint8Array}
+ */
+function decodeCRDTState(data: Uint8Array) {
+  let offset = 0
+  const r = new Uint8Array(data)
+  const view = new DataView(r.buffer)
+  const senderLength = view.getUint8(offset)
+  offset += 1
+  const sender = decodeString(data.subarray(1, senderLength + 1))
+  offset += senderLength
+  const state = r.subarray(offset)
+
+  return { sender, data: state }
+}
+
+function encodeCRDTState(address: string, data: Uint8Array) {
+  // address to uint8array
+  const addressBuffer = encodeString(address)
+  const addressOffset = 1
+  const messageLength = addressOffset + addressBuffer.byteLength + data.byteLength
+
+  const serializedMessage = new Uint8Array(messageLength)
+  serializedMessage.set(new Uint8Array([addressBuffer.byteLength]), 0)
+  serializedMessage.set(addressBuffer, 1)
+  serializedMessage.set(data, addressBuffer.byteLength + 1)
+  return serializedMessage
+}

package/src/network/state.ts

@@ -28,7 +28,7 @@ import {
   TriggerAreaResult,
   ComponentDefinition
 } from '@dcl/ecs'
-import { LIVEKIT_MAX_SIZE } from './server'
+import { LIVEKIT_MAX_SIZE } from '@dcl/ecs/dist/systems/crdt'
 
 export const NOT_SYNC_COMPONENTS: ComponentDefinition<unknown>[] = [
   VideoEvent,
@@ -79,9 +79,9 @@ export function engineToCrdt(engine: IEngine): Uint8Array[] {
     if (!shouldSyncComponent(itComponentDefinition)) {
       continue
     }
-
     itComponentDefinition.dumpCrdtStateToBuffer(crdtBuffer, (entity) => {
-      return NetworkEntity.has(entity)
+      const isNetworkEntity = NetworkEntity.has(entity)
+      return isNetworkEntity
     })
   }
 
@@ -103,6 +103,7 @@ export function engineToCrdt(engine: IEngine): Uint8Array[] {
         }
 
         // If the message itself is larger than the limit, we need to handle it specially
+        // For now, we'll skip it to prevent infinite loops
         if (messageSize / 1024 > LIVEKIT_MAX_SIZE) {
           console.error(
             `Message too large (${messageSize} bytes), skipping component ${message.componentId} for entity ${message.entityId}`