scoundrel-remote-eval 1.0.8 → 1.0.9

package/build/client/connections/web-socket/index.d.ts

@@ -0,0 +1,34 @@
+export default class WebSocket {
+    /**
+     * Creates a new WebSocket connection handler
+     * @param {WebSocket} ws The WebSocket instance
+     */
+    constructor(ws: WebSocket);
+    ws: WebSocket;
+    commands: {};
+    commandsCount: number;
+    close(): Promise<void>;
+    /**
+     * @param {(data: any) => void} callback
+     */
+    onCommand(callback: (data: any) => void): void;
+    onCommandCallback: (data: any) => void;
+    /**
+     * @param {Event} event
+     */
+    onSocketError: (event: Event) => void;
+    /**
+     * @param {MessageEvent} event
+     */
+    onSocketMessage: (event: MessageEvent) => void;
+    /**
+     * @param {Event} _event
+     */
+    onSocketOpen: (_event: Event) => void;
+    /**
+     * @param {Record<string, any>} data
+     */
+    send(data: Record<string, any>): void;
+    waitForOpened: () => Promise<any>;
+}
+//# sourceMappingURL=index.d.ts.map

package/build/client/connections/web-socket/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/client/connections/web-socket/index.js"],"names":[],"mappings":"AAQA;IACE;;;OAGG;IACH,gBAFW,SAAS,EAgBnB;IAbC,cAAY;IAWZ,aAAkB;IAClB,sBAAsB;IAGxB,uBAEC;IAED;;OAEG;IACH,oBAFW,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,QAI7B;IADC,0BAHgB,GAAG,KAAK,IAAI,CAGK;IAGnC;;OAEG;IACH,gBAAiB,OAFN,KAEW,UAErB;IAED;;OAEG;IACH,kBAAmB,OAFR,YAEa,UAUvB;IAED;;OAEG;IACH,eAAgB,QAFL,KAEW,UAErB;IAED;;OAEG;IACH,WAFW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QAQ7B;IAED,kCAME;CACH"}

package/build/client/connections/web-socket/index.js

@@ -0,0 +1,68 @@
+// @ts-check
+import Logger from "../../../logger.js";
+const logger = new Logger("Scoundrel WebSocket");
+// logger.setDebug(true)
+export default class WebSocket {
+    /**
+     * Creates a new WebSocket connection handler
+     * @param {WebSocket} ws The WebSocket instance
+     */
+    constructor(ws) {
+        /**
+         * @param {Event} event
+         */
+        this.onSocketError = (event) => {
+            logger.error(() => ["onSocketError", event]);
+        };
+        /**
+         * @param {MessageEvent} event
+         */
+        this.onSocketMessage = (event) => {
+            const data = JSON.parse(event.data);
+            logger.log(() => ["Client::Connections::WebSocket onSocketMessage", data]);
+            if (!this.onCommandCallback) {
+                throw new Error("No onCommand callback set, ignoring message");
+            }
+            this.onCommandCallback(data);
+        };
+        /**
+         * @param {Event} _event
+         */
+        this.onSocketOpen = (_event) => {
+            logger.log("onSocketOpen");
+        };
+        this.waitForOpened = () => new Promise((resolve, reject) => {
+            // @ts-ignore
+            this.ws.addEventListener("open", resolve);
+            // @ts-ignore
+            this.ws.addEventListener("error", reject);
+        });
+        this.ws = ws;
+        // @ts-ignore
+        this.ws.addEventListener("error", this.onSocketError);
+        // @ts-ignore
+        this.ws.addEventListener("open", this.onSocketOpen);
+        // @ts-ignore
+        this.ws.addEventListener("message", this.onSocketMessage);
+        this.commands = {};
+        this.commandsCount = 0;
+    }
+    async close() {
+        await this.ws.close();
+    }
+    /**
+     * @param {(data: any) => void} callback
+     */
+    onCommand(callback) {
+        this.onCommandCallback = callback;
+    }
+    /**
+     * @param {Record<string, any>} data
+     */
+    send(data) {
+        const sendData = JSON.stringify(data);
+        logger.log(() => ["Sending", sendData]);
+        // @ts-ignore
+        this.ws.send(sendData);
+    }
+}

package/build/client/index.d.ts

