@usebruno/js 0.49.0 → 0.51.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usebruno/js",
-  "version": "0.49.0",
+  "version": "0.51.0",
   "license": "MIT",
   "main": "src/index.js",
   "files": [
@@ -14,7 +14,7 @@
     "prepack": "npm run test"
   },
   "dependencies": {
-    "@usebruno/common": "0.23.0",
+    "@usebruno/common": "0.25.0",
     "@usebruno/query": "0.2.2",
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
@@ -28,7 +28,7 @@
     "handlebars": "^4.7.9",
     "json-query": "^2.2.2",
     "jsonwebtoken": "^9.0.3",
-    "lodash": "^4.17.21",
+    "lodash": "4.18.1",
     "moment": "^2.29.4",
     "nanoid": "3.3.8",
     "node-fetch": "^2.7.0",

package/src/bru.js

@@ -1,4 +1,4 @@
-const { cloneDeep } = require('lodash');
+const { cloneDeep, isEqual } = require('lodash');
 const { uuid } = require('./utils');
 const xmlFormat = require('xml-formatter');
 const { interpolate: _interpolate } = require('@usebruno/common');
@@ -121,8 +121,11 @@ class Bru {
       createCookieJar,
       getCookiesForUrl
     });
-    // Holds variables that are marked as persistent by scripts
-    this.persistentEnvVariables = {};
+    // Dirty flags — set by mutators so runtimes can skip IPC/disk writes for unchanged scopes
+    this._envDirty = false;
+    this._globalEnvDirty = false;
+    this._collVarsDirty = false;
+    this._runtimeVarsDirty = false;
     // Holds credential IDs to be reset after script execution
     this.oauth2CredentialsToReset = [];
     this.runner = {
@@ -240,7 +243,7 @@ class Bru {
     return this.interpolate(this.envVariables[key]);
   }
 
-  setEnvVar(key, value, options = {}) {
+  setEnvVar(key, value) {
     if (!key) {
       throw new Error('Creating a env variable without specifying a name is not allowed.');
     }
@@ -251,24 +254,21 @@ class Bru {
       );
     }
 
-    // When persist is true, only string values are allowed
-    if (options?.persist && typeof value !== 'string') {
-      throw new Error(`Persistent environment variables must be strings. Received ${typeof value} for key "${key}".`);
-    }
-
-    this.envVariables[key] = value;
-
-    if (options?.persist) {
-      this.persistentEnvVariables[key] = value;
-    } else {
-      if (this.persistentEnvVariables[key]) {
-        delete this.persistentEnvVariables[key];
-      }
+    // Deep-equal compare so object/array writes that mutate in place
+    // (e.g. `const c = bru.getEnvVar('cfg'); c.port = 4000; bru.setEnvVar('cfg', c);`)
+    // still flip the dirty flag — strict `!==` returned false for same-reference writes.
+    if (!Object.hasOwn(this.envVariables, key) || !isEqual(this.envVariables[key], value)) {
+      this.envVariables[key] = value;
+      this._envDirty = true;
     }
   }
 
   deleteEnvVar(key) {
-    delete this.envVariables[key];
+    if (key === '__name__') return;
+    if (Object.hasOwn(this.envVariables, key)) {
+      delete this.envVariables[key];
+      this._envDirty = true;
+    }
   }
 
   getAllEnvVars() {
@@ -278,15 +278,15 @@ class Bru {
   }
 
   deleteAllEnvVars() {
-    const envName = this.envVariables.__name__;
-    for (let key in this.envVariables) {
-      if (this.envVariables.hasOwnProperty(key)) {
-        delete this.envVariables[key];
-      }
-    }
-    if (envName !== undefined) {
-      this.envVariables.__name__ = envName;
+    // Iterate via Object.keys (own enumerable) so a user-set `hasOwnProperty` var
+    // can't shadow Object.prototype.hasOwnProperty and crash the loop.
+    let removed = false;
+    for (const key of Object.keys(this.envVariables)) {
+      if (key === '__name__') continue;
+      delete this.envVariables[key];
+      removed = true;
     }
+    if (removed) this._envDirty = true;
   }
 
   hasGlobalEnvVar(key) {
@@ -302,28 +302,31 @@ class Bru {
       throw new Error('Creating a env variable without specifying a name is not allowed.');
     }
 
-    this.globalEnvironmentVariables[key] = value;
+    if (!Object.hasOwn(this.globalEnvironmentVariables, key) || !isEqual(this.globalEnvironmentVariables[key], value)) {
+      this.globalEnvironmentVariables[key] = value;
+      this._globalEnvDirty = true;
+    }
   }
 
-  // TODO: deleteGlobalEnvVar works in the request lifecycle but does not update the UI.
-  // Re-enable once the UI sync issue is resolved.
-  // deleteGlobalEnvVar(key) {
-  //   delete this.globalEnvironmentVariables[key];
-  // }
+  deleteGlobalEnvVar(key) {
+    if (Object.hasOwn(this.globalEnvironmentVariables, key)) {
+      delete this.globalEnvironmentVariables[key];
+      this._globalEnvDirty = true;
+    }
+  }
 
   getAllGlobalEnvVars() {
     return Object.assign({}, this.globalEnvironmentVariables);
   }
 
-  // TODO: deleteAllGlobalEnvVars works in the request lifecycle but does not update the UI.
-  // Re-enable once the UI sync issue is resolved.
-  // deleteAllGlobalEnvVars() {
-  //   for (let key in this.globalEnvironmentVariables) {
-  //     if (this.globalEnvironmentVariables.hasOwnProperty(key)) {
-  //       delete this.globalEnvironmentVariables[key];
-  //     }
-  //   }
-  // }
+  deleteAllGlobalEnvVars() {
+    const keys = Object.keys(this.globalEnvironmentVariables);
+    if (!keys.length) return;
+    for (const key of keys) {
+      delete this.globalEnvironmentVariables[key];
+    }
+    this._globalEnvDirty = true;
+  }
 
   getOauth2CredentialVar(key) {
     return this.interpolate(this.oauth2CredentialVariables[key]);
@@ -363,7 +366,10 @@ class Bru {
       );
     }
 
-    this.runtimeVariables[key] = value;
+    if (!Object.hasOwn(this.runtimeVariables, key) || !isEqual(this.runtimeVariables[key], value)) {
+      this.runtimeVariables[key] = value;
+      this._runtimeVarsDirty = true;
+    }
   }
 
   getVar(key) {
@@ -378,15 +384,19 @@ class Bru {
   }
 
   deleteVar(key) {
-    delete this.runtimeVariables[key];
+    if (Object.hasOwn(this.runtimeVariables, key)) {
+      delete this.runtimeVariables[key];
+      this._runtimeVarsDirty = true;
+    }
   }
 
   deleteAllVars() {
-    for (let key in this.runtimeVariables) {
-      if (this.runtimeVariables.hasOwnProperty(key)) {
-        delete this.runtimeVariables[key];
-      }
+    const keys = Object.keys(this.runtimeVariables);
+    if (!keys.length) return;
+    for (const key of keys) {
+      delete this.runtimeVariables[key];
     }
+    this._runtimeVarsDirty = true;
   }
 
   getAllVars() {
@@ -397,48 +407,47 @@ class Bru {
     return this.interpolate(this.collectionVariables[key]);
   }
 
-  // TODO: setCollectionVar works in the request lifecycle but does not update the UI.
-  // Re-enable once the UI sync issue is resolved.
-  // setCollectionVar(key, value) {
-  //   if (!key) {
-  //     throw new Error('Creating a variable without specifying a name is not allowed.');
-  //   }
-  //
-  //   if (variableNameRegex.test(key) === false) {
-  //     throw new Error(
-  //       `Variable name: "${key}" contains invalid characters!`
-  //       + ' Names must only contain alpha-numeric characters, "-", "_", "."'
-  //     );
-  //   }
-  //
-  //   this.collectionVariables[key] = value;
-  // }
+  setCollectionVar(key, value) {
+    if (!key) {
+      throw new Error('Creating a variable without specifying a name is not allowed.');
+    }
+
+    if (variableNameRegex.test(key) === false) {
+      throw new Error(
+        `Variable name: "${key}" contains invalid characters!`
+        + ' Names must only contain alpha-numeric characters, "-", "_", "."'
+      );
+    }
+
+    if (!Object.hasOwn(this.collectionVariables, key) || !isEqual(this.collectionVariables[key], value)) {
+      this.collectionVariables[key] = value;
+      this._collVarsDirty = true;
+    }
+  }
 
   hasCollectionVar(key) {
     return Object.hasOwn(this.collectionVariables, key);
   }
 
-  // TODO: deleteCollectionVar works in the request lifecycle but does not update the UI.
-  // Re-enable once the UI sync issue is resolved.
-  // deleteCollectionVar(key) {
-  //   delete this.collectionVariables[key];
-  // }
-
-  // TODO: deleteAllCollectionVars works in the request lifecycle but does not update the UI.
-  // Re-enable once the UI sync issue is resolved.
-  // deleteAllCollectionVars() {
-  //   for (let key in this.collectionVariables) {
-  //     if (this.collectionVariables.hasOwnProperty(key)) {
-  //       delete this.collectionVariables[key];
-  //     }
-  //   }
-  // }
-
-  // TODO: getAllCollectionVars works in the request lifecycle but does not update the UI.
-  // Re-enable once the UI sync issue is resolved.
-  // getAllCollectionVars() {
-  //   return Object.assign({}, this.collectionVariables);
-  // }
+  deleteCollectionVar(key) {
+    if (Object.hasOwn(this.collectionVariables, key)) {
+      delete this.collectionVariables[key];
+      this._collVarsDirty = true;
+    }
+  }
+
+  deleteAllCollectionVars() {
+    const keys = Object.keys(this.collectionVariables);
+    if (!keys.length) return;
+    for (const key of keys) {
+      delete this.collectionVariables[key];
+    }
+    this._collVarsDirty = true;
+  }
+
+  getAllCollectionVars() {
+    return Object.assign({}, this.collectionVariables);
+  }
 
   getFolderVar(key) {
     return this.interpolate(this.folderVariables[key]);
@@ -491,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-request.js

@@ -70,7 +70,13 @@ class BrunoRequest {
             if (segment.startsWith(':')) {
               const paramName = segment.slice(1);
               const pathParam = this.req.pathParams.find((param) => param.name === paramName);
-              if (pathParam && pathParam.value) {
+              if (
+                pathParam
+                && pathParam.enabled !== false
+                && pathParam.value !== null
+                && pathParam.value !== undefined
+                && (typeof pathParam.value !== 'string' || pathParam.value.trim() !== '')
+              ) {
                 return pathParam.value;
               }
             }

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 {
@@ -106,11 +106,11 @@ class ScriptRuntime {
     // Extracted to avoid duplication across runtime branches
     const buildRequestScriptResult = () => ({
       request,
-      envVariables: cleanJson(envVariables),
-      runtimeVariables: cleanJson(runtimeVariables),
+      envVariables: bru._envDirty ? cleanJson(envVariables) : null,
+      runtimeVariables: bru._runtimeVarsDirty ? cleanJson(runtimeVariables) : null,
+      collectionVariables: bru._collVarsDirty ? cleanJson(collectionVariables) : null,
+      globalEnvironmentVariables: bru._globalEnvDirty ? cleanJson(globalEnvironmentVariables) : null,
       visualizations,
-      persistentEnvVariables: bru.persistentEnvVariables,
-      globalEnvironmentVariables: cleanJson(globalEnvironmentVariables),
       oauth2CredentialsToReset: bru.oauth2CredentialsToReset,
       results: cleanJson(__brunoTestResults.getResults()),
       nextRequestName: bru.nextRequest,
@@ -183,7 +183,7 @@ class ScriptRuntime {
     collectionName
   ) {
     let visualizations = [];
-    let setVisualizations = (data) => {
+    const setVisualizations = (data) => {
       if (data.type === VISUALIZATION_CLEAR) {
         visualizations = [];
       } else {
@@ -259,11 +259,11 @@ class ScriptRuntime {
     // Extracted to avoid duplication across runtime branches
     const buildResponseScriptResult = () => ({
       response,
-      envVariables: cleanJson(envVariables),
-      persistentEnvVariables: cleanJson(bru.persistentEnvVariables),
-      runtimeVariables: cleanJson(runtimeVariables),
+      envVariables: bru._envDirty ? cleanJson(envVariables) : null,
+      runtimeVariables: bru._runtimeVarsDirty ? cleanJson(runtimeVariables) : null,
+      collectionVariables: bru._collVarsDirty ? cleanJson(collectionVariables) : null,
+      globalEnvironmentVariables: bru._globalEnvDirty ? cleanJson(globalEnvironmentVariables) : null,
       visualizations,
-      globalEnvironmentVariables: cleanJson(globalEnvironmentVariables),
       oauth2CredentialsToReset: bru.oauth2CredentialsToReset,
       results: cleanJson(__brunoTestResults.getResults()),
       nextRequestName: bru.nextRequest,

package/src/runtime/test-runtime.js

@@ -69,11 +69,13 @@ class TestRuntime {
     if (!testsFile || !testsFile.length) {
       return {
         request,
-        envVariables,
-        runtimeVariables,
-        globalEnvironmentVariables,
+        envVariables: null,
+        runtimeVariables: null,
+        collectionVariables: null,
+        globalEnvironmentVariables: null,
         results: __brunoTestResults.getResults(),
-        nextRequestName: bru.nextRequest
+        nextRequestName: bru.nextRequest,
+        stopExecution: bru.stopExecution
       };
     }
 
@@ -141,13 +143,14 @@ class TestRuntime {
 
     const result = {
       request,
-      envVariables: cleanJson(envVariables),
-      runtimeVariables: cleanJson(runtimeVariables),
-      globalEnvironmentVariables: cleanJson(globalEnvironmentVariables),
-      persistentEnvVariables: cleanJson(bru.persistentEnvVariables),
+      envVariables: bru._envDirty ? cleanJson(envVariables) : null,
+      runtimeVariables: bru._runtimeVarsDirty ? cleanJson(runtimeVariables) : null,
+      collectionVariables: bru._collVarsDirty ? cleanJson(collectionVariables) : null,
+      globalEnvironmentVariables: bru._globalEnvDirty ? cleanJson(globalEnvironmentVariables) : null,
       oauth2CredentialsToReset: bru.oauth2CredentialsToReset,
       results: cleanJson(__brunoTestResults.getResults()),
       nextRequestName: bru.nextRequest,
+      stopExecution: bru.stopExecution,
       scriptedRequestEntries: cleanJson(bru.scriptedRequestEntries || [])
     };
 

package/src/runtime/vars-runtime.js

@@ -92,10 +92,10 @@ class VarsRuntime {
     }
 
     return {
-      envVariables,
-      runtimeVariables,
-      globalEnvironmentVariables: cleanJson(globalEnvironmentVariables),
-      persistentEnvVariables: cleanJson(bru.persistentEnvVariables),
+      envVariables: bru._envDirty ? cleanJson(envVariables) : null,
+      runtimeVariables: bru._runtimeVarsDirty ? cleanJson(runtimeVariables) : null,
+      collectionVariables: bru._collVarsDirty ? cleanJson(collectionVariables) : null,
+      globalEnvironmentVariables: bru._globalEnvDirty ? cleanJson(globalEnvironmentVariables) : null,
       error
     };
   }

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,211 +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, options = {}) {
-    bru.setEnvVar(vm.dump(key), vm.dump(value), vm.dump(options));
+  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();
 
-  // TODO: deleteGlobalEnvVar works in the request lifecycle but does not update the UI.
-  // Re-enable once the UI sync issue is resolved.
-  // let deleteGlobalEnvVar = vm.newFunction('deleteGlobalEnvVar', function (key) {
-  //   bru.deleteGlobalEnvVar(vm.dump(key));
-  // });
-  // vm.setProp(bruObject, 'deleteGlobalEnvVar', deleteGlobalEnvVar);
-  // deleteGlobalEnvVar.dispose();
+  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();
 
-  // TODO: deleteAllGlobalEnvVars works in the request lifecycle but does not update the UI.
-  // Re-enable once the UI sync issue is resolved.
-  // let deleteAllGlobalEnvVars = vm.newFunction('deleteAllGlobalEnvVars', function () {
-  //   bru.deleteAllGlobalEnvVars();
-  // });
-  // vm.setProp(bruObject, 'deleteAllGlobalEnvVars', deleteAllGlobalEnvVars);
-  // deleteAllGlobalEnvVars.dispose();
+  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);
     }
@@ -220,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);
@@ -235,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
@@ -253,75 +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();
 
-  // TODO: setCollectionVar works in the request lifecycle but does not update the UI.
-  // Re-enable once the UI sync issue is resolved.
-  // let setCollectionVar = vm.newFunction('setCollectionVar', function (key, value) {
-  //   bru.setCollectionVar(vm.dump(key), vm.dump(value));
-  // });
-  // vm.setProp(bruObject, 'setCollectionVar', setCollectionVar);
-  // setCollectionVar.dispose();
+  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();
 
-  // TODO: deleteCollectionVar works in the request lifecycle but does not update the UI.
-  // Re-enable once the UI sync issue is resolved.
-  // let deleteCollectionVar = vm.newFunction('deleteCollectionVar', function (key) {
-  //   bru.deleteCollectionVar(vm.dump(key));
-  // });
-  // vm.setProp(bruObject, 'deleteCollectionVar', deleteCollectionVar);
-  // deleteCollectionVar.dispose();
-
-  // TODO: deleteAllCollectionVars works in the request lifecycle but does not update the UI.
-  // Re-enable once the UI sync issue is resolved.
-  // let deleteAllCollectionVars = vm.newFunction('deleteAllCollectionVars', function () {
-  //   bru.deleteAllCollectionVars();
-  // });
-  // vm.setProp(bruObject, 'deleteAllCollectionVars', deleteAllCollectionVars);
-  // deleteAllCollectionVars.dispose();
-
-  // TODO: getAllCollectionVars works in the request lifecycle but does not update the UI.
-  // Re-enable once the UI sync issue is resolved.
-  // let getAllCollectionVars = vm.newFunction('getAllCollectionVars', function () {
-  //   return marshallToVm(bru.getAllCollectionVars(), vm);
-  // });
-  // vm.setProp(bruObject, 'getAllCollectionVars', getAllCollectionVars);
-  // getAllCollectionVars.dispose();
-
-  let getTestResults = vm.newFunction('getTestResults', () => {
+  const deleteCollectionVar = vm.newFunction('deleteCollectionVar', function (key) {
+    bru.deleteCollectionVar(vm.dump(key));
+  });
+  vm.setProp(bruObject, 'deleteCollectionVar', deleteCollectionVar);
+  deleteCollectionVar.dispose();
+
+  const deleteAllCollectionVars = vm.newFunction('deleteAllCollectionVars', function () {
+    bru.deleteAllCollectionVars();
+  });
+  vm.setProp(bruObject, 'deleteAllCollectionVars', deleteAllCollectionVars);
+  deleteAllCollectionVars.dispose();
+
+  const getAllCollectionVars = vm.newFunction('getAllCollectionVars', function () {
+    return marshallToVm(bru.getAllCollectionVars(), vm);
+  });
+  vm.setProp(bruObject, 'getAllCollectionVars', getAllCollectionVars);
+  getAllCollectionVars.dispose();
+
+  const getTestResults = vm.newFunction('getTestResults', () => {
     const promise = vm.newPromise();
     bru
       .getTestResults()
@@ -343,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()
@@ -365,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))
@@ -387,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))
@@ -408,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));
@@ -428,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'],