@volter/tabnode 0.5.25 → 0.5.27

package/dist/assets/{runtime-worker-D6N3DujB.js → runtime-worker-DPvtXRd8.js}

@@ -21146,10 +21146,17 @@ var implementation$1 = function bind2(that) {
 var implementation = implementation$1;
 var functionBind = Function.prototype.bind || implementation;
 var functionCall = Function.prototype.call;
-var functionApply = Function.prototype.apply;
+var functionApply;
+var hasRequiredFunctionApply;
+function requireFunctionApply() {
+  if (hasRequiredFunctionApply) return functionApply;
+  hasRequiredFunctionApply = 1;
+  functionApply = Function.prototype.apply;
+  return functionApply;
+}
 var reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
 var bind$2 = functionBind;
-var $apply$1 = functionApply;
+var $apply$1 = requireFunctionApply();
 var $call$2 = functionCall;
 var $reflectApply = reflectApply;
 var actualApply = $reflectApply || bind$2.call($call$2, $apply$1);
@@ -21269,7 +21276,7 @@ var hasSymbols = requireHasSymbols()();
 var getProto = requireGetProto();
 var $ObjectGPO = requireObject_getPrototypeOf();
 var $ReflectGPO = requireReflect_getPrototypeOf();
-var $apply = functionApply;
+var $apply = requireFunctionApply();
 var $call = functionCall;
 var needsEval = {};
 var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined$1 : getProto(Uint8Array);
@@ -21910,7 +21917,7 @@ function requireApplyBind() {
   if (hasRequiredApplyBind) return applyBind;
   hasRequiredApplyBind = 1;
   var bind3 = functionBind;
-  var $apply2 = functionApply;
+  var $apply2 = requireFunctionApply();
   var actualApply$1 = actualApply;
   applyBind = function applyBind2() {
     return actualApply$1(bind3, $apply2, arguments);
@@ -22521,9 +22528,9 @@ Sha256$1.prototype._hash = function() {
   H.writeInt32BE(this._h, 28);
   return H;
 };
-var sha256 = Sha256$1;
+var sha256$1 = Sha256$1;
 var inherits$2 = inherits_browserExports;
-var Sha256 = sha256;
+var Sha256 = sha256$1;
 var Hash$2 = hash$1;
 var Buffer$3 = safeBufferExports.Buffer;
 var W$3 = new Array(64);
@@ -22949,7 +22956,7 @@ var sha384 = Sha384;
   module.exports.sha = sha;
   module.exports.sha1 = sha1;
   module.exports.sha224 = sha224;
-  module.exports.sha256 = sha256;
+  module.exports.sha256 = sha256$1;
   module.exports.sha384 = sha384;
   module.exports.sha512 = sha512;
 })(sha_js);
@@ -23003,9 +23010,27 @@ function clean(...arrays) {
 function createView(arr) {
   return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
 function rotl(word, shift) {
   return word << shift | word >>> 32 - shift >>> 0;
 }
+const hasHexBuiltin = /* @__PURE__ */ (() => (
+  // @ts-ignore
+  typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+))();
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i10) => i10.toString(16).padStart(2, "0"));
+function bytesToHex(bytes2) {
+  abytes(bytes2);
+  if (hasHexBuiltin)
+    return bytes2.toHex();
+  let hex = "";
+  for (let i10 = 0; i10 < bytes2.length; i10++) {
+    hex += hexes[bytes2[i10]];
+  }
+  return hex;
+}
 function checkOpts(defaults2, opts, title = "opts") {
   aobject(defaults2, "defaults");
   if (opts !== void 0)
@@ -23026,9 +23051,17 @@ function createHasher(hashCons, info = {}) {
   Object.assign(hashC, info);
   return Object.freeze(hashC);
 }
+const oidNist = (suffix) => ({
+  // Current NIST hashAlgs suffixes used here fit in one DER subidentifier octet.
+  // Larger suffix values would need base-128 OID encoding and a different length byte.
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
 function Chi(a, b, c) {
   return a & b ^ ~a & c;
 }
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
 class HashMD {
   constructor(blockLen, outputLen, padOffset, isLE) {
     __publicField(this, "blockLen");
@@ -23124,6 +23157,16 @@ class HashMD {
     return this._cloneInto();
   }
 }
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
 const SHA1_IV = /* @__PURE__ */ Uint32Array.from([
   1732584193,
   4023233417,
@@ -32103,6 +32146,169 @@ function simpleHash(str) {
   }
   return hash2.toString(36);
 }
+const SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+class SHA2_32B extends HashMD {
+  constructor(outputLen, IV) {
+    super(64, outputLen, 8, false);
+    // We cannot use array here since array allows indexing by variable
+    // which means optimizer/compiler cannot use registers.
+    // Numeric initializers matter: starting the fields as `undefined` changes
+    // V8's field representation and makes sha256 3x slower (measured).
+    __publicField(this, "A", 0);
+    __publicField(this, "B", 0);
+    __publicField(this, "C", 0);
+    __publicField(this, "D", 0);
+    __publicField(this, "E", 0);
+    __publicField(this, "F", 0);
+    __publicField(this, "G", 0);
+    __publicField(this, "H", 0);
+    this.A = IV[0] | 0;
+    this.B = IV[1] | 0;
+    this.C = IV[2] | 0;
+    this.D = IV[3] | 0;
+    this.E = IV[4] | 0;
+    this.F = IV[5] | 0;
+    this.G = IV[6] | 0;
+    this.H = IV[7] | 0;
+  }
+  get() {
+    const { A: A10, B, C, D: D10, E: E7, F, G: G10, H } = this;
+    return [A10, B, C, D10, E7, F, G10, H];
+  }
+  // prettier-ignore
+  set(A10, B, C, D10, E7, F, G10, H) {
+    this.A = A10 | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D10 | 0;
+    this.E = E7 | 0;
+    this.F = F | 0;
+    this.G = G10 | 0;
+    this.H = H | 0;
+  }
+  _cloneInto(to2) {
+    (to2 || (to2 = new this.constructor())).set(...this.get());
+    return this._cloneIntoMeta(to2);
+  }
+  process(view, offset2) {
+    for (let i10 = 0; i10 < 16; i10++, offset2 += 4)
+      SHA256_W[i10] = view.getUint32(offset2, false);
+    for (let i10 = 16; i10 < 64; i10++) {
+      const W15 = SHA256_W[i10 - 15];
+      const W22 = SHA256_W[i10 - 2];
+      const s02 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s12 = rotr(W22, 17) ^ rotr(W22, 19) ^ W22 >>> 10;
+      SHA256_W[i10] = s12 + SHA256_W[i10 - 7] + s02 + SHA256_W[i10 - 16] | 0;
+    }
+    let { A: A10, B, C, D: D10, E: E7, F, G: G10, H } = this;
+    for (let i10 = 0; i10 < 64; i10++) {
+      const sigma12 = rotr(E7, 6) ^ rotr(E7, 11) ^ rotr(E7, 25);
+      const T12 = H + sigma12 + Chi(E7, F, G10) + SHA256_K[i10] + SHA256_W[i10] | 0;
+      const sigma02 = rotr(A10, 2) ^ rotr(A10, 13) ^ rotr(A10, 22);
+      const T22 = sigma02 + Maj(A10, B, C) | 0;
+      H = G10;
+      G10 = F;
+      F = E7;
+      E7 = D10 + T12 | 0;
+      D10 = C;
+      C = B;
+      B = A10;
+      A10 = T12 + T22 | 0;
+    }
+    A10 = A10 + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D10 = D10 + this.D | 0;
+    E7 = E7 + this.E | 0;
+    F = F + this.F | 0;
+    G10 = G10 + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A10, B, C, D10, E7, F, G10, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.destroyed = true;
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+}
+class _SHA256 extends SHA2_32B {
+  constructor() {
+    super(32, SHA256_IV);
+  }
+}
+const sha256 = /* @__PURE__ */ createHasher(
+  () => new _SHA256(),
+  /* @__PURE__ */ oidNist(1)
+);
 const fsModule = lazyModule("fs");
 lazyModule("internal/fs/promises");
 function fsModuleFor(process2) {
@@ -78295,6 +78501,30 @@ Object.defineProperty(globalThis, "__substrateEvalSource", {
   configurable: true,
   value: (source) => typeof source === "string" ? __substrateRewriteDynamicImportsInScript(source) : source
 });
+function __substratePrepareBody(rawCode, resolvedPath, format2, process2) {
+  let code2 = rawCode;
+  if (code2.startsWith("#!")) {
+    code2 = code2.slice(code2.indexOf("\n") + 1);
+  }
+  code2 = __substrateModuleTypes(code2, resolvedPath, format2, process2);
+  const __commonjs = format2 === "commonjs" || format2 === "commonjs-typescript" ? true : format2 === "module" || format2 === "module-typescript" ? false : resolvedPath.endsWith(".cjs") || resolvedPath.endsWith(".cts");
+  if (!__commonjs) {
+    const lowered = transformEsmToCjs(code2, resolvedPath);
+    code2 = lowered === code2 ? code2 : `${__substrateModuleMarker}"use strict";${lowered}`;
+  } else {
+    code2 = transformDynamicImportsRegex(code2);
+  }
+  return code2;
+}
+const PREPARED_MODULES_DIR = "/.tabnode/prepared";
+const PREPARED_MODULES_FORMAT = "tabnode-prepared-1";
+function preparedModuleKey(rawCode, resolvedPath) {
+  var _a3;
+  const extension = (_a3 = /\.(js|cjs|mjs)$/u.exec(resolvedPath)) == null ? void 0 : _a3[1];
+  if (!extension) return void 0;
+  const kind = extension === "cjs" ? "cjs" : "js";
+  return bytesToHex(sha256(new TextEncoder().encode(`${PREPARED_MODULES_FORMAT}|${kind}|${rawCode}`)));
+}
 function transformEsmToCjs(code2, filename) {
   const maybeEsm = __substrateHasEsmSyntax(code2);
   if (!maybeEsm) return __substrateRewriteDynamicImportsInScript(code2);
@@ -79333,6 +79563,14 @@ function createRequire(vfs2, fsShim, process2, currentDir, moduleCache, options,
     }
     const rawCode = source === void 0 || source === null ? defaultSource() : String(source);
     const dirname$1 = resolvedPath.startsWith("data:") ? currentDir : dirname(resolvedPath);
+    if (format2 === void 0 && !transformsTypes(process2) && vfs2.existsSync(PREPARED_MODULES_DIR)) {
+      const key = preparedModuleKey(rawCode, resolvedPath);
+      const prepared = key ? `${PREPARED_MODULES_DIR}/${key}` : void 0;
+      if (prepared && vfs2.existsSync(prepared)) {
+        runModuleBody(module, vfs2.readFileSync(prepared, "utf8"), resolvedPath, dirname$1, true);
+        return module;
+      }
+    }
     runModuleBody(module, prepareModuleCode(rawCode, resolvedPath, format2), resolvedPath, dirname$1);
     return module;
   };
@@ -79340,23 +79578,12 @@ function createRequire(vfs2, fsShim, process2, currentDir, moduleCache, options,
     const codeCacheKey = `${resolvedPath}|${format2 ?? ""}|${transformsTypes(process2) ? "transform-types|" : ""}${simpleHash(rawCode)}`;
     let code2 = processedCodeCache == null ? void 0 : processedCodeCache.get(codeCacheKey);
     if (!code2) {
-      code2 = rawCode;
-      if (code2.startsWith("#!")) {
-        code2 = code2.slice(code2.indexOf("\n") + 1);
-      }
-      code2 = __substrateModuleTypes(code2, resolvedPath, format2, process2);
-      const __commonjs = format2 === "commonjs" || format2 === "commonjs-typescript" ? true : format2 === "module" || format2 === "module-typescript" ? false : resolvedPath.endsWith(".cjs") || resolvedPath.endsWith(".cts");
-      if (!__commonjs) {
-        const lowered = transformEsmToCjs(code2, resolvedPath);
-        code2 = lowered === code2 ? code2 : `${__substrateModuleMarker}"use strict";${lowered}`;
-      } else {
-        code2 = transformDynamicImportsRegex(code2);
-      }
+      code2 = __substratePrepareBody(rawCode, resolvedPath, format2, process2);
       processedCodeCache == null ? void 0 : processedCodeCache.set(codeCacheKey, code2);
     }
     return code2;
   };
-  const runModuleBody = (module, prepared, resolvedPath, dirname2) => {
+  const runModuleBody = (module, prepared, resolvedPath, dirname2, scoped = false) => {
     let code2 = prepared;
     const moduleRequire = createRequire(
       vfs2,
@@ -79373,7 +79600,7 @@ function createRequire(vfs2, fsShim, process2, currentDir, moduleCache, options,
     try {
       const importMetaUrl = resolvedPath.startsWith("data:") ? resolvedPath : "file://" + resolvedPath;
       const strictBody = code2.startsWith(__substrateModuleMarker);
-      code2 = __substrateScopeGlobalCalls(code2);
+      if (!scoped) code2 = __substrateScopeGlobalCalls(code2);
       const wrappedCode = `(function($exports, $require, $module, $filename, $dirname, $process, $console, $importMeta, $dynamicImport, __substrateGuestGlobal, __substrateGuestConstructor) { var exports = $exports; var require = $require; var module = $module; var __filename = $filename; var __dirname = $dirname; var process = $process; var console = $console; var import_meta = $importMeta; var __dynamicImport = $dynamicImport; var document = void 0, window = void 0, location = void 0, self = void 0; var globalThis = __substrateGuestGlobal($process); var global = globalThis; var Buffer = globalThis.Buffer; var queueMicrotask = globalThis.queueMicrotask, atob = globalThis.atob, btoa = globalThis.btoa, structuredClone = globalThis.structuredClone, setTimeout = globalThis.setTimeout, clearTimeout = globalThis.clearTimeout, setInterval = globalThis.setInterval, clearInterval = globalThis.clearInterval; globalThis.process = $process; global.process = $process; with ({ __proto__: null, get navigator() { return globalThis.navigator; }, set navigator(value) { globalThis.navigator = value; }, get Navigator() { return globalThis.Navigator; }, set Navigator(value) { globalThis.Navigator = value; }, get Promise() { return globalThis.Promise; }, set Promise(value) { globalThis.Promise = value; }, get fetch() { return globalThis.fetch; }, set fetch(value) { globalThis.fetch = value; } }) { return (function() {${code2}
 }).call(${strictBody ? "void 0" : "$module.exports"}); }
 })${__substrateSourceURL(resolvedPath)}`;

package/dist/index.d.ts

@@ -10,7 +10,7 @@
 export { restoreHostGlobals, guestRealmInstalled } from './host-globals';
 export { VirtualFS } from './virtual-fs';
 export type { FSNode, MountedTree, Stats, FSWatcher, WatchListener, WatchEventType } from './virtual-fs';
-export { Runtime, execute } from './runtime';
+export { Runtime, execute, prepareModuleForImage, preparedModuleKey, PREPARED_MODULES_DIR } from './runtime';
 export type { Module, RuntimeOptions, RequireFunction } from './runtime';
 export { createRuntime, WorkerRuntime } from './create-runtime';
 export type { IRuntime, IExecuteResult, CreateRuntimeOptions, IRuntimeOptions, VFSSnapshot } from './runtime-interface';
@@ -31,6 +31,7 @@ export { utilModule as util } from './node-lib/util-module';
 export * as npm from './npm';
 export { PackageManager, install } from './npm';
 export { ServerBridge, getServerBridge, resetServerBridge } from './server-bridge';
+export { PortBridge, getPortBridge } from './port-bridge';
 export type { InitServiceWorkerOptions } from './server-bridge';
 /** What a page's request is answered with, the shape the bridge answers. */
 export type { ResponseData, LoopbackStreamFlow } from './node-lib/http-bridge';