diff --git a/tooling/agent/debugger_impl.cpp b/tooling/agent/debugger_impl.cpp
index 6862fabc5e64a5fc79904712e12d5fda74db4d50..dfaed570ef68feae509c6e62361443dd0f9acd65 100755
--- a/tooling/agent/debugger_impl.cpp
+++ b/tooling/agent/debugger_impl.cpp
@@ -2127,22 +2127,49 @@ std::vector<std::unique_ptr<Scope>> DebuggerImpl::GetClosureScopeChains(const Fr
         thread, DebuggerApi::GetEnv(frameHandler));
     JSMutableHandle<JSTaggedValue> valueHandle = JSMutableHandle<JSTaggedValue>(thread, JSTaggedValue::Hole());
     JSTaggedValue currentEnv = envHandle.GetTaggedValue();
-    if (!currentEnv.IsLexicalEnv()) {
-        LOG_DEBUGGER(DEBUG) << "GetClosureScopeChains: currentEnv is invalid";
+    JSMutableHandle<JSTaggedValue> sendableEnvHandle = JSMutableHandle<JSTaggedValue>(
+        thread, DebuggerApi::GetSendableEnv(vm_));
+    JSTaggedValue currentSendableEnv = sendableEnvHandle.GetTaggedValue();
+    if (!currentEnv.IsLexicalEnv() && !currentSendableEnv.IsSendableEnv()) {
+        LOG_DEBUGGER(DEBUG) << "GetClosureScopeChains: currentEnv and currentSendableEnv is invalid";
         return closureScopes;
     }
     // check if GetLocalScopeChain has already found and set 'this' value
     bool thisFound = (*thisObj)->HasValue();
     bool closureVarFound = false;
-    // currentEnv = currentEnv->parent until currentEnv is not lexicalEnv
-    for (; currentEnv.IsLexicalEnv(); currentEnv = LexicalEnv::Cast(currentEnv.GetTaggedObject())->GetParentEnv()) {
-        LexicalEnv *lexicalEnv = LexicalEnv::Cast(currentEnv.GetTaggedObject());
-        envHandle.Update(currentEnv);
-        if (lexicalEnv->GetScopeInfo().IsHole()) {
-            continue;
+    bool isLexicalEnv = true;
+    // currentEnv = currentEnv->parent until currentEnv is not lexicalEnv or sendableEnv
+    for (; currentEnv.IsLexicalEnv() || currentEnv.IsSendableEnv() || isLexicalEnv;
+         currentEnv = isLexicalEnv?LexicalEnv::Cast(currentEnv.GetTaggedObject())->GetParentEnv()
+                                  :SendableEnv::Cast(currentEnv.GetTaggedObject())->GetParentEnv()) {
+        // add SendableDebugInfo
+        if (!currentEnv.IsLexicalEnv() && isLexicalEnv) {
+            isLexicalEnv = false;
+            envHandle = sendableEnvHandle;
+            currentEnv = currentSendableEnv;
+            if (!currentEnv.IsSendableEnv()) {
+                break;
+            }
+        }
+        LexicalEnv *lexicalEnv = nullptr;
+        SendableEnv *sendableEnv = nullptr;
+        if (isLexicalEnv) {
+            lexicalEnv = LexicalEnv::Cast(currentEnv.GetTaggedObject());
+            envHandle.Update(currentEnv);
+            if (lexicalEnv->GetScopeInfo().IsHole()) {
+                continue;
+            }
+        } else {
+            sendableEnv = SendableEnv::Cast(currentEnv.GetTaggedObject());
+            envHandle.Update(currentEnv);
+            if (sendableEnv->GetScopeInfo().IsHole()) {
+                continue;
+            }
         }
         auto closureScope = std::make_unique<Scope>();
-        auto result = JSNativePointer::Cast(lexicalEnv->GetScopeInfo().GetTaggedObject())->GetExternalPointer();
+        auto result = isLexicalEnv?
+                      JSNativePointer::Cast(lexicalEnv->GetScopeInfo().GetTaggedObject())->GetExternalPointer():
+                      JSNativePointer::Cast(sendableEnv->GetScopeInfo().GetTaggedObject())->GetExternalPointer();
         ScopeDebugInfo *scopeDebugInfo = reinterpret_cast<ScopeDebugInfo *>(result);
         std::unique_ptr<RemoteObject> closure = std::make_unique<RemoteObject>();
         Local<ObjectRef> closureScopeObj = ObjectRef::New(vm_);
@@ -2153,8 +2180,13 @@ std::vector<std::unique_ptr<Scope>> DebuggerImpl::GetClosureScopeChains(const Fr
                 continue;
             }
             currentEnv = envHandle.GetTaggedValue();
-            lexicalEnv = LexicalEnv::Cast(currentEnv.GetTaggedObject());
-            valueHandle.Update(lexicalEnv->GetProperties(slot));
+            if (isLexicalEnv) {
+                lexicalEnv = LexicalEnv::Cast(currentEnv.GetTaggedObject());
+                valueHandle.Update(lexicalEnv->GetProperties(slot));
+            } else {
+                sendableEnv= SendableEnv::Cast(currentEnv.GetTaggedObject());
+                valueHandle.Update(sendableEnv->GetProperties(slot));
+            }
             Local<JSValueRef> value = JSNApiHelper::ToLocal<JSValueRef>(valueHandle);
             Local<JSValueRef> varName = StringRef::NewFromUtf8(vm_, name.c_str());
             nameCount[name]++;
diff --git a/tooling/backend/debugger_executor.cpp b/tooling/backend/debugger_executor.cpp
index c7d2a6c0eccd0dad862658389a46cf137416bfc7..1e5642e8a9f5311d35f8d520c146145fad5a0545 100644
--- a/tooling/backend/debugger_executor.cpp
+++ b/tooling/backend/debugger_executor.cpp
@@ -96,6 +96,10 @@ Local<JSValueRef> DebuggerExecutor::GetValue(const EcmaVM *vm, const FrameHandle
     if (!value.IsEmpty()) {
         return value;
     }
+    value = GetSendableValue(vm, name);
+    if (!value.IsEmpty()) {
+        return value;
+    }
     value = GetModuleValue(vm, frameHandler, name);
     if (!value.IsEmpty()) {
         return value;
@@ -117,6 +121,9 @@ bool DebuggerExecutor::SetValue(const EcmaVM *vm, FrameHandler *frameHandler,
     if (SetLexicalValue(vm, frameHandler, name, value)) {
         return true;
     }
+    if (SetSendableValue(vm, name, value)) {
+        return true;
+    }
     if (SetModuleValue(vm, frameHandler, name, value)) {
         return true;
     }
@@ -176,6 +183,19 @@ Local<JSValueRef> DebuggerExecutor::GetLexicalValue(const EcmaVM *vm, const Fram
     return result;
 }
 
+Local<JSValueRef> DebuggerExecutor::GetSendableValue(const EcmaVM *vm, Local<StringRef> name)
+{
+    Local<JSValueRef> result;
+
+    auto [level, slot] = DebuggerApi::GetSendableSlot(vm, name->ToString(vm));
+    if (level == -1) {
+        return result;
+    }
+
+    result = DebuggerApi::GetSendableProperties(vm, level, slot);
+    return result;
+}
+
 bool DebuggerExecutor::SetLexicalValue(const EcmaVM *vm, const FrameHandler *frameHandler,
                                        Local<StringRef> name, Local<JSValueRef> value)
 {
@@ -190,6 +210,19 @@ bool DebuggerExecutor::SetLexicalValue(const EcmaVM *vm, const FrameHandler *fra
     return true;
 }
 
+bool DebuggerExecutor::SetSendableValue(const EcmaVM *vm, Local<StringRef> name, Local<JSValueRef> value)
+{
+    std::string varName = name->ToString(vm);
+    auto [level, slot] = DebuggerApi::GetSendableSlot(vm, varName);
+    if (level == -1) {
+        return false;
+    }
+
+    DebuggerApi::SetSendableProperties(vm, level, slot, value);
+    vm->GetJsDebuggerManager()->NotifyScopeUpdated(varName, value, Scope::Type::Closure());
+    return true;
+}
+
 Local<JSValueRef> DebuggerExecutor::GetGlobalValue(const EcmaVM *vm, Local<StringRef> name)
 {
     return DebuggerApi::GetGlobalValue(vm, name);
diff --git a/tooling/backend/debugger_executor.h b/tooling/backend/debugger_executor.h
index 5f1f64fb41acb8a99ae3b18058a9b69f8ac2ca94..d06244d61abddf579d40daa712784313b53962ea 100644
--- a/tooling/backend/debugger_executor.h
+++ b/tooling/backend/debugger_executor.h
@@ -46,6 +46,7 @@ private:
     static Local<JSValueRef> GetLocalValue(const EcmaVM *vm, const FrameHandler *frameHandler, Local<StringRef> name);
     static Local<JSValueRef> GetLexicalValue(const EcmaVM *vm, const FrameHandler *frameHandler,
                                              Local<StringRef> name);
+    static Local<JSValueRef> GetSendableValue(const EcmaVM *vm, Local<StringRef> name);
     static Local<JSValueRef> GetModuleValue(const EcmaVM *vm, const FrameHandler *frameHandler, Local<StringRef> name);
     static Local<JSValueRef> GetGlobalValue(const EcmaVM *vm, Local<StringRef> name);
 
@@ -53,6 +54,7 @@ private:
                               Local<StringRef> name, Local<JSValueRef> value);
     static bool SetLexicalValue(const EcmaVM *vm, const FrameHandler *frameHandler,
                                 Local<StringRef> name, Local<JSValueRef> value);
+    static bool SetSendableValue(const EcmaVM *vm, Local<StringRef> name, Local<JSValueRef> value);
     static bool SetModuleValue(const EcmaVM *vm, const FrameHandler *frameHandler,
                                Local<StringRef> name, Local<JSValueRef> value);
     static bool SetGlobalValue(const EcmaVM *vm, Local<StringRef> name, Local<JSValueRef> value);