@volter/tabnode 0.2.14-volter.88

package/src/npm/tarball.ts

@@ -0,0 +1,246 @@
+/**
+ * Tarball Extractor
+ * Downloads and extracts npm package tarballs into the virtual file system
+ */
+
+import pako from 'pako';
+import { VirtualFS } from '../virtual-fs';
+import * as path from '../shims/path';
+
+export interface ExtractOptions {
+  stripComponents?: number; // Number of leading path components to strip (default: 1 for npm's "package/" prefix)
+  filter?: (path: string) => boolean;
+  onProgress?: (message: string) => void;
+}
+
+interface TarEntry {
+  name: string;
+  type: 'file' | 'directory' | 'symlink' | 'unknown';
+  size: number;
+  mode: number;
+  content?: Uint8Array;
+  linkTarget?: string;
+}
+
+/**
+ * Parse a tar archive from raw bytes
+ */
+function* parseTar(data: Uint8Array): Generator<TarEntry> {
+  const decoder = new TextDecoder();
+  let offset = 0;
+  // The name a pax extended header or a GNU long-name entry gave the entry
+  // that follows it.
+  let __nextName: string | undefined;
+
+  while (offset < data.length - 512) {
+    // Read 512-byte header
+    const header = data.slice(offset, offset + 512);
+    offset += 512;
+
+    // Check for end of archive (two zero blocks)
+    if (header.every((b) => b === 0)) {
+      break;
+    }
+
+    // Parse header fields
+    const name = parseString(header, 0, 100);
+    const mode = parseOctal(header, 100, 8);
+    const size = parseOctal(header, 124, 12);
+    const typeFlag = String.fromCharCode(header[156]);
+    const linkName = parseString(header, 157, 100);
+    const prefix = parseString(header, 345, 155);
+
+    // Skip empty entries
+    if (!name) {
+      continue;
+    }
+
+    // Combine prefix and name for long paths
+    const fullName = __nextName !== void 0 ? __nextName : prefix ? `${prefix}/${name}` : name;
+    __nextName = void 0;
+
+    // Determine entry type
+    let type: TarEntry['type'];
+    switch (typeFlag) {
+      case '0':
+      case '\0':
+      case '':
+        type = 'file';
+        break;
+      case '5':
+        type = 'directory';
+        break;
+      case '1':
+      case '2':
+        type = 'symlink';
+        break;
+      default:
+        type = 'unknown';
+    }
+
+    // Read file content (empty files get an empty Uint8Array)
+    let content: Uint8Array | undefined;
+    // Every entry's payload is skipped, not a file entry's only: an entry of
+    // another kind that carries one — the pax extended header npm's older
+    // tarballs put before every file — left its payload in place and the next
+    // header was read out of it. serve-favicon 2.5.0 came out of the store as
+    // files named by lines of its README and no package.json.
+    const __payload = size > 0 ? Math.ceil(size / 512) * 512 : 0;
+    if (typeFlag === "x" || typeFlag === "L") {
+      const __text = new TextDecoder().decode(data.slice(offset, offset + size));
+      offset += __payload;
+      if (typeFlag === "L") {
+        __nextName = __text.replace(/\0+$/, "");
+      } else {
+        for (const __line of __text.split("\n")) {
+          const __match = /^\d+ path=(.*)$/.exec(__line);
+          if (__match) __nextName = __match[1];
+        }
+      }
+      continue;
+    }
+    if (type === 'file') {
+      content = size > 0 ? data.slice(offset, offset + size) : new Uint8Array(0);
+    }
+    offset += __payload;
+
+    yield {
+      name: fullName,
+      type,
+      size,
+      mode,
+      content,
+      linkTarget: type === 'symlink' ? linkName : undefined,
+    };
+  }
+}
+
+/**
+ * Parse a null-terminated string from tar header
+ */
+function parseString(data: Uint8Array, offset: number, length: number): string {
+  const bytes = data.slice(offset, offset + length);
+  const nullIndex = bytes.indexOf(0);
+  const actualBytes = nullIndex >= 0 ? bytes.slice(0, nullIndex) : bytes;
+  return new TextDecoder().decode(actualBytes);
+}
+
+/**
+ * Parse an octal number from tar header
+ */
+function parseOctal(data: Uint8Array, offset: number, length: number): number {
+  const str = parseString(data, offset, length).trim();
+  return parseInt(str, 8) || 0;
+}
+
+/**
+ * Decompress gzipped data
+ */
+export function decompress(data: ArrayBuffer | Uint8Array): Uint8Array {
+  const input = data instanceof Uint8Array ? data : new Uint8Array(data);
+  return pako.inflate(input);
+}
+
+/**
+ * Extract a tarball to the virtual file system
+ */
+export function extractTarball(
+  tarballData: ArrayBuffer | Uint8Array,
+  vfs: VirtualFS,
+  destPath: string,
+  options: ExtractOptions = {}
+): string[] {
+  const { stripComponents = 1, filter, onProgress } = options;
+
+  // Decompress gzip
+  onProgress?.('Decompressing...');
+  const tarData = decompress(tarballData);
+
+  // Parse and extract tar entries
+  const extractedFiles: string[] = [];
+
+  for (const entry of parseTar(tarData)) {
+    // Skip non-file/directory entries for now
+    if (entry.type !== 'file' && entry.type !== 'directory') {
+      continue;
+    }
+
+    // Strip leading path components (npm packages have "package/" prefix)
+    let entryPath = entry.name;
+    if (stripComponents > 0) {
+      const parts = entryPath.split('/').filter(Boolean);
+      if (parts.length <= stripComponents) {
+        continue;
+      }
+      entryPath = parts.slice(stripComponents).join('/');
+    }
+
+    // Apply filter if provided
+    if (filter && !filter(entryPath)) {
+      continue;
+    }
+
+    // Build destination path
+    const fullPath = path.join(destPath, entryPath);
+
+    if (entry.type === 'directory') {
+      vfs.mkdirSync(fullPath, { recursive: true });
+    } else if (entry.type === 'file' && entry.content) {
+      // Ensure parent directory exists
+      const parentDir = path.dirname(fullPath);
+      vfs.mkdirSync(parentDir, { recursive: true });
+
+      // Write file
+      vfs.writeFileSync(fullPath, entry.content);
+      extractedFiles.push(fullPath);
+    }
+  }
+
+  onProgress?.(`Extracted ${extractedFiles.length} files`);
+
+  return extractedFiles;
+}
+
+/**
+ * Download and extract a tarball from URL
+ */
+// The store's hook gets the engine's own extractor for a package it must fetch.
+(globalThis as Record<symbol, unknown>)[Symbol.for("@volter/browser-runtime/package-extract")] = extractTarball;
+
+/** Run `work` over `items` with `size` of them in flight, each lane taking the next. */
+export async function __browserRuntimeInstallPool<T>(items: T[], size: number, work: (item: T) => Promise<void>): Promise<void> {
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(size, items.length) }, async () => {
+    for (;;) {
+      const index = next++;
+      if (index >= items.length) return;
+      await work(items[index]);
+    }
+  }));
+}
+
+export async function downloadAndExtract(
+  url: string,
+  vfs: VirtualFS,
+  destPath: string,
+  options: ExtractOptions = {}
+): Promise<string[]> {
+  const { onProgress } = options;
+
+  onProgress?.(`Downloading ${url}...`);
+
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to download tarball: ${response.status}`);
+  }
+
+  const data = await response.arrayBuffer();
+
+  return extractTarball(data, vfs, destPath, options);
+}
+
+export default {
+  decompress,
+  extractTarball,
+  downloadAndExtract,
+};

package/src/process-tokens.ts

@@ -0,0 +1,156 @@
+/**
+ * A run the embedding host has named, and the registry the container answers
+ * about it from.
+ *
+ * `container.run(command, { processToken })` names one run. The `node` command
+ * records the guest process it creates under that name, for as long as the run
+ * lasts, and forgets it when the run ends. Nothing here starts or ends a
+ * program: it is the registry three doors read, and the name a server
+ * registers itself under while its run is the one launching.
+ *
+ * The name reaches the `node` command through the shell's environment, under
+ * the reserved variable below, because two runs can be in flight at once on
+ * one shell and a module-level "the current run" would answer the later one
+ * for both. The guest never sees the variable: the environment the `node`
+ * command gives its process has it removed.
+ */
+
+import { AsyncLocalStorage } from './shims/async_hooks';
+
+/** Whatever the embedding runtime uses to name one guest process. */
+export type ProcessToken = string;
+
+/** The environment variable a run's name travels in, from `exec` to `node`. */
+export const PROCESS_TOKEN_ENV = '__TABNODE_PROCESS_TOKEN';
+
+/** What the engine can answer about one named run. */
+export interface OwnedRun {
+  /** The timers the run's guest still holds, as Node's loop counts them. */
+  pendingTimers(): number;
+  /** Clear those timers, as ending the process clears them. */
+  stopTimers(): void;
+  /**
+   * Report an exception nobody caught as this run's own, the way Node's
+   * process reports one: the run's `uncaughtException` listeners, else its
+   * stderr and exit 1. False when the run no longer answers.
+   */
+  reportUncaught(error: unknown): boolean;
+}
+
+const runs = new Map<ProcessToken, OwnedRun>();
+
+/**
+ * The run whose guest code is executing, as an async-local value rather than a
+ * module global. A module-level "the current run" answered the LATEST run for
+ * every reader, so a guest that spawned a child while another run was in
+ * flight was attributed to the wrong parent. The engine's own storage carries
+ * the value into timers, immediates, microtasks and `then` callbacks scheduled
+ * from inside the run; a native `await` continuation is its documented limit.
+ */
+const executing = new AsyncLocalStorage<ProcessToken>();
+
+/** Run `fn` as this token's guest code, so the doors below name that run. */
+export function enterRun<T>(token: ProcessToken, fn: () => T): T {
+  return executing.run(token, fn as (...args: unknown[]) => T);
+}
+
+/**
+ * Record a named run's guest for the run's lifetime. The answer releases it;
+ * releasing twice is harmless, as a run ends once.
+ */
+export function __recordRun(token: ProcessToken, run: OwnedRun): () => void {
+  runs.set(token, run);
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    if (runs.get(token) === run) runs.delete(token);
+  };
+}
+
+/** The run recorded under this name, while it lasts. */
+export function __runFor(token: ProcessToken): OwnedRun | undefined {
+  return runs.get(token);
+}
+
+/**
+ * The run now launching a guest, for a handle or a server the guest opens
+ * after its entry has returned, when no run is the current one any more.
+ * `enterRun`'s async-local value covers the guest's own turn and everything
+ * scheduled from inside it; a listen that lands after a native `await`
+ * continuation is attributed here.
+ */
+export let __lastLaunchedToken: ProcessToken | null = null;
+export function __setLastLaunchedToken(token: ProcessToken | null): void {
+  __lastLaunchedToken = token;
+}
+
+/** The run a guest is being launched under, where the host named one. */
+export function __currentProcessToken(): ProcessToken | null {
+  return executing.getStore() ?? null;
+}
+
+/**
+ * End a named run's timers. The servers it owns are released by `http`'s own
+ * half, `__releaseOwnedServers`, which calls this for the timers.
+ */
+export function __stopOwnedProcess(token: ProcessToken): void {
+  runs.get(token)?.stopTimers();
+}
+
+/**
+ * A process's own number.
+ *
+ * Node gives every process a distinct pid and `process.ppid` names its
+ * parent's; a program reads both, and other programs read a program's pid out
+ * of a file and ask whether it is still there. The engine gave every guest
+ * `pid: 1` and `ppid: 0`, while the parent's `ChildProcess` handle carried a
+ * real, distinct number minted by `process_wrap` -- so a child and its parent
+ * disagreed about the child's pid, and worse, every run answered
+ * `process.kill(1, 0)` with "yes, that is me".
+ *
+ * What that cost: openvscode-server's extension host takes a lock on its
+ * workspace storage directory (`vs/workbench/api/node/extHostStoragePaths`),
+ * writes `{ pid: process.pid }` into `vscode.lock`, and a later host reads
+ * that file and asks `processExists(pid)` -- `try { process.kill(pid, 0);
+ * return true } catch { return false }` -- before stealing a stale lock. Every
+ * host wrote pid 1 and every later host asked about pid 1, which is its own,
+ * so the lock read as held by a live process forever. `ExtensionStoragePaths.
+ * whenReady` never resolved, every `_loadExtensionContext` awaits it, and so
+ * every extension in the tab sat at "Activating..." and `vscode.git` never
+ * started at all.
+ */
+let __nextPid = 1000 + Math.floor(Math.random() * 30000);
+const pidsOfRuns = new Map<ProcessToken, { pid: number; ppid: number }>();
+
+/** The next process number this engine hands out. */
+export function mintPid(): number {
+  return __nextPid++;
+}
+
+/** Record the numbers a named run was started with, for the run to read back. */
+export function setRunPid(token: ProcessToken, pid: number, ppid: number): void {
+  pidsOfRuns.set(token, { pid, ppid });
+}
+
+/** The numbers a named run was started with, where one was recorded. */
+export function runPid(token: ProcessToken | null | undefined): { pid: number; ppid: number } | undefined {
+  return token === null || token === undefined ? undefined : pidsOfRuns.get(token);
+}
+
+/** A run that has ended is no longer a process; its number is nobody's. */
+export function forgetRunPid(token: ProcessToken): void {
+  pidsOfRuns.delete(token);
+}
+
+/** Whether a live run carries this number, which is what `kill(pid, 0)` asks. */
+export function pidIsLive(pid: number): boolean {
+  for (const entry of pidsOfRuns.values()) if (entry.pid === pid) return true;
+  return false;
+}
+
+/** The numbers a live process carries, looked up by its own pid. */
+export function processByPid(pid: number): { pid: number; ppid: number } | undefined {
+  for (const entry of pidsOfRuns.values()) if (entry.pid === pid) return entry;
+  return undefined;
+}

package/src/punycode-source.ts

@@ -0,0 +1,6 @@
+// punycode 2.3.1 (MIT, Mathias Bynens), the library Node ships as its deprecated
+// `punycode` builtin, embedded so the engine answers `require("punycode")`
+// with Node's own API: whatwg-url under node-fetch under google-auth-library asks
+// for it on the way into Dub's login action. Regenerate from the package, never edit.
+export const PUNYCODE_VERSION = "2.3.1";
+export const PUNYCODE_SOURCE = "'use strict';\n\n/** Highest positive signed 32-bit float value */\nconst maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1\n\n/** Bootstring parameters */\nconst base = 36;\nconst tMin = 1;\nconst tMax = 26;\nconst skew = 38;\nconst damp = 700;\nconst initialBias = 72;\nconst initialN = 128; // 0x80\nconst delimiter = '-'; // '\\x2D'\n\n/** Regular expressions */\nconst regexPunycode = /^xn--/;\nconst regexNonASCII = /[^\\0-\\x7F]/; // Note: U+007F DEL is excluded too.\nconst regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g; // RFC 3490 separators\n\n/** Error messages */\nconst errors = {\n\t'overflow': 'Overflow: input needs wider integers to process',\n\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t'invalid-input': 'Invalid input'\n};\n\n/** Convenience shortcuts */\nconst baseMinusTMin = base - tMin;\nconst floor = Math.floor;\nconst stringFromCharCode = String.fromCharCode;\n\n/*--------------------------------------------------------------------------*/\n\n/**\n * A generic error utility function.\n * @private\n * @param {String} type The error type.\n * @returns {Error} Throws a `RangeError` with the applicable error message.\n */\nfunction error(type) {\n\tthrow new RangeError(errors[type]);\n}\n\n/**\n * A generic `Array#map` utility function.\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} callback The function that gets called for every array\n * item.\n * @returns {Array} A new array of values returned by the callback function.\n */\nfunction map(array, callback) {\n\tconst result = [];\n\tlet length = array.length;\n\twhile (length--) {\n\t\tresult[length] = callback(array[length]);\n\t}\n\treturn result;\n}\n\n/**\n * A simple `Array#map`-like wrapper to work with domain name strings or email\n * addresses.\n * @private\n * @param {String} domain The domain name or email address.\n * @param {Function} callback The function that gets called for every\n * character.\n * @returns {String} A new string of characters returned by the callback\n * function.\n */\nfunction mapDomain(domain, callback) {\n\tconst parts = domain.split('@');\n\tlet result = '';\n\tif (parts.length > 1) {\n\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t// the local part (i.e. everything up to `@`) intact.\n\t\tresult = parts[0] + '@';\n\t\tdomain = parts[1];\n\t}\n\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\tdomain = domain.replace(regexSeparators, '\\x2E');\n\tconst labels = domain.split('.');\n\tconst encoded = map(labels, callback).join('.');\n\treturn result + encoded;\n}\n\n/**\n * Creates an array containing the numeric code points of each Unicode\n * character in the string. While JavaScript uses UCS-2 internally,\n * this function will convert a pair of surrogate halves (each of which\n * UCS-2 exposes as separate characters) into a single code point,\n * matching UTF-16.\n * @see `punycode.ucs2.encode`\n * @see <https://mathiasbynens.be/notes/javascript-encoding>\n * @memberOf punycode.ucs2\n * @name decode\n * @param {String} string The Unicode input string (UCS-2).\n * @returns {Array} The new array of code points.\n */\nfunction ucs2decode(string) {\n\tconst output = [];\n\tlet counter = 0;\n\tconst length = string.length;\n\twhile (counter < length) {\n\t\tconst value = string.charCodeAt(counter++);\n\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t// It's a high surrogate, and there is a next character.\n\t\t\tconst extra = string.charCodeAt(counter++);\n\t\t\tif ((extra & 0xFC00) == 0xDC00) { // Low surrogate.\n\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t} else {\n\t\t\t\t// It's an unmatched surrogate; only append this code unit, in case the\n\t\t\t\t// next code unit is the high surrogate of a surrogate pair.\n\t\t\t\toutput.push(value);\n\t\t\t\tcounter--;\n\t\t\t}\n\t\t} else {\n\t\t\toutput.push(value);\n\t\t}\n\t}\n\treturn output;\n}\n\n/**\n * Creates a string based on an array of numeric code points.\n * @see `punycode.ucs2.decode`\n * @memberOf punycode.ucs2\n * @name encode\n * @param {Array} codePoints The array of numeric code points.\n * @returns {String} The new Unicode string (UCS-2).\n */\nconst ucs2encode = codePoints => String.fromCodePoint(...codePoints);\n\n/**\n * Converts a basic code point into a digit/integer.\n * @see `digitToBasic()`\n * @private\n * @param {Number} codePoint The basic numeric code point value.\n * @returns {Number} The numeric value of a basic code point (for use in\n * representing integers) in the range `0` to `base - 1`, or `base` if\n * the code point does not represent a value.\n */\nconst basicToDigit = function(codePoint) {\n\tif (codePoint >= 0x30 && codePoint < 0x3A) {\n\t\treturn 26 + (codePoint - 0x30);\n\t}\n\tif (codePoint >= 0x41 && codePoint < 0x5B) {\n\t\treturn codePoint - 0x41;\n\t}\n\tif (codePoint >= 0x61 && codePoint < 0x7B) {\n\t\treturn codePoint - 0x61;\n\t}\n\treturn base;\n};\n\n/**\n * Converts a digit/integer into a basic code point.\n * @see `basicToDigit()`\n * @private\n * @param {Number} digit The numeric value of a basic code point.\n * @returns {Number} The basic code point whose value (when used for\n * representing integers) is `digit`, which needs to be in the range\n * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n * used; else, the lowercase form is used. The behavior is undefined\n * if `flag` is non-zero and `digit` has no uppercase form.\n */\nconst digitToBasic = function(digit, flag) {\n\t//  0..25 map to ASCII a..z or A..Z\n\t// 26..35 map to ASCII 0..9\n\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n};\n\n/**\n * Bias adaptation function as per section 3.4 of RFC 3492.\n * https://tools.ietf.org/html/rfc3492#section-3.4\n * @private\n */\nconst adapt = function(delta, numPoints, firstTime) {\n\tlet k = 0;\n\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\tdelta += floor(delta / numPoints);\n\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\tdelta = floor(delta / baseMinusTMin);\n\t}\n\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n};\n\n/**\n * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n * symbols.\n * @memberOf punycode\n * @param {String} input The Punycode string of ASCII-only symbols.\n * @returns {String} The resulting string of Unicode symbols.\n */\nconst decode = function(input) {\n\t// Don't use UCS-2.\n\tconst output = [];\n\tconst inputLength = input.length;\n\tlet i = 0;\n\tlet n = initialN;\n\tlet bias = initialBias;\n\n\t// Handle the basic code points: let `basic` be the number of input code\n\t// points before the last delimiter, or `0` if there is none, then copy\n\t// the first basic code points to the output.\n\n\tlet basic = input.lastIndexOf(delimiter);\n\tif (basic < 0) {\n\t\tbasic = 0;\n\t}\n\n\tfor (let j = 0; j < basic; ++j) {\n\t\t// if it's not a basic code point\n\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\terror('not-basic');\n\t\t}\n\t\toutput.push(input.charCodeAt(j));\n\t}\n\n\t// Main decoding loop: start just after the last delimiter if any basic code\n\t// points were copied; start at the beginning otherwise.\n\n\tfor (let index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t// `index` is the index of the next character to be consumed.\n\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t// which gets added to `i`. The overflow checking is easier\n\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t// value at the end to obtain `delta`.\n\t\tconst oldi = i;\n\t\tfor (let w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\tif (index >= inputLength) {\n\t\t\t\terror('invalid-input');\n\t\t\t}\n\n\t\t\tconst digit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\tif (digit >= base) {\n\t\t\t\terror('invalid-input');\n\t\t\t}\n\t\t\tif (digit > floor((maxInt - i) / w)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\ti += digit * w;\n\t\t\tconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\tif (digit < t) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tconst baseMinusT = base - t;\n\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tw *= baseMinusT;\n\n\t\t}\n\n\t\tconst out = output.length + 1;\n\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t// incrementing `n` each time, so we'll fix that now:\n\t\tif (floor(i / out) > maxInt - n) {\n\t\t\terror('overflow');\n\t\t}\n\n\t\tn += floor(i / out);\n\t\ti %= out;\n\n\t\t// Insert `n` at position `i` of the output.\n\t\toutput.splice(i++, 0, n);\n\n\t}\n\n\treturn String.fromCodePoint(...output);\n};\n\n/**\n * Converts a string of Unicode symbols (e.g. a domain name label) to a\n * Punycode string of ASCII-only symbols.\n * @memberOf punycode\n * @param {String} input The string of Unicode symbols.\n * @returns {String} The resulting Punycode string of ASCII-only symbols.\n */\nconst encode = function(input) {\n\tconst output = [];\n\n\t// Convert the input in UCS-2 to an array of Unicode code points.\n\tinput = ucs2decode(input);\n\n\t// Cache the length.\n\tconst inputLength = input.length;\n\n\t// Initialize the state.\n\tlet n = initialN;\n\tlet delta = 0;\n\tlet bias = initialBias;\n\n\t// Handle the basic code points.\n\tfor (const currentValue of input) {\n\t\tif (currentValue < 0x80) {\n\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t}\n\t}\n\n\tconst basicLength = output.length;\n\tlet handledCPCount = basicLength;\n\n\t// `handledCPCount` is the number of code points that have been handled;\n\t// `basicLength` is the number of basic code points.\n\n\t// Finish the basic string with a delimiter unless it's empty.\n\tif (basicLength) {\n\t\toutput.push(delimiter);\n\t}\n\n\t// Main encoding loop:\n\twhile (handledCPCount < inputLength) {\n\n\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t// larger one:\n\t\tlet m = maxInt;\n\t\tfor (const currentValue of input) {\n\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\tm = currentValue;\n\t\t\t}\n\t\t}\n\n\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t// but guard against overflow.\n\t\tconst handledCPCountPlusOne = handledCPCount + 1;\n\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\terror('overflow');\n\t\t}\n\n\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\tn = m;\n\n\t\tfor (const currentValue of input) {\n\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\t\t\tif (currentValue === n) {\n\t\t\t\t// Represent delta as a generalized variable-length integer.\n\t\t\t\tlet q = delta;\n\t\t\t\tfor (let k = base; /* no condition */; k += base) {\n\t\t\t\t\tconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tconst qMinusT = q - t;\n\t\t\t\t\tconst baseMinusT = base - t;\n\t\t\t\t\toutput.push(\n\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t);\n\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t}\n\n\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);\n\t\t\t\tdelta = 0;\n\t\t\t\t++handledCPCount;\n\t\t\t}\n\t\t}\n\n\t\t++delta;\n\t\t++n;\n\n\t}\n\treturn output.join('');\n};\n\n/**\n * Converts a Punycode string representing a domain name or an email address\n * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n * it doesn't matter if you call it on a string that has already been\n * converted to Unicode.\n * @memberOf punycode\n * @param {String} input The Punycoded domain name or email address to\n * convert to Unicode.\n * @returns {String} The Unicode representation of the given Punycode\n * string.\n */\nconst toUnicode = function(input) {\n\treturn mapDomain(input, function(string) {\n\t\treturn regexPunycode.test(string)\n\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t: string;\n\t});\n};\n\n/**\n * Converts a Unicode string representing a domain name or an email address to\n * Punycode. Only the non-ASCII parts of the domain name will be converted,\n * i.e. it doesn't matter if you call it with a domain that's already in\n * ASCII.\n * @memberOf punycode\n * @param {String} input The domain name or email address to convert, as a\n * Unicode string.\n * @returns {String} The Punycode representation of the given domain name or\n * email address.\n */\nconst toASCII = function(input) {\n\treturn mapDomain(input, function(string) {\n\t\treturn regexNonASCII.test(string)\n\t\t\t? 'xn--' + encode(string)\n\t\t\t: string;\n\t});\n};\n\n/*--------------------------------------------------------------------------*/\n\n/** Define the public API */\nconst punycode = {\n\t/**\n\t * A string representing the current Punycode.js version number.\n\t * @memberOf punycode\n\t * @type String\n\t */\n\t'version': '2.3.1',\n\t/**\n\t * An object of methods to convert from JavaScript's internal character\n\t * representation (UCS-2) to Unicode code points, and back.\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode\n\t * @type Object\n\t */\n\t'ucs2': {\n\t\t'decode': ucs2decode,\n\t\t'encode': ucs2encode\n\t},\n\t'decode': decode,\n\t'encode': encode,\n\t'toASCII': toASCII,\n\t'toUnicode': toUnicode\n};\n\nmodule.exports = punycode;\n";

package/src/runtime-interface.ts

@@ -0,0 +1,85 @@
+/**
+ * Runtime Interface - Common interface for main-thread and worker runtimes
+ */
+
+import type { VirtualFS } from './virtual-fs';
+
+export interface IRuntimeOptions {
+  cwd?: string;
+  env?: Record<string, string>;
+  onConsole?: (method: string, args: unknown[]) => void;
+}
+
+export interface IModule {
+  id: string;
+  filename: string;
+  exports: unknown;
+  loaded: boolean;
+  children: IModule[];
+  paths: string[];
+}
+
+export interface IExecuteResult {
+  exports: unknown;
+  module: IModule;
+}
+
+/**
+ * Common runtime interface implemented by both MainThreadRuntime and WorkerRuntime
+ */
+export interface IRuntime {
+  /**
+   * Execute code as a module
+   */
+  execute(code: string, filename?: string): Promise<IExecuteResult>;
+
+  /**
+   * Run a file from the virtual file system
+   */
+  runFile(filename: string): Promise<IExecuteResult>;
+
+  /**
+   * Clear the module cache
+   */
+  clearCache(): void;
+
+  /**
+   * Get the virtual file system (only available on main thread runtime)
+   */
+  getVFS?(): VirtualFS;
+
+  /**
+   * Terminate the runtime (only applicable to worker runtime)
+   */
+  terminate?(): void;
+}
+
+/**
+ * Options for creating a runtime
+ */
+export interface CreateRuntimeOptions extends IRuntimeOptions {
+  /**
+   * Which thread the guest runs on.
+   * - false (default): the caller's thread
+   * - true: a worker of the engine's own
+   * - 'auto': a worker where the realm has them, the caller's thread otherwise
+   *
+   * A worker is a thread, not an origin: it reaches the page's storage and
+   * its network. An embedder that needs origin isolation serves the run from
+   * an origin of its own, which is the substrate's isolation worker.
+   */
+  useWorker?: boolean | 'auto';
+}
+
+/**
+ * VFS snapshot for transferring to worker
+ */
+export interface VFSSnapshot {
+  files: VFSFileEntry[];
+}
+
+export interface VFSFileEntry {
+  path: string;
+  type: 'file' | 'directory';
+  content?: string; // base64 encoded for binary files
+}