@dcl/sdk 7.21.1-22917715332.commit-e5d969d → 7.21.1-22918726402.commit-ee210ee

package/network/events/implementation.js

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

package/network/events/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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 { registerMessages, getRoom, EventContext } from './implementation';
+import { EventSchemaRegistry } from './registry';
+export { registerMessages, getRoom };
+export type { EventContext, EventSchemaRegistry };

package/network/events/index.js

@@ -0,0 +1,43 @@
+/**
+ * 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 } from './implementation';
+// Re-export public API - only what users need
+export { registerMessages, getRoom };
+//# sourceMappingURL=data:application/json;base64,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

package/network/events/protocol.d.ts

@@ -0,0 +1,27 @@
+import { EventSchemas, EventTypes, EventSchemaRegistry } from './registry';
+/**
+ * Encode an event into a binary buffer
+ * @param eventType - The type of event from the registry
+ * @param data - The event data matching the schema
+ * @param registry - Optional custom registry (defaults to EventSchemas)
+ * @returns Binary buffer containing the encoded event
+ */
+export declare function encodeEvent<T extends EventSchemaRegistry = typeof EventSchemas, K extends keyof T = keyof T>(eventType: K, data: EventTypes<T>[K], registry?: T): Uint8Array;
+/**
+ * Decode a binary buffer into an event
+ * @param data - Binary buffer containing the encoded event
+ * @param registry - Optional custom registry (defaults to EventSchemas)
+ * @returns Decoded event with type, payload, and timestamp
+ */
+export declare function decodeEvent<T extends EventSchemaRegistry = typeof EventSchemas>(data: Uint8Array, registry?: T): {
+    eventType: keyof T;
+    payload: EventTypes<T>[keyof T];
+    timestamp: number;
+};
+/**
+ * Validate if an event type exists in the registry
+ * @param eventType - The event type to check
+ * @param registry - Optional custom registry (defaults to EventSchemas)
+ * @returns True if the event type exists
+ */
+export declare function isValidEventType<T extends EventSchemaRegistry = typeof EventSchemas>(eventType: string, registry?: T): eventType is Extract<keyof T, string>;

package/network/events/protocol.js

