@usebruno/js 0.50.0 → 0.51.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usebruno/js",
-  "version": "0.50.0",
+  "version": "0.51.0",
   "license": "MIT",
   "main": "src/index.js",
   "files": [
@@ -14,7 +14,7 @@
     "prepack": "npm run test"
   },
   "dependencies": {
-    "@usebruno/common": "0.24.0",
+    "@usebruno/common": "0.25.0",
     "@usebruno/query": "0.2.2",
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",

package/src/bru.js

@@ -500,13 +500,22 @@ class Bru {
     }
     if (type === 'table') {
       if (data?.provider === 'ag-grid') {
-        if (!data?.props?.columnDefinitions) {
-          throw new Error(`columns definitions are required`);
+        const { columnDefinitions, rowData } = data?.props || {};
+        let error;
+        if (rowData == null) {
+          error = 'Row data is required. Please provide an array of objects for table rendering.';
+        } else if (!Array.isArray(rowData)) {
+          error = `Invalid row data: expected an array of objects, received ${typeof rowData}.`;
+        } else if (columnDefinitions == null) {
+          error = 'Column definitions are required.';
+        } else if (!Array.isArray(columnDefinitions)) {
+          error = `Invalid column definitions: expected an array, received ${typeof columnDefinitions}.`;
         }
-        if (!data?.props?.rowData) {
-          throw new Error(`row data is required`);
+        if (error) {
+          this.setVisualizations({ uid: uuid(), type, data: { ...data, error } });
+        } else {
+          this.setVisualizations({ uid: uuid(), type, data });
         }
-        this.setVisualizations({ uid: uuid(), type, data });
       } else if (data?.provider === 'react-table') {
         this.setVisualizations({ uid: uuid(), type, data });
       }

package/src/bruno-response.js

@@ -32,7 +32,10 @@ class BrunoResponse {
   }
 
   getHeader(name) {
-    return this.res && this.res.headers ? this.res.headers[name] : null;
+    if (typeof name !== 'string' || !this.res?.headers) {
+      return null;
+    }
+    return this.res.headers[name.toLowerCase()];
   }
 
   getHeaders() {

package/src/runtime/script-runtime.js

@@ -32,7 +32,7 @@ class ScriptRuntime {
     collectionName
   ) {
     let visualizations = [];
-    let setVisualizations = (data) => {
+    const setVisualizations = (data) => {
       if (data.type === VISUALIZATION_CLEAR) {
         visualizations = [];
       } else {
@@ -183,7 +183,7 @@ class ScriptRuntime {
     collectionName
   ) {
     let visualizations = [];
-    let setVisualizations = (data) => {
+    const setVisualizations = (data) => {
       if (data.type === VISUALIZATION_CLEAR) {
         visualizations = [];
       } else {

package/src/runtime/test-runtime.js

@@ -74,7 +74,8 @@ class TestRuntime {
         collectionVariables: null,
         globalEnvironmentVariables: null,
         results: __brunoTestResults.getResults(),
-        nextRequestName: bru.nextRequest
+        nextRequestName: bru.nextRequest,
+        stopExecution: bru.stopExecution
       };
     }
 
@@ -149,6 +150,7 @@ class TestRuntime {
       oauth2CredentialsToReset: bru.oauth2CredentialsToReset,
       results: cleanJson(__brunoTestResults.getResults()),
       nextRequestName: bru.nextRequest,
+      stopExecution: bru.stopExecution,
       scriptedRequestEntries: cleanJson(bru.scriptedRequestEntries || [])
     };
 

package/src/sandbox/node-vm/cjs-loader.js

@@ -66,7 +66,7 @@ function resolveLocalModulePath(fromDir, moduleName) {
  * @param {Object} options.isolatedContext - The VM isolated context created with vm.createContext()
  * @param {string} options.currentModuleDir - Current module directory for resolving relative paths
  * @param {Map} options.localModuleCache - Cache for loaded modules
- * @param {string[]} options.additionalContextRootsAbsolute - Additional allowed root paths
+ * @param {string[]} options.additionalContextRootsAbsolute - Allowed roots for local file imports
  * @returns {Function} Custom require function
  */
 function createCustomRequire({
@@ -115,6 +115,7 @@ function createCustomRequire({
     return loadNpmModule({
       moduleName,
       collectionPath,
+      currentModuleDir,
       isolatedContext,
       localModuleCache
     });
@@ -269,7 +270,13 @@ function executeModuleInVmContext({
 }
 
 /**
- * Loads an npm module into the vm context
+ * Loads an npm module into the vm context.
+ *
+ * Resolution order matches standard Node.js walk-up:
+ *   1. currentModuleDir/node_modules → walk up parent dirs
+ *   2. collectionPath/node_modules
+ *   3. Bruno's bundled node_modules (final fallback for chai/ajv/axios/etc.)
+ *
  * @param {Object} options - Configuration options
  * @returns {*} The exported content of the loaded module
  * @throws {Error} When module cannot be resolved or loaded
@@ -277,19 +284,22 @@ function executeModuleInVmContext({
 function loadNpmModule({
   moduleName,
   collectionPath,
+  currentModuleDir,
   isolatedContext,
   localModuleCache
 }) {
   let resolvedPath;
 
-  // Module resolution order:
-  // 1. Collection's node_modules (user-installed packages for their collection)
-  // 2. Bruno's node_modules (fallback for built-in dependencies)
-  //
-  // This order ensures user packages take precedence, allowing users to:
-  // - Override Bruno's bundled package versions
-  // - Install collection-specific dependencies
-  if (collectionPath) {
+  if (currentModuleDir) {
+    try {
+      const callerRequire = nodeModule.createRequire(path.join(currentModuleDir, 'package.json'));
+      resolvedPath = callerRequire.resolve(moduleName);
+    } catch {
+      // Not found via walk-up, continue to fallbacks
+    }
+  }
+
+  if (!resolvedPath && collectionPath) {
     try {
       const collectionRequire = nodeModule.createRequire(path.join(collectionPath, 'package.json'));
       resolvedPath = collectionRequire.resolve(moduleName);
@@ -298,7 +308,7 @@ function loadNpmModule({
     }
   }
 
-  // Fall back to Bruno's node_modules
+  // Fall back to Bruno's bundled node_modules
   if (!resolvedPath) {
     try {
       resolvedPath = require.resolve(moduleName, { paths: module.paths });
@@ -320,7 +330,11 @@ function loadNpmModule({
 }
 
 /**
- * Creates require function for npm module dependencies
+ * Creates the require function handed to a loaded npm module. Resolution is
+ * plain Node.js walk-up from the module's own directory — internal relative
+ * requires, sibling packages, and npm-linked / file: dependencies all resolve
+ * the way native `require` would from that location.
+ *
  * @param {Object} options - Configuration options
  * @returns {Function} Custom require function for npm module dependencies
  */

package/src/sandbox/node-vm/index.spec.js

@@ -4,6 +4,36 @@ const path = require('path');
 const os = require('os');
 const { runScriptInNodeVm } = require('./index');
 
+// Windows denies symlink creation without developer mode / admin. Probe once at
+// module load so the dependent tests can be marked skipped in the reporter
+// instead of silently no-oping mid-test.
+const symlinksSupported = (() => {
+  const target = fs.mkdtempSync(path.join(os.tmpdir(), 'bruno-symlink-probe-'));
+  const link = target + '-link';
+  try {
+    fs.symlinkSync(target, link, 'dir');
+    fs.unlinkSync(link);
+    return true;
+  } catch (e) {
+    if (e.code === 'EPERM' || e.code === 'ENOTSUP') return false;
+    throw e;
+  } finally {
+    fs.rmSync(target, { recursive: true, force: true });
+  }
+})();
+const itIfSymlinks = symlinksSupported ? it : it.skip;
+
+const makePkg = (parentDir, pkgName, files) => {
+  const pkgDir = path.join(parentDir, pkgName);
+  fs.mkdirSync(pkgDir, { recursive: true });
+  for (const [relPath, content] of Object.entries(files)) {
+    const filePath = path.join(pkgDir, relPath);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+  }
+  return pkgDir;
+};
+
 describe('node-vm sandbox', () => {
   let testDir;
   let collectionPath;
@@ -240,6 +270,256 @@ describe('node-vm sandbox', () => {
       // Nested module should successfully access the additional root
       expect(context.bru.setVar).toHaveBeenCalledWith('result', true);
     });
+
+    it('should not cross-resolve npm package from a sibling additionalContextRoot when required by a collection script', async () => {
+      // Package lives only in additionalRoot/node_modules — the collection has
+      // no dependency declared for it.
+      const additionalRoot = path.join(testDir, 'shared');
+      makePkg(path.join(additionalRoot, 'node_modules'), 'shared-package', {
+        'index.js': 'module.exports = { fromShared: true };'
+      });
+
+      // A COLLECTION script directly requiring `shared-package` must fail:
+      // native Node walk-up from the collection never reaches a sibling
+      // additional root's node_modules, and cross-root discovery for bare-name
+      // resolution is intentionally not implemented. The supported patterns
+      // are (a) require the package from a shared script that itself lives
+      // inside additionalRoot (see the next test), or (b) declare the dep in
+      // the collection's own package.json.
+      const script = `require('shared-package');`;
+
+      const context = {
+        bru: { setVar: jest.fn() },
+        console: console
+      };
+
+      const scriptingConfig = {
+        additionalContextRoots: [additionalRoot]
+      };
+
+      await expect(
+        runScriptInNodeVm({ script, context, collectionPath, scriptingConfig })
+      ).rejects.toThrow(/Could not resolve module "shared-package"/);
+    });
+
+    it('should resolve npm module required by a shared script in additionalContextRoots', async () => {
+      const additionalRoot = path.join(testDir, 'shared');
+      makePkg(path.join(additionalRoot, 'node_modules'), 'shared-util', {
+        'index.js': 'module.exports = { parse: function(s) { return JSON.parse(s); } };'
+      });
+      fs.writeFileSync(
+        path.join(additionalRoot, 'parser.js'),
+        'const sharedUtil = require("shared-util"); module.exports = { parse: sharedUtil.parse };'
+      );
+
+      // Collection script requires the shared local script, which internally
+      // requires an npm package from the shared root's node_modules
+      const script = `
+        const parser = require('../shared/parser');
+        const result = parser.parse('{"ok":true}');
+        bru.setVar('result', result.ok);
+      `;
+
+      const context = {
+        bru: { setVar: jest.fn() },
+        console: console
+      };
+
+      const scriptingConfig = {
+        additionalContextRoots: [additionalRoot]
+      };
+
+      await runScriptInNodeVm({ script, context, collectionPath, scriptingConfig });
+
+      expect(context.bru.setVar).toHaveBeenCalledWith('result', true);
+    });
+
+    it('should walk up from a nested shared script to find its npm dependency', async () => {
+      // Structure:
+      //   shared/
+      //     node_modules/deep-dep/index.js   ← package hoisted at shared root
+      //     deep/nested/parser.js            ← requires 'deep-dep'
+      const additionalRoot = path.join(testDir, 'shared');
+      const nestedDir = path.join(additionalRoot, 'deep', 'nested');
+      fs.mkdirSync(nestedDir, { recursive: true });
+
+      makePkg(path.join(additionalRoot, 'node_modules'), 'deep-dep', {
+        'index.js': 'module.exports = { walkedUp: true };'
+      });
+
+      fs.writeFileSync(
+        path.join(nestedDir, 'parser.js'),
+        'const dep = require("deep-dep"); module.exports = { ok: dep.walkedUp };'
+      );
+
+      const script = `
+        const parser = require('../shared/deep/nested/parser');
+        bru.setVar('result', parser.ok);
+      `;
+
+      const context = {
+        bru: { setVar: jest.fn() },
+        console: console
+      };
+
+      const scriptingConfig = {
+        additionalContextRoots: [additionalRoot]
+      };
+
+      await runScriptInNodeVm({ script, context, collectionPath, scriptingConfig });
+
+      expect(context.bru.setVar).toHaveBeenCalledWith('result', true);
+    });
+
+    itIfSymlinks('should resolve npm modules when additionalContextRoots points at a symlink', async () => {
+      // Physical location of the shared root
+      const realShared = path.join(testDir, 'real-shared');
+      makePkg(path.join(realShared, 'node_modules'), 'symlinked-lib', {
+        'index.js': 'module.exports = { via: "symlink" };'
+      });
+
+      // Shared script inside the real location that requires the npm package.
+      // Loaded through the symlink below.
+      fs.writeFileSync(
+        path.join(realShared, 'helper.js'),
+        'const pkg = require("symlinked-lib"); module.exports = { via: pkg.via };'
+      );
+
+      // User-facing symlink that Bruno is told to treat as the shared root.
+      const linkedShared = path.join(testDir, 'linked-shared');
+      fs.symlinkSync(realShared, linkedShared, 'dir');
+
+      const script = `
+        const helper = require('../linked-shared/helper');
+        bru.setVar('via', helper.via);
+      `;
+
+      const context = {
+        bru: { setVar: jest.fn() },
+        console: console
+      };
+
+      const scriptingConfig = {
+        additionalContextRoots: [linkedShared]
+      };
+
+      await runScriptInNodeVm({ script, context, collectionPath, scriptingConfig });
+
+      expect(context.bru.setVar).toHaveBeenCalledWith('via', 'symlink');
+    });
+
+    itIfSymlinks('should allow subpath imports into an npm-linked package', async () => {
+      // Physical location of a multi-file package outside every declared root.
+      // Subpath file utils.js — require('subpath-pkg/utils') maps to utils.js
+      // (a file, not a directory-with-index.js).
+      const externalPkg = makePkg(testDir, 'external-subpath-pkg', {
+        'package.json': JSON.stringify({ name: 'subpath-pkg', main: 'index.js' }),
+        'index.js': 'module.exports = { root: true };',
+        'utils.js': 'module.exports = { greet: () => "sub-hello" };'
+      });
+
+      const nodeModulesDir = path.join(collectionPath, 'node_modules');
+      fs.mkdirSync(nodeModulesDir, { recursive: true });
+      fs.symlinkSync(externalPkg, path.join(nodeModulesDir, 'subpath-pkg'), 'dir');
+
+      const script = `
+        const utils = require('subpath-pkg/utils');
+        bru.setVar('result', utils.greet());
+      `;
+
+      const context = {
+        bru: { setVar: jest.fn() },
+        console: console
+      };
+
+      await runScriptInNodeVm({ script, context, collectionPath, scriptingConfig: {} });
+
+      expect(context.bru.setVar).toHaveBeenCalledWith('result', 'sub-hello');
+    });
+
+    itIfSymlinks('should allow internal relative requires inside an npm-linked package', async () => {
+      // Physical location of a multi-file package outside every declared root.
+      const externalPkg = makePkg(testDir, 'external-pkg', {
+        'package.json': JSON.stringify({ name: 'linked-pkg', main: 'index.js' }),
+        'index.js': 'const util = require("./util"); module.exports = { greet: util.greet };',
+        'util.js': 'module.exports = { greet: () => "hello" };'
+      });
+
+      // npm-link style: collection has node_modules/<pkg> as a symlink to the
+      // physical location that lives outside the collection.
+      const nodeModulesDir = path.join(collectionPath, 'node_modules');
+      fs.mkdirSync(nodeModulesDir, { recursive: true });
+      fs.symlinkSync(externalPkg, path.join(nodeModulesDir, 'linked-pkg'), 'dir');
+
+      const script = `
+        const pkg = require('linked-pkg');
+        bru.setVar('result', pkg.greet());
+      `;
+
+      const context = {
+        bru: { setVar: jest.fn() },
+        console: console
+      };
+
+      await runScriptInNodeVm({ script, context, collectionPath, scriptingConfig: {} });
+
+      expect(context.bru.setVar).toHaveBeenCalledWith('result', 'hello');
+    });
+
+    it('should allow a package in collection node_modules to require a sibling package', async () => {
+      // Two packages installed side-by-side in the collection's node_modules —
+      // pkg-a transitively requires pkg-b.
+      const nodeModulesDir = path.join(collectionPath, 'node_modules');
+      makePkg(nodeModulesDir, 'pkg-a', {
+        'package.json': JSON.stringify({ name: 'pkg-a', main: 'index.js' }),
+        'index.js': 'const b = require("pkg-b"); module.exports = { value: b.value + 1 };'
+      });
+      makePkg(nodeModulesDir, 'pkg-b', {
+        'package.json': JSON.stringify({ name: 'pkg-b', main: 'index.js' }),
+        'index.js': 'module.exports = { value: 41 };'
+      });
+
+      const script = `
+        const a = require('pkg-a');
+        bru.setVar('result', a.value);
+      `;
+
+      const context = {
+        bru: { setVar: jest.fn() },
+        console: console
+      };
+
+      await runScriptInNodeVm({ script, context, collectionPath, scriptingConfig: {} });
+
+      expect(context.bru.setVar).toHaveBeenCalledWith('result', 42);
+    });
+
+    itIfSymlinks('should allow a scoped npm-linked package', async () => {
+      // Physical location of a scoped multi-file package outside every declared root.
+      const externalPkg = makePkg(testDir, 'external-scoped-pkg', {
+        'package.json': JSON.stringify({ name: '@bruno/scoped-pkg', main: 'index.js' }),
+        'index.js': 'const util = require("./util"); module.exports = { greet: util.greet };',
+        'util.js': 'module.exports = { greet: () => "scoped-hello" };'
+      });
+
+      const scopeDir = path.join(collectionPath, 'node_modules', '@bruno');
+      fs.mkdirSync(scopeDir, { recursive: true });
+      fs.symlinkSync(externalPkg, path.join(scopeDir, 'scoped-pkg'), 'dir');
+
+      const script = `
+        const pkg = require('@bruno/scoped-pkg');
+        bru.setVar('result', pkg.greet());
+      `;
+
+      const context = {
+        bru: { setVar: jest.fn() },
+        console: console
+      };
+
+      await runScriptInNodeVm({ script, context, collectionPath, scriptingConfig: {} });
+
+      expect(context.bru.setVar).toHaveBeenCalledWith('result', 'scoped-hello');
+    });
   });
 
   describe('createCustomRequire - npm modules', () => {

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

@@ -7,207 +7,207 @@ const addBruShimToContext = (vm, bru) => {
   const bruRunnerObject = vm.newObject();
   const bruRunnerIterationDataObject = vm.newObject();
 
-  let cwd = vm.newFunction('cwd', function () {
+  const cwd = vm.newFunction('cwd', function () {
     return marshallToVm(bru.cwd(), vm);
   });
   vm.setProp(bruObject, 'cwd', cwd);
   cwd.dispose();
 
-  let getEnvName = vm.newFunction('getEnvName', function () {
+  const getEnvName = vm.newFunction('getEnvName', function () {
     return marshallToVm(bru.getEnvName(), vm);
   });
   vm.setProp(bruObject, 'getEnvName', getEnvName);
   getEnvName.dispose();
 
-  let getCollectionName = vm.newFunction('getCollectionName', function () {
+  const getCollectionName = vm.newFunction('getCollectionName', function () {
     return marshallToVm(bru.getCollectionName(), vm);
   });
   vm.setProp(bruObject, 'getCollectionName', getCollectionName);
   getCollectionName.dispose();
 
-  let isSafeMode = vm.newFunction('isSafeMode', function () {
+  const isSafeMode = vm.newFunction('isSafeMode', function () {
     return marshallToVm(bru.isSafeMode(), vm);
   });
   vm.setProp(bruObject, 'isSafeMode', isSafeMode);
   isSafeMode.dispose();
 
-  let getProcessEnv = vm.newFunction('getProcessEnv', function (key) {
+  const getProcessEnv = vm.newFunction('getProcessEnv', function (key) {
     return marshallToVm(bru.getProcessEnv(vm.dump(key)), vm);
   });
   vm.setProp(bruObject, 'getProcessEnv', getProcessEnv);
   getProcessEnv.dispose();
 
-  let interpolate = vm.newFunction('interpolate', function (str) {
+  const interpolate = vm.newFunction('interpolate', function (str) {
     return marshallToVm(bru.interpolate(vm.dump(str)), vm);
   });
   vm.setProp(bruObject, 'interpolate', interpolate);
   interpolate.dispose();
 
-  let hasEnvVar = vm.newFunction('hasEnvVar', function (key) {
+  const hasEnvVar = vm.newFunction('hasEnvVar', function (key) {
     return marshallToVm(bru.hasEnvVar(vm.dump(key)), vm);
   });
   vm.setProp(bruObject, 'hasEnvVar', hasEnvVar);
   hasEnvVar.dispose();
 
-  let getEnvVar = vm.newFunction('getEnvVar', function (key) {
+  const getEnvVar = vm.newFunction('getEnvVar', function (key) {
     return marshallToVm(bru.getEnvVar(vm.dump(key)), vm);
   });
   vm.setProp(bruObject, 'getEnvVar', getEnvVar);
   getEnvVar.dispose();
 
-  let setEnvVar = vm.newFunction('setEnvVar', function (key, value) {
+  const setEnvVar = vm.newFunction('setEnvVar', function (key, value) {
     bru.setEnvVar(vm.dump(key), vm.dump(value));
   });
   vm.setProp(bruObject, 'setEnvVar', setEnvVar);
   setEnvVar.dispose();
 
-  let deleteEnvVar = vm.newFunction('deleteEnvVar', function (key) {
+  const deleteEnvVar = vm.newFunction('deleteEnvVar', function (key) {
     bru.deleteEnvVar(vm.dump(key));
   });
   vm.setProp(bruObject, 'deleteEnvVar', deleteEnvVar);
   deleteEnvVar.dispose();
 
-  let getAllEnvVars = vm.newFunction('getAllEnvVars', function () {
+  const getAllEnvVars = vm.newFunction('getAllEnvVars', function () {
     return marshallToVm(bru.getAllEnvVars(), vm);
   });
   vm.setProp(bruObject, 'getAllEnvVars', getAllEnvVars);
   getAllEnvVars.dispose();
 
-  let deleteAllEnvVars = vm.newFunction('deleteAllEnvVars', function () {
+  const deleteAllEnvVars = vm.newFunction('deleteAllEnvVars', function () {
     bru.deleteAllEnvVars();
   });
   vm.setProp(bruObject, 'deleteAllEnvVars', deleteAllEnvVars);
   deleteAllEnvVars.dispose();
 
-  let getGlobalEnvVar = vm.newFunction('getGlobalEnvVar', function (key) {
+  const getGlobalEnvVar = vm.newFunction('getGlobalEnvVar', function (key) {
     return marshallToVm(bru.getGlobalEnvVar(vm.dump(key)), vm);
   });
   vm.setProp(bruObject, 'getGlobalEnvVar', getGlobalEnvVar);
   getGlobalEnvVar.dispose();
 
-  let getOauth2CredentialVar = vm.newFunction('getOauth2CredentialVar', function (key) {
+  const getOauth2CredentialVar = vm.newFunction('getOauth2CredentialVar', function (key) {
     return marshallToVm(bru.getOauth2CredentialVar(vm.dump(key)), vm);
   });
   vm.setProp(bruObject, 'getOauth2CredentialVar', getOauth2CredentialVar);
   getOauth2CredentialVar.dispose();
 
-  let resetOauth2Credential = vm.newFunction('resetOauth2Credential', function (credentialId) {
+  const resetOauth2Credential = vm.newFunction('resetOauth2Credential', function (credentialId) {
     bru.resetOauth2Credential(vm.dump(credentialId));
   });
   vm.setProp(bruObject, 'resetOauth2Credential', resetOauth2Credential);
   resetOauth2Credential.dispose();
 
-  let setGlobalEnvVar = vm.newFunction('setGlobalEnvVar', function (key, value) {
+  const setGlobalEnvVar = vm.newFunction('setGlobalEnvVar', function (key, value) {
     bru.setGlobalEnvVar(vm.dump(key), vm.dump(value));
   });
   vm.setProp(bruObject, 'setGlobalEnvVar', setGlobalEnvVar);
   setGlobalEnvVar.dispose();
 
-  let deleteGlobalEnvVar = vm.newFunction('deleteGlobalEnvVar', function (key) {
+  const deleteGlobalEnvVar = vm.newFunction('deleteGlobalEnvVar', function (key) {
     bru.deleteGlobalEnvVar(vm.dump(key));
   });
   vm.setProp(bruObject, 'deleteGlobalEnvVar', deleteGlobalEnvVar);
   deleteGlobalEnvVar.dispose();
 
-  let getAllGlobalEnvVars = vm.newFunction('getAllGlobalEnvVars', function () {
+  const getAllGlobalEnvVars = vm.newFunction('getAllGlobalEnvVars', function () {
     return marshallToVm(bru.getAllGlobalEnvVars(), vm);
   });
   vm.setProp(bruObject, 'getAllGlobalEnvVars', getAllGlobalEnvVars);
   getAllGlobalEnvVars.dispose();
 
-  let hasGlobalEnvVar = vm.newFunction('hasGlobalEnvVar', function (key) {
+  const hasGlobalEnvVar = vm.newFunction('hasGlobalEnvVar', function (key) {
     return marshallToVm(bru.hasGlobalEnvVar(vm.dump(key)), vm);
   });
   vm.setProp(bruObject, 'hasGlobalEnvVar', hasGlobalEnvVar);
   hasGlobalEnvVar.dispose();
 
-  let deleteAllGlobalEnvVars = vm.newFunction('deleteAllGlobalEnvVars', function () {
+  const deleteAllGlobalEnvVars = vm.newFunction('deleteAllGlobalEnvVars', function () {
     bru.deleteAllGlobalEnvVars();
   });
   vm.setProp(bruObject, 'deleteAllGlobalEnvVars', deleteAllGlobalEnvVars);
   deleteAllGlobalEnvVars.dispose();
 
-  let hasVar = vm.newFunction('hasVar', function (key) {
+  const hasVar = vm.newFunction('hasVar', function (key) {
     return marshallToVm(bru.hasVar(vm.dump(key)), vm);
   });
   vm.setProp(bruObject, 'hasVar', hasVar);
   hasVar.dispose();
 
-  let getVar = vm.newFunction('getVar', function (key) {
+  const getVar = vm.newFunction('getVar', function (key) {
     return marshallToVm(bru.getVar(vm.dump(key)), vm);
   });
   vm.setProp(bruObject, 'getVar', getVar);
   getVar.dispose();
 
-  let setVar = vm.newFunction('setVar', function (key, value) {
+  const setVar = vm.newFunction('setVar', function (key, value) {
     bru.setVar(vm.dump(key), vm.dump(value));
   });
   vm.setProp(bruObject, 'setVar', setVar);
   setVar.dispose();
 
-  let deleteVar = vm.newFunction('deleteVar', function (key) {
+  const deleteVar = vm.newFunction('deleteVar', function (key) {
     bru.deleteVar(vm.dump(key));
   });
   vm.setProp(bruObject, 'deleteVar', deleteVar);
   deleteVar.dispose();
 
-  let deleteAllVars = vm.newFunction('deleteAllVars', function () {
+  const deleteAllVars = vm.newFunction('deleteAllVars', function () {
     bru.deleteAllVars();
   });
   vm.setProp(bruObject, 'deleteAllVars', deleteAllVars);
   deleteAllVars.dispose();
 
-  let getAllVars = vm.newFunction('getAllVars', function () {
+  const getAllVars = vm.newFunction('getAllVars', function () {
     return marshallToVm(bru.getAllVars(), vm);
   });
   vm.setProp(bruObject, 'getAllVars', getAllVars);
   getAllVars.dispose();
 
-  let setNextRequest = vm.newFunction('setNextRequest', function (nextRequest) {
+  const setNextRequest = vm.newFunction('setNextRequest', function (nextRequest) {
     bru.setNextRequest(vm.dump(nextRequest));
   });
   vm.setProp(bruObject, 'setNextRequest', setNextRequest);
   setNextRequest.dispose();
 
-  let runnerSkipRequest = vm.newFunction('skipRequest', function () {
+  const runnerSkipRequest = vm.newFunction('skipRequest', function () {
     bru?.runner?.skipRequest();
   });
   vm.setProp(bruRunnerObject, 'skipRequest', runnerSkipRequest);
   runnerSkipRequest.dispose();
 
-  let runnerStopExecution = vm.newFunction('stopExecution', function () {
+  const runnerStopExecution = vm.newFunction('stopExecution', function () {
     bru?.runner?.stopExecution();
   });
   vm.setProp(bruRunnerObject, 'stopExecution', runnerStopExecution);
   runnerStopExecution.dispose();
 
-  let runnerSetNextRequest = vm.newFunction('setNextRequest', function (nextRequest) {
+  const runnerSetNextRequest = vm.newFunction('setNextRequest', function (nextRequest) {
     bru?.runner?.setNextRequest(vm.dump(nextRequest));
   });
   vm.setProp(bruRunnerObject, 'setNextRequest', runnerSetNextRequest);
   runnerSetNextRequest.dispose();
 
-  let runnerIterationIndex = marshallToVm(bru?.runner?.iterationIndex, vm);
+  const runnerIterationIndex = marshallToVm(bru?.runner?.iterationIndex, vm);
   vm.setProp(bruRunnerObject, 'iterationIndex', runnerIterationIndex);
   runnerIterationIndex.dispose();
 
-  let runnerTotalIterations = marshallToVm(bru?.runner?.totalIterations, vm);
+  const runnerTotalIterations = marshallToVm(bru?.runner?.totalIterations, vm);
   vm.setProp(bruRunnerObject, 'totalIterations', runnerTotalIterations);
   runnerTotalIterations.dispose();
 
-  let runnerSetIterationData = vm.newFunction('set', function (key, value) {
+  const runnerSetIterationData = vm.newFunction('set', function (key, value) {
     bru?.runner?.iterationData?.set(vm.dump(key), vm.dump(value));
   });
   vm.setProp(bruRunnerIterationDataObject, 'set', runnerSetIterationData);
   runnerSetIterationData.dispose();
 
-  let runnerUnsetIterationData = vm.newFunction('unset', function (key) {
+  const runnerUnsetIterationData = vm.newFunction('unset', function (key) {
     bru?.runner?.iterationData?.unset(vm.dump(key));
   });
   vm.setProp(bruRunnerIterationDataObject, 'unset', runnerUnsetIterationData);
   runnerUnsetIterationData.dispose();
 
-  let runnerGetIterationData = vm.newFunction('get', function (key) {
+  const runnerGetIterationData = vm.newFunction('get', function (key) {
     if (key) {
       return marshallToVm(bru?.runner?.iterationData?.get(vm.dump(key)), vm);
     }
@@ -216,13 +216,13 @@ const addBruShimToContext = (vm, bru) => {
   vm.setProp(bruRunnerIterationDataObject, 'get', runnerGetIterationData);
   runnerGetIterationData.dispose();
 
-  let runnerHasIterationData = vm.newFunction('has', function (key) {
+  const runnerHasIterationData = vm.newFunction('has', function (key) {
     return marshallToVm(bru?.runner?.iterationData?.has(vm.dump(key)), vm);
   });
   vm.setProp(bruRunnerIterationDataObject, 'has', runnerHasIterationData);
   runnerHasIterationData.dispose();
 
-  let runnerStringifyIterationData = vm.newFunction('stringify', function () {
+  const runnerStringifyIterationData = vm.newFunction('stringify', function () {
     return marshallToVm(bru?.runner?.iterationData?.stringify(), vm);
   });
   vm.setProp(bruRunnerIterationDataObject, 'stringify', runnerStringifyIterationData);
@@ -231,7 +231,7 @@ const addBruShimToContext = (vm, bru) => {
   vm.setProp(bruRunnerObject, 'iterationData', bruRunnerIterationDataObject);
   bruRunnerIterationDataObject.dispose();
 
-  let visualize = vm.newFunction('visualize', function (type, data) {
+  const visualize = vm.newFunction('visualize', function (type, 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
@@ -249,67 +249,67 @@ const addBruShimToContext = (vm, bru) => {
   vm.setProp(bruObject, 'visualize', visualize);
   visualize.dispose();
 
-  let clearVisualizations = vm.newFunction('clearVisualizations', function () {
+  const clearVisualizations = vm.newFunction('clearVisualizations', function () {
     bru.clearVisualizations();
   });
   vm.setProp(bruObject, 'clearVisualizations', clearVisualizations);
   clearVisualizations.dispose();
 
-  let getSecretVar = vm.newFunction('getSecretVar', function (key) {
+  const getSecretVar = vm.newFunction('getSecretVar', function (key) {
     return marshallToVm(bru.getSecretVar(vm.dump(key)), vm);
   });
   vm.setProp(bruObject, 'getSecretVar', getSecretVar);
   getSecretVar.dispose();
 
-  let getRequestVar = vm.newFunction('getRequestVar', function (key) {
+  const getRequestVar = vm.newFunction('getRequestVar', function (key) {
     return marshallToVm(bru.getRequestVar(vm.dump(key)), vm);
   });
   vm.setProp(bruObject, 'getRequestVar', getRequestVar);
   getRequestVar.dispose();
 
-  let getFolderVar = vm.newFunction('getFolderVar', function (key) {
+  const getFolderVar = vm.newFunction('getFolderVar', function (key) {
     return marshallToVm(bru.getFolderVar(vm.dump(key)), vm);
   });
   vm.setProp(bruObject, 'getFolderVar', getFolderVar);
   getFolderVar.dispose();
 
-  let getCollectionVar = vm.newFunction('getCollectionVar', function (key) {
+  const getCollectionVar = vm.newFunction('getCollectionVar', function (key) {
     return marshallToVm(bru.getCollectionVar(vm.dump(key)), vm);
   });
   vm.setProp(bruObject, 'getCollectionVar', getCollectionVar);
   getCollectionVar.dispose();
 
-  let setCollectionVar = vm.newFunction('setCollectionVar', function (key, value) {
+  const setCollectionVar = vm.newFunction('setCollectionVar', function (key, value) {
     bru.setCollectionVar(vm.dump(key), vm.dump(value));
   });
   vm.setProp(bruObject, 'setCollectionVar', setCollectionVar);
   setCollectionVar.dispose();
 
-  let hasCollectionVar = vm.newFunction('hasCollectionVar', function (key) {
+  const hasCollectionVar = vm.newFunction('hasCollectionVar', function (key) {
     return marshallToVm(bru.hasCollectionVar(vm.dump(key)), vm);
   });
   vm.setProp(bruObject, 'hasCollectionVar', hasCollectionVar);
   hasCollectionVar.dispose();
 
-  let deleteCollectionVar = vm.newFunction('deleteCollectionVar', function (key) {
+  const deleteCollectionVar = vm.newFunction('deleteCollectionVar', function (key) {
     bru.deleteCollectionVar(vm.dump(key));
   });
   vm.setProp(bruObject, 'deleteCollectionVar', deleteCollectionVar);
   deleteCollectionVar.dispose();
 
-  let deleteAllCollectionVars = vm.newFunction('deleteAllCollectionVars', function () {
+  const deleteAllCollectionVars = vm.newFunction('deleteAllCollectionVars', function () {
     bru.deleteAllCollectionVars();
   });
   vm.setProp(bruObject, 'deleteAllCollectionVars', deleteAllCollectionVars);
   deleteAllCollectionVars.dispose();
 
-  let getAllCollectionVars = vm.newFunction('getAllCollectionVars', function () {
+  const getAllCollectionVars = vm.newFunction('getAllCollectionVars', function () {
     return marshallToVm(bru.getAllCollectionVars(), vm);
   });
   vm.setProp(bruObject, 'getAllCollectionVars', getAllCollectionVars);
   getAllCollectionVars.dispose();
 
-  let getTestResults = vm.newFunction('getTestResults', () => {
+  const getTestResults = vm.newFunction('getTestResults', () => {
     const promise = vm.newPromise();
     bru
       .getTestResults()
@@ -331,7 +331,7 @@ const addBruShimToContext = (vm, bru) => {
   });
   getTestResults.consume((handle) => vm.setProp(bruObject, 'getTestResults', handle));
 
-  let getAssertionResults = vm.newFunction('getAssertionResults', () => {
+  const getAssertionResults = vm.newFunction('getAssertionResults', () => {
     const promise = vm.newPromise();
     bru
       .getAssertionResults()
@@ -353,7 +353,7 @@ const addBruShimToContext = (vm, bru) => {
   });
   getAssertionResults.consume((handle) => vm.setProp(bruObject, 'getAssertionResults', handle));
 
-  let runRequestHandle = vm.newFunction('runRequest', (args) => {
+  const runRequestHandle = vm.newFunction('runRequest', (args) => {
     const promise = vm.newPromise();
     bru
       .runRequest(vm.dump(args))
@@ -375,7 +375,7 @@ const addBruShimToContext = (vm, bru) => {
   });
   runRequestHandle.consume((handle) => vm.setProp(bruObject, 'runRequest', handle));
 
-  let sendRequestHandle = vm.newFunction('_sendRequest', (args) => {
+  const sendRequestHandle = vm.newFunction('_sendRequest', (args) => {
     const promise = vm.newPromise();
     bru
       .sendRequest(vm.dump(args))
@@ -396,7 +396,7 @@ const addBruShimToContext = (vm, bru) => {
   sendRequestHandle.consume((handle) => vm.setProp(bruObject, '_sendRequest', handle));
 
   // On vm.global, not bru, to stay off user-facing autocomplete.
-  let setScopeHandle = vm.newFunction('__bruSetScope', (scopeArg) => {
+  const setScopeHandle = vm.newFunction('__bruSetScope', (scopeArg) => {
     bru._currentScope = vm.dump(scopeArg) || null;
   });
   setScopeHandle.consume((handle) => vm.setProp(vm.global, '__bruSetScope', handle));
@@ -416,7 +416,7 @@ const addBruShimToContext = (vm, bru) => {
   });
   sleep.consume((handle) => vm.setProp(bruObject, 'sleep', handle));
 
-  let bruCookiesObject = vm.newObject();
+  const bruCookiesObject = vm.newObject();
   const { evalCode: cookiesEvalCode } = createPropertyListBridge(vm, bru.cookies, bruCookiesObject, {
     globalPath: 'globalThis.bru.cookies',
     syncReadMethods: ['get', 'has', 'count', 'indexOf', 'toObject', 'toString'],