feat: Wasm runtime inside a web worker (#37)

Author: cdata

typescript/common/runtime/package.json

@@ -31,7 +31,8 @@
     "@commontools/data": "^0.0.1",
     "@commontools/io": "^0.0.1",
     "@commontools/module": "^0.0.1",
-    "@commontools/usuba-rt": "^0.0.1"
+    "@commontools/usuba-rt": "^0.0.1",
+    "ses": "^1.5.0"
   },
   "devDependencies": {
     "tslib": "^2.6.2",
@@ -55,6 +56,12 @@
       "command": "tsc --build -f"
     },
     "clean": {
+      "dependencies": [
+        "../../packages/usuba-rt:clean",
+        "../data:clean",
+        "../io:clean",
+        "../module:clean"
+      ],
       "command": "rm -rf ./lib ./.wireit"
     }
   }

typescript/common/runtime/src/dictionary.ts renamed to typescript/common/runtime/src/common/data/dictionary.ts

@@ -2,7 +2,7 @@ import type {
   Dictionary as CommonDictionary,
   Value,
 } from '@commontools/data/interfaces/common-data-types.js';
-import { IO as CommonIO } from './io.js';
+import { IO as CommonIO } from '../../state/io/index.js';
 import { infer } from './infer.js';
 import { Reference } from './reference.js';
 

typescript/common/runtime/src/infer.ts renamed to typescript/common/runtime/src/common/data/infer.ts

@@ -2,7 +2,7 @@ import type {
   Value,
   Reference as CommonReference,
 } from '@commontools/data/interfaces/common-data-types.js';
