@fhevm/sdk 0.0.1 → 1.0.0-alpha.1

package/core/base/errors/InvalidTypeError.ts

@@ -0,0 +1,87 @@
+import type { ErrorMetadataParams } from './ErrorBase.js';
+import { ErrorBase } from './ErrorBase.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type ExpectedTypeParams = {
+  expectedType: string | string[];
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type InvalidTypeErrorType = InvalidTypeError & {
+  name: 'InvalidTypeError';
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// InvalidTypeError
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Error thrown when a value does not match its expected type.
+ *
+ * @example
+ * ```ts
+ * // With subject and actual type
+ * throw new InvalidTypeError({
+ *   subject: 'first argument of encrypt()',
+ *   expectedType: 'Uint8Array',
+ *   type: typeof value,
+ * });
+ * // => "first argument of encrypt() expected Uint8Array, got string"
+ *
+ * // Without subject
+ * throw new InvalidTypeError({ expectedType: 'ChecksummedAddress' });
+ * // => "expected ChecksummedAddress"
+ *
+ * // With custom type
+ * throw new InvalidTypeError({
+ *   subject: 'config.timeout',
+ *   expectedType: 'Custom',
+ *   expectedCustomType: 'positive integer',
+ *   type: 'number',
+ * });
+ * // => "config.timeout expected positive integer, got number"
+ * ```
+ */
+export class InvalidTypeError extends ErrorBase {
+  constructor(
+    {
+      subject,
+      index,
+      type,
+      expectedType,
+      metaMessages,
+    }: {
+      subject?: string | undefined;
+      index?: number | undefined;
+      type?: string | undefined;
+      metaMessages?: string[] | undefined;
+    } & ExpectedTypeParams,
+    options: ErrorMetadataParams,
+  ) {
+    const noType = type === undefined || type === 'unknown' || type === 'undefined';
+
+    const actualExpectedType = Array.isArray(expectedType) ? expectedType.join('|') : expectedType;
+
+    let message = '';
+    if (subject !== undefined) {
+      if (index !== undefined) {
+        message += `${subject}[${String(index)}] `;
+      } else {
+        message += `${subject} `;
+      }
+    }
+    message += `expected ${actualExpectedType}`;
+    if (!noType) {
+      message += `, got ${type}`;
+    }
+
+    super({
+      ...options,
+      message,
+      name: 'InvalidTypeError',
+      metaMessages,
+    });
+  }
+}

package/core/base/errors/utils.ts

@@ -0,0 +1,41 @@
+import { InternalError } from './InternalError.js';
+
+export function ensureError(e: unknown): Error {
+  if (e instanceof Error) {
+    return e;
+  }
+
+  const message = (e as { message?: string }).message ?? 'Non-Error value caught in exception handler';
+  const name = (e as { name?: string }).name ?? 'ErrorWrapper';
+  const cause = (e as { cause: unknown }).cause ?? e;
+
+  const err = new Error(message, { cause });
+  err.name = name;
+
+  return err;
+}
+
+export function assertNever(_value: never, message: string): never {
+  throw new InternalError({ message });
+}
+
+export function getErrorMessage(e: unknown): string {
+  let msg: string;
+  if (typeof e === 'string') {
+    msg = e;
+  } else if (e instanceof Error) {
+    msg = e.message;
+  } else {
+    msg = String(e);
+  }
+
+  // Strip leading and trailing quotes (" or ')
+  while (msg.startsWith('"') || msg.startsWith("'")) {
+    msg = msg.slice(1);
+  }
+  while (msg.endsWith('"') || msg.endsWith("'")) {
+    msg = msg.slice(0, -1);
+  }
+
+  return msg;
+}

package/core/base/fetch.ts

@@ -0,0 +1,284 @@
+import { normalizeBytes } from './bytes.js';
+import { abortableSleep } from './timeout.js';
+
+/**
+ * Extracts the response body as a Uint8Array.
+ *
+ * Uses `Response.bytes()` when available, falling back to `Response.arrayBuffer()`
+ * for compatibility. The `bytes()` method is a newer addition to the Fetch API
+ * and may not be supported in all environments. (older browsers, some JS runtimes, or polyfills).
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/bytes
+ */
+export async function getResponseBytes(response: Response): Promise<Uint8Array> {
+  const bytes: Uint8Array =
+    typeof response.bytes === 'function'
+      ? normalizeBytes(await response.bytes())
+      : normalizeBytes(await response.arrayBuffer());
+
+  return bytes;
+}
+
+/*
+  Nodejs Fetch:
+  =============
+  https://github.com/nodejs/undici/blob/8fd6c43c65952ebd2557964a726716879dea5506/lib/web/fetch/index.js#L135
+
+  TypeError:
+    -  webidl.argumentLengthCheck(arguments, 1, 'globalThis.fetch')
+  
+  Error:
+    - new Request(input, init)  
+      TypeError: 
+        - throw new TypeError('Failed to parse URL from ' + input, { cause: err })
+        - throw new TypeError(
+          'Request cannot be constructed from a URL that includes credentials: ' +
+            input
+        )
+        - throw new TypeError(`'window' option '${window}' must be null`)
+        - throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err })
+        - ...
+
+  AbortError:
+    - Abort signal
+
+  TypeError (Nodejs undici):
+
+    // See https://github.com/nodejs/undici/blob/8fd6c43c65952ebd2557964a726716879dea5506/lib/web/fetch/index.js#L237
+    if (response.type === 'error') {
+      p.reject(new TypeError('fetch failed', { cause: response.error }))
+      return
+    }
+
+    "fetch failed" - general network failure
+      - ECONNREFUSED (net.connect() / tls.connect())
+      - ENOTFOUND (net.connect() / tls.connect())
+      - UND_ERR_xxx (undici errors)
+
+    Undici error is accessible via: `TypeError.cause`
+*/
+
+interface FetchErrorInfo {
+  name: string;
+  message: string;
+  props: Record<string, string | number>;
+}
+
+/**
+ * Extracts structured error information from a fetch error's cause chain.
+ *
+ * Node.js fetch (undici) wraps network errors in a TypeError with a `cause`
+ * property pointing to the underlying error. This function traverses the
+ * cause chain and extracts:
+ * - `name`: The error name (e.g., "TypeError", "Error")
+ * - `message`: The error message
+ * - `props`: All string/number properties (e.g., code, errno, syscall, hostname)
+ *
+ * Uses duck typing (checks for `message` property) rather than `instanceof`
+ * to handle cross-realm errors.
+ *
+ * @example
+ * // For a DNS lookup failure:
+ * // TypeError: fetch failed
+ * //   cause: Error: getaddrinfo ENOTFOUND example.com
+ * //          { code: 'ENOTFOUND', errno: -3008, syscall: 'getaddrinfo', hostname: 'example.com' }
+ * //
+ * // Returns:
+ * // [
+ * //   {
+ * //     name: 'TypeError',
+ * //     message: 'fetch failed',
+ * //     props: {}
+ * //   },
+ * //   {
+ * //     name: 'Error',
+ * //     message: 'getaddrinfo ENOTFOUND example.com',
+ * //     props: {
+ * //       code: 'ENOTFOUND',
+ * //       errno: -3008,
+ * //       syscall: 'getaddrinfo',
+ * //       hostname: 'example.com'
+ * //     }
+ * //   }
+ * // ]
+ */
+const FETCH_ERROR_SKIP_PROPS = new Set(['message', 'cause', 'stack', 'name']);
+
+function getFetchErrorInfo(error: unknown): FetchErrorInfo[] {
+  const errors: FetchErrorInfo[] = [];
+  let current: unknown = error;
+
+  while (current !== null && typeof current === 'object') {
+    const obj = current as Record<string, unknown>;
+
+    if (typeof obj.message !== 'string') {
+      break;
+    }
+
+    const name = typeof obj.name === 'string' ? obj.name : 'Error';
+    const props: Record<string, string | number> = {};
+
+    for (const key of Object.keys(obj)) {
+      if (FETCH_ERROR_SKIP_PROPS.has(key)) continue;
+
+      const value = obj[key];
+      if (typeof value === 'string' || typeof value === 'number') {
+        props[key] = value;
+      }
+    }
+
+    errors.push({ name, message: obj.message, props });
+    current = obj.cause;
+  }
+
+  return errors;
+}
+
+/**
+ * Formats a fetch error into an array of human-readable messages.
+ *
+ * Traverses the error's cause chain and formats each error with its message
+ * and properties. The root error uses standard "Name: message" format, while
+ * nested causes are prefixed with "Cause: " and include name in the props.
+ *
+ * @param error - The error to format (typically from a failed fetch call)
+ * @returns An array of formatted error messages, one per error in the cause chain
+ *
+ * @example
+ * // For a DNS lookup failure (ENOTFOUND):
+ * // Input error structure:
+ * //   TypeError: fetch failed
+ * //     cause: Error: getaddrinfo ENOTFOUND api.example.com
+ * //            { code: 'ENOTFOUND', errno: -3008, syscall: 'getaddrinfo', hostname: 'api.example.com' }
+ * //
+ * // Output:
+ * // [
+ * //   "TypeError: fetch failed",
+ * //   "Cause: getaddrinfo ENOTFOUND api.example.com [name=Error, code=ENOTFOUND, errno=-3008, syscall=getaddrinfo, hostname=api.example.com]"
+ * // ]
+ *
+ * @example
+ * // For a connection refused error (ECONNREFUSED):
+ * // Output:
+ * // [
+ * //   "TypeError: fetch failed",
+ * //   "Cause: connect ECONNREFUSED 127.0.0.1:3000 [name=Error, code=ECONNREFUSED, errno=-61, syscall=connect, address=127.0.0.1, port=3000]"
+ * // ]
+ */
+export function formatFetchErrorMetaMessages(error: unknown): string[] {
+  const infos = getFetchErrorInfo(error);
+  if (infos.length === 0) {
+    return [String(error)];
+  }
+
+  return infos.map((info, index) => {
+    const isRoot = index === 0;
+    const propEntries = Object.entries(info.props);
+
+    if (isRoot) {
+      // Root error: "TypeError: fetch failed [props...]" or "TypeError: fetch failed"
+      const propsStr = propEntries.length > 0 ? ` [${propEntries.map(([k, v]) => `${k}=${v}`).join(', ')}]` : '';
+      return `${info.name}: ${info.message}${propsStr}`;
+    } else {
+      // Cause errors: "Cause: message [name=Error, props...]"
+      const allProps: Array<[string, string | number]> = [['name', info.name], ...propEntries];
+      const propsStr = ` [${allProps.map(([k, v]) => `${k}=${v}`).join(', ')}]`;
+      return `Cause: ${info.message}${propsStr}`;
+    }
+  });
+}
+
+export type FetchWithRetryParameters = {
+  readonly init?: RequestInit | undefined;
+  readonly retries?: number | undefined;
+  readonly retryDelayMs?: number | undefined;
+};
+
+/**
+ * Fetches a URL with automatic retry on network failures.
+ *
+ * Retries are triggered only for network-level errors (e.g., ECONNREFUSED, ENOTFOUND, UND_ERR_xxx (undici errors)
+ * connection timeouts). HTTP error responses (4xx, 5xx) are NOT retried - the response
+ * is returned as-is for the caller to handle.
+ *
+ * The operation is abortable via `init.signal`. If the signal is aborted, an AbortError
+ * is thrown immediately without further retries.
+ *
+ * @param url - The URL to fetch
+ * @param init - Optional fetch init options (method, headers, body, etc.)
+ * @param retries - Number of retry attempts on network failure (default: 3)
+ * @param retryDelayMs - Delay in milliseconds between retries (default: 1000)
+ * @returns The fetch Response
+ * @throws The last network error if all retries are exhausted
+ * @throws {Error} An error with name 'AbortError' if the signal is aborted
+ */
+export async function fetchWithRetry(
+  args: {
+    url: string;
+  } & FetchWithRetryParameters,
+): Promise<Response> {
+  let lastError: unknown;
+
+  const retries = args.retries ?? 3;
+  const retryDelayMs = args.retryDelayMs ?? 1000;
+  const { url, init } = args;
+
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    // Check if already aborted before fetching
+    init?.signal?.throwIfAborted();
+
+    try {
+      return await fetch(url, init);
+    } catch (error) {
+      // AbortError should not be retried - propagate immediately
+      if ((error as { name: string }).name === 'AbortError') {
+        throw error;
+      }
+
+      lastError = error;
+
+      if (attempt < retries) {
+        // Abortable delay between retries
+        await abortableSleep(retryDelayMs, init?.signal ?? undefined);
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Smoke-tests whether `fetch("data:...base64,...")` works and returns correct bytes.
+ *
+ * This is critical because {@link isomorphicCompileWasmFromBase64} relies on
+ * `fetch("data:application/octet-stream;base64,...")` to decode a base64 WASM
+ * binary into an `ArrayBuffer` before passing it to `WebAssembly.compile`.
+ * If any step in this pipeline fails, WASM compilation will silently produce
+ * corrupt bytes or throw.
+ *
+ * Known failure cases:
+ * - CSP `connect-src` without `data:` blocks data URL fetches
+ * - Sandboxed iframes without `allow-same-origin`
+ * - Older Node.js versions (< 18.13) with limited data URL fetch support
+ *
+ * When this returns `false`, callers should fall back to `atob` decoding
+ * or URL-based WASM loading via {@link isomorphicCompileWasm}.
+ */
+let _isDataUrlFetchSupportedPromise: Promise<boolean> | undefined;
+export function isDataUrlFetchSupported(): Promise<boolean> {
+  _isDataUrlFetchSupportedPromise ??= _isDataUrlFetchSupported();
+  return _isDataUrlFetchSupportedPromise;
+}
+
+async function _isDataUrlFetchSupported(): Promise<boolean> {
+  try {
+    const res = await fetch('data:text/plain;base64,YQ==');
+    if (!res.ok) {
+      return false;
+    }
+    const buf = await res.arrayBuffer();
+    return buf.byteLength === 1 && new Uint8Array(buf)[0] === 0x61; // 'a'
+  } catch {
+    return false;
+  }
+}

package/core/base/index.ts

@@ -0,0 +1 @@
+export { createTypedValue, createTypedValueArray } from './typedValue.js';

package/core/base/isomorphicWorker.ts

@@ -0,0 +1,283 @@
+interface NodeMessagePort {
+  on(event: 'error', listener: (error: Error) => void): void;
+  on(event: 'exit', listener: (code: number) => void): void;
+  on(event: string, listener: (data: MessageData) => void): void;
+  off(event: string, listener: (data: MessageData) => void): void;
+  postMessage(value: unknown): void;
+  terminate(): Promise<number>;
+}
+
+interface BrowserMessagePort {
+  addEventListener(event: string, listener: (event: MessageEvent<MessageData>) => void): void;
+  removeEventListener(event: string, listener: (event: MessageEvent<MessageData>) => void): void;
+  postMessage(value: unknown): void;
+  terminate(): void;
+}
+
+export type IsomorphicMessagePort = NodeMessagePort | BrowserMessagePort;
+
+interface MessageData {
+  type: string;
+  [key: string]: unknown;
+}
+
+type NodeWorkerConstructor = new (code: string | URL, options?: Record<string, unknown>) => NodeMessagePort;
+
+function isNodePort(target: IsomorphicMessagePort): target is NodeMessagePort {
+  return typeof (target as NodeMessagePort).on === 'function';
+}
+
+export function isBrowserLike(): boolean {
+  return typeof addEventListener === 'function' && typeof removeEventListener === 'function';
+}
+
+/**
+ * This function is called from inside a worker to get the messaging target
+ * It's the communication channel between a worker thread and its parent (main) thread.
+ */
+export async function getIsomorphicTarget(): Promise<IsomorphicMessagePort> {
+  if (isBrowserLike()) return self as unknown as BrowserMessagePort;
+  const nodeWorkerModuleName = 'worker_threads';
+  const nodeWorkerModuleId = `node:${nodeWorkerModuleName}`;
+  const { parentPort: nodeParentPort } = (await import(/* @vite-ignore */ nodeWorkerModuleId)) as {
+    parentPort: NodeMessagePort | null;
+  };
+  if (!nodeParentPort) {
+    throw new Error('Not running inside a worker thread');
+  }
+  return nodeParentPort;
+}
+
+export async function createIsomorphicWorker(url: string): Promise<Worker | NodeMessagePort> {
+  if (isBrowserLike()) {
+    return createBrowserLikeWorker(url);
+  }
+  return createNodeLikeWorker(url);
+}
+
+export async function createIsomorphicWorkerFromCode(jsCode: string): Promise<Worker | NodeMessagePort> {
+  if (isBrowserLike()) {
+    const blob = new Blob([jsCode], { type: 'application/javascript' });
+    const blobUrl = URL.createObjectURL(blob);
+    try {
+      const browserWorker = new Worker(blobUrl);
+      return browserWorker;
+    } finally {
+      URL.revokeObjectURL(blobUrl);
+    }
+  }
+  const nodeWorkerModuleName = 'worker_threads';
+  const nodeWorkerModuleId = `node:${nodeWorkerModuleName}`;
+  const { Worker: NodeWorker } = (await import(/* @vite-ignore */ nodeWorkerModuleId)) as {
+    Worker: NodeWorkerConstructor;
+  };
+  return new NodeWorker(jsCode, { eval: true });
+}
+
+/**
+ * Runs code in an isomorphic worker thread and returns the result.
+ *
+ * The `code` string is wrapped in an async IIFE that receives `data` as input.
+ * Use `return` to send the result back to the main thread.
+ *
+ * @example
+ * const module = await runCodeInIsomorphicWorker<WebAssembly.Module>(
+ *   `const res = await fetch("data:application/octet-stream;base64," + data);
+ *    const bytes = new Uint8Array(await res.arrayBuffer());
+ *    return WebAssembly.compile(bytes);`,
+ *   base64,
+ * );
+ *
+ * @param code - JS code to execute. Receives `data` as input, must `return` the result.
+ * @param input - Value sent to the worker via postMessage (must be structured-cloneable).
+ * @param timeoutMs - Max execution time before the worker is killed. Default: 30s.
+ */
+export async function runCodeInIsomorphicWorker<T>(
+  code: string,
+  input: unknown,
+  timeoutMs: number = 30_000,
+): Promise<T> {
+  const browserCode = `
+    self.onmessage = async ({ data }) => {
+      try {
+        const result = await (async (data) => { ${code} })(data);
+        self.postMessage({ result });
+      } catch (e) {
+        self.postMessage({ error: String(e) });
+      }
+    };
+  `;
+
+  const nodeCode = `
+    const { parentPort } = require("worker_threads");
+    parentPort.on("message", async (data) => {
+      try {
+        const result = await (async (data) => { ${code} })(data);
+        parentPort.postMessage({ result });
+      } catch (e) {
+        parentPort.postMessage({ error: String(e) });
+      }
+    });
+  `;
+
+  const workerCode = isBrowserLike() ? browserCode : nodeCode;
+  const worker = await createIsomorphicWorkerFromCode(workerCode);
+
+  return new Promise<T>((resolve, reject) => {
+    // Guards against double-settle (e.g. "exit" firing after "message")
+    let settled = false;
+
+    // Terminates the worker, clears the timer, and prevents further settles
+    const cleanup = (): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      // fire and forget. Do not await the promise (only in Nodejs)
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        worker.terminate();
+      } catch (_) {
+        /* already dead */
+      }
+    };
+
+    // Normalizes any error and rejects the promise
+    const fail = (e: unknown): void => {
+      cleanup();
+      reject(e instanceof Error ? e : new Error(String(e)));
+    };
+
+    // Processes the worker's { result, error } envelope
+    const handle = (msg: Record<string, unknown>): void => {
+      cleanup();
+      if (msg.error !== undefined) {
+        reject(new Error(typeof msg.error === 'string' ? msg.error : JSON.stringify(msg.error)));
+      } else {
+        resolve(msg.result as T);
+      }
+    };
+
+    // Rejects if the worker takes too long (e.g. infinite loop, hung fetch)
+    // Declared after fail/handle so all references are resolved before the timer can fire
+    const timer = setTimeout(() => {
+      if (!settled) fail(new Error(`Worker timed out after ${String(timeoutMs)}ms`));
+    }, timeoutMs);
+
+    // Bind listeners and send input to the worker
+    if ('on' in worker) {
+      // Node: EventEmitter API
+      worker.on('message', (data: MessageData) => {
+        handle(data);
+      });
+      worker.on('error', (e: Error) => {
+        fail(e);
+      });
+      worker.on('exit', (exitCode: number) => {
+        if (!settled) fail(new Error(`Worker exited with code ${String(exitCode)}`));
+      });
+      worker.postMessage(input);
+    } else {
+      // Browser: DOM event API
+      worker.onmessage = ({ data }: MessageEvent) => {
+        handle(data as Record<string, unknown>);
+      };
+      worker.onerror = (e: ErrorEvent) => {
+        fail(new Error(e.message));
+      };
+      worker.postMessage(input);
+    }
+  });
+}
+
+/**
+ * Smoke-tests the full inline worker pipeline (Blob URL in browser, eval in Node).
+ *
+ * Sends `"hello"` as input, executes `data + " world!"` in a worker, and verifies
+ * the result is `"hello world!"`. This validates:
+ * - Worker creation (Blob URL or eval mode)
+ * - postMessage input delivery
+ * - Code execution inside the worker
+ * - Result returned via postMessage
+ *
+ * Returns `false` (instead of throwing) when inline workers are blocked:
+ *
+ * Browser:
+ * - CSP `worker-src` does not allow `blob:` — the most common failure case.
+ *   @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Security-Policy/worker-src
+ * - CSP `script-src` blocks `unsafe-eval` (some engines treat Blob workers as eval).
+ *   @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Security-Policy/script-src
+ * - Sandboxed iframe without `allow-scripts`.
+ *   @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/iframe#sandbox
+ *
+ * Node.js:
+ * - `--disallow-code-generation-from-strings` flag blocks `{ eval: true }` workers.
+ *   @see https://nodejs.org/api/cli.html#--disallow-code-generation-from-strings
+ * - Experimental permission model restricts worker creation.
+ *   @see https://nodejs.org/api/permissions.html
+ *
+ * When this returns `false`, fall back to URL-based workers via `createIsomorphicWorker()`.
+ */
+let _blobWorkerSupportedPromise: Promise<boolean> | undefined;
+export function isBlobWorkerSupported(): Promise<boolean> {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-arguments
+  _blobWorkerSupportedPromise ??= runCodeInIsomorphicWorker<string>(`return data + " world!";`, 'hello', 5000).then(
+    (res) => res === 'hello world!',
+    () => false,
+  );
+  return _blobWorkerSupportedPromise;
+}
+
+function createBrowserLikeWorker(url: string): Worker {
+  return new Worker(url, {
+    type: 'module',
+    name: 'wasm_bindgen_worker',
+  });
+}
+
+async function createNodeLikeWorker(url: string): Promise<NodeMessagePort> {
+  const nodeWorkerModuleName = 'worker_threads';
+  const nodeWorkerModuleId = `node:${nodeWorkerModuleName}`;
+  const { Worker: NodeWorker } = (await import(/* @vite-ignore */ nodeWorkerModuleId)) as {
+    Worker: NodeWorkerConstructor;
+  };
+  // Node's Worker doesn't support data: or blob: URLs.
+  // For data: URLs, extract the code and use eval mode.
+  if (url.startsWith('data:')) {
+    const base64 = url.split(',')[1];
+    if (base64 === undefined) {
+      throw new Error('Invalid data url');
+    }
+
+    const nodeBufferModuleName = 'buffer';
+    const nodeBufferModuleId = `node:${nodeBufferModuleName}`;
+    const { Buffer: NodeBuffer } = (await import(/* @vite-ignore */ nodeBufferModuleId)) as {
+      Buffer: {
+        from(str: string, encoding: string): { toString(enc: string): string };
+      };
+    };
+    //const res = await fetch("data:application/octet-stream;base64," + data);
+    const code = NodeBuffer.from(base64, 'base64').toString('utf-8');
+    return new NodeWorker(code, { eval: true });
+  }
+  return new NodeWorker(url);
+}
+
+export function waitForMsgType(target: IsomorphicMessagePort, type: string): Promise<MessageData> {
+  return new Promise((resolve) => {
+    if (isNodePort(target)) {
+      // Node: EventEmitter, data passed directly
+      target.on('message', function onMsg(data: MessageData) {
+        if (data.type !== type) return;
+        target.off('message', onMsg);
+        resolve(data);
+      });
+    } else {
+      // Browser: DOM events, data wrapped in MessageEvent
+      target.addEventListener('message', function onMsg({ data }: MessageEvent<MessageData>) {
+        if (data.type !== type) return;
+        target.removeEventListener('message', onMsg);
+        resolve(data);
+      });
+    }
+  });
+}