@usebruno/js 0.50.0 → 0.52.0

package/src/sandbox/quickjs/index.js

@@ -2,11 +2,28 @@ const addBruShimToContext = require('./shims/bru');
 const addBrunoRequestShimToContext = require('./shims/bruno-request');
 const addConsoleShimToContext = require('./shims/console');
 const addBrunoResponseShimToContext = require('./shims/bruno-response');
+const addBrunoGrpcShimToContext = require('./shims/bruno-grpc');
 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');
+const { newQuickJSWASMModuleFromVariant, newVariant, RELEASE_SYNC } = require('quickjs-emscripten');
+
+// The engine prints its dispose-abort assertion to stderr on its own. Swallow
+// that line on the CLI, where stderr is the user's screen and a handled trap
+// would read as a crash; keep it in the app, whose console is not user facing.
+const isElectronHost = Boolean(process.versions.electron);
+const isContainedAbortLine = (line) =>
+  String(line).includes('list_empty(&rt->gc_obj_list)') && String(line).includes('JS_FreeRuntime');
+const quietEngineVariant = newVariant(RELEASE_SYNC, {
+  emscriptenModule: {
+    printErr: (line) => {
+      if (isElectronHost || !isContainedAbortLine(line)) {
+        console.error(line);
+      }
+    }
+  }
+});
 
 // execute `npm run sandbox:bundle-libraries` if the below file doesn't exist
 const getBundledCode = require('../bundle-browser-rollup');
@@ -16,8 +33,54 @@ const addCryptoUtilsShimToContext = require('./shims/lib/crypto-utils');
 const { wrapScriptInClosure, SANDBOX } = require('../../utils/sandbox');
 
 let QuickJSModule;
