From d32c6f6ce2776e1f0ed1dfda018dda1674b9910f Mon Sep 17 00:00:00 2001
From: agape1225 <49804691+agape1225@users.noreply.github.com>
Date: Wed, 30 Sep 2026 18:46:31 +0900
Subject: [PATCH 1/2] vm: allow sharing a microtask queue across contexts

Add `vm.createMicrotaskQueue()` and extend the `microtaskMode` option
to accept `{ type: 'manual', queue }`, so multiple vm contexts can
share a single, explicitly-drained microtask queue instead of each
having its own privately auto-drained one. This lets embedders (e.g.
implementing a Window/iframe pair) reproduce the spec's
same-microtask-queue ordering guarantees, which was not previously
possible from the public API.

`'afterEvaluate'` and `{ type: 'manual', queue }` are mutually
exclusive by construction, since they are two different values of the
same option.

Refs: https://github.com/nodejs/node/issues/65555
Signed-off-by: agape1225 <49804691+agape1225@users.noreply.github.com>
---
 doc/api/vm.md                                 | 103 ++++++++-
 lib/vm.js                                     |  59 ++++-
 src/env_properties.h                          |   1 +
 src/node_contextify.cc                        |  78 ++++++-
 src/node_contextify.h                         |  43 ++++
 .../test-vm-shared-microtask-queue-gc.js      |  30 +++
 ...st-vm-shared-microtask-queue-validation.js |  63 +++++
 .../test-vm-shared-microtask-queue.js         | 215 ++++++++++++++++++
 8 files changed, 568 insertions(+), 24 deletions(-)
 create mode 100644 test/parallel/test-vm-shared-microtask-queue-gc.js
 create mode 100644 test/parallel/test-vm-shared-microtask-queue-validation.js
 create mode 100644 test/parallel/test-vm-shared-microtask-queue.js

diff --git a/doc/api/vm.md b/doc/api/vm.md
index 14cd1f269b12..acb2bb07814a 100644
--- a/doc/api/vm.md
+++ b/doc/api/vm.md
@@ -313,10 +313,18 @@ changes:
       `EvalError`. **Default:** `true`.
     * `wasm` {boolean} If set to false any attempt to compile a WebAssembly
       module will throw a `WebAssembly.CompileError`. **Default:** `true`.
-  * `microtaskMode` {string} If set to `afterEvaluate`, microtasks (tasks
-    scheduled through `Promise`s and `async function`s) will be run immediately
-    after the script has run. They are included in the `timeout` and
-    `breakOnSigint` scopes in that case.
+  * `microtaskMode` {string|Object}
+    * If set to the string `'afterEvaluate'`, microtasks (tasks
+      scheduled through `Promise`s and `async function`s) will be run
+      immediately after the script has run. They are included in the
+      `timeout` and `breakOnSigint` scopes in that case.
+    * If set to an object of the form `{ type: 'manual', queue }`, where
+      `queue` is a [`vm.MicrotaskQueue`][] created via
+      [`vm.createMicrotaskQueue()`][], microtasks scheduled while running the
+      script are placed on `queue` instead of being drained automatically.
+      `queue` may be shared with other contexts so that microtasks from all
+      of them can be drained together, in the order they were scheduled, via
+      a single explicit [`microtaskQueue.runMicrotasks()`][] call.
 * Returns: {any} the result of the very last statement executed in the script.
 
 This method is a shortcut to `script.runInContext(vm.createContext(options), options)`.
@@ -1318,6 +1326,35 @@ added:
 
 A `ModuleRequest` represents the request to import a module with given import attributes and phase.
 
+## Class: `vm.MicrotaskQueue`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+An explicit microtask queue that can be attached to multiple contexts (via
+the `microtaskMode` option of [`vm.createContext()`][],
+[`vm.runInNewContext()`][], and [`script.runInNewContext()`][]) so that they
+share where their microtasks (`Promise` reactions and `async function`
+continuations) are placed, and so that those microtasks are drained together,
+explicitly, by the embedder, instead of automatically by Node.js.
+
+Instances are created with [`vm.createMicrotaskQueue()`][]; there is no
+public constructor.
+
+### `microtaskQueue.runMicrotasks()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Synchronously runs every microtask currently queued on `microtaskQueue`, in
+the order in which they were scheduled. If running a microtask schedules
+further microtasks on the same queue, those are run as well before this
+method returns.
+
 ## `vm.compileFunction(code[, params[, options]])`
 
 <!-- YAML
@@ -1470,10 +1507,19 @@ changes:
       `EvalError`. **Default:** `true`.
     * `wasm` {boolean} If set to false any attempt to compile a WebAssembly
       module will throw a `WebAssembly.CompileError`. **Default:** `true`.
-  * `microtaskMode` {string} If set to `afterEvaluate`, microtasks (tasks
-    scheduled through `Promise`s and `async function`s) will be run immediately
-    after a script has run through [`script.runInContext()`][].
-    They are included in the `timeout` and `breakOnSigint` scopes in that case.
+  * `microtaskMode` {string|Object}
+    * If set to the string `'afterEvaluate'`, microtasks (tasks
+      scheduled through `Promise`s and `async function`s) will be run
+      immediately after a script has run through [`script.runInContext()`][].
+      They are included in the `timeout` and `breakOnSigint` scopes in that
+      case.
+    * If set to an object of the form `{ type: 'manual', queue }`, where
+      `queue` is a [`vm.MicrotaskQueue`][] created via
+      [`vm.createMicrotaskQueue()`][], microtasks scheduled inside the new
+      context are placed on `queue` instead of being drained automatically.
+      `queue` may be shared with other contexts so that microtasks from all
+      of them can be drained together, in the order they were scheduled, via
+      a single explicit [`microtaskQueue.runMicrotasks()`][] call.
   * `importModuleDynamically`
     {Function|vm.constants.USE\_MAIN\_CONTEXT\_DEFAULT\_LOADER}
     Used to specify the how the modules should be loaded when `import()` is
@@ -1542,6 +1588,19 @@ context.
 The provided `name` and `origin` of the context are made visible through the
 Inspector API.
 
