@bash0816/claude-code 2.1.241 → 2.1.245

package/lib/bunfs-extract.js

@@ -0,0 +1,205 @@
+'use strict';
+
+const { openSync, readSync, closeSync, fstatSync, mkdirSync, writeFileSync, readdirSync, statSync, rmSync } = require('node:fs');
+const path = require('node:path');
+
+const TRAILER = Buffer.from('\n---- Bun! ----\n');
+const OFFSETS_STRUCT_SIZE = 32;
+const MODULE_TABLE_ENTRY_SIZE = 52;
+const SCAN_CHUNK_SIZE = 1024 * 1024;
+const NAPI_LOADER = 10;
+
+function readRange(fd, offset, length) {
+  const buf = Buffer.alloc(length);
+  const bytesRead = readSync(fd, buf, 0, length, offset);
+  if (bytesRead !== length) {
+    throw new Error(`bunfs-extract: short read at offset ${offset} (expected ${length}, got ${bytesRead})`);
+  }
+  return buf;
+}
+
+function findTrailerOffset(fd, fileSize) {
+  for (let end = fileSize; end > 0; end -= SCAN_CHUNK_SIZE) {
+    const start = Math.max(0, end - SCAN_CHUNK_SIZE - TRAILER.length);
+    const len = end - start;
+    const buf = readRange(fd, start, len);
+    const idx = buf.lastIndexOf(TRAILER);
+    if (idx >= 0) return start + idx;
+  }
+  throw new Error('bunfs-extract: StandaloneModuleGraph trailer not found');
+}
+
+function isSafeUint(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+
+function discoverModuleGraph(sourceBin) {
+  const fd = openSync(sourceBin, 'r');
+  try {
+    const fileSize = fstatSync(fd).size;
+    const trailerOffset = findTrailerOffset(fd, fileSize);
+
+    const offsetsStructStart = trailerOffset - OFFSETS_STRUCT_SIZE;
+    if (offsetsStructStart < 0) throw new Error('bunfs-extract: invalid trailer position');
+    const offsetsBuf = readRange(fd, offsetsStructStart, OFFSETS_STRUCT_SIZE);
+    const byteCount = Number(offsetsBuf.readBigUInt64LE(0));
+    const modulesOffset = offsetsBuf.readUInt32LE(8);
+    const modulesLength = offsetsBuf.readUInt32LE(12);
+    const entryPointId = offsetsBuf.readUInt32LE(16);
+
+    if (!isSafeUint(byteCount) || !isSafeUint(modulesOffset) || !isSafeUint(modulesLength)) {
+      throw new Error('bunfs-extract: unsafe integer in Offsets struct');
+    }
+    if (modulesLength % MODULE_TABLE_ENTRY_SIZE !== 0) {
+      throw new Error('bunfs-extract: module table length is not a multiple of entry size');
+    }
+
+    const dataStart = offsetsStructStart - byteCount;
+    if (dataStart < 0) throw new Error('bunfs-extract: computed dataStart is negative');
+
+    const numModules = modulesLength / MODULE_TABLE_ENTRY_SIZE;
+    if (numModules <= 0) throw new Error('bunfs-extract: module table is empty');
+    if (!(entryPointId >= 0 && entryPointId < numModules)) {
+      throw new Error(`bunfs-extract: entry_point_id ${entryPointId} out of range (numModules=${numModules})`);
+    }
+    if (modulesOffset + modulesLength > byteCount) {
+      throw new Error('bunfs-extract: module table extends beyond byte_count');
+    }
+
+    const modTableBuf = readRange(fd, dataStart + modulesOffset, modulesLength);
+
+    const modules = [];
+    const seenNames = new Set();
+    let entryName = null;
+    let entryModule = null;
+    for (let i = 0; i < numModules; i += 1) {
+      const base = i * MODULE_TABLE_ENTRY_SIZE;
+      const nameOff = modTableBuf.readUInt32LE(base);
+      const nameLen = modTableBuf.readUInt32LE(base + 4);
+      const contOff = modTableBuf.readUInt32LE(base + 8);
+      const contLen = modTableBuf.readUInt32LE(base + 12);
+      const loader = modTableBuf[base + 49];
+
+      if (!isSafeUint(nameOff) || !isSafeUint(nameLen) || !isSafeUint(contOff) || !isSafeUint(contLen)) {
+        throw new Error(`bunfs-extract: unsafe integer in module table entry ${i}`);
+      }
+      if (nameOff + nameLen > byteCount) {
+        throw new Error(`bunfs-extract: module ${i} name range out of bounds`);
+      }
+      if (contOff + contLen > byteCount) {
+        throw new Error(`bunfs-extract: module ${i} content range out of bounds`);
+      }
+
+      const name = readRange(fd, dataStart + nameOff, nameLen).toString('utf-8');
+      if (seenNames.has(name)) {
+        throw new Error(`bunfs-extract: duplicate module name ${name}`);
+      }
+      seenNames.add(name);
+
+      const absContOff = dataStart + contOff;
+      if (i === entryPointId) {
+        entryName = name;
+        entryModule = { name, contOff: absContOff, contLen };
+      }
+      if (loader === NAPI_LOADER) continue; // ネイティブ.nodeバイナリは未使用、展開しない
+      if (contLen === 0) continue;
+
+      modules.push({ name, contOff: absContOff, contLen });
+    }
+
+    if (entryName === null) throw new Error('bunfs-extract: entry module not found');
+
+    return { fd, modules, entryName, entryModule, numModules, byteCount };
+  } catch (error) {
+    closeSync(fd);
+    throw error;
+  }
+}
+
+function relPathFromModuleName(name) {
+  const rel = name.replace(/^\/\$bunfs\/root\//, '');
+  if (rel.includes('..') || path.isAbsolute(rel)) {
+    throw new Error(`bunfs-extract: rejected unsafe module name ${name}`);
+  }
+  return rel;
+}
+
+function extractToProcessOwnedDir(sourceBin, ownedDir) {
+  const graph = discoverModuleGraph(sourceBin);
+  const { fd, modules, entryName } = graph;
+  try {
+    mkdirSync(ownedDir, { recursive: true });
+    for (const mod of modules) {
+      const rel = relPathFromModuleName(mod.name);
+      const outPath = path.resolve(ownedDir, rel);
+      if (path.relative(ownedDir, outPath).startsWith('..')) {
+        throw new Error(`bunfs-extract: path escapes owned dir: ${mod.name}`);
+      }
+      mkdirSync(path.dirname(outPath), { recursive: true });
+      const content = readRange(fd, mod.contOff, mod.contLen);
+      writeFileSync(outPath, content);
+    }
+  } finally {
+    closeSync(fd);
+  }
+  return { entryRelPath: relPathFromModuleName(entryName) };
+}
+
+function cleanupStaleOwnedDirs(workdir, prefix, now = Date.now()) {
+  const maxAgeMs = 24 * 60 * 60 * 1000;
+  let entries;
+  try {
+    entries = readdirSync(workdir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (!entry.name.startsWith(prefix)) continue;
+    const dirPath = path.join(workdir, entry.name);
+    let stats;
+    try {
+      stats = statSync(dirPath);
+    } catch {
+      continue;
+    }
+    if (Number.isFinite(stats.mtimeMs) && now - stats.mtimeMs < maxAgeMs) continue;
+
+    const pidMatch = entry.name.match(/^esm\.(\d+)\./);
+    if (pidMatch) {
+      const pid = Number(pidMatch[1]);
+      if (Number.isInteger(pid) && pid > 0) {
+        try {
+          process.kill(pid, 0);
+          continue; // ESRCH以外(プロセス生存中、またはEPERM等)は削除対象から除外
+        } catch (error) {
+          if (error && error.code !== 'ESRCH') continue;
+        }
+      }
+    }
+    try {
+      rmSync(dirPath, { recursive: true, force: true });
+    } catch {}
+  }
+}
+
+function prepareProcessOwnedDir(sourceBin, workdir) {
+  const dirName = `esm.${process.pid}.${Date.now().toString(36)}.${Math.random().toString(36).slice(2)}.bare-dir`;
+  cleanupStaleOwnedDirs(workdir, 'esm.');
+  const ownedDir = path.join(workdir, dirName);
+  const { entryRelPath } = extractToProcessOwnedDir(sourceBin, ownedDir);
+  return { ownedDir, entryRelPath };
+}
+
+function readEntryContentPrefix(fd, entryModule, maxLength = 256) {
+  const length = Math.min(entryModule.contLen, maxLength);
+  return readRange(fd, entryModule.contOff, length);
+}
+
+module.exports = {
+  discoverModuleGraph,
+  extractToProcessOwnedDir,
+  cleanupStaleOwnedDirs,
+  prepareProcessOwnedDir,
+  readEntryContentPrefix,
+};

package/lib/bunfs-extract.test.js

@@ -0,0 +1,265 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const {
+  discoverModuleGraph,
+  extractToProcessOwnedDir,
+  cleanupStaleOwnedDirs,
+  prepareProcessOwnedDir,
+  readEntryContentPrefix,
+} = require('./bunfs-extract.js');
+
+const TRAILER = '\n---- Bun! ----\n';
+
+// StandaloneModuleGraphの最小合成バイナリを構築する。
+// レイアウト: [preamble padding][module contents][module table][Offsets(32byte)][trailer]
+function buildSyntheticBinary({ modules, entryPointId, corruptTrailer = false, preamblePadding = 64 }) {
+  const nameBuffers = modules.map((m) => Buffer.from(m.name, 'utf8'));
+  const contentBuffers = modules.map((m) => Buffer.from(m.content ?? '', 'utf8'));
+
+  const dataParts = [];
+  const nameOffsets = [];
+  const contOffsets = [];
+  let cursor = 0;
+  for (let i = 0; i < modules.length; i += 1) {
+    nameOffsets.push(cursor);
+    dataParts.push(nameBuffers[i]);
+    cursor += nameBuffers[i].length;
+  }
+  for (let i = 0; i < modules.length; i += 1) {
+    contOffsets.push(cursor);
+    dataParts.push(contentBuffers[i]);
+    cursor += contentBuffers[i].length;
+  }
+  const byteCountBeforeTable = cursor;
+
+  const MODULE_TABLE_ENTRY_SIZE = 52;
+  const modTable = Buffer.alloc(MODULE_TABLE_ENTRY_SIZE * modules.length);
+  for (let i = 0; i < modules.length; i += 1) {
+    const base = i * MODULE_TABLE_ENTRY_SIZE;
+    modTable.writeUInt32LE(nameOffsets[i], base);
+    modTable.writeUInt32LE(nameBuffers[i].length, base + 4);
+    modTable.writeUInt32LE(contOffsets[i], base + 8);
+    modTable.writeUInt32LE(contentBuffers[i].length, base + 12);
+    modTable[base + 49] = modules[i].loader ?? 1; // 1 = js
+  }
+  const modulesOffset = byteCountBeforeTable;
+  const modulesLength = modTable.length;
+  const byteCount = byteCountBeforeTable + modulesLength;
+
+  const offsetsBuf = Buffer.alloc(32);
+  offsetsBuf.writeBigUInt64LE(BigInt(byteCount), 0);
+  offsetsBuf.writeUInt32LE(modulesOffset, 8);
+  offsetsBuf.writeUInt32LE(modulesLength, 12);
+  offsetsBuf.writeUInt32LE(entryPointId, 16);
+
+  const trailerBuf = Buffer.from(corruptTrailer ? '\n---- NOT BUN ----\n' : TRAILER, 'utf8');
+
+  return Buffer.concat([
+    Buffer.alloc(preamblePadding),
+    ...dataParts,
+    modTable,
+    offsetsBuf,
+    trailerBuf,
+  ]);
+}
+
+function writeTempBinary(buf) {
+  const file = path.join(os.tmpdir(), `bunfs-extract-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.bin`);
+  fs.writeFileSync(file, buf);
+  return file;
+}
+
+test('discoverModuleGraph parses a well-formed synthetic StandaloneModuleGraph', () => {
+  const buf = buildSyntheticBinary({
+    modules: [
+      { name: '/$bunfs/root/cli', content: 'console.log("entry")' },
+      { name: '/$bunfs/root/chunk-a.js', content: 'export const a = 1;' },
+    ],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  try {
+    const graph = discoverModuleGraph(file);
+    try {
+      assert.equal(graph.numModules, 2);
+      assert.equal(graph.entryName, '/$bunfs/root/cli');
+      assert.equal(graph.modules.length, 2);
+      const prefix = readEntryContentPrefix(graph.fd, graph.entryModule, 256).toString('utf8');
+      assert.equal(prefix, 'console.log("entry")');
+    } finally {
+      fs.closeSync(graph.fd);
+    }
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('discoverModuleGraph rejects a binary with a corrupted trailer', () => {
+  const buf = buildSyntheticBinary({
+    modules: [{ name: '/$bunfs/root/cli', content: 'x' }],
+    entryPointId: 0,
+    corruptTrailer: true,
+  });
+  const file = writeTempBinary(buf);
+  try {
+    assert.throws(() => discoverModuleGraph(file), /trailer not found/);
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('discoverModuleGraph rejects entry_point_id out of range', () => {
+  const buf = buildSyntheticBinary({
+    modules: [{ name: '/$bunfs/root/cli', content: 'x' }],
+    entryPointId: 5, // 存在しないインデックス
+  });
+  const file = writeTempBinary(buf);
+  try {
+    assert.throws(() => discoverModuleGraph(file), /entry_point_id.*out of range/);
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('discoverModuleGraph rejects duplicate module names', () => {
+  const buf = buildSyntheticBinary({
+    modules: [
+      { name: '/$bunfs/root/cli', content: 'a' },
+      { name: '/$bunfs/root/cli', content: 'b' },
+    ],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  try {
+    assert.throws(() => discoverModuleGraph(file), /duplicate module name/);
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('discoverModuleGraph skips NAPI loader modules from extraction list', () => {
+  const buf = buildSyntheticBinary({
+    modules: [
+      { name: '/$bunfs/root/cli', content: 'x' },
+      { name: '/$bunfs/root/native.node', content: 'BINARY', loader: 10 },
+    ],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  try {
+    const graph = discoverModuleGraph(file);
+    try {
+      assert.equal(graph.modules.length, 1);
+      assert.equal(graph.modules[0].name, '/$bunfs/root/cli');
+    } finally {
+      fs.closeSync(graph.fd);
+    }
+  } finally {
+    fs.rmSync(file, { force: true });
+  }
+});
+
+test('extractToProcessOwnedDir rejects path traversal via module name', () => {
+  const buf = buildSyntheticBinary({
+    modules: [{ name: '/$bunfs/root/../../etc/passwd', content: 'evil' }],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  const ownedDir = path.join(os.tmpdir(), `bunfs-extract-owned-${process.pid}-${Date.now()}`);
+  try {
+    assert.throws(() => extractToProcessOwnedDir(file, ownedDir), /rejected unsafe module name|escapes owned dir/);
+  } finally {
+    fs.rmSync(file, { force: true });
+    fs.rmSync(ownedDir, { recursive: true, force: true });
+  }
+});
+
+test('extractToProcessOwnedDir writes module contents to the owned directory', () => {
+  const buf = buildSyntheticBinary({
+    modules: [
+      { name: '/$bunfs/root/cli', content: 'entry-content' },
+      { name: '/$bunfs/root/chunk-a.js', content: 'chunk-content' },
+    ],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  const ownedDir = path.join(os.tmpdir(), `bunfs-extract-owned-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  try {
+    const { entryRelPath } = extractToProcessOwnedDir(file, ownedDir);
+    assert.equal(entryRelPath, 'cli');
+    assert.equal(fs.readFileSync(path.join(ownedDir, 'cli'), 'utf8'), 'entry-content');
+    assert.equal(fs.readFileSync(path.join(ownedDir, 'chunk-a.js'), 'utf8'), 'chunk-content');
+  } finally {
+    fs.rmSync(file, { force: true });
+    fs.rmSync(ownedDir, { recursive: true, force: true });
+  }
+});
+
+test('cleanupStaleOwnedDirs keeps directories whose PID is still alive', () => {
+  const workdir = path.join(os.tmpdir(), `bunfs-cleanup-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(workdir, { recursive: true });
+  const aliveDir = path.join(workdir, `esm.${process.pid}.old.marker.bare-dir`);
+  fs.mkdirSync(aliveDir);
+  const oldTime = new Date(Date.now() - 48 * 60 * 60 * 1000);
+  fs.utimesSync(aliveDir, oldTime, oldTime);
+  try {
+    cleanupStaleOwnedDirs(workdir, 'esm.');
+    assert.ok(fs.existsSync(aliveDir), 'directory owned by a live PID must not be removed even if old');
+  } finally {
+    fs.rmSync(workdir, { recursive: true, force: true });
+  }
+});
+
+test('cleanupStaleOwnedDirs removes old directories whose PID is dead', () => {
+  const workdir = path.join(os.tmpdir(), `bunfs-cleanup-test-${process.pid}-${Date.now()}-dead`);
+  fs.mkdirSync(workdir, { recursive: true });
+  // 実在しない可能性が極めて高い巨大なPID番号を使う
+  const deadDir = path.join(workdir, `esm.999999999.old.marker.bare-dir`);
+  fs.mkdirSync(deadDir);
+  const oldTime = new Date(Date.now() - 48 * 60 * 60 * 1000);
+  fs.utimesSync(deadDir, oldTime, oldTime);
+  try {
+    cleanupStaleOwnedDirs(workdir, 'esm.');
+    assert.ok(!fs.existsSync(deadDir), 'stale directory owned by a dead PID should be removed');
+  } finally {
+    fs.rmSync(workdir, { recursive: true, force: true });
+  }
+});
+
+test('cleanupStaleOwnedDirs keeps recently modified directories regardless of PID', () => {
+  const workdir = path.join(os.tmpdir(), `bunfs-cleanup-test-${process.pid}-${Date.now()}-recent`);
+  fs.mkdirSync(workdir, { recursive: true });
+  const recentDir = path.join(workdir, `esm.999999998.recent.marker.bare-dir`);
+  fs.mkdirSync(recentDir);
+  try {
+    cleanupStaleOwnedDirs(workdir, 'esm.');
+    assert.ok(fs.existsSync(recentDir), 'recently created directory must not be removed regardless of PID liveness');
+  } finally {
+    fs.rmSync(workdir, { recursive: true, force: true });
+  }
+});
+
+test('prepareProcessOwnedDir extracts into a unique directory and returns entry path', () => {
+  const buf = buildSyntheticBinary({
+    modules: [{ name: '/$bunfs/root/cli', content: 'hello' }],
+    entryPointId: 0,
+  });
+  const file = writeTempBinary(buf);
+  const workdir = path.join(os.tmpdir(), `bunfs-prepare-test-${process.pid}-${Date.now()}`);
+  fs.mkdirSync(workdir, { recursive: true });
+  try {
+    const { ownedDir, entryRelPath } = prepareProcessOwnedDir(file, workdir);
+    assert.ok(ownedDir.startsWith(workdir));
+    assert.equal(entryRelPath, 'cli');
+    assert.equal(fs.readFileSync(path.join(ownedDir, 'cli'), 'utf8'), 'hello');
+  } finally {
+    fs.rmSync(file, { force: true });
+    fs.rmSync(workdir, { recursive: true, force: true });
+  }
+});

package/lib/bunfs-vm-guard.mjs

@@ -0,0 +1,116 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const realVm = require('node:vm');
+
+function injectBunIntoContext(context) {
+  if (!context || typeof context !== 'object') return context;
+  try {
+    if (!Object.prototype.hasOwnProperty.call(context, '__claudeYaml')) {
+      Object.defineProperty(context, '__claudeYaml', {
+        value: globalThis.__claudeYaml,
+        configurable: true,
+        writable: true,
+      });
+    }
+    if (!Object.prototype.hasOwnProperty.call(context, '__claudeBunShim')) {
+      Object.defineProperty(context, '__claudeBunShim', {
+        value: globalThis.__claudeBunShim,
+        configurable: true,
+        writable: true,
+      });
+    }
+    if (!Object.prototype.hasOwnProperty.call(context, '__claudeBun')) {
+      Object.defineProperty(context, '__claudeBun', {
+        value: globalThis.__claudeBunShim,
+        configurable: true,
+        writable: true,
+      });
+    }
+    if (Object.prototype.hasOwnProperty.call(context, 'Bun')) {
+      if (context.Bun && typeof context.Bun === 'object' && context.Bun !== globalThis.Bun) {
+        try {
+          context.Bun = globalThis.Bun;
+        } catch {
+          Object.defineProperty(context, 'Bun', {
+            value: globalThis.Bun,
+            configurable: true,
+            writable: true,
+          });
+        }
+      }
+      if (!context.Bun || typeof context.Bun !== 'object') {
+        Object.defineProperty(context, 'Bun', {
+          value: globalThis.Bun,
+          configurable: true,
+          writable: true,
+        });
+      }
+    } else {
+      Object.defineProperty(context, 'Bun', {
+        value: globalThis.Bun,
+        configurable: true,
+        writable: true,
+      });
+    }
+    if (context.Bun && globalThis.__claudeYaml) {
+      context.Bun.YAML = globalThis.__claudeYaml;
+    }
+  } catch {}
+  return context;
+}
+
+if (!realVm.__claudeBunShimPatched) {
+  const originalCreateContext = realVm.createContext.bind(realVm);
+  const originalRunInNewContext = realVm.runInNewContext.bind(realVm);
+  const originalRunInContext = realVm.runInContext.bind(realVm);
+  const originalRunInThisContext = realVm.runInThisContext && realVm.runInThisContext.bind(realVm);
+  const scriptProto = realVm.Script && realVm.Script.prototype;
+
+  realVm.createContext = (contextObject, ...rest) =>
+    originalCreateContext(injectBunIntoContext(contextObject), ...rest);
+  realVm.runInNewContext = (code, contextObject, ...rest) =>
+    originalRunInNewContext(code, injectBunIntoContext(contextObject), ...rest);
+  realVm.runInContext = (code, contextObject, ...rest) =>
+    originalRunInContext(code, injectBunIntoContext(contextObject), ...rest);
+  if (originalRunInThisContext) {
+    realVm.runInThisContext = (code, ...rest) => originalRunInThisContext(code, ...rest);
+  }
+
+  if (scriptProto && !scriptProto.__claudeBunShimPatched) {
+    const originalScriptRunInContext = scriptProto.runInContext;
+    const originalScriptRunInNewContext = scriptProto.runInNewContext;
+    const originalScriptRunInThisContext = scriptProto.runInThisContext;
+
+    scriptProto.runInContext = function (contextObject, ...rest) {
+      return originalScriptRunInContext.call(this, injectBunIntoContext(contextObject), ...rest);
+    };
+    scriptProto.runInNewContext = function (contextObject, ...rest) {
+      return originalScriptRunInNewContext.call(this, injectBunIntoContext(contextObject), ...rest);
+    };
+    if (originalScriptRunInThisContext) {
+      scriptProto.runInThisContext = function (...rest) {
+        return originalScriptRunInThisContext.call(this, ...rest);
+      };
+    }
+
+    Object.defineProperty(scriptProto, '__claudeBunShimPatched', { value: true });
+  }
+
+  Object.defineProperty(realVm, '__claudeBunShimPatched', { value: true });
+}
+
+export const createContext = realVm.createContext;
+export const isContext = realVm.isContext;
+export const runInContext = realVm.runInContext;
+export const runInNewContext = realVm.runInNewContext;
+export const runInThisContext = realVm.runInThisContext;
+export const createScript = realVm.createScript;
+export const compileFunction = realVm.compileFunction;
+export const measureMemory = realVm.measureMemory;
+export const Script = realVm.Script;
+export const SourceTextModule = realVm.SourceTextModule;
+export const SyntheticModule = realVm.SyntheticModule;
+export const constants = realVm.constants;
+
+export default realVm;