Intermediate changes

12 files changed, 375 insertions, 40 deletions

diff --git a/yt/yt/client/api/client_common.h b/yt/yt/client/api/client_common.h
index 23802ac1ff..4133955e90 100644
--- a/yt/yt/client/api/client_common.h
+++ b/yt/yt/client/api/client_common.h
@@ -184,6 +184,8 @@ struct TSelectRowsOptions
     TDetailedProfilingInfoPtr DetailedProfilingInfo;
     //! YSON map with placeholder values for parameterized queries.
     NYson::TYsonString PlaceholderValues;
+    //! If |true| then WebAssembly execution backend is used.
+    std::optional<bool> UseWebAssembly;
     //! Expected schemas for tables in a query (used for replica fallback in replicated tables).
     using TExpectedTableSchemas = THashMap<NYPath::TYPath, NTableClient::TTableSchemaPtr>;
     TExpectedTableSchemas ExpectedTableSchemas;
diff --git a/yt/yt/client/api/rpc_proxy/client_base.cpp b/yt/yt/client/api/rpc_proxy/client_base.cpp
index e3c1283542..191a57b935 100644
--- a/yt/yt/client/api/rpc_proxy/client_base.cpp
+++ b/yt/yt/client/api/rpc_proxy/client_base.cpp
@@ -999,6 +999,9 @@ TFuture<TSelectRowsResult> TClientBase::SelectRows(
     req->set_fail_on_incomplete_result(options.FailOnIncompleteResult);
     req->set_verbose_logging(options.VerboseLogging);
     req->set_new_range_inference(options.NewRangeInference);
+    if (options.UseWebAssembly) {
+        req->set_use_web_assembly(*options.UseWebAssembly);
+    }
     req->set_enable_code_cache(options.EnableCodeCache);
     req->set_memory_limit_per_node(options.MemoryLimitPerNode);
     ToProto(req->mutable_suppressable_access_tracking_options(), options);
diff --git a/yt/yt/client/driver/driver.cpp b/yt/yt/client/driver/driver.cpp
index 854e9a2d7c..dfc733e56c 100644
--- a/yt/yt/client/driver/driver.cpp
+++ b/yt/yt/client/driver/driver.cpp
@@ -364,11 +364,11 @@ public:
         REGISTER_ALL(TSetBundleConfigCommand,              "set_bundle_config",               Structured, Null,       false,  false);
 
         REGISTER    (TGetPipelineSpecCommand,              "get_pipeline_spec",               Null,       Structured, true,   false, ApiVersion4);
-        REGISTER    (TSetPipelineSpecCommand,              "set_pipeline_spec",               Structured, Null,       true,   false, ApiVersion4);
-        REGISTER    (TRemovePipelineDynamicSpecCommand,    "remove_pipeline_spec",            Null,       Null,       true,   false, ApiVersion4);
+        REGISTER    (TSetPipelineSpecCommand,              "set_pipeline_spec",               Structured, Structured, true,   false, ApiVersion4);
+        REGISTER    (TRemovePipelineSpecCommand,           "remove_pipeline_spec",            Null,       Structured, true,   false, ApiVersion4);
         REGISTER    (TGetPipelineDynamicSpecCommand,       "get_pipeline_dynamic_spec",       Null,       Structured, true,   false, ApiVersion4);
-        REGISTER    (TSetPipelineDynamicSpecCommand,       "set_pipeline_dynamic_spec",       Structured, Null,       true,   false, ApiVersion4);
-        REGISTER    (TRemovePipelineDynamicSpecCommand,    "remove_pipeline_dynamic_spec",    Null,       Null,       true,   false, ApiVersion4);
+        REGISTER    (TSetPipelineDynamicSpecCommand,       "set_pipeline_dynamic_spec",       Structured, Structured, true,   false, ApiVersion4);
+        REGISTER    (TRemovePipelineDynamicSpecCommand,    "remove_pipeline_dynamic_spec",    Null,       Structured, true,   false, ApiVersion4);
         REGISTER    (TStartPipelineCommand,                "start_pipeline",                  Null,       Structured, false,  false, ApiVersion4);
         REGISTER    (TStopPipelineCommand,                 "stop_pipeline",                   Null,       Structured, false,  false, ApiVersion4);
         REGISTER    (TPausePipelineCommand,                "pause_pipeline",                  Null,       Structured, false,  false, ApiVersion4);
diff --git a/yt/yt/client/driver/flow_commands.cpp b/yt/yt/client/driver/flow_commands.cpp
index 4b5d84bfd5..ded088fbfa 100644
--- a/yt/yt/client/driver/flow_commands.cpp
+++ b/yt/yt/client/driver/flow_commands.cpp
@@ -90,8 +90,6 @@ void ExecuteRemovePipelineSpecCommand(
     auto specSetter)
 {
     auto client = context->GetClient();
-    auto spec = context->ConsumeInputValue();
-
     auto getResult = WaitFor(specGetter(client, specGetterOptions))
         .ValueOrThrow();
 
diff --git a/yt/yt/client/driver/table_commands.cpp b/yt/yt/client/driver/table_commands.cpp
index ccd30ac874..7dea19cd84 100644
--- a/yt/yt/client/driver/table_commands.cpp
+++ b/yt/yt/client/driver/table_commands.cpp
@@ -783,6 +783,13 @@ void TSelectRowsCommand::Register(TRegistrar registrar)
 
     registrar.Parameter("placeholder_values", &TThis::PlaceholderValues)
         .Optional();
+
+    registrar.ParameterWithUniversalAccessor<std::optional<bool>>(
+        "use_web_assembly",
+        [] (TThis* command) -> auto& {
+            return command->Options.UseWebAssembly;
+        })
+        .Optional(/*init*/ false);
 }
 
 bool TSelectRowsCommand::HasResponseParameters() const
diff --git a/yt/yt/core/ytree/unittests/yson_schema_ut.cpp b/yt/yt/core/ytree/unittests/yson_schema_ut.cpp
index 65060e25e3..c2f61a64c8 100644
--- a/yt/yt/core/ytree/unittests/yson_schema_ut.cpp
+++ b/yt/yt/core/ytree/unittests/yson_schema_ut.cpp
@@ -143,11 +143,6 @@ void Deserialize(TCustomType& value, NYT::NYTree::INodePtr node)
     value.Value = node->GetValue<int>();
 }
 
