scoundrel-remote-eval 1.0.8 → 1.0.10

package/build/logger.js

@@ -0,0 +1,64 @@
+// @ts-check
+export default class Logger {
+    /**
+     * Creates a new Logger instance
+     *
+     * @param {string} scopeName The name of the scope for the logger
+     */
+    constructor(scopeName) {
+        this.debug = false;
+        this.scopeName = scopeName;
+    }
+    /**
+     * Enables or disables debug logging
+     *
+     * @param {boolean} newValue
+     */
+    setDebug(newValue) {
+        this.debug = newValue;
+    }
+    /**
+     * Logs an error message to the console if debug is enabled
+     *
+     * @param  {...any} args
+     */
+    error(...args) {
+        return this._sendToConsole("error", ...args);
+    }
+    /**
+     * Logs a message to the console if debug is enabled
+     * @param  {...any} args
+     */
+    log(...args) {
+        return this._sendToConsole("log", ...args);
+    }
+    /**
+     * Logs a warning message to the console if debug is enabled
+     * @param  {...any} args
+     */
+    warn(...args) {
+        return this._sendToConsole("warn", ...args);
+    }
+    /**
+     * Sends the log message to the console
+     * @param {string} logType
+     * @param  {...any} args
+     */
+    _sendToConsole(logType, ...args) {
+        if (!this.debug) {
+            return;
+        }
+        if (args.length == 1 && typeof args[0] == "function") {
+            const callbackArgs = args[0]();
+            if (Array.isArray(callbackArgs)) {
+                console[logType](this.scopeName, ...callbackArgs);
+            }
+            else {
+                console[logType](this.scopeName, callbackArgs);
+            }
+        }
+        else {
+            console[logType](this.scopeName, ...args);
+        }
+    }
+}

package/build/python-web-socket-runner.d.ts

@@ -0,0 +1,27 @@
+export default class PythonWebSocketRunner {
+    /** @type {Error | null} */
+    waitForPidRejectError: Error | null;
+    /** @type {((value: any) => void) | null} */
+    waitForPidResolve: ((value: any) => void) | null;
+    /** @type {((value: any) => void) | null} */
+    waitForPidReject: ((value: any) => void) | null;
+    runAndWaitForPid(): Promise<any>;
+    run(): Promise<void>;
+    onProcessExit: () => void;
+    /**
+     * @param {number} code
+     * @param {string} signal
+     */
+    onChildExit: (code: number, signal: string) => void;
+    /**
+     * @param {string | Buffer} data
+     */
+    onChildStderr: (data: string | Buffer) => void;
+    /**
+     * @param {string | Buffer} data
+     */
+    onChildStdout: (data: string | Buffer) => void;
+    pid: string;
+    close(): void;
+}
+//# sourceMappingURL=python-web-socket-runner.d.ts.map

package/build/python-web-socket-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-web-socket-runner.d.ts","sourceRoot":"","sources":["../src/python-web-socket-runner.js"],"names":[],"mappings":"AAUA;IACE,2BAA2B;IAC3B,uBADW,KAAK,GAAG,IAAI,CACK;IAE5B,4CAA4C;IAC5C,mBADW,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG,IAAI,CAChB;IAExB,4CAA4C;IAC5C,kBADW,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG,IAAI,CACjB;IAMvB,iCAMC;IAED,qBAQC;IAED,0BAKC;IAED;;;OAGG;IACH,cAAe,MAHJ,MAGQ,EAAE,QAFV,MAEgB,UAkB1B;IAED;;OAEG;IACH,gBAAiB,MAFN,MAAM,GAAG,MAEC,UAMpB;IAED;;OAEG;IACH,gBAAiB,MAFN,MAAM,GAAG,MAEC,UAqBpB;IAfG,YAAmB;IAiBvB,cAIC;CACF"}

package/build/python-web-socket-runner.js