@@ -0,0 +1,180 @@
+export default class Client {
+    /**
+     * Creates a new Scoundrel Client
+     *
+     * @param {any} backend The backend connection (e.g., WebSocket)
+     */
+    constructor(backend: any);
+    backend: any;
+    /** @type {Record<number, any>} */
+    outgoingCommands: Record<number, any>;
+    incomingCommands: {};
+    outgoingCommandsCount: number;
+    /** @type {Record<string, any>} */
+    _classes: Record<string, any>;
+    /** @type {Record<string, any>} */
+    _objects: Record<string, any>;
+    /** @type {Record<string, Reference>} */
+    references: Record<string, Reference>;
+    /** @type {Record<number, any>} */
+    objects: Record<number, any>;
+    objectsCount: number;
+    /**
+     * Closes the client connection
+     */
+    close(): Promise<void>;
+    /**
+     * Calls a method on a reference and returns the result directly
+     *
+     * @param {number} referenceId
+     * @param {string} methodName
+     * @param  {...any} args
+     * @returns {Promise<any>}
+     */
+    callMethodOnReference(referenceId: number, methodName: string, ...args: any[]): Promise<any>;
+    /**
+     * Calls a method on a reference and returns a new reference
+     *
+     * @param {number} referenceId
+     * @param {string} methodName
+     * @param  {...any} args
+     * @returns {Promise<Reference>}
+     */
+    callMethodOnReferenceWithReference(referenceId: number, methodName: string, ...args: any[]): Promise<Reference>;
+    /**
+     * Evaluates a string and returns a new reference
+     *
+     * @param {string} evalString
+     * @returns {Promise<Reference>}
+     */
+    evalWithReference(evalString: string): Promise<Reference>;
+    /**
+     * Imports a module and returns a reference to it
+     *
+     * @param {string} importName
+     * @returns {Promise<Reference>}
+     */
+    import(importName: string): Promise<Reference>;
+    /**
+     * Gets a registered object by name
+     *
+     * @param {string} objectName
+     * @returns {Promise<Reference>}
+     */
+    getObject(objectName: string): Promise<Reference>;
+    /**
+     * Spawns a new reference to an object
+     *
+     * @param {string} className
+     * @param  {...any} args
+     * @returns {Promise<Reference>}
+     */
+    newObjectWithReference(className: string, ...args: any[]): Promise<Reference>;
+    /**
+     * Checks if the input is a plain object
+     * @param {any} input
+     * @returns {boolean}
+     */
+    isPlainObject(input: any): boolean;
+    /**
+     * Handles an incoming command from the backend
+     * @param {object} args
+     * @param {string} args.command
+     * @param {number} args.command_id
+     * @param {any} args.data
+     * @param {string} [args.error]
+     * @param {string} [args.errorStack]
+     */
+    onCommand: ({ command, command_id: commandID, data, error, errorStack, ...restArgs }: {
+        command: string;
+        command_id: number;
+        data: any;
+        error?: string;
+        errorStack?: string;
+    }) => void;
+    /**
+     * Parases an argument for sending to the server
+     *
+     * @param {any} arg
+     * @returns {any}
+     */
+    parseArg(arg: any): any;
+    /**
+     * Reads an attribute on a reference and returns a new reference
+     *
+     * @param {number} referenceId
+     * @param {string} attributeName
+     * @returns {Promise<Reference>}
+     */
+    readAttributeOnReferenceWithReference(referenceId: number, attributeName: string): Promise<Reference>;
+    /**
+     * Reads an attribute on a reference and returns the result directly
+     *
+     * @param {number} referenceId
+     * @param {string} attributeName
+     * @returns {Promise<any>}
+     */
+    readAttributeOnReference(referenceId: number, attributeName: string): Promise<any>;
+    /**
+     * Registers a class by name
+     *
+     * @param {string} className
+     * @param {any} classInstance
+     */
+    registerClass(className: string, classInstance: any): void;
+    /**
+     * Gets a registered class by name
+     *
+     * @param {string} className
+     * @returns {any}
+     */
+    getClass(className: string): any;
+    /**
+     * Registers an object by name
+     *
+     * @param {string} objectName
+     * @param {any} objectInstance
+     */
+    registerObject(objectName: string, objectInstance: any): void;
+    /**
+     * Gets a registered object by name
+     *
+     * @param {string} objectName
+     * @returns {any}
+     */
+    _getRegisteredObject(objectName: string): any;
+    /**
+     * Responds to a command from the backend
+     * @param {number} commandId
+     * @param {any} data
+     */
+    respondToCommand(commandId: number, data: any): void;
+    /**
+     * Sends a command to the backend and returns a promise that resolves with the response
+     * @param {string} command
+     * @param {any} data
+     * @returns {Promise<any>}
+     */
+    sendCommand(command: string, data: any): Promise<any>;
+    /**
+     * Sends data to the backend
+     * @param {any} data
+     */
+    send(data: any): void;
+    /**
+     * Serializes a reference and returns the result directly
+     *
+     * @param {number} referenceId
+     * @returns {Promise<any>}
+     */
+    serializeReference(referenceId: number): Promise<any>;
+    /**
+     * Spawns a new reference to an object
+     *
+     * @param {string} id
+     * @returns {Reference}
+     */
+    spawnReference(id: string): Reference;
+}
+import Reference from "./reference.js";
+//# sourceMappingURL=index.d.ts.map

