@dcl/sdk 7.20.2-22104870534.commit-0df3cc0 → 7.20.2-22169778016.commit-030cbfe

package/network/server/index.js

@@ -0,0 +1,219 @@
+import { CrdtMessageType, ProcessMessageResultType, PutNetworkComponentOperation } from '@dcl/ecs';
+import * as components from '@dcl/ecs/dist/components';
+import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer';
+import { CommsMessage } from '../binary-message-bus';
+import { chunkCrdtMessages } from '../chunking';
+import * as utils from './utils';
+import { AUTH_SERVER_PEER_ID, DEBUG_NETWORK_MESSAGES } from '../message-bus-sync';
+export const LIVEKIT_MAX_SIZE = 12;
+export function createServerValidator(config) {
+    const { engine, binaryMessageBus } = config;
+    // Initialize components for network operations and transform fixing
+    const NetworkEntity = components.NetworkEntity(engine);
+    const CreatedBy = components.CreatedBy(engine);
+    const NetworkParent = components.NetworkParent(engine);
+    // Type guard to check if component supports corrections (both LWW and GrowOnlySet)
+    function supportsCorrections(component) {
+        return ((component.componentType === 0 /* ComponentType.LastWriteWinElementSet */ ||
+            component.componentType === 1 /* ComponentType.GrowOnlyValueSet */) &&
+            'getCrdtState' in component);
+    }
+    function findExistingNetworkEntity(message) {
+        // Look for existing network entity mapping (don't create new ones)
+        for (const [entityId, networkData] of engine.getEntitiesWith(NetworkEntity)) {
+            if (networkData.networkId === message.networkId && networkData.entityId === message.entityId) {
+                return entityId;
+            }
+        }
+        // Return null if not found
+        return null;
+    }
+    function findOrCreateNetworkEntity(message, sender, isServer) {
+        // Look for existing network entity mapping first
+        const existingEntity = findExistingNetworkEntity(message);
+        if (existingEntity) {
+            return existingEntity;
+        }
+        // Create new entity and network mapping
+        const newEntityId = engine.addEntity();
+        NetworkEntity.createOrReplace(newEntityId, {
+            networkId: message.networkId,
+            entityId: message.entityId
+        });
+        if (isServer) {
+            CreatedBy.createOrReplace(newEntityId, { address: sender });
+        }
+        DEBUG_NETWORK_MESSAGES() &&
+            console.log(`[DEBUG] Created new entity ${newEntityId} for network ${message.networkId}:${message.entityId}`);
+        return newEntityId;
+    }
+    function convertNetworkToRegularMessage(networkMessage, localEntityId, forceCorrections = false) {
+        const buffer = new ReadWriteByteBuffer();
+        try {
+            // Use the well-tested networkMessageToLocal utility with transform fixing for Unity
+            const message = utils.networkMessageToLocal(networkMessage, localEntityId, buffer, NetworkParent, forceCorrections);
+            return { ...message, messageBuffer: buffer.toBinary() };
+        }
+        catch (error) {
+            DEBUG_NETWORK_MESSAGES() && console.error('Error converting network message:', error);
+            return null;
+        }
+    }
+    function validateMessagePermissions(message, sender, _localEntityId) {
+        // Basic checks
+        if (!sender || sender === AUTH_SERVER_PEER_ID) {
+            return false; // Server shouldn't send messages to itself
+        }
+        if (message.type === CrdtMessageType.DELETE_ENTITY) {
+            // TODO: how to handle this case ?
+        }
+        if (message.type === CrdtMessageType.PUT_COMPONENT || message.type === CrdtMessageType.DELETE_COMPONENT) {
+            const component = engine.getComponent(message.componentId);
+            const buf = 'data' in message ? new ReadWriteByteBuffer(message.data) : null;
+            const value = buf ? component.schema.deserialize(buf) : null;
+            const dryRunCRDT = component.__dry_run_updateFromCrdt(message);
+            const validCRDT = [
+                ProcessMessageResultType.StateUpdatedData,
+                ProcessMessageResultType.StateUpdatedTimestamp,
+                ProcessMessageResultType.EntityDeleted
+            ].includes(dryRunCRDT);
+            const createdBy = CreatedBy.getOrNull(message.entityId);
+            const validMessage = validCRDT &&
+                component.__run_validateBeforeChange(message.entityId, value, sender, createdBy?.address ?? AUTH_SERVER_PEER_ID);
+            return !!validMessage;
+        }
+        // For now, basic validation - in the future this will check component sync permissions
+        // TODO: Check if sender owns the entity
+        // TODO: Check component sync mode ('all' | 'owner' | 'server')
+        // TODO: Run component custom validation
+        return true;
+    }
+    function broadcastBatchedMessages(messages, excludeSender) {
+        if (messages.length === 0)
+            return;
+        // Build the complete buffer with all messages
+        const networkBuffer = new ReadWriteByteBuffer();
+        for (const message of messages) {
+            // Skip oversized messages upfront
+            if (message.messageBuffer.byteLength / 1024 > LIVEKIT_MAX_SIZE) {
+                console.error(`Message too large (${message.messageBuffer.byteLength} bytes), skipping message from ${excludeSender}`);
+                continue;
+            }
+            networkBuffer.writeBuffer(message.messageBuffer, false);
+        }
+        // Use the chunking function to split into proper chunks
+        const chunks = chunkCrdtMessages(networkBuffer.toBinary(), LIVEKIT_MAX_SIZE);
+        for (const chunk of chunks) {
+            binaryMessageBus.emit(CommsMessage.CRDT, chunk);
+        }
+        DEBUG_NETWORK_MESSAGES() &&
+            console.log(`Total: ${messages.length} messages in ${chunks.length} chunks from ${excludeSender}`);
+    }
+    function sendCorrectionToSender(networkMessage, sender, localEntityId) {
+        try {
+            // Only handle component messages (PUT/DELETE), not entity deletion
+            if (networkMessage.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {
+                DEBUG_NETWORK_MESSAGES() && console.log('[AUTHORITATIVE] Cannot send authoritative message for entity deletion');
+                return;
+            }
+            // Safe to access componentId and timestamp now
+            const component = engine.getComponent(networkMessage.componentId);
+            // Only proceed if component supports authoritative messages (LWW or GrowOnlySet)
+            if (!supportsCorrections(component)) {
+                DEBUG_NETWORK_MESSAGES() && console.log('[AUTHORITATIVE] Component does not support authoritative messages');
+                return;
+            }
+            const serverCRDTState = component.getCrdtState(localEntityId);
+            if (serverCRDTState) {
+                // Create authoritative message using PUT_COMPONENT_NETWORK
+                // Each client will convert this to AUTHORITATIVE_PUT_COMPONENT with proper entity mapping
+                const correctionBuffer = new ReadWriteByteBuffer();
+                PutNetworkComponentOperation.write(networkMessage.entityId, // Use original network entity ID
+                serverCRDTState.timestamp, networkMessage.componentId, networkMessage.networkId, serverCRDTState.data, correctionBuffer);
+                // Send authoritative message directly to the sender
+                binaryMessageBus.emit(CommsMessage.CRDT_AUTHORITATIVE, correctionBuffer.toBinary(), [sender]);
+                DEBUG_NETWORK_MESSAGES() &&
+                    console.log(`[AUTHORITATIVE] Sent authoritative message to ${sender} for entity ${localEntityId} component ${networkMessage.componentId} with timestamp ${networkMessage.timestamp}`);
+            }
+        }
+        catch (error) {
+            DEBUG_NETWORK_MESSAGES() && console.error('Error sending correction:', error);
+        }
+    }
+    return {
+        findExistingNetworkEntity,
+        // transform Network messages to CRDT Common Messages.
+        processClientMessages: function processClientMessages(value, sender, forceCorrections = false) {
+            // console.log(`[CLIENT] Processing message from ${sender}, ${value.length} bytes`)
+            // Collect all regular messages in a single buffer for batched application
+            const combinedBuffer = new ReadWriteByteBuffer();
+            // Clients process network messages from server and convert them to regular messages
+            for (const message of utils.readMessages(value)) {
+                // Only process network messages in client message handler
+                if (utils.isNetworkMessage(message)) {
+                    const networkMessage = message;
+                    // Find or create network entity mapping
+                    const localEntityId = findOrCreateNetworkEntity(networkMessage, sender, false);
+                    // Convert network message to regular message or correction message
+                    const regularMessage = convertNetworkToRegularMessage(networkMessage, localEntityId, forceCorrections);
+                    if (regularMessage?.messageBuffer.byteLength) {
+                        combinedBuffer.writeBuffer(regularMessage.messageBuffer, false);
+                    }
+                }
+            }
+            return combinedBuffer.toBinary();
+        },
+        // Sever Code: process message, handle permissions, and broadcast if needed.
+        processServerMessages: function processServerMessages(value, sender) {
+            // console.log(`[SERVER] Processing message from ${sender}, ${value.length} bytes`)
+            // Collect all valid messages for batched broadcasting
+            const messagesToBroadcast = [];
+            const regularMessagesBuffer = new ReadWriteByteBuffer();
+            for (const message of utils.readMessages(value)) {
+                try {
+                    // Only process network messages in server message handler
+                    if (utils.isNetworkMessage(message)) {
+                        const networkMessage = message;
+                        // 1. Find or create network entity mapping
+                        const localEntityId = findOrCreateNetworkEntity(networkMessage, sender, true);
+                        // 2. Convert network message to regular message and collect for local application
+                        const regularMessage = convertNetworkToRegularMessage(networkMessage, localEntityId);
+                        // 3. Basic permission validation
+                        if (!validateMessagePermissions(regularMessage, sender, localEntityId)) {
+                            // Send correction back to sender with server's authoritative state
+                            sendCorrectionToSender(networkMessage, sender, localEntityId);
+                            continue;
+                        }
+                        // 4. Collect valid message for batched broadcasting
+                        messagesToBroadcast.push(networkMessage);
+                        if (regularMessage?.messageBuffer.byteLength) {
+                            regularMessagesBuffer.writeBuffer(regularMessage.messageBuffer, false);
+                        }
+                    }
+                }
+                catch (error) {
+                    DEBUG_NETWORK_MESSAGES() && console.error('Error processing server message:', error);
+                }
+            }
+            // Batch broadcast all valid messages together
+            broadcastBatchedMessages(messagesToBroadcast, sender);
+            return regularMessagesBuffer.toBinary();
+        },
+        // engine changes that needs to be broadcasted.
+        convertRegularToNetworkMessage: function convertRegularToNetworkMessage(regularMessage) {
+            const groupedBuffer = new ReadWriteByteBuffer();
+            // First pass: Convert all regular messages to network format and group them into one big buffer
+            for (const message of utils.readMessages(regularMessage)) {
+                // Only convert regular messages that have network data
+                const networkData = NetworkEntity.getOrNull(message.entityId);
+                if (networkData && !utils.isNetworkMessage(message)) {
+                    utils.localMessageToNetwork(message, networkData, groupedBuffer);
+                }
+            }
+            // Second pass: Use the new chunking function that respects message boundaries
+            const totalData = groupedBuffer.toBinary();
+            return chunkCrdtMessages(totalData, LIVEKIT_MAX_SIZE);
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/network/server/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  IEngine,\n  Entity,\n  CrdtMessageType,\n  CrdtMessageBody,\n  ProcessMessageResultType,\n  ComponentType,\n  PutNetworkComponentOperation\n} from '@dcl/ecs'\nimport * as components from '@dcl/ecs/dist/components'\nimport { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer'\nimport { CommsMessage } from '../binary-message-bus'\nimport { chunkCrdtMessages } from '../chunking'\nimport * as utils from './utils'\nimport { AUTH_SERVER_PEER_ID, DEBUG_NETWORK_MESSAGES } from '../message-bus-sync'\nimport { type BinaryMessageBus } from '../binary-message-bus'\nimport {\n  LastWriteWinElementSetComponentDefinition,\n  GrowOnlyValueSetComponentDefinition,\n  ComponentDefinition,\n  InternalBaseComponent\n} from '@dcl/ecs/dist/engine/component'\n\nexport const LIVEKIT_MAX_SIZE = 12\n\nexport interface ServerValidationConfig {\n  engine: IEngine\n  binaryMessageBus: ReturnType<typeof BinaryMessageBus>\n}\n\nexport function createServerValidator(config: ServerValidationConfig) {\n  const { engine, binaryMessageBus } = config\n\n  // Initialize components for network operations and transform fixing\n  const NetworkEntity = components.NetworkEntity(engine)\n  const CreatedBy = components.CreatedBy(engine)\n  const NetworkParent = components.NetworkParent(engine)\n\n  // Type guard to check if component supports corrections (both LWW and GrowOnlySet)\n  function supportsCorrections<T>(\n    component: ComponentDefinition<T>\n  ): component is LastWriteWinElementSetComponentDefinition<T> | GrowOnlyValueSetComponentDefinition<T> {\n    return (\n      (component.componentType === ComponentType.LastWriteWinElementSet ||\n        component.componentType === ComponentType.GrowOnlyValueSet) &&\n      'getCrdtState' in component\n    )\n  }\n\n  function findExistingNetworkEntity(message: utils.NetworkMessage): Entity | null {\n    // Look for existing network entity mapping (don't create new ones)\n    for (const [entityId, networkData] of engine.getEntitiesWith(NetworkEntity)) {\n      if (networkData.networkId === message.networkId && networkData.entityId === message.entityId) {\n        return entityId\n      }\n    }\n    // Return null if not found\n    return null\n  }\n\n  function findOrCreateNetworkEntity(message: utils.NetworkMessage, sender: string, isServer: boolean): Entity {\n    // Look for existing network entity mapping first\n    const existingEntity = findExistingNetworkEntity(message)\n\n    if (existingEntity) {\n      return existingEntity\n    }\n\n    // Create new entity and network mapping\n    const newEntityId = engine.addEntity()\n    NetworkEntity.createOrReplace(newEntityId, {\n      networkId: message.networkId,\n      entityId: message.entityId\n    })\n\n    if (isServer) {\n      CreatedBy.createOrReplace(newEntityId, { address: sender })\n    }\n\n    DEBUG_NETWORK_MESSAGES() &&\n      console.log(`[DEBUG] Created new entity ${newEntityId} for network ${message.networkId}:${message.entityId}`)\n    return newEntityId\n  }\n\n  function convertNetworkToRegularMessage(\n    networkMessage: utils.NetworkMessage,\n    localEntityId: Entity,\n    forceCorrections = false\n  ): (CrdtMessageBody & { messageBuffer: Uint8Array }) | null {\n    const buffer = new ReadWriteByteBuffer()\n\n    try {\n      // Use the well-tested networkMessageToLocal utility with transform fixing for Unity\n      const message = utils.networkMessageToLocal(\n        networkMessage,\n        localEntityId,\n        buffer,\n        NetworkParent,\n        forceCorrections\n      )\n      return { ...message, messageBuffer: buffer.toBinary() }\n    } catch (error) {\n      DEBUG_NETWORK_MESSAGES() && console.error('Error converting network message:', error)\n      return null\n    }\n  }\n\n  function validateMessagePermissions(message: utils.RegularMessage, sender: string, _localEntityId: Entity): boolean {\n    // Basic checks\n    if (!sender || sender === AUTH_SERVER_PEER_ID) {\n      return false // Server shouldn't send messages to itself\n    }\n\n    if (message.type === CrdtMessageType.DELETE_ENTITY) {\n      // TODO: how to handle this case ?\n    }\n\n    if (message.type === CrdtMessageType.PUT_COMPONENT || message.type === CrdtMessageType.DELETE_COMPONENT) {\n      const component = engine.getComponent(message.componentId) as InternalBaseComponent<unknown>\n      const buf = 'data' in message ? new ReadWriteByteBuffer(message.data) : null\n      const value = buf ? component.schema.deserialize(buf) : null\n      const dryRunCRDT = component.__dry_run_updateFromCrdt(message)\n      const validCRDT = [\n        ProcessMessageResultType.StateUpdatedData,\n        ProcessMessageResultType.StateUpdatedTimestamp,\n        ProcessMessageResultType.EntityDeleted\n      ].includes(dryRunCRDT)\n      const createdBy = CreatedBy.getOrNull(message.entityId)\n      const validMessage =\n        validCRDT &&\n        component.__run_validateBeforeChange(message.entityId, value, sender, createdBy?.address ?? AUTH_SERVER_PEER_ID)\n\n      return !!validMessage\n    }\n\n    // For now, basic validation - in the future this will check component sync permissions\n    // TODO: Check if sender owns the entity\n    // TODO: Check component sync mode ('all' | 'owner' | 'server')\n    // TODO: Run component custom validation\n    return true\n  }\n\n  function broadcastBatchedMessages(messages: utils.NetworkMessage[], excludeSender: string) {\n    if (messages.length === 0) return\n\n    // Build the complete buffer with all messages\n    const networkBuffer = new ReadWriteByteBuffer()\n    for (const message of messages) {\n      // Skip oversized messages upfront\n      if (message.messageBuffer.byteLength / 1024 > LIVEKIT_MAX_SIZE) {\n        console.error(\n          `Message too large (${message.messageBuffer.byteLength} bytes), skipping message from ${excludeSender}`\n        )\n        continue\n      }\n      networkBuffer.writeBuffer(message.messageBuffer, false)\n    }\n\n    // Use the chunking function to split into proper chunks\n    const chunks = chunkCrdtMessages(networkBuffer.toBinary(), LIVEKIT_MAX_SIZE)\n\n    for (const chunk of chunks) {\n      binaryMessageBus.emit(CommsMessage.CRDT, chunk)\n    }\n    DEBUG_NETWORK_MESSAGES() &&\n      console.log(`Total: ${messages.length} messages in ${chunks.length} chunks from ${excludeSender}`)\n  }\n\n  function sendCorrectionToSender(networkMessage: utils.NetworkMessage, sender: string, localEntityId: Entity) {\n    try {\n      // Only handle component messages (PUT/DELETE), not entity deletion\n      if (networkMessage.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {\n        DEBUG_NETWORK_MESSAGES() && console.log('[AUTHORITATIVE] Cannot send authoritative message for entity deletion')\n        return\n      }\n\n      // Safe to access componentId and timestamp now\n      const component = engine.getComponent(networkMessage.componentId)\n\n      // Only proceed if component supports authoritative messages (LWW or GrowOnlySet)\n      if (!supportsCorrections(component)) {\n        DEBUG_NETWORK_MESSAGES() && console.log('[AUTHORITATIVE] Component does not support authoritative messages')\n        return\n      }\n\n      const serverCRDTState = component.getCrdtState(localEntityId)\n\n      if (serverCRDTState) {\n        // Create authoritative message using PUT_COMPONENT_NETWORK\n        // Each client will convert this to AUTHORITATIVE_PUT_COMPONENT with proper entity mapping\n        const correctionBuffer = new ReadWriteByteBuffer()\n        PutNetworkComponentOperation.write(\n          networkMessage.entityId, // Use original network entity ID\n          serverCRDTState.timestamp,\n          networkMessage.componentId,\n          networkMessage.networkId,\n          serverCRDTState.data,\n          correctionBuffer\n        )\n        // Send authoritative message directly to the sender\n        binaryMessageBus.emit(CommsMessage.CRDT_AUTHORITATIVE, correctionBuffer.toBinary(), [sender])\n\n        DEBUG_NETWORK_MESSAGES() &&\n          console.log(\n            `[AUTHORITATIVE] Sent authoritative message to ${sender} for entity ${localEntityId} component ${networkMessage.componentId} with timestamp ${networkMessage.timestamp}`\n          )\n      }\n    } catch (error) {\n      DEBUG_NETWORK_MESSAGES() && console.error('Error sending correction:', error)\n    }\n  }\n\n  return {\n    findExistingNetworkEntity,\n    // transform Network messages to CRDT Common Messages.\n    processClientMessages: function processClientMessages(value: Uint8Array, sender: string, forceCorrections = false) {\n      // console.log(`[CLIENT] Processing message from ${sender}, ${value.length} bytes`)\n\n      // Collect all regular messages in a single buffer for batched application\n      const combinedBuffer = new ReadWriteByteBuffer()\n\n      // Clients process network messages from server and convert them to regular messages\n      for (const message of utils.readMessages(value)) {\n        // Only process network messages in client message handler\n        if (utils.isNetworkMessage(message)) {\n          const networkMessage = message as utils.NetworkMessage\n\n          // Find or create network entity mapping\n          const localEntityId = findOrCreateNetworkEntity(networkMessage, sender, false)\n\n          // Convert network message to regular message or correction message\n          const regularMessage = convertNetworkToRegularMessage(networkMessage, localEntityId, forceCorrections)\n\n          if (regularMessage?.messageBuffer.byteLength) {\n            combinedBuffer.writeBuffer(regularMessage.messageBuffer, false)\n          }\n        }\n      }\n      return combinedBuffer.toBinary()\n    },\n    // Sever Code: process message, handle permissions, and broadcast if needed.\n    processServerMessages: function processServerMessages(value: Uint8Array, sender: string) {\n      // console.log(`[SERVER] Processing message from ${sender}, ${value.length} bytes`)\n\n      // Collect all valid messages for batched broadcasting\n      const messagesToBroadcast: utils.NetworkMessage[] = []\n      const regularMessagesBuffer = new ReadWriteByteBuffer()\n\n      for (const message of utils.readMessages(value)) {\n        try {\n          // Only process network messages in server message handler\n          if (utils.isNetworkMessage(message)) {\n            const networkMessage = message as utils.NetworkMessage\n            // 1. Find or create network entity mapping\n            const localEntityId = findOrCreateNetworkEntity(networkMessage, sender, true)\n\n            // 2. Convert network message to regular message and collect for local application\n            const regularMessage = convertNetworkToRegularMessage(networkMessage, localEntityId)\n\n            // 3. Basic permission validation\n            if (!validateMessagePermissions(regularMessage as any, sender, localEntityId)) {\n              // Send correction back to sender with server's authoritative state\n              sendCorrectionToSender(networkMessage, sender, localEntityId)\n              continue\n            }\n\n            // 4. Collect valid message for batched broadcasting\n            messagesToBroadcast.push(networkMessage)\n\n            if (regularMessage?.messageBuffer.byteLength) {\n              regularMessagesBuffer.writeBuffer(regularMessage.messageBuffer, false)\n            }\n          }\n        } catch (error) {\n          DEBUG_NETWORK_MESSAGES() && console.error('Error processing server message:', error)\n        }\n      }\n      // Batch broadcast all valid messages together\n      broadcastBatchedMessages(messagesToBroadcast, sender)\n      return regularMessagesBuffer.toBinary()\n    },\n    // engine changes that needs to be broadcasted.\n    convertRegularToNetworkMessage: function convertRegularToNetworkMessage(regularMessage: Uint8Array): Uint8Array[] {\n      const groupedBuffer = new ReadWriteByteBuffer()\n\n      // First pass: Convert all regular messages to network format and group them into one big buffer\n      for (const message of utils.readMessages(regularMessage)) {\n        // Only convert regular messages that have network data\n        const networkData = NetworkEntity.getOrNull(message.entityId)\n\n        if (networkData && !utils.isNetworkMessage(message)) {\n          utils.localMessageToNetwork(message, networkData, groupedBuffer)\n        }\n      }\n\n      // Second pass: Use the new chunking function that respects message boundaries\n      const totalData = groupedBuffer.toBinary()\n      return chunkCrdtMessages(totalData, LIVEKIT_MAX_SIZE)\n    }\n  }\n}\n"]}

package/network/server/utils.d.ts

@@ -0,0 +1,18 @@
+import { Entity } from '@dcl/ecs/dist/engine';
+import { NetworkParent } from '@dcl/ecs';
+import { ReceiveMessage } from '@dcl/ecs/dist/runtime/types';
+import { ReceiveNetworkMessage } from '@dcl/ecs/dist/systems/crdt/types';
+import { ByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer';
+import { CrdtMessageBody, DeleteComponentMessage, DeleteComponentNetworkMessage, DeleteEntityMessage, DeleteEntityNetworkMessage, PutComponentMessage, AuthoritativePutComponentMessage, PutNetworkComponentMessage } from '@dcl/ecs/dist/serialization/crdt/types';
+import { INetowrkEntityType } from '@dcl/ecs/dist/components/types';
+export type NetworkMessage = (PutNetworkComponentMessage | DeleteComponentNetworkMessage | DeleteEntityNetworkMessage) & {
+    messageBuffer: Uint8Array;
+};
+export type RegularMessage = (PutComponentMessage | AuthoritativePutComponentMessage | DeleteComponentMessage | DeleteEntityMessage) & {
+    messageBuffer: Uint8Array;
+};
+export declare function readMessages(data: Uint8Array): (NetworkMessage | RegularMessage)[];
+export declare function isNetworkMessage(message: ReceiveMessage): message is ReceiveNetworkMessage;
+export declare function networkMessageToLocal(message: ReceiveNetworkMessage, localEntityId: Entity, destinationBuffer: ByteBuffer, networkParentComponent?: typeof NetworkParent, forceCorrections?: boolean): CrdtMessageBody;
+export declare function localMessageToNetwork(message: ReceiveMessage, network: INetowrkEntityType, destinationBuffer: ByteBuffer): void;
+export declare function fixTransformParent(message: ReceiveMessage, parent?: Entity): Uint8Array;

package/network/server/utils.js

@@ -0,0 +1,135 @@
+import { CrdtMessageProtocol } from '@dcl/ecs';
+import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer';
+import { AuthoritativePutComponentOperation, PutComponentOperation } from '@dcl/ecs/dist/serialization/crdt';
+import { CrdtMessageType } from '@dcl/ecs/dist/serialization/crdt/types';
+import { DeleteComponent } from '@dcl/ecs/dist/serialization/crdt/deleteComponent';
+import { DeleteEntity } from '@dcl/ecs/dist/serialization/crdt/deleteEntity';
+import { PutNetworkComponentOperation } from '@dcl/ecs/dist/serialization/crdt/network/putComponentNetwork';
+import { DeleteComponentNetwork } from '@dcl/ecs/dist/serialization/crdt/network/deleteComponentNetwork';
+import { DeleteEntityNetwork } from '@dcl/ecs/dist/serialization/crdt/network/deleteEntityNetwork';
+import { TransformSchema, COMPONENT_ID as TransformComponentId } from '@dcl/ecs/dist/components/manual/Transform';
+export function readMessages(data) {
+    const buffer = new ReadWriteByteBuffer(data);
+    const messages = [];
+    let header;
+    while ((header = CrdtMessageProtocol.getHeader(buffer))) {
+        const offset = buffer.currentReadOffset();
+        let message = undefined;
+        // Network messages
+        if (header.type === CrdtMessageType.DELETE_COMPONENT_NETWORK) {
+            message = DeleteComponentNetwork.read(buffer);
+        }
+        else if (header.type === CrdtMessageType.PUT_COMPONENT_NETWORK) {
+            message = PutNetworkComponentOperation.read(buffer);
+        }
+        else if (header.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {
+            message = DeleteEntityNetwork.read(buffer);
+        }
+        // Regular messages
+        else if (header.type === CrdtMessageType.PUT_COMPONENT) {
+            message = PutComponentOperation.read(buffer);
+        }
+        else if (header.type === CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT) {
+            message = AuthoritativePutComponentOperation.read(buffer);
+        }
+        else if (header.type === CrdtMessageType.DELETE_COMPONENT) {
+            message = DeleteComponent.read(buffer);
+        }
+        else if (header.type === CrdtMessageType.DELETE_ENTITY) {
+            message = DeleteEntity.read(buffer);
+        }
+        else {
+            // consume unknown messages
+            buffer.incrementReadOffset(header.length);
+        }
+        if (message) {
+            messages.push({
+                ...message,
+                messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())
+            });
+        }
+    }
+    return messages;
+}
+export function isNetworkMessage(message) {
+    return [
+        CrdtMessageType.DELETE_COMPONENT_NETWORK,
+        CrdtMessageType.DELETE_ENTITY_NETWORK,
+        CrdtMessageType.PUT_COMPONENT_NETWORK
+    ].includes(message.type);
+}
+export function networkMessageToLocal(message, localEntityId, destinationBuffer, 
+// Optional network parent component for transform fixing
+networkParentComponent, 
+// Force corrections - converts PUT_COMPONENT_NETWORK to authoritative_PUT_COMPONENT
+forceCorrections = false) {
+    if (message.type === CrdtMessageType.PUT_COMPONENT_NETWORK) {
+        let messageData = message.data;
+        // Fix transform parent if needed for Unity/engine processing
+        if (message.componentId === TransformComponentId && networkParentComponent) {
+            const parentNetwork = networkParentComponent.getOrNull(localEntityId);
+            messageData = fixTransformParent(message, parentNetwork?.entityId);
+        }
+        if (forceCorrections) {
+            // Use AUTHORITATIVE_PUT_COMPONENT for forced state updates
+            AuthoritativePutComponentOperation.write(localEntityId, message.timestamp, message.componentId, messageData, destinationBuffer);
+            return {
+                type: CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT,
+                componentId: message.componentId,
+                timestamp: message.timestamp,
+                data: messageData,
+                entityId: localEntityId
+            };
+        }
+        else {
+            // Normal PUT_COMPONENT conversion
+            PutComponentOperation.write(localEntityId, message.timestamp, message.componentId, messageData, destinationBuffer);
+            return {
+                type: CrdtMessageType.PUT_COMPONENT,
+                componentId: message.componentId,
+                timestamp: message.timestamp,
+                data: messageData,
+                entityId: localEntityId
+            };
+        }
+    }
+    else if (message.type === CrdtMessageType.DELETE_COMPONENT_NETWORK) {
+        DeleteComponent.write(localEntityId, message.componentId, message.timestamp, destinationBuffer);
+        return {
+            type: CrdtMessageType.DELETE_COMPONENT,
+            componentId: message.componentId,
+            timestamp: message.timestamp,
+            entityId: localEntityId
+        };
+    }
+    else if (message.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {
+        DeleteEntity.write(localEntityId, destinationBuffer);
+        return {
+            type: CrdtMessageType.DELETE_ENTITY,
+            entityId: localEntityId
+        };
+    }
+    throw 1;
+}
+export function localMessageToNetwork(message, network, destinationBuffer) {
+    if (message.type === CrdtMessageType.PUT_COMPONENT) {
+        PutNetworkComponentOperation.write(network.entityId, message.timestamp, message.componentId, network.networkId, message.data, destinationBuffer);
+    }
+    else if (message.type === CrdtMessageType.DELETE_COMPONENT) {
+        DeleteComponentNetwork.write(network.entityId, message.componentId, message.timestamp, network.networkId, destinationBuffer);
+    }
+    else if (message.type === CrdtMessageType.DELETE_ENTITY) {
+        DeleteEntityNetwork.write(network.entityId, network.networkId, destinationBuffer);
+    }
+}
+export function fixTransformParent(message, parent) {
+    const buffer = new ReadWriteByteBuffer();
+    const transform = 'data' in message && TransformSchema.deserialize(new ReadWriteByteBuffer(message.data));
+    if (!transform)
+        throw new Error('Invalid parent transform');
+    // Generate new transform raw data with the parent
+    const newTransform = { ...transform, parent };
+    TransformSchema.serialize(newTransform, buffer);
+    return buffer.toBinary();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/network/server/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { Entity } from '@dcl/ecs/dist/engine'\nimport { CrdtMessageProtocol, NetworkParent } from '@dcl/ecs'\nimport { ReceiveMessage } from '@dcl/ecs/dist/runtime/types'\nimport { ReceiveNetworkMessage } from '@dcl/ecs/dist/systems/crdt/types'\nimport { ByteBuffer, ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer'\nimport { AuthoritativePutComponentOperation, PutComponentOperation } from '@dcl/ecs/dist/serialization/crdt'\nimport {\n  CrdtMessage,\n  CrdtMessageBody,\n  CrdtMessageHeader,\n  CrdtMessageType,\n  DeleteComponentMessage,\n  DeleteComponentNetworkMessage,\n  DeleteEntityMessage,\n  DeleteEntityNetworkMessage,\n  PutComponentMessage,\n  AuthoritativePutComponentMessage,\n  PutNetworkComponentMessage\n} from '@dcl/ecs/dist/serialization/crdt/types'\nimport { DeleteComponent } from '@dcl/ecs/dist/serialization/crdt/deleteComponent'\nimport { DeleteEntity } from '@dcl/ecs/dist/serialization/crdt/deleteEntity'\nimport { INetowrkEntityType } from '@dcl/ecs/dist/components/types'\nimport { PutNetworkComponentOperation } from '@dcl/ecs/dist/serialization/crdt/network/putComponentNetwork'\nimport { DeleteComponentNetwork } from '@dcl/ecs/dist/serialization/crdt/network/deleteComponentNetwork'\nimport { DeleteEntityNetwork } from '@dcl/ecs/dist/serialization/crdt/network/deleteEntityNetwork'\nimport { TransformSchema, COMPONENT_ID as TransformComponentId } from '@dcl/ecs/dist/components/manual/Transform'\n\nexport type NetworkMessage = (\n  | PutNetworkComponentMessage\n  | DeleteComponentNetworkMessage\n  | DeleteEntityNetworkMessage\n) & { messageBuffer: Uint8Array }\n\nexport type RegularMessage = (\n  | PutComponentMessage\n  | AuthoritativePutComponentMessage\n  | DeleteComponentMessage\n  | DeleteEntityMessage\n) & {\n  messageBuffer: Uint8Array\n}\nexport function readMessages(data: Uint8Array): (NetworkMessage | RegularMessage)[] {\n  const buffer = new ReadWriteByteBuffer(data)\n  const messages: (NetworkMessage | RegularMessage)[] = []\n  let header: CrdtMessageHeader | null\n  while ((header = CrdtMessageProtocol.getHeader(buffer))) {\n    const offset = buffer.currentReadOffset()\n    let message: CrdtMessage | undefined = undefined\n\n    // Network messages\n    if (header.type === CrdtMessageType.DELETE_COMPONENT_NETWORK) {\n      message = DeleteComponentNetwork.read(buffer)!\n    } else if (header.type === CrdtMessageType.PUT_COMPONENT_NETWORK) {\n      message = PutNetworkComponentOperation.read(buffer)!\n    } else if (header.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {\n      message = DeleteEntityNetwork.read(buffer)!\n    }\n    // Regular messages\n    else if (header.type === CrdtMessageType.PUT_COMPONENT) {\n      message = PutComponentOperation.read(buffer)!\n    } else if (header.type === CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT) {\n      message = AuthoritativePutComponentOperation.read(buffer)!\n    } else if (header.type === CrdtMessageType.DELETE_COMPONENT) {\n      message = DeleteComponent.read(buffer)!\n    } else if (header.type === CrdtMessageType.DELETE_ENTITY) {\n      message = DeleteEntity.read(buffer)!\n    } else {\n      // consume unknown messages\n      buffer.incrementReadOffset(header.length)\n    }\n\n    if (message) {\n      messages.push({\n        ...message,\n        messageBuffer: buffer.buffer().subarray(offset, buffer.currentReadOffset())\n      })\n    }\n  }\n  return messages\n}\n\nexport function isNetworkMessage(message: ReceiveMessage): message is ReceiveNetworkMessage {\n  return [\n    CrdtMessageType.DELETE_COMPONENT_NETWORK,\n    CrdtMessageType.DELETE_ENTITY_NETWORK,\n    CrdtMessageType.PUT_COMPONENT_NETWORK\n  ].includes(message.type)\n}\n\nexport function networkMessageToLocal(\n  message: ReceiveNetworkMessage,\n  localEntityId: Entity,\n  destinationBuffer: ByteBuffer,\n  // Optional network parent component for transform fixing\n  networkParentComponent?: typeof NetworkParent,\n  // Force corrections - converts PUT_COMPONENT_NETWORK to authoritative_PUT_COMPONENT\n  forceCorrections = false\n): CrdtMessageBody {\n  if (message.type === CrdtMessageType.PUT_COMPONENT_NETWORK) {\n    let messageData = message.data\n\n    // Fix transform parent if needed for Unity/engine processing\n    if (message.componentId === TransformComponentId && networkParentComponent) {\n      const parentNetwork = networkParentComponent.getOrNull(localEntityId)\n      messageData = fixTransformParent(message, parentNetwork?.entityId)\n    }\n    if (forceCorrections) {\n      // Use AUTHORITATIVE_PUT_COMPONENT for forced state updates\n      AuthoritativePutComponentOperation.write(\n        localEntityId,\n        message.timestamp,\n        message.componentId,\n        messageData,\n        destinationBuffer\n      )\n      return {\n        type: CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT,\n        componentId: message.componentId,\n        timestamp: message.timestamp,\n        data: messageData,\n        entityId: localEntityId\n      }\n    } else {\n      // Normal PUT_COMPONENT conversion\n      PutComponentOperation.write(localEntityId, message.timestamp, message.componentId, messageData, destinationBuffer)\n      return {\n        type: CrdtMessageType.PUT_COMPONENT,\n        componentId: message.componentId,\n        timestamp: message.timestamp,\n        data: messageData,\n        entityId: localEntityId\n      }\n    }\n  } else if (message.type === CrdtMessageType.DELETE_COMPONENT_NETWORK) {\n    DeleteComponent.write(localEntityId, message.componentId, message.timestamp, destinationBuffer)\n    return {\n      type: CrdtMessageType.DELETE_COMPONENT,\n      componentId: message.componentId,\n      timestamp: message.timestamp,\n      entityId: localEntityId\n    }\n  } else if (message.type === CrdtMessageType.DELETE_ENTITY_NETWORK) {\n    DeleteEntity.write(localEntityId, destinationBuffer)\n    return {\n      type: CrdtMessageType.DELETE_ENTITY,\n      entityId: localEntityId\n    }\n  }\n  throw 1\n}\n\nexport function localMessageToNetwork(\n  message: ReceiveMessage,\n  network: INetowrkEntityType,\n  destinationBuffer: ByteBuffer\n) {\n  if (message.type === CrdtMessageType.PUT_COMPONENT) {\n    PutNetworkComponentOperation.write(\n      network.entityId,\n      message.timestamp,\n      message.componentId,\n      network.networkId,\n      message.data,\n      destinationBuffer\n    )\n  } else if (message.type === CrdtMessageType.DELETE_COMPONENT) {\n    DeleteComponentNetwork.write(\n      network.entityId,\n      message.componentId,\n      message.timestamp,\n      network.networkId,\n      destinationBuffer\n    )\n  } else if (message.type === CrdtMessageType.DELETE_ENTITY) {\n    DeleteEntityNetwork.write(network.entityId, network.networkId, destinationBuffer)\n  }\n}\n\nexport function fixTransformParent(message: ReceiveMessage, parent?: Entity): Uint8Array {\n  const buffer = new ReadWriteByteBuffer()\n  const transform = 'data' in message && TransformSchema.deserialize(new ReadWriteByteBuffer(message.data))\n\n  if (!transform) throw new Error('Invalid parent transform')\n\n  // Generate new transform raw data with the parent\n  const newTransform = { ...transform, parent }\n  TransformSchema.serialize(newTransform, buffer)\n  return buffer.toBinary()\n}\n"]}

package/network/state.js

@@ -1,6 +1,6 @@
 import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer';
 import { CrdtMessageProtocol, CrdtMessageType, PutComponentOperation, PutNetworkComponentOperation, NetworkEntity as _NetworkEntity, VideoEvent, AudioEvent, EngineInfo, GltfContainerLoadingState, PointerEventsResult, RaycastResult, RealmInfo, TweenState, UiDropdown, UiDropdownResult, UiInput, UiInputResult, UiText, UiTransform } from '@dcl/ecs';
-import { LIVEKIT_MAX_SIZE } from '@dcl/ecs/dist/systems/crdt';
+import { LIVEKIT_MAX_SIZE } from './server';
 export const NOT_SYNC_COMPONENTS = [
     VideoEvent,
     TweenState,
@@ -38,8 +38,7 @@ export function engineToCrdt(engine) {
             continue;
         }
         itComponentDefinition.dumpCrdtStateToBuffer(crdtBuffer, (entity) => {
-            const isNetworkEntity = NetworkEntity.has(entity);
-            return isNetworkEntity;
+            return NetworkEntity.has(entity);
         });
     }
     let header;
@@ -57,7 +56,6 @@ export function engineToCrdt(engine) {
                     networkBuffer.resetBuffer();
                 }
                 // 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}`);
                     continue;
@@ -77,4 +75,4 @@ export function engineToCrdt(engine) {
     }
     return chunks;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state.js","sourceRoot":"","sources":["../src/network/state.ts"],"names":[],"mappings":"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","sourcesContent":["import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer'\nimport {\n  CrdtMessageHeader,\n  CrdtMessageProtocol,\n  CrdtMessageType,\n  IEngine,\n  PutComponentOperation,\n  PutNetworkComponentOperation,\n  SyncComponents as _SyncComponents,\n  NetworkEntity as _NetworkEntity,\n  INetowrkEntity,\n  VideoEvent,\n  AudioEvent,\n  EngineInfo,\n  GltfContainerLoadingState,\n  PointerEventsResult,\n  RaycastResult,\n  RealmInfo,\n  TweenState,\n  UiDropdown,\n  UiDropdownResult,\n  UiInput,\n  UiInputResult,\n  UiText,\n  UiTransform,\n  ComponentDefinition\n} from '@dcl/ecs'\nimport { LIVEKIT_MAX_SIZE } from '@dcl/ecs/dist/systems/crdt'\n\nexport const NOT_SYNC_COMPONENTS: ComponentDefinition<unknown>[] = [\n  VideoEvent,\n  TweenState,\n  AudioEvent,\n  EngineInfo,\n  GltfContainerLoadingState,\n  PointerEventsResult,\n  RaycastResult,\n  RealmInfo,\n  UiDropdown,\n  UiDropdownResult,\n  UiInput,\n  UiInputResult,\n  UiTransform,\n  UiText\n]\n\nexport const NOT_SYNC_COMPONENTS_IDS = NOT_SYNC_COMPONENTS.map(($) => $.componentId)\nexport const NOT_SYNC_COMPONENTS_NAMES: string[] = [\n  'asset-packs::Script' // ComponentName from: https://github.com/decentraland/asset-packs/blob/main/src/enums.ts\n]\n\nexport function shouldSyncComponent(component: ComponentDefinition<unknown>): boolean {\n  return !(\n    NOT_SYNC_COMPONENTS_IDS.includes(component.componentId) ||\n    NOT_SYNC_COMPONENTS_NAMES.includes(component.componentName)\n  )\n}\n\nexport function getDesyncedComponents(engine: IEngine): ComponentDefinition<unknown>[] {\n  return [...NOT_SYNC_COMPONENTS, ...NOT_SYNC_COMPONENTS_NAMES.map(($) => engine.getComponentOrNull($))].filter(\n    Boolean\n  ) as ComponentDefinition<unknown>[]\n}\n\nexport function engineToCrdt(engine: IEngine): Uint8Array[] {\n  const crdtBuffer = new ReadWriteByteBuffer()\n  const networkBuffer = new ReadWriteByteBuffer()\n  const NetworkEntity = engine.getComponent(_NetworkEntity.componentId) as INetowrkEntity\n  const chunks: Uint8Array[] = []\n\n  for (const itComponentDefinition of engine.componentsIter()) {\n    if (!shouldSyncComponent(itComponentDefinition)) {\n      continue\n    }\n    itComponentDefinition.dumpCrdtStateToBuffer(crdtBuffer, (entity) => {\n      const isNetworkEntity = NetworkEntity.has(entity)\n      return isNetworkEntity\n    })\n  }\n\n  let header: CrdtMessageHeader | null\n  while ((header = CrdtMessageProtocol.getHeader(crdtBuffer))) {\n    if (header.type === CrdtMessageType.PUT_COMPONENT) {\n      const message = PutComponentOperation.read(crdtBuffer)!\n      const networkEntity = NetworkEntity.getOrNull(message.entityId)\n\n      // Check if adding this message would exceed the size limit\n      const currentBufferSize = networkBuffer.toBinary().byteLength\n      const messageSize = message.data.byteLength\n\n      if ((currentBufferSize + messageSize) / 1024 > LIVEKIT_MAX_SIZE) {\n        // If the current buffer has content, save it as a chunk\n        if (currentBufferSize > 0) {\n          chunks.push(networkBuffer.toCopiedBinary())\n          networkBuffer.resetBuffer()\n        }\n\n        // If the message itself is larger than the limit, we need to handle it specially\n        // For now, we'll skip it to prevent infinite loops\n        if (messageSize / 1024 > LIVEKIT_MAX_SIZE) {\n          console.error(\n            `Message too large (${messageSize} bytes), skipping component ${message.componentId} for entity ${message.entityId}`\n          )\n          continue\n        }\n      }\n\n      if (networkEntity) {\n        PutNetworkComponentOperation.write(\n          networkEntity.entityId,\n          message.timestamp,\n          message.componentId,\n          networkEntity.networkId,\n          message.data,\n          networkBuffer\n        )\n      }\n    } else {\n      crdtBuffer.incrementReadOffset(header.length)\n    }\n  }\n\n  // Add any remaining data as the final chunk\n  if (networkBuffer.currentWriteOffset() > 0) {\n    chunks.push(networkBuffer.toBinary())\n  }\n\n  return chunks\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state.js","sourceRoot":"","sources":["../src/network/state.ts"],"names":[],"mappings":"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","sourcesContent":["import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer'\nimport {\n  CrdtMessageHeader,\n  CrdtMessageProtocol,\n  CrdtMessageType,\n  IEngine,\n  PutComponentOperation,\n  PutNetworkComponentOperation,\n  SyncComponents as _SyncComponents,\n  NetworkEntity as _NetworkEntity,\n  INetowrkEntity,\n  VideoEvent,\n  AudioEvent,\n  EngineInfo,\n  GltfContainerLoadingState,\n  PointerEventsResult,\n  RaycastResult,\n  RealmInfo,\n  TweenState,\n  UiDropdown,\n  UiDropdownResult,\n  UiInput,\n  UiInputResult,\n  UiText,\n  UiTransform,\n  ComponentDefinition\n} from '@dcl/ecs'\nimport { LIVEKIT_MAX_SIZE } from './server'\n\nexport const NOT_SYNC_COMPONENTS: ComponentDefinition<unknown>[] = [\n  VideoEvent,\n  TweenState,\n  AudioEvent,\n  EngineInfo,\n  GltfContainerLoadingState,\n  PointerEventsResult,\n  RaycastResult,\n  RealmInfo,\n  UiDropdown,\n  UiDropdownResult,\n  UiInput,\n  UiInputResult,\n  UiTransform,\n  UiText\n]\n\nexport const NOT_SYNC_COMPONENTS_IDS = NOT_SYNC_COMPONENTS.map(($) => $.componentId)\nexport const NOT_SYNC_COMPONENTS_NAMES: string[] = [\n  'asset-packs::Script' // ComponentName from: https://github.com/decentraland/asset-packs/blob/main/src/enums.ts\n]\n\nexport function shouldSyncComponent(component: ComponentDefinition<unknown>): boolean {\n  return !(\n    NOT_SYNC_COMPONENTS_IDS.includes(component.componentId) ||\n    NOT_SYNC_COMPONENTS_NAMES.includes(component.componentName)\n  )\n}\n\nexport function getDesyncedComponents(engine: IEngine): ComponentDefinition<unknown>[] {\n  return [...NOT_SYNC_COMPONENTS, ...NOT_SYNC_COMPONENTS_NAMES.map(($) => engine.getComponentOrNull($))].filter(\n    Boolean\n  ) as ComponentDefinition<unknown>[]\n}\n\nexport function engineToCrdt(engine: IEngine): Uint8Array[] {\n  const crdtBuffer = new ReadWriteByteBuffer()\n  const networkBuffer = new ReadWriteByteBuffer()\n  const NetworkEntity = engine.getComponent(_NetworkEntity.componentId) as INetowrkEntity\n  const chunks: Uint8Array[] = []\n\n  for (const itComponentDefinition of engine.componentsIter()) {\n    if (!shouldSyncComponent(itComponentDefinition)) {\n      continue\n    }\n\n    itComponentDefinition.dumpCrdtStateToBuffer(crdtBuffer, (entity) => {\n      return NetworkEntity.has(entity)\n    })\n  }\n\n  let header: CrdtMessageHeader | null\n  while ((header = CrdtMessageProtocol.getHeader(crdtBuffer))) {\n    if (header.type === CrdtMessageType.PUT_COMPONENT) {\n      const message = PutComponentOperation.read(crdtBuffer)!\n      const networkEntity = NetworkEntity.getOrNull(message.entityId)\n\n      // Check if adding this message would exceed the size limit\n      const currentBufferSize = networkBuffer.toBinary().byteLength\n      const messageSize = message.data.byteLength\n\n      if ((currentBufferSize + messageSize) / 1024 > LIVEKIT_MAX_SIZE) {\n        // If the current buffer has content, save it as a chunk\n        if (currentBufferSize > 0) {\n          chunks.push(networkBuffer.toCopiedBinary())\n          networkBuffer.resetBuffer()\n        }\n\n        // If the message itself is larger than the limit, we need to handle it specially\n        if (messageSize / 1024 > LIVEKIT_MAX_SIZE) {\n          console.error(\n            `Message too large (${messageSize} bytes), skipping component ${message.componentId} for entity ${message.entityId}`\n          )\n          continue\n        }\n      }\n\n      if (networkEntity) {\n        PutNetworkComponentOperation.write(\n          networkEntity.entityId,\n          message.timestamp,\n          message.componentId,\n          networkEntity.networkId,\n          message.data,\n          networkBuffer\n        )\n      }\n    } else {\n      crdtBuffer.incrementReadOffset(header.length)\n    }\n  }\n\n  // Add any remaining data as the final chunk\n  if (networkBuffer.currentWriteOffset() > 0) {\n    chunks.push(networkBuffer.toBinary())\n  }\n\n  return chunks\n}\n"]}

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@dcl/sdk",
   "description": "",
-  "version": "7.20.2-22104870534.commit-0df3cc0",
+  "version": "7.20.2-22169778016.commit-030cbfe",
   "author": "Decentraland",
   "dependencies": {
-    "@dcl/ecs": "7.20.2-22104870534.commit-0df3cc0",
+    "@dcl/ecs": "7.20.2-22169778016.commit-030cbfe",
     "@dcl/ecs-math": "2.1.0",
     "@dcl/explorer": "1.0.164509-20240802172549.commit-fb95b9b",
-    "@dcl/js-runtime": "7.20.2-22104870534.commit-0df3cc0",
-    "@dcl/react-ecs": "7.20.2-22104870534.commit-0df3cc0",
-    "@dcl/sdk-commands": "7.20.2-22104870534.commit-0df3cc0",
+    "@dcl/js-runtime": "7.20.2-22169778016.commit-030cbfe",
+    "@dcl/react-ecs": "7.20.2-22169778016.commit-030cbfe",
+    "@dcl/sdk-commands": "7.20.2-22169778016.commit-030cbfe",
     "text-encoding": "0.7.0"
   },
   "keywords": [],
@@ -35,5 +35,5 @@
   },
   "types": "./index.d.ts",
   "typings": "./index.d.ts",
-  "commit": "0df3cc09f672669cf4f67ffc4f9946ca5b3ebeb7"
+  "commit": "030cbfee8a40495d9916ade20280282e63e3cc8b"
 }

package/server/env-var.d.ts

@@ -0,0 +1,15 @@
+/**
+ * EnvVar provides methods to fetch environment variables from the
+ * Server Side Storage service. This module only works when running
+ * on server-side scenes.
+ */
+export declare const EnvVar: {
+    /**
+     * Fetches a specific environment variable by key as plain text.
+     *
+     * @param key - The name of the environment variable to fetch
+     * @returns A promise that resolves to the plain text value, or empty string if not found
+     * @throws Error if not running on a server-side scene
+     */
+    get(key: string): Promise<string>;
+};

package/server/env-var.js

@@ -0,0 +1,31 @@
+import { getStorageServerUrl } from './storage-url';
+import { assertIsServer, wrapSignedFetch } from './utils';
+const MODULE_NAME = 'EnvVar';
+/**
+ * EnvVar provides methods to fetch environment variables from the
+ * Server Side Storage service. This module only works when running
+ * on server-side scenes.
+ */
+export const EnvVar = {
+    /**
+     * Fetches a specific environment variable by key as plain text.
+     *
+     * @param key - The name of the environment variable to fetch
+     * @returns A promise that resolves to the plain text value, or empty string if not found
+     * @throws Error if not running on a server-side scene
+     */
+    async get(key) {
+        assertIsServer(MODULE_NAME);
+        const baseUrl = await getStorageServerUrl();
+        const url = `${baseUrl}/env/${encodeURIComponent(key)}`;
+        const [error, data] = await wrapSignedFetch({
+            url
+        });
+        if (error) {
+            console.error(`Failed to fetch environment variable '${key}': ${error}`);
+            return '';
+        }
+        return data?.value ?? '';
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52LXZhci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9zZXJ2ZXIvZW52LXZhci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFDbkQsT0FBTyxFQUFFLGNBQWMsRUFBRSxlQUFlLEVBQUUsTUFBTSxTQUFTLENBQUE7QUFFekQsTUFBTSxXQUFXLEdBQUcsUUFBUSxDQUFBO0FBRTVCOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUc7SUFDcEI7Ozs7OztPQU1HO0lBQ0gsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFXO1FBQ25CLGNBQWMsQ0FBQyxXQUFXLENBQUMsQ0FBQTtRQUUzQixNQUFNLE9BQU8sR0FBRyxNQUFNLG1CQUFtQixFQUFFLENBQUE7UUFDM0MsTUFBTSxHQUFHLEdBQUcsR0FBRyxPQUFPLFFBQVEsa0JBQWtCLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQTtRQUV2RCxNQUFNLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxHQUFHLE1BQU0sZUFBZSxDQUFvQjtZQUM3RCxHQUFHO1NBQ0osQ0FBQyxDQUFBO1FBRUYsSUFBSSxLQUFLLEVBQUU7WUFDVCxPQUFPLENBQUMsS0FBSyxDQUFDLHlDQUF5QyxHQUFHLE1BQU0sS0FBSyxFQUFFLENBQUMsQ0FBQTtZQUN4RSxPQUFPLEVBQUUsQ0FBQTtTQUNWO1FBRUQsT0FBTyxJQUFJLEVBQUUsS0FBSyxJQUFJLEVBQUUsQ0FBQTtJQUMxQixDQUFDO0NBQ0YsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdldFN0b3JhZ2VTZXJ2ZXJVcmwgfSBmcm9tICcuL3N0b3JhZ2UtdXJsJ1xuaW1wb3J0IHsgYXNzZXJ0SXNTZXJ2ZXIsIHdyYXBTaWduZWRGZXRjaCB9IGZyb20gJy4vdXRpbHMnXG5cbmNvbnN0IE1PRFVMRV9OQU1FID0gJ0VudlZhcidcblxuLyoqXG4gKiBFbnZWYXIgcHJvdmlkZXMgbWV0aG9kcyB0byBmZXRjaCBlbnZpcm9ubWVudCB2YXJpYWJsZXMgZnJvbSB0aGVcbiAqIFNlcnZlciBTaWRlIFN0b3JhZ2Ugc2VydmljZS4gVGhpcyBtb2R1bGUgb25seSB3b3JrcyB3aGVuIHJ1bm5pbmdcbiAqIG9uIHNlcnZlci1zaWRlIHNjZW5lcy5cbiAqL1xuZXhwb3J0IGNvbnN0IEVudlZhciA9IHtcbiAgLyoqXG4gICAqIEZldGNoZXMgYSBzcGVjaWZpYyBlbnZpcm9ubWVudCB2YXJpYWJsZSBieSBrZXkgYXMgcGxhaW4gdGV4dC5cbiAgICpcbiAgICogQHBhcmFtIGtleSAtIFRoZSBuYW1lIG9mIHRoZSBlbnZpcm9ubWVudCB2YXJpYWJsZSB0byBmZXRjaFxuICAgKiBAcmV0dXJucyBBIHByb21pc2UgdGhhdCByZXNvbHZlcyB0byB0aGUgcGxhaW4gdGV4dCB2YWx1ZSwgb3IgZW1wdHkgc3RyaW5nIGlmIG5vdCBmb3VuZFxuICAgKiBAdGhyb3dzIEVycm9yIGlmIG5vdCBydW5uaW5nIG9uIGEgc2VydmVyLXNpZGUgc2NlbmVcbiAgICovXG4gIGFzeW5jIGdldChrZXk6IHN0cmluZyk6IFByb21pc2U8c3RyaW5nPiB7XG4gICAgYXNzZXJ0SXNTZXJ2ZXIoTU9EVUxFX05BTUUpXG5cbiAgICBjb25zdCBiYXNlVXJsID0gYXdhaXQgZ2V0U3RvcmFnZVNlcnZlclVybCgpXG4gICAgY29uc3QgdXJsID0gYCR7YmFzZVVybH0vZW52LyR7ZW5jb2RlVVJJQ29tcG9uZW50KGtleSl9YFxuXG4gICAgY29uc3QgW2Vycm9yLCBkYXRhXSA9IGF3YWl0IHdyYXBTaWduZWRGZXRjaDx7IHZhbHVlOiBzdHJpbmcgfT4oe1xuICAgICAgdXJsXG4gICAgfSlcblxuICAgIGlmIChlcnJvcikge1xuICAgICAgY29uc29sZS5lcnJvcihgRmFpbGVkIHRvIGZldGNoIGVudmlyb25tZW50IHZhcmlhYmxlICcke2tleX0nOiAke2Vycm9yfWApXG4gICAgICByZXR1cm4gJydcbiAgICB9XG5cbiAgICByZXR1cm4gZGF0YT8udmFsdWUgPz8gJydcbiAgfVxufVxuIl19

package/server/index.d.ts

@@ -0,0 +1,2 @@
+export { EnvVar } from './env-var';
+export { Storage, IStorage, ISceneStorage, IPlayerStorage, GetValuesOptions, GetValuesResult } from './storage';

package/server/index.js

@@ -0,0 +1,3 @@
+export { EnvVar } from './env-var';
+export { Storage } from './storage';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvc2VydmVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDbEMsT0FBTyxFQUFFLE9BQU8sRUFBOEUsTUFBTSxXQUFXLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBFbnZWYXIgfSBmcm9tICcuL2Vudi12YXInXG5leHBvcnQgeyBTdG9yYWdlLCBJU3RvcmFnZSwgSVNjZW5lU3RvcmFnZSwgSVBsYXllclN0b3JhZ2UsIEdldFZhbHVlc09wdGlvbnMsIEdldFZhbHVlc1Jlc3VsdCB9IGZyb20gJy4vc3RvcmFnZSdcbiJdfQ==