@@ -0,0 +1,94 @@
+// @ts-check
+import { exec, spawn } from "child_process";
+import Logger from "./logger.js";
+import { realpath } from "fs/promises";
+const logger = new Logger("Scoundrel PythonWebSocketRunner");
+// logger.setDebug(true)
+export default class PythonWebSocketRunner {
+    constructor() {
+        /** @type {Error | null} */
+        this.waitForPidRejectError = null;
+        /** @type {((value: any) => void) | null} */
+        this.waitForPidResolve = null;
+        /** @type {((value: any) => void) | null} */
+        this.waitForPidReject = null;
+        this.onProcessExit = () => {
+            if (this.pid) {
+                this.close();
+                logger.log(() => `onProcessExit: Killing Python process with PID ${this.pid}`);
+            }
+        };
+        /**
+         * @param {number} code
+         * @param {string} signal
+         */
+        this.onChildExit = (code, signal) => {
+            logger.log(() => `Child process exited with code ${code} and signal ${signal}`);
+            if (this.waitForPidRejectError) {
+                if (!this.waitForPidReject) {
+                    throw new Error("waitForPidReject is undefined while waitForPidRejectError is set");
+                }
+                this.waitForPidReject(this.waitForPidRejectError);
+                this.waitForPidResolve = null;
+                this.waitForPidReject = null;
+                this.waitForPidRejectError = null;
+            }
+            else if (this.waitForPidReject) {
+                this.waitForPidReject(new Error(`Python process exited before PID was received (code: ${code}, signal: ${signal})`));
+                this.waitForPidResolve = null;
+                this.waitForPidReject = null;
+                this.waitForPidRejectError = null;
+            }
+        };
+        /**
+         * @param {string | Buffer} data
+         */
+        this.onChildStderr = (data) => {
+            logger.error(() => `stderr: ${data}`);
+            if (this.waitForPidReject) {
+                this.waitForPidRejectError = new Error(`Python process stderr before PID was received: ${data}`);
+            }
+        };
+        /**
+         * @param {string | Buffer} data
+         */
+        this.onChildStdout = (data) => {
+            logger.log(() => `stdout: ${data}`);
+            const match = (`${data}`).match(/^Started with PID (\d+) on (.+):(.+)\n$/);
+            if (match) {
+                this.pid = match[1];
+                logger.log(() => `Registered PID ${this.pid}`);
+                if (this.waitForPidResolve) {
+                    if (!this.waitForPidResolve) {
+                        throw new Error("waitForPidResolve is undefined while waitForPidRejectError is set");
+                    }
+                    this.waitForPidResolve(null);
+                    this.waitForPidResolve = null;
+                    this.waitForPidReject = null;
+                    this.waitForPidRejectError = null;
+                }
+            }
+        };
+        process.on("exit", this.onProcessExit);
+    }
+    runAndWaitForPid() {
+        return new Promise((resolve, reject) => {
+            this.waitForPidResolve = resolve;
+            this.waitForPidReject = reject;
+            this.run();
+        });
+    }
+    async run() {
+        const filePath = `${process.cwd()}/../python/server/web-socket.py`;
+        const fileRealPath = await realpath(filePath);
+        const child = spawn("python3", [fileRealPath]);
+        child.on("exit", this.onChildExit);
+        child.stdout.on("data", this.onChildStdout);
+        child.stderr.on("data", this.onChildStderr);
+    }
+    close() {
+        if (this.pid) {
+            exec(`kill ${this.pid}`);
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+export default class WebSocketClient {
+    /**
+     * Creates a new WebSocketClient
+     * @param {import("ws").WebSocket} ws The WebSocket instance
+     */
+    constructor(ws: any);
+    ws: any;
+    /**
+     * @param {(data: any) => void} callback
+     */
+    onCommand(callback: (data: any) => void): void;
+    onCommandCallback: (data: any) => void;
+    /**
+     * @param {Error} error
+     */
+    onError: (error: Error) => void;
+    /**
+     * @param {string} rawData
+     */
+    onMessage: (rawData: string) => void;
+    /**
+     * @param {any} data
+     */
+    send(data: any): Promise<void>;
+}
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/server/connections/web-socket/client.js"],"names":[],"mappings":"AAEA;IACE;;;OAGG;IACH,qBAKC;IAJC,QAAY;IAMd;;OAEG;IACH,oBAFW,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,QAI7B;IADC,0BAHgB,GAAG,KAAK,IAAI,CAGK;IAGnC;;OAEG;IACH,UAAW,OAFA,KAEK,UAEf;IAED;;OAEG;IACH,YAAa,SAFF,MAES,UAMnB;IAED;;OAEG;IACH,WAFW,GAAG,iBAIb;CACF"}

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

@@ -0,0 +1,39 @@
+// @ts-check
+export default class WebSocketClient {
+    /**
+     * Creates a new WebSocketClient
+     * @param {import("ws").WebSocket} ws The WebSocket instance
+     */
+    constructor(ws) {
+        /**
+         * @param {Error} error
+         */
+        this.onError = (error) => {
+            console.error("WebSocketClient error", error);
+        };
+        /**
+         * @param {string} rawData
+         */
+        this.onMessage = (rawData) => {
+            const data = JSON.parse(rawData);
+            if (!this.onCommandCallback)
+                throw new Error("Command callback hasn't been set");
+            this.onCommandCallback(data);
+        };
+        this.ws = ws;
+        ws.on("error", this.onError);
+        ws.on("message", this.onMessage);
+    }
+    /**
+     * @param {(data: any) => void} callback
+     */
+    onCommand(callback) {
+        this.onCommandCallback = callback;
+    }
+    /**
+     * @param {any} data
+     */
+    async send(data) {
+        await this.ws.send(JSON.stringify(data));
+    }
+}

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

@@ -0,0 +1,19 @@
+export default class WebSocket {
+    /**
+     * Creates a new WebSocket connection handler
+     * @param {import("ws").Server} webSocketServer The WebSocket server instance
+     */
+    constructor(webSocketServer: any);
+    wss: any;
+    close(): void;
+    /**
+     * @param {import("ws").WebSocket} ws
+     */
+    onConnection: (ws: any) => void;
+    /**
+     * @param {(client: import("./client.js").default) => void} callback
+     */
+    onNewClient(callback: (client: import("./client.js").default) => void): void;
+    onNewClientCallback: (client: import("./client.js").default) => void;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/server/connections/web-socket/index.js"],"names":[],"mappings":"AAIA;IACE;;;OAGG;IACH,kCAGC;IAFC,SAA0B;IAI5B,cAA4B;IAE5B;;OAEG;IACH,eAAgB,OAAE,UAIjB;IAED;;OAEG;IACH,sBAFW,CAAC,MAAM,EAAE,OAAO,aAAa,EAAE,OAAO,KAAK,IAAI,QAMzD;IADC,8BALkB,OAAO,aAAa,EAAE,OAAO,KAAK,IAAI,CAKrB;CAEtC"}

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

@@ -0,0 +1,29 @@
+// @ts-check
+import WebSocketClient from "./client.js";
+export default class WebSocket {
+    /**
+     * Creates a new WebSocket connection handler
+     * @param {import("ws").Server} webSocketServer The WebSocket server instance
+     */
+    constructor(webSocketServer) {
+        /**
+         * @param {import("ws").WebSocket} ws
+         */
+        this.onConnection = (ws) => {
+            if (!this.onNewClientCallback)
+                throw new Error("'onNewClient' hasn't been called");
+            this.onNewClientCallback(new WebSocketClient(ws));
+        };
+        this.wss = webSocketServer;
+        this.wss.on("connection", this.onConnection);
+    }
+    close() { this.wss.close(); }
+    /**
+     * @param {(client: import("./client.js").default) => void} callback
+     */
+    onNewClient(callback) {
+        if (!callback)
+            throw new Error("No callback was given");
+        this.onNewClientCallback = callback;
+    }
+}

package/build/server/index.d.ts

@@ -0,0 +1,27 @@
+export default class ScoundrelServer {
+    /**
+     * Creates a new Scoundrel server
+     * @param {import("./connections/web-socket/index.js").default} backend The backend connection handler
+     */
+    constructor(backend: import("./connections/web-socket/index.js").default);
+    backend: import("./connections/web-socket/index.js").default;
+    /** @type {Client[]} */
+    clients: Client[];
+    events: EventEmitter<any>;
+    /** @type {SingleEventEmitter<(client: Client) => void>} */
+    onNewClientEventEmitter: SingleEventEmitter<(client: Client) => void>;
+    onNewClient: (listener: (client: Client) => void) => void;
+    /** @returns {void} */
+    close(): void;
+    /** @returns {Client[]} */
+    getClients(): Client[];
+    /**
+     * @param {import("./connections/web-socket/client.js").default} clientBackend
+     * @returns {void}
+     */
+    onNewClientFromBackend: (clientBackend: import("./connections/web-socket/client.js").default) => void;
+}
+import Client from "../client/index.js";
+import EventEmitter from "events";
+import SingleEventEmitter from "../utils/single-event-emitter.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.js"],"names":[],"mappings":"AAMA;IACE;;;OAGG;IACH,qBAFW,OAAO,mCAAmC,EAAE,OAAO,EAc7D;IAXC,6DAAsB;IAGtB,uBAAuB;IACvB,SADW,MAAM,EAAE,CACF;IAEjB,0BAAgC;IAEhC,2DAA2D;IAC3D,yBADW,kBAAkB,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC,CACA;IACvD,iCAFuC,MAAM,KAAK,IAAI,UAEK;IAG7D,sBAAsB;IACtB,SADc,IAAI,CACc;IAEhC,0BAA0B;IAC1B,cADc,MAAM,EAAE,CACc;IAEpC;;;OAGG;IACH,yBAA0B,eAHf,OAAO,oCAAoC,EAAE,OAGjB,KAF1B,IAAI,CAShB;CACF;mBAzCkB,oBAAoB;yBACd,QAAQ;+BACF,kCAAkC"}

package/build/server/index.js

@@ -0,0 +1,34 @@
+// @ts-check
+import Client from "../client/index.js";
+import EventEmitter from "events";
+import SingleEventEmitter from "../utils/single-event-emitter.js";
+export default class ScoundrelServer {
+    /**
+     * Creates a new Scoundrel server
+     * @param {import("./connections/web-socket/index.js").default} backend The backend connection handler
+     */
+    constructor(backend) {
+        /**
+         * @param {import("./connections/web-socket/client.js").default} clientBackend
+         * @returns {void}
+         */
+        this.onNewClientFromBackend = (clientBackend) => {
+            const client = new Client(clientBackend, { enableServerControl: true });
+            this.clients.push(client);
+            this.events.emit("newClient", client);
+            this.onNewClientEventEmitter.emit([client]);
+        };
+        this.backend = backend;
+        this.backend.onNewClient(this.onNewClientFromBackend);
+        /** @type {Client[]} */
+        this.clients = [];
+        this.events = new EventEmitter();
+        /** @type {SingleEventEmitter<(client: Client) => void>} */
+        this.onNewClientEventEmitter = new SingleEventEmitter();
+        this.onNewClient = this.onNewClientEventEmitter.connector();
+    }
+    /** @returns {void} */
+    close() { this.backend.close(); }
+    /** @returns {Client[]} */
+    getClients() { return this.clients; }
+}

package/build/utils/single-event-emitter.d.ts

@@ -0,0 +1,46 @@
+/**
+ * SingleEventEmitter: one listener at a time, strongly typed via JSDoc.
+ *
+ * @template {(...args: any[]) => any} Listener
+ */
+export default class SingleEventEmitter<Listener extends (...args: any[]) => any> {
+    /**
+     * @param {{ strict?: boolean }=} options
+     *  - strict (default true): throw if a listener is already connected
+     */
+    constructor(options?: {
+        strict?: boolean;
+    } | undefined);
+    /**
+     * Connect a listener (type-checked).
+     * @param {Listener} listener
+     * @returns {void}
+     */
+    connect(listener: Listener): void;
+    /**
+     * Disconnect only if the same listener is currently connected.
+     * @param {Listener} listener
+     * @returns {void}
+     */
+    disconnect(listener: Listener): void;
+    /** @returns {void} */
+    clear(): void;
+    /** @returns {boolean} */
+    hasListener(): boolean;
+    /**
+     * Emit the event to the connected listener (if any).
+     * Arguments are type-checked against Listener parameters.
+     * @param {...Parameters<Listener>} args
+     * @returns {boolean} true if a listener was called
+     */
+    emit(...args: Parameters<Listener>[]): boolean;
+    /**
+     * Create a "connect method" you can expose as `onNewClient` etc.
+     * The returned function is type-checked as (listener: Listener) => void.
+     *
+     * @returns {(listener: Listener) => void}
+     */
+    connector(): (listener: Listener) => void;
+    #private;
+}
+//# sourceMappingURL=single-event-emitter.d.ts.map

package/build/utils/single-event-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-event-emitter.d.ts","sourceRoot":"","sources":["../../src/utils/single-event-emitter.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wCAFuC,QAAQ,SAAlC,CAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAI;IASpC;;;OAGG;IACH,sBAHW;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,YAAC,EAK/B;IAED;;;;OAIG;IACH,kBAHW,QAAQ,GACN,IAAI,CAOhB;IAED;;;;OAIG;IACH,qBAHW,QAAQ,GACN,IAAI,CAIhB;IAED,sBAAsB;IACtB,SADc,IAAI,CAGjB;IAED,yBAAyB;IACzB,eADc,OAAO,CAGpB;IAED;;;;;OAKG;IACH,cAHc,UAAU,CAAC,QAAQ,CAAC,EAAA,GACrB,OAAO,CAOnB;IAED;;;;;OAKG;IACH,aAFa,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAKxC;;CACF"}

package/build/utils/single-event-emitter.js

@@ -0,0 +1,86 @@
+// @ts-check
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SingleEventEmitter_listener, _SingleEventEmitter_strict;
+/**
+ * SingleEventEmitter: one listener at a time, strongly typed via JSDoc.
+ *
+ * @template {(...args: any[]) => any} Listener
+ */
+class SingleEventEmitter {
+    /**
+     * @param {{ strict?: boolean }=} options
+     *  - strict (default true): throw if a listener is already connected
+     */
+    constructor(options) {
+        /** @type {Listener | null} */
+        _SingleEventEmitter_listener.set(this, null
+        /** @type {boolean} */
+        );
+        /** @type {boolean} */
+        _SingleEventEmitter_strict.set(this, void 0);
+        __classPrivateFieldSet(this, _SingleEventEmitter_strict, options?.strict ?? true, "f");
+    }
+    /**
+     * Connect a listener (type-checked).
+     * @param {Listener} listener
+     * @returns {void}
+     */
+    connect(listener) {
+        if (__classPrivateFieldGet(this, _SingleEventEmitter_listener, "f") && __classPrivateFieldGet(this, _SingleEventEmitter_strict, "f")) {
+            throw new Error("SingleEventEmitter already has a listener connected");
+        }
+        __classPrivateFieldSet(this, _SingleEventEmitter_listener, listener, "f");
+    }
+    /**
+     * Disconnect only if the same listener is currently connected.
+     * @param {Listener} listener
+     * @returns {void}
+     */
+    disconnect(listener) {
+        if (__classPrivateFieldGet(this, _SingleEventEmitter_listener, "f") === listener)
+            __classPrivateFieldSet(this, _SingleEventEmitter_listener, null, "f");
+    }
+    /** @returns {void} */
+    clear() {
+        __classPrivateFieldSet(this, _SingleEventEmitter_listener, null, "f");
+    }
+    /** @returns {boolean} */
+    hasListener() {
+        return __classPrivateFieldGet(this, _SingleEventEmitter_listener, "f") !== null;
+    }
+    /**
+     * Emit the event to the connected listener (if any).
+     * Arguments are type-checked against Listener parameters.
+     * @param {...Parameters<Listener>} args
+     * @returns {boolean} true if a listener was called
+     */
+    emit(...args) {
+        const fn = __classPrivateFieldGet(this, _SingleEventEmitter_listener, "f");
+        if (!fn)
+            return false;
+        fn(...args);
+        return true;
+    }
+    /**
+     * Create a "connect method" you can expose as `onNewClient` etc.
+     * The returned function is type-checked as (listener: Listener) => void.
+     *
+     * @returns {(listener: Listener) => void}
+     */
+    connector() {
+        // bind() keeps `this`, and the return type is enforced by the JSDoc above
+        return this.connect.bind(this);
+    }
+}
+_SingleEventEmitter_listener = new WeakMap(), _SingleEventEmitter_strict = new WeakMap();
+export default SingleEventEmitter;

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "scoundrel-remote-eval",
   "type": "module",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "",
-  "main": "src/index.js",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "files": ["build/**"],
   "scripts": {
+    "all-checks": "npm run typecheck && npm run lint && npm run test",
+    "build": "rm -rf build && tsc",
     "lint": "eslint",
+    "prepublishOnly": "npm run build",
     "typecheck": "tsc --noEmit",
-    "test": "jasmine"
+    "test": "jasmine",
+    "watch": "tsc -w"
   },
   "repository": {
     "type": "git",

package/eslint.config.js

@@ -1,18 +0,0 @@
-import js from "@eslint/js"
-import globals from "globals"
-import {defineConfig} from "eslint/config"
-
-export default defineConfig([
-  {
-    files: ["**/*.{js,mjs,cjs}"],
-    plugins: {js},
-    extends: ["js/recommended"],
-    languageOptions: {
-      globals: {
-        ...globals.browser,
-        ...globals.node,
-        ...globals.jasmine
-      }
-    }
-  }
-])

package/spec/reference-with-proxy-spec.js

@@ -1,101 +0,0 @@
-// @ts-check
-
-import Client from "../src/client/index.js"
-import ClientWebSocket from "../src/client/connections/web-socket/index.js"
-import referenceWithProxy from "../src/client/reference-proxy.js"
-import Server from "../src/server/index.js"
-import ServerWebSocket from "../src/server/connections/web-socket/index.js"
-import {WebSocket, WebSocketServer} from "ws"
-
-const shared = {}
-
-describe("referenceWithProxy", () => {
-  beforeEach(async () => {
-    shared.wss = new WebSocketServer({port: 8080})
-    shared.serverWebSocket = new ServerWebSocket(shared.wss)
-    shared.server = new Server(shared.serverWebSocket)
-
-    shared.ws = new WebSocket("http://localhost:8080")
-    shared.clientWebSocket = new ClientWebSocket(shared.ws)
-
-    await shared.clientWebSocket.waitForOpened()
-
-    shared.client = new Client(shared.clientWebSocket)
-
-    shared.serverClient = shared.server.getClients()[0]
-
-    if (!shared.serverClient) {
-      throw new Error("No client connected to server")
-    }
-  })
-
-  afterEach(async () => {
-    await shared.client.close()
-    await shared.server.close()
-  })
-
-  it("creates a reference with a proxy", async () => {
-    const stringObjectReference = await shared.client.newObjectWithReference("Array")
-    const stringObject = referenceWithProxy(stringObjectReference)
-
-    // @ts-ignore
-    await stringObject.push("test1")
-
-    // @ts-ignore
-    await stringObject.push("test2")
-
-    // @ts-ignore
-    const result = await stringObject.__serialize()
-
-    expect(result).toEqual(["test1", "test2"])
-  })
-
-  it("reads attributes from a reference", async () => {
-    const testArray = await shared.client.newObjectWithReference("Array")
-
-    await testArray.callMethod("push", "test1")
-    await testArray.callMethod("push", "test2")
-
-    const result = await testArray.serialize()
-
-    expect(result).toEqual(["test1", "test2"])
-
-    const firstValue = await testArray.readAttribute(0)
-    const secondValue = await testArray.readAttribute(1)
-
-    expect(firstValue).toEqual("test1")
-    expect(secondValue).toEqual("test2")
-  })
-
-  it("calls methods", async () => {
-    const stringObjectReference = await shared.client.newObjectWithReference("Array")
-    const stringObject = referenceWithProxy(stringObjectReference)
-
-    // @ts-ignore
-    await stringObject.push("test1")
-
-    // @ts-ignore
-    await stringObject.push("test2")
-
-    // @ts-ignore
-    const result = await stringObject.__serialize()
-
-    expect(result).toEqual(["test1", "test2"])
-  })
-
-  it("calls methods on the client from the server", async () => {
-    const stringObjectReference = await shared.serverClient.newObjectWithReference("Array")
-    const stringObject = referenceWithProxy(stringObjectReference)
-
-    // @ts-ignore
-    await stringObject.push("test1")
-
-    // @ts-ignore
-    await stringObject.push("test2")
-
-    // @ts-ignore
-    const result = await stringObject.__serialize()
-
-    expect(result).toEqual(["test1", "test2"])
-  })
-})