@usebruno/js 0.46.1 → 0.48.0

package/src/sandbox/bundle-libraries.js

@@ -1,8 +1,9 @@
 const rollup = require('rollup');
 const { nodeResolve } = require('@rollup/plugin-node-resolve');
 const commonjs = require('@rollup/plugin-commonjs');
+const json = require('@rollup/plugin-json');
 const fs = require('fs');
-const { terser } = require('rollup-plugin-terser');
+const terser = require('@rollup/plugin-terser').default;
 
 const bundleLibraries = async () => {
   const codeScript = `
@@ -13,6 +14,8 @@ const bundleLibraries = async () => {
     import atob from "atob";
     import * as cryptoJs from 'crypto-js';
     import tv4 from "tv4";
+    import Ajv from "ajv";
+    import addFormats from "ajv-formats";
     globalThis.expect = expect;
     globalThis.assert = assert;
     globalThis.moment = moment;
@@ -20,6 +23,8 @@ const bundleLibraries = async () => {
     globalThis.atob = atob;
     globalThis.Buffer = Buffer;
     globalThis.tv4 = tv4;
+    globalThis.Ajv = Ajv;
+    globalThis.addFormats = addFormats;
     globalThis.requireObject = {
       ...(globalThis.requireObject || {}),
       'chai': { expect, assert },
@@ -28,7 +33,9 @@ const bundleLibraries = async () => {
       'btoa': btoa,
       'atob': atob,
       'crypto-js': cryptoJs,
-      'tv4': tv4
+      'tv4': tv4,
+      'ajv': Ajv,
+      'ajv-formats': addFormats
     };
 `;
 
@@ -56,6 +63,7 @@ const bundleLibraries = async () => {
           browser: false
         }),
         commonjs(),
+        json(),
         terser()
       ]
     },

package/src/sandbox/quickjs/index.js

@@ -5,6 +5,7 @@ const addBrunoResponseShimToContext = require('./shims/bruno-response');
 const addTestShimToContext = require('./shims/test');
 const addLibraryShimsToContext = require('./shims/lib');
 const addLocalModuleLoaderShimToContext = require('./shims/local-module');
+const { getRequireCode } = require('./shims/require');
 const { newQuickJSWASMModule, memoizePromiseFactory } = require('quickjs-emscripten');
 
 // execute `npm run sandbox:bundle-libraries` if the below file doesn't exist
@@ -14,10 +15,9 @@ const { marshallToVm } = require('./utils');
 const addCryptoUtilsShimToContext = require('./shims/lib/crypto-utils');
 const { wrapScriptInClosure, SANDBOX } = require('../../utils/sandbox');
 
-let QuickJSSyncContext;
+let QuickJSModule;
 const loader = memoizePromiseFactory(() => newQuickJSWASMModule());