-void Deserialize(TCustomType& codec, NYT::NYson::TYsonPullParserCursor* cursor)
-{
-    Deserialize(codec, NYT::NYson::ExtractTo<NYT::NYTree::INodePtr>(cursor));
-}
-
 struct TTestStructWithCustomType
     : public TYsonStruct
 {
diff --git a/yt/yt/core/ytree/unittests/yson_struct_ut.cpp b/yt/yt/core/ytree/unittests/yson_struct_ut.cpp
index ae8fea5526..cc507e3178 100644
--- a/yt/yt/core/ytree/unittests/yson_struct_ut.cpp
+++ b/yt/yt/core/ytree/unittests/yson_struct_ut.cpp
@@ -1458,11 +1458,11 @@ public:
     }
 };
 
-TEST(TYsonStructTest, TestCustomDefaultsOfNestedStructsAreDiscardedOnDeserialize)
+TEST(TYsonStructTest, TestCustomDefaultsOfNestedStructsAreNotDiscardedOnDeserialize)
 {
     auto deserialized = ConvertTo<TIntrusivePtr<TYsonStructWithNestedStructsAndCustomDefaults>>(TYsonString(TStringBuf("{}")));
-    EXPECT_EQ(deserialized->YsonSerializable->IntValue, 1);
-    EXPECT_EQ(deserialized->YsonStruct->IntValue, 1);
+    EXPECT_EQ(deserialized->YsonSerializable->IntValue, 10);
+    EXPECT_EQ(deserialized->YsonStruct->IntValue, 10);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1825,6 +1825,66 @@ TEST(TYsonStructTest, ExternalizedYsonStructPostPreprocessors)
 
 ////////////////////////////////////////////////////////////////////////////////
 
+struct TTestTraitConfigWithDefaults
+{
+    int Field1;
+    double Field2;
+};
+
+class TTestTraitConfigWithDefaultsSerializer
+    : public TExternalizedYsonStruct
+{
+public:
+    REGISTER_EXTERNALIZED_YSON_STRUCT(TTestTraitConfigWithDefaults, TTestTraitConfigWithDefaultsSerializer);
+
+    static void Register(TRegistrar registrar)
+    {
+        registrar.ExternalClassParameter("field1", &TThat::Field1)
+            .Default(42);
+        registrar.ExternalClassParameter("field2", &TThat::Field2)
+            .Default(34);
+    }
+};
+
+ASSIGN_EXTERNAL_YSON_SERIALIZER(TTestTraitConfigWithDefaults, TTestTraitConfigWithDefaultsSerializer);
+
+class TFieldTesterWithCustomDefaults
+    : public NYT::NYTree::TYsonStructLite
+{
+public:
+    TTestTraitConfigWithDefaults Field;
+
+    REGISTER_YSON_STRUCT_LITE(TFieldTesterWithCustomDefaults);
+
+    static void Register(TRegistrar registrar)
+    {
+        registrar.Parameter("field", &TThis::Field)
+            .Default({44, 12});
+    }
+};
+
+TEST(TYsonStructTest, ExternalizedYsonStructCustomDefaults)
+{
+    TFieldTesterWithCustomDefaults tester;
+
+    EXPECT_EQ(tester.Field.Field1, 44);
+    EXPECT_EQ(tester.Field.Field2, 12);
+
+    auto node = BuildYsonNodeFluently()
+        .BeginMap()
+            .Item("field").BeginMap()
+                .Item("field2").Value(77)
+            .EndMap()
+        .EndMap()->AsMap();
+
+    tester.Load(node);
+
+    EXPECT_EQ(tester.Field.Field1, 44);
+    EXPECT_EQ(tester.Field.Field2, 77);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 struct TTestDerivedPodConfig
     : public TTestTraitConfig
 {
@@ -2017,5 +2077,192 @@ TEST(TYsonStructTest, ExternalizedYsonStructDerivedFromTwoExternalizedBases)
 
 ////////////////////////////////////////////////////////////////////////////////
 
+class TYsonStructWithCustomSubDefault
+    : public TYsonStruct
+{
+public:
+    TIntrusivePtr<TSimpleYsonStruct> Sub;
+
+    REGISTER_YSON_STRUCT(TYsonStructWithCustomSubDefault);
+
+    static void Register(TRegistrar registrar)
+    {
+        registrar.Parameter("sub", &TYsonStructWithCustomSubDefault::Sub)
+            .DefaultCtor([] {
+                auto sub = New<TSimpleYsonStruct>();
+                sub->IntValue = 2;
+                return sub;
+            });
+    }
+};
+
+TEST(TYsonStructTest, CustomSubStruct)
+{
+    auto testStruct = New<TYsonStructWithCustomSubDefault>();
+    EXPECT_EQ(testStruct->Sub->IntValue, 2);
+
+    auto testNode = BuildYsonNodeFluently()
+        .BeginMap()
+        .EndMap();
+    testStruct->Load(testNode);
+    EXPECT_EQ(testStruct->Sub->IntValue, 2);
+
+    testNode = BuildYsonNodeFluently()
+        .BeginMap()
+            .Item("sub")
+                .BeginMap()
+                .EndMap()
+        .EndMap();
+    testStruct->Load(testNode);
+    EXPECT_EQ(testStruct->Sub->IntValue, 2);
+
+    testNode = BuildYsonNodeFluently()
+        .BeginMap()
+            .Item("sub")
+                .BeginMap()
+                    .Item("int_value").Value(3)
+                .EndMap()
+        .EndMap();
+    testStruct->Load(testNode);
+    EXPECT_EQ(testStruct->Sub->IntValue, 3);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+// NB: Currently TYsonStructLite cannot be used as a field in another config as is.
+// Thus test below uses std::optional + MergeStrategy::Combine instead of plain struct.
+
+class TTestSubConfigLiteWithDefaults
+    : public TYsonStructLite
+{
+public:
+    int MyInt;
+    TString MyString;
+
+    REGISTER_YSON_STRUCT_LITE(TTestSubConfigLiteWithDefaults);
+
+    static void Register(TRegistrar registrar)
+    {
+        registrar.Parameter("my_int", &TThis::MyInt)
+            .Default(42);
+        registrar.Parameter("my_string", &TThis::MyString)
+            .Default("y");
+    }
+};
+
+class TTestConfigWithSubStructLite
+    : public TYsonStructLite
+{
+public:
+    std::optional<TTestSubConfigLiteWithDefaults> Sub;
+
+    REGISTER_YSON_STRUCT_LITE(TTestConfigWithSubStructLite);
+
+    static void Register(TRegistrar registrar)
+    {
+        registrar.Parameter("sub", &TThis::Sub)
+            .DefaultCtor([] {
+                TTestSubConfigLiteWithDefaults sub = {};
+                sub.MyInt = 11;
+                sub.MyString = "x";
+                return sub;
+            })
+            .MergeBy(EMergeStrategy::Combine);
+    }
+};
+
+TEST(TYsonStructTest, CustomSubStructLite)
+{
+    TTestConfigWithSubStructLite testStruct = {};
+
+    auto testNode = BuildYsonNodeFluently()
+        .BeginMap()
+        .EndMap();
+    testStruct.Load(testNode->AsMap());
+    EXPECT_EQ(testStruct.Sub->MyInt, 11);
+    EXPECT_EQ(testStruct.Sub->MyString, "x");
+
+    testNode = BuildYsonNodeFluently()
+        .BeginMap()
+            .Item("sub")
+                .BeginMap()
+                .EndMap()
+        .EndMap();
+    testStruct.Load(testNode->AsMap());
+    EXPECT_EQ(testStruct.Sub->MyInt, 11);
+    EXPECT_EQ(testStruct.Sub->MyString, "x");
+
+    testNode = BuildYsonNodeFluently()
+        .BeginMap()
+            .Item("sub")
+                .BeginMap()
+                    .Item("my_string").Value("C")
+                .EndMap()
+        .EndMap();
+    testStruct.Load(testNode->AsMap());
+    EXPECT_EQ(testStruct.Sub->MyInt, 11);
+    EXPECT_EQ(testStruct.Sub->MyString, "C");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TTestSupConfigWithCustomDefaults
+{
+    TTestTraitConfigWithDefaults Sub;
+};
+
+class TTestSupConfigWithCustomDefaultsSerializer
+    : public TExternalizedYsonStruct
+{
+public:
+    REGISTER_EXTERNALIZED_YSON_STRUCT(TTestSupConfigWithCustomDefaults, TTestSupConfigWithCustomDefaultsSerializer);
+
+    static void Register(TRegistrar registrar)
+    {
+        registrar.ExternalClassParameter("sub", &TThat::Sub)
+            .Default(TTestTraitConfigWithDefaults{
+                .Field1 = 16,
+                .Field2 = 34,
+            });
+    }
+};
+
+ASSIGN_EXTERNAL_YSON_SERIALIZER(TTestSupConfigWithCustomDefaults, TTestSupConfigWithCustomDefaultsSerializer);
+
+TEST(TYsonStructTest, CustomSubExternalizedStruct)
+{
+    TTestSupConfigWithCustomDefaults testStruct = {};
+
+    auto testNode = BuildYsonNodeFluently()
+        .BeginMap()
+        .EndMap();
+    Deserialize(testStruct, testNode->AsMap());
+    EXPECT_EQ(testStruct.Sub.Field1, 16);
+    EXPECT_EQ(testStruct.Sub.Field2, 34);
+
+    testNode = BuildYsonNodeFluently()
+        .BeginMap()
+            .Item("sub")
+                .BeginMap()
+                .EndMap()
+        .EndMap();
+    Deserialize(testStruct, testNode->AsMap());
+    EXPECT_EQ(testStruct.Sub.Field1, 16);
+    EXPECT_EQ(testStruct.Sub.Field2, 34);
+
+    testNode = BuildYsonNodeFluently()
+        .BeginMap()
+            .Item("sub")
+                .BeginMap()
+                    .Item("field2").Value(77)
+                .EndMap()
+        .EndMap();
+    Deserialize(testStruct, testNode->AsMap());
+    EXPECT_EQ(testStruct.Sub.Field1, 16);
+    EXPECT_EQ(testStruct.Sub.Field2, 77);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 } // namespace
 } // namespace NYT::NYTree
diff --git a/yt/yt/core/ytree/yson_struct-inl.h b/yt/yt/core/ytree/yson_struct-inl.h
index 656b0c5e60..be12349395 100644
--- a/yt/yt/core/ytree/yson_struct-inl.h
+++ b/yt/yt/core/ytree/yson_struct-inl.h
@@ -54,10 +54,16 @@ const std::type_info& CallCtor()
 //! Creates TSerializer object which has preprocessors applied
 //! to a TStruct object referred to by writable.
 template <std::default_initializable TStruct, class TSerializer>
-TSerializer TExternalizedYsonStruct::CreateWritable(TStruct& writable)
+TSerializer TExternalizedYsonStruct::CreateWritable(TStruct& writable, bool setDefaults)
 {
     static_assert(std::derived_from<TSerializer, TExternalizedYsonStruct>);
-    return TSerializer(&writable);
+    if (setDefaults) {
+        return TSerializer(&writable);
+    }
+
+    auto ret = TSerializer();
+    ret.SetThat(&writable);
+    return ret;
 }
 
 //! Creates TSerializer object which has preprocessors applied
@@ -267,11 +273,19 @@ void Serialize(const T& value, NYson::IYsonConsumer* consumer)
 
 template <class T>
     requires CExternallySerializable<T>
+void DeserializeExternalized(T& value, INodePtr node, bool postprocess, bool setDefaults)
+{
+    using TTraits = TGetExternalizedYsonStructTraits<T>;
+    using TSerializer = typename TTraits::TExternalSerializer;
+    auto serializer = TSerializer::template CreateWritable<T, TSerializer>(value, setDefaults);
+    serializer.Load(node, postprocess, setDefaults);
+}
+
+template <class T>
+    requires CExternallySerializable<T>
 void Deserialize(T& value, INodePtr node)
 {
-    using TSerializer = typename TGetExternalizedYsonStructTraits<T>::TExternalSerializer;
-    auto serializer = TSerializer::template CreateWritable<T, TSerializer>(value);
-    Deserialize(serializer, node);
+    DeserializeExternalized(value, std::move(node), /*postprocess*/ true, /*setDefaults*/ true);
 }
 
 template <class T>
@@ -552,7 +566,8 @@ public: \
 #define ASSIGN_EXTERNAL_YSON_SERIALIZER(TStruct, TSerializer) \
     [[maybe_unused]] constexpr auto GetExternalizedYsonStructTraits(TStruct) \
     { \
-        struct [[maybe_unused]] TTraits { \
+        struct [[maybe_unused]] TTraits \
+        { \
             using TExternalSerializer = TSerializer; \
         }; \
         static_assert(std::derived_from<TTraits::TExternalSerializer, ::NYT::NYTree::TExternalizedYsonStruct>, "External serializer must be derived from TExternalizedYsonStruct"); \
diff --git a/yt/yt/core/ytree/yson_struct.h b/yt/yt/core/ytree/yson_struct.h
index 6c815600aa..f28f5808f7 100644
--- a/yt/yt/core/ytree/yson_struct.h
+++ b/yt/yt/core/ytree/yson_struct.h
@@ -162,7 +162,7 @@ public:
 
     template <std::default_initializable TStruct, class TSerializer>
         // requires std::derived_from<TSerializer, TExternalizedYsonStruct<TStruct>>
-    static TSerializer CreateWritable(TStruct& writable);
+    static TSerializer CreateWritable(TStruct& writable, bool setDefaults);
 
     template <std::default_initializable TStruct, class TSerializer>
         // requires std::derived_from<TSerializer, TExternalizedYsonStruct<TStruct>>
diff --git a/yt/yt/core/ytree/yson_struct_detail-inl.h b/yt/yt/core/ytree/yson_struct_detail-inl.h
index 34d87a4412..06a54ff6ae 100644
--- a/yt/yt/core/ytree/yson_struct_detail-inl.h
+++ b/yt/yt/core/ytree/yson_struct_detail-inl.h
@@ -38,19 +38,24 @@ concept SupportsDontSerializeDefault =
 
 ////////////////////////////////////////////////////////////////////////////////
 
+// Primitive type
 template <class T>
 void LoadFromNode(
     T& parameter,
     NYTree::INodePtr node,
     const NYPath::TYPath& path,
-    EMergeStrategy /*mergeStrategy*/,
+    EMergeStrategy mergeStrategy,
     std::optional<EUnrecognizedStrategy> /*recursiveUnrecognizedStrategy*/)
 {
+    if (mergeStrategy == EMergeStrategy::Overwrite) {
+        parameter = T();
+    }
+
     try {
         Deserialize(parameter, node);
     } catch (const std::exception& ex) {
         THROW_ERROR_EXCEPTION("Error reading parameter %v", path)
-                << ex;
+            << ex;
     }
 }
 
@@ -114,6 +119,52 @@ void LoadFromNode(
     }
 }
 
+// YsonStructLite or ExternalizedYsonStruct serializer
+template <std::derived_from<TYsonStructLite> T>
+void LoadFromNode(
+    T& parameter,
+    NYTree::INodePtr node,
+    const NYPath::TYPath& path,
+    EMergeStrategy mergeStrategy,
+    std::optional<EUnrecognizedStrategy> /*recursiveUnrecognizedStrategy*/)
+{
+    if (mergeStrategy == EMergeStrategy::Overwrite) {
+        // NB: We call SetDefaults here instead of plain T()
+        // because ExternalizedYsonStruct serializer doesn't
+        // own its data therefore defaulting it would drop the
+        // reference to the actual object instead of overwriting it.
+        parameter.SetDefaults();
+    }
+
+    try {
+        parameter.Load(node, /*postprocess*/ true, /*setDefaults*/ false);
+    } catch (const std::exception& ex) {
+        THROW_ERROR_EXCEPTION("Error reading parameter %v", path)
+            << ex;
+    }
+}
+
+// ExternalizedYsonStruct
+template <CExternallySerializable T>
+void LoadFromNode(
+    T& parameter,
+    NYTree::INodePtr node,
+    const NYPath::TYPath& path,
+    EMergeStrategy mergeStrategy,
+    std::optional<EUnrecognizedStrategy> /*recursiveUnrecognizedStrategy*/)
+{
+    if (mergeStrategy == EMergeStrategy::Overwrite) {
+        parameter = T();
+    }
+
+    try {
+        DeserializeExternalized(parameter, node, /*postprocess*/ true, /*setDefaults*/ false);
+    } catch (const std::exception& ex) {
+        THROW_ERROR_EXCEPTION("Error reading parameter %v", path)
+            << ex;
+    }
+}
+
 // std::optional
 template <class T>
 void LoadFromNode(
@@ -136,6 +187,19 @@ void LoadFromNode(
             break;
         }
 
+        case EMergeStrategy::Combine: {
+            if (node->GetType() != NYTree::ENodeType::Entity) {
+                if (parameter.has_value()) {
+                    LoadFromNode(*parameter, node, path, EMergeStrategy::Combine, recursiveUnrecognizedStrategy);
+                } else {
+                    T value;
+                    LoadFromNode(value, node, path, EMergeStrategy::Overwrite, recursiveUnrecognizedStrategy);
+                    parameter = std::move(value);
+                }
+            }
+            break;
+        }
+
         default:
             YT_UNIMPLEMENTED();
     }
@@ -234,20 +298,17 @@ void LoadFromNode(
 
 ////////////////////////////////////////////////////////////////////////////////
 
+// Primitive type or YsonStructLite or ExternalizedYsonStruct
+// See LoadFromNode for further specialization.
 template <class T>
 void LoadFromCursor(
     T& parameter,
     NYson::TYsonPullParserCursor* cursor,
     const NYPath::TYPath& path,
-    EMergeStrategy /*mergeStrategy*/,
-    std::optional<EUnrecognizedStrategy> /*recursiveUnrecognizedStrategy*/)
+    EMergeStrategy mergeStrategy,
+    std::optional<EUnrecognizedStrategy> recursiveUnrecognizedStrategy)
 {
-    try {
-        Deserialize(parameter, cursor);
-    } catch (const std::exception& ex) {
-        THROW_ERROR_EXCEPTION("Error reading parameter %v", path)
-            << ex;
-    }
+    LoadFromNode(parameter, NYson::ExtractTo<NYTree::INodePtr>(cursor), path, mergeStrategy, recursiveUnrecognizedStrategy);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -359,6 +420,21 @@ void LoadFromCursor(
                 break;
             }
 
+            case EMergeStrategy::Combine: {
+                if ((*cursor)->GetType() == NYson::EYsonItemType::EntityValue) {
+                    cursor->Next();
+                } else {
+                    if (parameter.has_value()) {
+                        LoadFromCursor(*parameter, cursor, path, EMergeStrategy::Combine, recursiveUnrecognizedStrategy);
+                    } else {
+                        T value;
+                        LoadFromCursor(value, cursor, path, EMergeStrategy::Overwrite, recursiveUnrecognizedStrategy);
+                        parameter = std::move(value);
+                    }
+                }
+                break;
+            }
+
             default:
                 YT_UNIMPLEMENTED();
         }
@@ -727,14 +803,6 @@ void TYsonStructParameter<TValue>::SetDefaultsInitialized(TYsonStructBase* self)
     if (DefaultCtor_) {
         value = (*DefaultCtor_)();
     }
-
-    NPrivate::InvokeForComposites(
-        &value,
-        [] <NPrivate::IsYsonStructOrYsonSerializable T> (TIntrusivePtr<T> obj) {
-            if (obj) {
-                obj->SetDefaults();
-            }
-        });
 }
 
 template <class TValue>
diff --git a/yt/yt/core/ytree/yson_struct_detail.h b/yt/yt/core/ytree/yson_struct_detail.h
index 5a3effd704..d4e9fea19a 100644
--- a/yt/yt/core/ytree/yson_struct_detail.h
+++ b/yt/yt/core/ytree/yson_struct_detail.h
@@ -64,7 +64,6 @@ struct IYsonStructParameter
     virtual void WriteSchema(const TYsonStructBase* self, NYson::IYsonConsumer* consumer) const = 0;
 };
 
-//using IYsonStructParameterPtr = TIntrusivePtr<IYsonStructParameter>;
 DECLARE_REFCOUNTED_STRUCT(IYsonStructParameter)
 DEFINE_REFCOUNTED_TYPE(IYsonStructParameter)
 
diff --git a/yt/yt_proto/yt/client/api/rpc_proxy/proto/api_service.proto b/yt/yt_proto/yt/client/api/rpc_proxy/proto/api_service.proto
index a0cef87d82..5abd081653 100644
--- a/yt/yt_proto/yt/client/api/rpc_proxy/proto/api_service.proto
+++ b/yt/yt_proto/yt/client/api/rpc_proxy/proto/api_service.proto
@@ -591,6 +591,7 @@ message TReqSelectRows
     optional bool use_canonical_null_relations = 20;
     optional bool merge_versioned_rows = 21;
     optional int32 syntax_version = 22 [default = 1];
+    optional bool use_web_assembly = 23;
 
     optional TSuppressableAccessTrackingOptions suppressable_access_tracking_options = 104;
 }