diff --git a/src/cppbor_parse.cpp b/src/cppbor_parse.cpp
index a221cf4..a9a9b7d 100644
--- a/src/cppbor_parse.cpp
+++ b/src/cppbor_parse.cpp
@@ -16,8 +16,11 @@
 
 #include "cppbor_parse.h"
 
+#include <memory>
 #include <sstream>
 #include <stack>
+#include <type_traits>
+#include "cppbor.h"
 
 #ifndef __TRUSTY__
 #include <android-base/logging.h>
@@ -110,8 +113,11 @@
 
 class IncompleteItem {
   public:
+    static IncompleteItem* cast(Item* item);
+
     virtual ~IncompleteItem() {}
     virtual void add(std::unique_ptr<Item> item) = 0;
+    virtual std::unique_ptr<Item> finalize() && = 0;
 };
 
 class IncompleteArray : public Array, public IncompleteItem {
@@ -126,6 +132,12 @@
         mEntries.push_back(std::move(item));
     }
 
+    virtual std::unique_ptr<Item> finalize() && override {
+        // Use Array explicitly so the compiler picks the correct ctor overload
+        Array* thisArray = this;
+        return std::make_unique<Array>(std::move(*thisArray));
+    }
+
   private:
     size_t mSize;
 };
@@ -146,6 +158,10 @@
         }
     }
 
+    virtual std::unique_ptr<Item> finalize() && override {
+        return std::make_unique<Map>(std::move(*this));
+    }
+
   private:
     std::unique_ptr<Item> mKeyHeldForAdding;
     size_t mSize;
@@ -159,8 +175,36 @@
     size_t size() const override { return 1; }
 
     void add(std::unique_ptr<Item> item) override { mTaggedItem = std::move(item); }
+
+    virtual std::unique_ptr<Item> finalize() && override {
+        return std::make_unique<SemanticTag>(std::move(*this));
+    }
 };
 
+IncompleteItem* IncompleteItem::cast(Item* item) {
+    CHECK(item->isCompound());
+    // Semantic tag must be check first, because SemanticTag::type returns the wrapped item's type.
+    if (item->asSemanticTag()) {
+#if __has_feature(cxx_rtti)
+        CHECK(dynamic_cast<IncompleteSemanticTag*>(item));
+#endif
+        return static_cast<IncompleteSemanticTag*>(item);
+    } else if (item->type() == ARRAY) {
+#if __has_feature(cxx_rtti)
+        CHECK(dynamic_cast<IncompleteArray*>(item));
+#endif
+        return static_cast<IncompleteArray*>(item);
+    } else if (item->type() == MAP) {
+#if __has_feature(cxx_rtti)
+        CHECK(dynamic_cast<IncompleteMap*>(item));
+#endif
+        return static_cast<IncompleteMap*>(item);
+    } else {
+        CHECK(false);  // Impossible to get here.
+    }
+    return nullptr;
+}
+
 std::tuple<const uint8_t*, ParseClient*> handleEntries(size_t entryCount, const uint8_t* hdrBegin,
                                                        const uint8_t* pos, const uint8_t* end,
                                                        const std::string& typeName,
@@ -320,13 +364,15 @@
                                  const uint8_t* end) override {
         CHECK(item->isCompound() && item.get() == mParentStack.top());
         mParentStack.pop();
+        IncompleteItem* incompleteItem = IncompleteItem::cast(item.get());
+        std::unique_ptr<Item> finalizedItem = std::move(*incompleteItem).finalize();
 
         if (mParentStack.empty()) {
-            mTheItem = std::move(item);
+            mTheItem = std::move(finalizedItem);
             mPosition = end;
             return nullptr;  // We're done
         } else {
-            appendToLastParent(std::move(item));
+            appendToLastParent(std::move(finalizedItem));
             return this;
         }
     }