package/build/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.js"],"names":[],"mappings":"AASA;IACE;;;;OAIG;IACH,qBAFW,GAAG,EAwBb;IArBC,aAAsB;IAGtB,kCAAkC;IAClC,kBADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CACJ;IAC1B,qBAA0B;IAC1B,8BAA8B;IAE9B,kCAAkC;IAClC,UADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CACZ;IAElB,kCAAkC;IAClC,UADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CACZ;IAElB,wCAAwC;IACxC,YADW,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAChB;IAEpB,kCAAkC;IAClC,SADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CACb;IAEjB,qBAAqB;IAGvB;;OAEG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,mCALW,MAAM,cACN,MAAM,WACF,GAAG,EAAA,GACL,OAAO,CAAC,GAAG,CAAC,CAWxB;IAED;;;;;;;OAOG;IACH,gDALW,MAAM,cACN,MAAM,WACF,GAAG,EAAA,GACL,OAAO,CAAC,SAAS,CAAC,CAY9B;IAED;;;;;OAKG;IACH,8BAHW,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAU9B;IAED;;;;;OAKG;IACH,mBAHW,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAe9B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAY9B;IAED;;;;;;OAMG;IACH,kCAJW,MAAM,WACF,GAAG,EAAA,GACL,OAAO,CAAC,SAAS,CAAC,CAe9B;IAED;;;;OAIG;IACH,qBAHW,GAAG,GACD,OAAO,CAQnB;IAED;;;;;;;;OAQG;IACH,YAAa,0EANV;QAAqB,OAAO,EAApB,MAAM;QACO,UAAU,EAAvB,MAAM;QACI,IAAI,EAAd,GAAG;QACW,KAAK,GAAnB,MAAM;QACQ,UAAU,GAAxB,MAAM;KAEkE,UA+GlF;IAED;;;;;OAKG;IACH,cAHW,GAAG,GACD,GAAG,CAwBf;IAED;;;;;;OAMG;IACH,mDAJW,MAAM,iBACN,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAW9B;IAED;;;;;;OAMG;IACH,sCAJW,MAAM,iBACN,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CASxB;IAED;;;;;OAKG;IACH,yBAHW,MAAM,iBACN,GAAG,QAMb;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,GAAG,CAIf;IAED;;;;;OAKG;IACH,2BAHW,MAAM,kBACN,GAAG,QAMb;IAED;;;;;OAKG;IACH,iCAHW,MAAM,GACJ,GAAG,CAIf;IAED;;;;OAIG;IACH,4BAHW,MAAM,QACN,GAAG,QAIb;IAED;;;;;OAKG;IACH,qBAJW,MAAM,QACN,GAAG,GACD,OAAO,CAAC,GAAG,CAAC,CAexB;IAED;;;OAGG;IACH,WAFW,GAAG,QAIb;IAED;;;;;OAKG;IACH,gCAHW,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CAMxB;IAED;;;;;OAKG;IACH,mBAHW,MAAM,GACJ,SAAS,CAQrB;CACF;sBAjdqB,gBAAgB"}

package/build/client/index.js

