diff --git a/doc/api/vm.md b/doc/api/vm.md
index 14cd1f269b12..5ac74208e097 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()`][]; the constructor is
+not exported by the `node:vm` module.
+
+### `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..58dcf51d1bef 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,6 @@ function getContextOptions(options) {
       validateBoolean(wasm, 'options.contextCodeGeneration.wasm');
     contextOptions.codeGeneration = { strings, wasm };
   }
-  if (options.microtaskMode !== undefined)
-    validateString(options.microtaskMode, 'options.microtaskMode');
   return contextOptions;
 }
 
@@ -252,15 +296,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 +454,7 @@ module.exports = {
   runInThisContext,
   isContext,
   compileFunction,
+  createMicrotaskQueue,
   measureMemory,
   constants: vmConstants,
 };
diff --git a/src/env_properties.h b/src/env_properties.h
index 087193faba98..c528a3b107ef 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-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
new file mode 100644
index 000000000000..794b9df0cde6
--- /dev/null
+++ b/test/parallel/test-vm-shared-microtask-queue-validation.js
@@ -0,0 +1,73 @@
+'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('');
+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' });
+  }
+}
+
+// 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..7f3ee56ee2e4
--- /dev/null
+++ b/test/parallel/test-vm-shared-microtask-queue.js
@@ -0,0 +1,255 @@
+// 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);
+}
+
+// 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`.
+{
+  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']);
+}
+
+// All context-creation APIs parse the object form once. In particular, they
+// must not read either property a second time after validation.
+{
+  const script = new vm.Script(
+    "Promise.resolve().then(() => record('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
+// 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' });
+}