@usebruno/js 0.47.0 → 0.49.0

package/src/sandbox/bundle-libraries.js

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

package/src/sandbox/quickjs/index.js

@@ -11,14 +11,13 @@ const { newQuickJSWASMModule, memoizePromiseFactory } = require('quickjs-emscrip
 // execute `npm run sandbox:bundle-libraries` if the below file doesn't exist
 const getBundledCode = require('../bundle-browser-rollup');
 const addPathShimToContext = require('./shims/lib/path');
-const { marshallToVm } = require('./utils');
+const { marshallToVm, createManagedQuickJsContext } = require('./utils');
 const addCryptoUtilsShimToContext = require('./shims/lib/crypto-utils');
 const { wrapScriptInClosure, SANDBOX } = require('../../utils/sandbox');
 
-let QuickJSSyncContext;
+let QuickJSModule;
 const loader = memoizePromiseFactory(() => newQuickJSWASMModule());
-const getContext = (opts) => loader().then((mod) => (QuickJSSyncContext = mod.newContext(opts)));
-getContext();
+loader().then((mod) => (QuickJSModule = mod));
 
 const toNumber = (value) => {
   const num = Number(value);
@@ -57,10 +56,10 @@ const executeQuickJsVm = ({ script: externalScript, context: externalContext, sc
 
     externalScript = removeQuotes(externalScript);
   }
-
-  const vm = QuickJSSyncContext;
-
+  let managedQuickJsContext;
   try {
+    managedQuickJsContext = createManagedQuickJsContext(QuickJSModule);
+    const vm = managedQuickJsContext.vm;
     const { bru, req, res, ...variables } = externalContext;
 
     bru && addBruShimToContext(vm, bru);
@@ -76,7 +75,7 @@ const executeQuickJsVm = ({ script: externalScript, context: externalContext, sc
 
     let scriptText = scriptType === 'template-literal' ? templateLiteralText : jsExpressionText;
 
-    const result = vm.evalCode(scriptText);
+    const result = vm.evalCodeRetained(scriptText);
     if (result.error) {
       let e = vm.dump(result.error);
       result.error.dispose();
@@ -88,6 +87,8 @@ const executeQuickJsVm = ({ script: externalScript, context: externalContext, sc
     }
   } catch (error) {
     console.error('Error executing the script!', error);
+  } finally {
+    managedQuickJsContext?.dispose();
   }
 };
 
@@ -97,9 +98,11 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
   }
   externalScript = externalScript?.trim();
 
+  let managedQuickJsContext;
   try {
-    const module = await newQuickJSWASMModule();
-    const vm = module.newContext();
+    const module = await loader();
+    managedQuickJsContext = createManagedQuickJsContext(module);
+    const vm = managedQuickJsContext.vm;
 
     // add crypto utilities required by the crypto-js library in bundledCode
     await addCryptoUtilsShimToContext(vm);
@@ -128,21 +131,32 @@ const executeQuickJsVmAsync = async ({ script: externalScript, context: external
 
     const script = wrapScriptInClosure(externalScript, SANDBOX.QUICKJS);
 
-    const result = vm.evalCode(script, scriptPath);
+    const result = vm.evalCodeRetained(script, scriptPath);
     const promiseHandle = vm.unwrapResult(result);
     const resolvedResult = await vm.resolvePromise(promiseHandle);
     promiseHandle.dispose();
     const resolvedHandle = vm.unwrapResult(resolvedResult);
     resolvedHandle.dispose();
-    // vm.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`.
+    try {
+      await managedQuickJsContext?.waitForPendingDeferreds?.();
+      managedQuickJsContext?.dispose();
+    } catch (teardownError) {
+      throw teardownError;
+    }
   }
 };
 
 module.exports = {
   executeQuickJsVm,
-  executeQuickJsVmAsync
+  executeQuickJsVmAsync,
+  loader
 };

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

@@ -117,6 +117,12 @@ const addBruShimToContext = (vm, bru) => {
   vm.setProp(bruObject, 'getAllGlobalEnvVars', getAllGlobalEnvVars);
   getAllGlobalEnvVars.dispose();
 
+  let 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 () {
@@ -401,10 +407,20 @@ 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) => {
+    bru._currentScope = vm.dump(scopeArg) || null;
+  });
+  setScopeHandle.consume((handle) => vm.setProp(vm.global, '__bruSetScope', handle));
+
   const sleep = vm.newFunction('sleep', (timer) => {
     const t = vm.getString(timer);
     const promise = vm.newPromise();
     setTimeout(() => {
+      // The VM may have been disposed while this native timer was pending
+      // (e.g. a setTimeout/sleep whose promise the script never awaited).
+      // Touching the VM after teardown throws QuickJSUseAfterFree, so bail out.
+      if (!vm.alive) return;
       promise.resolve(vm.newString('slept'));
     }, t);
     promise.settled.then(vm.runtime.executePendingJobs);

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

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

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

@@ -1,4 +1,5 @@
 const { marshallToVm } = require('../utils');
+const { createPropertyListBridge } = require('../utils/property-list-bridge');
 
 // Marshal a QuickJS query argument to a host-compatible value.
 // Function handles are wrapped as native callbacks; other values are dumped as-is.
@@ -34,25 +35,43 @@ const addBrunoResponseShimToContext = (vm, res) => {
 
   const status = marshallToVm(res?.status, vm);
   const statusText = marshallToVm(res?.statusText, vm);
-  const headers = marshallToVm(res?.headers, vm);
   const body = marshallToVm(res?.body, vm);
   const responseTime = marshallToVm(res?.responseTime, vm);
   const url = marshallToVm(res?.url, vm);
 
   vm.setProp(resFn, 'status', status);
   vm.setProp(resFn, 'statusText', statusText);
-  vm.setProp(resFn, 'headers', headers);
   vm.setProp(resFn, 'body', body);
   vm.setProp(resFn, 'responseTime', responseTime);
   vm.setProp(resFn, 'url', url);
 
   status.dispose();
-  headers.dispose();
   body.dispose();
   responseTime.dispose();
   url.dispose();
   statusText.dispose();
 
+  // res.headers — plain headers object for backward-compatible bracket access
+  const headersVal = marshallToVm(res?.headers || {}, vm);
+  vm.setProp(resFn, 'headers', headersVal);
+  headersVal.dispose();
+
+  // res.headerList — read-only PropertyList bridge for structured header operations
+  let resHeadersEvalCode = '';
+  if (res?.headerList) {
+    const headerListObj = vm.newObject();
+    const bridge = createPropertyListBridge(vm, res.headerList, headerListObj, {
+      globalPath: 'globalThis.res.headerList',
+      syncReadMethods: ['get', 'has', 'count', 'indexOf', 'toObject', 'toString'],
+      syncReadObjectMethods: ['one', 'all', 'toJSON'],
+      syncWriteMethods: ['add', 'upsert', 'remove', 'clear', 'populate', 'repopulate', 'assimilate'],
+      withIterators: true
+    });
+    resHeadersEvalCode = bridge.evalCode;
+    vm.setProp(resFn, 'headerList', headerListObj);
+    headerListObj.dispose();
+  }
+
   let getStatusText = vm.newFunction('getStatusText', function () {
     return marshallToVm(res.getStatusText(), vm);
   });
@@ -109,6 +128,12 @@ const addBrunoResponseShimToContext = (vm, res) => {
 
   vm.setProp(vm.global, 'res', resFn);
   resFn.dispose();
+
+  // Evaluate iterator code after res is on global (iterators reference globalThis.res.headerList)
+  // Wrapped in a block to avoid const redeclaration conflicts with req.headerList's evalCode
+  if (resHeadersEvalCode) {
+    vm.evalCode(`{ ${resHeadersEvalCode} }`);
+  }
 };
 
 module.exports = addBrunoResponseShimToContext;

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

@@ -79,6 +79,179 @@ const addBruShimToContext = (vm, __brunoTestResults) => {
       })();
     `
   );
+  // Register custom chai assertion for jsonSchema (expect(...).to.have.jsonSchema(schema, options))
+  vm.evalCode(
+    `
+      (function() {
+        var Ajv = require('ajv');
+        var addFormats = require('ajv-formats');
+        var defaultAjv = new Ajv({ allErrors: true });
+        addFormats(defaultAjv);
+        var SUPPORTED_SCHEMA_VERSIONS = [
+          'http://json-schema.org/draft-07/schema#',
+          'http://json-schema.org/draft-07/schema'
+        ];
+        var proto = Object.getPrototypeOf(expect(null));
+        proto.jsonSchema = function(schema, ajvOptions) {
+          if (schema && schema.$schema && !SUPPORTED_SCHEMA_VERSIONS.includes(schema.$schema)) {
+            this.assert(
+              false,
+              'Unsupported JSON Schema version: "' + schema.$schema + '". Bruno currently only supports Draft-07 (http://json-schema.org/draft-07/schema#). Please update your schema to be Draft-07 compatible and remove the $schema property.',
+              'Unsupported JSON Schema version: "' + schema.$schema + '".'
+            );
+          }
+          var ajv;
+          if (ajvOptions) {
+            ajv = new Ajv(Object.assign({ allErrors: true }, ajvOptions));
+            addFormats(ajv);
+          } else {
+            ajv = defaultAjv;
+          }
+          var validate;
+          try {
+            validate = ajv.compile(schema);
+          } catch (e) {
+            this.assert(false, 'JSON schema compile error: ' + e.message, 'JSON schema compile error: ' + e.message);
+          }
+          var data = this._obj;
+          var isValid = validate(data);
+
+          var dataStr;
+          try { dataStr = JSON.stringify(data); } catch (e) { dataStr = '[unserializable value]'; }
+          this.assert(
+            isValid,
+            'expected ' + dataStr + ' to match JSON schema, validation errors: ' + (validate.errors ? JSON.stringify(validate.errors) : 'none'),
+            'expected ' + dataStr + ' to not match JSON schema'
+          );
+          return this;
+        };
+      })();
+    `
+  );
+  // Register custom chai assertion for jsonBody (Postman parity)
+  vm.evalCode(
+    `
+      (function() {
+        var proto = Object.getPrototypeOf(expect(null));
+
+        // Parse a property path into an array of keys.
+        // Handles: dot notation (a.b), numeric brackets (a[0]), quoted brackets (a["b.c"], a['key']),
+        // and combinations like data[0]["a.b"].name
+        //
+        // Examples:
+        //   "a.b.c"              -> ["a", "b", "c"]
+        //   "items[0].name"      -> ["items", "0", "name"]
+        //   'data["a.b"]'        -> ["data", "a.b"]
+        //   "matrix[0][1]"       -> ["matrix", "0", "1"]
+        //   'nested["x.y"].z'    -> ["nested", "x.y", "z"]
+        //   '["say \\"hi\\""]'   -> ["say \\"hi\\""]
+        function parsePath(path) {
+          var keys = [];
+          var i = 0;
+          while (i < path.length) {
+            if (path[i] === '.') {
+              i++;
+            } else if (path[i] === '[') {
+              i++;
+              if (i < path.length && (path[i] === "'" || path[i] === '"')) {
+                var quote = path[i];
+                i++;
+                var key = '';
+                while (i < path.length && path[i] !== quote) {
+                  if (path[i] === '\\\\' && i + 1 < path.length && path[i + 1] === quote) {
+                    key += quote;
+                    i += 2;
+                  } else {
+                    key += path[i];
+                    i++;
+                  }
+                }
+                i++; // skip closing quote
+                i++; // skip ']'
+                keys.push(key);
+              } else {
+                var key = '';
+                while (i < path.length && path[i] !== ']') {
+                  key += path[i];
+                  i++;
+                }
+                i++; // skip ']'
+                keys.push(key);
+              }
+            } else {
+              var key = '';
+              while (i < path.length && path[i] !== '.' && path[i] !== '[') {
+                key += path[i];
+                i++;
+              }
+              keys.push(key);
+            }
+          }
+          return keys;
+        }
+
+        function getNestedValue(obj, path) {
+          var keys = parsePath(path);
+          var current = obj;
+          for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            if (current === null || current === undefined || !Object.prototype.hasOwnProperty.call(Object(current), key)) {
+              return { found: false };
+            }
+            current = current[key];
+          }
+          return { found: true, value: current };
+        }
+
+        function deepEqual(a, b) {
+          if (a === b) return true;
+          if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
+          if (Array.isArray(a) !== Array.isArray(b)) return false;
+          var keysA = Object.keys(a);
+          var keysB = Object.keys(b);
+          if (keysA.length !== keysB.length) return false;
+          for (var i = 0; i < keysA.length; i++) {
+            if (!Object.prototype.hasOwnProperty.call(b, keysA[i]) || !deepEqual(a[keysA[i]], b[keysA[i]])) return false;
+          }
+          return true;
+        }
+
+        proto.jsonBody = function() {
+          var obj = this._obj;
+          var args = Array.prototype.slice.call(arguments);
+
+          if (args.length === 0) {
+            this.assert(
+              typeof obj === 'object' && obj !== null,
+              'expected value to be a JSON body (object or array)',
+              'expected value not to be a JSON body'
+            );
+          } else if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null) {
+            this.assert(
+              deepEqual(obj, args[0]),
+              'expected body to deeply equal given object',
+              'expected body to not deeply equal given object'
+            );
+          } else if (args.length === 1) {
+            var result = getNestedValue(obj, String(args[0]));
+            this.assert(
+              result.found,
+              "expected body to have nested property '" + args[0] + "'",
+              "expected body to not have nested property '" + args[0] + "'"
+            );
+          } else {
+            var result = getNestedValue(obj, String(args[0]));
+            this.assert(
+              result.found && deepEqual(result.value, args[1]),
+              "expected body to have nested property '" + args[0] + "' equal to given value",
+              "expected body to not have nested property '" + args[0] + "' equal to given value"
+            );
+          }
+          return this;
+        };
+      })();
+    `
+  );
 };
 
 module.exports = addBruShimToContext;

package/src/sandbox/quickjs/utils/index.js

@@ -1,3 +1,130 @@
+/**
+ * Creates a QuickJS context with centralized lifecycle management:
+ * - vm.evalCode() auto-disposes result handles (for shim setup code)
+ * - vm.evalCodeRetained() returns the raw result (for user script execution)
+ * - all newObject/newFunction/newArray handles are tracked and disposed on teardown
+ */
+const createManagedQuickJsContext = (module) => {
+  const vm = module.newContext();
+  const disposeTracked = trackQuickJsContext(vm);
+  const evalCodeRetained = vm.evalCode.bind(vm);
+  const waitForPendingDeferreds = trackPendingDeferreds(vm);
+
+  vm.evalCode = (code, filename = 'eval.js') => {
+    const result = evalCodeRetained(code, filename);
+    if (result.error) {
+      const error = vm.dump(result.error);
+      result.error.dispose();
+      throw error;
+    }
+    result.value.dispose();
+  };
+
+  vm.evalCodeRetained = evalCodeRetained;
+
+  return {
+    vm,
+    waitForPendingDeferreds,
+    dispose: () => disposeQuickJsContext(vm, disposeTracked)
+  };
+};
+
+/**
+ * Track every deferred created by the async shims (sendRequest, axios, cookie
+ * jar, sleep, ...) so teardown can wait for them to settle. A user script that
+ * fires-and-forgets async work (e.g. an un-awaited setTimeout) resolves the
+ * wrapping closure immediately; without this, the VM is disposed before the
+ * deferred's host callback runs, and touching the freed context throws
+ * `QuickJSUseAfterFree`. Each `.settled` resolves once the deferred is
+ * resolved/rejected, so awaiting them keeps the context alive long enough.
+ *
+ * The hook is installed now (at context creation) so it captures promises as
+ * the script runs. Returns a function that drains the captured deferreds at
+ * teardown; new deferreds can be created while we wait (a chained timer), so it
+ * drains in place until none remain.
+ */
+
+const trackPendingDeferreds = (vm) => {
+  const pendingDeferreds = [];
+  const originalNewPromise = vm.newPromise.bind(vm);
+  vm.newPromise = (...args) => {
+    const deferred = originalNewPromise(...args);
+    pendingDeferreds.push(deferred.settled.catch(() => { }));
+    return deferred;
+  };
+
+  return async () => {
+    while (pendingDeferreds.length) {
+      const batch = pendingDeferreds.splice(0);
+      await Promise.all(batch);
+    }
+  };
+};
+
+/**
+ * Tracks handles created via newObject/newFunction/newArray so they can all be
+ * disposed before the context. quickjs-emscripten requires every heap handle to
+ * be disposed individually; shims attach then drop their ref via .dispose().
+ */
+const trackQuickJsContext = (vm) => {
+  const handles = [];
+
+  const track = (handle) => {
+    handles.push(handle);
+    return handle;
+  };
+
+  // Replace an allocator with a wrapper that records every handle it returns,
+  // so teardown can dispose them all. Behaviour is otherwise identical.
+  const trackAllocations = (method) => {
+    const original = vm[method]?.bind(vm);
+    if (!original) {
+      return;
+    }
+
+    vm[method] = (...args) => track(original(...args));
+  };
+
+  ['newObject', 'newFunction', 'newArray'].forEach(trackAllocations);
+
+  // Dispose newest-first: later handles may reference earlier ones.
+  return () => {
+    for (const handle of handles.reverse()) {
+      if (handle?.alive) {
+        handle.dispose();
+      }
+    }
+  };
+};
+
+/**
+ * Clears shim globals, drains pending QuickJS jobs, and disposes the context.
+ * Pass disposeTracked from trackQuickJsContext() to free shim handles first.
+ */
+const disposeQuickJsContext = (vm, disposeTracked) => {
+  if (!vm?.alive) {
+    return;
+  }
+
+  if (typeof disposeTracked === 'function') {
+    disposeTracked();
+  }
+
+  // Drain the runtime's pending job queue (resolved/rejected promise callbacks)
+  // before disposing. Executing a job can schedule more jobs (chained `.then()`s),
+  // so we keep going until `hasPendingJob()` reports the queue is empty or a job
+  // throws.
+  while (vm.runtime?.hasPendingJob?.()) {
+    const result = vm.runtime.executePendingJobs();
+    // On error, dispose the error handle and stop draining.
+    if (result.error) {
+      result.error.dispose();
+      break;
+    }
+  }
+  vm.dispose();
+};
+
 const marshallToVm = (value, vm) => {
   if (value === undefined) {
     return vm.undefined;
@@ -79,5 +206,8 @@ async function invokeFunction(vm, quickFn, args = []) {
 
 module.exports = {
   marshallToVm,
-  invokeFunction
+  invokeFunction,
+  createManagedQuickJsContext,
+  disposeQuickJsContext,
+  trackQuickJsContext
 };

package/src/sandbox/quickjs/utils/property-list-bridge.js

@@ -81,6 +81,7 @@ const createPropertyListBridge = (vm, nativeList, targetObj, options) => {
     globalPath,
     syncReadMethods = [],
     syncReadObjectMethods = [],
+    syncWriteMethods = [],
     asyncWriteMethods = [],
     withIterators = false
   } = options;
@@ -103,6 +104,16 @@ const createPropertyListBridge = (vm, nativeList, targetObj, options) => {
     fn.consume((handle) => vm.setProp(targetObj, methodName, handle));
   }
 
+  // Sync write methods — void return, just call and discard
+  for (const methodName of syncWriteMethods) {
+    const fn = vm.newFunction(methodName, (...vmArgs) => {
+      const args = vmArgs.map((a) => vm.dump(a));
+      nativeList[methodName](...args);
+      return vm.undefined;
+    });
+    fn.consume((handle) => vm.setProp(targetObj, methodName, handle));
+  }
+
   // Async write methods — two-phase setup:
   // Phase 1 (native): Register `_prefixed` bridge functions (e.g. `_add`, `_remove`) via
   // createAsyncBridge. These are QuickJS promise-based wrappers that call the native method's
@@ -149,11 +160,25 @@ const createPropertyListBridge = (vm, nativeList, targetObj, options) => {
   // operation inside the VM where the callback lives. Requires `all` in `syncReadObjectMethods`.
   if (withIterators) {
     evalCode += `const _allNative = ${globalPath}.all;
-    ${globalPath}.each = (fn) => { _allNative().forEach(fn); };
-    ${globalPath}.filter = (fn) => _allNative().filter(fn);
-    ${globalPath}.find = (fn) => _allNative().find(fn);
-    ${globalPath}.map = (fn) => _allNative().map(fn);
-    ${globalPath}.reduce = (fn, ...rest) => rest.length ? _allNative().reduce(fn, rest[0]) : _allNative().reduce(fn);\n`;
+    ${globalPath}.each = (fn, ctx) => { const b = ctx !== undefined ? fn.bind(ctx) : fn; _allNative().forEach(b); };
+    ${globalPath}.filter = (fn, ctx) => { const b = ctx !== undefined ? fn.bind(ctx) : fn; return _allNative().filter(b); };
+    ${globalPath}.find = (fn, ctx) => { const b = ctx !== undefined ? fn.bind(ctx) : fn; return _allNative().find(b); };
+    ${globalPath}.map = (fn, ctx) => { const b = ctx !== undefined ? fn.bind(ctx) : fn; return _allNative().map(b); };
+    ${globalPath}.reduce = (fn, ...rest) => { const ctx = rest.length > 1 ? rest[1] : undefined; const b = ctx !== undefined ? fn.bind(ctx) : fn; return rest.length > 0 ? _allNative().reduce(b, rest[0]) : _allNative().reduce(b); };\n`;
+  }
+
+  // Override `remove` when it's a syncWriteMethod so function predicates work in-VM.
+  // The native bridge can't serialize function handles (vm.dump fails on functions).
+  // Instead: pull items via all(), run the predicate in-VM, call native remove(key) per match.
+  if (withIterators && syncWriteMethods.includes('remove')) {
+    evalCode += `const _removeNative = ${globalPath}.remove;
+    ${globalPath}.remove = (predicate) => {
+      if (typeof predicate === 'function') {
+        _allNative().filter(predicate).forEach(item => _removeNative(item.key));
+      } else {
+        _removeNative(predicate);
+      }
+    };\n`;
   }
 
   return { evalCode };