+## `vm.createMicrotaskQueue()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {vm.MicrotaskQueue}
+
+Creates a new [`vm.MicrotaskQueue`][] that can be passed as the `queue` of a
+`{ type: 'manual', queue }` value for the `microtaskMode` option of
+[`vm.createContext()`][], so that multiple contexts can share where their
+microtasks are placed. See [`vm.MicrotaskQueue`][] for details.
+
 ## `vm.isContext(object)`
 
 <!-- YAML
@@ -1819,10 +1878,18 @@ changes:
     experimental modules API. We do not recommend using it in a production
     environment. For detailed information, see
     [Support of dynamic `import()` in compilation APIs][].
-  * `microtaskMode` {string} If set to `afterEvaluate`, microtasks (tasks
-    scheduled through `Promise`s and `async function`s) will be run immediately
-    after the script has run. They are included in the `timeout` and
-    `breakOnSigint` scopes in that case.
+  * `microtaskMode` {string|Object}
+    * If set to the string `'afterEvaluate'`, microtasks (tasks
+      scheduled through `Promise`s and `async function`s) will be run
+      immediately after the script has run. They are included in the
+      `timeout` and `breakOnSigint` scopes in that case.
+    * If set to an object of the form `{ type: 'manual', queue }`, where
+      `queue` is a [`vm.MicrotaskQueue`][] created via
+      [`vm.createMicrotaskQueue()`][], microtasks scheduled while running the
+      script are placed on `queue` instead of being drained automatically.
+      `queue` may be shared with other contexts so that microtasks from all
+      of them can be drained together, in the order they were scheduled, via
+      a single explicit [`microtaskQueue.runMicrotasks()`][] call.
 * Returns: {any} the result of the very last statement executed in the script.
 
 This method is a shortcut to
@@ -2352,6 +2419,13 @@ the ECMAScript specification for [enqueuing jobs][], by allowing asynchronous
 tasks from different contexts to run in a different order than they were
 enqueued.
 
+Contexts that need to share promises without departing from the
+specification's ordering guarantees can instead attach the same
+[`vm.MicrotaskQueue`][] to each of them (`microtaskMode: { type: 'manual',
+queue }`) and call [`microtaskQueue.runMicrotasks()`][] explicitly, once,
+whenever a checkpoint is due; microtasks from every context sharing `queue`
+then run together, in the order they were scheduled.
+
 ## Support of dynamic `import()` in compilation APIs
 
 The following APIs support an `importModuleDynamically` option to enable dynamic