-const getContext = (opts) => loader().then((mod) => (QuickJSSyncContext = mod.newContext(opts)));
-getContext();
+loader().then((mod) => (QuickJSModule = mod));
 
 const toNumber = (value) => {
   const num = Number(value);
@@ -57,9 +57,8 @@ const executeQuickJsVm = ({ script: externalScript, context: externalContext, sc
     externalScript = removeQuotes(externalScript);
   }
 
-  const vm = QuickJSSyncContext;
-
   try {
+    const vm = QuickJSModule.newContext();
     const { bru, req, res, ...variables } = externalContext;
 
     bru && addBruShimToContext(vm, bru);
@@ -97,51 +96,18 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
   externalScript = externalScript?.trim();
 
   try {
-    const module = await newQuickJSWASMModule();
+    const module = await loader();
     const vm = module.newContext();
 
     // add crypto utilities required by the crypto-js library in bundledCode
     await addCryptoUtilsShimToContext(vm);
 
     const bundledCode = getBundledCode?.toString() || '';
-    const moduleLoaderCode = function () {
-      return `
-        globalThis.require = (mod) => {
-          let lib = globalThis.requireObject[mod];
-          let isModuleAPath = (module) => (module?.startsWith('.') || module?.startsWith?.(bru.cwd()))
-          if (lib) {
-            return lib;
-          }
-          else if (isModuleAPath(mod)) {
-            // fetch local module
-            let localModuleCode = globalThis.__brunoLoadLocalModule(mod);
-
-            // compile local module as iife
-            (function (){
-              const initModuleExportsCode = "const module = { exports: {} };"
-              const copyModuleExportsCode = "\\n;globalThis.requireObject[mod] = module.exports;";
-              const patchedRequire = ${`
-                "\\n;" +
-                "let require = (subModule) => isModuleAPath(subModule) ? globalThis.require(path.resolve(bru.cwd(), mod, '..', subModule)) : globalThis.require(subModule)" +
-                "\\n;" 
-              `}
-              eval(initModuleExportsCode + patchedRequire + localModuleCode + copyModuleExportsCode);
-            })();
-
-            // resolve module
-            return globalThis.requireObject[mod];
-          }
-          else {
-            throw new Error("Cannot find module " + mod);
-          }
-        }
-      `;
-    };
 
     vm.evalCode(
       `
         (${bundledCode})()
-        ${moduleLoaderCode()}
+        ${getRequireCode()}
       `
     );
 
@@ -176,5 +142,6 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
 
 module.exports = {
   executeQuickJsVm,
-  executeQuickJsVmAsync
+  executeQuickJsVmAsync,
+  loader
 };

package/src/sandbox/quickjs/shims/bru.js

@@ -1,5 +1,6 @@
 const { cleanJson, cleanCircularJson } = require('../../../utils');
 const { marshallToVm } = require('../utils');
+const { createPropertyListBridge } = require('../utils/property-list-bridge');
 
 const addBruShimToContext = (vm, bru) => {
   const bruObject = vm.newObject();
@@ -229,11 +230,29 @@ const addBruShimToContext = (vm, bru) => {
   bruRunnerIterationDataObject.dispose();
 
   let visualize = vm.newFunction('visualize', function (type, data) {
-    bru.visualize(vm.dump(type), vm.dump(data));
+    try {
+      // Guard against missing handles: vm.dump() accesses .owner on the handle
+      // to verify its VM context. When called with no args, the handles are
+      // undefined, and vm.dump(undefined) throws a generic
+      // "Cannot read properties of undefined (reading 'owner')" instead of
+      // letting bru.visualize() throw a meaningful error message.
+      bru.visualize(
+        type ? vm.dump(type) : undefined,
+        data ? vm.dump(data) : undefined
+      );
+    } catch (err) {
+      throw vm.newError(err.message || String(err));
+    }
   });
   vm.setProp(bruObject, 'visualize', visualize);
   visualize.dispose();
 
+  let clearVisualizations = vm.newFunction('clearVisualizations', function () {
+    bru.clearVisualizations();
+  });
+  vm.setProp(bruObject, 'clearVisualizations', clearVisualizations);
+  clearVisualizations.dispose();
+
   let getSecretVar = vm.newFunction('getSecretVar', function (key) {
     return marshallToVm(bru.getSecretVar(vm.dump(key)), vm);
   });
@@ -394,6 +413,13 @@ const addBruShimToContext = (vm, bru) => {
   sleep.consume((handle) => vm.setProp(bruObject, 'sleep', handle));
 
   let bruCookiesObject = vm.newObject();
+  const { evalCode: cookiesEvalCode } = createPropertyListBridge(vm, bru.cookies, bruCookiesObject, {
+    globalPath: 'globalThis.bru.cookies',
+    syncReadMethods: ['get', 'has', 'count', 'indexOf', 'toObject', 'toString'],
+    syncReadObjectMethods: ['one', 'all', 'idx', 'toJSON'],
+    asyncWriteMethods: ['add', 'upsert', 'remove', 'clear', 'delete'],
+    withIterators: true
+  });
 
   const _jarFn = vm.newFunction('_jar', () => {
     const nativeJar = bru.cookies.jar();
@@ -571,6 +597,10 @@ const addBruShimToContext = (vm, bru) => {
       }
     };
 
+    {
+      ${cookiesEvalCode}
+    }
+
     globalThis.bru.cookies.jar = () => {
       const _jar = globalThis.bru.cookies._jar();
 

package/src/sandbox/quickjs/shims/bruno-request.js

@@ -1,11 +1,11 @@
 const { marshallToVm } = require('../utils');
+const { createPropertyListBridge } = require('../utils/property-list-bridge');
 
 const addBrunoRequestShimToContext = (vm, req) => {
   const reqObject = vm.newObject();
 
   const url = marshallToVm(req.getUrl(), vm);
   const method = marshallToVm(req.getMethod(), vm);
-  const headers = marshallToVm(req.getHeaders(), vm);
   const body = marshallToVm(req.getBody(), vm);
   const timeout = marshallToVm(req.getTimeout(), vm);
   const name = marshallToVm(req.getName(), vm);
@@ -14,7 +14,6 @@ const addBrunoRequestShimToContext = (vm, req) => {
 
   vm.setProp(reqObject, 'url', url);
   vm.setProp(reqObject, 'method', method);
-  vm.setProp(reqObject, 'headers', headers);
   vm.setProp(reqObject, 'body', body);
   vm.setProp(reqObject, 'timeout', timeout);
   vm.setProp(reqObject, 'name', name);
@@ -23,13 +22,29 @@ const addBrunoRequestShimToContext = (vm, req) => {
 
   url.dispose();
   method.dispose();
-  headers.dispose();
   body.dispose();
   timeout.dispose();
   name.dispose();
   pathParams.dispose();
   tags.dispose();
 
+  // req.headers — plain headers object for backward-compatible bracket access
+  const headersVal = marshallToVm(req.getHeaders(), vm);
+  vm.setProp(reqObject, 'headers', headersVal);
+  headersVal.dispose();
+
+  // req.headerList — PropertyList bridge for structured header operations
+  const headerListObj = vm.newObject();
+  const { evalCode: headersEvalCode } = createPropertyListBridge(vm, req.headerList, headerListObj, {
+    globalPath: 'globalThis.req.headerList',
+    syncReadMethods: ['get', 'has', 'count', 'indexOf', 'toObject', 'toString'],
+    syncReadObjectMethods: ['one', 'all', 'toJSON'],
+    syncWriteMethods: ['add', 'upsert', 'remove', 'clear', 'populate', 'repopulate', 'assimilate'],
+    withIterators: true
+  });
+  vm.setProp(reqObject, 'headerList', headerListObj);
+  headerListObj.dispose();
+
   let getUrl = vm.newFunction('getUrl', function () {
     return marshallToVm(req.getUrl(), vm);
   });
@@ -177,6 +192,12 @@ const addBrunoRequestShimToContext = (vm, req) => {
 
   vm.setProp(vm.global, 'req', reqObject);
   reqObject.dispose();
+
+  // Evaluate iterator code after req is on global (iterators reference globalThis.req.headerList)
+  // Wrapped in a block to avoid const redeclaration conflicts with other evalCode blocks
+  if (headersEvalCode) {
+    vm.evalCode(`{ ${headersEvalCode} }`);
+  }
 };
 
 module.exports = addBrunoRequestShimToContext;

package/src/sandbox/quickjs/shims/bruno-response.js

@@ -1,31 +1,77 @@
 const { marshallToVm } = require('../utils');
+const { createPropertyListBridge } = require('../utils/property-list-bridge');
+
+// Marshal a QuickJS query argument to a host-compatible value.
+// Function handles are wrapped as native callbacks; other values are dumped as-is.
+// Safe because @usebruno/query's get() invokes filters synchronously,
+// so the borrowed arg handle is still valid.
+const toHostQueryArg = (vm, arg) => {
+  if (vm.typeof(arg) === 'function') {
+    return (item) => {
+      const itemHandle = marshallToVm(item, vm);
+      const result = vm.callFunction(arg, vm.undefined, itemHandle);
+      itemHandle.dispose();
+
+      if (result.error) {
+        const error = vm.dump(result.error);
+        result.error.dispose();
+        throw error;
+      }
+
+      const value = vm.dump(result.value);
+      result.value.dispose();
+      return value;
+    };
+  }
+
+  return vm.dump(arg);
+};
 
 const addBrunoResponseShimToContext = (vm, res) => {
-  let resFn = vm.newFunction('res', function (exprStr) {
-    return marshallToVm(res(vm.dump(exprStr)), vm);
+  let resFn = vm.newFunction('res', function (exprStr, ...queryArgs) {
+    const nativeArgs = queryArgs.map((arg) => toHostQueryArg(vm, arg));
+    return marshallToVm(res(vm.dump(exprStr), ...nativeArgs), vm);
   });
 
   const status = marshallToVm(res?.status, vm);
   const statusText = marshallToVm(res?.statusText, vm);
-  const headers = marshallToVm(res?.headers, vm);
   const body = marshallToVm(res?.body, vm);
   const responseTime = marshallToVm(res?.responseTime, vm);
   const url = marshallToVm(res?.url, vm);
 
   vm.setProp(resFn, 'status', status);
   vm.setProp(resFn, 'statusText', statusText);
-  vm.setProp(resFn, 'headers', headers);
   vm.setProp(resFn, 'body', body);
   vm.setProp(resFn, 'responseTime', responseTime);
   vm.setProp(resFn, 'url', url);
 
   status.dispose();
-  headers.dispose();
   body.dispose();
   responseTime.dispose();
   url.dispose();
   statusText.dispose();
 
+  // res.headers — plain headers object for backward-compatible bracket access
+  const headersVal = marshallToVm(res?.headers || {}, vm);
+  vm.setProp(resFn, 'headers', headersVal);
+  headersVal.dispose();
+
+  // res.headerList — read-only PropertyList bridge for structured header operations
+  let resHeadersEvalCode = '';
+  if (res?.headerList) {
+    const headerListObj = vm.newObject();
+    const bridge = createPropertyListBridge(vm, res.headerList, headerListObj, {
+      globalPath: 'globalThis.res.headerList',
+      syncReadMethods: ['get', 'has', 'count', 'indexOf', 'toObject', 'toString'],
+      syncReadObjectMethods: ['one', 'all', 'toJSON'],
+      syncWriteMethods: ['add', 'upsert', 'remove', 'clear', 'populate', 'repopulate', 'assimilate'],
+      withIterators: true
+    });
+    resHeadersEvalCode = bridge.evalCode;
+    vm.setProp(resFn, 'headerList', headerListObj);
+    headerListObj.dispose();
+  }
+
   let getStatusText = vm.newFunction('getStatusText', function () {
     return marshallToVm(res.getStatusText(), vm);
   });
@@ -82,6 +128,12 @@ const addBrunoResponseShimToContext = (vm, res) => {
 
   vm.setProp(vm.global, 'res', resFn);
   resFn.dispose();
+
+  // Evaluate iterator code after res is on global (iterators reference globalThis.res.headerList)
+  // Wrapped in a block to avoid const redeclaration conflicts with req.headerList's evalCode
+  if (resHeadersEvalCode) {
+    vm.evalCode(`{ ${resHeadersEvalCode} }`);
+  }
 };
 
 module.exports = addBrunoResponseShimToContext;

package/src/sandbox/quickjs/shims/bruno-response.spec.js

@@ -0,0 +1,91 @@
+const { describe, it, expect, beforeAll, beforeEach, afterEach, afterAll } = require('@jest/globals');
+const { newQuickJSWASMModule } = require('quickjs-emscripten');
+const addBrunoResponseShimToContext = require('./bruno-response');
+
+describe('bruno response shim', () => {
+  let vm, module;
+
+  beforeAll(async () => {
+    module = await newQuickJSWASMModule();
+  });
+
+  beforeEach(() => {
+    vm = module.newContext();
+  });
+
+  afterEach(() => {
+    if (vm) {
+      try {
+        vm.dispose();
+      } catch (err) {
+        console.error('Error disposing vm', err);
+      }
+      vm = null;
+    }
+  });
+
+  afterAll(() => {
+    if (module) {
+      try {
+        module.dispose();
+      } catch (err) {
+        console.error('Error disposing module', err);
+      }
+      module = null;
+    }
+  });
+
+  it('forwards response query filter callbacks in safe mode', () => {
+    const resources = [
+      { id: 'test', value: 1 },
+      { id: 'other', value: 2 }
+    ];
+    const response = Object.assign(
+      (expr, filter) => {
+        expect(expr).toBe('resources[?].id');
+        return resources.filter(filter).map((item) => item.id);
+      },
+      { status: 200, statusText: 'OK', headers: {}, body: { resources } }
+    );
+
+    addBrunoResponseShimToContext(vm, response);
+
+    const result = vm.evalCode(`
+      res('resources[?].id', r => r.id === 'test')
+    `);
+
+    const valueHandle = vm.unwrapResult(result);
+    const filtered = vm.dump(valueHandle);
+    valueHandle.dispose();
+
+    expect(filtered).toEqual(['test']);
+  });
+
+  it('still supports object predicates in safe mode', () => {
+    const resources = [
+      { id: 'test', value: 1 },
+      { id: 'other', value: 2 }
+    ];
+    const response = Object.assign(
+      (expr, predicate) => {
+        expect(expr).toBe('resources[?].id');
+        return resources.filter((item) =>
+          Object.entries(predicate).every(([key, value]) => item[key] === value)
+        ).map((item) => item.id);
+      },
+      { status: 200, statusText: 'OK', headers: {}, body: { resources } }
+    );
+
+    addBrunoResponseShimToContext(vm, response);
+
+    const result = vm.evalCode(`
+      res('resources[?].id', { id: 'other' })
+    `);
+
+    const valueHandle = vm.unwrapResult(result);
+    const filtered = vm.dump(valueHandle);
+    valueHandle.dispose();
+
+    expect(filtered).toEqual(['other']);
+  });
+});

package/src/sandbox/quickjs/shims/lib/uuid.spec.js

@@ -0,0 +1,166 @@
+const { describe, it, expect, beforeAll, beforeEach, afterEach, afterAll } = require('@jest/globals');
+const { newQuickJSWASMModule } = require('quickjs-emscripten');
+const { validate: uuidValidate, version: uuidVersion } = require('uuid');
+const addUuidShimToContext = require('./uuid');
+const { addRequireShimToContext } = require('../require');
+const { createEvalHelper } = require('../../utils/test-helpers');
+
+describe('uuid shim tests', () => {
+  let vm, module, evalAndDump;
+
+  beforeAll(async () => {
+    module = await newQuickJSWASMModule();
+  });
+
+  beforeEach(async () => {
+    vm = module.newContext();
+    evalAndDump = createEvalHelper(vm);
+    await addUuidShimToContext(vm);
+    addRequireShimToContext(vm, { enableLocalModules: false });
+  });
+
+  afterEach(() => {
+    if (vm) {
+      try {
+        vm.dispose();
+      } catch (err) {
+        // Ignore disposal errors
+      }
+      vm = null;
+    }
+  });
+
+  afterAll(() => {
+    if (module) {
+      try {
+        module.dispose();
+      } catch (err) {
+        // Ignore disposal errors
+      }
+      module = null;
+    }
+  });
+
+  /**
+   * Validates that a string is a valid UUID of the expected version
+   */
+  function expectUuidVersion(uuid, expectedVersion) {
+    expect(uuidValidate(uuid)).toBe(true);
+    expect(uuidVersion(uuid)).toBe(expectedVersion);
+  }
+
+  describe('uuid version functions', () => {
+    const versionTests = [
+      { fn: 'v1', version: 1 },
+      { fn: 'v4', version: 4 },
+      { fn: 'v6', version: 6, note: 'RFC 9562' },
+      { fn: 'v7', version: 7, note: 'RFC 9562' }
+    ];
+
+    it.each(versionTests)('$fn should generate valid uuid and be accessible via require', ({ fn, version }) => {
+      // Test direct access
+      const directUuid = evalAndDump(`globalThis.uuid.${fn}()`);
+      expectUuidVersion(directUuid, version);
+
+      // Test require with destructuring
+      const requireUuid = evalAndDump(`const { ${fn} } = require('uuid'); ${fn}()`);
+      expectUuidVersion(requireUuid, version);
+    });
+
+    it('v7 should be accessible with alias pattern (v7: uuidv7) - issue #7333', () => {
+      const uuid = evalAndDump(`
+        const { v7: uuidv7 } = require('uuid');
+        uuidv7();
+      `);
+      expectUuidVersion(uuid, 7);
+    });
+
+    it('v7 should generate time-ordered uuids', () => {
+      const [uuid1, uuid2] = evalAndDump(`
+        const { v7 } = require('uuid');
+        [v7(), v7()];
+      `);
+      // v7 UUIDs are lexicographically sortable by design (timestamp in most significant bits)
+      expect(uuid1 <= uuid2).toBe(true);
+    });
+  });
+
+  describe('name-based uuid functions (v3, v5)', () => {
+    const DNS_NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+
+    it.each([
+      { fn: 'v3', version: 3 },
+      { fn: 'v5', version: 5 }
+    ])('$fn should generate valid uuid with namespace', ({ fn, version }) => {
+      const uuid = evalAndDump(`
+        const { ${fn} } = require('uuid');
+        ${fn}('example.com', '${DNS_NAMESPACE}');
+      `);
+      expectUuidVersion(uuid, version);
+    });
+  });
+
+  describe('conversion functions', () => {
+    it('should convert between v1 and v6 using v1ToV6 and v6ToV1', () => {
+      const [v1Uuid, v6FromV1, v6Uuid, v1FromV6] = evalAndDump(`
+        const { v1, v6, v1ToV6, v6ToV1 } = require('uuid');
+        const v1Uuid = v1();
+        const v6Uuid = v6();
+        [v1Uuid, v1ToV6(v1Uuid), v6Uuid, v6ToV1(v6Uuid)];
+      `);
+
+      expectUuidVersion(v1Uuid, 1);
+      expectUuidVersion(v6FromV1, 6);
+      expectUuidVersion(v6Uuid, 6);
+      expectUuidVersion(v1FromV6, 1);
+    });
+  });
+
+  describe('utility functions', () => {
+    it('should validate uuids correctly', () => {
+      const [isValid, isInvalid] = evalAndDump(`
+        const { v4, validate } = require('uuid');
+        [validate(v4()), validate('not-a-uuid')];
+      `);
+      expect(isValid).toBe(true);
+      expect(isInvalid).toBe(false);
+    });
+
+    it('should detect uuid version correctly', () => {
+      const [v4Version, v7Version] = evalAndDump(`
+        const { v4, v7, version } = require('uuid');
+        [version(v4()), version(v7())];
+      `);
+      expect(v4Version).toBe(4);
+      expect(v7Version).toBe(7);
+    });
+
+    it('should parse and stringify uuid', () => {
+      const [original, stringified, isObject, length] = evalAndDump(`
+        const { v4, parse, stringify } = require('uuid');
+        const original = v4();
+        const parsed = parse(original);
+        [original, stringify(parsed), typeof parsed === 'object', Object.keys(parsed).length];
+      `);
+      expect(original).toBe(stringified);
+      expect(isObject).toBe(true);
+      expect(length).toBe(16);
+    });
+  });
+
+  describe('issue #7333 regression test', () => {
+    it('should work with the exact pattern from the bug report', () => {
+      const [typeOfFn, id1, id2] = evalAndDump(`
+        const { v7: uuidv7 } = require('uuid');
+        const id1 = uuidv7();
+        const id2 = uuidv7();
+        [typeof uuidv7, id1, id2];
+      `);
+
+      expect(typeOfFn).toBe('function');
+      expectUuidVersion(id1, 7);
+      expectUuidVersion(id2, 7);
+      expect(id1).not.toBe(id2);
+    });
+  });
+});

package/src/sandbox/quickjs/shims/require.js

@@ -0,0 +1,56 @@
+/**
+ * Returns JavaScript code that sets up the require() function in the QuickJS VM.
+ * This module loader looks up modules from globalThis.requireObject and optionally
+ * supports loading local modules if the necessary context (bru.cwd, __brunoLoadLocalModule) is available.
+ *
+ * @param {Object} options
+ * @param {boolean} options.enableLocalModules - Whether to enable local module loading (requires bru context)
+ * @returns {string} JavaScript code to eval in the VM
+ */
+function getRequireCode() {
+  return `
+    globalThis.require = (mod) => {
+      let lib = globalThis.requireObject[mod];
+      let isModuleAPath = (module) => (module?.startsWith('.') || (typeof bru !== 'undefined' && module?.startsWith(bru.cwd())))
+      if (lib) {
+        return lib;
+      }
+      else if (isModuleAPath(mod)) {
+        // fetch local module
+        let localModuleCode = globalThis.__brunoLoadLocalModule(mod);
+
+        // compile local module as iife
+        (function (){
+          const initModuleExportsCode = "const module = { exports: {} };"
+          const copyModuleExportsCode = "\\n;globalThis.requireObject[mod] = module.exports;";
+          const patchedRequire = ${`
+            "\\n;" +
+            "let require = (subModule) => isModuleAPath(subModule) ? globalThis.require(path.resolve(bru.cwd(), mod, '..', subModule)) : globalThis.require(subModule)" +
+            "\\n;"
+          `}
+          eval(initModuleExportsCode + patchedRequire + localModuleCode + copyModuleExportsCode);
+        })();
+
+        // resolve module
+        return globalThis.requireObject[mod];
+      }
+      else {
+        throw new Error("Cannot find module " + mod);
+      }
+    }
+  `;
+}
+
+/**
+ * Adds the require() function to a QuickJS VM context
+ * @param {Object} vm - QuickJS VM context
+ * @param {Object} options - Options passed to getRequireCode
+ */
+function addRequireShimToContext(vm) {
+  vm.evalCode(getRequireCode());
+}
+
+module.exports = {
+  getRequireCode,
+  addRequireShimToContext
+};