diff --git a/src/parser/WASMComponentParser.cpp b/src/parser/WASMComponentParser.cpp
new file mode 100644
index 000000000..21aed7549
--- /dev/null
+++ b/src/parser/WASMComponentParser.cpp
@@ -0,0 +1,321 @@
+/*
+ * Copyright (c) 2022-present Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "Walrus.h"
+
+#include "parser/WASMComponentParser.h"
+#include "runtime/Store.h"
+#include "runtime/TypeStore.h"
+
+#include "wabt/binary-reader.h"
+#include "wabt/walrus/binary-reader-walrus.h"
+
+namespace wabt {
+
+class WASMComponentBinaryReader : public wabt::WASMComponentBinaryReaderDelegate {
+private:
+    Walrus::TypeStore& m_typeStore;
+
+public:
+    WASMComponentBinaryReader(Walrus::TypeStore& typeStore)
+        : m_typeStore(typeStore)
+    {
+    }
+
+    void OnCoreModule(const void* data,
+                      size_t size,
+                      const ReadBinaryOptions& options)
+    {
+    }
+
+    void BeginComponent(uint32_t version, size_t depth)
+    {
+    }
+
+    void EndComponent()
+    {
+    }
+
+    void BeginCoreInstance(Index module_index,
+                           uint32_t argument_count)
+    {
+    }
+
+    void OnCoreInstanceArg(const ComponentStringLoc& name,
+                           ComponentSort sort,
+                           Index index)
+    {
+    }
+
+    void EndCoreInstance()
+    {
+    }
+
+    void BeginInlineCoreInstance(uint32_t argument_count)
+    {
+    }
+
+    void OnInlineCoreInstanceArg(const ComponentStringLoc& name,
+                                 ComponentSort sort,
+                                 Index index)
+    {
+    }
+
+    void EndInlineCoreInstance()
+    {
+    }
+
+    void BeginInstance(Index component_index,
+                       uint32_t argument_count)
+    {
+    }
+
+    void OnInstanceArg(const ComponentStringLoc& name,
+                       ComponentSort sort,
+                       Index index)
+    {
+    }
+
+    void EndInstance()
+    {
+    }
+
+    void BeginInlineInstance(uint32_t argument_count)
+    {
+    }
+
+    void OnInlineInstanceArg(const ComponentStringLoc& name,
+                             nonstd::string_view* version_suffix,
+                             ComponentSort sort,
+                             Index index)
+    {
+    }
+
+    void EndInlineInstance()
+    {
+    }
+
+    void OnAliasExport(ComponentSort sort,
+                       Index instance_index,
+                       const ComponentStringLoc& name)
+    {
+    }
+
+    void OnAliasCoreExport(ComponentSort sort,
+                           Index core_instance_index,
+                           const ComponentStringLoc& name)
+    {
+    }
+
+    void OnAliasOuter(ComponentSort sort,
+                      uint32_t counter,
+                      uint32_t index)
+    {
+    }
+
+    void OnPrimitiveType(const ComponentType& type)
+    {
+    }
+
+    void BeginRecordType(uint32_t field_count)
+    {
+    }
+
+    void OnRecordField(const ComponentStringLoc& field_name,
+                       const ComponentType& field_type)
+    {
+    }
+
+    void EndRecordType()
+    {
+    }
+
+    void BeginVariantType(uint32_t case_count)
+    {
+    }
+
+    void OnVariantCase(const ComponentStringLoc& case_name,
+                       const ComponentType& case_type)
+    {
+    }
+
+    void EndVariantType()
+    {
+    }
+
+    void OnListType(const ComponentType& type)
+    {
+    }
+
+    void OnListFixedType(const ComponentType& type,
+                         uint32_t size)
+    {
+    }
+
+    void BeginTupleType(uint32_t item_count)
+    {
+    }
+
+    void OnTupleItem(const ComponentType& item)
+    {
+    }
+
+    void EndTupleType()
+    {
+    }
+
+    void BeginFlagsType(uint32_t label_count)
+    {
+    }
+
+    void OnFlagsLabel(const ComponentStringLoc& label)
+    {
+    }
+
+    void EndFlagsType()
+    {
+    }
+
+    void BeginEnumType(uint32_t label_count)
+    {
+    }
+
+    void OnEnumLabel(const ComponentStringLoc& label)
+    {
+    }
+
+    void EndEnumType()
+    {
+    }
+
+    void OnOptionType(const ComponentType& type)
+    {
+    }
+
+    void OnResultType(const ComponentType& result_type,
+                      const ComponentType& error_type)
+    {
+    }
+
+    void OnOwnType(Index index)
+    {
+    }
+
+    void OnBorrowType(Index index)
+    {
+    }
+
+    void OnStreamType(const ComponentType& type)
+    {
+    }
+
+    void OnFutureType(const ComponentType& type)
+    {
+    }
+
+    void BeginFuncType(ComponentTypeDef type,
+                       uint32_t param_count)
+    {
+    }
+
+    void OnFuncParam(ComponentStringLoc name,
+                     const ComponentType& type)
+    {
+    }
+
+    void OnFuncResult(const ComponentType& type)
+    {
+    }
+
+    void EndFuncType()
+    {
+    }
+
+    void OnResourceType(ComponentResourceRep rep,
+                        Index dtor)
+    {
+    }
+
+    void OnResourceAsyncType(ComponentResourceRep rep,
+                             Index dtor,
+                             Index callback)
+    {
+    }
+
+    void BeginInstanceType(uint32_t count)
+    {
+    }
+
+    void EndInstanceType()
+    {
+    }
+
+    void BeginComponentType(uint32_t count)
+    {
+    }
+
+    void EndComponentType()
+    {
+    }
+
+    void OnCanonLift(Index core_func_index,
+                     uint32_t option_count,
+                     ComponentCanonOption* options,
+                     Index type_index)
+    {
+    }
+
+    void OnCanonLower(Index func_index,
+                      uint32_t option_count,
+                      ComponentCanonOption* options)
+    {
+    }
+
+    void OnCanonType(ComponentCanon canon,
+                     Index type_index)
+    {
+    }
+
+    void OnImport(const ComponentStringLoc& name,
+                  nonstd::string_view* version_suffix,
+                  const ComponentExternalInfo& external_info)
+    {
+    }
+
+    void OnExport(const ComponentStringLoc& name,
+                  nonstd::string_view* version_suffix,
+                  ComponentExternalInfo* external_info,
+                  ComponentExportInfo* export_info)
+    {
+    }
+};
+
+} // namespace wabt
+
+namespace Walrus {
+
+std::pair<Optional<Component*>, std::string> WASMComponentParser::parseBinary(Store* store, const std::string& filename, const uint8_t* data, size_t len, const uint32_t JITFlags, const uint32_t featureFlags)
+{
+    wabt::WASMComponentBinaryReader delegate(store->getTypeStore());
+
+    std::string error = ReadWasmComponentBinary(filename, data, len, &delegate, featureFlags);
+    if (error.length()) {
+        return std::make_pair(nullptr, error);
+    }
+
+    return std::make_pair(nullptr, std::string());
+}
+
+} // namespace Walrus
diff --git a/src/parser/WASMComponentParser.h b/src/parser/WASMComponentParser.h
new file mode 100644
index 000000000..11210de50
--- /dev/null
+++ b/src/parser/WASMComponentParser.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2022-present Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __WalrusWASMComponentParser__
+#define __WalrusWASMComponentParser__
+
+#include "runtime/Component.h"
+
+namespace Walrus {
+
+class WASMComponentParser {
+public:
+    // returns <result, error>
+    static std::pair<Optional<Component*>, std::string> parseBinary(Store* store, const std::string& filename, const uint8_t* data, size_t len, const uint32_t JITFlags = 0, const uint32_t featureFlags = 0);
+};
+
+} // namespace Walrus
+
+#endif // __WalrusParser__
diff --git a/src/parser/WASMParser.cpp b/src/parser/WASMParser.cpp
index 28cafbe6b..792bd5e01 100644
--- a/src/parser/WASMParser.cpp
+++ b/src/parser/WASMParser.cpp
@@ -442,7 +442,7 @@ class WASMBinaryReader : public wabt::WASMBinaryReaderDelegate {
     size_t* m_readerOffsetPointer;
     const uint8_t* m_readerDataPointer;
     size_t m_codeEndOffset;
-    Walrus::TypeStore& typeStore;
+    Walrus::TypeStore& m_typeStore;
 
     struct PreprocessData {
         struct LocalVariableInfo {
@@ -864,7 +864,7 @@ class WASMBinaryReader : public wabt::WASMBinaryReaderDelegate {
         : m_readerOffsetPointer(nullptr)
         , m_readerDataPointer(nullptr)
         , m_codeEndOffset(0)
-        , typeStore(typeStore)
+        , m_typeStore(typeStore)
         , m_inInitExpr(false)
         , m_currentFunction(nullptr)
         , m_currentFunctionType(nullptr)
@@ -1013,7 +1013,7 @@ class WASMBinaryReader : public wabt::WASMBinaryReaderDelegate {
     virtual void EndTypeSection() override
     {
         m_result.m_typesAddedToStore = true;
-        typeStore.updateTypes(m_result.m_compositeTypes);
+        m_typeStore.updateTypes(m_result.m_compositeTypes);
     }
 
     virtual void OnImportCount(Index count) override
diff --git a/src/parser/WASMParser.h b/src/parser/WASMParser.h
index 440c48442..1ea931db7 100644
--- a/src/parser/WASMParser.h
+++ b/src/parser/WASMParser.h
@@ -60,4 +60,4 @@ class WASMParser {
 
 } // namespace Walrus
 
-#endif // __WalrusParser__
+#endif // __WalrusWASMParser__
diff --git a/src/runtime/Component.h b/src/runtime/Component.h
new file mode 100644
index 000000000..ef814ae2b
--- /dev/null
+++ b/src/runtime/Component.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2022-present Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __WalrusComponent__
+#define __WalrusComponent__
+
+#include "runtime/Module.h"
+
+namespace wabt {
+class WASMComponentBinaryReader;
+}
+
+namespace Walrus {
+
+class Component {
+    friend class wabt::WASMComponentBinaryReader;
+
+public:
+    virtual ~Component() {}
+};
+
+} // namespace Walrus
+
+#endif // __WalrusComponent__
diff --git a/src/shell/Shell.cpp b/src/shell/Shell.cpp
index 8b02876f7..a817db9fd 100644
--- a/src/shell/Shell.cpp
+++ b/src/shell/Shell.cpp
@@ -12,6 +12,7 @@
 #include "runtime/Engine.h"
 #include "runtime/Store.h"
 #include "runtime/Module.h"
+#include "runtime/Component.h"
 #include "runtime/Instance.h"
 #include "runtime/Function.h"
 #include "runtime/Table.h"
@@ -21,6 +22,7 @@
 #include "runtime/Trap.h"
 #include "runtime/DefinedFunctionTypes.h"
 #include "parser/WASMParser.h"
+#include "parser/WASMComponentParser.h"
 
 #include "wabt/wast-lexer.h"
 #include "wabt/wast-parser.h"
@@ -368,6 +370,17 @@ static Trap::TrapResult executeWASM(Store* store, const std::string& filename, c
                     &data);
 }
 
+static wabt::Result executeWASMComponent(Store* store, const std::string& filename, const std::vector<uint8_t>& src)
+{
+    std::pair<Optional<Component*>, std::string> parseResult = WASMComponentParser::parseBinary(store, filename, src.data(), src.size());
+    if (!parseResult.second.empty()) {
+        printf("Cannot run module: %s\n", parseResult.second.c_str());
+        return wabt::Result::Error;
+    }
+
+    return wabt::Result::Ok;
+}
+
 static bool endsWith(const std::string& str, const std::string& suffix)
 {
     return str.size() >= suffix.size() && str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
@@ -801,14 +814,40 @@ static Instance* fetchInstance(wabt::Var& moduleVar, std::map<size_t, Instance*>
 static void executeWAST(Store* store, const std::string& filename, const std::vector<uint8_t>& src, DefinedFunctionTypes& functionTypes)
 {
     wabt::Errors errors;
+    wabt::Features features;
+    features.EnableAll();
+    wabt::WastParseOptions parseWastOptions(features);
     auto lexer = wabt::WastLexer::CreateBufferLexer("test.wabt", src.data(), src.size(), &errors);
     ASSERT(lexer);
 
+    if (lexer->IsComponent()) {
+        std::unique_ptr<wabt::Component> component;
+        auto result = ParseWatComponent(lexer.get(), &component, &errors, &parseWastOptions);
+
+        if (wabt::Succeeded(result)) {
+            wabt::WriteBinaryOptions writeBinaryOptions;
+            writeBinaryOptions.features = features;
+            wabt::MemoryStream stream;
+            result = WriteBinaryComponent(&stream, component.get(), writeBinaryOptions);
+
+            if (wabt::Succeeded(result)) {
+                result = executeWASMComponent(store, filename, stream.output_buffer().data);
+            }
+        }
+
+        if (!wabt::Succeeded(result)) {
+            printf("Syntax error(s):\n");
+            for (auto& e : errors) {
+                printf("  %s\n", e.message.c_str());
+            }
+            printf("\n");
+            RELEASE_ASSERT_NOT_REACHED();
+        }
+        return;
+    }
+
     std::unique_ptr<wabt::Script> script;
-    wabt::Features features;
-    features.EnableAll();
-    wabt::WastParseOptions parse_wast_options(features);
-    auto result = wabt::ParseWastScript(lexer.get(), &script, &errors, &parse_wast_options);
+    auto result = wabt::ParseWastScript(lexer.get(), &script, &errors, &parseWastOptions);
     if (!wabt::Succeeded(result)) {
         printf("Syntax error(s):\n");
         for (auto& e : errors) {
@@ -1233,7 +1272,6 @@ int main(int argc, const char* argv[])
 
     parseArguments(argc, argv, options);
 
-
 #ifdef ENABLE_WASI
     // initialize WASI
     uvwasi_t uvwasi;
@@ -1288,6 +1326,8 @@ int main(int argc, const char* argv[])
             if (endsWith(filePath, "wasm")) {
                 if (!options.exportToRun.empty()) {
                     runExports(store, filePath, buf, options.exportToRun, functionTypes);
+                } else if (wabt::ReadBinaryIsComponent(buf.data(), buf.size())) {
+                    executeWASMComponent(store, filePath, buf);
                 } else {
                     auto trapResult = executeWASM(store, filePath, buf, functionTypes);
                     if (trapResult.exception) {
diff --git a/third_party/wabt/include/wabt/binary-reader.h b/third_party/wabt/include/wabt/binary-reader.h
index 275d3f595..1b5ff7047 100644
--- a/third_party/wabt/include/wabt/binary-reader.h
+++ b/third_party/wabt/include/wabt/binary-reader.h
@@ -581,28 +581,32 @@ class ComponentBinaryReaderDelegate {
 
   virtual Result BeginCoreInstanceSection(uint32_t count) = 0;
   virtual Result EndCoreInstanceSection() = 0;
-  virtual Result OnCoreInstance(const ComponentIndexLoc& module_index,
-                                uint32_t argument_count) = 0;
+  virtual Result BeginCoreInstance(const ComponentIndexLoc& module_index,
+                                   uint32_t argument_count) = 0;
   virtual Result OnCoreInstanceArg(const ComponentStringLoc& name,
                                    ComponentSort sort,
                                    const ComponentIndexLoc& index) = 0;
-  virtual Result OnInlineCoreInstance(uint32_t argument_count) = 0;
+  virtual Result EndCoreInstance() = 0;
+  virtual Result BeginInlineCoreInstance(uint32_t argument_count) = 0;
   virtual Result OnInlineCoreInstanceArg(const ComponentStringLoc& name,
                                          ComponentSort sort,
                                          const ComponentIndexLoc& index) = 0;
+  virtual Result EndInlineCoreInstance() = 0;
 
   virtual Result BeginInstanceSection(uint32_t count) = 0;
   virtual Result EndInstanceSection() = 0;
-  virtual Result OnInstance(const ComponentIndexLoc& component_index,
-                            uint32_t argument_count) = 0;
+  virtual Result BeginInstance(const ComponentIndexLoc& component_index,
+                               uint32_t argument_count) = 0;
   virtual Result OnInstanceArg(const ComponentStringLoc& name,
                                ComponentSort sort,
                                const ComponentIndexLoc& index) = 0;
-  virtual Result OnInlineInstance(uint32_t argument_count) = 0;
+  virtual Result EndInstance() = 0;
+  virtual Result BeginInlineInstance(uint32_t argument_count) = 0;
   virtual Result OnInlineInstanceArg(const ComponentStringLoc& name,
                                      nonstd::string_view* version_suffix,
                                      ComponentSort sort,
                                      const ComponentIndexLoc& index) = 0;
+  virtual Result EndInlineInstance() = 0;
 
   virtual Result BeginAliasSection(uint32_t count) = 0;
   virtual Result EndAliasSection() = 0;
@@ -619,21 +623,26 @@ class ComponentBinaryReaderDelegate {
   virtual Result BeginTypeSection(uint32_t count) = 0;
   virtual Result EndTypeSection() = 0;
   virtual Result OnPrimitiveType(const ComponentType& type) = 0;
-  virtual Result OnRecordType(uint32_t field_count) = 0;
+  virtual Result BeginRecordType(uint32_t field_count) = 0;
   virtual Result OnRecordField(const ComponentStringLoc& field_name,
                                const ComponentTypeLoc& field_type) = 0;
-  virtual Result OnVariantType(uint32_t case_count) = 0;
+  virtual Result EndRecordType() = 0;
+  virtual Result BeginVariantType(uint32_t case_count) = 0;
   virtual Result OnVariantCase(const ComponentStringLoc& case_name,
                                const ComponentTypeLoc& case_type) = 0;
+  virtual Result EndVariantType() = 0;
   virtual Result OnListType(const ComponentTypeLoc& type) = 0;
   virtual Result OnListFixedType(const ComponentTypeLoc& type,
                                  uint32_t size) = 0;
-  virtual Result OnTupleType(uint32_t item_count) = 0;
+  virtual Result BeginTupleType(uint32_t item_count) = 0;
   virtual Result OnTupleItem(const ComponentTypeLoc& item) = 0;
-  virtual Result OnFlagsType(uint32_t label_count) = 0;
+  virtual Result EndTupleType() = 0;
+  virtual Result BeginFlagsType(uint32_t label_count) = 0;
   virtual Result OnFlagsLabel(const ComponentStringLoc& label) = 0;
-  virtual Result OnEnumType(uint32_t label_count) = 0;
+  virtual Result EndFlagsType() = 0;
+  virtual Result BeginEnumType(uint32_t label_count) = 0;
   virtual Result OnEnumLabel(const ComponentStringLoc& label) = 0;
+  virtual Result EndEnumType() = 0;
   virtual Result OnOptionType(const ComponentTypeLoc& type) = 0;
   virtual Result OnResultType(const ComponentTypeLoc& result_type,
                               const ComponentTypeLoc& error_type) = 0;
@@ -641,11 +650,12 @@ class ComponentBinaryReaderDelegate {
   virtual Result OnBorrowType(const ComponentIndexLoc& index) = 0;
   virtual Result OnStreamType(const ComponentTypeLoc& type) = 0;
   virtual Result OnFutureType(const ComponentTypeLoc& type) = 0;
-  virtual Result OnFuncType(ComponentTypeDef type,
-                            uint32_t param_count) = 0;
-  virtual Result OnFuncParam(ComponentStringLoc name,
-                             ComponentTypeLoc type) = 0;
+  virtual Result BeginFuncType(ComponentTypeDef type,
+                               uint32_t param_count) = 0;
+  virtual Result OnFuncParam(const ComponentStringLoc& name,
+                             const ComponentTypeLoc& type) = 0;
   virtual Result OnFuncResult(const ComponentTypeLoc& type) = 0;
+  virtual Result EndFuncType() = 0;
   virtual Result OnResourceType(ComponentResourceRep rep,
                                 const ComponentIndexLoc& dtor) = 0;
   virtual Result OnResourceAsyncType(ComponentResourceRep rep,
diff --git a/third_party/wabt/include/wabt/shared-validator.h b/third_party/wabt/include/wabt/shared-validator.h
index 89ad69732..812120af3 100644
--- a/third_party/wabt/include/wabt/shared-validator.h
+++ b/third_party/wabt/include/wabt/shared-validator.h
@@ -444,10 +444,9 @@ class SharedComponentValidator {
   Result OnInstanceArg(const ComponentStringLoc& name,
                        ComponentSort sort,
                        const ComponentIndexLoc& index);
-  Result OnInlineInstance();
+  Result OnInlineInstance(uint32_t argument_count);
   Result OnInlineInstanceArg(const ComponentStringLoc& name,
-                             bool has_version_suffix,
-                             nonstd::string_view version_suffix,
+                             nonstd::string_view* version_suffix,
                              ComponentSort sort,
                              const ComponentIndexLoc& index);
 
@@ -490,8 +489,8 @@ class SharedComponentValidator {
   Result OnFutureType(const ComponentTypeLoc& type);
   Result OnFuncType(ComponentTypeDef type,
                     uint32_t param_count);
-  Result OnFuncParam(ComponentStringLoc name,
-                     ComponentTypeLoc type);
+  Result OnFuncParam(const ComponentStringLoc& name,
+                     const ComponentTypeLoc& type);
   Result OnFuncResult(const ComponentTypeLoc& type);
   Result OnResourceType(const Location& loc,
                         ComponentResourceRep rep,
@@ -780,6 +779,7 @@ class SharedComponentValidator {
 
     // Sorts.
     TypeBaseVector types;
+    TypeBaseVector instances;
   };
 
   struct Component : public TypeDefList {
@@ -792,7 +792,6 @@ class SharedComponentValidator {
     TypeBaseVector core_modules;
     TypeBaseVector funcs;
     TypeBaseVector components;
-    TypeBaseVector instances;
   };
 
   struct CoreModule : public TypeBase {
diff --git a/third_party/wabt/include/wabt/walrus/binary-reader-walrus.h b/third_party/wabt/include/wabt/walrus/binary-reader-walrus.h
index 716334129..f0e6200e1 100644
--- a/third_party/wabt/include/wabt/walrus/binary-reader-walrus.h
+++ b/third_party/wabt/include/wabt/walrus/binary-reader-walrus.h
@@ -239,11 +239,129 @@ class WASMBinaryReaderDelegate {
     size_t m_skipValidationUntil;
 };
 
+class WASMComponentBinaryReaderDelegate {
+public:
+    virtual ~WASMComponentBinaryReaderDelegate() {}
+
+    virtual void OnCoreModule(const void* data,
+                              size_t size,
+                              const ReadBinaryOptions& options) = 0;
+    virtual void BeginComponent(uint32_t version, size_t depth) = 0;
+    virtual void EndComponent() = 0;
+
+    virtual void BeginCoreInstance(Index module_index,
+                                   uint32_t argument_count) = 0;
+    virtual void OnCoreInstanceArg(const ComponentStringLoc& name,
+                                   ComponentSort sort,
+                                   Index index) = 0;
+    virtual void EndCoreInstance() = 0;
+    virtual void BeginInlineCoreInstance(uint32_t argument_count) = 0;
+    virtual void OnInlineCoreInstanceArg(const ComponentStringLoc& name,
+                                         ComponentSort sort,
+                                         Index index) = 0;
+    virtual void EndInlineCoreInstance() = 0;
+
+    virtual void BeginInstance(Index component_index,
+                               uint32_t argument_count) = 0;
+    virtual void OnInstanceArg(const ComponentStringLoc& name,
+                               ComponentSort sort,
+                               Index index) = 0;
+    virtual void EndInstance() = 0;
+    virtual void BeginInlineInstance(uint32_t argument_count) = 0;
+    virtual void OnInlineInstanceArg(const ComponentStringLoc& name,
+                                     nonstd::string_view* version_suffix,
+                                     ComponentSort sort,
+                                     Index index) = 0;
+    virtual void EndInlineInstance() = 0;
+
+    virtual void OnAliasExport(ComponentSort sort,
+                               Index instance_index,
+                               const ComponentStringLoc& name) = 0;
+    virtual void OnAliasCoreExport(ComponentSort sort,
+                                   Index core_instance_index,
+                                   const ComponentStringLoc& name) = 0;
+    virtual void OnAliasOuter(ComponentSort sort,
+                              uint32_t counter,
+                              uint32_t index) = 0;
+
+    virtual void OnPrimitiveType(const ComponentType& type) = 0;
+    virtual void BeginRecordType(uint32_t field_count) = 0;
+    virtual void OnRecordField(const ComponentStringLoc& field_name,
+                               const ComponentType& field_type) = 0;
+    virtual void EndRecordType() = 0;
+    virtual void BeginVariantType(uint32_t case_count) = 0;
+    virtual void OnVariantCase(const ComponentStringLoc& case_name,
+                               const ComponentType& case_type) = 0;
+    virtual void EndVariantType() = 0;
+    virtual void OnListType(const ComponentType& type) = 0;
+    virtual void OnListFixedType(const ComponentType& type,
+                                 uint32_t size) = 0;
+    virtual void BeginTupleType(uint32_t item_count) = 0;
+    virtual void OnTupleItem(const ComponentType& item) = 0;
+    virtual void EndTupleType() = 0;
+    virtual void BeginFlagsType(uint32_t label_count) = 0;
+    virtual void OnFlagsLabel(const ComponentStringLoc& label) = 0;
+    virtual void EndFlagsType() = 0;
+    virtual void BeginEnumType(uint32_t label_count) = 0;
+    virtual void OnEnumLabel(const ComponentStringLoc& label) = 0;
+    virtual void EndEnumType() = 0;
+    virtual void OnOptionType(const ComponentType& type) = 0;
+    virtual void OnResultType(const ComponentType& result_type,
+                              const ComponentType& error_type) = 0;
+    virtual void OnOwnType(Index index) = 0;
+    virtual void OnBorrowType(Index index) = 0;
+    virtual void OnStreamType(const ComponentType& type) = 0;
+    virtual void OnFutureType(const ComponentType& type) = 0;
+    virtual void BeginFuncType(ComponentTypeDef type,
+                               uint32_t param_count) = 0;
+    virtual void OnFuncParam(ComponentStringLoc name,
+                             const ComponentType& type) = 0;
+    virtual void OnFuncResult(const ComponentType& type) = 0;
+    virtual void EndFuncType() = 0;
+    virtual void OnResourceType(ComponentResourceRep rep,
+                                Index dtor) = 0;
+    virtual void OnResourceAsyncType(ComponentResourceRep rep,
+                                     Index dtor,
+                                     Index callback) = 0;
+    virtual void BeginInstanceType(uint32_t count) = 0;
+    virtual void EndInstanceType() = 0;
+    virtual void BeginComponentType(uint32_t count) = 0;
+    virtual void EndComponentType() = 0;
+
+    virtual void OnCanonLift(Index core_func_index,
+                             uint32_t option_count,
+                             ComponentCanonOption* options,
+                             Index type_index) = 0;
+    virtual void OnCanonLower(Index func_index,
+                              uint32_t option_count,
+                              ComponentCanonOption* options) = 0;
+    virtual void OnCanonType(ComponentCanon canon,
+                             Index type_index) = 0;
+
+    virtual void OnImport(const ComponentStringLoc& name,
+                          nonstd::string_view* version_suffix,
+                          const ComponentExternalInfo& external_info) = 0;
+
+    virtual void OnExport(const ComponentStringLoc& name,
+                          nonstd::string_view* version_suffix,
+                          ComponentExternalInfo* external_info,
+                          ComponentExportInfo* export_info) = 0;
+
+    const std::string& WalrusParseError()
+    {
+        return m_walrusParseError;
+    }
+
+protected:
+    std::string m_walrusParseError;
+};
+
 enum FeatureFlagValue : uint32_t {
     enableWebAssembly3 = 1 << 0,
 };
 
 std::string ReadWasmBinary(const std::string& filename, const uint8_t *data, size_t size, WASMBinaryReaderDelegate* delegate, const uint32_t featureFlags);
+std::string ReadWasmComponentBinary(const std::string& filename, const uint8_t *data, size_t size, WASMComponentBinaryReaderDelegate* delegate, const uint32_t featureFlags);
 
 }  // namespace wabt
 
diff --git a/third_party/wabt/include/wabt/wast-lexer.h b/third_party/wabt/include/wabt/wast-lexer.h
index ef82aec1a..1399ce18d 100644
--- a/third_party/wabt/include/wabt/wast-lexer.h
+++ b/third_party/wabt/include/wabt/wast-lexer.h
@@ -48,6 +48,7 @@ class WastLexer {
                                                       Errors*);
 
   Token GetToken();
+  bool IsComponent();
 
   nonstd::string_view Filename() const { return filename_; }
 
diff --git a/third_party/wabt/include/wabt/wast-parser.h b/third_party/wabt/include/wabt/wast-parser.h
index 6489fb046..a269e114a 100644
--- a/third_party/wabt/include/wabt/wast-parser.h
+++ b/third_party/wabt/include/wabt/wast-parser.h
@@ -50,7 +50,6 @@ class WastParser {
   Result ParseModule(std::unique_ptr<Module>* out_module);
   Result ParseScript(std::unique_ptr<Script>* out_script);
   Result ParseComponent(std::unique_ptr<Component>* out_component);
-  bool IsComponent();
 
   std::unique_ptr<Script> ReleaseScript();
 
@@ -437,11 +436,8 @@ Result ParseWastScript(WastLexer* lexer,
                        Errors*,
                        WastParseOptions* options);
 
-// The out_module is optional. If it is non null, and the input does not
-// starts with "(component", the parsing falls back to module parsing.
 Result ParseWatComponent(WastLexer* lexer,
                          std::unique_ptr<Component>* out_component,
-                         std::unique_ptr<Module>* out_module,
                          Errors*,
                          WastParseOptions* options);
 
diff --git a/third_party/wabt/src/binary-reader-ir.cc b/third_party/wabt/src/binary-reader-ir.cc
index 0254f1ae9..b92a42cfe 100644
--- a/third_party/wabt/src/binary-reader-ir.cc
+++ b/third_party/wabt/src/binary-reader-ir.cc
@@ -2062,28 +2062,32 @@ class BinaryReaderComponentIR : public ComponentBinaryReaderDelegate {
 
   Result BeginCoreInstanceSection(uint32_t count) override;
   Result EndCoreInstanceSection() override;
-  Result OnCoreInstance(const ComponentIndexLoc& module_index,
-                        uint32_t argument_count) override;
+  Result BeginCoreInstance(const ComponentIndexLoc& module_index,
+                           uint32_t argument_count) override;
   Result OnCoreInstanceArg(const ComponentStringLoc& name,
                            ComponentSort sort,
                            const ComponentIndexLoc& index) override;
-  Result OnInlineCoreInstance(uint32_t argument_count) override;
+  Result EndCoreInstance() override;
+  Result BeginInlineCoreInstance(uint32_t argument_count) override;
   Result OnInlineCoreInstanceArg(const ComponentStringLoc& name,
                                  ComponentSort sort,
                                  const ComponentIndexLoc& index) override;
+  Result EndInlineCoreInstance() override;
 
   Result BeginInstanceSection(uint32_t count) override;
   Result EndInstanceSection() override;
-  Result OnInstance(const ComponentIndexLoc& component_index,
-                    uint32_t argument_count) override;
+  Result BeginInstance(const ComponentIndexLoc& component_index,
+                       uint32_t argument_count) override;
   Result OnInstanceArg(const ComponentStringLoc& name,
                        ComponentSort sort,
                        const ComponentIndexLoc& index) override;
-  Result OnInlineInstance(uint32_t argument_count) override;
+  Result EndInstance() override;
+  Result BeginInlineInstance(uint32_t argument_count) override;
   Result OnInlineInstanceArg(const ComponentStringLoc& name,
                              nonstd::string_view* version_suffix,
                              ComponentSort sort,
                              const ComponentIndexLoc& index) override;
+  Result EndInlineInstance() override;
 
   Result BeginAliasSection(uint32_t count) override;
   Result EndAliasSection() override;
@@ -2100,20 +2104,25 @@ class BinaryReaderComponentIR : public ComponentBinaryReaderDelegate {
   Result BeginTypeSection(uint32_t count) override;
   Result EndTypeSection() override;
   Result OnPrimitiveType(const ComponentType& type) override;
-  Result OnRecordType(uint32_t field_count) override;
+  Result BeginRecordType(uint32_t field_count) override;
   Result OnRecordField(const ComponentStringLoc& field_name,
                        const ComponentTypeLoc& field_type) override;
-  Result OnVariantType(uint32_t case_count) override;
+  Result EndRecordType() override;
+  Result BeginVariantType(uint32_t case_count) override;
   Result OnVariantCase(const ComponentStringLoc& case_name,
                        const ComponentTypeLoc& case_type) override;
+  Result EndVariantType() override;
   Result OnListType(const ComponentTypeLoc& type) override;
   Result OnListFixedType(const ComponentTypeLoc& type, uint32_t size) override;
-  Result OnTupleType(uint32_t type_count) override;
+  Result BeginTupleType(uint32_t type_count) override;
   Result OnTupleItem(const ComponentTypeLoc& item) override;
-  Result OnFlagsType(uint32_t label_count) override;
+  Result EndTupleType() override;
+  Result BeginFlagsType(uint32_t label_count) override;
   Result OnFlagsLabel(const ComponentStringLoc& label) override;
-  Result OnEnumType(uint32_t label_count) override;
+  Result EndFlagsType() override;
+  Result BeginEnumType(uint32_t label_count) override;
   Result OnEnumLabel(const ComponentStringLoc& label) override;
+  Result EndEnumType() override;
   Result OnOptionType(const ComponentTypeLoc& type) override;
   Result OnResultType(const ComponentTypeLoc& result_type,
                       const ComponentTypeLoc& error_type) override;
@@ -2121,9 +2130,11 @@ class BinaryReaderComponentIR : public ComponentBinaryReaderDelegate {
   Result OnBorrowType(const ComponentIndexLoc& index) override;
   Result OnStreamType(const ComponentTypeLoc& type) override;
   Result OnFutureType(const ComponentTypeLoc& type) override;
-  Result OnFuncType(ComponentTypeDef type, uint32_t param_count) override;
-  Result OnFuncParam(ComponentStringLoc name, ComponentTypeLoc type) override;
+  Result BeginFuncType(ComponentTypeDef type, uint32_t param_count) override;
+  Result OnFuncParam(const ComponentStringLoc& name,
+                     const ComponentTypeLoc& type) override;
   Result OnFuncResult(const ComponentTypeLoc& type) override;
+  Result EndFuncType() override;
   Result OnResourceType(ComponentResourceRep rep,
                         const ComponentIndexLoc& dtor) override;
   Result OnResourceAsyncType(ComponentResourceRep rep,
@@ -2218,7 +2229,7 @@ Result BinaryReaderComponentIR::EndCoreInstanceSection() {
   return Result::Ok;
 }
 
-Result BinaryReaderComponentIR::OnCoreInstance(
+Result BinaryReaderComponentIR::BeginCoreInstance(
     const ComponentIndexLoc& module_index,
     uint32_t argument_count) {
   auto value_type =
@@ -2236,7 +2247,12 @@ Result BinaryReaderComponentIR::OnCoreInstanceArg(
   return Result::Ok;
 }
 
-Result BinaryReaderComponentIR::OnInlineCoreInstance(uint32_t argument_count) {
+Result BinaryReaderComponentIR::EndCoreInstance() {
+  return Result::Ok;
+}
+
+Result BinaryReaderComponentIR::BeginInlineCoreInstance(
+    uint32_t argument_count) {
   auto instance = MakeUnique<ComponentInstance>(argument_count);
   last_ = instance.get();
   def_list_->Append(std::move(instance));
@@ -2251,6 +2267,10 @@ Result BinaryReaderComponentIR::OnInlineCoreInstanceArg(
   return Result::Ok;
 }
 
+Result BinaryReaderComponentIR::EndInlineCoreInstance() {
+  return Result::Ok;
+}
+
 Result BinaryReaderComponentIR::BeginInstanceSection(uint32_t count) {
   assert(def_list_->IsComponent());
   return Result::Ok;
@@ -2261,7 +2281,7 @@ Result BinaryReaderComponentIR::EndInstanceSection() {
   return Result::Ok;
 }
 
-Result BinaryReaderComponentIR::OnInstance(
+Result BinaryReaderComponentIR::BeginInstance(
     const ComponentIndexLoc& component_index,
     uint32_t argument_count) {
   auto instance = MakeUnique<ComponentInstance>(false, component_index,
@@ -2278,7 +2298,11 @@ Result BinaryReaderComponentIR::OnInstanceArg(const ComponentStringLoc& name,
   return Result::Ok;
 }
 
-Result BinaryReaderComponentIR::OnInlineInstance(uint32_t argument_count) {
+Result BinaryReaderComponentIR::EndInstance() {
+  return Result::Ok;
+}
+
+Result BinaryReaderComponentIR::BeginInlineInstance(uint32_t argument_count) {
   auto instance = MakeUnique<ComponentInlineInstance>(argument_count);
   last_ = instance.get();
   def_list_->Append(std::move(instance));
@@ -2299,6 +2323,10 @@ Result BinaryReaderComponentIR::OnInlineInstanceArg(
   return Result::Ok;
 }
 
+Result BinaryReaderComponentIR::EndInlineInstance() {
+  return Result::Ok;
+}
+
 Result BinaryReaderComponentIR::BeginAliasSection(uint32_t count) {
   assert(def_list_->IsComponent());
   return Result::Ok;
@@ -2384,7 +2412,7 @@ Result BinaryReaderComponentIR::OnPrimitiveType(const ComponentType& type) {
   return Result::Ok;
 }
 
-Result BinaryReaderComponentIR::OnRecordType(uint32_t field_count) {
+Result BinaryReaderComponentIR::BeginRecordType(uint32_t field_count) {
   auto value_type = MakeUnique<ComponentTypeItems>(
       ComponentTypeDef::Record, GetLocation());
   last_ = value_type.get();
@@ -2399,7 +2427,11 @@ Result BinaryReaderComponentIR::OnRecordField(
   return Result::Ok;
 }
 
-Result BinaryReaderComponentIR::OnVariantType(uint32_t case_count) {
+Result BinaryReaderComponentIR::EndRecordType() {
+  return Result::Ok;
+}
+
+Result BinaryReaderComponentIR::BeginVariantType(uint32_t case_count) {
   auto value_type = MakeUnique<ComponentTypeItems>(
       ComponentTypeDef::Variant, GetLocation());
   last_ = value_type.get();
@@ -2414,6 +2446,10 @@ Result BinaryReaderComponentIR::OnVariantCase(
   return Result::Ok;
 }
 
+Result BinaryReaderComponentIR::EndVariantType() {
+  return Result::Ok;
+}
+
 Result BinaryReaderComponentIR::OnListType(const ComponentTypeLoc& type) {
   auto value_type =
       MakeUnique<ComponentValueType>(ComponentTypeDef::List, type);
@@ -2429,7 +2465,7 @@ Result BinaryReaderComponentIR::OnListFixedType(const ComponentTypeLoc& type,
   return Result::Ok;
 }
 
-Result BinaryReaderComponentIR::OnTupleType(uint32_t type_count) {
+Result BinaryReaderComponentIR::BeginTupleType(uint32_t type_count) {
   auto value_type = MakeUnique<ComponentTypeTuple>(GetLocation());
   last_ = value_type.get();
   def_list_->AppendType(std::move(value_type));
@@ -2441,7 +2477,11 @@ Result BinaryReaderComponentIR::OnTupleItem(const ComponentTypeLoc& item) {
   return Result::Ok;
 }
 
-Result BinaryReaderComponentIR::OnFlagsType(uint32_t label_count) {
+Result BinaryReaderComponentIR::EndTupleType() {
+  return Result::Ok;
+}
+
+Result BinaryReaderComponentIR::BeginFlagsType(uint32_t label_count) {
   auto value_type = MakeUnique<ComponentTypeLabels>(
       ComponentTypeDef::Flags, GetLocation());
   last_ = value_type.get();
@@ -2454,7 +2494,11 @@ Result BinaryReaderComponentIR::OnFlagsLabel(const ComponentStringLoc& label) {
   return Result::Ok;
 }
 
-Result BinaryReaderComponentIR::OnEnumType(uint32_t enum_count) {
+Result BinaryReaderComponentIR::EndFlagsType() {
+  return Result::Ok;
+}
+
+Result BinaryReaderComponentIR::BeginEnumType(uint32_t enum_count) {
   auto value_type = MakeUnique<ComponentTypeLabels>(
       ComponentTypeDef::Enum, GetLocation());
   last_ = value_type.get();
@@ -2467,6 +2511,10 @@ Result BinaryReaderComponentIR::OnEnumLabel(const ComponentStringLoc& label) {
   return Result::Ok;
 }
 
+Result BinaryReaderComponentIR::EndEnumType() {
+  return Result::Ok;
+}
+
 Result BinaryReaderComponentIR::OnOptionType(const ComponentTypeLoc& type) {
   auto value_type =
       MakeUnique<ComponentValueType>(ComponentTypeDef::Option, type);
@@ -2511,16 +2559,16 @@ Result BinaryReaderComponentIR::OnFutureType(const ComponentTypeLoc& type) {
   return Result::Ok;
 }
 
-Result BinaryReaderComponentIR::OnFuncType(ComponentTypeDef type,
-                                           uint32_t param_count) {
+Result BinaryReaderComponentIR::BeginFuncType(ComponentTypeDef type,
+                                              uint32_t param_count) {
   auto value_type = MakeUnique<ComponentTypeFunc>(type);
   last_ = value_type.get();
   def_list_->AppendType(std::move(value_type));
   return Result::Ok;
 }
 
-Result BinaryReaderComponentIR::OnFuncParam(ComponentStringLoc name,
-                                            ComponentTypeLoc type) {
+Result BinaryReaderComponentIR::OnFuncParam(const ComponentStringLoc& name,
+                                            const ComponentTypeLoc& type) {
   last_->AsTypeFunc()->AppendParam(string_table_.Append(name), type);
   return Result::Ok;
 }
@@ -2530,6 +2578,10 @@ Result BinaryReaderComponentIR::OnFuncResult(const ComponentTypeLoc& type) {
   return Result::Ok;
 }
 
+Result BinaryReaderComponentIR::EndFuncType() {
+  return Result::Ok;
+}
+
 Result BinaryReaderComponentIR::BeginInstanceType(uint32_t count) {
   auto type = MakeUnique<ComponentInterfaceType>(
       def_list_, ComponentTypeDef::Instance);
diff --git a/third_party/wabt/src/binary-reader.cc b/third_party/wabt/src/binary-reader.cc
index 8504ade25..ea82f5b94 100644
--- a/third_party/wabt/src/binary-reader.cc
+++ b/third_party/wabt/src/binary-reader.cc
@@ -3673,9 +3673,9 @@ Result BinaryReader::ReadComponentCoreInstance() {
   CHECK_RESULT(ReadU32Leb128(&argument_count, "counter"));
 
   if (is_inline) {
-    COMPONENT_CALLBACK(OnInlineCoreInstance, argument_count);
+    COMPONENT_CALLBACK(BeginInlineCoreInstance, argument_count);
   } else {
-    COMPONENT_CALLBACK(OnCoreInstance, from_index, argument_count);
+    COMPONENT_CALLBACK(BeginCoreInstance, from_index, argument_count);
   }
 
   for (uint32_t i = 0; i < argument_count; i++) {
@@ -3702,6 +3702,12 @@ Result BinaryReader::ReadComponentCoreInstance() {
     }
   }
 
+  if (is_inline) {
+    COMPONENT_CALLBACK0(EndInlineCoreInstance);
+  } else {
+    COMPONENT_CALLBACK0(EndCoreInstance);
+  }
+
   return Result::Ok;
 }
 
@@ -3723,7 +3729,7 @@ Result BinaryReader::ReadComponentInstance() {
   uint32_t argument_count;
   CHECK_RESULT(ReadComponentIndex(&from_index, "component index"));
   CHECK_RESULT(ReadU32Leb128(&argument_count, "counter"));
-  COMPONENT_CALLBACK(OnInstance, from_index, argument_count);
+  COMPONENT_CALLBACK(BeginInstance, from_index, argument_count);
 
   for (uint32_t i = 0; i < argument_count; i++) {
     ComponentStringLoc name;
@@ -3736,13 +3742,14 @@ Result BinaryReader::ReadComponentInstance() {
     COMPONENT_CALLBACK(OnInstanceArg, name, sort, index);
   }
 
+  COMPONENT_CALLBACK0(EndInstance);
   return Result::Ok;
 }
 
 Result BinaryReader::ReadComponentInlineInstance() {
   uint32_t argument_count;
   CHECK_RESULT(ReadU32Leb128(&argument_count, "counter"));
-  COMPONENT_CALLBACK(OnInlineInstance, argument_count);
+  COMPONENT_CALLBACK(BeginInlineInstance, argument_count);
 
   for (uint32_t i = 0; i < argument_count; i++) {
     ComponentStringLoc name;
@@ -3773,6 +3780,7 @@ Result BinaryReader::ReadComponentInlineInstance() {
     CHECK_RESULT(ReadComponentIndex(&index, "index"));
     COMPONENT_CALLBACK(OnInlineInstanceArg, name, version_suffix, sort, index);
   }
+  COMPONENT_CALLBACK0(EndInlineInstance);
   return Result::Ok;
 }
 
@@ -3874,7 +3882,7 @@ Result BinaryReader::ReadComponentType() {
         case ComponentTypeDef::Record: {
           uint32_t field_count;
           CHECK_RESULT(ReadU32Leb128(&field_count, "field count"));
-          COMPONENT_CALLBACK(OnRecordType, field_count);
+          COMPONENT_CALLBACK(BeginRecordType, field_count);
 
           for (uint32_t i = 0; i < field_count; i++) {
             ComponentStringLoc name;
@@ -3883,12 +3891,13 @@ Result BinaryReader::ReadComponentType() {
             CHECK_RESULT(ReadComponentValType(&type));
             COMPONENT_CALLBACK(OnRecordField, name, type);
           }
+          COMPONENT_CALLBACK0(EndRecordType);
           break;
         }
         case ComponentTypeDef::Variant: {
           uint32_t case_count;
           CHECK_RESULT(ReadU32Leb128(&case_count, "case count"));
-          COMPONENT_CALLBACK(OnVariantType, case_count);
+          COMPONENT_CALLBACK(BeginVariantType, case_count);
 
           for (uint32_t i = 0; i < case_count; i++) {
             ComponentStringLoc name;
@@ -3900,6 +3909,7 @@ Result BinaryReader::ReadComponentType() {
             ERROR_UNLESS(unused == 0, "only zero value is supported");
             COMPONENT_CALLBACK(OnVariantCase, name, type);
           }
+          COMPONENT_CALLBACK0(EndVariantType);
           break;
         }
         case ComponentTypeDef::List:
@@ -3918,13 +3928,14 @@ Result BinaryReader::ReadComponentType() {
         case ComponentTypeDef::Tuple: {
           uint32_t type_count;
           CHECK_RESULT(ReadU32Leb128(&type_count, "type count"));
-          COMPONENT_CALLBACK(OnTupleType, type_count);
+          COMPONENT_CALLBACK(BeginTupleType, type_count);
 
           for (uint32_t i = 0; i < type_count; i++) {
             ComponentTypeLoc item;
             CHECK_RESULT(ReadComponentValType(&item));
             COMPONENT_CALLBACK(OnTupleItem, item);
           }
+          COMPONENT_CALLBACK0(EndTupleType);
           break;
         }
         case ComponentTypeDef::Flags:
@@ -3932,9 +3943,9 @@ Result BinaryReader::ReadComponentType() {
           uint32_t label_count;
           CHECK_RESULT(ReadU32Leb128(&label_count, "name count"));
           if (def_type == ComponentTypeDef::Flags) {
-            COMPONENT_CALLBACK(OnFlagsType, label_count);
+            COMPONENT_CALLBACK(BeginFlagsType, label_count);
           } else {
-            COMPONENT_CALLBACK(OnEnumType, label_count);
+            COMPONENT_CALLBACK(BeginEnumType, label_count);
           }
 
           for (uint32_t i = 0; i < label_count; i++) {
@@ -3947,6 +3958,12 @@ Result BinaryReader::ReadComponentType() {
               COMPONENT_CALLBACK(OnEnumLabel, label);
             }
           }
+
+          if (def_type == ComponentTypeDef::Flags) {
+            COMPONENT_CALLBACK0(EndFlagsType);
+          } else {
+            COMPONENT_CALLBACK0(EndEnumType);
+          }
           break;
         }
         case ComponentTypeDef::Option: {
@@ -3991,7 +4008,7 @@ Result BinaryReader::ReadComponentType() {
           uint32_t param_count;
           CHECK_RESULT(ReadU32Leb128(&param_count, "param count"));
 
-          COMPONENT_CALLBACK(OnFuncType, def_type, param_count);
+          COMPONENT_CALLBACK(BeginFuncType, def_type, param_count);
 
           for (uint32_t i = 0; i < param_count; i++) {
             ComponentStringLoc name;
@@ -4020,6 +4037,7 @@ Result BinaryReader::ReadComponentType() {
           }
 
           COMPONENT_CALLBACK(OnFuncResult, result);
+          COMPONENT_CALLBACK(EndFuncType);
           break;
         }
         case ComponentTypeDef::Instance:
diff --git a/third_party/wabt/src/binary-writer.cc b/third_party/wabt/src/binary-writer.cc
index ac5cd3dbd..f8160e057 100644
--- a/third_party/wabt/src/binary-writer.cc
+++ b/third_party/wabt/src/binary-writer.cc
@@ -2310,7 +2310,7 @@ void BinaryWriter::WriteComponentValueType(const ComponentType& type,
   }
 
   if (type.IsIndex()) {
-    WriteU32Leb128(stream_, type.GetIndex(), "type index");
+    WriteS64Leb128(stream_, type.GetIndex(), "type index");
   } else {
     stream_->WriteU8Enum(type.GetType(), "primitive type");
   }
diff --git a/third_party/wabt/src/shared-validator.cc b/third_party/wabt/src/shared-validator.cc
index 6e8db9525..8dec27eb7 100644
--- a/third_party/wabt/src/shared-validator.cc
+++ b/third_party/wabt/src/shared-validator.cc
@@ -2087,7 +2087,7 @@ Result SharedComponentValidator::OnInstanceArg(const ComponentStringLoc& name,
   return Result::Ok;
 }
 
-Result SharedComponentValidator::OnInlineInstance() {
+Result SharedComponentValidator::OnInlineInstance(uint32_t argument_count) {
   auto type_value = MakeUnique<TypeExternalList>(TypeDef::Instance);
   CurrentAsComponent()->instances.push_back(type_value.get());
   objects_.push_back(std::move(type_value));
@@ -2096,8 +2096,7 @@ Result SharedComponentValidator::OnInlineInstance() {
 
 Result SharedComponentValidator::OnInlineInstanceArg(
     const ComponentStringLoc& name,
-    bool has_version_suffix,
-    nonstd::string_view version_suffix,
+    nonstd::string_view* version_suffix,
     ComponentSort sort,
     const ComponentIndexLoc& index) {
   const std::string* export_name = string_table_.Append(name.str);
@@ -2116,9 +2115,10 @@ Result SharedComponentValidator::OnAliasExport(
     ComponentSort sort,
     const ComponentIndexLoc& instance_index,
     const ComponentStringLoc& name) {
-  if (sort != ComponentSort::CoreModule && sort != ComponentSort::Func &&
-      sort != ComponentSort::Value && sort != ComponentSort::Type &&
-      sort != ComponentSort::Component && sort != ComponentSort::Instance) {
+  if (sort != ComponentSort::Type && sort != ComponentSort::Instance &&
+      ((current_->info_bits & IsObject) == 0 ||
+       (sort != ComponentSort::CoreModule && sort != ComponentSort::Func &&
+        sort != ComponentSort::Value && sort != ComponentSort::Component))) {
     return PrintError(loc, "invalid alias export sort (%s)", sort.GetName());
   }
 
@@ -2126,16 +2126,18 @@ Result SharedComponentValidator::OnAliasExport(
   Result result =
       CheckIndex(ComponentSort::Instance, instance_index, &type_base);
 
-  TypeExternalList* instance = type_base->AsTypeExternalList();
-  const std::string* export_name = string_table_.Find(name.str);
   bool found = false;
-  type_base = nullptr;
-  if (export_name != nullptr) {
-    for (auto& item : instance->exports) {
-      if (item.name == export_name) {
-        found = true;
-        type_base = item.type_base;
-        break;
+  if (type_base != nullptr) {
+    TypeExternalList* instance = type_base->AsTypeExternalList();
+    const std::string* export_name = string_table_.Find(name.str);
+    type_base = nullptr;
+    if (export_name != nullptr) {
+      for (auto& item : instance->exports) {
+        if (item.name == export_name) {
+          found = true;
+          type_base = item.type_base;
+          break;
+        }
       }
     }
   }
@@ -2454,8 +2456,8 @@ Result SharedComponentValidator::OnFuncType(ComponentTypeDef type,
   return Result::Ok;
 }
 
-Result SharedComponentValidator::OnFuncParam(ComponentStringLoc name,
-                                             ComponentTypeLoc type) {
+Result SharedComponentValidator::OnFuncParam(const ComponentStringLoc& name,
+                                             const ComponentTypeLoc& type) {
   TypeRef type_ref;
   Result result = CheckType(type, ExcludeLast, &type_ref);
   TypeFunc::Param param{string_table_.Append(name.str), type_ref};
@@ -2635,6 +2637,10 @@ SharedComponentValidator::TypeBaseVector* SharedComponentValidator::GetSort(
     return &def_list->types;
   }
 
+  if (sort == ComponentSort::Instance) {
+    return &def_list->instances;
+  }
+
   if ((def_list->info_bits & IsObject) == 0) {
     return nullptr;
   }
@@ -2652,8 +2658,6 @@ SharedComponentValidator::TypeBaseVector* SharedComponentValidator::GetSort(
       return &component->funcs;
     case ComponentSort::Component:
       return &component->components;
-    case ComponentSort::Instance:
-      return &component->instances;
     default:
       // TODO: implement more checks.
       return nullptr;
diff --git a/third_party/wabt/src/walrus/binary-reader-walrus.cc b/third_party/wabt/src/walrus/binary-reader-walrus.cc
index 5f0a9651e..aee6b0f88 100644
--- a/third_party/wabt/src/walrus/binary-reader-walrus.cc
+++ b/third_party/wabt/src/walrus/binary-reader-walrus.cc
@@ -1615,4 +1615,480 @@ std::string ReadWasmBinary(const std::string &filename, const uint8_t *data, siz
     return std::string();
 }
 
+#undef CHECK_RESULT
+#define CHECK_RESULT(expr)                                           \
+  do {                                                               \
+    if (WABT_UNLIKELY(Failed(expr))) {                               \
+      return ::wabt::Result::Error;                                  \
+    }                                                                \
+  } while (0)
+
+class ComponentBinaryReaderDelegateWalrus: public ComponentBinaryReaderDelegate {
+public:
+    ComponentBinaryReaderDelegateWalrus(WASMComponentBinaryReaderDelegate *delegate, const std::string &filename, const uint32_t featureFlags) :
+        m_externalDelegate(delegate), m_validator(&m_errors, filename, ValidateOptions(getFeatures(featureFlags))) {
+    }
+
+    Location GetLocation() const {
+        Location loc;
+        loc.offset = state->offset;
+        return loc;
+    }
+
+    bool OnError(const Error& err) override {
+        m_errors.push_back(err);
+        return true;
+    }
+
+    Result OnCoreModule(const void* data,
+                        size_t size,
+                        const ReadBinaryOptions& options) override {
+        CHECK_RESULT(m_validator.OnCoreModule());
+        m_externalDelegate->OnCoreModule(data, size, options);
+        return Result::Ok;
+    }
+
+    Result BeginComponent(uint32_t version, size_t depth) override {
+        CHECK_RESULT(m_validator.BeginComponent());
+        m_externalDelegate->BeginComponent(version, depth);
+        return Result::Ok;
+    }
+
+    Result EndComponent() override {
+        CHECK_RESULT(m_validator.EndComponent());
+        m_externalDelegate->EndComponent();
+        return Result::Ok;
+    }
+
+    Result BeginCoreInstanceSection(uint32_t count) override {
+        return Result::Ok;
+    }
+
+    Result EndCoreInstanceSection() override {
+        return Result::Ok;
+    }
+
+    Result BeginCoreInstance(const ComponentIndexLoc& module_index,
+                             uint32_t argument_count) override {
+        CHECK_RESULT(m_validator.OnCoreInstance(module_index, argument_count));
+        m_externalDelegate->BeginCoreInstance(module_index.index, argument_count);
+        return Result::Ok;
+    }
+
+    Result OnCoreInstanceArg(const ComponentStringLoc& name,
+                             ComponentSort sort,
+                             const ComponentIndexLoc& index) override {
+        CHECK_RESULT(m_validator.OnCoreInstanceArg(name, sort, index));
+        m_externalDelegate->OnCoreInstanceArg(name, sort, index.index);
+        return Result::Ok;
+    }
+
+    Result EndCoreInstance() override {
+        m_externalDelegate->EndCoreInstance();
+        return Result::Ok;
+    }
+
+    Result BeginInlineCoreInstance(uint32_t argument_count) override {
+        CHECK_RESULT(m_validator.OnInlineCoreInstance(argument_count));
+        m_externalDelegate->BeginInlineCoreInstance(argument_count);
+        return Result::Ok;
+    }
+
+    Result OnInlineCoreInstanceArg(const ComponentStringLoc& name,
+                                   ComponentSort sort,
+                                   const ComponentIndexLoc& index) override {
+        CHECK_RESULT(m_validator.OnInlineCoreInstanceArg(name, sort, index));
+        m_externalDelegate->OnInlineCoreInstanceArg(name, sort, index.index);
+        return Result::Ok;
+    }
+
+    Result EndInlineCoreInstance() override {
+        m_externalDelegate->EndInlineCoreInstance();
+        return Result::Ok;
+    }
+
+    Result BeginInstanceSection(uint32_t count) override {
+        return Result::Ok;
+    }
+
+    Result EndInstanceSection() override {
+        return Result::Ok;
+    }
+
+    Result BeginInstance(const ComponentIndexLoc& component_index,
+                         uint32_t argument_count) override {
+        CHECK_RESULT(m_validator.OnInstance(component_index, argument_count));
+        m_externalDelegate->BeginInstance(component_index.index, argument_count);
+        return Result::Ok;
+    }
+
+    Result OnInstanceArg(const ComponentStringLoc& name,
+                         ComponentSort sort,
+                         const ComponentIndexLoc& index) override {
+        CHECK_RESULT(m_validator.OnInstanceArg(name, sort, index));
+        m_externalDelegate->OnInstanceArg(name, sort, index.index);
+        return Result::Ok;
+    }
+
+    Result EndInstance() override {
+        m_externalDelegate->EndInstance();
+        return Result::Ok;
+    }
+
+    Result BeginInlineInstance(uint32_t argument_count) override {
+        CHECK_RESULT(m_validator.OnInlineInstance(argument_count));
+        m_externalDelegate->BeginInlineInstance(argument_count);
+        return Result::Ok;
+    }
+
+    Result OnInlineInstanceArg(const ComponentStringLoc& name,
+                               nonstd::string_view* version_suffix,
+                               ComponentSort sort,
+                               const ComponentIndexLoc& index) override {
+        CHECK_RESULT(m_validator.OnInlineInstanceArg(name, version_suffix, sort, index));
+        m_externalDelegate->OnInlineInstanceArg(name, version_suffix, sort, index.index);
+        return Result::Ok;
+    }
+
+    Result EndInlineInstance() override {
+        m_externalDelegate->EndInlineInstance();
+        return Result::Ok;
+    }
+
+    Result BeginAliasSection(uint32_t count) override {
+        return Result::Ok;
+    }
+
+    Result EndAliasSection() override {
+        return Result::Ok;
+    }
+
+    Result OnAliasExport(ComponentSort sort,
+                         const ComponentIndexLoc& instance_index,
+                         const ComponentStringLoc& name) override {
+        CHECK_RESULT(m_validator.OnAliasExport(GetLocation(), sort, instance_index, name));
+        m_externalDelegate->OnAliasExport(sort, instance_index.index, name);
+        return Result::Ok;
+    }
+
+    Result OnAliasCoreExport(ComponentSort sort,
+                             const ComponentIndexLoc& core_instance_index,
+                             const ComponentStringLoc& name) override {
+        CHECK_RESULT(m_validator.OnAliasCoreExport(GetLocation(), sort, core_instance_index, name));
+        m_externalDelegate->OnAliasCoreExport(sort, core_instance_index.index, name);
+        return Result::Ok;
+    }
+
+    Result OnAliasOuter(ComponentSort sort,
+                        uint32_t counter,
+                        uint32_t index) override {
+        CHECK_RESULT(m_validator.OnAliasOuter(GetLocation(), sort, counter, index));
+        m_externalDelegate->OnAliasOuter(sort, counter, index);
+        return Result::Ok;
+    }
+
+    Result BeginTypeSection(uint32_t count) override {
+        return Result::Ok;
+    }
+
+    Result EndTypeSection() override {
+        return Result::Ok;
+    }
+
+    Result OnPrimitiveType(const ComponentType& type) override {
+        CHECK_RESULT(m_validator.OnPrimitiveType(type));
+        m_externalDelegate->OnPrimitiveType(type);
+        return Result::Ok;
+    }
+
+    Result BeginRecordType(uint32_t field_count) override {
+        CHECK_RESULT(m_validator.OnRecordType(GetLocation(), field_count));
+        m_externalDelegate->BeginRecordType(field_count);
+        return Result::Ok;
+    }
+
+    Result OnRecordField(const ComponentStringLoc& field_name,
+                         const ComponentTypeLoc& field_type) override {
+        CHECK_RESULT(m_validator.OnRecordField(field_name, field_type));
+        m_externalDelegate->OnRecordField(field_name, field_type.type);
+        return Result::Ok;
+    }
+
+    Result EndRecordType() override {
+        m_externalDelegate->EndRecordType();
+        return Result::Ok;
+    }
+
+    Result BeginVariantType(uint32_t case_count) override {
+        CHECK_RESULT(m_validator.OnVariantType(GetLocation(), case_count));
+        m_externalDelegate->BeginVariantType(case_count);
+        return Result::Ok;
+    }
+
+    Result OnVariantCase(const ComponentStringLoc& case_name,
+                         const ComponentTypeLoc& case_type) override {
+        CHECK_RESULT(m_validator.OnVariantCase(case_name, case_type));
+        m_externalDelegate->OnVariantCase(case_name, case_type.type);
+        return Result::Ok;
+    }
+
+    Result EndVariantType() override {
+        m_externalDelegate->EndVariantType();
+        return Result::Ok;
+    }
+
+    Result OnListType(const ComponentTypeLoc& type) override {
+        CHECK_RESULT(m_validator.OnListType(type));
+        m_externalDelegate->OnListType(type.type);
+        return Result::Ok;
+    }
+
+    Result OnListFixedType(const ComponentTypeLoc& type,
+                           uint32_t size) override {
+        CHECK_RESULT(m_validator.OnListFixedType(GetLocation(), type, size));
+        m_externalDelegate->OnListFixedType(type.type, size);
+        return Result::Ok;
+    }
+
+    Result BeginTupleType(uint32_t item_count) override {
+        CHECK_RESULT(m_validator.OnTupleType(GetLocation(), item_count));
+        m_externalDelegate->BeginTupleType(item_count);
+        return Result::Ok;
+    }
+
+    Result OnTupleItem(const ComponentTypeLoc& item) override {
+        CHECK_RESULT(m_validator.OnTupleItem(item));
+        m_externalDelegate->OnTupleItem(item.type);
+        return Result::Ok;
+    }
+
+    Result EndTupleType() override {
+        m_externalDelegate->EndTupleType();
+        return Result::Ok;
+    }
+
+    Result BeginFlagsType(uint32_t label_count) override {
+        CHECK_RESULT(m_validator.OnFlagsType(GetLocation(), label_count));
+        m_externalDelegate->BeginFlagsType(label_count);
+        return Result::Ok;
+    }
+
+    Result OnFlagsLabel(const ComponentStringLoc& label) override {
+        CHECK_RESULT(m_validator.OnFlagsLabel(label));
+        m_externalDelegate->OnFlagsLabel(label);
+        return Result::Ok;
+    }
+
+    Result EndFlagsType() override {
+        m_externalDelegate->EndFlagsType();
+        return Result::Ok;
+    }
+
+    Result BeginEnumType(uint32_t label_count) override {
+        CHECK_RESULT(m_validator.OnEnumType(GetLocation(), label_count));
+        m_externalDelegate->BeginEnumType(label_count);
+        return Result::Ok;
+    }
+
+    Result OnEnumLabel(const ComponentStringLoc& label) override {
+        CHECK_RESULT(m_validator.OnEnumLabel(label));
+        m_externalDelegate->OnEnumLabel(label);
+        return Result::Ok;
+    }
+
+    Result EndEnumType() override {
+        m_externalDelegate->EndEnumType();
+        return Result::Ok;
+    }
+
+    Result OnOptionType(const ComponentTypeLoc& type) override {
+        CHECK_RESULT(m_validator.OnOptionType(type));
+        m_externalDelegate->OnOptionType(type.type);
+        return Result::Ok;
+    }
+
+    Result OnResultType(const ComponentTypeLoc& result_type,
+                        const ComponentTypeLoc& error_type) override {
+        CHECK_RESULT(m_validator.OnResultType(result_type, error_type));
+        m_externalDelegate->OnResultType(result_type.type, error_type.type);
+        return Result::Ok;
+    }
+
+    Result OnOwnType(const ComponentIndexLoc& index) override {
+        CHECK_RESULT(m_validator.OnOwnType(index));
+        m_externalDelegate->OnOwnType(index.index);
+        return Result::Ok;
+    }
+
+    Result OnBorrowType(const ComponentIndexLoc& index) override {
+        CHECK_RESULT(m_validator.OnBorrowType(index));
+        m_externalDelegate->OnBorrowType(index.index);
+        return Result::Ok;
+    }
+
+    Result OnStreamType(const ComponentTypeLoc& type) override {
+        CHECK_RESULT(m_validator.OnStreamType(type));
+        m_externalDelegate->OnStreamType(type.type);
+        return Result::Ok;
+    }
+
+    Result OnFutureType(const ComponentTypeLoc& type) override {
+        CHECK_RESULT(m_validator.OnFutureType(type));
+        m_externalDelegate->OnFutureType(type.type);
+        return Result::Ok;
+    }
+
+    Result BeginFuncType(ComponentTypeDef type,
+                         uint32_t param_count) override {
+        CHECK_RESULT(m_validator.OnFuncType(type, param_count));
+        m_externalDelegate->BeginFuncType(type, param_count);
+        return Result::Ok;
+    }
+
+    Result OnFuncParam(const ComponentStringLoc& name,
+                       const ComponentTypeLoc& type) override {
+        CHECK_RESULT(m_validator.OnFuncParam(name, type));
+        m_externalDelegate->OnFuncParam(name, type.type);
+        return Result::Ok;
+    }
+
+    Result OnFuncResult(const ComponentTypeLoc& type) override {
+        CHECK_RESULT(m_validator.OnFuncResult(type));
+        m_externalDelegate->OnFuncResult(type.type);
+        return Result::Ok;
+    }
+
+    Result EndFuncType() override {
+        m_externalDelegate->EndFuncType();
+        return Result::Ok;
+    }
+
+    Result OnResourceType(ComponentResourceRep rep,
+                          const ComponentIndexLoc& dtor) override {
+        CHECK_RESULT(m_validator.OnResourceType(GetLocation(), rep, dtor));
+        m_externalDelegate->OnResourceType(rep, dtor.index);
+        return Result::Ok;
+    }
+
+    Result OnResourceAsyncType(ComponentResourceRep rep,
+                               const ComponentIndexLoc& dtor,
+                               const ComponentIndexLoc& callback) override {
+        CHECK_RESULT(m_validator.OnResourceAsyncType(GetLocation(), rep, dtor, callback));
+        m_externalDelegate->OnResourceAsyncType(rep, dtor.index, callback.index);
+        return Result::Ok;
+    }
+
+    Result BeginInstanceType(uint32_t count) override {
+        CHECK_RESULT(m_validator.BeginInstanceType(count));
+        m_externalDelegate->BeginInstanceType(count);
+        return Result::Ok;
+    }
+
+    Result EndInstanceType() override {
+        CHECK_RESULT(m_validator.EndInstanceType());
+        m_externalDelegate->EndInstanceType();
+        return Result::Ok;
+    }
+
+    Result BeginComponentType(uint32_t count) override {
+        CHECK_RESULT(m_validator.BeginComponentType(count));
+        m_externalDelegate->BeginComponentType(count);
+        return Result::Ok;
+    }
+
+    Result EndComponentType() override {
+        CHECK_RESULT(m_validator.EndComponentType());
+        m_externalDelegate->EndComponentType();
+        return Result::Ok;
+    }
+
+    Result BeginCanonSection(uint32_t count) override {
+        return Result::Ok;
+    }
+
+    Result EndCanonSection() override {
+        return Result::Ok;
+    }
+
+    Result OnCanonLift(const ComponentIndexLoc& core_func_index,
+                       uint32_t option_count,
+                       ComponentCanonOption* options,
+                       const ComponentIndexLoc& type_index) override {
+        CHECK_RESULT(m_validator.OnCanonLift(core_func_index, option_count, options, type_index));
+        m_externalDelegate->OnCanonLift(core_func_index.index, option_count, options, type_index.index);
+        return Result::Ok;
+    }
+
+    Result OnCanonLower(const ComponentIndexLoc& func_index,
+                        uint32_t option_count,
+                        ComponentCanonOption* options) override {
+        CHECK_RESULT(m_validator.OnCanonLower(func_index, option_count, options));
+        m_externalDelegate->OnCanonLower(func_index.index, option_count, options);
+        return Result::Ok;
+    }
+
+    Result OnCanonType(ComponentCanon canon,
+                       const ComponentIndexLoc& type_index) override {
+        CHECK_RESULT(m_validator.OnCanonType(canon, type_index));
+        m_externalDelegate->OnCanonType(canon, type_index.index);
+        return Result::Ok;
+    }
+
+    Result BeginImportSection(uint32_t count) override {
+        return Result::Ok;
+    }
+
+    Result EndImportSection() override {
+        return Result::Ok;
+    }
+
+    Result OnImport(const ComponentStringLoc& name,
+                    nonstd::string_view* version_suffix,
+                    const ComponentExternalInfo& external_info) override {
+        CHECK_RESULT(m_validator.OnImport(name, version_suffix, external_info));
+        m_externalDelegate->OnImport(name, version_suffix, external_info);
+        return Result::Ok;
+    }
+
+    Result BeginExportSection(uint32_t count) override {
+        return Result::Ok;
+    }
+
+    Result EndExportSection() override {
+        return Result::Ok;
+    }
+
+    Result OnExport(const ComponentStringLoc& name,
+                    nonstd::string_view* version_suffix,
+                    ComponentExternalInfo* external_info,
+                    ComponentExportInfo* export_info) override {
+        CHECK_RESULT(m_validator.OnExport(name, version_suffix, external_info, export_info));
+        m_externalDelegate->OnExport(name, version_suffix, external_info, export_info);
+        return Result::Ok;
+    }
+
+    WASMComponentBinaryReaderDelegate *m_externalDelegate;
+    Errors m_errors;
+    SharedComponentValidator m_validator;
+};
+
+std::string ReadWasmComponentBinary(const std::string &filename, const uint8_t *data, size_t size, WASMComponentBinaryReaderDelegate *delegate, const uint32_t featureFlags) {
+    const bool kReadDebugNames = false;
+    const bool kStopOnFirstError = true;
+    const bool kFailOnCustomSectionError = true;
+    ReadBinaryOptions options(getFeatures(featureFlags), nullptr, kReadDebugNames, kStopOnFirstError, kFailOnCustomSectionError);
+    ComponentBinaryReaderDelegateWalrus binaryReaderDelegateWalrus(delegate, filename, featureFlags);
+    Result result = ReadBinaryComponent(data, size, &binaryReaderDelegateWalrus, options);
+
+    if (WABT_UNLIKELY(binaryReaderDelegateWalrus.m_errors.size())) {
+        return std::move(binaryReaderDelegateWalrus.m_errors.begin()->message);
+    }
+
+    if (WABT_UNLIKELY(result != ::wabt::Result::Ok)) {
+        return std::string("read wasm error");
+    }
+
+    return std::string();
+}
+
 }  // namespace wabt
diff --git a/third_party/wabt/src/wast-lexer.cc b/third_party/wabt/src/wast-lexer.cc
index e097df9e2..22beba741 100644
--- a/third_party/wabt/src/wast-lexer.cc
+++ b/third_party/wabt/src/wast-lexer.cc
@@ -190,6 +190,32 @@ Token WastLexer::GetToken() {
   }
 }
 
+bool WastLexer::IsComponent() {
+  int line = line_;
+  const char* line_start = line_start_;
+  const char* token_start = token_start_;
+  const char* cursor = cursor_;
+  Errors* errors = errors_;
+
+  Errors discarded_errors;
+  errors_ = &discarded_errors;
+
+  bool result = false;
+
+  Token token = GetToken();
+  if (token.token_type() == TokenType::Lpar) {
+    token = GetToken();
+    result = token.token_type() == TokenType::Component;
+  }
+
+  line_ = line;
+  line_start_ = line_start;
+  token_start_ = token_start;
+  cursor_ = cursor;
+  errors_ = errors;
+  return result;
+}
+
 Location WastLexer::GetLocation() {
   auto column = [this](const char* p) {
     return std::max(1, static_cast<int>(p - line_start_ + 1));
diff --git a/third_party/wabt/src/wast-parser.cc b/third_party/wabt/src/wast-parser.cc
index f68ae50de..16b2fb4f1 100644
--- a/third_party/wabt/src/wast-parser.cc
+++ b/third_party/wabt/src/wast-parser.cc
@@ -1438,10 +1438,6 @@ Result WastParser::ParseComponent(std::unique_ptr<Component>* out_component) {
   }
 }
 
-bool WastParser::IsComponent() {
-  return PeekMatchLpar(TokenType::Component);
-}
-
 Result WastParser::ParseCustomSectionAnnotation(Module* module) {
   WABT_TRACE(ParseCustomSectionAnnotation);
   Location loc = GetLocation();
@@ -4690,6 +4686,9 @@ Result WastParser::ParseComponentDefValType(
     }
 
     switch (Peek(0)) {
+      case TokenType::Bool:
+        type = ComponentType::Bool;
+        break;
       case TokenType::S8:
         type = ComponentType::S8;
         break;
@@ -5978,18 +5977,11 @@ Result ParseWastScript(WastLexer* lexer,
 
 Result ParseWatComponent(WastLexer* lexer,
                          std::unique_ptr<Component>* out_component,
-                         std::unique_ptr<Module>* out_module,
                          Errors* errors,
                          WastParseOptions* options) {
   assert(out_component != nullptr);
   assert(options != nullptr);
   WastParser parser(lexer, errors, options);
-
-  if (out_module != nullptr && !parser.IsComponent()) {
-    CHECK_RESULT(parser.ParseModule(out_module));
-    return Result::Ok;
-  }
-
   CHECK_RESULT(parser.ParseComponent(out_component));
   return Result::Ok;
 }