@@ -2577,17 +2651,22 @@ const { Script, SyntheticModule } = require('node:vm');
 [`Error`]: errors.md#class-error
 [`URL`]: url.md#class-url
 [`eval()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
+[`microtaskQueue.runMicrotasks()`]: #microtaskqueuerunmicrotasks
 [`optionsExpression`]: https://tc39.es/proposal-import-attributes/#sec-evaluate-import-call
 [`script.runInContext()`]: #scriptrunincontextcontextifiedobject-options
+[`script.runInNewContext()`]: #scriptruninnewcontextcontextobject-options
 [`script.runInThisContext()`]: #scriptruninthiscontextoptions
 [`sourceTextModule.instantiate()`]: #sourcetextmoduleinstantiate
 [`sourceTextModule.linkRequests(modules)`]: #sourcetextmodulelinkrequestsmodules
 [`sourceTextModule.moduleRequests`]: #sourcetextmodulemodulerequests
 [`url.origin`]: url.md#urlorigin
+[`vm.MicrotaskQueue`]: #class-vmmicrotaskqueue
 [`vm.compileFunction()`]: #vmcompilefunctioncode-params-options
 [`vm.constants.DONT_CONTEXTIFY`]: #vmconstantsdont_contextify
 [`vm.createContext()`]: #vmcreatecontextcontextobject-options
+[`vm.createMicrotaskQueue()`]: #vmcreatemicrotaskqueue
 [`vm.runInContext()`]: #vmrunincontextcode-contextifiedobject-options
+[`vm.runInNewContext()`]: #vmruninnewcontextcode-contextobject-options
 [`vm.runInThisContext()`]: #vmruninthiscontextcode-options
 [contextified]: #what-does-it-mean-to-contextify-an-object
 [enqueuing jobs]: https://tc39.es/ecma262/#sec-hostenqueuepromisejob
diff --git a/lib/vm.js b/lib/vm.js
index 2c7446af6076..a9c82b9a1513 100644
--- a/lib/vm.js
+++ b/lib/vm.js
@@ -32,6 +32,8 @@ const {
 
 const {
   ContextifyScript,
+  MicrotaskQueue: ContextifyMicrotaskQueue,
+  isMicrotaskQueue,
   makeContext,
   constants,
   measureMemory: _measureMemory,
@@ -194,6 +196,50 @@ function getRunInContextArgs(contextifiedObject, options = kEmptyObject) {
   };
 }
 
+class MicrotaskQueue extends ContextifyMicrotaskQueue {}
+
+function createMicrotaskQueue() {
+  return new MicrotaskQueue();
+}
+
+/**
+ * Validates and normalizes the `microtaskMode` option shared by
+ * `vm.createContext()`, `vm.runInNewContext()`, and `script.runInNewContext()`.
+ *
+ * `microtaskMode` accepts either:
+ * - the string `'afterEvaluate'` (unchanged legacy behavior: the context gets
+ *   its own private microtask queue that is drained automatically after
+ *   every evaluation), or
+ * - an object `{ type: 'manual', queue }`, where `queue` is a
+ *   `vm.MicrotaskQueue` created via `vm.createMicrotaskQueue()`, that the
+ *   context should share with other contexts. Draining only happens when the
+ *   caller explicitly calls `queue.runMicrotasks()`.
+ * These two forms are mutually exclusive by construction: a context is either
+ * drained automatically (with a private queue) or shared-and-manual, never
+ * both, so there is no "shared queue that also auto-drains" combination to
+ * reason about.
+ * @param {undefined | 'afterEvaluate' | { type: string, queue: unknown }}
+ *   microtaskMode
+ * @returns {{ afterEvaluate: boolean, queueHandle: MicrotaskQueue|undefined }}
+ */
+function getMicrotaskModeOptions(microtaskMode) {
+  if (microtaskMode === undefined) {
+    return { afterEvaluate: false, queueHandle: undefined };
+  }
+  if (typeof microtaskMode === 'string') {
+    validateOneOf(microtaskMode, 'options.microtaskMode', ['afterEvaluate']);
+    return { afterEvaluate: true, queueHandle: undefined };
+  }
+  validateObject(microtaskMode, 'options.microtaskMode');
+  const { type, queue } = microtaskMode;
+  validateOneOf(type, 'options.microtaskMode.type', ['manual']);
+  if (!isMicrotaskQueue(queue)) {
+    throw new ERR_INVALID_ARG_TYPE(
+      'options.microtaskMode.queue', 'vm.MicrotaskQueue', queue);
+  }
+  return { afterEvaluate: false, queueHandle: queue };
+}
+
 function getContextOptions(options) {
   if (!options)
     return {};
@@ -217,8 +263,7 @@ function getContextOptions(options) {
       validateBoolean(wasm, 'options.contextCodeGeneration.wasm');
     contextOptions.codeGeneration = { strings, wasm };
   }
-  if (options.microtaskMode !== undefined)
-    validateString(options.microtaskMode, 'options.microtaskMode');
+  getMicrotaskModeOptions(options.microtaskMode);
   return contextOptions;
 }
 
@@ -252,15 +297,14 @@ function createContext(contextObject = { __proto__: ObjectPrototype }, options =
     validateBoolean(wasm, 'options.codeGeneration.wasm');
   }
 
-  validateOneOf(microtaskMode,
-                'options.microtaskMode',
-                ['afterEvaluate', undefined]);
-  const microtaskQueue = (microtaskMode === 'afterEvaluate');
+  const { afterEvaluate, queueHandle } = getMicrotaskModeOptions(microtaskMode);
 
   const hostDefinedOptionId =
     getHostDefinedOptionId(importModuleDynamically, name);
 
-  const result = makeContext(contextObject, name, origin, strings, wasm, microtaskQueue, hostDefinedOptionId);
+  const result = makeContext(
+    contextObject, name, origin, strings, wasm,
+    queueHandle ?? afterEvaluate, hostDefinedOptionId);
   // Register the context scope callback after the context was initialized.
   registerImportModuleDynamically(result, importModuleDynamically);
   return result;
@@ -411,6 +455,7 @@ module.exports = {
   runInThisContext,
   isContext,
   compileFunction,
+  createMicrotaskQueue,
   measureMemory,
   constants: vmConstants,
 };
diff --git a/src/env_properties.h b/src/env_properties.h
index 087193faba98..dd4e7b664a0f 100644
--- a/src/env_properties.h
+++ b/src/env_properties.h
@@ -437,6 +437,7 @@
   V(lock_info_template, v8::DictionaryTemplate)                                \
   V(lock_query_template, v8::DictionaryTemplate)                               \
   V(message_port_constructor_template, v8::FunctionTemplate)                   \
+  V(microtask_queue_constructor_template, v8::FunctionTemplate)                 \
   V(module_wrap_constructor_template, v8::FunctionTemplate)                    \
   V(mx_record_template, v8::DictionaryTemplate)                                \
   V(naptr_record_template, v8::DictionaryTemplate)                             \
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
index 838a65c1ff35..b5e32e07bff9 100644
--- a/src/node_contextify.cc
+++ b/src/node_contextify.cc
@@ -153,10 +153,10 @@ ContextifyContext* ContextifyContext::New(Environment* env,
 
   const SnapshotData* snapshot_data = env->isolate_data()->snapshot_data();
 
-  MicrotaskQueue* queue =
-      options->own_microtask_queue
-          ? options->own_microtask_queue.get()
-          : env->isolate()->GetCurrentContext()->GetMicrotaskQueue();
+  MicrotaskQueue* queue = options->own_microtask_queue.get();
+  if (queue == nullptr) queue = options->shared_microtask_queue.get();
+  if (queue == nullptr)
+    queue = env->isolate()->GetCurrentContext()->GetMicrotaskQueue();
 
   Local<Context> v8_context;
   if (!(CreateV8Context(env->isolate(), object_template, snapshot_data, queue)
@@ -178,7 +178,8 @@ ContextifyContext::ContextifyContext(Environment* env,
                                      ContextOptions* options)
     : microtask_queue_(options->own_microtask_queue
                            ? options->own_microtask_queue.release()
-                           : nullptr) {
+                           : nullptr),
+      shared_microtask_queue_(std::move(options->shared_microtask_queue)) {
   CppgcMixin::Wrap(this, env, wrapper);
 
   context_.Reset(env->isolate(), v8_context);
@@ -445,6 +446,15 @@ void ContextifyContext::MakeContext(const FunctionCallbackInfo<Value>& args) {
   if (args[5]->IsBoolean() && args[5]->BooleanValue(env->isolate())) {
     options.own_microtask_queue =
         MicrotaskQueue::New(env->isolate(), MicrotasksPolicy::kExplicit);
+  } else if (args[5]->IsObject()) {
+    CHECK(env->microtask_queue_constructor_template()->HasInstance(args[5]));
+    // A vm.MicrotaskQueue (options.microtaskMode = { type: 'manual', queue })
+    // is not exclusively owned by this context, so it's stored separately
+    // from own_microtask_queue: see ContextOptions::shared_microtask_queue
+    // and ContextifyContext::microtask_queue().
+    ContextifyMicrotaskQueue* queue;
+    ASSIGN_OR_RETURN_UNWRAP(&queue, args[5].As<Object>());
+    options.shared_microtask_queue = queue->microtask_queue();
   }
 
   CHECK(args[6]->IsSymbol());
@@ -2027,6 +2037,62 @@ static void MeasureMemory(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(promise);
 }
 
+void ContextifyMicrotaskQueue::CreatePerIsolateProperties(
+    IsolateData* isolate_data, Local<ObjectTemplate> target) {
+  Isolate* isolate = isolate_data->isolate();
+
+  Local<FunctionTemplate> tmpl = NewFunctionTemplate(isolate, New);
+  tmpl->InstanceTemplate()->SetInternalFieldCount(
+      BaseObject::kInternalFieldCount);
+  SetProtoMethod(isolate, tmpl, "runMicrotasks", RunMicrotasks);
+
+  SetConstructorFunction(isolate, target, "MicrotaskQueue", tmpl);
+  isolate_data->set_microtask_queue_constructor_template(tmpl);
+  SetMethod(isolate, target, "isMicrotaskQueue", IsMicrotaskQueue);
+}
+
+void ContextifyMicrotaskQueue::RegisterExternalReferences(
+    ExternalReferenceRegistry* registry) {
+  registry->Register(New);
+  registry->Register(RunMicrotasks);
+  registry->Register(IsMicrotaskQueue);
+}
+
+ContextifyMicrotaskQueue::ContextifyMicrotaskQueue(Environment* env,
+                                                   Local<Object> wrap)
+    : BaseObject(env, wrap),
+      microtask_queue_(
+          MicrotaskQueue::New(env->isolate(), MicrotasksPolicy::kExplicit)) {
+  // Nothing outside this wrapper needs to keep it alive: once no JS
+  // reference to it remains, it's fine for it to be collected. The
+  // underlying v8::MicrotaskQueue stays alive independently, for as long as
+  // any ContextifyContext still holds a shared_ptr copy of it (see
+  // ContextOptions::shared_microtask_queue).
+  MakeWeak();
+}
+
+// new vm.MicrotaskQueue()
+void ContextifyMicrotaskQueue::New(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(args.IsConstructCall());
+  new ContextifyMicrotaskQueue(env, args.This());
+}
+
+void ContextifyMicrotaskQueue::IsMicrotaskQueue(
+    const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  args.GetReturnValue().Set(
+      env->microtask_queue_constructor_template()->HasInstance(args[0]));
+}
+
+// queue.runMicrotasks()
+void ContextifyMicrotaskQueue::RunMicrotasks(
+    const FunctionCallbackInfo<Value>& args) {
+  ContextifyMicrotaskQueue* queue;
+  ASSIGN_OR_RETURN_UNWRAP(&queue, args.This());
+  queue->microtask_queue_->PerformCheckpoint(args.GetIsolate());
+}
+
 void CreatePerIsolateProperties(IsolateData* isolate_data,
                                 Local<ObjectTemplate> target) {
   Isolate* isolate = isolate_data->isolate();
@@ -2034,6 +2100,7 @@ void CreatePerIsolateProperties(IsolateData* isolate_data,
   ContextifyContext::CreatePerIsolateProperties(isolate_data, target);
   ContextifyScript::CreatePerIsolateProperties(isolate_data, target);
   ContextifyFunction::CreatePerIsolateProperties(isolate_data, target);
+  ContextifyMicrotaskQueue::CreatePerIsolateProperties(isolate_data, target);
 
   SetMethod(isolate, target, "runInterruptible", RunInterruptible);
 
@@ -2083,6 +2150,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   ContextifyContext::RegisterExternalReferences(registry);
   ContextifyScript::RegisterExternalReferences(registry);
   ContextifyFunction::RegisterExternalReferences(registry);
+  ContextifyMicrotaskQueue::RegisterExternalReferences(registry);
 
   registry->Register(CompileFunctionForCJSLoader);
   registry->Register(RunInterruptible);
diff --git a/src/node_contextify.h b/src/node_contextify.h
index 1066633daf65..1e98fc6463b2 100644
--- a/src/node_contextify.h
+++ b/src/node_contextify.h
@@ -19,6 +19,12 @@ struct ContextOptions {
   v8::Local<v8::Boolean> allow_code_gen_strings;
   v8::Local<v8::Boolean> allow_code_gen_wasm;
   std::unique_ptr<v8::MicrotaskQueue> own_microtask_queue;
+  // Set when a vm.MicrotaskQueue (see ContextifyMicrotaskQueue below) is
+  // passed in via `microtaskMode: { type: 'manual', queue }`. Unlike
+  // own_microtask_queue, this queue is not exclusively owned by the context:
+  // it may be shared by multiple contexts, and none of them auto-drain it
+  // (see ContextifyContext::microtask_queue()).
+  std::shared_ptr<v8::MicrotaskQueue> shared_microtask_queue;
   v8::Local<v8::Symbol> host_defined_options_id;
   bool vanilla = false;
 };
@@ -187,6 +193,43 @@ class ContextifyContext final : CPPGC_MIXIN(ContextifyContext) {
 
   v8::TracedReference<v8::Context> context_;
   std::unique_ptr<v8::MicrotaskQueue> microtask_queue_;
+  // Keep the queue alive even after its JS handle is collected.
+  std::shared_ptr<v8::MicrotaskQueue> shared_microtask_queue_;
+};
+
+/**
+ * JS-facing handle for an explicit v8::MicrotaskQueue that can be shared by
+ * multiple vm.Context instances (see ContextOptions::shared_microtask_queue
+ * and ContextifyContext::New()). Created from JS via vm.createMicrotaskQueue().
+ *
+ * Unlike ContextifyContext, this does not need to be cppgc-managed: the
+ * underlying v8::MicrotaskQueue is kept alive via std::shared_ptr, with each
+ * ContextifyContext that uses it holding its own copy of the shared_ptr. That
+ * means the queue survives independently of this wrapper's own JS lifetime,
+ * so a plain (weak-by-default) BaseObject is sufficient here.
+ */
+class ContextifyMicrotaskQueue final : public BaseObject {
+ public:
+  ContextifyMicrotaskQueue(Environment* env, v8::Local<v8::Object> wrap);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void RunMicrotasks(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsMicrotaskQueue(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  inline std::shared_ptr<v8::MicrotaskQueue> microtask_queue() const {
+    return microtask_queue_;
+  }
+
+  SET_MEMORY_INFO_NAME(ContextifyMicrotaskQueue)
+  SET_SELF_SIZE(ContextifyMicrotaskQueue)
+  SET_NO_MEMORY_INFO()
+
+ private:
+  std::shared_ptr<v8::MicrotaskQueue> microtask_queue_;
 };
 
 class ContextifyScript final : CPPGC_MIXIN(ContextifyScript) {
diff --git a/test/parallel/test-vm-shared-microtask-queue-gc.js b/test/parallel/test-vm-shared-microtask-queue-gc.js
new file mode 100644
index 000000000000..92ba8ab8268d
--- /dev/null
+++ b/test/parallel/test-vm-shared-microtask-queue-gc.js
@@ -0,0 +1,30 @@
+// Flags: --expose-gc
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const vm = require('vm');
+const { gcUntil } = require('../common/gc');
+
+async function test() {
+  for (const sandbox of [{}, vm.constants.DONT_CONTEXTIFY]) {
+    let queue = vm.createMicrotaskQueue();
+    const ref = new WeakRef(queue);
+    const context = vm.createContext(sandbox, {
+      microtaskMode: { type: 'manual', queue },
+    });
+    queue = null;
+    await gcUntil('microtask queue handle', () => ref.deref() === undefined);
+
+    // The V8 context still needs its queue after the handle has been collected.
+    // Enqueuing a reaction would access freed memory without context ownership.
+    assert.strictEqual(vm.runInContext(`
+      globalThis.ran = false;
+      Promise.resolve().then(() => { ran = true; });
+      ran;
+    `, context), false);
+    global.gc();
+    assert.strictEqual(vm.runInContext('ran', context), false);
+  }
+}
+
+test().then(common.mustCall());
diff --git a/test/parallel/test-vm-shared-microtask-queue-validation.js b/test/parallel/test-vm-shared-microtask-queue-validation.js
new file mode 100644
index 000000000000..57624edd6fe0
--- /dev/null
+++ b/test/parallel/test-vm-shared-microtask-queue-validation.js
@@ -0,0 +1,63 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+const queue = vm.createMicrotaskQueue();
+const fake = { __proto__: Object.getPrototypeOf(queue) };
+const proxy = new Proxy(queue, {});
+
+const script = new vm.Script('');
+for (const invalid of [fake, proxy, {}, null, undefined, 1, 'queue']) {
+  const options = { microtaskMode: { type: 'manual', queue: invalid } };
+  for (const create of [
+    () => vm.createContext({}, options),
+    () => vm.runInNewContext('', {}, options),
+    () => script.runInNewContext({}, options),
+  ]) {
+    assert.throws(create, { code: 'ERR_INVALID_ARG_TYPE' });
+  }
+}
+
+// A revoked Proxy is also rejected, but not with `ERR_INVALID_ARG_TYPE`:
+// building that error's message reads `value.constructor` (see
+// `determineSpecificType()` in lib/internal/errors.js), which throws on a
+// revoked Proxy before the intended error can be constructed. This is a
+// pre-existing, feature-independent limitation of `ERR_INVALID_ARG_TYPE`
+// itself (e.g. `fs.readFileSync()` hits the same thing), not something
+// specific to `vm.MicrotaskQueue` validation. What this test guards is that
+// an invalid queue is still rejected, not accepted and used.
+{
+  const { proxy: revoked, revoke } = Proxy.revocable(queue, {});
+  revoke();
+  const options = { microtaskMode: { type: 'manual', queue: revoked } };
+  assert.throws(() => vm.createContext({}, options), TypeError);
+}
+
+// Changing a real handle's JS prototype must not change its native identity.
+const runMicrotasks = queue.runMicrotasks;
+Object.setPrototypeOf(queue, null);
+const trace = [];
+const context = vm.createContext({ trace }, {
+  microtaskMode: { type: 'manual', queue },
+});
+vm.runInContext('Promise.resolve().then(() => trace.push(1))', context);
+assert.deepStrictEqual(trace, []);
+runMicrotasks.call(queue);
+assert.deepStrictEqual(trace, [1]);
+
+// Draining one queue must leave other queues and Node's own work pending.
+const first = vm.createMicrotaskQueue();
+const second = vm.createMicrotaskQueue();
+const events = [];
+process.nextTick(common.mustCall(() => events.push('tick')));
+Promise.resolve().then(() => events.push('main')).then(common.mustCall());
+for (const [handle, label] of [[first, 'first'], [second, 'second']]) {
+  vm.runInNewContext('Promise.resolve().then(() => events.push(label))',
+                     { events, label },
+                     { microtaskMode: { type: 'manual', queue: handle } });
+}
+first.runMicrotasks();
+assert.deepStrictEqual(events, ['first']);
+second.runMicrotasks();
+assert.deepStrictEqual(events, ['first', 'second']);
diff --git a/test/parallel/test-vm-shared-microtask-queue.js b/test/parallel/test-vm-shared-microtask-queue.js
new file mode 100644
index 000000000000..cd4c887f3c07
--- /dev/null
+++ b/test/parallel/test-vm-shared-microtask-queue.js
@@ -0,0 +1,215 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// Tests `vm.createMicrotaskQueue()` and the `microtaskMode: { type: 'manual',
+// queue }` form of the `microtaskMode` option, which let multiple contexts
+// share where their microtasks are placed and have that queue drained
+// explicitly by the embedder, instead of automatically by Node.js.
+//
+// Refs: https://github.com/nodejs/node/issues/65555
+
+'use strict';
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+// `vm.createMicrotaskQueue()` returns a usable, independent handle each time.
+{
+  const queue = vm.createMicrotaskQueue();
+  assert.strictEqual(typeof queue.runMicrotasks, 'function');
+  // Draining an empty queue is a no-op, not an error.
+  queue.runMicrotasks();
+
+  const other = vm.createMicrotaskQueue();
+  assert.notStrictEqual(queue, other);
+}
+
+// `vm.MicrotaskQueue` (the constructor) is intentionally not exposed: only
+// `vm.createMicrotaskQueue()` is public, so there is no way to construct or
+// name the class directly from user code.
+assert.strictEqual(vm.MicrotaskQueue, undefined);
+
+// `microtaskQueue.runMicrotasks()` throws when called on an unrelated `this`.
+{
+  const queue = vm.createMicrotaskQueue();
+  assert.throws(() => {
+    queue.runMicrotasks.call({});
+  }, {
+    name: 'TypeError',
+  });
+}
+
+// The exact scenario from the issue: a Window-like context and a same-agent
+// iframe-like context need to share a single microtask queue so that
+// reactions from both are drained together, in scheduling order.
+{
+  function run(microtaskMode, drain = () => {}) {
+    const trace = [];
+    const record = (entry) => trace.push(entry);
+    const window = vm.createContext({ record }, { microtaskMode });
+    const iframe = vm.createContext({ record }, { microtaskMode });
+
+    vm.runInContext(`
+      const pending = new Promise((resolve) => {
+        globalThis.resolve = resolve;
+      });
+      pending.then(() => {
+        record('win-rxn');
+        Promise.resolve().then(() => record('win-follow-up'));
+      });
+    `, window);
+
+    vm.runInContext(`
+      const pending = new Promise((resolve) => {
+        globalThis.resolve = resolve;
+      });
+      pending.then(() => record('iframe-rxn'));
+    `, iframe);
+
+    window.resolveIframe = iframe.resolve;
+    vm.runInContext('resolve(); resolveIframe();', window);
+    drain(iframe);
+
+    return trace;
+  }
+
+  // Default contexts implicitly share Node's own queue, but there is no
+  // public API to force a checkpoint before run() returns.
+  assert.deepStrictEqual(run(undefined), []);
+
+  // `afterEvaluate` gives every context its own private queue, so `window`'s
+  // queue is drained to exhaustion (including its own follow-up) before
+  // `iframe`'s reaction ever gets a chance to run.
+  assert.deepStrictEqual(
+    run('afterEvaluate', (iframe) => vm.runInContext('', iframe)),
+    ['win-rxn', 'win-follow-up', 'iframe-rxn'],
+  );
+
+  // A single shared queue, drained once, explicitly, by the embedder,
+  // reproduces the HTML specification's ordering.
+  const queue = vm.createMicrotaskQueue();
+  assert.deepStrictEqual(
+    run({ type: 'manual', queue }, () => queue.runMicrotasks()),
+    ['win-rxn', 'iframe-rxn', 'win-follow-up'],
+  );
+}
+
+// A shared queue is never drained automatically: microtasks stay queued
+// across separate runInContext() calls until runMicrotasks() is called.
+{
+  const queue = vm.createMicrotaskQueue();
+  const trace = [];
+  const record = (entry) => trace.push(entry);
+  const contextA = vm.createContext({ record }, { microtaskMode: { type: 'manual', queue } });
+  const contextB = vm.createContext({ record }, { microtaskMode: { type: 'manual', queue } });
+
+  vm.runInContext("Promise.resolve().then(() => record('a'));", contextA);
+  vm.runInContext("Promise.resolve().then(() => record('b'));", contextB);
+  assert.deepStrictEqual(trace, []);
+
+  queue.runMicrotasks();
+  assert.deepStrictEqual(trace, ['a', 'b']);
+}
+
+// `vm.runInNewContext()` and `script.runInNewContext()` also accept the
+// object form (they build their context via `getContextOptions()` +
+// `createContext()`, both of which now go through `getMicrotaskModeOptions()`).
+{
+  const queue = vm.createMicrotaskQueue();
+  const trace = [];
+  const record = (entry) => trace.push(entry);
+
+  vm.runInNewContext(
+    "Promise.resolve().then(() => record('runInNewContext'));",
+    { record },
+    { microtaskMode: { type: 'manual', queue } },
+  );
+  assert.deepStrictEqual(trace, []);
+  queue.runMicrotasks();
+  assert.deepStrictEqual(trace, ['runInNewContext']);
+
+  const script = new vm.Script("Promise.resolve().then(() => record('script.runInNewContext'));");
+  script.runInNewContext({ record }, { microtaskMode: { type: 'manual', queue } });
+  assert.deepStrictEqual(trace, ['runInNewContext']);
+  queue.runMicrotasks();
+  assert.deepStrictEqual(trace, ['runInNewContext', 'script.runInNewContext']);
+}
+
+// `vm.constants.DONT_CONTEXTIFY` sandboxes (no wrapper object, the V8
+// context's global proxy is used directly) share a manual queue the same
+// way ordinary sandbox objects do.
+{
+  const queue = vm.createMicrotaskQueue();
+  const trace = [];
+  const options = { microtaskMode: { type: 'manual', queue } };
+
+  const first = vm.createContext(vm.constants.DONT_CONTEXTIFY, options);
+  const second = vm.createContext(vm.constants.DONT_CONTEXTIFY, options);
+  first.trace = trace;
+  second.trace = trace;
+
+  vm.runInContext("Promise.resolve().then(() => trace.push('first'));", first);
+  vm.runInContext("Promise.resolve().then(() => trace.push('second'));", second);
+  assert.deepStrictEqual(trace, []);
+
+  queue.runMicrotasks();
+  assert.deepStrictEqual(trace, ['first', 'second']);
+}
+
+// Invalid `microtaskMode` values.
+{
+  // Not a recognized string.
+  assert.throws(() => {
+    vm.createContext({}, { microtaskMode: 'nonsense' });
+  }, { code: 'ERR_INVALID_ARG_VALUE' });
+
+  // Neither a string nor an object.
+  assert.throws(() => {
+    vm.createContext({}, { microtaskMode: 42 });
+  }, { code: 'ERR_INVALID_ARG_TYPE' });
+
+  // An object, but with the wrong `type`.
+  const queue = vm.createMicrotaskQueue();
+  assert.throws(() => {
+    vm.createContext({}, { microtaskMode: { type: 'automatic', queue } });
+  }, { code: 'ERR_INVALID_ARG_VALUE' });
+
+  // `type: 'manual'`, but `queue` is not a `vm.MicrotaskQueue`.
+  assert.throws(() => {
+    vm.createContext({}, { microtaskMode: { type: 'manual', queue: {} } });
+  }, { code: 'ERR_INVALID_ARG_TYPE' });
+
+  assert.throws(() => {
+    vm.createContext({}, { microtaskMode: { type: 'manual' } }); // no queue at all
+  }, { code: 'ERR_INVALID_ARG_TYPE' });
+}
+
+// `'afterEvaluate'` and `{ type: 'manual', queue }` are mutually exclusive by
+// construction: `microtaskMode` is a single value that is either a string or
+// an object, so there is no way to request both at once. Passing a plain
+// object without `type: 'manual'` set is rejected the same way any other
+// malformed object would be, not treated as "also afterEvaluate".
+{
+  const queue = vm.createMicrotaskQueue();
+  assert.throws(() => {
+    vm.createContext({}, { microtaskMode: { queue } }); // `type` missing
+  }, { code: 'ERR_INVALID_ARG_VALUE' });
+}

From eb201792adc6f7ae4ccc68ff52a2ff3db87ca13f Mon Sep 17 00:00:00 2001
From: leah-1ee <selee3196@gmail.com>
Date: Thu, 1 Oct 2026 14:30:42 +0900
Subject: [PATCH 2/2] vm: avoid repeated microtask mode parsing

Parse microtaskMode only in createContext() so convenience APIs do not
read type and queue getters repeatedly.

Add regression tests for getter access, invalid options, and shared
manual queues during module evaluation. Clarify that the queue
constructor is not exported and fix the C++ macro line length.

Refs: https://github.com/nodejs/node/issues/65555

Signed-off-by: leah-1ee <selee3196@gmail.com>
---
 doc/api/vm.md                                 |  4 +-
 lib/vm.js                                     |  1 -
 src/env_properties.h                          |  2 +-
 .../test-vm-shared-microtask-queue-module.js  | 57 ++++++++++++
 ...st-vm-shared-microtask-queue-validation.js | 26 ++++--
 .../test-vm-shared-microtask-queue.js         | 86 ++++++++++++++-----
 6 files changed, 141 insertions(+), 35 deletions(-)
 create mode 100644 test/parallel/test-vm-shared-microtask-queue-module.js

diff --git a/doc/api/vm.md b/doc/api/vm.md
index acb2bb07814a..5ac74208e097 100644
--- a/doc/api/vm.md
+++ b/doc/api/vm.md
@@ -1341,8 +1341,8 @@ share where their microtasks (`Promise` reactions and `async function`
 continuations) are placed, and so that those microtasks are drained together,
 explicitly, by the embedder, instead of automatically by Node.js.
 
-Instances are created with [`vm.createMicrotaskQueue()`][]; there is no
-public constructor.
+Instances are created with [`vm.createMicrotaskQueue()`][]; the constructor is
+not exported by the `node:vm` module.
 
 ### `microtaskQueue.runMicrotasks()`
 
diff --git a/lib/vm.js b/lib/vm.js
index a9c82b9a1513..58dcf51d1bef 100644
--- a/lib/vm.js
+++ b/lib/vm.js
@@ -263,7 +263,6 @@ function getContextOptions(options) {
       validateBoolean(wasm, 'options.contextCodeGeneration.wasm');
     contextOptions.codeGeneration = { strings, wasm };
   }
-  getMicrotaskModeOptions(options.microtaskMode);
   return contextOptions;
 }
 
diff --git a/src/env_properties.h b/src/env_properties.h
index dd4e7b664a0f..c528a3b107ef 100644
--- a/src/env_properties.h
+++ b/src/env_properties.h
@@ -437,7 +437,7 @@
   V(lock_info_template, v8::DictionaryTemplate)                                \
   V(lock_query_template, v8::DictionaryTemplate)                               \
   V(message_port_constructor_template, v8::FunctionTemplate)                   \
-  V(microtask_queue_constructor_template, v8::FunctionTemplate)                 \
+  V(microtask_queue_constructor_template, v8::FunctionTemplate)                \
   V(module_wrap_constructor_template, v8::FunctionTemplate)                    \
   V(mx_record_template, v8::DictionaryTemplate)                                \
   V(naptr_record_template, v8::DictionaryTemplate)                             \
diff --git a/test/parallel/test-vm-shared-microtask-queue-module.js b/test/parallel/test-vm-shared-microtask-queue-module.js
new file mode 100644
index 000000000000..1d5f9ef34061
--- /dev/null
+++ b/test/parallel/test-vm-shared-microtask-queue-module.js
@@ -0,0 +1,57 @@
+// Flags: --experimental-vm-modules
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+(async () => {
+  const queue = vm.createMicrotaskQueue();
+  const trace = [];
+  const record = (entry) => trace.push(entry);
+  const microtaskMode = { type: 'manual', queue };
+  const contextA = vm.createContext({ record }, { microtaskMode });
+  const contextB = vm.createContext({ record }, { microtaskMode });
+  const moduleA = new vm.SourceTextModule(`
+    await Promise.resolve();
+    record('a');
+    Promise.resolve().then(() => record('a-follow-up'));
+  `, { context: contextA });
+  const moduleB = new vm.SourceTextModule(`
+    await Promise.resolve();
+    record('b');
+    Promise.resolve().then(() => record('b-follow-up'));
+  `, { context: contextB });
+
+  await moduleA.link(common.mustNotCall());
+  await moduleB.link(common.mustNotCall());
+
+  const evaluationA = moduleA.evaluate();
+  const evaluationB = moduleB.evaluate();
+  let completed = 0;
+  let resolveCompleted;
+  const allCompleted = new Promise((resolve) => {
+    resolveCompleted = resolve;
+  });
+  const onCompleted = () => {
+    if (++completed === 2) resolveCompleted();
+  };
+  evaluationA.then(common.mustCall(() => {
+    onCompleted();
+  }));
+  evaluationB.then(common.mustCall(() => {
+    onCompleted();
+  }));
+
+  assert.deepStrictEqual(trace, []);
+  queue.runMicrotasks();
+  assert.deepStrictEqual(trace, [
+    'a',
+    'b',
+    'a-follow-up',
+    'b-follow-up',
+  ]);
+
+  await allCompleted;
+  assert.strictEqual(completed, 2);
+})().then(common.mustCall());
diff --git a/test/parallel/test-vm-shared-microtask-queue-validation.js b/test/parallel/test-vm-shared-microtask-queue-validation.js
index 57624edd6fe0..794b9df0cde6 100644
--- a/test/parallel/test-vm-shared-microtask-queue-validation.js
+++ b/test/parallel/test-vm-shared-microtask-queue-validation.js
@@ -8,14 +8,24 @@ const fake = { __proto__: Object.getPrototypeOf(queue) };
 const proxy = new Proxy(queue, {});
 
 const script = new vm.Script('');
-for (const invalid of [fake, proxy, {}, null, undefined, 1, 'queue']) {
-  const options = { microtaskMode: { type: 'manual', queue: invalid } };
-  for (const create of [
-    () => vm.createContext({}, options),
-    () => vm.runInNewContext('', {}, options),
-    () => script.runInNewContext({}, options),
-  ]) {
-    assert.throws(create, { code: 'ERR_INVALID_ARG_TYPE' });
+const createContext = (options) => vm.createContext({}, options);
+const runInNewContext = (options) => vm.runInNewContext('', {}, options);
+const scriptRunInNewContext =
+  (options) => script.runInNewContext({}, options);
+const contextCreators = [
+  createContext,
+  runInNewContext,
+  scriptRunInNewContext,
+];
+
+for (const create of contextCreators) {
+  assert.throws(() => {
+    create({ microtaskMode: { type: 'automatic', queue } });
+  }, { code: 'ERR_INVALID_ARG_VALUE' });
+
+  for (const invalid of [fake, proxy, {}, null, undefined, 1, 'queue']) {
+    const options = { microtaskMode: { type: 'manual', queue: invalid } };
+    assert.throws(() => create(options), { code: 'ERR_INVALID_ARG_TYPE' });
   }
 }
 
diff --git a/test/parallel/test-vm-shared-microtask-queue.js b/test/parallel/test-vm-shared-microtask-queue.js
index cd4c887f3c07..7f3ee56ee2e4 100644
--- a/test/parallel/test-vm-shared-microtask-queue.js
+++ b/test/parallel/test-vm-shared-microtask-queue.js
@@ -42,9 +42,8 @@ const vm = require('vm');
   assert.notStrictEqual(queue, other);
 }
 
-// `vm.MicrotaskQueue` (the constructor) is intentionally not exposed: only
-// `vm.createMicrotaskQueue()` is public, so there is no way to construct or
-// name the class directly from user code.
+// The constructor is intentionally not exported from `vm`; the public API for
+// creating queues is `vm.createMicrotaskQueue()`.
 assert.strictEqual(vm.MicrotaskQueue, undefined);
 
 // `microtaskQueue.runMicrotasks()` throws when called on an unrelated `this`.
@@ -129,28 +128,69 @@ assert.strictEqual(vm.MicrotaskQueue, undefined);
   assert.deepStrictEqual(trace, ['a', 'b']);
 }
 
-// `vm.runInNewContext()` and `script.runInNewContext()` also accept the
-// object form (they build their context via `getContextOptions()` +
-// `createContext()`, both of which now go through `getMicrotaskModeOptions()`).
+// All context-creation APIs parse the object form once. In particular, they
+// must not read either property a second time after validation.
 {
-  const queue = vm.createMicrotaskQueue();
-  const trace = [];
-  const record = (entry) => trace.push(entry);
-
-  vm.runInNewContext(
-    "Promise.resolve().then(() => record('runInNewContext'));",
-    { record },
-    { microtaskMode: { type: 'manual', queue } },
+  const script = new vm.Script(
+    "Promise.resolve().then(() => record('script.runInNewContext'));",
   );
-  assert.deepStrictEqual(trace, []);
-  queue.runMicrotasks();
-  assert.deepStrictEqual(trace, ['runInNewContext']);
-
-  const script = new vm.Script("Promise.resolve().then(() => record('script.runInNewContext'));");
-  script.runInNewContext({ record }, { microtaskMode: { type: 'manual', queue } });
-  assert.deepStrictEqual(trace, ['runInNewContext']);
-  queue.runMicrotasks();
-  assert.deepStrictEqual(trace, ['runInNewContext', 'script.runInNewContext']);
+  const createAndRun = [
+    {
+      expected: 'createContext',
+      run(sandbox, options) {
+        const context = vm.createContext(sandbox, options);
+        vm.runInContext(
+          "Promise.resolve().then(() => record('createContext'));",
+          context,
+        );
+      },
+    },
+    {
+      expected: 'runInNewContext',
+      run(sandbox, options) {
+        vm.runInNewContext(
+          "Promise.resolve().then(() => record('runInNewContext'));",
+          sandbox,
+          options,
+        );
+      },
+    },
+    {
+      expected: 'script.runInNewContext',
+      run(sandbox, options) {
+        script.runInNewContext(sandbox, options);
+      },
+    },
+  ];
+
+  for (const { expected, run } of createAndRun) {
+    const queue = vm.createMicrotaskQueue();
+    const trace = [];
+    const record = (entry) => trace.push(entry);
+    let typeGetCount = 0;
+    let queueGetCount = 0;
+    const microtaskMode = {
+      get type() {
+        if (++typeGetCount > 1) {
+          throw new Error('microtaskMode.type was read more than once');
+        }
+        return 'manual';
+      },
+      get queue() {
+        if (++queueGetCount > 1) {
+          throw new Error('microtaskMode.queue was read more than once');
+        }
+        return queue;
+      },
+    };
+
+    run({ record }, { microtaskMode });
+    assert.strictEqual(typeGetCount, 1);
+    assert.strictEqual(queueGetCount, 1);
+    assert.deepStrictEqual(trace, []);
+    queue.runMicrotasks();
+    assert.deepStrictEqual(trace, [expected]);
+  }
 }
 
 // `vm.constants.DONT_CONTEXTIFY` sandboxes (no wrapper object, the V8