deps: V8: backport 5177b10891e6

Original commit message:
fix(inspector): hold on to promises
Keep `m_evaluationResult` strong for evaluations
until the promise settles or the request is cancelled.
Bug: 536271637
Change-Id: If21cc4aa0ba6bb2e2722d5ee73eb7744a0ead207
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/8123081
Commit-Queue: Simon Zünd <szuend@chromium.org>
Reviewed-by: Simon Zünd <szuend@chromium.org>
Reviewed-by: Kim-Anh Tran <kimanh@chromium.org>
Cr-Commit-Position: refs/heads/main@{#108874}
Refs: v8/v8@5177b10
Co-authored-by: avivkeller <me@aviv.sh>
PR-URL: #64631
Reviewed-By: Daeyeon Jeong <daeyeon.dev@gmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>

Author: avivkeller

common.gypi

@@ -41,7 +41,7 @@
 
 # Reset this number to 0 on major V8 upgrades.
 # Increment by one for each non-official patch applied to deps/v8.
-'v8_embedder_string': '-node.51',
+'v8_embedder_string': '-node.52',
 
 ##### V8 defaults for Node.js #####
 

deps/v8/AUTHORS

@@ -76,6 +76,7 @@ Artem Kobzar <artem.kobzar@jetbrains.com>
 Arthur Islamov <arthur@islamov.ai>
 Asuka Shikina <shikina.asuka@gmail.com>
 Aurèle Barrière <aurele.barriere@gmail.com>
+Aviv Keller <me@aviv.sh>
 Bala Avulapati <bavulapati@gmail.com>
 Bangfu Tao <bangfu.tao@samsung.com>
 Ben Coe <bencoe@gmail.com>

deps/v8/src/inspector/injected-script.cc

@@ -204,8 +204,7 @@ class InjectedScript::ProtocolPromiseHandler {
  PromiseHandlerTracker::DiscardReason::kFulfilled);
  }
 