@@ -0,0 +1,413 @@
+// @ts-check
+import Logger from "../logger.js";
+import Reference from "./reference.js";
+const logger = new Logger("Scoundrel Client");
+// logger.setDebug(true)
+export default class Client {
+    /**
+     * Creates a new Scoundrel Client
+     *
+     * @param {any} backend The backend connection (e.g., WebSocket)
+     */
+    constructor(backend) {
+        /**
+         * Handles an incoming command from the backend
+         * @param {object} args
+         * @param {string} args.command
+         * @param {number} args.command_id
+         * @param {any} args.data
+         * @param {string} [args.error]
+         * @param {string} [args.errorStack]
+         */
+        this.onCommand = ({ command, command_id: commandID, data, error, errorStack, ...restArgs }) => {
+            logger.log(() => ["onCommand", { command, commandID, data, error, errorStack, restArgs }]);
+            try {
+                if (!command) {
+                    throw new Error(`No command key given in data: ${Object.keys(restArgs).join(", ")}`);
+                }
+                else if (command == "get_object") {
+                    const serverObject = this._getRegisteredObject(data.object_name);
+                    let object;
+                    if (serverObject) {
+                        object = serverObject;
+                    }
+                    else {
+                        object = globalThis[data.object_name];
+                        if (!object)
+                            throw new Error(`No such object: ${data.object_name}`);
+                    }
+                    const objectId = ++this.objectsCount;
+                    this.objects[objectId] = object;
+                    this.respondToCommand(commandID, { object_id: objectId });
+                }
+                else if (command == "new_object_with_reference") {
+                    const className = data.class_name;
+                    let object;
+                    if (typeof className == "string") {
+                        const ClassInstance = this.getClass(className) || globalThis[className];
+                        if (!ClassInstance)
+                            throw new Error(`No such class: ${className}`);
+                        object = new ClassInstance(...data.args);
+                    }
+                    else {
+                        throw new Error(`Don't know how to handle class name: ${typeof className}`);
+                    }
+                    const objectId = ++this.objectsCount;
+                    this.objects[objectId] = object;
+                    this.respondToCommand(commandID, { object_id: objectId });
+                }
+                else if (command == "call_method_on_reference") {
+                    const referenceId = data.reference_id;
+                    const object = this.objects[referenceId];
+                    if (!object)
+                        throw new Error(`No object by that ID: ${referenceId}`);
+                    const method = object[data.method_name];
+                    if (!method)
+                        throw new Error(`No method called '${data.method_name}' on a '${object.constructor.name}'`);
+                    const response = method.call(object, ...data.args);
+                    this.respondToCommand(commandID, { response });
+                }
+                else if (command == "serialize_reference") {
+                    const referenceId = data.reference_id;
+                    const object = this.objects[referenceId];
+                    if (!object)
+                        throw new Error(`No object by that ID: ${referenceId}`);
+                    this.respondToCommand(commandID, JSON.stringify(object));
+                }
+                else if (command == "read_attribute") {
+                    const attributeName = data.attribute_name;
+                    const referenceId = data.reference_id;
+                    const returnWith = data.with;
+                    const object = this.objects[referenceId];
+                    if (!object)
+                        throw new Error(`No object by that ID: ${referenceId}`);
+                    const attribute = object[attributeName];
+                    if (returnWith == "reference") {
+                        const objectId = ++this.objectsCount;
+                        this.objects[objectId] = attribute;
+                        this.respondToCommand(commandID, { response: objectId });
+                    }
+                    else {
+                        this.respondToCommand(commandID, { response: attribute });
+                    }
+                }
+                else if (command == "command_response") {
+                    if (!(commandID in this.outgoingCommands)) {
+                        throw new Error(`Outgoing command ${commandID} not found: ${Object.keys(this.outgoingCommands).join(", ")}`);
+                    }
+                    const savedCommand = this.outgoingCommands[commandID];
+                    delete this.outgoingCommands[commandID];
+                    if (error) {
+                        const errorToThrow = new Error(error);
+                        if (errorStack) {
+                            errorToThrow.stack = `${errorStack}\n\n${errorToThrow.stack}`;
+                        }
+                        savedCommand.reject(errorToThrow);
+                    }
+                    else {
+                        logger.log(() => [`Resolving command ${commandID} with data`, data]);
+                        savedCommand.resolve(data.data);
+                    }
+                }
+                else {
+                    throw new Error(`Unknown command: ${command}`);
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    this.send({ command: "command_response", command_id: commandID, error: error.message, errorStack: error.stack });
+                }
+                else {
+                    this.send({ command: "command_response", command_id: commandID, error: String(error) });
+                }
+                logger.error(error);
+            }
+        };
+        this.backend = backend;
+        this.backend.onCommand(this.onCommand);
+        /** @type {Record<number, any>} */
+        this.outgoingCommands = {};
+        this.incomingCommands = {};
+        this.outgoingCommandsCount = 0;
+        /** @type {Record<string, any>} */
+        this._classes = {};
+        /** @type {Record<string, any>} */
+        this._objects = {};
+        /** @type {Record<string, Reference>} */
+        this.references = {};
+        /** @type {Record<number, any>} */
+        this.objects = {};
+        this.objectsCount = 0;
+    }
+    /**
+     * Closes the client connection
+     */
+    async close() {
+        this.backend.close();
+    }
+    /**
+     * Calls a method on a reference and returns the result directly
+     *
+     * @param {number} referenceId
+     * @param {string} methodName
+     * @param  {...any} args
+     * @returns {Promise<any>}
+     */
+    async callMethodOnReference(referenceId, methodName, ...args) {
+        const result = await this.sendCommand("call_method_on_reference", {
+            args: this.parseArg(args),
+            method_name: methodName,
+            reference_id: referenceId,
+            with: "result"
+        });
+        return result.response;
+    }
+    /**
+     * Calls a method on a reference and returns a new reference
+     *
+     * @param {number} referenceId
+     * @param {string} methodName
+     * @param  {...any} args
+     * @returns {Promise<Reference>}
+     */
+    async callMethodOnReferenceWithReference(referenceId, methodName, ...args) {
+        const result = await this.sendCommand("call_method_on_reference", {
+            args: this.parseArg(args),
+            method_name: methodName,
+            reference_id: referenceId,
+            with: "reference"
+        });
+        const id = result.response;
+        return this.spawnReference(id);
+    }
+    /**
+     * Evaluates a string and returns a new reference
+     *
+     * @param {string} evalString
+     * @returns {Promise<Reference>}
+     */
+    async evalWithReference(evalString) {
+        const result = await this.sendCommand("eval", {
+            eval_string: evalString,
+            with_reference: true
+        });
+        const id = result.object_id;
+        return this.spawnReference(id);
+    }
+    /**
+     * Imports a module and returns a reference to it
+     *
+     * @param {string} importName
+     * @returns {Promise<Reference>}
+     */
+    async import(importName) {
+        const result = await this.sendCommand("import", {
+            import_name: importName
+        });
+        logger.log(() => ["import", { result }]);
+        if (!result)
+            throw new Error("No result given");
+        if (!result.object_id)
+            throw new Error(`No object ID given in result: ${JSON.stringify(result)}`);
+        const id = result.object_id;
+        return this.spawnReference(id);
+    }
+    /**
+     * Gets a registered object by name
+     *
+     * @param {string} objectName
+     * @returns {Promise<Reference>}
+     */
+    async getObject(objectName) {
+        const result = await this.sendCommand("get_object", {
+            object_name: objectName
+        });
+        if (!result)
+            throw new Error("Blank result given");
+        const id = result.object_id;
+        return this.spawnReference(id);
+    }
+    /**
+     * Spawns a new reference to an object
+     *
+     * @param {string} className
+     * @param  {...any} args
+     * @returns {Promise<Reference>}
+     */
+    async newObjectWithReference(className, ...args) {
+        const result = await this.sendCommand("new_object_with_reference", {
+            args: this.parseArg(args),
+            class_name: className
+        });
+        if (!result)
+            throw new Error("Blank result given");
+        const id = result.object_id;
+        if (!id)
+            throw new Error(`No object ID given in result: ${JSON.stringify(result)}`);
+        return this.spawnReference(id);
+    }
+    /**
+     * Checks if the input is a plain object
+     * @param {any} input
+     * @returns {boolean}
+     */
+    isPlainObject(input) {
+        if (input && typeof input === "object" && !Array.isArray(input)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Parases an argument for sending to the server
+     *
+     * @param {any} arg
+     * @returns {any}
+     */
+    parseArg(arg) {
+        if (Array.isArray(arg)) {
+            return arg.map((argInArray) => this.parseArg(argInArray));
+        }
+        else if (arg instanceof Reference) {
+            return {
+                __scoundrel_object_id: arg.id,
+                __scoundrel_type: "reference"
+            };
+        }
+        else if (this.isPlainObject(arg)) {
+            /** @type {Record<any, any>} */
+            const newObject = {};
+            for (const key in arg) {
+                const value = arg[key];
+                newObject[key] = this.parseArg(value);
+            }
+            return newObject;
+        }
+        return arg;
+    }
+    /**
+     * Reads an attribute on a reference and returns a new reference
+     *
+     * @param {number} referenceId
+     * @param {string} attributeName
+     * @returns {Promise<Reference>}
+     */
+    async readAttributeOnReferenceWithReference(referenceId, attributeName) {
+        const result = await this.sendCommand("read_attribute", {
+            attribute_name: attributeName,
+            reference_id: referenceId,
+            with: "reference"
+        });
+        const id = result.response;
+        return this.spawnReference(id);
+    }
+    /**
+     * Reads an attribute on a reference and returns the result directly
+     *
+     * @param {number} referenceId
+     * @param {string} attributeName
+     * @returns {Promise<any>}
+     */
+    async readAttributeOnReference(referenceId, attributeName) {
+        const result = await this.sendCommand("read_attribute", {
+            attribute_name: attributeName,
+            reference_id: referenceId,
+            with: "result"
+        });
+        return result.response;
+    }
+    /**
+     * Registers a class by name
+     *
+     * @param {string} className
+     * @param {any} classInstance
+     */
+    registerClass(className, classInstance) {
+        if (className in this._classes)
+            throw new Error(`Class already exists: ${className}`);
+        this._classes[className] = classInstance;
+    }
+    /**
+     * Gets a registered class by name
+     *
+     * @param {string} className
+     * @returns {any}
+     */
+    getClass(className) {
+        return this._classes[className];
+    }
+    /**
+     * Registers an object by name
+     *
+     * @param {string} objectName
+     * @param {any} objectInstance
+     */
+    registerObject(objectName, objectInstance) {
+        if (objectName in this._objects)
+            throw new Error(`Object already exists: ${objectName}`);
+        this._objects[objectName] = objectInstance;
+    }
+    /**
+     * Gets a registered object by name
+     *
+     * @param {string} objectName
+     * @returns {any}
+     */
+    _getRegisteredObject(objectName) {
+        return this._objects[objectName];
+    }
+    /**
+     * Responds to a command from the backend
+     * @param {number} commandId
+     * @param {any} data
+     */
+    respondToCommand(commandId, data) {
+        this.sendCommand("command_response", { command_id: commandId, data });
+    }
+    /**
+     * Sends a command to the backend and returns a promise that resolves with the response
+     * @param {string} command
+     * @param {any} data
+     * @returns {Promise<any>}
+     */
+    sendCommand(command, data) {
+        return new Promise((resolve, reject) => {
+            const outgoingCommandCount = ++this.outgoingCommandsCount;
+            const commandData = {
+                command,
+                command_id: outgoingCommandCount,
+                data
+            };
+            this.outgoingCommands[outgoingCommandCount] = { resolve, reject };
+            logger.log(() => ["Sending", commandData]);
+            this.send(commandData);
+        });
+    }
+    /**
+     * Sends data to the backend
+     * @param {any} data
+     */
+    send(data) {
+        this.backend.send(data);
+    }
+    /**
+     * Serializes a reference and returns the result directly
+     *
+     * @param {number} referenceId
+     * @returns {Promise<any>}
+     */
+    async serializeReference(referenceId) {
+        const json = await this.sendCommand("serialize_reference", { reference_id: referenceId });
+        return JSON.parse(json);
+    }
+    /**
+     * Spawns a new reference to an object
+     *
+     * @param {string} id
+     * @returns {Reference}
+     */
+    spawnReference(id) {
+        const reference = new Reference(this, id);
+        this.references[id] = reference;
+        return reference;
+    }
+}