-import { IO } from './io.js';
+import { IO } from '../../state/io/index.js';
 
 export class Reference implements CommonReference {
   #io;

typescript/common/runtime/src/reference.ts renamed to typescript/common/runtime/src/common/data/reference.ts

@@ -0,0 +1,38 @@
+export type ElementUnion<T extends readonly any[]> = T[number];
+
+export type EventMap<Events> = {
+  [E in keyof Events]: never;
+};
+
+export const assertNever = (value: never): never => {
+  throw new Error(`Unhandled value: ${value}`);
+};
+
+export const downcast = <T>(value: unknown): T => {
+  return value as T;
+};
+
+export const isEvent = <AllEvents, Event extends AllEvents>(
+  event: AllEvents,
+  check: Event
+): event is Event => {
+  return event === check;
+};
+
+export const isError = (candidate: unknown): candidate is { error: string } => {
+  return (
+    candidate != null &&
+    typeof candidate == 'object' &&
+    'error' in candidate &&
+    typeof candidate.error != 'undefined'
+  );
+};
+
+export const throwIfError = (
+  candidate: unknown
+): candidate is { error: string } => {
+  if (isError(candidate)) {
+    throw new Error(candidate.error);
+  }
+  return false;
+};

typescript/common/runtime/src/helpers.ts

@@ -1,56 +1,95 @@
-import { Runtime as UsubaRuntime } from '@commontools/usuba-rt';
-import { wit as commonDataWit } from '@commontools/data';
-import { wit as commonIoWit } from '@commontools/io';
-import { wit as commonModuleWit } from '@commontools/module';
-import type { Value } from '@commontools/data/interfaces/common-data-types.js';
-import type { IO } from './io.js';
-import { Reference } from './reference.js';
-import { Dictionary } from './dictionary.js';
+import { WorkerPool } from './worker/pool.js';
+import { Input } from './state/input.js';
+import { HostToModuleRPC } from './rpc/index.js';
+import { Output } from './state/output.js';
+import { assertNever, throwIfError } from './helpers.js';
+import { HostModuleEventHandler } from './rpc/host.js';
 
 export type { Value } from '@commontools/data/interfaces/common-data-types.js';
 
-export * from './io.js';
-export * from './dictionary.js';
-export * from './reference.js';
-export * from './infer.js';
+export * from './state/io/index.js';
+export * from './state/input.js';
+export * from './state/output.js';
+export * from './state/storage/index.js';
+export * from './state/storage/localstorage.js';
+export * from './common/data/dictionary.js';
+export * from './common/data/reference.js';
+export * from './common/data/infer.js';
 
 export type ContentType = 'text/javascript';
 
-export interface Module {
-  run: () => void;
+export const SES_SANDBOX = 'ses';
+export const WASM_SANDBOX = 'wasm';
+export const CONFIDENTIAL_COMPUTE_SANDBOX = 'confidential-compute';
+
+export type Sandbox =
+  | typeof SES_SANDBOX
+  | typeof WASM_SANDBOX
+  | typeof CONFIDENTIAL_COMPUTE_SANDBOX;
+
+export class Module {
+  #rpc;
+  #input;
+
+  constructor(port: MessagePort, input: Input) {
+    this.#rpc = new HostToModuleRPC(port, this.#handleModuleRPCEvent);
+    this.#input = input;
+  }
+
+  async run(): Promise<void> {
+    throwIfError(await this.#rpc.send('module:run', undefined));
+  }
+
+  output(keys: string[]) {
+    return new Output(this.#rpc, keys);
+  }
+
+  #handleModuleRPCEvent = (async (event, detail) => {
+    switch (event) {
+      case 'host:storage:read':
+        try {
+          return {
+            value: await this.#input.read(detail.key),
+          };
+        } catch (error) {
+          return {
+            error: `${error}`,
+          };
+        }
+    }
+
+    return assertNever(event as never);
+  }) as HostModuleEventHandler;
 }
 
 export class Runtime {
-  #inner = new UsubaRuntime([commonDataWit, commonIoWit]);
+  #workerPool = new WorkerPool();
 
   async eval(
-    contentType: ContentType,
+    id: string,
+    sandbox: Sandbox,
+    contentType: 'text/javascript',
     sourceCode: string,
-    io: IO
+    input: Input
   ): Promise<Module> {
-    const blueprint = await this.#inner.defineModule<{
-      module: { create(): { run: () => void } };
-    }>({
-      contentType,
-      sourceCode,
-      wit: commonModuleWit,
-    });
-
-    const { module } = await blueprint.instantiate({
-      'common:data/types': {
-        Reference,
-        Dictionary,
-      },
-      'common:io/state': {
-        read(name: string) {
-          return new Reference(io, name);
-        },
-        write(name: string, value: Value) {
-          io.write(name, value);
+    const { rpc: runtimeRpc } = await this.#workerPool.get(sandbox);
+    const { port1: moduleTx, port2: moduleRx } = new MessageChannel();
+    const module = new Module(moduleTx, input);
+
+    throwIfError(
+      await runtimeRpc.send(
+        'runtime:eval',
+        {
+          id,
+          contentType,
+          sourceCode,
+          inputKeys: input.keys,
+          port: moduleRx,
         },
-      },
-    });
+        [moduleRx]
+      )
+    );
 
-    return module.create();
+    return module;
   }
 }

typescript/common/runtime/src/index.ts

@@ -0,0 +1,57 @@
+// import { Value } from '@commontools/data/interfaces/common-data-types.js';
+
+import { ElementUnion, EventMap } from '../helpers.js';
+import { Value } from '../index.js';
+import { RPCEventHandler } from './index.js';
+
+/**
+ * Messages sent to the host runtime from a worker
+ */
+
+export const HOST_WORKER_EVENTS = ['rpc:handshake:confirmed'] as const;
+
+export type HostWorkerEvents = ElementUnion<typeof HOST_WORKER_EVENTS>;
+
+export type HostWorkerRequests = EventMap<HostWorkerEvents> & {
+  'rpc:handshake:confirmed': void;
+};
+
+export type HostWorkerResponses = EventMap<HostWorkerEvents> & {
+  'rpc:handshake:confirmed': void;
+};
+
+export type HostWorkerEventHandler = RPCEventHandler<
+  HostWorkerEvents,
+  HostWorkerRequests,
+  HostWorkerResponses
+>;
+
+/**
+ * Messages sent to the host runtime from a module-within-a-worker
+ */
+
+export const HOST_MODULE_EVENTS = ['host:storage:read'] as const;
+
+export type HostModuleEvents = ElementUnion<typeof HOST_MODULE_EVENTS>;
+
+export type HostModuleRequests = EventMap<HostModuleEvents> & {
+  'host:storage:read': {
+    key: string;
+  };
+};
+
+export type HostModuleResponses = EventMap<HostModuleEvents> & {
+  'host:storage:read':
+    | {
+        error: string;
+      }
+    | {
+        value: Value;
+      };
+};
+
+export type HostModuleEventHandler = RPCEventHandler<
+  HostModuleEvents,
+  HostModuleRequests,
+  HostModuleResponses
+>;