@@ -346,21 +392,7 @@
   private:
     void appendToLastParent(std::unique_ptr<Item> item) {
         auto parent = mParentStack.top();
-#if __has_feature(cxx_rtti)
-        assert(dynamic_cast<IncompleteItem*>(parent));
-#endif
-
-        IncompleteItem* parentItem{};
-        if (parent->type() == ARRAY) {
-            parentItem = static_cast<IncompleteArray*>(parent);
-        } else if (parent->type() == MAP) {
-            parentItem = static_cast<IncompleteMap*>(parent);
-        } else if (parent->asSemanticTag()) {
-            parentItem = static_cast<IncompleteSemanticTag*>(parent);
-        } else {
-            CHECK(false);  // Impossible to get here.
-        }
-        parentItem->add(std::move(item));
+        IncompleteItem::cast(parent)->add(std::move(item));
     }
 
     std::unique_ptr<Item> mTheItem;
diff --git a/tests/cppbor_test.cpp b/tests/cppbor_test.cpp
index b9a2f35..3c4d97f 100644
--- a/tests/cppbor_test.cpp
+++ b/tests/cppbor_test.cpp
@@ -1642,6 +1642,39 @@
     EXPECT_EQ(arr[0]->asTstr()->value(), "hello");
 }
 
+TEST(FullParserTest, MutableOutput) {
+    Array nestedArray("pizza", 31415);
+    Map nestedMap("array", std::move(nestedArray));
+    Array input(std::move(nestedMap));
+
+    auto [updatedItem, ignoredPos, ignoredMessage] = parse(input.encode());
+    updatedItem->asArray()->add(42);
+
+    // add some stuff to the map in our array
+    Map* parsedNestedMap = updatedItem->asArray()->get(0)->asMap();
+    ASSERT_NE(nullptr, parsedNestedMap);
+    parsedNestedMap->add("number", 10);
+    EXPECT_THAT(updatedItem->asArray()->get(0)->asMap()->get("number"), MatchesItem(Uint(10)));
+    parsedNestedMap->add(42, "the answer");
+    EXPECT_THAT(updatedItem->asArray()->get(0)->asMap()->get(42), MatchesItem(Tstr("the answer")));
+
+    // add some stuff to the array in the map that's in our array
+    Array* parsedNestedArray = parsedNestedMap->get("array")->asArray();
+    ASSERT_NE(nullptr, parsedNestedArray);
+    parsedNestedArray->add("pie");
+    EXPECT_THAT(
+        updatedItem->asArray()->get(0)->asMap()->get("array")->asArray()->get(2),
+        MatchesItem(Tstr("pie")));
+
+    // encode the mutated item, then ensure the CBOR is valid
+    const auto encodedUpdatedItem = updatedItem->encode();
+    auto [parsedUpdatedItem, pos, message] = parse(encodedUpdatedItem);
+    EXPECT_EQ("", message);
+    EXPECT_EQ(pos, encodedUpdatedItem.data() + encodedUpdatedItem.size());
+    ASSERT_NE(nullptr, parsedUpdatedItem);
+    EXPECT_THAT(parsedUpdatedItem, MatchesItem(ByRef(*updatedItem)));
+}
+
 TEST(FullParserTest, Map) {
     Map val("hello", -4, 3, Bstr("hi"));
 
@@ -1663,6 +1696,20 @@
     EXPECT_THAT(item, MatchesItem(ByRef(val)));
 }
 
+TEST(FullParserTest, TaggedArray) {
+    SemanticTag val(10, Array().add(42));
+
+    auto [item, pos, message] = parse(val.encode());
+    EXPECT_THAT(item, MatchesItem(ByRef(val)));
+}
+
+TEST(FullParserTest, TaggedMap) {
+    SemanticTag val(100, Map().add("foo", "bar"));
+
+    auto [item, pos, message] = parse(val.encode());
+    EXPECT_THAT(item, MatchesItem(ByRef(val)));
+}
+
 TEST(FullParserTest, Complex) {
     vector<uint8_t> vec = {0x01, 0x02, 0x08, 0x03};
     Map val("Outer1",