-ProtocolPromiseHandler(PromiseHandlerTracker::Id id,
- V8InspectorSessionImpl* session,
+ProtocolPromiseHandler(V8InspectorSessionImpl* session,
 int executionContextId, const String16& objectGroup,
  std::unique_ptr<WrapOptions> wrapOptions,
 bool replMode, bool throwOnSideEffect,
@@ -220,7 +219,13 @@ class InjectedScript::ProtocolPromiseHandler {
  m_replMode(replMode),
  m_throwOnSideEffect(throwOnSideEffect),
  m_callback(std::move(callback)),
- m_evaluationResult(m_inspector->isolate(), evaluationResult) {
+ m_evaluationResult(m_inspector->isolate(), evaluationResult) {}
+
+voidmakeWeak(PromiseHandlerTracker::Id id) {
+if (m_isActive || m_evaluationResult.IsEmpty() ||
+ m_evaluationResult.IsWeak()) {
+return;
+ }
  m_evaluationResult.SetWeak(reinterpret_cast<PromiseHandlerTracker::Id*>(id),
  cleanup, v8::WeakCallbackType::kParameter);
  }
@@ -238,6 +243,7 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidthenCallback(v8::Local<v8::Value> value) {
+ m_isActive = true;
 // We don't need the m_evaluationResult in the `thenCallback`, but we also
 // don't want `cleanup` running in case we re-enter JS.
  m_evaluationResult.Reset();
@@ -285,9 +291,10 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidcatchCallback(v8::Local<v8::Value> result) {
+ m_isActive = true;
 // Hold strongly onto m_evaluationResult now to prevent `cleanup` from
 // running in case any code below triggers GC.
- m_evaluationResult.ClearWeak();
+if (m_evaluationResult.IsWeak()) m_evaluationResult.ClearWeak();
  V8InspectorSessionImpl* session =
  m_inspector->sessionById(m_contextGroupId, m_sessionId);
 if (!session) return;
@@ -393,6 +400,7 @@ class InjectedScript::ProtocolPromiseHandler {
  std::unique_ptr<WrapOptions> m_wrapOptions;
 bool m_replMode;
 bool m_throwOnSideEffect;
+bool m_isActive = false;
  std::weak_ptr<EvaluateCallback> m_callback;
  v8::Global<v8::Promise> m_evaluationResult;
 };
@@ -1190,8 +1198,7 @@ template <typename... Args>
 PromiseHandlerTracker::Id PromiseHandlerTracker::create(Args&&... args) {
  Id id = m_lastUsedId++;
  InjectedScript::ProtocolPromiseHandler* handler =
-newInjectedScript::ProtocolPromiseHandler(id,
- std::forward<Args>(args)...);
+newInjectedScript::ProtocolPromiseHandler(std::forward<Args>(args)...);
  m_promiseHandlers.emplace(id, handler);
 return id;
 }
@@ -1225,6 +1232,30 @@ InjectedScript::ProtocolPromiseHandler* PromiseHandlerTracker::get(
 return iter->second.get();
 }
 
+voidPromiseHandlerTracker::makeWeakForContext(int executionContextId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_executionContextId == executionContextId) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForObjectGroup(
+int sessionId, const String16& objectGroup) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId &&
+ handler->m_objectGroup == objectGroup) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForSession(int sessionId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId) handler->makeWeak(id);
+ }
+}
+
 voidPromiseHandlerTracker::sendFailure(
  InjectedScript::ProtocolPromiseHandler* handler,
 const protocol::DispatchResponse& response) const {

deps/v8/src/inspector/injected-script.h

@@ -298,6 +298,9 @@ class PromiseHandlerTracker {
  Id create(Args&&... args);
 voiddiscard(Id id, DiscardReason reason);
  InjectedScript::ProtocolPromiseHandler* get(Id id) const;
+voidmakeWeakForContext(int executionContextId);
+voidmakeWeakForObjectGroup(int sessionId, const String16& objectGroup);
+voidmakeWeakForSession(int sessionId);
 
 private:
 voidsendFailure(InjectedScript::ProtocolPromiseHandler* handler,

deps/v8/src/inspector/v8-inspector-impl.cc

@@ -261,6 +261,7 @@ void V8InspectorImpl::contextCollected(int groupId, int contextId) {
  session->runtimeAgent()->reportExecutionContextDestroyed(inspectedContext);
  });
 discardInspectedContext(groupId, contextId);
+ m_promiseHandlerTracker.makeWeakForContext(contextId);
 }
 
 voidV8InspectorImpl::resetContextGroup(int contextGroupId) {

deps/v8/src/inspector/v8-inspector-session-impl.cc

@@ -233,6 +233,7 @@ void V8InspectorSessionImpl::discardInjectedScripts() {
  [&sessionId](InspectedContext* context) {
  context->discardInjectedScript(sessionId);
  });
+ m_inspector->promiseHandlerTracker().makeWeakForSession(sessionId);
 }
 
 Response V8InspectorSessionImpl::findInjectedScript(
@@ -269,6 +270,10 @@ void V8InspectorSessionImpl::releaseObjectGroup(const String16& objectGroup) {
  InjectedScript* injectedScript = context->getInjectedScript(sessionId);
 if (injectedScript) injectedScript->releaseObjectGroup(objectGroup);
  });
+if (!objectGroup.isEmpty()) {
+ m_inspector->promiseHandlerTracker().makeWeakForObjectGroup(m_sessionId,
+ objectGroup);
+ }
 }
 
 boolV8InspectorSessionImpl::unwrapObject(

deps/v8/test/inspector/runtime/evaluate-promise-lifetime-expected.txt

@@ -0,0 +1,65 @@
+Tests the lifetime of pending Runtime.evaluate requests.
+
+Running test: testPromiseIsKeptAlive
+Using replMode:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+Using awaitPromise:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+
+Running test: testObjectGroupReleaseMakesPromiseCollectible
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+
+Running test: testContextDestructionDiscardsPromise
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+
+Running test: testSessionDestructionMakesPromiseCollectible
+Promise is alive before disconnect: true
+Promise is alive after disconnect: false

deps/v8/test/inspector/runtime/evaluate-promise-lifetime.js

@@ -0,0 +1,105 @@
+// Copyright 2026 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --no-stress-incremental-marking
+
+let{Protocol}=InspectorTest.start(
+'Tests the lifetime of pending Runtime.evaluate requests.');
+
+constevaluationModes=[
+{
+name: 'replMode',
+arguments: {replMode: true},
+expression:
+'await new Promise(resolve => globalThis.resolve = resolve); 42',
+resolveExpression: 'resolve()',
+pendingExpression: 'await new Promise(() => {})',
+},
+{
+name: 'awaitPromise',
+arguments: {awaitPromise: true},
+expression: `(() => {
+ let resolve;
+ const promise = new Promise(r => resolve = r);
+ promise.resolve = resolve;
+ globalThis.weak = new WeakRef(promise);
+ return promise;
+ })()`,
+resolveExpression: 'weak.deref().resolve(42)',
+pendingExpression: 'new Promise(() => {})',
+},
+];
+
+functionevaluate(Protocol,mode,expression,extraArguments={}){
+returnProtocol.Runtime.evaluate(
+{...mode.arguments, ...extraArguments, expression});
+}
+
+InspectorTest.runAsyncTestSuite([
+asyncfunctiontestPromiseIsKeptAlive(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(Protocol,mode,mode.expression);
+
+awaitProtocol.HeapProfiler.collectGarbage();
+awaitProtocol.Runtime.evaluate({expression: mode.resolveExpression});
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestObjectGroupReleaseMakesPromiseCollectible(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(
+Protocol,mode,mode.pendingExpression,
+{objectGroup: 'evaluation'});
+
+awaitProtocol.Runtime.releaseObjectGroup({objectGroup: 'evaluation'});
+awaitProtocol.HeapProfiler.collectGarbage();
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestContextDestructionDiscardsPromise(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession=contextGroup.connect();
+constevaluation=evaluate(
+session.Protocol,mode,mode.pendingExpression);
+
+awaitsession.Protocol.Runtime.evaluate(
+{expression: 'inspector.fireContextDestroyed()'});
+
+InspectorTest.logMessage(awaitevaluation);
+session.disconnect();
+}
+},
+
+asyncfunctiontestSessionDestructionMakesPromiseCollectible(){
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession1=contextGroup.connect();
+constsession2=contextGroup.connect();
+session1.Protocol.Runtime.evaluate({
+expression: evaluationModes[1].expression,
+awaitPromise: true,
+});
+
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+letresult=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive before disconnect: ${result.result.result.value}`);
+
+session1.disconnect();
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+result=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive after disconnect: ${result.result.result.value}`);
+session2.disconnect();
+},
+]);

common.gypi

@@ -41,7 +41,7 @@
 
 # Reset this number to 0 on major V8 upgrades.
 # Increment by one for each non-official patch applied to deps/v8.
-'v8_embedder_string': '-node.51',
+'v8_embedder_string': '-node.52',
 
 ##### V8 defaults for Node.js #####
 

deps/v8/AUTHORS

@@ -76,6 +76,7 @@ Artem Kobzar <artem.kobzar@jetbrains.com>
 Arthur Islamov <arthur@islamov.ai>
 Asuka Shikina <shikina.asuka@gmail.com>
 Aurèle Barrière <aurele.barriere@gmail.com>
+Aviv Keller <me@aviv.sh>
 Bala Avulapati <bavulapati@gmail.com>
 Bangfu Tao <bangfu.tao@samsung.com>
 Ben Coe <bencoe@gmail.com>

deps/v8/src/inspector/injected-script.cc

@@ -204,8 +204,7 @@ class InjectedScript::ProtocolPromiseHandler {
  PromiseHandlerTracker::DiscardReason::kFulfilled);
  }
 
-ProtocolPromiseHandler(PromiseHandlerTracker::Id id,
- V8InspectorSessionImpl* session,
+ProtocolPromiseHandler(V8InspectorSessionImpl* session,
 int executionContextId, const String16& objectGroup,
  std::unique_ptr<WrapOptions> wrapOptions,
 bool replMode, bool throwOnSideEffect,
@@ -220,7 +219,13 @@ class InjectedScript::ProtocolPromiseHandler {
  m_replMode(replMode),
  m_throwOnSideEffect(throwOnSideEffect),
  m_callback(std::move(callback)),
- m_evaluationResult(m_inspector->isolate(), evaluationResult) {
+ m_evaluationResult(m_inspector->isolate(), evaluationResult) {}
+
+voidmakeWeak(PromiseHandlerTracker::Id id) {
+if (m_isActive || m_evaluationResult.IsEmpty() ||
+ m_evaluationResult.IsWeak()) {
+return;
+ }
  m_evaluationResult.SetWeak(reinterpret_cast<PromiseHandlerTracker::Id*>(id),
  cleanup, v8::WeakCallbackType::kParameter);
  }
@@ -238,6 +243,7 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidthenCallback(v8::Local<v8::Value> value) {
+ m_isActive = true;
 // We don't need the m_evaluationResult in the `thenCallback`, but we also
 // don't want `cleanup` running in case we re-enter JS.
  m_evaluationResult.Reset();
@@ -285,9 +291,10 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidcatchCallback(v8::Local<v8::Value> result) {
+ m_isActive = true;
 // Hold strongly onto m_evaluationResult now to prevent `cleanup` from
 // running in case any code below triggers GC.
- m_evaluationResult.ClearWeak();
+if (m_evaluationResult.IsWeak()) m_evaluationResult.ClearWeak();
  V8InspectorSessionImpl* session =
  m_inspector->sessionById(m_contextGroupId, m_sessionId);
 if (!session) return;
@@ -393,6 +400,7 @@ class InjectedScript::ProtocolPromiseHandler {
  std::unique_ptr<WrapOptions> m_wrapOptions;
 bool m_replMode;
 bool m_throwOnSideEffect;
+bool m_isActive = false;
  std::weak_ptr<EvaluateCallback> m_callback;
  v8::Global<v8::Promise> m_evaluationResult;
 };
@@ -1190,8 +1198,7 @@ template <typename... Args>
 PromiseHandlerTracker::Id PromiseHandlerTracker::create(Args&&... args) {
  Id id = m_lastUsedId++;
  InjectedScript::ProtocolPromiseHandler* handler =
-newInjectedScript::ProtocolPromiseHandler(id,
- std::forward<Args>(args)...);
+newInjectedScript::ProtocolPromiseHandler(std::forward<Args>(args)...);
  m_promiseHandlers.emplace(id, handler);
 return id;
 }
@@ -1225,6 +1232,30 @@ InjectedScript::ProtocolPromiseHandler* PromiseHandlerTracker::get(
 return iter->second.get();
 }
 
+voidPromiseHandlerTracker::makeWeakForContext(int executionContextId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_executionContextId == executionContextId) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForObjectGroup(
+int sessionId, const String16& objectGroup) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId &&
+ handler->m_objectGroup == objectGroup) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForSession(int sessionId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId) handler->makeWeak(id);
+ }
+}
+
 voidPromiseHandlerTracker::sendFailure(
  InjectedScript::ProtocolPromiseHandler* handler,
 const protocol::DispatchResponse& response) const {

deps/v8/src/inspector/injected-script.h

@@ -298,6 +298,9 @@ class PromiseHandlerTracker {
  Id create(Args&&... args);
 voiddiscard(Id id, DiscardReason reason);
  InjectedScript::ProtocolPromiseHandler* get(Id id) const;
+voidmakeWeakForContext(int executionContextId);
+voidmakeWeakForObjectGroup(int sessionId, const String16& objectGroup);
+voidmakeWeakForSession(int sessionId);
 
 private:
 voidsendFailure(InjectedScript::ProtocolPromiseHandler* handler,

deps/v8/src/inspector/v8-inspector-impl.cc

@@ -261,6 +261,7 @@ void V8InspectorImpl::contextCollected(int groupId, int contextId) {
  session->runtimeAgent()->reportExecutionContextDestroyed(inspectedContext);
  });
 discardInspectedContext(groupId, contextId);
+ m_promiseHandlerTracker.makeWeakForContext(contextId);
 }
 
 voidV8InspectorImpl::resetContextGroup(int contextGroupId) {

deps/v8/src/inspector/v8-inspector-session-impl.cc

@@ -233,6 +233,7 @@ void V8InspectorSessionImpl::discardInjectedScripts() {
  [&sessionId](InspectedContext* context) {
  context->discardInjectedScript(sessionId);
  });
+ m_inspector->promiseHandlerTracker().makeWeakForSession(sessionId);
 }
 
 Response V8InspectorSessionImpl::findInjectedScript(
@@ -269,6 +270,10 @@ void V8InspectorSessionImpl::releaseObjectGroup(const String16& objectGroup) {
  InjectedScript* injectedScript = context->getInjectedScript(sessionId);
 if (injectedScript) injectedScript->releaseObjectGroup(objectGroup);
  });
+if (!objectGroup.isEmpty()) {
+ m_inspector->promiseHandlerTracker().makeWeakForObjectGroup(m_sessionId,
+ objectGroup);
+ }
 }
 
 boolV8InspectorSessionImpl::unwrapObject(

deps/v8/test/inspector/runtime/evaluate-promise-lifetime-expected.txt

@@ -0,0 +1,65 @@
+Tests the lifetime of pending Runtime.evaluate requests.
+
+Running test: testPromiseIsKeptAlive
+Using replMode:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+Using awaitPromise:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+
+Running test: testObjectGroupReleaseMakesPromiseCollectible
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+
+Running test: testContextDestructionDiscardsPromise
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+
+Running test: testSessionDestructionMakesPromiseCollectible
+Promise is alive before disconnect: true
+Promise is alive after disconnect: false

deps/v8/test/inspector/runtime/evaluate-promise-lifetime.js

@@ -0,0 +1,105 @@
+// Copyright 2026 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --no-stress-incremental-marking
+
+let{Protocol}=InspectorTest.start(
+'Tests the lifetime of pending Runtime.evaluate requests.');
+
+constevaluationModes=[
+{
+name: 'replMode',
+arguments: {replMode: true},
+expression:
+'await new Promise(resolve => globalThis.resolve = resolve); 42',
+resolveExpression: 'resolve()',
+pendingExpression: 'await new Promise(() => {})',
+},
+{
+name: 'awaitPromise',
+arguments: {awaitPromise: true},
+expression: `(() => {
+ let resolve;
+ const promise = new Promise(r => resolve = r);
+ promise.resolve = resolve;
+ globalThis.weak = new WeakRef(promise);
+ return promise;
+ })()`,
+resolveExpression: 'weak.deref().resolve(42)',
+pendingExpression: 'new Promise(() => {})',
+},
+];
+
+functionevaluate(Protocol,mode,expression,extraArguments={}){
+returnProtocol.Runtime.evaluate(
+{...mode.arguments, ...extraArguments, expression});
+}
+
+InspectorTest.runAsyncTestSuite([
+asyncfunctiontestPromiseIsKeptAlive(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(Protocol,mode,mode.expression);
+
+awaitProtocol.HeapProfiler.collectGarbage();
+awaitProtocol.Runtime.evaluate({expression: mode.resolveExpression});
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestObjectGroupReleaseMakesPromiseCollectible(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(
+Protocol,mode,mode.pendingExpression,
+{objectGroup: 'evaluation'});
+
+awaitProtocol.Runtime.releaseObjectGroup({objectGroup: 'evaluation'});
+awaitProtocol.HeapProfiler.collectGarbage();
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestContextDestructionDiscardsPromise(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession=contextGroup.connect();
+constevaluation=evaluate(
+session.Protocol,mode,mode.pendingExpression);
+
+awaitsession.Protocol.Runtime.evaluate(
+{expression: 'inspector.fireContextDestroyed()'});
+
+InspectorTest.logMessage(awaitevaluation);
+session.disconnect();
+}
+},
+
+asyncfunctiontestSessionDestructionMakesPromiseCollectible(){
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession1=contextGroup.connect();
+constsession2=contextGroup.connect();
+session1.Protocol.Runtime.evaluate({
+expression: evaluationModes[1].expression,
+awaitPromise: true,
+});
+
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+letresult=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive before disconnect: ${result.result.result.value}`);
+
+session1.disconnect();
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+result=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive after disconnect: ${result.result.result.value}`);
+session2.disconnect();
+},
+]);

common.gypi

@@ -41,7 +41,7 @@
 
 # Reset this number to 0 on major V8 upgrades.
 # Increment by one for each non-official patch applied to deps/v8.
-'v8_embedder_string': '-node.51',
+'v8_embedder_string': '-node.52',
 
 ##### V8 defaults for Node.js #####
 

deps/v8/AUTHORS

@@ -76,6 +76,7 @@ Artem Kobzar <artem.kobzar@jetbrains.com>
 Arthur Islamov <arthur@islamov.ai>
 Asuka Shikina <shikina.asuka@gmail.com>
 Aurèle Barrière <aurele.barriere@gmail.com>
+Aviv Keller <me@aviv.sh>
 Bala Avulapati <bavulapati@gmail.com>
 Bangfu Tao <bangfu.tao@samsung.com>
 Ben Coe <bencoe@gmail.com>

deps/v8/src/inspector/injected-script.cc

@@ -204,8 +204,7 @@ class InjectedScript::ProtocolPromiseHandler {
  PromiseHandlerTracker::DiscardReason::kFulfilled);
  }
 
-ProtocolPromiseHandler(PromiseHandlerTracker::Id id,
- V8InspectorSessionImpl* session,
+ProtocolPromiseHandler(V8InspectorSessionImpl* session,
 int executionContextId, const String16& objectGroup,
  std::unique_ptr<WrapOptions> wrapOptions,
 bool replMode, bool throwOnSideEffect,
@@ -220,7 +219,13 @@ class InjectedScript::ProtocolPromiseHandler {
  m_replMode(replMode),
  m_throwOnSideEffect(throwOnSideEffect),
  m_callback(std::move(callback)),
- m_evaluationResult(m_inspector->isolate(), evaluationResult) {
+ m_evaluationResult(m_inspector->isolate(), evaluationResult) {}
+
+voidmakeWeak(PromiseHandlerTracker::Id id) {
+if (m_isActive || m_evaluationResult.IsEmpty() ||
+ m_evaluationResult.IsWeak()) {
+return;
+ }
  m_evaluationResult.SetWeak(reinterpret_cast<PromiseHandlerTracker::Id*>(id),
  cleanup, v8::WeakCallbackType::kParameter);
  }
@@ -238,6 +243,7 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidthenCallback(v8::Local<v8::Value> value) {
+ m_isActive = true;
 // We don't need the m_evaluationResult in the `thenCallback`, but we also
 // don't want `cleanup` running in case we re-enter JS.
  m_evaluationResult.Reset();
@@ -285,9 +291,10 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidcatchCallback(v8::Local<v8::Value> result) {
+ m_isActive = true;
 // Hold strongly onto m_evaluationResult now to prevent `cleanup` from
 // running in case any code below triggers GC.
- m_evaluationResult.ClearWeak();
+if (m_evaluationResult.IsWeak()) m_evaluationResult.ClearWeak();
  V8InspectorSessionImpl* session =
  m_inspector->sessionById(m_contextGroupId, m_sessionId);
 if (!session) return;
@@ -393,6 +400,7 @@ class InjectedScript::ProtocolPromiseHandler {
  std::unique_ptr<WrapOptions> m_wrapOptions;
 bool m_replMode;
 bool m_throwOnSideEffect;
+bool m_isActive = false;
  std::weak_ptr<EvaluateCallback> m_callback;
  v8::Global<v8::Promise> m_evaluationResult;
 };
@@ -1190,8 +1198,7 @@ template <typename... Args>
 PromiseHandlerTracker::Id PromiseHandlerTracker::create(Args&&... args) {
  Id id = m_lastUsedId++;
  InjectedScript::ProtocolPromiseHandler* handler =
-newInjectedScript::ProtocolPromiseHandler(id,
- std::forward<Args>(args)...);
+newInjectedScript::ProtocolPromiseHandler(std::forward<Args>(args)...);
  m_promiseHandlers.emplace(id, handler);
 return id;
 }
@@ -1225,6 +1232,30 @@ InjectedScript::ProtocolPromiseHandler* PromiseHandlerTracker::get(
 return iter->second.get();
 }
 
+voidPromiseHandlerTracker::makeWeakForContext(int executionContextId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_executionContextId == executionContextId) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForObjectGroup(
+int sessionId, const String16& objectGroup) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId &&
+ handler->m_objectGroup == objectGroup) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForSession(int sessionId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId) handler->makeWeak(id);
+ }
+}
+
 voidPromiseHandlerTracker::sendFailure(
  InjectedScript::ProtocolPromiseHandler* handler,
 const protocol::DispatchResponse& response) const {

deps/v8/src/inspector/injected-script.h

@@ -298,6 +298,9 @@ class PromiseHandlerTracker {
  Id create(Args&&... args);
 voiddiscard(Id id, DiscardReason reason);
  InjectedScript::ProtocolPromiseHandler* get(Id id) const;
+voidmakeWeakForContext(int executionContextId);
+voidmakeWeakForObjectGroup(int sessionId, const String16& objectGroup);
+voidmakeWeakForSession(int sessionId);
 
 private:
 voidsendFailure(InjectedScript::ProtocolPromiseHandler* handler,

deps/v8/src/inspector/v8-inspector-impl.cc

@@ -261,6 +261,7 @@ void V8InspectorImpl::contextCollected(int groupId, int contextId) {
  session->runtimeAgent()->reportExecutionContextDestroyed(inspectedContext);
  });
 discardInspectedContext(groupId, contextId);
+ m_promiseHandlerTracker.makeWeakForContext(contextId);
 }
 
 voidV8InspectorImpl::resetContextGroup(int contextGroupId) {

deps/v8/src/inspector/v8-inspector-session-impl.cc

@@ -233,6 +233,7 @@ void V8InspectorSessionImpl::discardInjectedScripts() {
  [&sessionId](InspectedContext* context) {
  context->discardInjectedScript(sessionId);
  });
+ m_inspector->promiseHandlerTracker().makeWeakForSession(sessionId);
 }
 
 Response V8InspectorSessionImpl::findInjectedScript(
@@ -269,6 +270,10 @@ void V8InspectorSessionImpl::releaseObjectGroup(const String16& objectGroup) {
  InjectedScript* injectedScript = context->getInjectedScript(sessionId);
 if (injectedScript) injectedScript->releaseObjectGroup(objectGroup);
  });
+if (!objectGroup.isEmpty()) {
+ m_inspector->promiseHandlerTracker().makeWeakForObjectGroup(m_sessionId,
+ objectGroup);
+ }
 }
 
 boolV8InspectorSessionImpl::unwrapObject(

deps/v8/test/inspector/runtime/evaluate-promise-lifetime-expected.txt

@@ -0,0 +1,65 @@
+Tests the lifetime of pending Runtime.evaluate requests.
+
+Running test: testPromiseIsKeptAlive
+Using replMode:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+Using awaitPromise:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+
+Running test: testObjectGroupReleaseMakesPromiseCollectible
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+
+Running test: testContextDestructionDiscardsPromise
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+
+Running test: testSessionDestructionMakesPromiseCollectible
+Promise is alive before disconnect: true
+Promise is alive after disconnect: false

deps/v8/test/inspector/runtime/evaluate-promise-lifetime.js

@@ -0,0 +1,105 @@
+// Copyright 2026 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --no-stress-incremental-marking
+
+let{Protocol}=InspectorTest.start(
+'Tests the lifetime of pending Runtime.evaluate requests.');
+
+constevaluationModes=[
+{
+name: 'replMode',
+arguments: {replMode: true},
+expression:
+'await new Promise(resolve => globalThis.resolve = resolve); 42',
+resolveExpression: 'resolve()',
+pendingExpression: 'await new Promise(() => {})',
+},
+{
+name: 'awaitPromise',
+arguments: {awaitPromise: true},
+expression: `(() => {
+ let resolve;
+ const promise = new Promise(r => resolve = r);
+ promise.resolve = resolve;
+ globalThis.weak = new WeakRef(promise);
+ return promise;
+ })()`,
+resolveExpression: 'weak.deref().resolve(42)',
+pendingExpression: 'new Promise(() => {})',
+},
+];
+
+functionevaluate(Protocol,mode,expression,extraArguments={}){
+returnProtocol.Runtime.evaluate(
+{...mode.arguments, ...extraArguments, expression});
+}
+
+InspectorTest.runAsyncTestSuite([
+asyncfunctiontestPromiseIsKeptAlive(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(Protocol,mode,mode.expression);
+
+awaitProtocol.HeapProfiler.collectGarbage();
+awaitProtocol.Runtime.evaluate({expression: mode.resolveExpression});
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestObjectGroupReleaseMakesPromiseCollectible(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(
+Protocol,mode,mode.pendingExpression,
+{objectGroup: 'evaluation'});
+
+awaitProtocol.Runtime.releaseObjectGroup({objectGroup: 'evaluation'});
+awaitProtocol.HeapProfiler.collectGarbage();
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestContextDestructionDiscardsPromise(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession=contextGroup.connect();
+constevaluation=evaluate(
+session.Protocol,mode,mode.pendingExpression);
+
+awaitsession.Protocol.Runtime.evaluate(
+{expression: 'inspector.fireContextDestroyed()'});
+
+InspectorTest.logMessage(awaitevaluation);
+session.disconnect();
+}
+},
+
+asyncfunctiontestSessionDestructionMakesPromiseCollectible(){
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession1=contextGroup.connect();
+constsession2=contextGroup.connect();
+session1.Protocol.Runtime.evaluate({
+expression: evaluationModes[1].expression,
+awaitPromise: true,
+});
+
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+letresult=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive before disconnect: ${result.result.result.value}`);
+
+session1.disconnect();
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+result=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive after disconnect: ${result.result.result.value}`);
+session2.disconnect();
+},
+]);

common.gypi

@@ -41,7 +41,7 @@
 
 # Reset this number to 0 on major V8 upgrades.
 # Increment by one for each non-official patch applied to deps/v8.
-'v8_embedder_string': '-node.51',
+'v8_embedder_string': '-node.52',
 
 ##### V8 defaults for Node.js #####
 

deps/v8/AUTHORS

@@ -76,6 +76,7 @@ Artem Kobzar <artem.kobzar@jetbrains.com>
 Arthur Islamov <arthur@islamov.ai>
 Asuka Shikina <shikina.asuka@gmail.com>
 Aurèle Barrière <aurele.barriere@gmail.com>
+Aviv Keller <me@aviv.sh>
 Bala Avulapati <bavulapati@gmail.com>
 Bangfu Tao <bangfu.tao@samsung.com>
 Ben Coe <bencoe@gmail.com>

deps/v8/src/inspector/injected-script.cc

@@ -204,8 +204,7 @@ class InjectedScript::ProtocolPromiseHandler {
  PromiseHandlerTracker::DiscardReason::kFulfilled);
  }
 
-ProtocolPromiseHandler(PromiseHandlerTracker::Id id,
- V8InspectorSessionImpl* session,
+ProtocolPromiseHandler(V8InspectorSessionImpl* session,
 int executionContextId, const String16& objectGroup,
  std::unique_ptr<WrapOptions> wrapOptions,
 bool replMode, bool throwOnSideEffect,
@@ -220,7 +219,13 @@ class InjectedScript::ProtocolPromiseHandler {
  m_replMode(replMode),
  m_throwOnSideEffect(throwOnSideEffect),
  m_callback(std::move(callback)),
- m_evaluationResult(m_inspector->isolate(), evaluationResult) {
+ m_evaluationResult(m_inspector->isolate(), evaluationResult) {}
+
+voidmakeWeak(PromiseHandlerTracker::Id id) {
+if (m_isActive || m_evaluationResult.IsEmpty() ||
+ m_evaluationResult.IsWeak()) {
+return;
+ }
  m_evaluationResult.SetWeak(reinterpret_cast<PromiseHandlerTracker::Id*>(id),
  cleanup, v8::WeakCallbackType::kParameter);
  }
@@ -238,6 +243,7 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidthenCallback(v8::Local<v8::Value> value) {
+ m_isActive = true;
 // We don't need the m_evaluationResult in the `thenCallback`, but we also
 // don't want `cleanup` running in case we re-enter JS.
  m_evaluationResult.Reset();
@@ -285,9 +291,10 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidcatchCallback(v8::Local<v8::Value> result) {
+ m_isActive = true;
 // Hold strongly onto m_evaluationResult now to prevent `cleanup` from
 // running in case any code below triggers GC.
- m_evaluationResult.ClearWeak();
+if (m_evaluationResult.IsWeak()) m_evaluationResult.ClearWeak();
  V8InspectorSessionImpl* session =
  m_inspector->sessionById(m_contextGroupId, m_sessionId);
 if (!session) return;
@@ -393,6 +400,7 @@ class InjectedScript::ProtocolPromiseHandler {
  std::unique_ptr<WrapOptions> m_wrapOptions;
 bool m_replMode;
 bool m_throwOnSideEffect;
+bool m_isActive = false;
  std::weak_ptr<EvaluateCallback> m_callback;
  v8::Global<v8::Promise> m_evaluationResult;
 };
@@ -1190,8 +1198,7 @@ template <typename... Args>
 PromiseHandlerTracker::Id PromiseHandlerTracker::create(Args&&... args) {
  Id id = m_lastUsedId++;
  InjectedScript::ProtocolPromiseHandler* handler =
-newInjectedScript::ProtocolPromiseHandler(id,
- std::forward<Args>(args)...);
+newInjectedScript::ProtocolPromiseHandler(std::forward<Args>(args)...);
  m_promiseHandlers.emplace(id, handler);
 return id;
 }
@@ -1225,6 +1232,30 @@ InjectedScript::ProtocolPromiseHandler* PromiseHandlerTracker::get(
 return iter->second.get();
 }
 
+voidPromiseHandlerTracker::makeWeakForContext(int executionContextId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_executionContextId == executionContextId) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForObjectGroup(
+int sessionId, const String16& objectGroup) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId &&
+ handler->m_objectGroup == objectGroup) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForSession(int sessionId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId) handler->makeWeak(id);
+ }
+}
+
 voidPromiseHandlerTracker::sendFailure(
  InjectedScript::ProtocolPromiseHandler* handler,
 const protocol::DispatchResponse& response) const {

deps/v8/src/inspector/injected-script.h

@@ -298,6 +298,9 @@ class PromiseHandlerTracker {
  Id create(Args&&... args);
 voiddiscard(Id id, DiscardReason reason);
  InjectedScript::ProtocolPromiseHandler* get(Id id) const;
+voidmakeWeakForContext(int executionContextId);
+voidmakeWeakForObjectGroup(int sessionId, const String16& objectGroup);
+voidmakeWeakForSession(int sessionId);
 
 private:
 voidsendFailure(InjectedScript::ProtocolPromiseHandler* handler,

deps/v8/src/inspector/v8-inspector-impl.cc

@@ -261,6 +261,7 @@ void V8InspectorImpl::contextCollected(int groupId, int contextId) {
  session->runtimeAgent()->reportExecutionContextDestroyed(inspectedContext);
  });
 discardInspectedContext(groupId, contextId);
+ m_promiseHandlerTracker.makeWeakForContext(contextId);
 }
 
 voidV8InspectorImpl::resetContextGroup(int contextGroupId) {

deps/v8/src/inspector/v8-inspector-session-impl.cc

@@ -233,6 +233,7 @@ void V8InspectorSessionImpl::discardInjectedScripts() {
  [&sessionId](InspectedContext* context) {
  context->discardInjectedScript(sessionId);
  });
+ m_inspector->promiseHandlerTracker().makeWeakForSession(sessionId);
 }
 
 Response V8InspectorSessionImpl::findInjectedScript(
@@ -269,6 +270,10 @@ void V8InspectorSessionImpl::releaseObjectGroup(const String16& objectGroup) {
  InjectedScript* injectedScript = context->getInjectedScript(sessionId);
 if (injectedScript) injectedScript->releaseObjectGroup(objectGroup);
  });
+if (!objectGroup.isEmpty()) {
+ m_inspector->promiseHandlerTracker().makeWeakForObjectGroup(m_sessionId,
+ objectGroup);
+ }
 }
 
 boolV8InspectorSessionImpl::unwrapObject(

deps/v8/test/inspector/runtime/evaluate-promise-lifetime-expected.txt

@@ -0,0 +1,65 @@
+Tests the lifetime of pending Runtime.evaluate requests.
+
+Running test: testPromiseIsKeptAlive
+Using replMode:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+Using awaitPromise:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+
+Running test: testObjectGroupReleaseMakesPromiseCollectible
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+
+Running test: testContextDestructionDiscardsPromise
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+
+Running test: testSessionDestructionMakesPromiseCollectible
+Promise is alive before disconnect: true
+Promise is alive after disconnect: false

deps/v8/test/inspector/runtime/evaluate-promise-lifetime.js

@@ -0,0 +1,105 @@
+// Copyright 2026 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --no-stress-incremental-marking
+
+let{Protocol}=InspectorTest.start(
+'Tests the lifetime of pending Runtime.evaluate requests.');
+
+constevaluationModes=[
+{
+name: 'replMode',
+arguments: {replMode: true},
+expression:
+'await new Promise(resolve => globalThis.resolve = resolve); 42',
+resolveExpression: 'resolve()',
+pendingExpression: 'await new Promise(() => {})',
+},
+{
+name: 'awaitPromise',
+arguments: {awaitPromise: true},
+expression: `(() => {
+ let resolve;
+ const promise = new Promise(r => resolve = r);
+ promise.resolve = resolve;
+ globalThis.weak = new WeakRef(promise);
+ return promise;
+ })()`,
+resolveExpression: 'weak.deref().resolve(42)',
+pendingExpression: 'new Promise(() => {})',
+},
+];
+
+functionevaluate(Protocol,mode,expression,extraArguments={}){
+returnProtocol.Runtime.evaluate(
+{...mode.arguments, ...extraArguments, expression});
+}
+
+InspectorTest.runAsyncTestSuite([
+asyncfunctiontestPromiseIsKeptAlive(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(Protocol,mode,mode.expression);
+
+awaitProtocol.HeapProfiler.collectGarbage();
+awaitProtocol.Runtime.evaluate({expression: mode.resolveExpression});
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestObjectGroupReleaseMakesPromiseCollectible(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(
+Protocol,mode,mode.pendingExpression,
+{objectGroup: 'evaluation'});
+
+awaitProtocol.Runtime.releaseObjectGroup({objectGroup: 'evaluation'});
+awaitProtocol.HeapProfiler.collectGarbage();
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestContextDestructionDiscardsPromise(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession=contextGroup.connect();
+constevaluation=evaluate(
+session.Protocol,mode,mode.pendingExpression);
+
+awaitsession.Protocol.Runtime.evaluate(
+{expression: 'inspector.fireContextDestroyed()'});
+
+InspectorTest.logMessage(awaitevaluation);
+session.disconnect();
+}
+},
+
+asyncfunctiontestSessionDestructionMakesPromiseCollectible(){
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession1=contextGroup.connect();
+constsession2=contextGroup.connect();
+session1.Protocol.Runtime.evaluate({
+expression: evaluationModes[1].expression,
+awaitPromise: true,
+});
+
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+letresult=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive before disconnect: ${result.result.result.value}`);
+
+session1.disconnect();
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+result=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive after disconnect: ${result.result.result.value}`);
+session2.disconnect();
+},
+]);

common.gypi

@@ -41,7 +41,7 @@
 
 # Reset this number to 0 on major V8 upgrades.
 # Increment by one for each non-official patch applied to deps/v8.
-'v8_embedder_string': '-node.51',
+'v8_embedder_string': '-node.52',
 
 ##### V8 defaults for Node.js #####
 

deps/v8/AUTHORS

@@ -76,6 +76,7 @@ Artem Kobzar <artem.kobzar@jetbrains.com>
 Arthur Islamov <arthur@islamov.ai>
 Asuka Shikina <shikina.asuka@gmail.com>
 Aurèle Barrière <aurele.barriere@gmail.com>
+Aviv Keller <me@aviv.sh>
 Bala Avulapati <bavulapati@gmail.com>
 Bangfu Tao <bangfu.tao@samsung.com>
 Ben Coe <bencoe@gmail.com>

deps/v8/src/inspector/injected-script.cc

@@ -204,8 +204,7 @@ class InjectedScript::ProtocolPromiseHandler {
  PromiseHandlerTracker::DiscardReason::kFulfilled);
  }
 
-ProtocolPromiseHandler(PromiseHandlerTracker::Id id,
- V8InspectorSessionImpl* session,
+ProtocolPromiseHandler(V8InspectorSessionImpl* session,
 int executionContextId, const String16& objectGroup,
  std::unique_ptr<WrapOptions> wrapOptions,
 bool replMode, bool throwOnSideEffect,
@@ -220,7 +219,13 @@ class InjectedScript::ProtocolPromiseHandler {
  m_replMode(replMode),
  m_throwOnSideEffect(throwOnSideEffect),
  m_callback(std::move(callback)),
- m_evaluationResult(m_inspector->isolate(), evaluationResult) {
+ m_evaluationResult(m_inspector->isolate(), evaluationResult) {}
+
+voidmakeWeak(PromiseHandlerTracker::Id id) {
+if (m_isActive || m_evaluationResult.IsEmpty() ||
+ m_evaluationResult.IsWeak()) {
+return;
+ }
  m_evaluationResult.SetWeak(reinterpret_cast<PromiseHandlerTracker::Id*>(id),
  cleanup, v8::WeakCallbackType::kParameter);
  }
@@ -238,6 +243,7 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidthenCallback(v8::Local<v8::Value> value) {
+ m_isActive = true;
 // We don't need the m_evaluationResult in the `thenCallback`, but we also
 // don't want `cleanup` running in case we re-enter JS.
  m_evaluationResult.Reset();
@@ -285,9 +291,10 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidcatchCallback(v8::Local<v8::Value> result) {
+ m_isActive = true;
 // Hold strongly onto m_evaluationResult now to prevent `cleanup` from
 // running in case any code below triggers GC.
- m_evaluationResult.ClearWeak();
+if (m_evaluationResult.IsWeak()) m_evaluationResult.ClearWeak();
  V8InspectorSessionImpl* session =
  m_inspector->sessionById(m_contextGroupId, m_sessionId);
 if (!session) return;
@@ -393,6 +400,7 @@ class InjectedScript::ProtocolPromiseHandler {
  std::unique_ptr<WrapOptions> m_wrapOptions;
 bool m_replMode;
 bool m_throwOnSideEffect;
+bool m_isActive = false;
  std::weak_ptr<EvaluateCallback> m_callback;
  v8::Global<v8::Promise> m_evaluationResult;
 };
@@ -1190,8 +1198,7 @@ template <typename... Args>
 PromiseHandlerTracker::Id PromiseHandlerTracker::create(Args&&... args) {
  Id id = m_lastUsedId++;
  InjectedScript::ProtocolPromiseHandler* handler =
-newInjectedScript::ProtocolPromiseHandler(id,
- std::forward<Args>(args)...);
+newInjectedScript::ProtocolPromiseHandler(std::forward<Args>(args)...);
  m_promiseHandlers.emplace(id, handler);
 return id;
 }
@@ -1225,6 +1232,30 @@ InjectedScript::ProtocolPromiseHandler* PromiseHandlerTracker::get(
 return iter->second.get();
 }
 
+voidPromiseHandlerTracker::makeWeakForContext(int executionContextId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_executionContextId == executionContextId) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForObjectGroup(
+int sessionId, const String16& objectGroup) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId &&
+ handler->m_objectGroup == objectGroup) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForSession(int sessionId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId) handler->makeWeak(id);
+ }
+}
+
 voidPromiseHandlerTracker::sendFailure(
  InjectedScript::ProtocolPromiseHandler* handler,
 const protocol::DispatchResponse& response) const {

deps/v8/src/inspector/injected-script.h

@@ -298,6 +298,9 @@ class PromiseHandlerTracker {
  Id create(Args&&... args);
 voiddiscard(Id id, DiscardReason reason);
  InjectedScript::ProtocolPromiseHandler* get(Id id) const;
+voidmakeWeakForContext(int executionContextId);
+voidmakeWeakForObjectGroup(int sessionId, const String16& objectGroup);
+voidmakeWeakForSession(int sessionId);
 
 private:
 voidsendFailure(InjectedScript::ProtocolPromiseHandler* handler,

deps/v8/src/inspector/v8-inspector-impl.cc

@@ -261,6 +261,7 @@ void V8InspectorImpl::contextCollected(int groupId, int contextId) {
  session->runtimeAgent()->reportExecutionContextDestroyed(inspectedContext);
  });
 discardInspectedContext(groupId, contextId);
+ m_promiseHandlerTracker.makeWeakForContext(contextId);
 }
 
 voidV8InspectorImpl::resetContextGroup(int contextGroupId) {

deps/v8/src/inspector/v8-inspector-session-impl.cc

@@ -233,6 +233,7 @@ void V8InspectorSessionImpl::discardInjectedScripts() {
  [&sessionId](InspectedContext* context) {
  context->discardInjectedScript(sessionId);
  });
+ m_inspector->promiseHandlerTracker().makeWeakForSession(sessionId);
 }
 
 Response V8InspectorSessionImpl::findInjectedScript(
@@ -269,6 +270,10 @@ void V8InspectorSessionImpl::releaseObjectGroup(const String16& objectGroup) {
  InjectedScript* injectedScript = context->getInjectedScript(sessionId);
 if (injectedScript) injectedScript->releaseObjectGroup(objectGroup);
  });
+if (!objectGroup.isEmpty()) {
+ m_inspector->promiseHandlerTracker().makeWeakForObjectGroup(m_sessionId,
+ objectGroup);
+ }
 }
 
 boolV8InspectorSessionImpl::unwrapObject(

deps/v8/test/inspector/runtime/evaluate-promise-lifetime-expected.txt

@@ -0,0 +1,65 @@
+Tests the lifetime of pending Runtime.evaluate requests.
+
+Running test: testPromiseIsKeptAlive
+Using replMode:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+Using awaitPromise:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+
+Running test: testObjectGroupReleaseMakesPromiseCollectible
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+
+Running test: testContextDestructionDiscardsPromise
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+
+Running test: testSessionDestructionMakesPromiseCollectible
+Promise is alive before disconnect: true
+Promise is alive after disconnect: false

deps/v8/test/inspector/runtime/evaluate-promise-lifetime.js

@@ -0,0 +1,105 @@
+// Copyright 2026 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --no-stress-incremental-marking
+
+let{Protocol}=InspectorTest.start(
+'Tests the lifetime of pending Runtime.evaluate requests.');
+
+constevaluationModes=[
+{
+name: 'replMode',
+arguments: {replMode: true},
+expression:
+'await new Promise(resolve => globalThis.resolve = resolve); 42',
+resolveExpression: 'resolve()',
+pendingExpression: 'await new Promise(() => {})',
+},
+{
+name: 'awaitPromise',
+arguments: {awaitPromise: true},
+expression: `(() => {
+ let resolve;
+ const promise = new Promise(r => resolve = r);
+ promise.resolve = resolve;
+ globalThis.weak = new WeakRef(promise);
+ return promise;
+ })()`,
+resolveExpression: 'weak.deref().resolve(42)',
+pendingExpression: 'new Promise(() => {})',
+},
+];
+
+functionevaluate(Protocol,mode,expression,extraArguments={}){
+returnProtocol.Runtime.evaluate(
+{...mode.arguments, ...extraArguments, expression});
+}
+
+InspectorTest.runAsyncTestSuite([
+asyncfunctiontestPromiseIsKeptAlive(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(Protocol,mode,mode.expression);
+
+awaitProtocol.HeapProfiler.collectGarbage();
+awaitProtocol.Runtime.evaluate({expression: mode.resolveExpression});
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestObjectGroupReleaseMakesPromiseCollectible(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(
+Protocol,mode,mode.pendingExpression,
+{objectGroup: 'evaluation'});
+
+awaitProtocol.Runtime.releaseObjectGroup({objectGroup: 'evaluation'});
+awaitProtocol.HeapProfiler.collectGarbage();
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestContextDestructionDiscardsPromise(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession=contextGroup.connect();
+constevaluation=evaluate(
+session.Protocol,mode,mode.pendingExpression);
+
+awaitsession.Protocol.Runtime.evaluate(
+{expression: 'inspector.fireContextDestroyed()'});
+
+InspectorTest.logMessage(awaitevaluation);
+session.disconnect();
+}
+},
+
+asyncfunctiontestSessionDestructionMakesPromiseCollectible(){
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession1=contextGroup.connect();
+constsession2=contextGroup.connect();
+session1.Protocol.Runtime.evaluate({
+expression: evaluationModes[1].expression,
+awaitPromise: true,
+});
+
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+letresult=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive before disconnect: ${result.result.result.value}`);
+
+session1.disconnect();
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+result=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive after disconnect: ${result.result.result.value}`);
+session2.disconnect();
+},
+]);

common.gypi

@@ -41,7 +41,7 @@
 
 # Reset this number to 0 on major V8 upgrades.
 # Increment by one for each non-official patch applied to deps/v8.
-'v8_embedder_string': '-node.51',
+'v8_embedder_string': '-node.52',
 
 ##### V8 defaults for Node.js #####
 

deps/v8/AUTHORS

@@ -76,6 +76,7 @@ Artem Kobzar <artem.kobzar@jetbrains.com>
 Arthur Islamov <arthur@islamov.ai>
 Asuka Shikina <shikina.asuka@gmail.com>
 Aurèle Barrière <aurele.barriere@gmail.com>
+Aviv Keller <me@aviv.sh>
 Bala Avulapati <bavulapati@gmail.com>
 Bangfu Tao <bangfu.tao@samsung.com>
 Ben Coe <bencoe@gmail.com>

deps/v8/src/inspector/injected-script.cc

@@ -204,8 +204,7 @@ class InjectedScript::ProtocolPromiseHandler {
  PromiseHandlerTracker::DiscardReason::kFulfilled);
  }
 
-ProtocolPromiseHandler(PromiseHandlerTracker::Id id,
- V8InspectorSessionImpl* session,
+ProtocolPromiseHandler(V8InspectorSessionImpl* session,
 int executionContextId, const String16& objectGroup,
  std::unique_ptr<WrapOptions> wrapOptions,
 bool replMode, bool throwOnSideEffect,
@@ -220,7 +219,13 @@ class InjectedScript::ProtocolPromiseHandler {
  m_replMode(replMode),
  m_throwOnSideEffect(throwOnSideEffect),
  m_callback(std::move(callback)),
- m_evaluationResult(m_inspector->isolate(), evaluationResult) {
+ m_evaluationResult(m_inspector->isolate(), evaluationResult) {}
+
+voidmakeWeak(PromiseHandlerTracker::Id id) {
+if (m_isActive || m_evaluationResult.IsEmpty() ||
+ m_evaluationResult.IsWeak()) {
+return;
+ }
  m_evaluationResult.SetWeak(reinterpret_cast<PromiseHandlerTracker::Id*>(id),
  cleanup, v8::WeakCallbackType::kParameter);
  }
@@ -238,6 +243,7 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidthenCallback(v8::Local<v8::Value> value) {
+ m_isActive = true;
 // We don't need the m_evaluationResult in the `thenCallback`, but we also
 // don't want `cleanup` running in case we re-enter JS.
  m_evaluationResult.Reset();
@@ -285,9 +291,10 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidcatchCallback(v8::Local<v8::Value> result) {
+ m_isActive = true;
 // Hold strongly onto m_evaluationResult now to prevent `cleanup` from
 // running in case any code below triggers GC.
- m_evaluationResult.ClearWeak();
+if (m_evaluationResult.IsWeak()) m_evaluationResult.ClearWeak();
  V8InspectorSessionImpl* session =
  m_inspector->sessionById(m_contextGroupId, m_sessionId);
 if (!session) return;
@@ -393,6 +400,7 @@ class InjectedScript::ProtocolPromiseHandler {
  std::unique_ptr<WrapOptions> m_wrapOptions;
 bool m_replMode;
 bool m_throwOnSideEffect;
+bool m_isActive = false;
  std::weak_ptr<EvaluateCallback> m_callback;
  v8::Global<v8::Promise> m_evaluationResult;
 };
@@ -1190,8 +1198,7 @@ template <typename... Args>
 PromiseHandlerTracker::Id PromiseHandlerTracker::create(Args&&... args) {
  Id id = m_lastUsedId++;
  InjectedScript::ProtocolPromiseHandler* handler =
-newInjectedScript::ProtocolPromiseHandler(id,
- std::forward<Args>(args)...);
+newInjectedScript::ProtocolPromiseHandler(std::forward<Args>(args)...);
  m_promiseHandlers.emplace(id, handler);
 return id;
 }
@@ -1225,6 +1232,30 @@ InjectedScript::ProtocolPromiseHandler* PromiseHandlerTracker::get(
 return iter->second.get();
 }
 
+voidPromiseHandlerTracker::makeWeakForContext(int executionContextId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_executionContextId == executionContextId) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForObjectGroup(
+int sessionId, const String16& objectGroup) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId &&
+ handler->m_objectGroup == objectGroup) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForSession(int sessionId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId) handler->makeWeak(id);
+ }
+}
+
 voidPromiseHandlerTracker::sendFailure(
  InjectedScript::ProtocolPromiseHandler* handler,
 const protocol::DispatchResponse& response) const {

deps/v8/src/inspector/injected-script.h

@@ -298,6 +298,9 @@ class PromiseHandlerTracker {
  Id create(Args&&... args);
 voiddiscard(Id id, DiscardReason reason);
  InjectedScript::ProtocolPromiseHandler* get(Id id) const;
+voidmakeWeakForContext(int executionContextId);
+voidmakeWeakForObjectGroup(int sessionId, const String16& objectGroup);
+voidmakeWeakForSession(int sessionId);
 
 private:
 voidsendFailure(InjectedScript::ProtocolPromiseHandler* handler,

deps/v8/src/inspector/v8-inspector-impl.cc

@@ -261,6 +261,7 @@ void V8InspectorImpl::contextCollected(int groupId, int contextId) {
  session->runtimeAgent()->reportExecutionContextDestroyed(inspectedContext);
  });
 discardInspectedContext(groupId, contextId);
+ m_promiseHandlerTracker.makeWeakForContext(contextId);
 }
 
 voidV8InspectorImpl::resetContextGroup(int contextGroupId) {

deps/v8/src/inspector/v8-inspector-session-impl.cc

@@ -233,6 +233,7 @@ void V8InspectorSessionImpl::discardInjectedScripts() {
  [&sessionId](InspectedContext* context) {
  context->discardInjectedScript(sessionId);
  });
+ m_inspector->promiseHandlerTracker().makeWeakForSession(sessionId);
 }
 
 Response V8InspectorSessionImpl::findInjectedScript(
@@ -269,6 +270,10 @@ void V8InspectorSessionImpl::releaseObjectGroup(const String16& objectGroup) {
  InjectedScript* injectedScript = context->getInjectedScript(sessionId);
 if (injectedScript) injectedScript->releaseObjectGroup(objectGroup);
  });
+if (!objectGroup.isEmpty()) {
+ m_inspector->promiseHandlerTracker().makeWeakForObjectGroup(m_sessionId,
+ objectGroup);
+ }
 }
 
 boolV8InspectorSessionImpl::unwrapObject(

deps/v8/test/inspector/runtime/evaluate-promise-lifetime-expected.txt

@@ -0,0 +1,65 @@
+Tests the lifetime of pending Runtime.evaluate requests.
+
+Running test: testPromiseIsKeptAlive
+Using replMode:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+Using awaitPromise:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+
+Running test: testObjectGroupReleaseMakesPromiseCollectible
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+
+Running test: testContextDestructionDiscardsPromise
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+
+Running test: testSessionDestructionMakesPromiseCollectible
+Promise is alive before disconnect: true
+Promise is alive after disconnect: false

deps/v8/test/inspector/runtime/evaluate-promise-lifetime.js

@@ -0,0 +1,105 @@
+// Copyright 2026 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --no-stress-incremental-marking
+
+let{Protocol}=InspectorTest.start(
+'Tests the lifetime of pending Runtime.evaluate requests.');
+
+constevaluationModes=[
+{
+name: 'replMode',
+arguments: {replMode: true},
+expression:
+'await new Promise(resolve => globalThis.resolve = resolve); 42',
+resolveExpression: 'resolve()',
+pendingExpression: 'await new Promise(() => {})',
+},
+{
+name: 'awaitPromise',
+arguments: {awaitPromise: true},
+expression: `(() => {
+ let resolve;
+ const promise = new Promise(r => resolve = r);
+ promise.resolve = resolve;
+ globalThis.weak = new WeakRef(promise);
+ return promise;
+ })()`,
+resolveExpression: 'weak.deref().resolve(42)',
+pendingExpression: 'new Promise(() => {})',
+},
+];
+
+functionevaluate(Protocol,mode,expression,extraArguments={}){
+returnProtocol.Runtime.evaluate(
+{...mode.arguments, ...extraArguments, expression});
+}
+
+InspectorTest.runAsyncTestSuite([
+asyncfunctiontestPromiseIsKeptAlive(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(Protocol,mode,mode.expression);
+
+awaitProtocol.HeapProfiler.collectGarbage();
+awaitProtocol.Runtime.evaluate({expression: mode.resolveExpression});
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestObjectGroupReleaseMakesPromiseCollectible(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(
+Protocol,mode,mode.pendingExpression,
+{objectGroup: 'evaluation'});
+
+awaitProtocol.Runtime.releaseObjectGroup({objectGroup: 'evaluation'});
+awaitProtocol.HeapProfiler.collectGarbage();
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestContextDestructionDiscardsPromise(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession=contextGroup.connect();
+constevaluation=evaluate(
+session.Protocol,mode,mode.pendingExpression);
+
+awaitsession.Protocol.Runtime.evaluate(
+{expression: 'inspector.fireContextDestroyed()'});
+
+InspectorTest.logMessage(awaitevaluation);
+session.disconnect();
+}
+},
+
+asyncfunctiontestSessionDestructionMakesPromiseCollectible(){
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession1=contextGroup.connect();
+constsession2=contextGroup.connect();
+session1.Protocol.Runtime.evaluate({
+expression: evaluationModes[1].expression,
+awaitPromise: true,
+});
+
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+letresult=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive before disconnect: ${result.result.result.value}`);
+
+session1.disconnect();
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+result=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive after disconnect: ${result.result.result.value}`);
+session2.disconnect();
+},
+]);

common.gypi

@@ -41,7 +41,7 @@
 
 # Reset this number to 0 on major V8 upgrades.
 # Increment by one for each non-official patch applied to deps/v8.
-'v8_embedder_string': '-node.51',
+'v8_embedder_string': '-node.52',
 
 ##### V8 defaults for Node.js #####
 

deps/v8/AUTHORS

@@ -76,6 +76,7 @@ Artem Kobzar <artem.kobzar@jetbrains.com>
 Arthur Islamov <arthur@islamov.ai>
 Asuka Shikina <shikina.asuka@gmail.com>
 Aurèle Barrière <aurele.barriere@gmail.com>
+Aviv Keller <me@aviv.sh>
 Bala Avulapati <bavulapati@gmail.com>
 Bangfu Tao <bangfu.tao@samsung.com>
 Ben Coe <bencoe@gmail.com>

deps/v8/src/inspector/injected-script.cc

@@ -204,8 +204,7 @@ class InjectedScript::ProtocolPromiseHandler {
  PromiseHandlerTracker::DiscardReason::kFulfilled);
  }
 
-ProtocolPromiseHandler(PromiseHandlerTracker::Id id,
- V8InspectorSessionImpl* session,
+ProtocolPromiseHandler(V8InspectorSessionImpl* session,
 int executionContextId, const String16& objectGroup,
  std::unique_ptr<WrapOptions> wrapOptions,
 bool replMode, bool throwOnSideEffect,
@@ -220,7 +219,13 @@ class InjectedScript::ProtocolPromiseHandler {
  m_replMode(replMode),
  m_throwOnSideEffect(throwOnSideEffect),
  m_callback(std::move(callback)),
- m_evaluationResult(m_inspector->isolate(), evaluationResult) {
+ m_evaluationResult(m_inspector->isolate(), evaluationResult) {}
+
+voidmakeWeak(PromiseHandlerTracker::Id id) {
+if (m_isActive || m_evaluationResult.IsEmpty() ||
+ m_evaluationResult.IsWeak()) {
+return;
+ }
  m_evaluationResult.SetWeak(reinterpret_cast<PromiseHandlerTracker::Id*>(id),
  cleanup, v8::WeakCallbackType::kParameter);
  }
@@ -238,6 +243,7 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidthenCallback(v8::Local<v8::Value> value) {
+ m_isActive = true;
 // We don't need the m_evaluationResult in the `thenCallback`, but we also
 // don't want `cleanup` running in case we re-enter JS.
  m_evaluationResult.Reset();
@@ -285,9 +291,10 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidcatchCallback(v8::Local<v8::Value> result) {
+ m_isActive = true;
 // Hold strongly onto m_evaluationResult now to prevent `cleanup` from
 // running in case any code below triggers GC.
- m_evaluationResult.ClearWeak();
+if (m_evaluationResult.IsWeak()) m_evaluationResult.ClearWeak();
  V8InspectorSessionImpl* session =
  m_inspector->sessionById(m_contextGroupId, m_sessionId);
 if (!session) return;
@@ -393,6 +400,7 @@ class InjectedScript::ProtocolPromiseHandler {
  std::unique_ptr<WrapOptions> m_wrapOptions;
 bool m_replMode;
 bool m_throwOnSideEffect;
+bool m_isActive = false;
  std::weak_ptr<EvaluateCallback> m_callback;
  v8::Global<v8::Promise> m_evaluationResult;
 };
@@ -1190,8 +1198,7 @@ template <typename... Args>
 PromiseHandlerTracker::Id PromiseHandlerTracker::create(Args&&... args) {
  Id id = m_lastUsedId++;
  InjectedScript::ProtocolPromiseHandler* handler =
-newInjectedScript::ProtocolPromiseHandler(id,
- std::forward<Args>(args)...);
+newInjectedScript::ProtocolPromiseHandler(std::forward<Args>(args)...);
  m_promiseHandlers.emplace(id, handler);
 return id;
 }
@@ -1225,6 +1232,30 @@ InjectedScript::ProtocolPromiseHandler* PromiseHandlerTracker::get(
 return iter->second.get();
 }
 
+voidPromiseHandlerTracker::makeWeakForContext(int executionContextId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_executionContextId == executionContextId) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForObjectGroup(
+int sessionId, const String16& objectGroup) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId &&
+ handler->m_objectGroup == objectGroup) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForSession(int sessionId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId) handler->makeWeak(id);
+ }
+}
+
 voidPromiseHandlerTracker::sendFailure(
  InjectedScript::ProtocolPromiseHandler* handler,
 const protocol::DispatchResponse& response) const {

deps/v8/src/inspector/injected-script.h

@@ -298,6 +298,9 @@ class PromiseHandlerTracker {
  Id create(Args&&... args);
 voiddiscard(Id id, DiscardReason reason);
  InjectedScript::ProtocolPromiseHandler* get(Id id) const;
+voidmakeWeakForContext(int executionContextId);
+voidmakeWeakForObjectGroup(int sessionId, const String16& objectGroup);
+voidmakeWeakForSession(int sessionId);
 
 private:
 voidsendFailure(InjectedScript::ProtocolPromiseHandler* handler,

deps/v8/src/inspector/v8-inspector-impl.cc

@@ -261,6 +261,7 @@ void V8InspectorImpl::contextCollected(int groupId, int contextId) {
  session->runtimeAgent()->reportExecutionContextDestroyed(inspectedContext);
  });
 discardInspectedContext(groupId, contextId);
+ m_promiseHandlerTracker.makeWeakForContext(contextId);
 }
 
 voidV8InspectorImpl::resetContextGroup(int contextGroupId) {

deps/v8/src/inspector/v8-inspector-session-impl.cc

@@ -233,6 +233,7 @@ void V8InspectorSessionImpl::discardInjectedScripts() {
  [&sessionId](InspectedContext* context) {
  context->discardInjectedScript(sessionId);
  });
+ m_inspector->promiseHandlerTracker().makeWeakForSession(sessionId);
 }
 
 Response V8InspectorSessionImpl::findInjectedScript(
@@ -269,6 +270,10 @@ void V8InspectorSessionImpl::releaseObjectGroup(const String16& objectGroup) {
  InjectedScript* injectedScript = context->getInjectedScript(sessionId);
 if (injectedScript) injectedScript->releaseObjectGroup(objectGroup);
  });
+if (!objectGroup.isEmpty()) {
+ m_inspector->promiseHandlerTracker().makeWeakForObjectGroup(m_sessionId,
+ objectGroup);
+ }
 }
 
 boolV8InspectorSessionImpl::unwrapObject(

deps/v8/test/inspector/runtime/evaluate-promise-lifetime-expected.txt

@@ -0,0 +1,65 @@
+Tests the lifetime of pending Runtime.evaluate requests.
+
+Running test: testPromiseIsKeptAlive
+Using replMode:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+Using awaitPromise:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+
+Running test: testObjectGroupReleaseMakesPromiseCollectible
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+
+Running test: testContextDestructionDiscardsPromise
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+
+Running test: testSessionDestructionMakesPromiseCollectible
+Promise is alive before disconnect: true
+Promise is alive after disconnect: false

deps/v8/test/inspector/runtime/evaluate-promise-lifetime.js

@@ -0,0 +1,105 @@
+// Copyright 2026 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --no-stress-incremental-marking
+
+let{Protocol}=InspectorTest.start(
+'Tests the lifetime of pending Runtime.evaluate requests.');
+
+constevaluationModes=[
+{
+name: 'replMode',
+arguments: {replMode: true},
+expression:
+'await new Promise(resolve => globalThis.resolve = resolve); 42',
+resolveExpression: 'resolve()',
+pendingExpression: 'await new Promise(() => {})',
+},
+{
+name: 'awaitPromise',
+arguments: {awaitPromise: true},
+expression: `(() => {
+ let resolve;
+ const promise = new Promise(r => resolve = r);
+ promise.resolve = resolve;
+ globalThis.weak = new WeakRef(promise);
+ return promise;
+ })()`,
+resolveExpression: 'weak.deref().resolve(42)',
+pendingExpression: 'new Promise(() => {})',
+},
+];
+
+functionevaluate(Protocol,mode,expression,extraArguments={}){
+returnProtocol.Runtime.evaluate(
+{...mode.arguments, ...extraArguments, expression});
+}
+
+InspectorTest.runAsyncTestSuite([
+asyncfunctiontestPromiseIsKeptAlive(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(Protocol,mode,mode.expression);
+
+awaitProtocol.HeapProfiler.collectGarbage();
+awaitProtocol.Runtime.evaluate({expression: mode.resolveExpression});
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestObjectGroupReleaseMakesPromiseCollectible(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(
+Protocol,mode,mode.pendingExpression,
+{objectGroup: 'evaluation'});
+
+awaitProtocol.Runtime.releaseObjectGroup({objectGroup: 'evaluation'});
+awaitProtocol.HeapProfiler.collectGarbage();
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestContextDestructionDiscardsPromise(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession=contextGroup.connect();
+constevaluation=evaluate(
+session.Protocol,mode,mode.pendingExpression);
+
+awaitsession.Protocol.Runtime.evaluate(
+{expression: 'inspector.fireContextDestroyed()'});
+
+InspectorTest.logMessage(awaitevaluation);
+session.disconnect();
+}
+},
+
+asyncfunctiontestSessionDestructionMakesPromiseCollectible(){
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession1=contextGroup.connect();
+constsession2=contextGroup.connect();
+session1.Protocol.Runtime.evaluate({
+expression: evaluationModes[1].expression,
+awaitPromise: true,
+});
+
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+letresult=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive before disconnect: ${result.result.result.value}`);
+
+session1.disconnect();
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+result=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive after disconnect: ${result.result.result.value}`);
+session2.disconnect();
+},
+]);

common.gypi

@@ -41,7 +41,7 @@
 
 # Reset this number to 0 on major V8 upgrades.
 # Increment by one for each non-official patch applied to deps/v8.
-'v8_embedder_string': '-node.51',
+'v8_embedder_string': '-node.52',
 
 ##### V8 defaults for Node.js #####
 

deps/v8/AUTHORS

@@ -76,6 +76,7 @@ Artem Kobzar <artem.kobzar@jetbrains.com>
 Arthur Islamov <arthur@islamov.ai>
 Asuka Shikina <shikina.asuka@gmail.com>
 Aurèle Barrière <aurele.barriere@gmail.com>
+Aviv Keller <me@aviv.sh>
 Bala Avulapati <bavulapati@gmail.com>
 Bangfu Tao <bangfu.tao@samsung.com>
 Ben Coe <bencoe@gmail.com>

deps/v8/src/inspector/injected-script.cc

@@ -204,8 +204,7 @@ class InjectedScript::ProtocolPromiseHandler {
  PromiseHandlerTracker::DiscardReason::kFulfilled);
  }
 
-ProtocolPromiseHandler(PromiseHandlerTracker::Id id,
- V8InspectorSessionImpl* session,
+ProtocolPromiseHandler(V8InspectorSessionImpl* session,
 int executionContextId, const String16& objectGroup,
  std::unique_ptr<WrapOptions> wrapOptions,
 bool replMode, bool throwOnSideEffect,
@@ -220,7 +219,13 @@ class InjectedScript::ProtocolPromiseHandler {
  m_replMode(replMode),
  m_throwOnSideEffect(throwOnSideEffect),
  m_callback(std::move(callback)),
- m_evaluationResult(m_inspector->isolate(), evaluationResult) {
+ m_evaluationResult(m_inspector->isolate(), evaluationResult) {}
+
+voidmakeWeak(PromiseHandlerTracker::Id id) {
+if (m_isActive || m_evaluationResult.IsEmpty() ||
+ m_evaluationResult.IsWeak()) {
+return;
+ }
  m_evaluationResult.SetWeak(reinterpret_cast<PromiseHandlerTracker::Id*>(id),
  cleanup, v8::WeakCallbackType::kParameter);
  }
@@ -238,6 +243,7 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidthenCallback(v8::Local<v8::Value> value) {
+ m_isActive = true;
 // We don't need the m_evaluationResult in the `thenCallback`, but we also
 // don't want `cleanup` running in case we re-enter JS.
  m_evaluationResult.Reset();
@@ -285,9 +291,10 @@ class InjectedScript::ProtocolPromiseHandler {
  }
 
 voidcatchCallback(v8::Local<v8::Value> result) {
+ m_isActive = true;
 // Hold strongly onto m_evaluationResult now to prevent `cleanup` from
 // running in case any code below triggers GC.
- m_evaluationResult.ClearWeak();
+if (m_evaluationResult.IsWeak()) m_evaluationResult.ClearWeak();
  V8InspectorSessionImpl* session =
  m_inspector->sessionById(m_contextGroupId, m_sessionId);
 if (!session) return;
@@ -393,6 +400,7 @@ class InjectedScript::ProtocolPromiseHandler {
  std::unique_ptr<WrapOptions> m_wrapOptions;
 bool m_replMode;
 bool m_throwOnSideEffect;
+bool m_isActive = false;
  std::weak_ptr<EvaluateCallback> m_callback;
  v8::Global<v8::Promise> m_evaluationResult;
 };
@@ -1190,8 +1198,7 @@ template <typename... Args>
 PromiseHandlerTracker::Id PromiseHandlerTracker::create(Args&&... args) {
  Id id = m_lastUsedId++;
  InjectedScript::ProtocolPromiseHandler* handler =
-newInjectedScript::ProtocolPromiseHandler(id,
- std::forward<Args>(args)...);
+newInjectedScript::ProtocolPromiseHandler(std::forward<Args>(args)...);
  m_promiseHandlers.emplace(id, handler);
 return id;
 }
@@ -1225,6 +1232,30 @@ InjectedScript::ProtocolPromiseHandler* PromiseHandlerTracker::get(
 return iter->second.get();
 }
 
+voidPromiseHandlerTracker::makeWeakForContext(int executionContextId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_executionContextId == executionContextId) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForObjectGroup(
+int sessionId, const String16& objectGroup) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId &&
+ handler->m_objectGroup == objectGroup) {
+ handler->makeWeak(id);
+ }
+ }
+}
+
+voidPromiseHandlerTracker::makeWeakForSession(int sessionId) {
+for (auto& [id, handler] : m_promiseHandlers) {
+if (handler->m_sessionId == sessionId) handler->makeWeak(id);
+ }
+}
+
 voidPromiseHandlerTracker::sendFailure(
  InjectedScript::ProtocolPromiseHandler* handler,
 const protocol::DispatchResponse& response) const {

deps/v8/src/inspector/injected-script.h

@@ -298,6 +298,9 @@ class PromiseHandlerTracker {
  Id create(Args&&... args);
 voiddiscard(Id id, DiscardReason reason);
  InjectedScript::ProtocolPromiseHandler* get(Id id) const;
+voidmakeWeakForContext(int executionContextId);
+voidmakeWeakForObjectGroup(int sessionId, const String16& objectGroup);
+voidmakeWeakForSession(int sessionId);
 
 private:
 voidsendFailure(InjectedScript::ProtocolPromiseHandler* handler,

deps/v8/src/inspector/v8-inspector-impl.cc

@@ -261,6 +261,7 @@ void V8InspectorImpl::contextCollected(int groupId, int contextId) {
  session->runtimeAgent()->reportExecutionContextDestroyed(inspectedContext);
  });
 discardInspectedContext(groupId, contextId);
+ m_promiseHandlerTracker.makeWeakForContext(contextId);
 }
 
 voidV8InspectorImpl::resetContextGroup(int contextGroupId) {

deps/v8/src/inspector/v8-inspector-session-impl.cc

@@ -233,6 +233,7 @@ void V8InspectorSessionImpl::discardInjectedScripts() {
  [&sessionId](InspectedContext* context) {
  context->discardInjectedScript(sessionId);
  });
+ m_inspector->promiseHandlerTracker().makeWeakForSession(sessionId);
 }
 
 Response V8InspectorSessionImpl::findInjectedScript(
@@ -269,6 +270,10 @@ void V8InspectorSessionImpl::releaseObjectGroup(const String16& objectGroup) {
  InjectedScript* injectedScript = context->getInjectedScript(sessionId);
 if (injectedScript) injectedScript->releaseObjectGroup(objectGroup);
  });
+if (!objectGroup.isEmpty()) {
+ m_inspector->promiseHandlerTracker().makeWeakForObjectGroup(m_sessionId,
+ objectGroup);
+ }
 }
 
 boolV8InspectorSessionImpl::unwrapObject(

deps/v8/test/inspector/runtime/evaluate-promise-lifetime-expected.txt

@@ -0,0 +1,65 @@
+Tests the lifetime of pending Runtime.evaluate requests.
+
+Running test: testPromiseIsKeptAlive
+Using replMode:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+Using awaitPromise:
+{
+ id : <messageId>
+ result : {
+ result : {
+ description : 42
+ type : number
+ value : 42
+ }
+ }
+}
+
+Running test: testObjectGroupReleaseMakesPromiseCollectible
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Promise was collected
+ }
+ id : <messageId>
+}
+
+Running test: testContextDestructionDiscardsPromise
+Using replMode:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+Using awaitPromise:
+{
+ error : {
+ code : -32000
+ message : Execution context was destroyed.
+ }
+ id : <messageId>
+}
+
+Running test: testSessionDestructionMakesPromiseCollectible
+Promise is alive before disconnect: true
+Promise is alive after disconnect: false

deps/v8/test/inspector/runtime/evaluate-promise-lifetime.js

@@ -0,0 +1,105 @@
+// Copyright 2026 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --no-stress-incremental-marking
+
+let{Protocol}=InspectorTest.start(
+'Tests the lifetime of pending Runtime.evaluate requests.');
+
+constevaluationModes=[
+{
+name: 'replMode',
+arguments: {replMode: true},
+expression:
+'await new Promise(resolve => globalThis.resolve = resolve); 42',
+resolveExpression: 'resolve()',
+pendingExpression: 'await new Promise(() => {})',
+},
+{
+name: 'awaitPromise',
+arguments: {awaitPromise: true},
+expression: `(() => {
+ let resolve;
+ const promise = new Promise(r => resolve = r);
+ promise.resolve = resolve;
+ globalThis.weak = new WeakRef(promise);
+ return promise;
+ })()`,
+resolveExpression: 'weak.deref().resolve(42)',
+pendingExpression: 'new Promise(() => {})',
+},
+];
+
+functionevaluate(Protocol,mode,expression,extraArguments={}){
+returnProtocol.Runtime.evaluate(
+{...mode.arguments, ...extraArguments, expression});
+}
+
+InspectorTest.runAsyncTestSuite([
+asyncfunctiontestPromiseIsKeptAlive(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(Protocol,mode,mode.expression);
+
+awaitProtocol.HeapProfiler.collectGarbage();
+awaitProtocol.Runtime.evaluate({expression: mode.resolveExpression});
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestObjectGroupReleaseMakesPromiseCollectible(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constevaluation=evaluate(
+Protocol,mode,mode.pendingExpression,
+{objectGroup: 'evaluation'});
+
+awaitProtocol.Runtime.releaseObjectGroup({objectGroup: 'evaluation'});
+awaitProtocol.HeapProfiler.collectGarbage();
+
+InspectorTest.logMessage(awaitevaluation);
+}
+},
+
+asyncfunctiontestContextDestructionDiscardsPromise(){
+for(constmodeofevaluationModes){
+InspectorTest.log(`Using ${mode.name}:`);
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession=contextGroup.connect();
+constevaluation=evaluate(
+session.Protocol,mode,mode.pendingExpression);
+
+awaitsession.Protocol.Runtime.evaluate(
+{expression: 'inspector.fireContextDestroyed()'});
+
+InspectorTest.logMessage(awaitevaluation);
+session.disconnect();
+}
+},
+
+asyncfunctiontestSessionDestructionMakesPromiseCollectible(){
+constcontextGroup=newInspectorTest.ContextGroup();
+constsession1=contextGroup.connect();
+constsession2=contextGroup.connect();
+session1.Protocol.Runtime.evaluate({
+expression: evaluationModes[1].expression,
+awaitPromise: true,
+});
+
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+letresult=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive before disconnect: ${result.result.result.value}`);
+
+session1.disconnect();
+awaitsession2.Protocol.HeapProfiler.collectGarbage();
+result=awaitsession2.Protocol.Runtime.evaluate(
+{expression: 'weak.deref() !== undefined'});
+InspectorTest.log(
+`Promise is alive after disconnect: ${result.result.result.value}`);
+session2.disconnect();
+},
+]);