-const loader = memoizePromiseFactory(() => newQuickJSWASMModule());
-loader().then((mod) => (QuickJSModule = mod));
+let quickJSModulePromise;
+let quickJSModuleLoading = false;
+let quickJSModuleRecycleCount = 0;
+
+// Memoized WASM module for sync + async. reload swaps with no gap; failed
+// reload restores the old memo, failed initial load clears it.
+const loader = ({ reload = false } = {}) => {
+  if (!quickJSModulePromise || (reload && !quickJSModuleLoading)) {
+    const previousPromise = quickJSModulePromise;
+    quickJSModuleLoading = true;
+    quickJSModulePromise = newQuickJSWASMModuleFromVariant(quietEngineVariant)
+      .then((mod) => {
+        QuickJSModule = mod;
+        return mod;
+      })
+      .catch((loadError) => {
+        console.error(reload ? 'QuickJS module reload failed' : 'QuickJS module load failed', loadError);
+        quickJSModulePromise = reload ? previousPromise : null;
+        if (quickJSModulePromise) {
+          return quickJSModulePromise;
+        }
+        throw loadError;
+      })
+      .finally(() => {
+        quickJSModuleLoading = false;
+      });
+  }
+  return quickJSModulePromise;
+};
+loader().catch(() => {});
+
+// On dispose WASM trap, recycle the module (old one keeps serving until ready).
+const recycleQuickJSModuleOnAbort = (teardownError, ownerModule) => {
+  if (!(teardownError instanceof WebAssembly.RuntimeError)) {
+    return false;
+  }
+  // Skip if this module was already replaced.
+  if (!ownerModule || ownerModule === QuickJSModule) {
+    quickJSModuleRecycleCount += 1;
+    console.warn(
+      quickJSModuleRecycleCount === 1
+        ? 'QuickJS engine crashed during cleanup and was replaced; the run was not affected'
+        : `QuickJS engine replaced again (${quickJSModuleRecycleCount} this session)`
+    );
+    loader({ reload: true }).catch(() => {});
+  }
+  return true;
+};
 
 const toNumber = (value) => {
   const num = Number(value);
@@ -57,8 +120,9 @@ const executeQuickJsVm = ({ script: externalScript, context: externalContext, sc
     externalScript = removeQuotes(externalScript);
   }
   let managedQuickJsContext;
+  const quickJsModule = QuickJSModule;
   try {
-    managedQuickJsContext = createManagedQuickJsContext(QuickJSModule);
+    managedQuickJsContext = createManagedQuickJsContext(quickJsModule);
     const vm = managedQuickJsContext.vm;
     const { bru, req, res, ...variables } = externalContext;
 
@@ -88,7 +152,13 @@ const executeQuickJsVm = ({ script: externalScript, context: externalContext, sc
   } catch (error) {
     console.error('Error executing the script!', error);
   } finally {
-    managedQuickJsContext?.dispose();
+    try {
+      managedQuickJsContext?.dispose();
+    } catch (teardownError) {
+      if (!recycleQuickJSModuleOnAbort(teardownError, quickJsModule)) {
+        console.error('Error disposing QuickJS context', teardownError);
+      }
+    }
   }
 };
 
@@ -99,9 +169,11 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
   externalScript = externalScript?.trim();
 
   let managedQuickJsContext;
+  let scriptError;
+  let quickJsModule;
   try {
-    const module = await loader();
-    managedQuickJsContext = createManagedQuickJsContext(module);
+    quickJsModule = await loader();
+    managedQuickJsContext = createManagedQuickJsContext(quickJsModule);
     const vm = managedQuickJsContext.vm;
 
     // add crypto utilities required by the crypto-js library in bundledCode
@@ -120,6 +192,7 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
 
     consoleFn && addConsoleShimToContext(vm, consoleFn);
     bru && addBruShimToContext(vm, bru);
+    bru?.grpc && addBrunoGrpcShimToContext(vm, bru.grpc);
     req && addBrunoRequestShimToContext(vm, req);
     res && addBrunoResponseShimToContext(vm, res);
     addLocalModuleLoaderShimToContext(vm, collectionPath);
@@ -137,22 +210,33 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
     promiseHandle.dispose();
     const resolvedHandle = vm.unwrapResult(resolvedResult);
     resolvedHandle.dispose();
-    return;
   } catch (error) {
     error.__isQuickJS = true;
-    throw error;
-  } finally {
-    // Wait for any in-flight async work (sendRequest, axios, cookie jar, timers,
-    // un-awaited promises) to settle before tearing down the VM. Disposing while
-    // a deferred is still pending lets its later host callback touch a freed
-    // context, throwing `QuickJSUseAfterFree`.
+    scriptError = error;
+  }
+
+  // The run waits for every pending deferred before returning: un-awaited
+  // async work is the user's choice, and the run is not done until it is.
+  // The wait is unbounded by design; cancelling the request is the way out.
+  if (managedQuickJsContext) {
+    // No try/catch: every awaited settle promise is pre-caught at creation
+    // (trackPendingDeferreds), so this await cannot reject and skip dispose.
+    await managedQuickJsContext.waitForPendingDeferreds();
     try {
-      await managedQuickJsContext?.waitForPendingDeferreds?.();
-      managedQuickJsContext?.dispose();
+      managedQuickJsContext.dispose();
     } catch (teardownError) {
-      throw teardownError;
+      const recycled = recycleQuickJSModuleOnAbort(teardownError, quickJsModule);
+      if (!scriptError && !recycled) {
+        scriptError = teardownError;
+      } else if (!recycled) {
+        console.error('Error disposing QuickJS context', teardownError);
+      }
     }
   }
+
+  if (scriptError) {
+    throw scriptError;
+  }
 };
 
 module.exports = {

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'],

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

@@ -0,0 +1,29 @@
+const addBrunoGrpcRequestShimToContext = require('./grpc/bruno-grpc-request');
+const addBrunoGrpcResponseShimToContext = require('./grpc/bruno-grpc-response');
+
+/**
+ * Installs `bru.grpc` onto the `bru` object the bru shim has already put on the global, so it has
+ * to run after it.
+ */
+const addBrunoGrpcShimToContext = (vm, grpc) => {
+  const bruObject = vm.getProp(vm.global, 'bru');
+  const grpcObject = vm.newObject();
+
+  const { evalCode: requestEvalCode } = addBrunoGrpcRequestShimToContext(vm, grpc.request, grpcObject);
+  // `response` is absent in `beforeCallStart`, which has no response yet.
+  const { evalCode: responseEvalCode } = grpc.response
+    ? addBrunoGrpcResponseShimToContext(vm, grpc.response, grpcObject)
+    : { evalCode: [] };
+
+  vm.setProp(bruObject, 'grpc', grpcObject);
+  grpcObject.dispose();
+  bruObject.dispose();
+
+  // The list code reaches its target through `globalThis.bru.grpc`, so it can only run now that
+  // `grpc` is on `bru`. Each block is braced on its own — every bridge declares the same consts.
+  for (const code of [...requestEvalCode, ...responseEvalCode].filter(Boolean)) {
+    vm.evalCode(`{ ${code} }`);
+  }
+};
+
+module.exports = addBrunoGrpcShimToContext;

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

@@ -0,0 +1,47 @@
+const { marshallToVm } = require('../../utils');
+const addGrpcMetadataListShimToContext = require('./grpc-metadata-list');
+const addGrpcMessageListShimToContext = require('./grpc-message-list');
+
+// Keep this in step with BrunoGrpcRequest.
+const addBrunoGrpcRequestShimToContext = (vm, request, grpcObject) => {
+  const requestObject = vm.newObject();
+
+  const scalars = ['url', 'method', 'methodType', 'authMode', 'protoPath', 'name'];
+
+  for (const property of scalars) {
+    const value = marshallToVm(request[property], vm);
+    vm.setProp(requestObject, property, value);
+    value.dispose();
+  }
+
+  // request.metadata — writable in `beforeCallStart`, read-only in `afterCallEnd`
+  const metadataEvalCode = addGrpcMetadataListShimToContext(
+    vm,
+    request.metadata,
+    requestObject,
+    'metadata',
+    'globalThis.bru.grpc.request'
+  );
+
+  // request.messages — the messages the call sent, read-only, and empty until it has sent any
+  const messagesEvalCode = addGrpcMessageListShimToContext(
+    vm,
+    request.messages,
+    requestObject,
+    'globalThis.bru.grpc.request'
+  );
+
+  // request.message — present only in `beforeMessageSend`.
+  if (request.message) {
+    const message = marshallToVm(request.message, vm);
+    vm.setProp(requestObject, 'message', message);
+    message.dispose();
+  }
+
+  vm.setProp(grpcObject, 'request', requestObject);
+  requestObject.dispose();
+
+  return { evalCode: [metadataEvalCode, messagesEvalCode] };
+};
+
+module.exports = addBrunoGrpcRequestShimToContext;