@@ -0,0 +1,66 @@
+import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer';
+import { Schemas } from '@dcl/ecs';
+import { EventSchemas } from './registry';
+// Event envelope that wraps all events with metadata
+const EventEnvelope = Schemas.Map({
+    eventType: Schemas.String,
+    timestamp: Schemas.Int64
+});
+/**
+ * Encode an event into a binary buffer
+ * @param eventType - The type of event from the registry
+ * @param data - The event data matching the schema
+ * @param registry - Optional custom registry (defaults to EventSchemas)
+ * @returns Binary buffer containing the encoded event
+ */
+export function encodeEvent(eventType, data, registry = EventSchemas) {
+    const buffer = new ReadWriteByteBuffer();
+    // Write envelope with event type and timestamp
+    EventEnvelope.serialize({
+        eventType: eventType,
+        timestamp: Date.now()
+    }, buffer);
+    // Get the schema for this event type
+    const schema = registry[eventType];
+    if (!schema) {
+        throw new Error(`Unknown event type: ${String(eventType)}`);
+    }
+    // Write the typed payload
+    schema.serialize(data, buffer);
+    return buffer.toBinary();
+}
+/**
+ * Decode a binary buffer into an event
+ * @param data - Binary buffer containing the encoded event
+ * @param registry - Optional custom registry (defaults to EventSchemas)
+ * @returns Decoded event with type, payload, and timestamp
+ */
+export function decodeEvent(data, registry = EventSchemas) {
+    const buffer = new ReadWriteByteBuffer();
+    buffer.writeBuffer(data, false);
+    // Read envelope
+    const envelope = EventEnvelope.deserialize(buffer);
+    const eventType = envelope.eventType;
+    // Get the schema for this event type
+    const schema = registry[eventType];
+    if (!schema) {
+        throw new Error(`Unknown event type: ${String(eventType)}`);
+    }
+    // Read the typed payload
+    const payload = schema.deserialize(buffer);
+    return {
+        eventType,
+        payload,
+        timestamp: envelope.timestamp
+    };
+}
+/**
+ * Validate if an event type exists in the registry
+ * @param eventType - The event type to check
+ * @param registry - Optional custom registry (defaults to EventSchemas)
+ * @returns True if the event type exists
+ */
+export function isValidEventType(eventType, registry = EventSchemas) {
+    return eventType in registry;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdG9jb2wuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbmV0d29yay9ldmVudHMvcHJvdG9jb2wudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sd0NBQXdDLENBQUE7QUFDNUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLFVBQVUsQ0FBQTtBQUNsQyxPQUFPLEVBQUUsWUFBWSxFQUFtQyxNQUFNLFlBQVksQ0FBQTtBQUUxRSxxREFBcUQ7QUFDckQsTUFBTSxhQUFhLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQztJQUNoQyxTQUFTLEVBQUUsT0FBTyxDQUFDLE1BQU07SUFDekIsU0FBUyxFQUFFLE9BQU8sQ0FBQyxLQUFLO0NBQ3pCLENBQUMsQ0FBQTtBQUVGOzs7Ozs7R0FNRztBQUNILE1BQU0sVUFBVSxXQUFXLENBQ3pCLFNBQVksRUFDWixJQUFzQixFQUN0QixXQUFjLFlBQWlCO0lBRS9CLE1BQU0sTUFBTSxHQUFHLElBQUksbUJBQW1CLEVBQUUsQ0FBQTtJQUV4QywrQ0FBK0M7SUFDL0MsYUFBYSxDQUFDLFNBQVMsQ0FDckI7UUFDRSxTQUFTLEVBQUUsU0FBbUI7UUFDOUIsU0FBUyxFQUFFLElBQUksQ0FBQyxHQUFHLEVBQUU7S0FDdEIsRUFDRCxNQUFNLENBQ1AsQ0FBQTtJQUVELHFDQUFxQztJQUNyQyxNQUFNLE1BQU0sR0FBRyxRQUFRLENBQUMsU0FBUyxDQUFDLENBQUE7SUFDbEMsSUFBSSxDQUFDLE1BQU0sRUFBRTtRQUNYLE1BQU0sSUFBSSxLQUFLLENBQUMsdUJBQXVCLE1BQU0sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUE7S0FDNUQ7SUFFRCwwQkFBMEI7SUFDMUIsTUFBTSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUE7SUFFOUIsT0FBTyxNQUFNLENBQUMsUUFBUSxFQUFFLENBQUE7QUFDMUIsQ0FBQztBQUVEOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLFdBQVcsQ0FDekIsSUFBZ0IsRUFDaEIsV0FBYyxZQUFpQjtJQU0vQixNQUFNLE1BQU0sR0FBRyxJQUFJLG1CQUFtQixFQUFFLENBQUE7SUFDeEMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLENBQUE7SUFFL0IsZ0JBQWdCO0lBQ2hCLE1BQU0sUUFBUSxHQUFHLGFBQWEsQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLENBQUE7SUFDbEQsTUFBTSxTQUFTLEdBQUcsUUFBUSxDQUFDLFNBQW9CLENBQUE7SUFFL0MscUNBQXFDO0lBQ3JDLE1BQU0sTUFBTSxHQUFHLFFBQVEsQ0FBQyxTQUFTLENBQUMsQ0FBQTtJQUNsQyxJQUFJLENBQUMsTUFBTSxFQUFFO1FBQ1gsTUFBTSxJQUFJLEtBQUssQ0FBQyx1QkFBdUIsTUFBTSxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsQ0FBQTtLQUM1RDtJQUVELHlCQUF5QjtJQUN6QixNQUFNLE9BQU8sR0FBRyxNQUFNLENBQUMsV0FBVyxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBRTFDLE9BQU87UUFDTCxTQUFTO1FBQ1QsT0FBTztRQUNQLFNBQVMsRUFBRSxRQUFRLENBQUMsU0FBUztLQUM5QixDQUFBO0FBQ0gsQ0FBQztBQUVEOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLGdCQUFnQixDQUM5QixTQUFpQixFQUNqQixXQUFjLFlBQWlCO0lBRS9CLE9BQU8sU0FBUyxJQUFJLFFBQVEsQ0FBQTtBQUM5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVhZFdyaXRlQnl0ZUJ1ZmZlciB9IGZyb20gJ0BkY2wvZWNzL2Rpc3Qvc2VyaWFsaXphdGlvbi9CeXRlQnVmZmVyJ1xuaW1wb3J0IHsgU2NoZW1hcyB9IGZyb20gJ0BkY2wvZWNzJ1xuaW1wb3J0IHsgRXZlbnRTY2hlbWFzLCBFdmVudFR5cGVzLCBFdmVudFNjaGVtYVJlZ2lzdHJ5IH0gZnJvbSAnLi9yZWdpc3RyeSdcblxuLy8gRXZlbnQgZW52ZWxvcGUgdGhhdCB3cmFwcyBhbGwgZXZlbnRzIHdpdGggbWV0YWRhdGFcbmNvbnN0IEV2ZW50RW52ZWxvcGUgPSBTY2hlbWFzLk1hcCh7XG4gIGV2ZW50VHlwZTogU2NoZW1hcy5TdHJpbmcsXG4gIHRpbWVzdGFtcDogU2NoZW1hcy5JbnQ2NFxufSlcblxuLyoqXG4gKiBFbmNvZGUgYW4gZXZlbnQgaW50byBhIGJpbmFyeSBidWZmZXJcbiAqIEBwYXJhbSBldmVudFR5cGUgLSBUaGUgdHlwZSBvZiBldmVudCBmcm9tIHRoZSByZWdpc3RyeVxuICogQHBhcmFtIGRhdGEgLSBUaGUgZXZlbnQgZGF0YSBtYXRjaGluZyB0aGUgc2NoZW1hXG4gKiBAcGFyYW0gcmVnaXN0cnkgLSBPcHRpb25hbCBjdXN0b20gcmVnaXN0cnkgKGRlZmF1bHRzIHRvIEV2ZW50U2NoZW1hcylcbiAqIEByZXR1cm5zIEJpbmFyeSBidWZmZXIgY29udGFpbmluZyB0aGUgZW5jb2RlZCBldmVudFxuICovXG5leHBvcnQgZnVuY3Rpb24gZW5jb2RlRXZlbnQ8VCBleHRlbmRzIEV2ZW50U2NoZW1hUmVnaXN0cnkgPSB0eXBlb2YgRXZlbnRTY2hlbWFzLCBLIGV4dGVuZHMga2V5b2YgVCA9IGtleW9mIFQ+KFxuICBldmVudFR5cGU6IEssXG4gIGRhdGE6IEV2ZW50VHlwZXM8VD5bS10sXG4gIHJlZ2lzdHJ5OiBUID0gRXZlbnRTY2hlbWFzIGFzIFRcbik6IFVpbnQ4QXJyYXkge1xuICBjb25zdCBidWZmZXIgPSBuZXcgUmVhZFdyaXRlQnl0ZUJ1ZmZlcigpXG5cbiAgLy8gV3JpdGUgZW52ZWxvcGUgd2l0aCBldmVudCB0eXBlIGFuZCB0aW1lc3RhbXBcbiAgRXZlbnRFbnZlbG9wZS5zZXJpYWxpemUoXG4gICAge1xuICAgICAgZXZlbnRUeXBlOiBldmVudFR5cGUgYXMgc3RyaW5nLFxuICAgICAgdGltZXN0YW1wOiBEYXRlLm5vdygpXG4gICAgfSxcbiAgICBidWZmZXJcbiAgKVxuXG4gIC8vIEdldCB0aGUgc2NoZW1hIGZvciB0aGlzIGV2ZW50IHR5cGVcbiAgY29uc3Qgc2NoZW1hID0gcmVnaXN0cnlbZXZlbnRUeXBlXVxuICBpZiAoIXNjaGVtYSkge1xuICAgIHRocm93IG5ldyBFcnJvcihgVW5rbm93biBldmVudCB0eXBlOiAke1N0cmluZyhldmVudFR5cGUpfWApXG4gIH1cblxuICAvLyBXcml0ZSB0aGUgdHlwZWQgcGF5bG9hZFxuICBzY2hlbWEuc2VyaWFsaXplKGRhdGEsIGJ1ZmZlcilcblxuICByZXR1cm4gYnVmZmVyLnRvQmluYXJ5KClcbn1cblxuLyoqXG4gKiBEZWNvZGUgYSBiaW5hcnkgYnVmZmVyIGludG8gYW4gZXZlbnRcbiAqIEBwYXJhbSBkYXRhIC0gQmluYXJ5IGJ1ZmZlciBjb250YWluaW5nIHRoZSBlbmNvZGVkIGV2ZW50XG4gKiBAcGFyYW0gcmVnaXN0cnkgLSBPcHRpb25hbCBjdXN0b20gcmVnaXN0cnkgKGRlZmF1bHRzIHRvIEV2ZW50U2NoZW1hcylcbiAqIEByZXR1cm5zIERlY29kZWQgZXZlbnQgd2l0aCB0eXBlLCBwYXlsb2FkLCBhbmQgdGltZXN0YW1wXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZWNvZGVFdmVudDxUIGV4dGVuZHMgRXZlbnRTY2hlbWFSZWdpc3RyeSA9IHR5cGVvZiBFdmVudFNjaGVtYXM+KFxuICBkYXRhOiBVaW50OEFycmF5LFxuICByZWdpc3RyeTogVCA9IEV2ZW50U2NoZW1hcyBhcyBUXG4pOiB7XG4gIGV2ZW50VHlwZToga2V5b2YgVFxuICBwYXlsb2FkOiBFdmVudFR5cGVzPFQ+W2tleW9mIFRdXG4gIHRpbWVzdGFtcDogbnVtYmVyXG59IHtcbiAgY29uc3QgYnVmZmVyID0gbmV3IFJlYWRXcml0ZUJ5dGVCdWZmZXIoKVxuICBidWZmZXIud3JpdGVCdWZmZXIoZGF0YSwgZmFsc2UpXG5cbiAgLy8gUmVhZCBlbnZlbG9wZVxuICBjb25zdCBlbnZlbG9wZSA9IEV2ZW50RW52ZWxvcGUuZGVzZXJpYWxpemUoYnVmZmVyKVxuICBjb25zdCBldmVudFR5cGUgPSBlbnZlbG9wZS5ldmVudFR5cGUgYXMga2V5b2YgVFxuXG4gIC8vIEdldCB0aGUgc2NoZW1hIGZvciB0aGlzIGV2ZW50IHR5cGVcbiAgY29uc3Qgc2NoZW1hID0gcmVnaXN0cnlbZXZlbnRUeXBlXVxuICBpZiAoIXNjaGVtYSkge1xuICAgIHRocm93IG5ldyBFcnJvcihgVW5rbm93biBldmVudCB0eXBlOiAke1N0cmluZyhldmVudFR5cGUpfWApXG4gIH1cblxuICAvLyBSZWFkIHRoZSB0eXBlZCBwYXlsb2FkXG4gIGNvbnN0IHBheWxvYWQgPSBzY2hlbWEuZGVzZXJpYWxpemUoYnVmZmVyKVxuXG4gIHJldHVybiB7XG4gICAgZXZlbnRUeXBlLFxuICAgIHBheWxvYWQsXG4gICAgdGltZXN0YW1wOiBlbnZlbG9wZS50aW1lc3RhbXBcbiAgfVxufVxuXG4vKipcbiAqIFZhbGlkYXRlIGlmIGFuIGV2ZW50IHR5cGUgZXhpc3RzIGluIHRoZSByZWdpc3RyeVxuICogQHBhcmFtIGV2ZW50VHlwZSAtIFRoZSBldmVudCB0eXBlIHRvIGNoZWNrXG4gKiBAcGFyYW0gcmVnaXN0cnkgLSBPcHRpb25hbCBjdXN0b20gcmVnaXN0cnkgKGRlZmF1bHRzIHRvIEV2ZW50U2NoZW1hcylcbiAqIEByZXR1cm5zIFRydWUgaWYgdGhlIGV2ZW50IHR5cGUgZXhpc3RzXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpc1ZhbGlkRXZlbnRUeXBlPFQgZXh0ZW5kcyBFdmVudFNjaGVtYVJlZ2lzdHJ5ID0gdHlwZW9mIEV2ZW50U2NoZW1hcz4oXG4gIGV2ZW50VHlwZTogc3RyaW5nLFxuICByZWdpc3RyeTogVCA9IEV2ZW50U2NoZW1hcyBhcyBUXG4pOiBldmVudFR5cGUgaXMgRXh0cmFjdDxrZXlvZiBULCBzdHJpbmc+IHtcbiAgcmV0dXJuIGV2ZW50VHlwZSBpbiByZWdpc3RyeVxufVxuIl19

package/network/events/registry.d.ts

@@ -0,0 +1,8 @@
+import { ISchema } from '@dcl/ecs';
+export type EventSchemaRegistry = Record<string, ISchema>;
+export type EventTypes<T extends EventSchemaRegistry = EventSchemaRegistry> = {
+    [K in keyof T]: T[K] extends ISchema<infer U> ? U : never;
+};
+export type RegisteredEvents = EventSchemaRegistry;
+export declare const EventSchemas: EventSchemaRegistry;
+export type ValidateEventRegistry<T extends EventSchemaRegistry> = T;

package/network/events/registry.js

@@ -0,0 +1,3 @@
+// Default empty registry
+export const EventSchemas = {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbmV0d29yay9ldmVudHMvcmVnaXN0cnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBYUEseUJBQXlCO0FBQ3pCLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxFQUFzQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSVNjaGVtYSB9IGZyb20gJ0BkY2wvZWNzJ1xuXG4vLyBCYXNlIHR5cGUgZm9yIGV2ZW50IHNjaGVtYSByZWdpc3RyeVxuZXhwb3J0IHR5cGUgRXZlbnRTY2hlbWFSZWdpc3RyeSA9IFJlY29yZDxzdHJpbmcsIElTY2hlbWE+XG5cbi8vIFR5cGUgZXh0cmFjdGlvbiBmcm9tIHNjaGVtYXNcbmV4cG9ydCB0eXBlIEV2ZW50VHlwZXM8VCBleHRlbmRzIEV2ZW50U2NoZW1hUmVnaXN0cnkgPSBFdmVudFNjaGVtYVJlZ2lzdHJ5PiA9IHtcbiAgW0sgaW4ga2V5b2YgVF06IFRbS10gZXh0ZW5kcyBJU2NoZW1hPGluZmVyIFU+ID8gVSA6IG5ldmVyXG59XG5cbi8vIEdsb2JhbCBpbnRlcmZhY2UgdGhhdCB1c2VycyBjYW4gYXVnbWVudCB3aXRoIHRoZWlyIG93biBldmVudHNcbmV4cG9ydCB0eXBlIFJlZ2lzdGVyZWRFdmVudHMgPSBFdmVudFNjaGVtYVJlZ2lzdHJ5XG5cbi8vIERlZmF1bHQgZW1wdHkgcmVnaXN0cnlcbmV4cG9ydCBjb25zdCBFdmVudFNjaGVtYXMgPSB7fSBhcyBSZWdpc3RlcmVkRXZlbnRzXG5cbi8vIEhlbHBlciB0byBlbnN1cmUgdXNlciBldmVudHMgY29uZm9ybSB0byB0aGUgcmVnaXN0cnkgdHlwZVxuZXhwb3J0IHR5cGUgVmFsaWRhdGVFdmVudFJlZ2lzdHJ5PFQgZXh0ZW5kcyBFdmVudFNjaGVtYVJlZ2lzdHJ5PiA9IFRcbiJdfQ==

package/network/index.d.ts

@@ -1,2 +1,8 @@
-declare const getChildren: (parent: import("@dcl/ecs").Entity) => Iterable<import("@dcl/ecs").Entity>, syncEntity: (entityId: import("@dcl/ecs").Entity, componentIds: number[], entityEnumId?: number | undefined) => void, parentEntity: (entity: import("@dcl/ecs").Entity, parent: import("@dcl/ecs").Entity) => void, getParent: (child: import("@dcl/ecs").Entity) => import("@dcl/ecs").Entity | undefined, myProfile: import("./message-bus-sync").IProfile, removeParent: (entity: import("@dcl/ecs").Entity) => void, getFirstChild: (entity: import("@dcl/ecs").Entity) => import("@dcl/ecs").Entity, isStateSyncronized: () => boolean;
-export { getFirstChild, getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, isStateSyncronized };
+export declare function isServer(): boolean;
+declare const getChildren: (parent: import("@dcl/ecs").Entity) => Iterable<import("@dcl/ecs").Entity>, syncEntity: (entityId: import("@dcl/ecs").Entity, componentIds: number[], entityEnumId?: number | undefined) => void, parentEntity: (entity: import("@dcl/ecs").Entity, parent: import("@dcl/ecs").Entity) => void, getParent: (child: import("@dcl/ecs").Entity) => import("@dcl/ecs").Entity | undefined, myProfile: import("./message-bus-sync").IProfile, removeParent: (entity: import("@dcl/ecs").Entity) => void, getFirstChild: (entity: import("@dcl/ecs").Entity) => import("@dcl/ecs").Entity, isStateSyncronized: () => boolean, binaryMessageBus: {
+    on: <K extends import("./binary-message-bus").CommsMessage>(message: K, callback: (value: Uint8Array, sender: string) => void) => void;
+    emit: <K_1 extends import("./binary-message-bus").CommsMessage>(message: K_1, value: Uint8Array, toPeerAddress?: string[] | undefined) => void;
+    __processMessages: (messages: Uint8Array[]) => void;
+}, eventBus: import("./events/implementation").Room<import("./events").EventSchemaRegistry>;
+export { registerMessages, getRoom } from './events';
+export { getFirstChild, getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, isStateSyncronized, binaryMessageBus, eventBus };

package/network/index.js

@@ -2,7 +2,20 @@ 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(false);
+void isServerApi({}).then((response) => {
+    isServerAtom.swap(!!response.isServer);
+});
+// Helper function to check if running on server
+export function isServer() {
+    return isServerAtom.getOrNull() ?? false;
+}
 // initialize sync transport for sdk engine
-const { getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, getFirstChild, isStateSyncronized } = addSyncTransport(engine, sendBinary, getUserData);
-export { getFirstChild, getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, isStateSyncronized };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvbmV0d29yay9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0NBQWtDLENBQUE7QUFDN0QsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFVBQVUsQ0FBQTtBQUNqQyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQTtBQUNyRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUE7QUFFbEQsMkNBQTJDO0FBQzNDLE1BQU0sRUFBRSxXQUFXLEVBQUUsVUFBVSxFQUFFLFlBQVksRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxhQUFhLEVBQUUsa0JBQWtCLEVBQUUsR0FDcEgsZ0JBQWdCLENBQUMsTUFBTSxFQUFFLFVBQVUsRUFBRSxXQUFXLENBQUMsQ0FBQTtBQUVuRCxPQUFPLEVBQUUsYUFBYSxFQUFFLFdBQVcsRUFBRSxVQUFVLEVBQUUsWUFBWSxFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLGtCQUFrQixFQUFFLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzZW5kQmluYXJ5IH0gZnJvbSAnfnN5c3RlbS9Db21tdW5pY2F0aW9uc0NvbnRyb2xsZXInXG5pbXBvcnQgeyBlbmdpbmUgfSBmcm9tICdAZGNsL2VjcydcbmltcG9ydCB7IGFkZFN5bmNUcmFuc3BvcnQgfSBmcm9tICcuL21lc3NhZ2UtYnVzLXN5bmMnXG5pbXBvcnQgeyBnZXRVc2VyRGF0YSB9IGZyb20gJ35zeXN0ZW0vVXNlcklkZW50aXR5J1xuXG4vLyBpbml0aWFsaXplIHN5bmMgdHJhbnNwb3J0IGZvciBzZGsgZW5naW5lXG5jb25zdCB7IGdldENoaWxkcmVuLCBzeW5jRW50aXR5LCBwYXJlbnRFbnRpdHksIGdldFBhcmVudCwgbXlQcm9maWxlLCByZW1vdmVQYXJlbnQsIGdldEZpcnN0Q2hpbGQsIGlzU3RhdGVTeW5jcm9uaXplZCB9ID1cbiAgYWRkU3luY1RyYW5zcG9ydChlbmdpbmUsIHNlbmRCaW5hcnksIGdldFVzZXJEYXRhKVxuXG5leHBvcnQgeyBnZXRGaXJzdENoaWxkLCBnZXRDaGlsZHJlbiwgc3luY0VudGl0eSwgcGFyZW50RW50aXR5LCBnZXRQYXJlbnQsIG15UHJvZmlsZSwgcmVtb3ZlUGFyZW50LCBpc1N0YXRlU3luY3Jvbml6ZWQgfVxuIl19
+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';
+export { getFirstChild, getChildren, syncEntity, parentEntity, getParent, myProfile, removeParent, isStateSyncronized, binaryMessageBus, eventBus };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvbmV0d29yay9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0NBQWtDLENBQUE7QUFDN0QsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFVBQVUsQ0FBQTtBQUNqQyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQTtBQUNyRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUE7QUFDbEQsT0FBTyxFQUFFLFFBQVEsSUFBSSxXQUFXLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQTtBQUMzRCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sU0FBUyxDQUFBO0FBRTlCLDRDQUE0QztBQUM1QyxNQUFNLFlBQVksR0FBRyxJQUFJLENBQVUsS0FBSyxDQUFDLENBQUE7QUFDekMsS0FBSyxXQUFXLENBQUMsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsUUFBUSxFQUFFLEVBQUU7SUFDckMsWUFBWSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxDQUFBO0FBQ3hDLENBQUMsQ0FBQyxDQUFBO0FBRUYsZ0RBQWdEO0FBQ2hELE1BQU0sVUFBVSxRQUFRO0lBQ3RCLE9BQU8sWUFBWSxDQUFDLFNBQVMsRUFBRSxJQUFJLEtBQUssQ0FBQTtBQUMxQyxDQUFDO0FBRUQsMkNBQTJDO0FBQzNDLE1BQU0sRUFDSixXQUFXLEVBQ1gsVUFBVSxFQUNWLFlBQVksRUFDWixTQUFTLEVBQ1QsU0FBUyxFQUNULFlBQVksRUFDWixhQUFhLEVBQ2Isa0JBQWtCLEVBQ2xCLGdCQUFnQixFQUNoQixRQUFRLEVBQ1QsR0FBRyxnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxXQUFXLEVBQUUsU0FBUyxDQUFDLENBQUE7QUFFN0Usc0NBQXNDO0FBQ3RDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxPQUFPLEVBQUUsTUFBTSxVQUFVLENBQUE7QUFFcEQsT0FBTyxFQUNMLGFBQWEsRUFDYixXQUFXLEVBQ1gsVUFBVSxFQUNWLFlBQVksRUFDWixTQUFTLEVBQ1QsU0FBUyxFQUNULFlBQVksRUFDWixrQkFBa0IsRUFDbEIsZ0JBQWdCLEVBQ2hCLFFBQVEsRUFDVCxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgc2VuZEJpbmFyeSB9IGZyb20gJ35zeXN0ZW0vQ29tbXVuaWNhdGlvbnNDb250cm9sbGVyJ1xuaW1wb3J0IHsgZW5naW5lIH0gZnJvbSAnQGRjbC9lY3MnXG5pbXBvcnQgeyBhZGRTeW5jVHJhbnNwb3J0IH0gZnJvbSAnLi9tZXNzYWdlLWJ1cy1zeW5jJ1xuaW1wb3J0IHsgZ2V0VXNlckRhdGEgfSBmcm9tICd+c3lzdGVtL1VzZXJJZGVudGl0eSdcbmltcG9ydCB7IGlzU2VydmVyIGFzIGlzU2VydmVyQXBpIH0gZnJvbSAnfnN5c3RlbS9FbmdpbmVBcGknXG5pbXBvcnQgeyBBdG9tIH0gZnJvbSAnLi4vYXRvbSdcblxuLy8gQ3JlYXRlIGlzU2VydmVyIGF0b20gZm9yIGNvbnNpc3RlbnQgc3RhdGVcbmNvbnN0IGlzU2VydmVyQXRvbSA9IEF0b208Ym9vbGVhbj4oZmFsc2UpXG52b2lkIGlzU2VydmVyQXBpKHt9KS50aGVuKChyZXNwb25zZSkgPT4ge1xuICBpc1NlcnZlckF0b20uc3dhcCghIXJlc3BvbnNlLmlzU2VydmVyKVxufSlcblxuLy8gSGVscGVyIGZ1bmN0aW9uIHRvIGNoZWNrIGlmIHJ1bm5pbmcgb24gc2VydmVyXG5leHBvcnQgZnVuY3Rpb24gaXNTZXJ2ZXIoKTogYm9vbGVhbiB7XG4gIHJldHVybiBpc1NlcnZlckF0b20uZ2V0T3JOdWxsKCkgPz8gZmFsc2Vcbn1cblxuLy8gaW5pdGlhbGl6ZSBzeW5jIHRyYW5zcG9ydCBmb3Igc2RrIGVuZ2luZVxuY29uc3Qge1xuICBnZXRDaGlsZHJlbixcbiAgc3luY0VudGl0eSxcbiAgcGFyZW50RW50aXR5LFxuICBnZXRQYXJlbnQsXG4gIG15UHJvZmlsZSxcbiAgcmVtb3ZlUGFyZW50LFxuICBnZXRGaXJzdENoaWxkLFxuICBpc1N0YXRlU3luY3Jvbml6ZWQsXG4gIGJpbmFyeU1lc3NhZ2VCdXMsXG4gIGV2ZW50QnVzXG59ID0gYWRkU3luY1RyYW5zcG9ydChlbmdpbmUsIHNlbmRCaW5hcnksIGdldFVzZXJEYXRhLCBpc1NlcnZlckFwaSwgJ25ldHdvcmsnKVxuXG4vLyBSZS1leHBvcnQgdGhlIHJvb20gbWVzc2FnaW5nIHN5c3RlbVxuZXhwb3J0IHsgcmVnaXN0ZXJNZXNzYWdlcywgZ2V0Um9vbSB9IGZyb20gJy4vZXZlbnRzJ1xuXG5leHBvcnQge1xuICBnZXRGaXJzdENoaWxkLFxuICBnZXRDaGlsZHJlbixcbiAgc3luY0VudGl0eSxcbiAgcGFyZW50RW50aXR5LFxuICBnZXRQYXJlbnQsXG4gIG15UHJvZmlsZSxcbiAgcmVtb3ZlUGFyZW50LFxuICBpc1N0YXRlU3luY3Jvbml6ZWQsXG4gIGJpbmFyeU1lc3NhZ2VCdXMsXG4gIGV2ZW50QnVzXG59XG4iXX0=

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

@@ -1,14 +1,27 @@
 /// <reference types="@dcl/js-runtime" />
 import { IEngine } from '@dcl/ecs';
 import { type SendBinaryRequest, type SendBinaryResponse } from '~system/CommunicationsController';
+import { CommsMessage } from './binary-message-bus';
 import { GetUserDataRequest, GetUserDataResponse } from '~system/UserIdentity';
+import { IsServerRequest, IsServerResponse } from '~system/EngineApi';
+import { Atom } from '../atom';
+import { Room } from './events/implementation';
 export type IProfile = {
     networkId: number;
     userId: string;
 };
-export declare function addSyncTransport(engine: IEngine, sendBinary: (msg: SendBinaryRequest) => Promise<SendBinaryResponse>, getUserData: (value: GetUserDataRequest) => Promise<GetUserDataResponse>): {
+export declare const AUTH_SERVER_PEER_ID = "authoritative-server";
+export declare const DEBUG_NETWORK_MESSAGES: () => any;
+export declare function addSyncTransport(engine: IEngine, sendBinary: (msg: SendBinaryRequest) => Promise<SendBinaryResponse>, getUserData: (value: GetUserDataRequest) => Promise<GetUserDataResponse>, isServerFn: (request: IsServerRequest) => Promise<IsServerResponse>, name: string): {
     myProfile: IProfile;
     isStateSyncronized: () => boolean;
+    binaryMessageBus: {
+        on: <K extends CommsMessage>(message: K, callback: (value: Uint8Array, sender: string) => void) => void;
+        emit: <K_1 extends CommsMessage>(message: K_1, value: Uint8Array, toPeerAddress?: string[] | undefined) => void;
+        __processMessages: (messages: Uint8Array[]) => void;
+    };
+    eventBus: Room<import("./events").EventSchemaRegistry>;
+    isRoomReadyAtom: Atom<boolean>;
     syncEntity: (entityId: import("@dcl/ecs").Entity, componentIds: number[], entityEnumId?: number | undefined) => void;
     getChildren: (parent: import("@dcl/ecs").Entity) => Iterable<import("@dcl/ecs").Entity>;
     getParent: (child: import("@dcl/ecs").Entity) => import("@dcl/ecs").Entity | undefined;