@scrypted/server 0.0.134 → 0.0.139

package/src/plugin/runtime/runtime-worker.ts

@@ -0,0 +1,28 @@
+import { RpcMessage, RpcPeer } from "../../rpc";
+import { PluginDebug } from "../plugin-debug";
+import {Readable} from "stream";
+
+export interface RuntimeWorkerOptions {
+    pluginDebug: PluginDebug;
+    env: any;
+}
+
+export interface RuntimeWorker {
+    pid: number;
+    stdout: Readable;
+    stderr: Readable;
+    killed: boolean;
+
+    kill(): void;
+
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: 'close', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+    on(event: 'disconnect', listener: () => void): this;
+    on(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+    once(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+
+    send(message: RpcMessage, reject?: (e: Error) => void): void;
+
+    setupRpcPeer(peer: RpcPeer): void;
+}
+

package/src/plugin/system.ts

@@ -1,6 +1,6 @@
-import { EventListenerOptions, EventDetails, EventListenerRegister, ScryptedDevice, ScryptedInterface, ScryptedInterfaceDescriptors, SystemDeviceState, SystemManager, ScryptedInterfaceProperty, ScryptedDeviceType, Logger } from "@scrypted/sdk/types";
+import { EventListenerOptions, EventDetails, EventListenerRegister, ScryptedDevice, ScryptedInterface, ScryptedInterfaceDescriptors, SystemDeviceState, SystemManager, ScryptedInterfaceProperty, ScryptedDeviceType, Logger } from "@scrypted/types";
 import { PluginAPI } from "./plugin-api";
-import { handleFunctionInvocations, PrimitiveProxyHandler, PROPERTY_PROXY_ONEWAY_METHODS } from '../rpc';
+import {  PrimitiveProxyHandler, RpcPeer } from '../rpc';
 import { EventRegistry } from "../event-registry";
 import { allInterfaceProperties, isValidInterfaceMethod } from "./descriptor";
 
@@ -24,7 +24,7 @@ class DeviceProxyHandler implements PrimitiveProxyHandler<any>, ScryptedDevice {
         if (p === 'id')
             return this.id;
 
-        const handled = handleFunctionInvocations(this, target, p, receiver);
+        const handled = RpcPeer.handleFunctionInvocations(this, target, p, receiver);
         if (handled)
             return handled;
 
@@ -96,10 +96,10 @@ class EventListenerRegisterImpl implements EventListenerRegister {
 
 function makeOneWayCallback<T>(input: T): T {
     const f: any = input;
-    const oneways: string[] = f[PROPERTY_PROXY_ONEWAY_METHODS] || [];
+    const oneways: string[] = f[RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS] || [];
     if (!oneways.includes(null))
         oneways.push(null);
-    f[PROPERTY_PROXY_ONEWAY_METHODS] = oneways;
+    f[RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS] = oneways;
     return input;
 }
 

package/src/rpc.ts

@@ -1,25 +1,21 @@
 import vm from 'vm';
 
-const finalizerIdSymbol = Symbol('rpcFinalizerId');
-
-function getDefaultTransportSafeArgumentTypes() {
-    const jsonSerializable = new Set<string>();
-    jsonSerializable.add(Number.name);
-    jsonSerializable.add(String.name);
-    jsonSerializable.add(Object.name);
-    jsonSerializable.add(Boolean.name);
-    jsonSerializable.add(Array.name);
-    return jsonSerializable;
-}
-
 export function startPeriodicGarbageCollection() {
     if (!global.gc) {
         console.warn('rpc peer garbage collection not available: global.gc is not exposed.');
         return;
     }
-    return setInterval(() => {
-        global?.gc();
-    }, 10000);
+    try {
+        const g = global;
+        if (g.gc) {
+            return setInterval(() => {
+                g.gc!();
+            }, 10000);
+        }
+    }
+    catch (e) {
+
+    }
 }
 
 export interface RpcMessage {
@@ -32,7 +28,7 @@ interface RpcParam extends RpcMessage {
 }
 
 interface RpcApply extends RpcMessage {
-    id: string;
+    id: string | undefined;
     proxyId: string;
     args: any[];
     method: string;
@@ -51,8 +47,8 @@ interface RpcOob extends RpcMessage {
 }
 
 interface RpcRemoteProxyValue {
-    __remote_proxy_id: string;
-    __remote_proxy_finalizer_id: string;
+    __remote_proxy_id: string | undefined;
+    __remote_proxy_finalizer_id: string | undefined;
     __remote_constructor_name: string;
     __remote_proxy_props: any;
     __remote_proxy_oneway_methods: string[];
@@ -65,7 +61,7 @@ interface RpcLocalProxyValue {
 
 interface RpcFinalize extends RpcMessage {
     __local_proxy_id: string;
-    __local_proxy_finalizer_id: string;
+    __local_proxy_finalizer_id: string | undefined;
 }
 
 interface Deferred {
@@ -73,29 +69,6 @@ interface Deferred {
     reject: any;
 }
 
-export function handleFunctionInvocations(thiz: PrimitiveProxyHandler<any>, target: any, p: PropertyKey, receiver: any): any {
-    if (p === 'apply') {
-        return (thisArg: any, args: any[]) => {
-            return thiz.apply(target, thiz, args);
-        }
-    }
-    else if (p === 'call') {
-        return (thisArg: any, ...args: any[]) => {
-            return thiz.apply(target, thiz, args);
-        }
-    }
-    else if (p === 'toString' || p === Symbol.toPrimitive) {
-        return (thisArg: any, ...args: any[]) => {
-            return thiz.toPrimitive();
-        }
-    }
-}
-
-export const PROPERTY_PROXY_ONEWAY_METHODS = '__proxy_oneway_methods';
-export const PROPERTY_JSON_DISABLE_SERIALIZATION = '__json_disable_serialization';
-export const PROPERTY_PROXY_PROPERTIES = '__proxy_props';
-export const PROPERTY_JSON_COPY_SERIALIZE_CHILDREN = '__json_copy_serialize_children';
-
 export interface PrimitiveProxyHandler<T extends object> extends ProxyHandler<T> {
     toPrimitive(): any;
 }
@@ -120,11 +93,11 @@ class RpcProxy implements PrimitiveProxyHandler<any> {
             return this.constructorName;
         if (p === '__proxy_peer')
             return this.peer;
-        if (p === PROPERTY_PROXY_PROPERTIES)
+        if (p === RpcPeer.PROPERTY_PROXY_PROPERTIES)
             return this.proxyProps;
-        if (p === PROPERTY_PROXY_ONEWAY_METHODS)
+        if (p === RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS)
             return this.proxyOneWayMethods;
-        if (p === PROPERTY_JSON_DISABLE_SERIALIZATION || p === PROPERTY_JSON_COPY_SERIALIZE_CHILDREN)
+        if (p === RpcPeer.PROPERTY_JSON_DISABLE_SERIALIZATION || p === RpcPeer.PROPERTY_JSON_COPY_SERIALIZE_CHILDREN)
             return;
         if (p === 'then')
             return;
@@ -132,14 +105,14 @@ class RpcProxy implements PrimitiveProxyHandler<any> {
             return;
         if (this.proxyProps?.[p] !== undefined)
             return this.proxyProps?.[p];
-        const handled = handleFunctionInvocations(this, target, p, receiver);
+        const handled = RpcPeer.handleFunctionInvocations(this, target, p, receiver);
         if (handled)
             return handled;
         return new Proxy(() => p, this);
     }
 
     set(target: any, p: string | symbol, value: any, receiver: any): boolean {
-        if (p === finalizerIdSymbol)
+        if (p === RpcPeer.finalizerIdSymbol)
             this.entry.finalizerId = value;
         return true;
     }
@@ -180,7 +153,7 @@ class RpcProxy implements PrimitiveProxyHandler<any> {
 
 // todo: error constructor adds a "cause" variable in Chrome 93, Node v??
 export class RPCResultError extends Error {
-    constructor(peer: RpcPeer, message: string, public cause?: Error, options?: { name: string, stack: string}) {
+    constructor(peer: RpcPeer, message: string, public cause?: Error, options?: { name: string, stack: string | undefined }) {
         super(`${peer.selfName}:${peer.peerName}: ${message}`);
 
         if (options?.name) {
@@ -225,12 +198,12 @@ export interface RpcSerializer {
 
 interface LocalProxiedEntry {
     id: string;
-    finalizerId: string;
+    finalizerId: string | undefined;
 }
 
 export class RpcPeer {
     idCounter = 1;
-    onOob: (oob: any) => void;
+    onOob?: (oob: any) => void;
     params: { [name: string]: any } = {};
     pendingResults: { [id: string]: Deferred } = {};
     proxyCounter = 1;
@@ -240,7 +213,42 @@ export class RpcPeer {
     finalizers = new FinalizationRegistry(entry => this.finalize(entry as LocalProxiedEntry));
     nameDeserializerMap = new Map<string, RpcSerializer>();
     constructorSerializerMap = new Map<string, string>();
-    transportSafeArgumentTypes = getDefaultTransportSafeArgumentTypes();
+    transportSafeArgumentTypes = RpcPeer.getDefaultTransportSafeArgumentTypes();
+
+    static readonly finalizerIdSymbol = Symbol('rpcFinalizerId');
+
+    static getDefaultTransportSafeArgumentTypes() {
+        const jsonSerializable = new Set<string>();
+        jsonSerializable.add(Number.name);
+        jsonSerializable.add(String.name);
+        jsonSerializable.add(Object.name);
+        jsonSerializable.add(Boolean.name);
+        jsonSerializable.add(Array.name);
+        return jsonSerializable;
+    }
+
+    static handleFunctionInvocations(thiz: PrimitiveProxyHandler<any>, target: any, p: PropertyKey, receiver: any): any {
+        if (p === 'apply') {
+            return (thisArg: any, args: any[]) => {
+                return thiz.apply!(target, thiz, args);
+            }
+        }
+        else if (p === 'call') {
+            return (thisArg: any, ...args: any[]) => {
+                return thiz.apply!(target, thiz, args);
+            }
+        }
+        else if (p === 'toString' || p === Symbol.toPrimitive) {
+            return (thisArg: any, ...args: any[]) => {
+                return thiz.toPrimitive();
+            }
+        }
+    }
+
+    static readonly PROPERTY_PROXY_ONEWAY_METHODS = '__proxy_oneway_methods';
+    static readonly PROPERTY_JSON_DISABLE_SERIALIZATION = '__json_disable_serialization';
+    static readonly PROPERTY_PROXY_PROPERTIES = '__proxy_props';
+    static readonly PROPERTY_JSON_COPY_SERIALIZE_CHILDREN = '__json_copy_serialize_children';
 
     constructor(public selfName: string, public peerName: string, public send: (message: RpcMessage, reject?: (e: Error) => void) => void) {
     }
@@ -327,7 +335,7 @@ export class RpcPeer {
         if (!value)
             return value;
 
-        const copySerializeChildren = value[PROPERTY_JSON_COPY_SERIALIZE_CHILDREN];
+        const copySerializeChildren = value[RpcPeer.PROPERTY_JSON_COPY_SERIALIZE_CHILDREN];
         if (copySerializeChildren) {
             const ret: any = {};
             for (const [key, val] of Object.entries(value)) {
@@ -341,7 +349,7 @@ export class RpcPeer {
             let proxy = this.remoteWeakProxies[__remote_proxy_id]?.deref();
             if (!proxy)
                 proxy = this.newProxy(__remote_proxy_id, __remote_constructor_name, __remote_proxy_props, __remote_proxy_oneway_methods);
-            proxy[finalizerIdSymbol] = __remote_proxy_finalizer_id;
+            proxy[RpcPeer.finalizerIdSymbol] = __remote_proxy_finalizer_id;
             return proxy;
         }
 
@@ -352,15 +360,16 @@ export class RpcPeer {
             return ret;
         }
 
-        if (this.nameDeserializerMap.has(__remote_constructor_name)) {
-            return this.nameDeserializerMap.get(__remote_constructor_name).deserialize(__serialized_value);
+        const deserializer = this.nameDeserializerMap.get(__remote_constructor_name);
+        if (deserializer) {
+            return deserializer.deserialize(__serialized_value);
         }
 
         return value;
     }
 
     serialize(value: any): any {
-        if (value?.[PROPERTY_JSON_COPY_SERIALIZE_CHILDREN] === true) {
+        if (value?.[RpcPeer.PROPERTY_JSON_COPY_SERIALIZE_CHILDREN] === true) {
             const ret: any = {};
             for (const [key, val] of Object.entries(value)) {
                 ret[key] = this.serialize(val);
@@ -368,7 +377,7 @@ export class RpcPeer {
             return ret;
         }
 
-        if (!value || (!value[PROPERTY_JSON_DISABLE_SERIALIZATION] && this.transportSafeArgumentTypes.has(value.constructor?.name))) {
+        if (!value || (!value[RpcPeer.PROPERTY_JSON_DISABLE_SERIALIZATION] && this.transportSafeArgumentTypes.has(value.constructor?.name))) {
             return value;
         }
 
@@ -382,8 +391,8 @@ export class RpcPeer {
                 __remote_proxy_id: proxiedEntry.id,
                 __remote_proxy_finalizer_id,
                 __remote_constructor_name,
-                __remote_proxy_props: value?.[PROPERTY_PROXY_PROPERTIES],
-                __remote_proxy_oneway_methods: value?.[PROPERTY_PROXY_ONEWAY_METHODS],
+                __remote_proxy_props: value?.[RpcPeer.PROPERTY_PROXY_PROPERTIES],
+                __remote_proxy_oneway_methods: value?.[RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS],
             }
             return ret;
         }
@@ -400,13 +409,15 @@ export class RpcPeer {
         if (serializerMapName) {
             __remote_constructor_name = serializerMapName;
             const serializer = this.nameDeserializerMap.get(serializerMapName);
+            if (!serializer)
+                throw new Error('serializer not found for ' + serializerMapName);
             const serialized = serializer.serialize(value);
             const ret: RpcRemoteProxyValue = {
                 __remote_proxy_id: undefined,
                 __remote_proxy_finalizer_id: undefined,
                 __remote_constructor_name,
-                __remote_proxy_props: value?.[PROPERTY_PROXY_PROPERTIES],
-                __remote_proxy_oneway_methods: value?.[PROPERTY_PROXY_ONEWAY_METHODS],
+                __remote_proxy_props: value?.[RpcPeer.PROPERTY_PROXY_PROPERTIES],
+                __remote_proxy_oneway_methods: value?.[RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS],
                 __serialized_value: serialized,
             }
             return ret;
@@ -424,8 +435,8 @@ export class RpcPeer {
             __remote_proxy_id,
             __remote_proxy_finalizer_id: __remote_proxy_id,
             __remote_constructor_name,
-            __remote_proxy_props: value?.[PROPERTY_PROXY_PROPERTIES],
-            __remote_proxy_oneway_methods: value?.[PROPERTY_PROXY_ONEWAY_METHODS],
+            __remote_proxy_props: value?.[RpcPeer.PROPERTY_PROXY_PROPERTIES],
+            __remote_proxy_oneway_methods: value?.[RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS],
         }
 
         return ret;
@@ -462,7 +473,7 @@ export class RpcPeer {
                     const rpcApply = message as RpcApply;
                     const result: RpcResult = {
                         type: 'result',
-                        id: rpcApply.id,
+                        id: rpcApply.id || '',
                     };
 
                     try {
@@ -504,7 +515,7 @@ export class RpcPeer {
                     if (!deferred)
                         throw new Error(`unknown result ${rpcResult.id}`);
                     if (rpcResult.message || rpcResult.stack) {
-                        const e = new RPCResultError(this, rpcResult.message, undefined, {
+                        const e = new RPCResultError(this, rpcResult.message || 'no message', undefined, {
                             name: rpcResult.result,
                             stack: rpcResult.stack,
                         });
@@ -542,4 +553,19 @@ export class RpcPeer {
             return;
         }
     }
-}
+}
+
+export function getEvalSource() {
+    return `
+    (() => {
+        ${RpcProxy}
+
+        ${RpcPeer}
+    
+        return {
+            RpcPeer,
+            RpcProxy,
+        };
+    })();
+    `;
+}

package/src/runtime.ts

@@ -1,6 +1,6 @@
 import { Level } from './level';
 import { PluginHost } from './plugin/plugin-host';
-import { ScryptedNativeId, Device, EngineIOHandler, HttpRequest, HttpRequestHandler, OauthClient, PushHandler, ScryptedDevice, ScryptedInterface, ScryptedInterfaceProperty } from '@scrypted/sdk/types';
+import { ScryptedNativeId, Device, EngineIOHandler, HttpRequest, HttpRequestHandler, OauthClient, PushHandler, ScryptedDevice, ScryptedInterface, ScryptedInterfaceProperty } from '@scrypted/types';
 import { PluginDeviceProxyHandler } from './plugin/plugin-device';
 import { Plugin, PluginDevice, ScryptedAlert } from './db-types';
 import { getState, ScryptedStateManager, setState } from './state';
@@ -495,7 +495,8 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
             if (pluginHost.killed)
                 return;
             pluginHost.kill();
-            console.error('plugin unexpectedly exited, restarting in 1 minute', pluginHost.pluginId);
+            const timeout = 60000;
+            console.error(`plugin unexpectedly exited, restarting in ${timeout}ms`, pluginHost.pluginId);
             setTimeout(async () => {
                 const existing = this.plugins[pluginHost.pluginId];
                 if (existing !== pluginHost) {
@@ -515,7 +516,7 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
                 catch (e) {
                     console.error('error restarting plugin', plugin._id, e);
                 }
-            }, 60000);
+            }, timeout);
         });
     }
 

package/src/scrypted-main.ts

@@ -9,16 +9,24 @@ if (!semver.gte(process.version, '16.0.0')) {
 
 startPeriodicGarbageCollection();
 
-process.on('unhandledRejection', error => {
-    if (error?.constructor !== RPCResultError && error?.constructor !== PluginError) {
-        throw error;
-    }
-    console.warn('unhandled rejection of RPC Result', error);
-});
+if (process.argv[2] === 'child' || process.argv[2] === 'child-thread') {
+    process.on('uncaughtException', e => {
+        console.error('uncaughtException', e);
+    });
+    process.on('unhandledRejection', e => {
+        console.error('unhandledRejection', e);
+    });
 
-if (process.argv[2] === 'child') {
     require('./scrypted-plugin-main');
 }
 else {
+    process.on('unhandledRejection', error => {
+        if (error?.constructor !== RPCResultError && error?.constructor !== PluginError) {
+            console.error('wtf', error);
+            throw error;
+        }
+        console.warn('unhandled rejection of RPC Result', error);
+    });
+
     require('./scrypted-server-main');
 }

package/src/scrypted-plugin-main.ts

@@ -1,6 +1,32 @@
-import { startPluginRemote, startSharedPluginRemote } from "./plugin/plugin-remote-worker";
+import { startPluginRemote } from "./plugin/plugin-remote-worker";
+import { RpcMessage } from "./rpc";
+import worker_threads from "worker_threads";
+import v8 from 'v8';
 
-if (process.argv[3] !== '@scrypted/shared')
-    startPluginRemote(process.argv[3]);
-else
-    startSharedPluginRemote();
+if (process.argv[2] === 'child-thread') {
+    const peer = startPluginRemote(process.argv[3], (message, reject) => {
+        try {
+            worker_threads.parentPort.postMessage(v8.serialize(message));
+        }
+        catch (e) {
+            reject?.(e);
+        }
+    });
+    peer.transportSafeArgumentTypes.add(Buffer.name);
+    worker_threads.parentPort.on('message', message => peer.handleMessage(v8.deserialize(message)));
+}
+else {
+    const peer = startPluginRemote(process.argv[3], (message, reject) => process.send(message, undefined, {
+        swallowErrors: !reject,
+    }, e => {
+        if (e)
+            reject?.(e);
+    }));
+
+    peer.transportSafeArgumentTypes.add(Buffer.name);
+    process.on('message', message=> peer.handleMessage(message as RpcMessage));
+    process.on('disconnect', () => {
+        console.error('peer host disconnected, exiting.');
+        process.exit(1);
+    });
+}

package/src/scrypted-server-main.ts

@@ -378,7 +378,7 @@ async function start() {
             const hash = crypto.createHash('sha256');
             hash.update(salted);
             const sha = hash.digest().toString('hex');
-            if (user.passwordHash !== sha) {
+            if (user.passwordHash !== sha && user.token !== password) {
                 res.send({
                     error: 'Incorrect password.',
                     hasLogin,

package/src/services/plugin.ts

@@ -1,4 +1,4 @@
-import { ScryptedInterfaceProperty, ScryptedNativeId } from "@scrypted/sdk/types";
+import { ScryptedInterfaceProperty, ScryptedNativeId } from "@scrypted/types";
 import { ScryptedRuntime } from "../runtime";
 import { Plugin } from '../db-types';
 import { getState } from "../state";

package/src/state.ts

@@ -1,5 +1,5 @@
 import { ScryptedRuntime } from "./runtime";
-import { ScryptedNativeId, EventDetails, EventListenerOptions, EventListenerRegister, Refresh, ScryptedInterface, ScryptedInterfaceProperty, SystemDeviceState } from "@scrypted/sdk/types";
+import { ScryptedNativeId, EventDetails, EventListenerOptions, EventListenerRegister, Refresh, ScryptedInterface, ScryptedInterfaceProperty, SystemDeviceState } from "@scrypted/types";
 import { RefreshSymbol } from "./plugin/plugin-device";
 import throttle from 'lodash/throttle';
 import { sleep } from "./sleep";

package/src/threading.ts

@@ -0,0 +1,108 @@
+import worker_threads from 'worker_threads';
+import { getEvalSource, RpcPeer } from './rpc';
+import v8 from 'v8';
+
+export async function newThread<T>(thread: () => Promise<T>): Promise<T>;
+export async function newThread<V, T>(params: V, thread: (params: V) => Promise<T>): Promise<T>;
+
+export async function newThread<T>(...args: any[]): Promise<T> {
+    let thread: () => Promise<T> = args[1];
+    let params: { [key: string]: any } = {};
+    if (thread) {
+        params = args[0];
+    }
+    else {
+        thread = args[0];
+    }
+
+    const m = (customRequire: string, RpcPeer: any) => {
+        if (customRequire) {
+            const g = global as any;
+            g[customRequire] = g.require;
+        }
+        const v8 = global.require('v8');
+        const worker_threads = global.require('worker_threads');
+        const vm = global.require('vm');
+        const mainPeer = new RpcPeer('thread', 'main', (message: any, reject: any) => {
+            try {
+                worker_threads.parentPort.postMessage(v8.serialize(message));
+            }
+            catch (e) {
+                reject?.(e);
+            }
+        });
+        worker_threads.parentPort.on('message', (message: any) => mainPeer.handleMessage(v8.deserialize(message)));
+
+        mainPeer.params.eval = async (script: string, paramNames: string[], ...paramValues: any[]) => {
+            const f = vm.compileFunction(`return (${script})`, paramNames, {
+                filename: 'script.js',
+            });
+            const params: any = {};
+            for (let i = 0; i < paramNames.length; i++) {
+                params[paramNames[i]] = paramValues[i];
+            }
+            const c = await f(...paramValues);
+            return await c(params);
+        }
+    };
+    const rpcSource = getEvalSource();
+
+    let customRequire = params.customRequire || '';
+
+    const workerSource = `
+    const {RpcPeer} = ${rpcSource};
+
+    (${m})("${customRequire}", RpcPeer)`;
+
+    const worker = new worker_threads.Worker(workerSource, {
+        eval: true,
+    });
+
+    const threadPeer = new RpcPeer('main', 'thread', (message, reject) => {
+        try {
+            worker.postMessage(v8.serialize(message));
+        }
+        catch (e) {
+            reject?.(e);
+        }
+    });
+    worker.on('message', (message: any) => threadPeer.handleMessage(v8.deserialize(message)));
+
+    const e = await threadPeer.getParam('eval');
+    const paramNames = Object.keys(params);
+    const paramValues = Object.values(params);
+    try {
+        return await e(thread.toString(), paramNames, ...paramValues);
+    }
+    finally {
+        worker.terminate();
+    }
+}
+
+async function test() {
+    const foo = 5;
+    const bar = 6;
+
+    console.log(await newThread({
+        foo, bar,
+    }, async () => {
+        return foo + bar;
+    }));
+
+
+    console.log(await newThread({
+        foo, bar,
+    }, async ({foo,bar}) => {
+        return foo + bar;
+    }));
+
+    const sayHelloInMainThread = () => console.log('hello! main thread:', worker_threads.isMainThread);
+    await newThread({
+        sayHelloInMainThread,
+    }, async () => {
+        sayHelloInMainThread();
+    })
+}
+
+// if (true)
+//     test();