@dcl/sdk 7.24.6-30098879609.commit-e704246 → 7.25.1-30310486734.commit-5ffe873

package/atom.d.ts

@@ -0,0 +1,19 @@
+declare class SimpleObservable<T> {
+    private observers;
+    private onceObservers;
+    add(callback: (value: T) => void): (value: T) => void;
+    addOnce(callback: (value: T) => void): void;
+    remove(callback: (value: T) => void): void;
+    notifyObservers(value: T): void;
+}
+declare const EMPTY: unique symbol;
+type EMPTY = typeof EMPTY;
+export type Atom<T> = {
+    deref(): Promise<T>;
+    getOrNull(): T | null;
+    observable: SimpleObservable<T>;
+    swap(value: T): T | void;
+    pipe(fn: (value: T) => void | Promise<void>): Promise<void>;
+};
+export declare function Atom<T>(initialValue?: T | EMPTY): Atom<T>;
+export {};

package/atom.js

@@ -0,0 +1,83 @@
+import future from './future';
+// atom value wrapper like in clojure
+// Simple Observable implementation to replace Babylon.js dependency
+class SimpleObservable {
+    constructor() {
+        this.observers = [];
+        this.onceObservers = [];
+    }
+    add(callback) {
+        this.observers.push(callback);
+        return callback;
+    }
+    addOnce(callback) {
+        this.onceObservers.push(callback);
+    }
+    remove(callback) {
+        const index = this.observers.indexOf(callback);
+        if (index > -1) {
+            this.observers.splice(index, 1);
+        }
+    }
+    notifyObservers(value) {
+        this.observers.forEach((observer) => observer(value));
+        if (this.onceObservers.length > 0) {
+            this.onceObservers.forEach((observer) => observer(value));
+            this.onceObservers.length = 0;
+        }
+    }
+}
+const EMPTY = Symbol('empty');
+export function Atom(initialValue = EMPTY) {
+    const observable = new SimpleObservable();
+    let value = initialValue;
+    const valueFutures = [];
+    observable.addOnce((value) => {
+        valueFutures.forEach(($) => $.resolve(value));
+        valueFutures.length = 0;
+    });
+    return {
+        async pipe(fn) {
+            observable.add(async (t) => {
+                try {
+                    await fn(t);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+            if (value !== EMPTY) {
+                try {
+                    await fn(value);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            }
+        },
+        deref() {
+            if (value === EMPTY) {
+                const ret = future();
+                valueFutures.push(ret);
+                return ret;
+            }
+            return Promise.resolve(value);
+        },
+        getOrNull() {
+            if (value === EMPTY) {
+                return null;
+            }
+            return value;
+        },
+        observable,
+        swap(newValue) {
+            const oldValue = value;
+            if (newValue !== value) {
+                value = newValue;
+                observable.notifyObservers(value);
+            }
+            return oldValue === EMPTY ? undefined : oldValue;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/composite-provider.js

@@ -1,7 +1,6 @@
 import { compositeFromLoader } from '~sdk/all-composites';
 import { readFile } from '~system/Runtime';
-import { Composite } from '@dcl/ecs';
-import { decodeUtf8 } from './internal/utf8';
+import { Composite, getGlobal } from '@dcl/ecs';
 const composites = new Map();
 function findCached(src) {
     return composites.get(src) ?? null;
@@ -28,8 +27,14 @@ function decodeFromBytes(content) {
     // The first-byte check is a fast path; a JSON.parse failure falls back to fromBinary
     // because a protobuf message can also begin with 0x7b.
     if (content[0] === 0x7b /* '{' */) {
+        const TD = getGlobal('TextDecoder');
+        if (!TD) {
+            throw new Error('loadComposite: TextDecoder is not available in this runtime. ' +
+                'Use a .composite.bin file, or import `@dcl/sdk/ethereum-provider` ' +
+                'to install the TextEncoder/TextDecoder polyfill.');
+        }
         try {
-            return Composite.fromJson(JSON.parse(decodeUtf8(content, { fatal: true })));
+            return Composite.fromJson(JSON.parse(new TD().decode(content)));
         }
         catch {
             return Composite.fromBinary(content);
@@ -64,4 +69,4 @@ export const compositeProvider = {
         return cache(src, composite);
     }
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/future.d.ts

@@ -0,0 +1,8 @@
+export type IFuture<T> = Promise<T> & {
+    resolve: (x: T) => void;
+    reject: (x: Error) => void;
+    finally: (fn: () => void) => void;
+    isPending: boolean;
+};
+export declare function future<T = any>(): IFuture<T>;
+export default future;

package/future.js

@@ -0,0 +1,26 @@
+export function future() {
+    let resolver;
+    let rejecter;
+    const promise = new Promise((ok, err) => {
+        resolver = (x) => {
+            ok(x);
+            promise.isPending = false;
+        };
+        rejecter = (x) => {
+            err(x);
+            promise.isPending = false;
+        };
+    }).catch((e) => Promise.reject(e));
+    promise.resolve = resolver;
+    promise.reject = rejecter;
+    if (!('finally' in promise)) {
+        promise.finally = (fn) => {
+            promise.then(fn);
+            promise.catch(fn);
+        };
+    }
+    promise.isPending = true;
+    return promise;
+}
+export default future;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,7 +1,10 @@
 export declare enum CommsMessage {
-    CRDT = 1,
-    REQ_CRDT_STATE = 2,
-    RES_CRDT_STATE = 3
+    CRDT = 7,
+    REQ_CRDT_STATE = 8,
+    RES_CRDT_STATE = 9,
+    CRDT_SERVER = 4,
+    CRDT_AUTHORITATIVE = 5,
+    CUSTOM_EVENT = 6
 }
 export declare function BinaryMessageBus<T extends CommsMessage>(send: (message: Uint8Array, toPeerAddress?: string[]) => void): {
     on: <K extends T>(message: K, callback: (value: Uint8Array, sender: string) => void) => void;

package/network/binary-message-bus.js

@@ -1,9 +1,12 @@
 import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer';
 export var CommsMessage;
 (function (CommsMessage) {
-    CommsMessage[CommsMessage["CRDT"] = 1] = "CRDT";
-    CommsMessage[CommsMessage["REQ_CRDT_STATE"] = 2] = "REQ_CRDT_STATE";
-    CommsMessage[CommsMessage["RES_CRDT_STATE"] = 3] = "RES_CRDT_STATE";
+    CommsMessage[CommsMessage["CRDT"] = 7] = "CRDT";
+    CommsMessage[CommsMessage["REQ_CRDT_STATE"] = 8] = "REQ_CRDT_STATE";
+    CommsMessage[CommsMessage["RES_CRDT_STATE"] = 9] = "RES_CRDT_STATE";
+    CommsMessage[CommsMessage["CRDT_SERVER"] = 4] = "CRDT_SERVER";
+    CommsMessage[CommsMessage["CRDT_AUTHORITATIVE"] = 5] = "CRDT_AUTHORITATIVE";
+    CommsMessage[CommsMessage["CUSTOM_EVENT"] = 6] = "CUSTOM_EVENT";
 })(CommsMessage || (CommsMessage = {}));
 export function BinaryMessageBus(send) {
     const mapping = new Map();
@@ -17,8 +20,9 @@ export function BinaryMessageBus(send) {
         __processMessages: (messages) => {
             for (const message of messages) {
                 const commsMsg = decodeCommsMessage(message);
-                if (!commsMsg)
+                if (!commsMsg) {
                     continue;
+                }
                 const { sender, messageType, data } = commsMsg;
                 const fn = mapping.get(messageType);
                 if (fn)
@@ -65,4 +69,4 @@ export function encodeString(s) {
     buffer.writeUtf8String(s);
     return buffer.readBuffer();
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/network/chunking.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Chunks CRDT messages from a Uint8Array buffer, respecting message boundaries
+ * Uses the comprehensive readMessages function that handles all message types
+ */
+export declare function chunkCrdtMessages(data: Uint8Array, maxSizeKB?: number): Uint8Array[];

package/network/chunking.js

@@ -0,0 +1,38 @@
+import { ReadWriteByteBuffer } from '@dcl/ecs/dist/serialization/ByteBuffer';
+import { readMessages } from './server/utils';
+/**
+ * Chunks CRDT messages from a Uint8Array buffer, respecting message boundaries
+ * Uses the comprehensive readMessages function that handles all message types
+ */
+export function chunkCrdtMessages(data, maxSizeKB = 12) {
+    if (data.length === 0) {
+        return [];
+    }
+    const networkBuffer = new ReadWriteByteBuffer();
+    const chunks = [];
+    for (const message of readMessages(data)) {
+        // Check if adding this message would exceed the size limit
+        const currentBufferSize = networkBuffer.toBinary().byteLength;
+        const messageSize = message.messageBuffer.byteLength;
+        if ((currentBufferSize + messageSize) / 1024 > maxSizeKB) {
+            // If the current buffer has content, save it as a chunk
+            if (currentBufferSize > 0) {
+                chunks.push(networkBuffer.toCopiedBinary());
+                networkBuffer.resetBuffer();
+            }
+            // If the message itself is larger than the limit, skip it
+            if (messageSize / 1024 > maxSizeKB) {
+                console.error(`Message too large (${messageSize} bytes), skipping CRDT message`);
+                continue;
+            }
+        }
+        // Add message to current buffer
+        networkBuffer.writeBuffer(message.messageBuffer, false);
+    }
+    // Add any remaining data as the final chunk
+    if (networkBuffer.currentWriteOffset() > 0) {
+        chunks.push(networkBuffer.toBinary());
+    }
+    return chunks;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/network/events/implementation.d.ts

@@ -0,0 +1,93 @@
+import { IEngine } from '@dcl/ecs';
+import { EventTypes, EventSchemaRegistry } from './registry';
+import { Atom } from '../../atom';
+export type EventContext = {
+    from: string;
+};
+export type EventCallback<T> = (data: T, context?: EventContext) => void;
+export type SendOptions = {
+    to?: string[];
+};
+export declare class Room<T extends EventSchemaRegistry = EventSchemaRegistry> {
+    private listeners;
+    private binaryMessageBus;
+    private isServerFuture;
+    private isRoomReadyAtom;
+    private messageQueue;
+    private isProcessingQueue;
+    constructor(_engine: IEngine, binaryMessageBus: any, isServerFn: Atom<boolean>, isRoomReadyAtom: Atom<boolean>);
+    /**
+     * Flush queued messages when room becomes ready
+     */
+    private flushMessageQueue;
+    /**
+     * 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.
+     */
+    send<K extends keyof T>(eventType: K, data: EventTypes<T>[K], options?: SendOptions): Promise<void>;
+    /**
+     * Listen for an event
+     * @param eventType - The type of event to listen for
+     * @param callback - Callback to handle the event
+     * @returns Unsubscribe function
+     */
+    onMessage<K extends keyof T>(eventType: K, callback: EventCallback<EventTypes<T>[K]>): () => void;
+    /**
+     * Remove all listeners for a specific event type
+     * @param eventType - The type of event to clear listeners for
+     */
+    clear<K extends keyof T>(eventType?: K): void;
+    /**
+     * Get the number of listeners for an event type
+     * @param eventType - The type of event to check
+     * @returns Number of registered listeners
+     */
+    listenerCount<K extends keyof T>(eventType: K): number;
+    /**
+     * Check if the room is ready to send messages
+     * @returns true if messages will be sent immediately, false if they will be queued
+     */
+    isReady(): boolean;
+    /**
+     * Subscribe to room readiness changes
+     * @param callback - Called when room becomes ready or disconnected
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```ts
+     * const unsubscribe = room.onReady((isReady) => {
+     *   if (isReady) {
+     *     console.log('Room connected!')
+     *   } else {
+     *     console.log('Room disconnected')
+     *   }
+     * })
+     *
+     * // Later: unsubscribe()
+     * ```
+     */
+    onReady(callback: (isReady: boolean) => void): () => void;
+}
+/**
+ * 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 declare function registerMessages<T extends EventSchemaRegistry>(messages: T): Room<T>;
+/**
+ * Get a typed version of the global room
+ * Use this when you want the room with your specific message types
+ *
+ * @example
+ * ```typescript
+ * const MyMessages = { ... }
+ * registerMessages(MyMessages) // Register first
+ * const room = getRoom<typeof MyMessages>() // Then get typed version
+ * ```
+ */
+export declare function getRoom<T extends EventSchemaRegistry>(): Room<T>;