scoundrel-remote-eval 1.0.19 → 1.0.21

package/build/client/index.js

@@ -1,9 +1,16 @@
 // @ts-check
 import Logger from "../logger.js";
 import Reference from "./reference.js";
+import referenceProxy from "./reference-proxy.js";
 import safeJSONStringify from "../utils/safe-json-stringify.js";
 const logger = new Logger("Scoundrel Client");
+/** @typedef {import("./reference-proxy.js").Proxy} Proxy */
 // logger.setDebug(true)
+/**
+ * @typedef {{reference?: boolean, result?: boolean, proxy?: boolean}} ReturnOptions
+ * @typedef {ReturnOptions & {result?: false}} ReturnReferenceOptions
+ * @typedef {ReturnOptions & {result: true, reference?: false}} ReturnResultOptions
+ */
 export default class Client {
     /**
      * Creates a new Scoundrel Client
@@ -285,18 +292,98 @@ export default class Client {
     }
     /**
      * Calls a method on a reference and returns the result directly
+     * @overload
      * @param {number} referenceId Reference identifier
      * @param {string} methodName Method name to invoke
      * @param  {...any} args Arguments to pass to the method
      * @returns {Promise<any>} Result from the method call
      */
-    async callMethodOnReference(referenceId, methodName, ...args) {
+    /**
+     * Calls a method on a reference and returns a new reference
+     * @overload
+     * @param {number} referenceId Reference identifier
+     * @param {string} methodName Method name to invoke
+     * @param {ReturnReferenceOptions} options Options for the call
+     * @param  {...any} args Arguments to pass to the method
+     * @returns {Promise<Reference | Proxy>} Reference or proxy to the returned value
+     */
+    /**
+     * Calls a method on a reference and returns the result directly
+     * @overload
+     * @param {number} referenceId Reference identifier
+     * @param {string} methodName Method name to invoke
+     * @param {ReturnResultOptions} options Options for the call
+     * @param  {...any} args Arguments to pass to the method
+     * @returns {Promise<any>} Result from the method call
+     */
+    /**
+     * Calls a method on a reference and returns the result directly
+     * @param {number} referenceId Reference identifier
+     * @param {string} methodName Method name to invoke
+     * @param {ReturnOptions | any} [optionsOrArg] Options for the call or first argument
+     * @param  {...any} args Arguments to pass to the method
+     * @returns {Promise<Reference | Proxy | any>} Result or reference from the method call
+     */
+    async callMethodOnReference(referenceId, methodName, optionsOrArg, ...args) {
+        const allowedOptions = new Set(["reference", "result", "proxy"]);
+        /** @type {ReturnOptions | undefined} */
+        let options;
+        /** @type {any[]} */
+        let methodArgs;
+        if (typeof optionsOrArg === "undefined") {
+            methodArgs = args;
+        }
+        else if (this.isPlainObject(optionsOrArg)) {
+            const optionKeys = Object.keys(optionsOrArg);
+            const hasOptionKey = optionKeys.some((key) => allowedOptions.has(key));
+            if (hasOptionKey) {
+                const unknownOptions = optionKeys.filter((key) => !allowedOptions.has(key));
+                if (unknownOptions.length === 0) {
+                    const optionValuesAreBoolean = optionKeys
+                        .filter((key) => allowedOptions.has(key))
+                        .every((key) => typeof optionsOrArg[key] === "boolean");
+                    if (optionValuesAreBoolean) {
+                        options = /** @type {ReturnOptions} */ (optionsOrArg);
+                        methodArgs = args;
+                    }
+                    else {
+                        methodArgs = [optionsOrArg, ...args];
+                    }
+                }
+                else {
+                    throw new Error(`Unknown callMethodOnReference options: ${unknownOptions.join(", ")}`);
+                }
+            }
+            else {
+                methodArgs = [optionsOrArg, ...args];
+            }
+        }
+        else {
+            methodArgs = [optionsOrArg, ...args];
+        }
+        const returnReference = options?.reference === true;
+        const returnResult = options?.result === true;
+        const returnProxy = options?.proxy === true;
+        const returnFlags = [returnReference, returnResult, returnProxy].filter(Boolean).length;
+        if (returnFlags > 1) {
+            throw new Error("callMethodOnReference options reference, result, and proxy are mutually exclusive");
+        }
+        const withReference = returnReference || returnProxy;
         const result = await this.sendCommand("call_method_on_reference", {
-            args: this.parseArg(args),
+            args: this.parseArg(methodArgs),
             method_name: methodName,
             reference_id: referenceId,
-            with: "result"
+            with: withReference ? "reference" : "result"
         });
+        if (!result)
+            throw new Error("Blank result given");
+        if (withReference) {
+            const objectId = result.response;
+            if (!objectId)
+                throw new Error(`No object ID given in result: ${JSON.stringify(result)}`);
+            const spawnedReference = this.spawnReference(objectId);
+            return returnProxy ? referenceProxy(spawnedReference) : spawnedReference;
+        }
         return result.response;
     }
     /**
@@ -307,21 +394,39 @@ export default class Client {
      * @returns {Promise<Reference>} Reference to the return value
      */
     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"
+        console.warn("Scoundrel Client", "callMethodOnReferenceWithReference is deprecated; use callMethodOnReference with reference instead.");
+        return this.callMethodOnReference(referenceId, methodName, { reference: true }, ...args);
+    }
+    /**
+     * Evaluates a string and returns a proxy
+     * @param {string} evalString Code to evaluate
+     * @returns {Promise<Proxy>} Proxy to the evaluated value
+     */
+    async eval(evalString) {
+        if (typeof evalString !== "string") {
+            throw new Error("eval requires an eval string");
+        }
+        const result = await this.sendCommand("eval", {
+            eval_string: evalString,
+            with_reference: true
         });
-        const id = result.response;
-        return this.spawnReference(id);
+        if (!result)
+            throw new Error("Blank result given");
+        const objectId = result.object_id;
+        if (!objectId)
+            throw new Error(`No object ID given in result: ${JSON.stringify(result)}`);
+        const spawnedReference = this.spawnReference(objectId);
+        return referenceProxy(spawnedReference);
     }
     /**
-     * Evaluates a string and returns a new reference
+     * Evaluates a string and returns a reference
      * @param {string} evalString Code to evaluate
      * @returns {Promise<Reference>} Reference to the evaluated value
      */
-    async evalWithReference(evalString) {
+    async evalReference(evalString) {
+        if (typeof evalString !== "string") {
+            throw new Error("evalReference requires an eval string");
+        }
         const result = await this.sendCommand("eval", {
             eval_string: evalString,
             with_reference: true
@@ -333,12 +438,53 @@ export default class Client {
             throw new Error(`No object ID given in result: ${JSON.stringify(result)}`);
         return this.spawnReference(objectId);
     }
+    /**
+     * Evaluates a string and returns the result directly
+     * @param {string} evalString Code to evaluate
+     * @returns {Promise<any>} Evaluated result
+     */
+    async evalResult(evalString) {
+        if (typeof evalString !== "string") {
+            throw new Error("evalResult requires an eval string");
+        }
+        const result = await this.sendCommand("eval", {
+            eval_string: evalString,
+            with_reference: false
+        });
+        if (!result)
+            throw new Error("Blank result given");
+        if (!("response" in result))
+            throw new Error(`No response given in result: ${JSON.stringify(result)}`);
+        return result.response;
+    }
+    /**
+     * Imports a module and returns a proxy to it
+     * @param {string} importName Module name to import
+     * @returns {Promise<Proxy>} Proxy to the module
+     */
+    async import(importName) {
+        if (typeof importName !== "string")
+            throw new Error("import requires a module name");
+        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;
+        const spawnedReference = this.spawnReference(id);
+        return referenceProxy(spawnedReference);
+    }
     /**
      * Imports a module and returns a reference to it
      * @param {string} importName Module name to import
      * @returns {Promise<Reference>} Reference to the module
      */
-    async import(importName) {
+    async importReference(importName) {
+        if (typeof importName !== "string")
+            throw new Error("importReference requires a module name");
         const result = await this.sendCommand("import", {
             import_name: importName
         });
@@ -351,11 +497,31 @@ export default class Client {
         return this.spawnReference(id);
     }
     /**
-     * Gets a registered object by name
+     * Imports a module and returns the serialized result
+     * @param {string} importName Module name to import
+     * @returns {Promise<any>} Serialized result for the module
+     */
+    async importResult(importName) {
+        const reference = await this.importReference(importName);
+        return await reference.serialize();
+    }
+    /**
+     * Gets a registered object by name and returns a proxy
      * @param {string} objectName Registered object name
-     * @returns {Promise<Reference>} Reference to the object
+     * @returns {Promise<Proxy>} Proxy to the object
      */
     async getObject(objectName) {
+        const reference = await this.getObjectReference(objectName);
+        return referenceProxy(reference);
+    }
+    /**
+     * Gets a registered object by name and returns a reference
+     * @param {string} objectName Registered object name
+     * @returns {Promise<Reference>} Reference to the object
+     */
+    async getObjectReference(objectName) {
+        if (typeof objectName !== "string")
+            throw new Error("getObjectReference requires an object name");
         const result = await this.sendCommand("get_object", {
             object_name: objectName
         });
@@ -365,12 +531,44 @@ export default class Client {
         return this.spawnReference(id);
     }
     /**
-     * Spawns a new reference to an object
+     * Gets a registered object by name and returns the serialized result
+     * @param {string} objectName Registered object name
+     * @returns {Promise<any>} Serialized result for the object
+     */
+    async getObjectResult(objectName) {
+        const reference = await this.getObjectReference(objectName);
+        return await reference.serialize();
+    }
+    /**
+     * Spawns a new reference to an object and returns a proxy
+     * @param {string} className Class name to construct
+     * @param  {...any} args Constructor arguments
+     * @returns {Promise<Proxy>} Proxy to the new instance
+     */
+    async newObject(className, ...args) {
+        if (typeof className !== "string")
+            throw new Error("newObject requires a class name");
+        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)}`);
+        const spawnedReference = this.spawnReference(id);
+        return referenceProxy(spawnedReference);
+    }
+    /**
+     * Spawns a new reference to an object and returns a reference
      * @param {string} className Class name to construct
      * @param  {...any} args Constructor arguments
      * @returns {Promise<Reference>} Reference to the new instance
      */
-    async newObjectWithReference(className, ...args) {
+    async newObjectReference(className, ...args) {
+        if (typeof className !== "string")
+            throw new Error("newObjectReference requires a class name");
         const result = await this.sendCommand("new_object_with_reference", {
             args: this.parseArg(args),
             class_name: className
@@ -382,6 +580,16 @@ export default class Client {
             throw new Error(`No object ID given in result: ${JSON.stringify(result)}`);
         return this.spawnReference(id);
     }
+    /**
+     * Spawns a new reference to an object and returns the serialized result
+     * @param {string} className Class name to construct
+     * @param  {...any} args Constructor arguments
+     * @returns {Promise<any>} Serialized result for the new instance
+     */
+    async newObjectResult(className, ...args) {
+        const reference = await this.newObjectReference(className, ...args);
+        return await reference.serialize();
+    }
     /**
      * Checks if the input is a plain object
      * @param {any} input Value to inspect
@@ -421,32 +629,159 @@ export default class Client {
     }
     /**
      * Reads an attribute on a reference and returns a new reference
+     * @overload
      * @param {number} referenceId Reference identifier
-     * @param {string} attributeName Attribute name to read
+     * @param {string | number} attributeName Attribute name to read
      * @returns {Promise<Reference>} Reference to the attribute value
      */
-    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 a new reference
+     * @overload
+     * @param {number} referenceId Reference identifier
+     * @param {string | number} attributeName Attribute name to read
+     * @param {ReturnReferenceOptions} optionsOrArg Options for the read
+     * @returns {Promise<Reference | Proxy>} Reference or proxy to the attribute value
+     */
+    /**
+     * Reads an attribute on a reference and returns the result directly
+     * @overload
+     * @param {number} referenceId Reference identifier
+     * @param {string | number} attributeName Attribute name to read
+     * @param {ReturnResultOptions} optionsOrArg Options for the read
+     * @returns {Promise<any>} Attribute value
+     */
+    /**
+     * Reads an attribute on a reference and returns a new reference
+     * @param {number} referenceId Reference identifier
+     * @param {string | number} attributeName Attribute name to read
+     * @param {ReturnOptions} [optionsOrArg] Options for the read
+     * @returns {Promise<Reference | Proxy | any>} Reference, proxy, or result
+     */
+    async readAttributeOnReferenceWithReference(referenceId, attributeName, optionsOrArg) {
+        const allowedOptions = new Set(["reference", "result", "proxy"]);
+        /** @type {ReturnOptions} */
+        let options = { reference: true };
+        if (typeof optionsOrArg === "undefined") {
+            options = { reference: true };
+        }
+        else if (this.isPlainObject(optionsOrArg)) {
+            const optionKeys = Object.keys(optionsOrArg);
+            const hasOptionKey = optionKeys.some((key) => allowedOptions.has(key));
+            if (hasOptionKey) {
+                const unknownOptions = optionKeys.filter((key) => !allowedOptions.has(key));
+                if (unknownOptions.length === 0) {
+                    const hasExplicitReturn = Object.prototype.hasOwnProperty.call(optionsOrArg, "reference")
+                        || Object.prototype.hasOwnProperty.call(optionsOrArg, "result")
+                        || Object.prototype.hasOwnProperty.call(optionsOrArg, "proxy");
+                    options = /** @type {ReturnOptions} */ ({
+                        ...(hasExplicitReturn ? {} : { reference: true }),
+                        ...optionsOrArg
+                    });
+                }
+                else {
+                    throw new Error(`Unknown readAttributeOnReferenceWithReference options: ${unknownOptions.join(", ")}`);
+                }
+            }
+            else {
+                throw new Error("readAttributeOnReferenceWithReference does not accept positional arguments");
+            }
+        }
+        else {
+            throw new Error("readAttributeOnReferenceWithReference does not accept positional arguments");
+        }
+        const returnReference = options?.reference === true;
+        const returnResult = options?.result === true;
+        const returnProxy = options?.proxy === true;
+        const returnFlags = [returnReference, returnResult, returnProxy].filter(Boolean).length;
+        if (returnFlags > 1) {
+            throw new Error("readAttributeOnReferenceWithReference options reference, result, and proxy are mutually exclusive");
+        }
+        return this.readAttributeOnReference(referenceId, options, attributeName);
     }
     /**
      * Reads an attribute on a reference and returns the result directly
+     * @overload
+     * @param {number} referenceId Reference identifier
+     * @param {string | number} attributeName Attribute name to read
+     * @returns {Promise<any>} Attribute value
+     */
+    /**
+     * Reads an attribute on a reference and returns a new reference
+     * @overload
+     * @param {number} referenceId Reference identifier
+     * @param {ReturnReferenceOptions} options Options for the read
+     * @param {string | number} attributeName Attribute name to read
+     * @returns {Promise<Reference | Proxy>} Reference or proxy to the attribute value
+     */
+    /**
+     * Reads an attribute on a reference and returns a result or reference
+     * @overload
+     * @param {number} referenceId Reference identifier
+     * @param {ReturnOptions} options Options for the read
+     * @param {string | number} attributeName Attribute name to read
+     * @returns {Promise<Reference | Proxy | any>} Attribute value or reference
+     */
+    /**
+     * Reads an attribute on a reference and returns the result directly
+     * @overload
      * @param {number} referenceId Reference identifier
-     * @param {string} attributeName Attribute name to read
+     * @param {ReturnResultOptions} options Options for the read
+     * @param {string | number} attributeName Attribute name to read
      * @returns {Promise<any>} Attribute value
      */
-    async readAttributeOnReference(referenceId, attributeName) {
+    /**
+     * Reads an attribute on a reference and returns the result directly
+     * @param {number} referenceId Reference identifier
+     * @param {string | number | ReturnOptions} attributeNameOrOptions Attribute name or options
+     * @param {string | number} [attributeName] Attribute name when using options
+     * @returns {Promise<Reference | Proxy | any>} Attribute value or reference
+     */
+    async readAttributeOnReference(referenceId, attributeNameOrOptions, attributeName) {
+        const allowedOptions = new Set(["reference", "result", "proxy"]);
+        /** @type {ReturnOptions | undefined} */
+        let options;
+        /** @type {string | number | undefined} */
+        let targetAttributeName = attributeName;
+        if (this.isPlainObject(attributeNameOrOptions)) {
+            const optionKeys = Object.keys(attributeNameOrOptions);
+            const hasOptionKey = optionKeys.some((key) => allowedOptions.has(key));
+            if (hasOptionKey) {
+                const unknownOptions = optionKeys.filter((key) => !allowedOptions.has(key));
+                if (unknownOptions.length === 0) {
+                    options = /** @type {ReturnOptions} */ (attributeNameOrOptions);
+                }
+                else {
+                    throw new Error(`Unknown readAttributeOnReference options: ${unknownOptions.join(", ")}`);
+                }
+            }
+            else {
+                targetAttributeName = /** @type {string | number} */ (attributeNameOrOptions);
+            }
+        }
+        else {
+            targetAttributeName = /** @type {string | number} */ (attributeNameOrOptions);
+        }
+        if (typeof targetAttributeName === "undefined") {
+            throw new Error("readAttributeOnReference requires an attribute name");
+        }
+        const returnReference = options?.reference === true;
+        const returnResult = options?.result === true;
+        const returnProxy = options?.proxy === true;
+        const returnFlags = [returnReference, returnResult, returnProxy].filter(Boolean).length;
+        if (returnFlags > 1) {
+            throw new Error("readAttributeOnReference options reference, result, and proxy are mutually exclusive");
+        }
+        const withReference = returnReference || returnProxy;
         const result = await this.sendCommand("read_attribute", {
-            attribute_name: attributeName,
+            attribute_name: targetAttributeName,
             reference_id: referenceId,
-            with: "result"
+            with: withReference ? "reference" : "result"
         });
-        return result.response;
+        if (!withReference)
+            return result.response;
+        const id = result.response;
+        const spawnedReference = this.spawnReference(id);
+        return returnProxy ? referenceProxy(spawnedReference) : spawnedReference;
     }
     /**
      * Registers a class by name
@@ -571,4 +906,4 @@ export default class Client {
         this.serverControlEnabled = true;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/client/index.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Logger from \"../logger.js\"\nimport Reference from \"./reference.js\"\nimport safeJSONStringify from \"../utils/safe-json-stringify.js\"\n\nconst logger = new Logger(\"Scoundrel Client\")\n\n// logger.setDebug(true)\n\nexport default class Client {\n  /**\n   * Creates a new Scoundrel Client\n   * @param {any} backend The backend connection (e.g., WebSocket)\n   * @param {{enableServerControl?: boolean}} [options] Client configuration options\n   */\n  constructor(backend, options = {}) {\n    this.backend = backend\n    this.backend.onCommand(this.onCommand)\n\n    /** @type {Record<number, any>} */\n    this.outgoingCommands = {}\n    this.incomingCommands = {}\n    this.outgoingCommandsCount = 0\n\n    /** @type {Record<string, any>} */\n    this._classes = {}\n\n    /** @type {Record<string, any>} */\n    this._objects = {}\n\n    /** @type {Record<string, Reference>} */\n    this.references = {}\n\n    /** @type {Record<number, any>} */\n    this.objects = {}\n\n    this.objectsCount = 0\n\n    /** @type {boolean} */\n    this.serverControlEnabled = Boolean(options.enableServerControl)\n  }\n\n  /**\n   * Closes the client connection\n   */\n  async close() {\n    this.backend.close()\n  }\n\n  /**\n   * Calls a method on a reference and returns the result directly\n   * @param {number} referenceId Reference identifier\n   * @param {string} methodName Method name to invoke\n   * @param  {...any} args Arguments to pass to the method\n   * @returns {Promise<any>} Result from the method call\n   */\n  async callMethodOnReference(referenceId, methodName, ...args) {\n    const result = await this.sendCommand(\"call_method_on_reference\", {\n      args: this.parseArg(args),\n      method_name: methodName,\n      reference_id: referenceId,\n      with: \"result\"\n    })\n\n    return result.response\n  }\n\n  /**\n   * Calls a method on a reference and returns a new reference\n   * @param {number} referenceId Reference identifier\n   * @param {string} methodName Method name to invoke\n   * @param  {...any} args Arguments to pass to the method\n   * @returns {Promise<Reference>} Reference to the return value\n   */\n  async callMethodOnReferenceWithReference(referenceId, methodName, ...args) {\n    const result = await this.sendCommand(\"call_method_on_reference\", {\n      args: this.parseArg(args),\n      method_name: methodName,\n      reference_id: referenceId,\n      with: \"reference\"\n    })\n    const id = result.response\n\n    return this.spawnReference(id)\n  }\n\n  /**\n   * Evaluates a string and returns a new reference\n   * @param {string} evalString Code to evaluate\n   * @returns {Promise<Reference>} Reference to the evaluated value\n   */\n  async evalWithReference(evalString) {\n    const result = await this.sendCommand(\"eval\", {\n      eval_string: evalString,\n      with_reference: true\n    })\n\n    if (!result) throw new Error(\"Blank result given\")\n\n    const objectId = result.object_id\n\n    if (!objectId) throw new Error(`No object ID given in result: ${JSON.stringify(result)}`)\n\n    return this.spawnReference(objectId)\n  }\n\n  /**\n   * Imports a module and returns a reference to it\n   * @param {string} importName Module name to import\n   * @returns {Promise<Reference>} Reference to the module\n   */\n  async import(importName) {\n    const result = await this.sendCommand(\"import\", {\n      import_name: importName\n    })\n\n    logger.log(() => [\"import\", {result}])\n\n    if (!result) throw new Error(\"No result given\")\n    if (!result.object_id) throw new Error(`No object ID given in result: ${JSON.stringify(result)}`)\n\n    const id = result.object_id\n\n    return this.spawnReference(id)\n  }\n\n  /**\n   * Gets a registered object by name\n   * @param {string} objectName Registered object name\n   * @returns {Promise<Reference>} Reference to the object\n   */\n  async getObject(objectName) {\n    const result = await this.sendCommand(\"get_object\", {\n      object_name: objectName\n    })\n\n    if (!result) throw new Error(\"Blank result given\")\n\n    const id = result.object_id\n\n    return this.spawnReference(id)\n  }\n\n  /**\n   * Spawns a new reference to an object\n   * @param {string} className Class name to construct\n   * @param  {...any} args Constructor arguments\n   * @returns {Promise<Reference>} Reference to the new instance\n   */\n  async newObjectWithReference(className, ...args) {\n    const result = await this.sendCommand(\"new_object_with_reference\", {\n      args: this.parseArg(args),\n      class_name: className\n    })\n\n    if (!result) throw new Error(\"Blank result given\")\n\n    const id = result.object_id\n\n    if (!id) throw new Error(`No object ID given in result: ${JSON.stringify(result)}`)\n\n    return this.spawnReference(id)\n  }\n\n  /**\n   * Checks if the input is a plain object\n   * @param {any} input Value to inspect\n   * @returns {boolean} True when the value is a plain object\n   */\n  isPlainObject(input) {\n    if (input && typeof input === \"object\" && !Array.isArray(input)) {\n      return true\n    }\n\n    return false\n  }\n\n  /**\n   * Handles an incoming command from the backend\n   * @param {object} args Command payload\n   * @param {string} args.command Command name\n   * @param {number} args.command_id Command identifier\n   * @param {any} args.data Command data\n   * @param {string} [args.error] Error message from the backend\n   * @param {string} [args.errorStack] Error stack from the backend\n   */\n  onCommand = ({command, command_id: commandID, data, error, errorStack, ...restArgs}) => {\n    logger.log(() => [\"onCommand\", {command, commandID, data, error, errorStack, restArgs}])\n\n    try {\n      if (!command) {\n        throw new Error(`No command key given in data: ${Object.keys(restArgs).join(\", \")}`)\n      } else if (command == \"command_response\") {\n        if (!(commandID in this.outgoingCommands)) {\n          throw new Error(`Outgoing command ${commandID} not found: ${Object.keys(this.outgoingCommands).join(\", \")}`)\n        }\n\n        const savedCommand = this.outgoingCommands[commandID]\n\n        delete this.outgoingCommands[commandID]\n\n        if (error) {\n          const errorToThrow = new Error(error)\n          const sanitizeStack = (stack) => {\n            if (!stack) return []\n            return stack\n              .split(\"\\n\")\n              .map((line) => line.trim())\n              .filter((line) => line)\n              .filter((line) => !/node_modules\\/ws/.test(line))\n              .filter((line) => !/(?:^|\\()node:/.test(line))\n              .filter((line) => !/(?:^|\\()node:internal\\//.test(line))\n              .filter((line) => !/(?:^|\\()internal\\//.test(line))\n              .filter((line) => !line.startsWith(\"Error:\"))\n          }\n\n          const formatSection = (label, stack) => {\n            const lines = sanitizeStack(stack)\n            if (lines.length === 0) return []\n            return [`${label} ${lines[0]}`, ...lines.slice(1)]\n          }\n\n          const combinedStack = [\n            `Error: ${error}`,\n            ...formatSection(\"[SCOUNTDREL-SERVER]\", errorStack),\n            ...formatSection(\"[SCOUNDREL-CLIENT]\", errorToThrow.stack),\n            ...formatSection(\"[SCOUNDREL-CLIENT]\", savedCommand.originStack ? `Command created at:\\n${savedCommand.originStack}` : null)\n          ].join(\"\\n\")\n\n          errorToThrow.stack = combinedStack\n\n          savedCommand.reject(errorToThrow)\n        } else {\n          logger.log(() => [`Resolving command ${commandID} with data`, data])\n          savedCommand.resolve(data.data)\n        }\n      } else if (!this.serverControlEnabled) {\n        this.send({command: \"command_response\", command_id: commandID, error: \"Server control is disabled\"})\n        return\n      } else if (command == \"get_object\") {\n        const serverObject = this._getRegisteredObject(data.object_name)\n        const serverClass = this._getRegisteredClass(data.object_name)\n        let object\n\n        if (serverObject !== undefined) {\n          object = serverObject\n        } else if (serverClass !== undefined) {\n          object = serverClass\n        } else {\n          object = globalThis[data.object_name]\n\n          if (object === undefined) throw new Error(`No such object: ${data.object_name}`)\n        }\n\n        const objectId = ++this.objectsCount\n\n        this.objects[objectId] = object\n        this.respondToCommand(commandID, {object_id: objectId})\n      } else if (command == \"new_object_with_reference\") {\n        const className = data.class_name\n        let object\n\n        if (typeof className == \"string\") {\n          const ClassInstance = this.getClass(className) || globalThis[className]\n\n          if (!ClassInstance) throw new Error(`No such class: ${className}`)\n\n          object = new ClassInstance(...data.args)\n        } else {\n          throw new Error(`Don't know how to handle class name: ${typeof className}`)\n        }\n\n        const objectId = ++this.objectsCount\n\n        this.objects[objectId] = object\n        this.respondToCommand(commandID, {object_id: objectId})\n      } else if (command == \"call_method_on_reference\") {\n        const referenceId = data.reference_id\n        const object = this.objects[referenceId]\n\n        if (!object) throw new Error(`No object by that ID: ${referenceId}`)\n\n        const method = object[data.method_name]\n\n        if (!method) throw new Error(`No method called '${data.method_name}' on a '${object.constructor.name}'`)\n\n        const respondWithValue = (responseValue) => {\n          if (data.with == \"reference\") {\n            const objectId = ++this.objectsCount\n\n            this.objects[objectId] = responseValue\n            this.respondToCommand(commandID, {response: objectId})\n          } else {\n            this.respondToCommand(commandID, {response: responseValue})\n          }\n        }\n\n        const response = method.call(object, ...data.args)\n\n        if (response && typeof response.then == \"function\") {\n          response.then(respondWithValue).catch((promiseError) => {\n            if (promiseError instanceof Error) {\n              this.send({command: \"command_response\", command_id: commandID, error: promiseError.message, errorStack: promiseError.stack})\n            } else {\n              this.send({command: \"command_response\", command_id: commandID, error: String(promiseError)})\n            }\n          })\n        } else {\n          respondWithValue(response)\n        }\n      } else if (command == \"serialize_reference\") {\n        const referenceId = data.reference_id\n        const object = this.objects[referenceId]\n\n        if (!object) throw new Error(`No object by that ID: ${referenceId}`)\n\n        const serialized = safeJSONStringify(object)\n        this.respondToCommand(commandID, serialized)\n      } else if (command == \"read_attribute\") {\n        const attributeName = data.attribute_name\n        const referenceId = data.reference_id\n        const returnWith = data.with\n        const object = this.objects[referenceId]\n\n        if (!object) throw new Error(`No object by that ID: ${referenceId}`)\n\n        const attribute = object[attributeName]\n\n        if (returnWith == \"reference\") {\n          const objectId = ++this.objectsCount\n\n          this.objects[objectId] = attribute\n          this.respondToCommand(commandID, {response: objectId})\n        } else {\n          this.respondToCommand(commandID, {response: attribute})\n        }\n      } else if (command == \"eval\") {\n        const respondWithResult = (evalResult) => {\n          if (data.with_reference) {\n            const objectId = ++this.objectsCount\n\n            this.objects[objectId] = evalResult\n            this.respondToCommand(commandID, {object_id: objectId})\n          } else {\n            this.respondToCommand(commandID, {response: evalResult})\n          }\n        }\n\n        const scope = {...this._objects, ...this._classes}\n        const reservedIdentifiers = new Set([\n          \"break\",\n          \"case\",\n          \"catch\",\n          \"class\",\n          \"const\",\n          \"continue\",\n          \"debugger\",\n          \"default\",\n          \"delete\",\n          \"do\",\n          \"else\",\n          \"export\",\n          \"extends\",\n          \"finally\",\n          \"for\",\n          \"function\",\n          \"if\",\n          \"import\",\n          \"in\",\n          \"instanceof\",\n          \"new\",\n          \"return\",\n          \"super\",\n          \"switch\",\n          \"this\",\n          \"throw\",\n          \"try\",\n          \"typeof\",\n          \"var\",\n          \"void\",\n          \"while\",\n          \"with\",\n          \"yield\",\n          \"let\",\n          \"enum\",\n          \"await\",\n          \"implements\",\n          \"package\",\n          \"protected\",\n          \"static\",\n          \"interface\",\n          \"private\",\n          \"public\",\n          \"eval\"\n        ])\n\n        const isValidIdentifier = (name) =>\n          /^(?:[$_]|\\p{ID_Start})(?:[$_]|\\p{ID_Continue})*$/u.test(name) && !reservedIdentifiers.has(name)\n\n        const scopeKeys = Object.keys(scope)\n        const invalidKeys = scopeKeys.filter((key) => !isValidIdentifier(key))\n\n        if (invalidKeys.length > 0) {\n          throw new Error(`Invalid registered identifier(s): ${invalidKeys.join(\", \")}`)\n        }\n\n        // Ensure registered objects/classes are available as locals inside the eval\n        const evaluator = new Function(\"__evalString\", ...scopeKeys, \"return eval(__evalString)\")\n        const evalResult = evaluator(data.eval_string, ...scopeKeys.map((key) => scope[key]))\n\n        if (evalResult && typeof evalResult.then == \"function\") {\n          evalResult.then(respondWithResult).catch((promiseError) => {\n            if (promiseError instanceof Error) {\n              this.send({command: \"command_response\", command_id: commandID, error: promiseError.message, errorStack: promiseError.stack})\n            } else {\n              this.send({command: \"command_response\", command_id: commandID, error: String(promiseError)})\n            }\n          })\n        } else {\n          respondWithResult(evalResult)\n        }\n      } else {\n        throw new Error(`Unknown command: ${command}`)\n      }\n    } catch (error) {\n      if (error instanceof Error) {\n        this.send({command: \"command_response\", command_id: commandID, error: error.message, errorStack: error.stack})\n      } else {\n        this.send({command: \"command_response\", command_id: commandID, error: String(error)})\n      }\n\n      logger.error(error)\n    }\n  }\n\n  /**\n   * Parases an argument for sending to the server\n   * @param {any} arg Argument to serialize for transport\n   * @returns {any} Serialized argument payload\n   */\n  parseArg(arg) {\n    if (Array.isArray(arg)) {\n      return arg.map((argInArray) => this.parseArg(argInArray))\n    } else if (arg instanceof Reference) {\n      return {\n        __scoundrel_object_id: arg.id,\n        __scoundrel_type: \"reference\"\n      }\n    } else if (this.isPlainObject(arg)) {\n      /** @type {Record<any, any>} */\n      const newObject = {}\n\n      for (const key in arg) {\n        const value = arg[key]\n\n        newObject[key] = this.parseArg(value)\n      }\n\n      return newObject\n    }\n\n    return arg\n  }\n\n  /**\n   * Reads an attribute on a reference and returns a new reference\n   * @param {number} referenceId Reference identifier\n   * @param {string} attributeName Attribute name to read\n   * @returns {Promise<Reference>} Reference to the attribute value\n   */\n  async readAttributeOnReferenceWithReference(referenceId, attributeName) {\n    const result = await this.sendCommand(\"read_attribute\", {\n      attribute_name: attributeName,\n      reference_id: referenceId,\n      with: \"reference\"\n    })\n    const id = result.response\n\n    return this.spawnReference(id)\n  }\n\n  /**\n   * Reads an attribute on a reference and returns the result directly\n   * @param {number} referenceId Reference identifier\n   * @param {string} attributeName Attribute name to read\n   * @returns {Promise<any>} Attribute value\n   */\n  async readAttributeOnReference(referenceId, attributeName) {\n    const result = await this.sendCommand(\"read_attribute\", {\n      attribute_name: attributeName,\n      reference_id: referenceId,\n      with: \"result\"\n    })\n    return result.response\n  }\n\n  /**\n   * Registers a class by name\n   * @param {string} className Class name to register\n   * @param {any} classInstance Class constructor or instance\n   */\n  registerClass(className, classInstance) {\n    if (className in this._classes) throw new Error(`Class already exists: ${className}`)\n\n    this._classes[className] = classInstance\n  }\n\n  /**\n   * Unregisters a class by name\n   * @param {string} className Class name to remove\n   */\n  unregisterClass(className) {\n    if (!(className in this._classes)) throw new Error(`Class does not exist: ${className}`)\n\n    delete this._classes[className]\n  }\n\n  /**\n   * Gets a registered class by name\n   * @param {string} className Class name to look up\n   * @returns {any} Registered class or undefined\n   */\n  _getRegisteredClass(className) {\n    return this._classes[className]\n  }\n\n  /**\n   * Gets a registered class by name\n   * @param {string} className Class name to look up\n   * @returns {any} Registered class or undefined\n   */\n  getClass(className) {\n    return this._classes[className]\n  }\n\n  /**\n   * Registers an object by name\n   * @param {string} objectName Object name to register\n   * @param {any} objectInstance Object instance\n   */\n  registerObject(objectName, objectInstance) {\n    if (objectName in this._objects) throw new Error(`Object already exists: ${objectName}`)\n\n    this._objects[objectName] = objectInstance\n  }\n\n  /**\n   * Unregisters an object by name\n   * @param {string} objectName Object name to remove\n   */\n  unregisterObject(objectName) {\n    if (!(objectName in this._objects)) throw new Error(`Object does not exist: ${objectName}`)\n\n    delete this._objects[objectName]\n  }\n\n  /**\n   * Gets a registered object by name\n   * @param {string} objectName Object name to look up\n   * @returns {any} Registered object or undefined\n   */\n  _getRegisteredObject(objectName) {\n    return this._objects[objectName]\n  }\n\n  /**\n   * Responds to a command from the backend\n   * @param {number} commandId Command identifier\n   * @param {any} data Response payload\n   */\n  respondToCommand(commandId, data) {\n    this.send({command: \"command_response\", command_id: commandId, data: {command_id: commandId, data}})\n  }\n\n  /**\n   * Sends a command to the backend and returns a promise that resolves with the response\n   * @param {string} command Command name\n   * @param {any} data Command payload\n   * @returns {Promise<any>} Response from the backend\n   */\n  sendCommand(command, data) {\n    return new Promise((resolve, reject) => {\n      const outgoingCommandCount = ++this.outgoingCommandsCount\n      const originError = new Error(`Command '${command}' dispatched`)\n      // Strip the sendCommand frame to highlight the caller site.\n      if (Error.captureStackTrace) Error.captureStackTrace(originError, this.sendCommand)\n      const commandData = {\n        command,\n        command_id: outgoingCommandCount,\n        data\n      }\n\n      this.outgoingCommands[outgoingCommandCount] = {resolve, reject, originStack: originError.stack}\n      logger.log(() => [\"Sending\", commandData])\n      this.send(commandData)\n    })\n  }\n\n  /**\n   * Sends data to the backend\n   * @param {any} data Payload to send\n   */\n  send(data) {\n    this.backend.send(data)\n  }\n\n  /**\n   * Serializes a reference and returns the result directly\n   * @param {number} referenceId Reference identifier\n   * @returns {Promise<any>} Parsed JSON representation\n   */\n  async serializeReference(referenceId) {\n    const json = await this.sendCommand(\"serialize_reference\", {reference_id: referenceId})\n\n    return JSON.parse(json)\n  }\n\n  /**\n   * Spawns a new reference to an object\n   * @param {string} id Reference identifier\n   * @returns {Reference} Reference instance\n   */\n  spawnReference(id) {\n    const reference = new Reference(this, id)\n\n    this.references[id] = reference\n\n    return reference\n  }\n\n  enableServerControl() {\n    this.serverControlEnabled = true\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/client/index.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Logger from \"../logger.js\"\nimport Reference from \"./reference.js\"\nimport referenceProxy from \"./reference-proxy.js\"\nimport safeJSONStringify from \"../utils/safe-json-stringify.js\"\n\nconst logger = new Logger(\"Scoundrel Client\")\n\n/** @typedef {import(\"./reference-proxy.js\").Proxy} Proxy */\n\n// logger.setDebug(true)\n\n/**\n * @typedef {{reference?: boolean, result?: boolean, proxy?: boolean}} ReturnOptions\n * @typedef {ReturnOptions & {result?: false}} ReturnReferenceOptions\n * @typedef {ReturnOptions & {result: true, reference?: false}} ReturnResultOptions\n */\nexport default class Client {\n  /**\n   * Creates a new Scoundrel Client\n   * @param {any} backend The backend connection (e.g., WebSocket)\n   * @param {{enableServerControl?: boolean}} [options] Client configuration options\n   */\n  constructor(backend, options = {}) {\n    this.backend = backend\n    this.backend.onCommand(this.onCommand)\n\n    /** @type {Record<number, any>} */\n    this.outgoingCommands = {}\n    this.incomingCommands = {}\n    this.outgoingCommandsCount = 0\n\n    /** @type {Record<string, any>} */\n    this._classes = {}\n\n    /** @type {Record<string, any>} */\n    this._objects = {}\n\n    /** @type {Record<string, Reference>} */\n    this.references = {}\n\n    /** @type {Record<number, any>} */\n    this.objects = {}\n\n    this.objectsCount = 0\n\n    /** @type {boolean} */\n    this.serverControlEnabled = Boolean(options.enableServerControl)\n  }\n\n  /**\n   * Closes the client connection\n   */\n  async close() {\n    this.backend.close()\n  }\n\n  /**\n   * Calls a method on a reference and returns the result directly\n   * @overload\n   * @param {number} referenceId Reference identifier\n   * @param {string} methodName Method name to invoke\n   * @param  {...any} args Arguments to pass to the method\n   * @returns {Promise<any>} Result from the method call\n   */\n  /**\n   * Calls a method on a reference and returns a new reference\n   * @overload\n   * @param {number} referenceId Reference identifier\n   * @param {string} methodName Method name to invoke\n   * @param {ReturnReferenceOptions} options Options for the call\n   * @param  {...any} args Arguments to pass to the method\n   * @returns {Promise<Reference | Proxy>} Reference or proxy to the returned value\n   */\n  /**\n   * Calls a method on a reference and returns the result directly\n   * @overload\n   * @param {number} referenceId Reference identifier\n   * @param {string} methodName Method name to invoke\n   * @param {ReturnResultOptions} options Options for the call\n   * @param  {...any} args Arguments to pass to the method\n   * @returns {Promise<any>} Result from the method call\n   */\n  /**\n   * Calls a method on a reference and returns the result directly\n   * @param {number} referenceId Reference identifier\n   * @param {string} methodName Method name to invoke\n   * @param {ReturnOptions | any} [optionsOrArg] Options for the call or first argument\n   * @param  {...any} args Arguments to pass to the method\n   * @returns {Promise<Reference | Proxy | any>} Result or reference from the method call\n   */\n  async callMethodOnReference(referenceId, methodName, optionsOrArg, ...args) {\n    const allowedOptions = new Set([\"reference\", \"result\", \"proxy\"])\n    /** @type {ReturnOptions | undefined} */\n    let options\n    /** @type {any[]} */\n    let methodArgs\n\n    if (typeof optionsOrArg === \"undefined\") {\n      methodArgs = args\n    } else if (this.isPlainObject(optionsOrArg)) {\n      const optionKeys = Object.keys(optionsOrArg)\n      const hasOptionKey = optionKeys.some((key) => allowedOptions.has(key))\n\n      if (hasOptionKey) {\n        const unknownOptions = optionKeys.filter((key) => !allowedOptions.has(key))\n        if (unknownOptions.length === 0) {\n          const optionValuesAreBoolean = optionKeys\n            .filter((key) => allowedOptions.has(key))\n            .every((key) => typeof optionsOrArg[key] === \"boolean\")\n\n          if (optionValuesAreBoolean) {\n            options = /** @type {ReturnOptions} */ (optionsOrArg)\n            methodArgs = args\n          } else {\n            methodArgs = [optionsOrArg, ...args]\n          }\n        } else {\n          throw new Error(`Unknown callMethodOnReference options: ${unknownOptions.join(\", \")}`)\n        }\n      } else {\n        methodArgs = [optionsOrArg, ...args]\n      }\n    } else {\n      methodArgs = [optionsOrArg, ...args]\n    }\n\n    const returnReference = options?.reference === true\n    const returnResult = options?.result === true\n    const returnProxy = options?.proxy === true\n    const returnFlags = [returnReference, returnResult, returnProxy].filter(Boolean).length\n\n    if (returnFlags > 1) {\n      throw new Error(\"callMethodOnReference options reference, result, and proxy are mutually exclusive\")\n    }\n\n    const withReference = returnReference || returnProxy\n    const result = await this.sendCommand(\"call_method_on_reference\", {\n      args: this.parseArg(methodArgs),\n      method_name: methodName,\n      reference_id: referenceId,\n      with: withReference ? \"reference\" : \"result\"\n    })\n\n    if (!result) throw new Error(\"Blank result given\")\n\n    if (withReference) {\n      const objectId = result.response\n\n      if (!objectId) throw new Error(`No object ID given in result: ${JSON.stringify(result)}`)\n\n      const spawnedReference = this.spawnReference(objectId)\n      return returnProxy ? referenceProxy(spawnedReference) : spawnedReference\n    }\n\n    return result.response\n  }\n\n  /**\n   * Calls a method on a reference and returns a new reference\n   * @param {number} referenceId Reference identifier\n   * @param {string} methodName Method name to invoke\n   * @param  {...any} args Arguments to pass to the method\n   * @returns {Promise<Reference>} Reference to the return value\n   */\n  async callMethodOnReferenceWithReference(referenceId, methodName, ...args) {\n    console.warn(\"Scoundrel Client\", \"callMethodOnReferenceWithReference is deprecated; use callMethodOnReference with reference instead.\")\n    return this.callMethodOnReference(referenceId, methodName, {reference: true}, ...args)\n  }\n\n  /**\n   * Evaluates a string and returns a proxy\n   * @param {string} evalString Code to evaluate\n   * @returns {Promise<Proxy>} Proxy to the evaluated value\n   */\n  async eval(evalString) {\n    if (typeof evalString !== \"string\") {\n      throw new Error(\"eval requires an eval string\")\n    }\n\n    const result = await this.sendCommand(\"eval\", {\n      eval_string: evalString,\n      with_reference: true\n    })\n\n    if (!result) throw new Error(\"Blank result given\")\n\n    const objectId = result.object_id\n\n    if (!objectId) throw new Error(`No object ID given in result: ${JSON.stringify(result)}`)\n\n    const spawnedReference = this.spawnReference(objectId)\n    return referenceProxy(spawnedReference)\n  }\n\n  /**\n   * Evaluates a string and returns a reference\n   * @param {string} evalString Code to evaluate\n   * @returns {Promise<Reference>} Reference to the evaluated value\n   */\n  async evalReference(evalString) {\n    if (typeof evalString !== \"string\") {\n      throw new Error(\"evalReference requires an eval string\")\n    }\n\n    const result = await this.sendCommand(\"eval\", {\n      eval_string: evalString,\n      with_reference: true\n    })\n\n    if (!result) throw new Error(\"Blank result given\")\n\n    const objectId = result.object_id\n\n    if (!objectId) throw new Error(`No object ID given in result: ${JSON.stringify(result)}`)\n\n    return this.spawnReference(objectId)\n  }\n\n  /**\n   * Evaluates a string and returns the result directly\n   * @param {string} evalString Code to evaluate\n   * @returns {Promise<any>} Evaluated result\n   */\n  async evalResult(evalString) {\n    if (typeof evalString !== \"string\") {\n      throw new Error(\"evalResult requires an eval string\")\n    }\n\n    const result = await this.sendCommand(\"eval\", {\n      eval_string: evalString,\n      with_reference: false\n    })\n\n    if (!result) throw new Error(\"Blank result given\")\n    if (!(\"response\" in result)) throw new Error(`No response given in result: ${JSON.stringify(result)}`)\n\n    return result.response\n  }\n\n  /**\n   * Imports a module and returns a proxy to it\n   * @param {string} importName Module name to import\n   * @returns {Promise<Proxy>} Proxy to the module\n   */\n  async import(importName) {\n    if (typeof importName !== \"string\") throw new Error(\"import requires a module name\")\n\n    const result = await this.sendCommand(\"import\", {\n      import_name: importName\n    })\n\n    logger.log(() => [\"import\", {result}])\n\n    if (!result) throw new Error(\"No result given\")\n    if (!result.object_id) throw new Error(`No object ID given in result: ${JSON.stringify(result)}`)\n\n    const id = result.object_id\n    const spawnedReference = this.spawnReference(id)\n\n    return referenceProxy(spawnedReference)\n  }\n\n  /**\n   * Imports a module and returns a reference to it\n   * @param {string} importName Module name to import\n   * @returns {Promise<Reference>} Reference to the module\n   */\n  async importReference(importName) {\n    if (typeof importName !== \"string\") throw new Error(\"importReference requires a module name\")\n\n    const result = await this.sendCommand(\"import\", {\n      import_name: importName\n    })\n\n    logger.log(() => [\"import\", {result}])\n\n    if (!result) throw new Error(\"No result given\")\n    if (!result.object_id) throw new Error(`No object ID given in result: ${JSON.stringify(result)}`)\n\n    const id = result.object_id\n\n    return this.spawnReference(id)\n  }\n\n  /**\n   * Imports a module and returns the serialized result\n   * @param {string} importName Module name to import\n   * @returns {Promise<any>} Serialized result for the module\n   */\n  async importResult(importName) {\n    const reference = await this.importReference(importName)\n    return await reference.serialize()\n  }\n\n  /**\n   * Gets a registered object by name and returns a proxy\n   * @param {string} objectName Registered object name\n   * @returns {Promise<Proxy>} Proxy to the object\n   */\n  async getObject(objectName) {\n    const reference = await this.getObjectReference(objectName)\n    return referenceProxy(reference)\n  }\n\n  /**\n   * Gets a registered object by name and returns a reference\n   * @param {string} objectName Registered object name\n   * @returns {Promise<Reference>} Reference to the object\n   */\n  async getObjectReference(objectName) {\n    if (typeof objectName !== \"string\") throw new Error(\"getObjectReference requires an object name\")\n\n    const result = await this.sendCommand(\"get_object\", {\n      object_name: objectName\n    })\n\n    if (!result) throw new Error(\"Blank result given\")\n\n    const id = result.object_id\n\n    return this.spawnReference(id)\n  }\n\n  /**\n   * Gets a registered object by name and returns the serialized result\n   * @param {string} objectName Registered object name\n   * @returns {Promise<any>} Serialized result for the object\n   */\n  async getObjectResult(objectName) {\n    const reference = await this.getObjectReference(objectName)\n    return await reference.serialize()\n  }\n\n  /**\n   * Spawns a new reference to an object and returns a proxy\n   * @param {string} className Class name to construct\n   * @param  {...any} args Constructor arguments\n   * @returns {Promise<Proxy>} Proxy to the new instance\n   */\n  async newObject(className, ...args) {\n    if (typeof className !== \"string\") throw new Error(\"newObject requires a class name\")\n\n    const result = await this.sendCommand(\"new_object_with_reference\", {\n      args: this.parseArg(args),\n      class_name: className\n    })\n\n    if (!result) throw new Error(\"Blank result given\")\n\n    const id = result.object_id\n\n    if (!id) throw new Error(`No object ID given in result: ${JSON.stringify(result)}`)\n\n    const spawnedReference = this.spawnReference(id)\n\n    return referenceProxy(spawnedReference)\n  }\n\n  /**\n   * Spawns a new reference to an object and returns a reference\n   * @param {string} className Class name to construct\n   * @param  {...any} args Constructor arguments\n   * @returns {Promise<Reference>} Reference to the new instance\n   */\n  async newObjectReference(className, ...args) {\n    if (typeof className !== \"string\") throw new Error(\"newObjectReference requires a class name\")\n\n    const result = await this.sendCommand(\"new_object_with_reference\", {\n      args: this.parseArg(args),\n      class_name: className\n    })\n\n    if (!result) throw new Error(\"Blank result given\")\n\n    const id = result.object_id\n\n    if (!id) throw new Error(`No object ID given in result: ${JSON.stringify(result)}`)\n\n    return this.spawnReference(id)\n  }\n\n  /**\n   * Spawns a new reference to an object and returns the serialized result\n   * @param {string} className Class name to construct\n   * @param  {...any} args Constructor arguments\n   * @returns {Promise<any>} Serialized result for the new instance\n   */\n  async newObjectResult(className, ...args) {\n    const reference = await this.newObjectReference(className, ...args)\n    return await reference.serialize()\n  }\n\n  /**\n   * Checks if the input is a plain object\n   * @param {any} input Value to inspect\n   * @returns {boolean} True when the value is a plain object\n   */\n  isPlainObject(input) {\n    if (input && typeof input === \"object\" && !Array.isArray(input)) {\n      return true\n    }\n\n    return false\n  }\n\n  /**\n   * Handles an incoming command from the backend\n   * @param {object} args Command payload\n   * @param {string} args.command Command name\n   * @param {number} args.command_id Command identifier\n   * @param {any} args.data Command data\n   * @param {string} [args.error] Error message from the backend\n   * @param {string} [args.errorStack] Error stack from the backend\n   */\n  onCommand = ({command, command_id: commandID, data, error, errorStack, ...restArgs}) => {\n    logger.log(() => [\"onCommand\", {command, commandID, data, error, errorStack, restArgs}])\n\n    try {\n      if (!command) {\n        throw new Error(`No command key given in data: ${Object.keys(restArgs).join(\", \")}`)\n      } else if (command == \"command_response\") {\n        if (!(commandID in this.outgoingCommands)) {\n          throw new Error(`Outgoing command ${commandID} not found: ${Object.keys(this.outgoingCommands).join(\", \")}`)\n        }\n\n        const savedCommand = this.outgoingCommands[commandID]\n\n        delete this.outgoingCommands[commandID]\n\n        if (error) {\n          const errorToThrow = new Error(error)\n          const sanitizeStack = (stack) => {\n            if (!stack) return []\n            return stack\n              .split(\"\\n\")\n              .map((line) => line.trim())\n              .filter((line) => line)\n              .filter((line) => !/node_modules\\/ws/.test(line))\n              .filter((line) => !/(?:^|\\()node:/.test(line))\n              .filter((line) => !/(?:^|\\()node:internal\\//.test(line))\n              .filter((line) => !/(?:^|\\()internal\\//.test(line))\n              .filter((line) => !line.startsWith(\"Error:\"))\n          }\n\n          const formatSection = (label, stack) => {\n            const lines = sanitizeStack(stack)\n            if (lines.length === 0) return []\n            return [`${label} ${lines[0]}`, ...lines.slice(1)]\n          }\n\n          const combinedStack = [\n            `Error: ${error}`,\n            ...formatSection(\"[SCOUNTDREL-SERVER]\", errorStack),\n            ...formatSection(\"[SCOUNDREL-CLIENT]\", errorToThrow.stack),\n            ...formatSection(\"[SCOUNDREL-CLIENT]\", savedCommand.originStack ? `Command created at:\\n${savedCommand.originStack}` : null)\n          ].join(\"\\n\")\n\n          errorToThrow.stack = combinedStack\n\n          savedCommand.reject(errorToThrow)\n        } else {\n          logger.log(() => [`Resolving command ${commandID} with data`, data])\n          savedCommand.resolve(data.data)\n        }\n      } else if (!this.serverControlEnabled) {\n        this.send({command: \"command_response\", command_id: commandID, error: \"Server control is disabled\"})\n        return\n      } else if (command == \"get_object\") {\n        const serverObject = this._getRegisteredObject(data.object_name)\n        const serverClass = this._getRegisteredClass(data.object_name)\n        let object\n\n        if (serverObject !== undefined) {\n          object = serverObject\n        } else if (serverClass !== undefined) {\n          object = serverClass\n        } else {\n          object = globalThis[data.object_name]\n\n          if (object === undefined) throw new Error(`No such object: ${data.object_name}`)\n        }\n\n        const objectId = ++this.objectsCount\n\n        this.objects[objectId] = object\n        this.respondToCommand(commandID, {object_id: objectId})\n      } else if (command == \"new_object_with_reference\") {\n        const className = data.class_name\n        let object\n\n        if (typeof className == \"string\") {\n          const ClassInstance = this.getClass(className) || globalThis[className]\n\n          if (!ClassInstance) throw new Error(`No such class: ${className}`)\n\n          object = new ClassInstance(...data.args)\n        } else {\n          throw new Error(`Don't know how to handle class name: ${typeof className}`)\n        }\n\n        const objectId = ++this.objectsCount\n\n        this.objects[objectId] = object\n        this.respondToCommand(commandID, {object_id: objectId})\n      } else if (command == \"call_method_on_reference\") {\n        const referenceId = data.reference_id\n        const object = this.objects[referenceId]\n\n        if (!object) throw new Error(`No object by that ID: ${referenceId}`)\n\n        const method = object[data.method_name]\n\n        if (!method) throw new Error(`No method called '${data.method_name}' on a '${object.constructor.name}'`)\n\n        const respondWithValue = (responseValue) => {\n          if (data.with == \"reference\") {\n            const objectId = ++this.objectsCount\n\n            this.objects[objectId] = responseValue\n            this.respondToCommand(commandID, {response: objectId})\n          } else {\n            this.respondToCommand(commandID, {response: responseValue})\n          }\n        }\n\n        const response = method.call(object, ...data.args)\n\n        if (response && typeof response.then == \"function\") {\n          response.then(respondWithValue).catch((promiseError) => {\n            if (promiseError instanceof Error) {\n              this.send({command: \"command_response\", command_id: commandID, error: promiseError.message, errorStack: promiseError.stack})\n            } else {\n              this.send({command: \"command_response\", command_id: commandID, error: String(promiseError)})\n            }\n          })\n        } else {\n          respondWithValue(response)\n        }\n      } else if (command == \"serialize_reference\") {\n        const referenceId = data.reference_id\n        const object = this.objects[referenceId]\n\n        if (!object) throw new Error(`No object by that ID: ${referenceId}`)\n\n        const serialized = safeJSONStringify(object)\n        this.respondToCommand(commandID, serialized)\n      } else if (command == \"read_attribute\") {\n        const attributeName = data.attribute_name\n        const referenceId = data.reference_id\n        const returnWith = data.with\n        const object = this.objects[referenceId]\n\n        if (!object) throw new Error(`No object by that ID: ${referenceId}`)\n\n        const attribute = object[attributeName]\n\n        if (returnWith == \"reference\") {\n          const objectId = ++this.objectsCount\n\n          this.objects[objectId] = attribute\n          this.respondToCommand(commandID, {response: objectId})\n        } else {\n          this.respondToCommand(commandID, {response: attribute})\n        }\n      } else if (command == \"eval\") {\n        const respondWithResult = (evalResult) => {\n          if (data.with_reference) {\n            const objectId = ++this.objectsCount\n\n            this.objects[objectId] = evalResult\n            this.respondToCommand(commandID, {object_id: objectId})\n          } else {\n            this.respondToCommand(commandID, {response: evalResult})\n          }\n        }\n\n        const scope = {...this._objects, ...this._classes}\n        const reservedIdentifiers = new Set([\n          \"break\",\n          \"case\",\n          \"catch\",\n          \"class\",\n          \"const\",\n          \"continue\",\n          \"debugger\",\n          \"default\",\n          \"delete\",\n          \"do\",\n          \"else\",\n          \"export\",\n          \"extends\",\n          \"finally\",\n          \"for\",\n          \"function\",\n          \"if\",\n          \"import\",\n          \"in\",\n          \"instanceof\",\n          \"new\",\n          \"return\",\n          \"super\",\n          \"switch\",\n          \"this\",\n          \"throw\",\n          \"try\",\n          \"typeof\",\n          \"var\",\n          \"void\",\n          \"while\",\n          \"with\",\n          \"yield\",\n          \"let\",\n          \"enum\",\n          \"await\",\n          \"implements\",\n          \"package\",\n          \"protected\",\n          \"static\",\n          \"interface\",\n          \"private\",\n          \"public\",\n          \"eval\"\n        ])\n\n        const isValidIdentifier = (name) =>\n          /^(?:[$_]|\\p{ID_Start})(?:[$_]|\\p{ID_Continue})*$/u.test(name) && !reservedIdentifiers.has(name)\n\n        const scopeKeys = Object.keys(scope)\n        const invalidKeys = scopeKeys.filter((key) => !isValidIdentifier(key))\n\n        if (invalidKeys.length > 0) {\n          throw new Error(`Invalid registered identifier(s): ${invalidKeys.join(\", \")}`)\n        }\n\n        // Ensure registered objects/classes are available as locals inside the eval\n        const evaluator = new Function(\"__evalString\", ...scopeKeys, \"return eval(__evalString)\")\n        const evalResult = evaluator(data.eval_string, ...scopeKeys.map((key) => scope[key]))\n\n        if (evalResult && typeof evalResult.then == \"function\") {\n          evalResult.then(respondWithResult).catch((promiseError) => {\n            if (promiseError instanceof Error) {\n              this.send({command: \"command_response\", command_id: commandID, error: promiseError.message, errorStack: promiseError.stack})\n            } else {\n              this.send({command: \"command_response\", command_id: commandID, error: String(promiseError)})\n            }\n          })\n        } else {\n          respondWithResult(evalResult)\n        }\n      } else {\n        throw new Error(`Unknown command: ${command}`)\n      }\n    } catch (error) {\n      if (error instanceof Error) {\n        this.send({command: \"command_response\", command_id: commandID, error: error.message, errorStack: error.stack})\n      } else {\n        this.send({command: \"command_response\", command_id: commandID, error: String(error)})\n      }\n\n      logger.error(error)\n    }\n  }\n\n  /**\n   * Parases an argument for sending to the server\n   * @param {any} arg Argument to serialize for transport\n   * @returns {any} Serialized argument payload\n   */\n  parseArg(arg) {\n    if (Array.isArray(arg)) {\n      return arg.map((argInArray) => this.parseArg(argInArray))\n    } else if (arg instanceof Reference) {\n      return {\n        __scoundrel_object_id: arg.id,\n        __scoundrel_type: \"reference\"\n      }\n    } else if (this.isPlainObject(arg)) {\n      /** @type {Record<any, any>} */\n      const newObject = {}\n\n      for (const key in arg) {\n        const value = arg[key]\n\n        newObject[key] = this.parseArg(value)\n      }\n\n      return newObject\n    }\n\n    return arg\n  }\n\n  /**\n   * Reads an attribute on a reference and returns a new reference\n   * @overload\n   * @param {number} referenceId Reference identifier\n   * @param {string | number} attributeName Attribute name to read\n   * @returns {Promise<Reference>} Reference to the attribute value\n   */\n  /**\n   * Reads an attribute on a reference and returns a new reference\n   * @overload\n   * @param {number} referenceId Reference identifier\n   * @param {string | number} attributeName Attribute name to read\n   * @param {ReturnReferenceOptions} optionsOrArg Options for the read\n   * @returns {Promise<Reference | Proxy>} Reference or proxy to the attribute value\n   */\n  /**\n   * Reads an attribute on a reference and returns the result directly\n   * @overload\n   * @param {number} referenceId Reference identifier\n   * @param {string | number} attributeName Attribute name to read\n   * @param {ReturnResultOptions} optionsOrArg Options for the read\n   * @returns {Promise<any>} Attribute value\n   */\n  /**\n   * Reads an attribute on a reference and returns a new reference\n   * @param {number} referenceId Reference identifier\n   * @param {string | number} attributeName Attribute name to read\n   * @param {ReturnOptions} [optionsOrArg] Options for the read\n   * @returns {Promise<Reference | Proxy | any>} Reference, proxy, or result\n   */\n  async readAttributeOnReferenceWithReference(referenceId, attributeName, optionsOrArg) {\n    const allowedOptions = new Set([\"reference\", \"result\", \"proxy\"])\n    /** @type {ReturnOptions} */\n    let options = {reference: true}\n\n    if (typeof optionsOrArg === \"undefined\") {\n      options = {reference: true}\n    } else if (this.isPlainObject(optionsOrArg)) {\n      const optionKeys = Object.keys(optionsOrArg)\n      const hasOptionKey = optionKeys.some((key) => allowedOptions.has(key))\n\n      if (hasOptionKey) {\n        const unknownOptions = optionKeys.filter((key) => !allowedOptions.has(key))\n        if (unknownOptions.length === 0) {\n          const hasExplicitReturn = Object.prototype.hasOwnProperty.call(optionsOrArg, \"reference\")\n            || Object.prototype.hasOwnProperty.call(optionsOrArg, \"result\")\n            || Object.prototype.hasOwnProperty.call(optionsOrArg, \"proxy\")\n          options = /** @type {ReturnOptions} */ ({\n            ...(hasExplicitReturn ? {} : {reference: true}),\n            ...optionsOrArg\n          })\n        } else {\n          throw new Error(`Unknown readAttributeOnReferenceWithReference options: ${unknownOptions.join(\", \")}`)\n        }\n      } else {\n        throw new Error(\"readAttributeOnReferenceWithReference does not accept positional arguments\")\n      }\n    } else {\n      throw new Error(\"readAttributeOnReferenceWithReference does not accept positional arguments\")\n    }\n\n    const returnReference = options?.reference === true\n    const returnResult = options?.result === true\n    const returnProxy = options?.proxy === true\n    const returnFlags = [returnReference, returnResult, returnProxy].filter(Boolean).length\n\n    if (returnFlags > 1) {\n      throw new Error(\"readAttributeOnReferenceWithReference options reference, result, and proxy are mutually exclusive\")\n    }\n\n    return this.readAttributeOnReference(referenceId, options, attributeName)\n  }\n\n  /**\n   * Reads an attribute on a reference and returns the result directly\n   * @overload\n   * @param {number} referenceId Reference identifier\n   * @param {string | number} attributeName Attribute name to read\n   * @returns {Promise<any>} Attribute value\n   */\n  /**\n   * Reads an attribute on a reference and returns a new reference\n   * @overload\n   * @param {number} referenceId Reference identifier\n   * @param {ReturnReferenceOptions} options Options for the read\n   * @param {string | number} attributeName Attribute name to read\n   * @returns {Promise<Reference | Proxy>} Reference or proxy to the attribute value\n   */\n  /**\n   * Reads an attribute on a reference and returns a result or reference\n   * @overload\n   * @param {number} referenceId Reference identifier\n   * @param {ReturnOptions} options Options for the read\n   * @param {string | number} attributeName Attribute name to read\n   * @returns {Promise<Reference | Proxy | any>} Attribute value or reference\n   */\n  /**\n   * Reads an attribute on a reference and returns the result directly\n   * @overload\n   * @param {number} referenceId Reference identifier\n   * @param {ReturnResultOptions} options Options for the read\n   * @param {string | number} attributeName Attribute name to read\n   * @returns {Promise<any>} Attribute value\n   */\n  /**\n   * Reads an attribute on a reference and returns the result directly\n   * @param {number} referenceId Reference identifier\n   * @param {string | number | ReturnOptions} attributeNameOrOptions Attribute name or options\n   * @param {string | number} [attributeName] Attribute name when using options\n   * @returns {Promise<Reference | Proxy | any>} Attribute value or reference\n   */\n  async readAttributeOnReference(referenceId, attributeNameOrOptions, attributeName) {\n    const allowedOptions = new Set([\"reference\", \"result\", \"proxy\"])\n    /** @type {ReturnOptions | undefined} */\n    let options\n    /** @type {string | number | undefined} */\n    let targetAttributeName = attributeName\n\n    if (this.isPlainObject(attributeNameOrOptions)) {\n      const optionKeys = Object.keys(attributeNameOrOptions)\n      const hasOptionKey = optionKeys.some((key) => allowedOptions.has(key))\n\n      if (hasOptionKey) {\n        const unknownOptions = optionKeys.filter((key) => !allowedOptions.has(key))\n        if (unknownOptions.length === 0) {\n          options = /** @type {ReturnOptions} */ (attributeNameOrOptions)\n        } else {\n          throw new Error(`Unknown readAttributeOnReference options: ${unknownOptions.join(\", \")}`)\n        }\n      } else {\n        targetAttributeName = /** @type {string | number} */ (attributeNameOrOptions)\n      }\n    } else {\n      targetAttributeName = /** @type {string | number} */ (attributeNameOrOptions)\n    }\n\n    if (typeof targetAttributeName === \"undefined\") {\n      throw new Error(\"readAttributeOnReference requires an attribute name\")\n    }\n\n    const returnReference = options?.reference === true\n    const returnResult = options?.result === true\n    const returnProxy = options?.proxy === true\n    const returnFlags = [returnReference, returnResult, returnProxy].filter(Boolean).length\n\n    if (returnFlags > 1) {\n      throw new Error(\"readAttributeOnReference options reference, result, and proxy are mutually exclusive\")\n    }\n\n    const withReference = returnReference || returnProxy\n    const result = await this.sendCommand(\"read_attribute\", {\n      attribute_name: targetAttributeName,\n      reference_id: referenceId,\n      with: withReference ? \"reference\" : \"result\"\n    })\n\n    if (!withReference) return result.response\n\n    const id = result.response\n    const spawnedReference = this.spawnReference(id)\n\n    return returnProxy ? referenceProxy(spawnedReference) : spawnedReference\n  }\n\n  /**\n   * Registers a class by name\n   * @param {string} className Class name to register\n   * @param {any} classInstance Class constructor or instance\n   */\n  registerClass(className, classInstance) {\n    if (className in this._classes) throw new Error(`Class already exists: ${className}`)\n\n    this._classes[className] = classInstance\n  }\n\n  /**\n   * Unregisters a class by name\n   * @param {string} className Class name to remove\n   */\n  unregisterClass(className) {\n    if (!(className in this._classes)) throw new Error(`Class does not exist: ${className}`)\n\n    delete this._classes[className]\n  }\n\n  /**\n   * Gets a registered class by name\n   * @param {string} className Class name to look up\n   * @returns {any} Registered class or undefined\n   */\n  _getRegisteredClass(className) {\n    return this._classes[className]\n  }\n\n  /**\n   * Gets a registered class by name\n   * @param {string} className Class name to look up\n   * @returns {any} Registered class or undefined\n   */\n  getClass(className) {\n    return this._classes[className]\n  }\n\n  /**\n   * Registers an object by name\n   * @param {string} objectName Object name to register\n   * @param {any} objectInstance Object instance\n   */\n  registerObject(objectName, objectInstance) {\n    if (objectName in this._objects) throw new Error(`Object already exists: ${objectName}`)\n\n    this._objects[objectName] = objectInstance\n  }\n\n  /**\n   * Unregisters an object by name\n   * @param {string} objectName Object name to remove\n   */\n  unregisterObject(objectName) {\n    if (!(objectName in this._objects)) throw new Error(`Object does not exist: ${objectName}`)\n\n    delete this._objects[objectName]\n  }\n\n  /**\n   * Gets a registered object by name\n   * @param {string} objectName Object name to look up\n   * @returns {any} Registered object or undefined\n   */\n  _getRegisteredObject(objectName) {\n    return this._objects[objectName]\n  }\n\n  /**\n   * Responds to a command from the backend\n   * @param {number} commandId Command identifier\n   * @param {any} data Response payload\n   */\n  respondToCommand(commandId, data) {\n    this.send({command: \"command_response\", command_id: commandId, data: {command_id: commandId, data}})\n  }\n\n  /**\n   * Sends a command to the backend and returns a promise that resolves with the response\n   * @param {string} command Command name\n   * @param {any} data Command payload\n   * @returns {Promise<any>} Response from the backend\n   */\n  sendCommand(command, data) {\n    return new Promise((resolve, reject) => {\n      const outgoingCommandCount = ++this.outgoingCommandsCount\n      const originError = new Error(`Command '${command}' dispatched`)\n      // Strip the sendCommand frame to highlight the caller site.\n      if (Error.captureStackTrace) Error.captureStackTrace(originError, this.sendCommand)\n      const commandData = {\n        command,\n        command_id: outgoingCommandCount,\n        data\n      }\n\n      this.outgoingCommands[outgoingCommandCount] = {resolve, reject, originStack: originError.stack}\n      logger.log(() => [\"Sending\", commandData])\n      this.send(commandData)\n    })\n  }\n\n  /**\n   * Sends data to the backend\n   * @param {any} data Payload to send\n   */\n  send(data) {\n    this.backend.send(data)\n  }\n\n  /**\n   * Serializes a reference and returns the result directly\n   * @param {number} referenceId Reference identifier\n   * @returns {Promise<any>} Parsed JSON representation\n   */\n  async serializeReference(referenceId) {\n    const json = await this.sendCommand(\"serialize_reference\", {reference_id: referenceId})\n\n    return JSON.parse(json)\n  }\n\n  /**\n   * Spawns a new reference to an object\n   * @param {string} id Reference identifier\n   * @returns {Reference} Reference instance\n   */\n  spawnReference(id) {\n    const reference = new Reference(this, id)\n\n    this.references[id] = reference\n\n    return reference\n  }\n\n  enableServerControl() {\n    this.serverControlEnabled = true\n  }\n}\n"]}