diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc
index 139a6d7..93c9a31 100644
--- a/quiche/quic/moqt/moqt_framer.cc
+++ b/quiche/quic/moqt/moqt_framer.cc
@@ -111,33 +111,44 @@
   const KeyValuePairList& list_;
 };
 
-class WireFullTrackName {
+class WireTrackNamespace {
  public:
-  using DataType = FullTrackName;
-
-  // If |includes_name| is true, the last element in the tuple is the track
-  // name and is therefore not counted in the prefix of the namespace tuple.
-  WireFullTrackName(const FullTrackName& name, bool includes_name)
-      : name_(name), includes_name_(includes_name) {}
+  WireTrackNamespace(const TrackNamespace& name) : namespace_(name) {}
 
   size_t GetLengthOnWire() {
     return quiche::ComputeLengthOnWire(
-        WireVarInt62(num_elements()),
-        WireSpan<WireStringWithVarInt62Length, std::string>(name_.tuple()));
+        WireVarInt62(namespace_.number_of_elements()),
+        WireSpan<WireStringWithVarInt62Length, std::string>(
+            namespace_.tuple()));
   }
   absl::Status SerializeIntoWriter(quiche::QuicheDataWriter& writer) {
     return quiche::SerializeIntoWriter(
-        writer, WireVarInt62(num_elements()),
-        WireSpan<WireStringWithVarInt62Length, std::string>(name_.tuple()));
+        writer, WireVarInt62(namespace_.number_of_elements()),
+        WireSpan<WireStringWithVarInt62Length, std::string>(
+            namespace_.tuple()));
   }
 
  private:
-  size_t num_elements() const {
-    return includes_name_ ? (name_.tuple().size() - 1) : name_.tuple().size();
+  const TrackNamespace& namespace_;
+};
+
+class WireFullTrackName {
+ public:
+  WireFullTrackName(const FullTrackName& name) : name_(name) {}
+
+  size_t GetLengthOnWire() {
+    return quiche::ComputeLengthOnWire(
+        WireTrackNamespace(name_.track_namespace()),
+        WireStringWithVarInt62Length(name_.name()));
+  }
+  absl::Status SerializeIntoWriter(quiche::QuicheDataWriter& writer) {
+    return quiche::SerializeIntoWriter(
+        writer, WireTrackNamespace(name_.track_namespace()),
+        WireStringWithVarInt62Length(name_.name()));
   }
 
+ private:
   const FullTrackName& name_;
-  const bool includes_name_;
 };
 
 // Serializes data into buffer using the default allocator.  Invokes QUICHE_BUG
@@ -432,7 +443,7 @@
       return SerializeControlMessage(
           MoqtMessageType::kSubscribe, WireVarInt62(message.request_id),
           WireVarInt62(message.track_alias),
-          WireFullTrackName(message.full_track_name, true),
+          WireFullTrackName(message.full_track_name),
           WireUint8(message.subscriber_priority),
           WireDeliveryOrder(message.group_order), WireBoolean(message.forward),
           WireVarInt62(message.filter_type), WireKeyValuePairList(parameters));
@@ -443,7 +454,7 @@
       return SerializeControlMessage(
           MoqtMessageType::kSubscribe, WireVarInt62(message.request_id),
           WireVarInt62(message.track_alias),
-          WireFullTrackName(message.full_track_name, true),
+          WireFullTrackName(message.full_track_name),
           WireUint8(message.subscriber_priority),
           WireDeliveryOrder(message.group_order), WireBoolean(message.forward),
           WireVarInt62(message.filter_type), WireVarInt62(message.start->group),
@@ -460,7 +471,7 @@
       return SerializeControlMessage(
           MoqtMessageType::kSubscribe, WireVarInt62(message.request_id),
           WireVarInt62(message.track_alias),
-          WireFullTrackName(message.full_track_name, true),
+          WireFullTrackName(message.full_track_name),
           WireUint8(message.subscriber_priority),
           WireDeliveryOrder(message.group_order), WireBoolean(message.forward),
           WireVarInt62(message.filter_type), WireVarInt62(message.start->group),
@@ -550,24 +561,22 @@
         << "Serializing invalid MoQT parameters";
     return quiche::QuicheBuffer();
   }
-  return SerializeControlMessage(
-      MoqtMessageType::kAnnounce,
-      WireFullTrackName(message.track_namespace, false),
-      WireKeyValuePairList(parameters));
+  return SerializeControlMessage(MoqtMessageType::kAnnounce,
+                                 WireTrackNamespace(message.track_namespace),
+                                 WireKeyValuePairList(parameters));
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeAnnounceOk(
     const MoqtAnnounceOk& message) {
-  return SerializeControlMessage(
-      MoqtMessageType::kAnnounceOk,
-      WireFullTrackName(message.track_namespace, false));
+  return SerializeControlMessage(MoqtMessageType::kAnnounceOk,
+                                 WireTrackNamespace(message.track_namespace));
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeAnnounceError(
     const MoqtAnnounceError& message) {
   return SerializeControlMessage(
       MoqtMessageType::kAnnounceError,
-      WireFullTrackName(message.track_namespace, false),
+      WireTrackNamespace(message.track_namespace),
       WireVarInt62(message.error_code),
       WireStringWithVarInt62Length(message.reason_phrase));
 }
@@ -576,7 +585,7 @@
     const MoqtAnnounceCancel& message) {
   return SerializeControlMessage(
       MoqtMessageType::kAnnounceCancel,
-      WireFullTrackName(message.track_namespace, false),
+      WireTrackNamespace(message.track_namespace),
       WireVarInt62(message.error_code),
       WireStringWithVarInt62Length(message.reason_phrase));
 }
@@ -591,17 +600,15 @@
         << "Serializing invalid MoQT parameters";
     return quiche::QuicheBuffer();
   }
-  return SerializeControlMessage(
-      MoqtMessageType::kTrackStatusRequest,
-      WireFullTrackName(message.full_track_name, true),
-      WireKeyValuePairList(parameters));
+  return SerializeControlMessage(MoqtMessageType::kTrackStatusRequest,
+                                 WireFullTrackName(message.full_track_name),
+                                 WireKeyValuePairList(parameters));
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeUnannounce(
     const MoqtUnannounce& message) {
-  return SerializeControlMessage(
-      MoqtMessageType::kUnannounce,
-      WireFullTrackName(message.track_namespace, false));
+  return SerializeControlMessage(MoqtMessageType::kUnannounce,
+                                 WireTrackNamespace(message.track_namespace));
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeTrackStatus(
@@ -615,8 +622,7 @@
     return quiche::QuicheBuffer();
   }
   return SerializeControlMessage(
-      MoqtMessageType::kTrackStatus,
-      WireFullTrackName(message.full_track_name, true),
+      MoqtMessageType::kTrackStatus, WireFullTrackName(message.full_track_name),
       WireVarInt62(message.status_code), WireVarInt62(message.last_group),
       WireVarInt62(message.last_object), WireKeyValuePairList(parameters));
 }
@@ -637,33 +643,30 @@
         << "Serializing invalid MoQT parameters";
     return quiche::QuicheBuffer();
   }
-  return SerializeControlMessage(
-      MoqtMessageType::kSubscribeAnnounces,
-      WireFullTrackName(message.track_namespace, false),
-      WireKeyValuePairList(parameters));
+  return SerializeControlMessage(MoqtMessageType::kSubscribeAnnounces,
+                                 WireTrackNamespace(message.track_namespace),
+                                 WireKeyValuePairList(parameters));
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeSubscribeAnnouncesOk(
     const MoqtSubscribeAnnouncesOk& message) {
-  return SerializeControlMessage(
-      MoqtMessageType::kSubscribeAnnouncesOk,
-      WireFullTrackName(message.track_namespace, false));
+  return SerializeControlMessage(MoqtMessageType::kSubscribeAnnouncesOk,
+                                 WireTrackNamespace(message.track_namespace));
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeSubscribeAnnouncesError(
     const MoqtSubscribeAnnouncesError& message) {
   return SerializeControlMessage(
       MoqtMessageType::kSubscribeAnnouncesError,
-      WireFullTrackName(message.track_namespace, false),
+      WireTrackNamespace(message.track_namespace),
       WireVarInt62(message.error_code),
       WireStringWithVarInt62Length(message.reason_phrase));
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeUnsubscribeAnnounces(
     const MoqtUnsubscribeAnnounces& message) {
-  return SerializeControlMessage(
-      MoqtMessageType::kUnsubscribeAnnounces,
-      WireFullTrackName(message.track_namespace, false));
+  return SerializeControlMessage(MoqtMessageType::kUnsubscribeAnnounces,
+                                 WireTrackNamespace(message.track_namespace));
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeMaxRequestId(
@@ -703,7 +706,7 @@
       WireUint8(message.subscriber_priority),
       WireDeliveryOrder(message.group_order),
       WireVarInt62(FetchType::kStandalone),
-      WireFullTrackName(message.full_track_name, true),
+      WireFullTrackName(message.full_track_name),
       WireVarInt62(message.start_object.group),
       WireVarInt62(message.start_object.object),
       WireVarInt62(message.end_group),
diff --git a/quiche/quic/moqt/moqt_integration_test.cc b/quiche/quic/moqt/moqt_integration_test.cc
index b6c95ad..c1099ee 100644
--- a/quiche/quic/moqt/moqt_integration_test.cc
+++ b/quiche/quic/moqt/moqt_integration_test.cc
@@ -139,20 +139,20 @@
   auto parameters = std::make_optional<VersionSpecificParameters>(
       AuthTokenType::kOutOfBand, "foo");
   EXPECT_CALL(server_callbacks_.incoming_announce_callback,
-              Call(FullTrackName{"foo"}, parameters))
+              Call(TrackNamespace{"foo"}, parameters))
       .WillOnce(Return(std::nullopt));
   testing::MockFunction<void(
-      FullTrackName track_namespace,
+      TrackNamespace track_namespace,
       std::optional<MoqtAnnounceErrorReason> error_message)>
       announce_callback;
-  client_->session()->Announce(FullTrackName{"foo"},
+  client_->session()->Announce(TrackNamespace{"foo"},
                                announce_callback.AsStdFunction(), *parameters);
   bool matches = false;
   EXPECT_CALL(announce_callback, Call(_, _))
-      .WillOnce([&](FullTrackName track_namespace,
+      .WillOnce([&](TrackNamespace track_namespace,
                     std::optional<MoqtAnnounceErrorReason> error) {
         matches = true;
-        EXPECT_EQ(track_namespace, FullTrackName{"foo"});
+        EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         EXPECT_FALSE(error.has_value());
       });
   bool success =
@@ -160,14 +160,14 @@
   EXPECT_TRUE(success);
   matches = false;
   EXPECT_CALL(server_callbacks_.incoming_announce_callback, Call(_, _))
-      .WillOnce([&](FullTrackName name,
+      .WillOnce([&](TrackNamespace name,
                     std::optional<VersionSpecificParameters> parameters) {
         matches = true;
-        EXPECT_EQ(name, FullTrackName{"foo"});
+        EXPECT_EQ(name, TrackNamespace{"foo"});
         EXPECT_FALSE(parameters.has_value());
         return std::nullopt;
       });
-  client_->session()->Unannounce(FullTrackName{"foo"});
+  client_->session()->Unannounce(TrackNamespace{"foo"});
   success = test_harness_.RunUntilWithDefaultTimeout([&]() { return matches; });
   EXPECT_TRUE(success);
 }
@@ -177,20 +177,20 @@
   auto parameters = std::make_optional<VersionSpecificParameters>(
       AuthTokenType::kOutOfBand, "foo");
   EXPECT_CALL(server_callbacks_.incoming_announce_callback,
-              Call(FullTrackName{"foo"}, parameters))
+              Call(TrackNamespace{"foo"}, parameters))
       .WillOnce(Return(std::nullopt));
   testing::MockFunction<void(
-      FullTrackName track_namespace,
+      TrackNamespace track_namespace,
       std::optional<MoqtAnnounceErrorReason> error_message)>
       announce_callback;
-  client_->session()->Announce(FullTrackName{"foo"},
+  client_->session()->Announce(TrackNamespace{"foo"},
                                announce_callback.AsStdFunction(), *parameters);
   bool matches = false;
   EXPECT_CALL(announce_callback, Call(_, _))
-      .WillOnce([&](FullTrackName track_namespace,
+      .WillOnce([&](TrackNamespace track_namespace,
                     std::optional<MoqtAnnounceErrorReason> error) {
         matches = true;
-        EXPECT_EQ(track_namespace, FullTrackName{"foo"});
+        EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         EXPECT_FALSE(error.has_value());
       });
   bool success =
@@ -198,16 +198,17 @@
   EXPECT_TRUE(success);
   matches = false;
   EXPECT_CALL(announce_callback, Call(_, _))
-      .WillOnce([&](FullTrackName track_namespace,
+      .WillOnce([&](TrackNamespace track_namespace,
                     std::optional<MoqtAnnounceErrorReason> error) {
         matches = true;
-        EXPECT_EQ(track_namespace, FullTrackName{"foo"});
+        EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         ASSERT_TRUE(error.has_value());
         EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError);
         EXPECT_EQ(error->reason_phrase, "internal error");
       });
-  server_->session()->CancelAnnounce(
-      FullTrackName{"foo"}, RequestErrorCode::kInternalError, "internal error");
+  server_->session()->CancelAnnounce(TrackNamespace{"foo"},
+                                     RequestErrorCode::kInternalError,
+                                     "internal error");
   success = test_harness_.RunUntilWithDefaultTimeout([&]() { return matches; });
   EXPECT_TRUE(success);
 }
@@ -217,22 +218,21 @@
   auto parameters = std::make_optional<VersionSpecificParameters>(
       AuthTokenType::kOutOfBand, "foo");
   EXPECT_CALL(server_callbacks_.incoming_announce_callback,
-              Call(FullTrackName{"foo"}, parameters))
+              Call(TrackNamespace{"foo"}, parameters))
       .WillOnce(Return(std::nullopt));
   MockSubscribeRemoteTrackVisitor server_visitor;
   testing::MockFunction<void(
-      FullTrackName track_namespace,
+      TrackNamespace track_namespace,
       std::optional<MoqtAnnounceErrorReason> error_message)>
       announce_callback;
-  client_->session()->Announce(FullTrackName{"foo"},
+  client_->session()->Announce(TrackNamespace{"foo"},
                                announce_callback.AsStdFunction(), *parameters);
   bool matches = false;
   EXPECT_CALL(announce_callback, Call(_, _))
-      .WillOnce([&](FullTrackName track_namespace,
+      .WillOnce([&](TrackNamespace track_namespace,
                     std::optional<MoqtAnnounceErrorReason> error) {
-        EXPECT_EQ(track_namespace, FullTrackName{"foo"});
-        FullTrackName track_name = track_namespace;
-        track_name.AddElement("/catalog");
+        EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
+        FullTrackName track_name(track_namespace, "/catalog");
         EXPECT_FALSE(error.has_value());
         server_->session()->SubscribeCurrentObject(track_name, &server_visitor,
                                                    VersionSpecificParameters());
@@ -254,10 +254,9 @@
       AuthTokenType::kOutOfBand, "foo");
   MockSubscribeRemoteTrackVisitor server_visitor;
   EXPECT_CALL(server_callbacks_.incoming_announce_callback, Call(_, parameters))
-      .WillOnce([&](const FullTrackName& track_namespace,
+      .WillOnce([&](const TrackNamespace& track_namespace,
                     std::optional<VersionSpecificParameters> /*parameters*/) {
-        FullTrackName track_name = track_namespace;
-        track_name.AddElement("data");
+        FullTrackName track_name(track_namespace, "data");
         server_->session()->SubscribeAbsolute(
             track_name, /*start_group=*/0, /*start_object=*/0, &server_visitor,
             VersionSpecificParameters());
@@ -274,8 +273,8 @@
     received_subscribe_ok = true;
   });
   client_->session()->Announce(
-      FullTrackName{"test"},
-      [](FullTrackName, std::optional<MoqtAnnounceErrorReason>) {},
+      TrackNamespace{"test"},
+      [](TrackNamespace, std::optional<MoqtAnnounceErrorReason>) {},
       *parameters);
   bool success = test_harness_.RunUntilWithDefaultTimeout(
       [&]() { return received_subscribe_ok; });
@@ -447,18 +446,18 @@
 TEST_F(MoqtIntegrationTest, AnnounceFailure) {
   EstablishSession();
   testing::MockFunction<void(
-      FullTrackName track_namespace,
+      TrackNamespace track_namespace,
       std::optional<MoqtAnnounceErrorReason> error_message)>
       announce_callback;
-  client_->session()->Announce(FullTrackName{"foo"},
+  client_->session()->Announce(TrackNamespace{"foo"},
                                announce_callback.AsStdFunction(),
                                VersionSpecificParameters());
   bool matches = false;
   EXPECT_CALL(announce_callback, Call(_, _))
-      .WillOnce([&](FullTrackName track_namespace,
+      .WillOnce([&](TrackNamespace track_namespace,
                     std::optional<MoqtAnnounceErrorReason> error) {
         matches = true;
-        EXPECT_EQ(track_namespace, FullTrackName{"foo"});
+        EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         ASSERT_TRUE(error.has_value());
         EXPECT_EQ(error->error_code, RequestErrorCode::kNotSupported);
       });
diff --git a/quiche/quic/moqt/moqt_messages.cc b/quiche/quic/moqt/moqt_messages.cc
index 96e50cd..3cb9923 100644
--- a/quiche/quic/moqt/moqt_messages.cc
+++ b/quiche/quic/moqt/moqt_messages.cc
@@ -7,7 +7,6 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -307,29 +306,71 @@
   return "Unknown preference " + std::to_string(static_cast<int>(preference));
 }
 
-std::string FullTrackName::ToString() const {
+TrackNamespace::TrackNamespace(absl::Span<const absl::string_view> elements)
+    : tuple_(elements.begin(), elements.end()) {
+  if (std::size(elements) > kMaxNamespaceElements) {
+    tuple_.clear();
+    QUICHE_BUG(Moqt_namespace_too_large_01)
+        << "Constructing a namespace that is too large.";
+    return;
+  }
+  for (auto it : elements) {
+    length_ += it.size();
+    if (length_ > kMaxFullTrackNameSize) {
+      tuple_.clear();
+      QUICHE_BUG(Moqt_namespace_too_large_02)
+          << "Constructing a namespace that is too large.";
+      return;
+    }
+  }
+}
+
+bool TrackNamespace::InNamespace(const TrackNamespace& other) const {
+  if (tuple_.size() < other.tuple_.size()) {
+    return false;
+  }
+  for (int i = 0; i < other.tuple_.size(); ++i) {
+    if (tuple_[i] != other.tuple_[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void TrackNamespace::AddElement(absl::string_view element) {
+  if (!CanAddElement(element)) {
+    QUICHE_BUG(Moqt_namespace_too_large_03)
+        << "Constructing a namespace that is too large.";
+    return;
+  }
+  length_ += element.length();
+  tuple_.push_back(std::string(element));
+}
+
+std::string TrackNamespace::ToString() const {
   std::vector<std::string> bits;
   bits.reserve(tuple_.size());
   for (absl::string_view raw_bit : tuple_) {
     bits.push_back(absl::StrCat("\"", absl::CHexEscape(raw_bit), "\""));
   }
-  return absl::StrCat("{", absl::StrJoin(bits, ", "), "}");
+  return absl::StrCat("{", absl::StrJoin(bits, "::"), "}");
 }
 
-bool FullTrackName::operator==(const FullTrackName& other) const {
-  if (tuple_.size() != other.tuple_.size()) {
+bool TrackNamespace::operator==(const TrackNamespace& other) const {
+  if (number_of_elements() != other.number_of_elements()) {
     return false;
   }
   return absl::c_equal(tuple_, other.tuple_);
 }
-bool FullTrackName::operator<(const FullTrackName& other) const {
+
+bool TrackNamespace::operator<(const TrackNamespace& other) const {
   return absl::c_lexicographical_compare(tuple_, other.tuple_);
 }
-FullTrackName::FullTrackName(absl::Span<const absl::string_view> elements)
-    : tuple_(elements.begin(), elements.end()) {
-  QUICHE_BUG_IF(Moqt_namespace_too_large_03,
-                std::size(elements) > (kMaxNamespaceElements + 1))
-      << "Constructing a namespace that is too large.";
+
+void FullTrackName::set_name(absl::string_view name) {
+  QUIC_BUG_IF(Moqt_name_too_large_03, !CanAddName(name))
+      << "Setting a name that is too large.";
+  name_ = name;
 }
 
 absl::Status MoqtStreamErrorToStatus(webtransport::StreamErrorCode error_code,
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
index 1b61d18..3a32cb9 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -18,6 +18,7 @@
 #include "absl/container/btree_map.h"
 #include "absl/container/inlined_vector.h"
 #include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
@@ -47,6 +48,7 @@
 inline constexpr uint64_t kDefaultMaxAuthTokenCacheSize = 0;
 inline constexpr uint64_t kMinNamespaceElements = 1;
 inline constexpr uint64_t kMaxNamespaceElements = 32;
+inline constexpr size_t kMaxFullTrackNameSize = 1024;
 
 struct QUICHE_EXPORT MoqtSessionParameters {
   // TODO: support multiple versions.
@@ -265,67 +267,103 @@
 };
 using MoqtAnnounceErrorReason = MoqtSubscribeErrorReason;
 
-// Full track name represents a tuple of name elements. All higher order
-// elements MUST be present, but lower-order ones (like the name) can be
-// omitted.
-class FullTrackName {
+class TrackNamespace {
  public:
-  explicit FullTrackName(absl::Span<const absl::string_view> elements);
-  explicit FullTrackName(
+  explicit TrackNamespace(absl::Span<const absl::string_view> elements);
+  explicit TrackNamespace(
       std::initializer_list<const absl::string_view> elements)
-      : FullTrackName(absl::Span<const absl::string_view>(
-            std::data(elements), std::size(elements))) {
-    QUICHE_BUG_IF(Moqt_namespace_too_large_02,
-                  elements.size() > (kMaxNamespaceElements + 1))
-        << "Constructing a namespace that is too large.";
-  }
-  explicit FullTrackName(absl::string_view ns, absl::string_view name)
-      : FullTrackName({ns, name}) {}
-  FullTrackName() : FullTrackName({}) {}
+      : TrackNamespace(absl::Span<const absl::string_view>(
+            std::data(elements), std::size(elements))) {}
+  explicit TrackNamespace(absl::string_view ns) : TrackNamespace({ns}) {}
+  TrackNamespace() : TrackNamespace({}) {}
 
+  bool IsValid() const {
+    return !tuple_.empty() && tuple_.size() <= kMaxNamespaceElements &&
+           length_ <= kMaxFullTrackNameSize;
+  }
+  bool InNamespace(const TrackNamespace& other) const;
+  // Check if adding an element will exceed limits, without triggering a
+  // bug. Useful for the parser, which has to be robust to malformed data.
+  bool CanAddElement(absl::string_view element) {
+    return (tuple_.size() < kMaxNamespaceElements &&
+            length_ + element.length() <= kMaxFullTrackNameSize);
+  }
+  void AddElement(absl::string_view element);
   std::string ToString() const;
-
-  void AddElement(absl::string_view element) {
-    QUICHE_BUG_IF(Moqt_namespace_too_large_01,
-                  tuple_.size() > (kMaxNamespaceElements + 1))
-        << "Constructing a namespace that is too large.";
-    tuple_.push_back(std::string(element));
-  }
-  // Remove the last element to convert a name to a namespace.
-  void NameToNamespace() { tuple_.pop_back(); }
-  // returns true is |this| is a subdomain of |other|.
-  bool InNamespace(const FullTrackName& other) const {
-    if (tuple_.size() < other.tuple_.size()) {
-      return false;
-    }
-    for (int i = 0; i < other.tuple_.size(); ++i) {
-      if (tuple_[i] != other.tuple_[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-  absl::Span<const std::string> tuple() const {
-    return absl::MakeConstSpan(tuple_);
-  }
-
-  bool operator==(const FullTrackName& other) const;
-  bool operator<(const FullTrackName& other) const;
+  // Returns the number of elements in the tuple.
+  size_t number_of_elements() const { return tuple_.size(); }
+  // Returns the sum of the lengths of all elements in the tuple.
+  size_t total_length() const { return length_; }
+  bool operator==(const TrackNamespace& other) const;
+  bool operator<(const TrackNamespace& other) const;
+  const std::vector<std::string>& tuple() const { return tuple_; }
 
   template <typename H>
-  friend H AbslHashValue(H h, const FullTrackName& m) {
+  friend H AbslHashValue(H h, const TrackNamespace& m) {
     return H::combine(std::move(h), m.tuple_);
   }
-
   template <typename Sink>
-  friend void AbslStringify(Sink& sink, const FullTrackName& track_name) {
-    sink.Append(track_name.ToString());
+  friend void AbslStringify(Sink& sink, const TrackNamespace& track_namespace) {
+    sink.Append(track_namespace.ToString());
   }
 
-  bool empty() const { return tuple_.empty(); }
+ private:
+  std::vector<std::string> tuple_;
+  size_t length_ = 0;  // size in bytes.
+};
+
+class FullTrackName {
+ public:
+  FullTrackName(absl::string_view ns, absl::string_view name)
+      : namespace_(ns), name_(name) {
+    QUICHE_BUG_IF(Moqt_full_track_name_too_large_01, !IsValid())
+        << "Constructing a Full Track Name that is too large.";
+  }
+  FullTrackName(TrackNamespace ns, absl::string_view name)
+      : namespace_(ns), name_(name) {
+    QUICHE_BUG_IF(Moqt_full_track_name_too_large_02, !IsValid())
+        << "Constructing a Full Track Name that is too large.";
+  }
+  FullTrackName() = default;
+
+  bool IsValid() const {
+    return namespace_.IsValid() && length() <= kMaxFullTrackNameSize;
+  }
+  const TrackNamespace& track_namespace() const { return namespace_; }
+  TrackNamespace& track_namespace() { return namespace_; }
+  absl::string_view name() const { return name_; }
+  void AddElement(absl::string_view element) {
+    return namespace_.AddElement(element);
+  }
+  std::string ToString() const {
+    return absl::StrCat(namespace_.ToString(), "::", name_);
+  }
+  // Check if the name will exceed limits, without triggering a bug. Useful for
+  // the parser, which has to be robust to malformed data.
+  bool CanAddName(absl::string_view name) {
+    return (namespace_.total_length() + name.length() <= kMaxFullTrackNameSize);
+  }
+  void set_name(absl::string_view name);
+  size_t length() const { return namespace_.total_length() + name_.length(); }
+  bool operator==(const FullTrackName& other) const {
+    return name_ == other.name_ && namespace_ == other.namespace_;
+  }
+  bool operator<(const FullTrackName& other) const {
+    return namespace_ < other.namespace_ ||
+           (namespace_ == other.namespace_ && name_ < other.name_);
+  }
+  template <typename H>
+  friend H AbslHashValue(H h, const FullTrackName& m) {
+    return H::combine(std::move(h), m.namespace_.tuple(), m.name_);
+  }
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const FullTrackName& full_track_name) {
+    sink.Append(full_track_name.ToString());
+  }
 
  private:
-  absl::InlinedVector<std::string, 2> tuple_;
+  TrackNamespace namespace_;
+  std::string name_ = "";
 };
 
 // These are absolute sequence numbers.
@@ -586,22 +624,22 @@
 };
 
 struct QUICHE_EXPORT MoqtAnnounce {
-  FullTrackName track_namespace;
+  TrackNamespace track_namespace;
   VersionSpecificParameters parameters;
 };
 
 struct QUICHE_EXPORT MoqtAnnounceOk {
-  FullTrackName track_namespace;
+  TrackNamespace track_namespace;
 };
 
 struct QUICHE_EXPORT MoqtAnnounceError {
-  FullTrackName track_namespace;
+  TrackNamespace track_namespace;
   RequestErrorCode error_code;
   std::string reason_phrase;
 };
 
 struct QUICHE_EXPORT MoqtUnannounce {
-  FullTrackName track_namespace;
+  TrackNamespace track_namespace;
 };
 
 enum class QUICHE_EXPORT MoqtTrackStatusCode : uint64_t {
@@ -634,7 +672,7 @@
 };
 
 struct QUICHE_EXPORT MoqtAnnounceCancel {
-  FullTrackName track_namespace;
+  TrackNamespace track_namespace;
   RequestErrorCode error_code;
   std::string reason_phrase;
 };
@@ -649,22 +687,22 @@
 };
 
 struct QUICHE_EXPORT MoqtSubscribeAnnounces {
-  FullTrackName track_namespace;
+  TrackNamespace track_namespace;
   VersionSpecificParameters parameters;
 };
 
 struct QUICHE_EXPORT MoqtSubscribeAnnouncesOk {
-  FullTrackName track_namespace;
+  TrackNamespace track_namespace;
 };
 
 struct QUICHE_EXPORT MoqtSubscribeAnnouncesError {
-  FullTrackName track_namespace;
+  TrackNamespace track_namespace;
   RequestErrorCode error_code;
   std::string reason_phrase;
 };
 
 struct QUICHE_EXPORT MoqtUnsubscribeAnnounces {
-  FullTrackName track_namespace;
+  TrackNamespace track_namespace;
 };
 
 struct QUICHE_EXPORT MoqtMaxRequestId {
diff --git a/quiche/quic/moqt/moqt_messages_test.cc b/quiche/quic/moqt/moqt_messages_test.cc
index 0b554f2..1eafaa7 100644
--- a/quiche/quic/moqt/moqt_messages_test.cc
+++ b/quiche/quic/moqt/moqt_messages_test.cc
@@ -8,44 +8,90 @@
 
 #include "absl/hash/hash.h"
 #include "absl/strings/string_view.h"
+#include "quiche/common/platform/api/quiche_expect_bug.h"
 #include "quiche/common/platform/api/quiche_test.h"
 
 namespace moqt::test {
 namespace {
 
-TEST(MoqtMessagesTest, FullTrackNameConstructors) {
-  FullTrackName name1({"foo", "bar"});
+TEST(MoqtMessagesTest, TrackNamespaceConstructors) {
+  TrackNamespace name1({"foo", "bar"});
   std::vector<absl::string_view> list = {"foo", "bar"};
-  FullTrackName name2(list);
+  TrackNamespace name2(list);
   EXPECT_EQ(name1, name2);
   EXPECT_EQ(absl::HashOf(name1), absl::HashOf(name2));
 }
 
-TEST(MoqtMessagesTest, FullTrackNameOrder) {
-  FullTrackName name1({"a", "b"});
-  FullTrackName name2({"a", "b", "c"});
-  FullTrackName name3({"b", "a"});
+TEST(MoqtMessagesTest, TrackNamespaceOrder) {
+  TrackNamespace name1({"a", "b"});
+  TrackNamespace name2({"a", "b", "c"});
+  TrackNamespace name3({"b", "a"});
   EXPECT_LT(name1, name2);
   EXPECT_LT(name2, name3);
   EXPECT_LT(name1, name3);
 }
 
-TEST(MoqtMessagesTest, FullTrackNameInNamespace) {
-  FullTrackName name1({"a", "b"});
-  FullTrackName name2({"a", "b", "c"});
-  FullTrackName name3({"d", "b"});
+TEST(MoqtMessagesTest, TrackNamespaceInNamespace) {
+  TrackNamespace name1({"a", "b"});
+  TrackNamespace name2({"a", "b", "c"});
+  TrackNamespace name3({"d", "b"});
   EXPECT_TRUE(name2.InNamespace(name1));
   EXPECT_FALSE(name1.InNamespace(name2));
   EXPECT_TRUE(name1.InNamespace(name1));
   EXPECT_FALSE(name2.InNamespace(name3));
 }
 
-TEST(MoqtMessagesTest, FullTrackNameToString) {
-  FullTrackName name1({"a", "b"});
-  EXPECT_EQ(name1.ToString(), R"({"a", "b"})");
+TEST(MoqtMessagesTest, TrackNamespaceToString) {
+  TrackNamespace name1({"a", "b"});
+  EXPECT_EQ(name1.ToString(), R"({"a"::"b"})");
 
-  FullTrackName name2({"\xff", "\x61"});
-  EXPECT_EQ(name2.ToString(), R"({"\xff", "a"})");
+  TrackNamespace name2({"\xff", "\x61"});
+  EXPECT_EQ(name2.ToString(), R"({"\xff"::"a"})");
+}
+
+TEST(MoqtMessagesTest, FullTrackNameToString) {
+  FullTrackName name1(TrackNamespace{"a", "b"}, "c");
+  EXPECT_EQ(name1.ToString(), R"({"a"::"b"}::c)");
+}
+
+TEST(MoqtMessagesTest, TooManyNamespaceElements) {
+  // 32 elements work.
+  TrackNamespace name1({"a", "b", "c",  "d",  "e",  "f",  "g",  "h",
+                        "i", "j", "k",  "l",  "m",  "n",  "o",  "p",
+                        "q", "r", "s",  "t",  "u",  "v",  "w",  "x",
+                        "y", "z", "aa", "bb", "cc", "dd", "ee", "ff"});
+  EXPECT_TRUE(name1.IsValid());
+  EXPECT_QUICHE_BUG(name1.AddElement("a"),
+                    "Constructing a namespace that is too large.");
+  EXPECT_EQ(name1.number_of_elements(), kMaxNamespaceElements);
+
+  // 33 elements fail,
+  TrackNamespace name2;
+  EXPECT_QUICHE_BUG(
+      name2 = TrackNamespace({"a",  "b",  "c",  "d",  "e",  "f", "g", "h", "i",
+                              "j",  "k",  "l",  "m",  "n",  "o", "p", "q", "r",
+                              "s",  "t",  "u",  "v",  "w",  "x", "y", "z", "aa",
+                              "bb", "cc", "dd", "ee", "ff", "gg"}),
+      "Constructing a namespace that is too large.");
+  EXPECT_FALSE(name2.IsValid());
+}
+
+TEST(MoqtMessagesTest, FullTrackNameTooLong) {
+  char raw_name[kMaxFullTrackNameSize + 1];
+  absl::string_view track_namespace(raw_name, kMaxFullTrackNameSize);
+  // Adding an element takes it over the length limit.
+  TrackNamespace max_length_namespace({track_namespace});
+  EXPECT_TRUE(max_length_namespace.IsValid());
+  EXPECT_QUICHE_BUG(max_length_namespace.AddElement("f"),
+                    "Constructing a namespace that is too large.");
+  // Constructing a FullTrackName where the name brings it over the length
+  // limit.
+  EXPECT_QUICHE_BUG(FullTrackName(max_length_namespace, "f"),
+                    "Constructing a Full Track Name that is too large.");
+  // The namespace is too long by itself..
+  absl::string_view big_namespace(raw_name, kMaxFullTrackNameSize + 1);
+  EXPECT_QUICHE_BUG(TrackNamespace({big_namespace}),
+                    "Constructing a namespace that is too large.");
 }
 
 }  // namespace
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc
index 608052b..01cd6c1 100644
--- a/quiche/quic/moqt/moqt_parser.cc
+++ b/quiche/quic/moqt/moqt_parser.cc
@@ -403,17 +403,14 @@
   MoqtSubscribe subscribe;
   uint64_t filter, group, object;
   uint8_t group_order, forward;
-  absl::string_view track_name;
   if (!reader.ReadVarInt62(&subscribe.request_id) ||
       !reader.ReadVarInt62(&subscribe.track_alias) ||
-      !ReadTrackNamespace(reader, subscribe.full_track_name) ||
-      !reader.ReadStringPieceVarInt62(&track_name) ||
+      !ReadFullTrackName(reader, subscribe.full_track_name) ||
       !reader.ReadUInt8(&subscribe.subscriber_priority) ||
       !reader.ReadUInt8(&group_order) || !reader.ReadUInt8(&forward) ||
       !reader.ReadVarInt62(&filter)) {
     return 0;
   }
-  subscribe.full_track_name.AddElement(track_name);
   if (!ParseDeliveryOrder(group_order, subscribe.group_order)) {
     ParseError("Invalid group order value in SUBSCRIBE");
     return 0;
@@ -653,14 +650,9 @@
 size_t MoqtControlParser::ProcessTrackStatusRequest(
     quic::QuicDataReader& reader) {
   MoqtTrackStatusRequest track_status_request;
-  if (!ReadTrackNamespace(reader, track_status_request.full_track_name)) {
+  if (!ReadFullTrackName(reader, track_status_request.full_track_name)) {
     return 0;
   }
-  absl::string_view name;
-  if (!reader.ReadStringPieceVarInt62(&name)) {
-    return 0;
-  }
-  track_status_request.full_track_name.AddElement(name);
   KeyValuePairList parameters;
   if (!ParseKeyValuePairList(reader, parameters)) {
     return 0;
@@ -689,14 +681,9 @@
 
 size_t MoqtControlParser::ProcessTrackStatus(quic::QuicDataReader& reader) {
   MoqtTrackStatus track_status;
-  if (!ReadTrackNamespace(reader, track_status.full_track_name)) {
+  if (!ReadFullTrackName(reader, track_status.full_track_name)) {
     return 0;
   }
-  absl::string_view name;
-  if (!reader.ReadStringPieceVarInt62(&name)) {
-    return 0;
-  }
-  track_status.full_track_name.AddElement(name);
   uint64_t value;
   if (!reader.ReadVarInt62(&value) ||
       !reader.ReadVarInt62(&track_status.last_group) ||
@@ -799,7 +786,6 @@
 
 size_t MoqtControlParser::ProcessFetch(quic::QuicDataReader& reader) {
   MoqtFetch fetch;
-  absl::string_view track_name;
   uint8_t group_order;
   uint64_t end_object;
   uint64_t type;
@@ -826,16 +812,13 @@
     }
     case FetchType::kStandalone: {
       fetch.joining_fetch = std::nullopt;
-      if (!ReadTrackNamespace(reader, fetch.full_track_name) ||
-          !reader.ReadStringPieceVarInt62(&track_name) ||
+      if (!ReadFullTrackName(reader, fetch.full_track_name) ||
           !reader.ReadVarInt62(&fetch.start_object.group) ||
           !reader.ReadVarInt62(&fetch.start_object.object) ||
           !reader.ReadVarInt62(&fetch.end_group) ||
           !reader.ReadVarInt62(&end_object)) {
         return 0;
       }
-      // Elements that have to be translated from the literal value.
-      fetch.full_track_name.AddElement(track_name);
       fetch.end_object =
           end_object == 0 ? std::optional<uint64_t>() : (end_object - 1);
       if (fetch.end_group < fetch.start_object.group ||
@@ -957,8 +940,8 @@
 }
 
 bool MoqtControlParser::ReadTrackNamespace(quic::QuicDataReader& reader,
-                                           FullTrackName& full_track_name) {
-  QUICHE_DCHECK(full_track_name.empty());
+                                           TrackNamespace& track_namespace) {
+  QUICHE_DCHECK(!track_namespace.IsValid());
   uint64_t num_elements;
   if (!reader.ReadVarInt62(&num_elements)) {
     return false;
@@ -973,8 +956,31 @@
     if (!reader.ReadStringPieceVarInt62(&element)) {
       return false;
     }
-    full_track_name.AddElement(element);
+    if (!track_namespace.CanAddElement(element)) {
+      ParseError(MoqtError::kProtocolViolation, "Full track name is too large");
+      return false;
+    }
+    track_namespace.AddElement(element);
   }
+  QUICHE_DCHECK(track_namespace.IsValid());
+  return true;
+}
+
+bool MoqtControlParser::ReadFullTrackName(quic::QuicDataReader& reader,
+                                          FullTrackName& full_track_name) {
+  QUICHE_DCHECK(!full_track_name.IsValid());
+  if (!ReadTrackNamespace(reader, full_track_name.track_namespace())) {
+    return false;
+  }
+  absl::string_view name;
+  if (!reader.ReadStringPieceVarInt62(&name)) {
+    return false;
+  }
+  if (!full_track_name.CanAddName(name)) {
+    ParseError(MoqtError::kProtocolViolation, "Full track name is too large");
+    return false;
+  }
+  full_track_name.set_name(name);
   return true;
 }
 
diff --git a/quiche/quic/moqt/moqt_parser.h b/quiche/quic/moqt/moqt_parser.h
index 1cb2fe3..030861d 100644
--- a/quiche/quic/moqt/moqt_parser.h
+++ b/quiche/quic/moqt/moqt_parser.h
@@ -136,11 +136,14 @@
   void ParseError(absl::string_view reason);
   void ParseError(MoqtError error, absl::string_view reason);
 
-  // Parses a message that a track namespace but not name. The last element of
-  // |full_track_name| will be set to the empty string. Returns false if it
-  // could not parse the full namespace field.
+  // Reads a TrackNamespace from the reader. Returns false if the namespace is
+  // too large. Sets a ParseError if the namespace is malformed.
   bool ReadTrackNamespace(quic::QuicDataReader& reader,
-                          FullTrackName& full_track_name);
+                          TrackNamespace& track_namespace);
+  // Reads a FullTrackName from the reader. Returns false if the name is too
+  // large. Sets a ParseError if the name is malformed.
+  bool ReadFullTrackName(quic::QuicDataReader& reader,
+                         FullTrackName& full_track_name);
   // Translates raw key/value pairs into semantically meaningful formats.
   // The spec defines many encoding errors in AUTHORIZATION TOKEN as
   // request level. This treats them as session-level, unless they are a result
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc
index 1e91479..8ad711c 100644
--- a/quiche/quic/moqt/moqt_session.cc
+++ b/quiche/quic/moqt/moqt_session.cc
@@ -89,6 +89,7 @@
 
   absl::StatusOr<std::shared_ptr<MoqtTrackPublisher>> GetTrack(
       const FullTrackName& track_name) override {
+    QUICHE_DCHECK(track_name.IsValid());
     return absl::NotFoundError("No tracks published");
   }
 };
@@ -249,9 +250,10 @@
 }
 
 bool MoqtSession::SubscribeAnnounces(
-    FullTrackName track_namespace,
+    TrackNamespace track_namespace,
     MoqtOutgoingSubscribeAnnouncesCallback callback,
     VersionSpecificParameters parameters) {
+  QUICHE_DCHECK(track_namespace.IsValid());
   if (received_goaway_ || sent_goaway_) {
     QUIC_DLOG(INFO) << ENDPOINT
                     << "Tried to send SUBSCRIBE_ANNOUNCES after GOAWAY";
@@ -267,7 +269,8 @@
   return true;
 }
 
-bool MoqtSession::UnsubscribeAnnounces(FullTrackName track_namespace) {
+bool MoqtSession::UnsubscribeAnnounces(TrackNamespace track_namespace) {
+  QUICHE_DCHECK(track_namespace.IsValid());
   if (!outgoing_subscribe_announces_.contains(track_namespace)) {
     return false;
   }
@@ -280,9 +283,10 @@
   return true;
 }
 
-void MoqtSession::Announce(FullTrackName track_namespace,
+void MoqtSession::Announce(TrackNamespace track_namespace,
                            MoqtOutgoingAnnounceCallback announce_callback,
                            VersionSpecificParameters parameters) {
+  QUICHE_DCHECK(track_namespace.IsValid());
   if (outgoing_announces_.contains(track_namespace)) {
     std::move(announce_callback)(
         track_namespace,
@@ -304,7 +308,8 @@
   outgoing_announces_[track_namespace] = std::move(announce_callback);
 }
 
-bool MoqtSession::Unannounce(FullTrackName track_namespace) {
+bool MoqtSession::Unannounce(TrackNamespace track_namespace) {
+  QUICHE_DCHECK(track_namespace.IsValid());
   auto it = outgoing_announces_.find(track_namespace);
   if (it == outgoing_announces_.end()) {
     return false;  // Could have been destroyed by ANNOUNCE_CANCEL.
@@ -318,9 +323,10 @@
   return true;
 }
 
-void MoqtSession::CancelAnnounce(FullTrackName track_namespace,
+void MoqtSession::CancelAnnounce(TrackNamespace track_namespace,
                                  RequestErrorCode code,
                                  absl::string_view reason) {
+  QUICHE_DCHECK(track_namespace.IsValid());
   MoqtAnnounceCancel message{track_namespace, code, std::string(reason)};
 
   SendControlMessage(framer_.SerializeAnnounceCancel(message));
@@ -332,6 +338,7 @@
                                     uint64_t start_group, uint64_t start_object,
                                     SubscribeRemoteTrack::Visitor* visitor,
                                     VersionSpecificParameters parameters) {
+  QUICHE_DCHECK(name.IsValid());
   MoqtSubscribe message;
   message.full_track_name = name;
   message.subscriber_priority = kDefaultSubscriberPriority;
@@ -349,6 +356,7 @@
                                     uint64_t end_group,
                                     SubscribeRemoteTrack::Visitor* visitor,
                                     VersionSpecificParameters parameters) {
+  QUICHE_DCHECK(name.IsValid());
   if (end_group < start_group) {
     QUIC_DLOG(ERROR) << "Subscription end is before beginning";
     return false;
@@ -368,6 +376,7 @@
 bool MoqtSession::SubscribeCurrentObject(const FullTrackName& name,
                                          SubscribeRemoteTrack::Visitor* visitor,
                                          VersionSpecificParameters parameters) {
+  QUICHE_DCHECK(name.IsValid());
   MoqtSubscribe message;
   message.full_track_name = name;
   message.subscriber_priority = kDefaultSubscriberPriority;
@@ -383,6 +392,7 @@
 bool MoqtSession::SubscribeNextGroup(const FullTrackName& name,
                                      SubscribeRemoteTrack::Visitor* visitor,
                                      VersionSpecificParameters parameters) {
+  QUICHE_DCHECK(name.IsValid());
   MoqtSubscribe message;
   message.full_track_name = name;
   message.subscriber_priority = kDefaultSubscriberPriority;
@@ -400,10 +410,12 @@
     std::optional<uint64_t> end_group,
     std::optional<MoqtPriority> subscriber_priority,
     std::optional<bool> forward, VersionSpecificParameters parameters) {
+  QUICHE_DCHECK(name.IsValid());
   auto it = subscribe_by_name_.find(name);
   if (it == subscribe_by_name_.end()) {
     return false;
   }
+  QUICHE_DCHECK(name.IsValid());
   SubscribeRemoteTrack* track = it->second;
   MoqtSubscribeUpdate subscribe_update;
   subscribe_update.request_id = track->request_id();
@@ -435,10 +447,12 @@
 };
 
 void MoqtSession::Unsubscribe(const FullTrackName& name) {
+  QUICHE_DCHECK(name.IsValid());
   SubscribeRemoteTrack* track = RemoteTrackByName(name);
   if (track == nullptr) {
     return;
   }
+  QUICHE_DCHECK(name.IsValid());
   QUIC_DLOG(INFO) << ENDPOINT << "Sent UNSUBSCRIBE message for " << name;
   MoqtUnsubscribe message;
   message.subscribe_id = track->request_id();
@@ -452,6 +466,7 @@
                         MoqtPriority priority,
                         std::optional<MoqtDeliveryOrder> delivery_order,
                         VersionSpecificParameters parameters) {
+  QUICHE_DCHECK(name.IsValid());
   if (next_request_id_ >= peer_max_request_id_) {
     QUIC_DLOG(INFO) << ENDPOINT << "Tried to send FETCH with ID "
                     << next_request_id_
@@ -485,6 +500,7 @@
                                SubscribeRemoteTrack::Visitor* visitor,
                                uint64_t num_previous_groups,
                                VersionSpecificParameters parameters) {
+  QUICHE_DCHECK(name.IsValid());
   return JoiningFetch(
       name, visitor,
       [this, id = next_request_id_](std::unique_ptr<MoqtFetchTask> fetch_task) {
@@ -509,6 +525,7 @@
                                MoqtPriority priority,
                                std::optional<MoqtDeliveryOrder> delivery_order,
                                VersionSpecificParameters parameters) {
+  QUICHE_DCHECK(name.IsValid());
   if ((next_request_id_ + 2) >= peer_max_request_id_) {
     QUIC_DLOG(INFO) << ENDPOINT << "Tried to send JOINING_FETCH with ID "
                     << (next_request_id_ + 2)
@@ -789,6 +806,7 @@
 
 SubscribeRemoteTrack* MoqtSession::RemoteTrackByName(
     const FullTrackName& name) {
+  QUICHE_DCHECK(name.IsValid());
   auto it = subscribe_by_name_.find(name);
   if (it == subscribe_by_name_.end()) {
     return nullptr;
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h
index ec0efe1..b7e5301 100644
--- a/quiche/quic/moqt/moqt_session.h
+++ b/quiche/quic/moqt/moqt_session.h
@@ -95,22 +95,22 @@
   quic::Perspective perspective() const { return parameters_.perspective; }
 
   // Returns true if message was sent.
-  bool SubscribeAnnounces(FullTrackName track_namespace,
+  bool SubscribeAnnounces(TrackNamespace track_namespace,
                           MoqtOutgoingSubscribeAnnouncesCallback callback,
                           VersionSpecificParameters parameters);
-  bool UnsubscribeAnnounces(FullTrackName track_namespace);
+  bool UnsubscribeAnnounces(TrackNamespace track_namespace);
 
   // Send an ANNOUNCE message for |track_namespace|, and call
   // |announce_callback| when the response arrives. Will fail immediately if
   // there is already an unresolved ANNOUNCE for that namespace.
-  void Announce(FullTrackName track_namespace,
+  void Announce(TrackNamespace track_namespace,
                 MoqtOutgoingAnnounceCallback announce_callback,
                 VersionSpecificParameters parameters);
   // Returns true if message was sent, false if there is no ANNOUNCE to cancel.
-  bool Unannounce(FullTrackName track_namespace);
+  bool Unannounce(TrackNamespace track_namespace);
   // Allows the subscriber to declare it will not subscribe to |track_namespace|
   // anymore.
-  void CancelAnnounce(FullTrackName track_namespace, RequestErrorCode code,
+  void CancelAnnounce(TrackNamespace track_namespace, RequestErrorCode code,
                       absl::string_view reason_phrase);
 
   // Returns true if SUBSCRIBE was sent. If there is already a subscription to
@@ -737,13 +737,13 @@
   // Indexed by track namespace. If the value is not nullptr, no OK or ERROR
   // has been received. The entry is deleted after sending UNANNOUNCE or
   // receiving ANNOUNCE_CANCEL.
-  absl::flat_hash_map<FullTrackName, MoqtOutgoingAnnounceCallback>
+  absl::flat_hash_map<TrackNamespace, MoqtOutgoingAnnounceCallback>
       outgoing_announces_;
   // The value is nullptr after OK or ERROR is received. The entry is deleted
   // when sending UNSUBSCRIBE_ANNOUNCES, to make sure the application doesn't
   // unsubscribe from something that it isn't subscribed to. ANNOUNCEs that
   // result from this subscription use incoming_announce_callback.
-  absl::flat_hash_map<FullTrackName, MoqtOutgoingSubscribeAnnouncesCallback>
+  absl::flat_hash_map<TrackNamespace, MoqtOutgoingSubscribeAnnouncesCallback>
       outgoing_subscribe_announces_;
 
   // The minimum request ID the peer can use that is monotonically increasing.
diff --git a/quiche/quic/moqt/moqt_session_callbacks.h b/quiche/quic/moqt/moqt_session_callbacks.h
index 3b0271a..447bc00 100644
--- a/quiche/quic/moqt/moqt_session_callbacks.h
+++ b/quiche/quic/moqt/moqt_session_callbacks.h
@@ -33,7 +33,7 @@
 // ANNOUNCE sets a value for |parameters|, UNANNOUNCE does not.
 using MoqtIncomingAnnounceCallback =
     quiche::MultiUseCallback<std::optional<MoqtAnnounceErrorReason>(
-        const FullTrackName& track_namespace,
+        const TrackNamespace& track_namespace,
         const std::optional<VersionSpecificParameters>& parameters)>;
 
 // Called whenever SUBSCRIBE_ANNOUNCES or UNSUBSCRIBE_ANNOUNCES is received from
@@ -43,11 +43,11 @@
 // UNSUBSCRIBE_ANNOUNCES does not.
 using MoqtIncomingSubscribeAnnouncesCallback =
     quiche::MultiUseCallback<std::optional<MoqtSubscribeErrorReason>(
-        const FullTrackName& track_namespace,
+        const TrackNamespace& track_namespace,
         std::optional<VersionSpecificParameters> parameters)>;
 
 inline std::optional<MoqtAnnounceErrorReason> DefaultIncomingAnnounceCallback(
-    const FullTrackName& /*track_namespace*/,
+    const TrackNamespace& /*track_namespace*/,
     std::optional<VersionSpecificParameters> /*parameters*/) {
   return std::optional(MoqtAnnounceErrorReason{
       RequestErrorCode::kNotSupported,
@@ -56,7 +56,7 @@
 
 inline std::optional<MoqtSubscribeErrorReason>
 DefaultIncomingSubscribeAnnouncesCallback(
-    const FullTrackName& track_namespace,
+    const TrackNamespace& track_namespace,
     std::optional<VersionSpecificParameters> /*parameters*/) {
   return MoqtSubscribeErrorReason{
       RequestErrorCode::kNotSupported,
diff --git a/quiche/quic/moqt/moqt_session_interface.h b/quiche/quic/moqt/moqt_session_interface.h
index 8f76a19..8e822f9 100644
--- a/quiche/quic/moqt/moqt_session_interface.h
+++ b/quiche/quic/moqt/moqt_session_interface.h
@@ -23,11 +23,11 @@
 // after calling this callback. Alternatively, the application can call
 // Unannounce() to delete the state.
 using MoqtOutgoingAnnounceCallback = quiche::MultiUseCallback<void(
-    FullTrackName track_namespace,
+    TrackNamespace track_namespace,
     std::optional<MoqtAnnounceErrorReason> error)>;
 
 using MoqtOutgoingSubscribeAnnouncesCallback = quiche::SingleUseCallback<void(
-    FullTrackName track_namespace, std::optional<RequestErrorCode> error,
+    TrackNamespace track_namespace, std::optional<RequestErrorCode> error,
     absl::string_view reason)>;
 
 class MoqtSessionInterface {
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc
index 8b4814b..ed23ccd 100644
--- a/quiche/quic/moqt/moqt_session_test.cc
+++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -354,7 +354,7 @@
 
 TEST_F(MoqtSessionTest, AnnounceWithOkAndCancel) {
   testing::MockFunction<void(
-      FullTrackName track_namespace,
+      TrackNamespace track_namespace,
       std::optional<MoqtAnnounceErrorReason> error_message)>
       announce_resolved_callback;
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
@@ -362,42 +362,42 @@
   EXPECT_CALL(mock_session_, GetStreamById(_)).WillOnce(Return(&mock_stream_));
   EXPECT_CALL(mock_stream_,
               Writev(ControlMessageOfType(MoqtMessageType::kAnnounce), _));
-  session_.Announce(FullTrackName{"foo"},
+  session_.Announce(TrackNamespace("foo"),
                     announce_resolved_callback.AsStdFunction(),
                     VersionSpecificParameters());
 
   MoqtAnnounceOk ok = {
-      /*track_namespace=*/FullTrackName{"foo"},
+      TrackNamespace("foo"),
   };
   EXPECT_CALL(announce_resolved_callback, Call(_, _))
-      .WillOnce([&](FullTrackName track_namespace,
+      .WillOnce([&](TrackNamespace track_namespace,
                     std::optional<MoqtAnnounceErrorReason> error) {
-        EXPECT_EQ(track_namespace, FullTrackName{"foo"});
+        EXPECT_EQ(track_namespace, TrackNamespace("foo"));
         EXPECT_FALSE(error.has_value());
       });
   stream_input->OnAnnounceOkMessage(ok);
 
   MoqtAnnounceCancel cancel = {
-      /*track_namespace=*/FullTrackName{"foo"},
-      /*error_code=*/RequestErrorCode::kInternalError,
+      TrackNamespace("foo"),
+      RequestErrorCode::kInternalError,
       /*reason_phrase=*/"Test error",
   };
   EXPECT_CALL(announce_resolved_callback, Call(_, _))
-      .WillOnce([&](FullTrackName track_namespace,
+      .WillOnce([&](TrackNamespace track_namespace,
                     std::optional<MoqtAnnounceErrorReason> error) {
-        EXPECT_EQ(track_namespace, FullTrackName{"foo"});
+        EXPECT_EQ(track_namespace, TrackNamespace("foo"));
         ASSERT_TRUE(error.has_value());
         EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError);
         EXPECT_EQ(error->reason_phrase, "Test error");
       });
   stream_input->OnAnnounceCancelMessage(cancel);
   // State is gone.
-  EXPECT_FALSE(session_.Unannounce(FullTrackName{"foo"}));
+  EXPECT_FALSE(session_.Unannounce(TrackNamespace("foo")));
 }
 
 TEST_F(MoqtSessionTest, AnnounceWithOkAndUnannounce) {
   testing::MockFunction<void(
-      FullTrackName track_namespace,
+      TrackNamespace track_namespace,
       std::optional<MoqtAnnounceErrorReason> error_message)>
       announce_resolved_callback;
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
@@ -405,17 +405,17 @@
   EXPECT_CALL(mock_session_, GetStreamById(_)).WillOnce(Return(&mock_stream_));
   EXPECT_CALL(mock_stream_,
               Writev(ControlMessageOfType(MoqtMessageType::kAnnounce), _));
-  session_.Announce(FullTrackName{"foo"},
+  session_.Announce(TrackNamespace{"foo"},
                     announce_resolved_callback.AsStdFunction(),
                     VersionSpecificParameters());
 
   MoqtAnnounceOk ok = {
-      /*track_namespace=*/FullTrackName{"foo"},
+      TrackNamespace{"foo"},
   };
   EXPECT_CALL(announce_resolved_callback, Call(_, _))
-      .WillOnce([&](FullTrackName track_namespace,
+      .WillOnce([&](TrackNamespace track_namespace,
                     std::optional<MoqtAnnounceErrorReason> error) {
-        EXPECT_EQ(track_namespace, FullTrackName{"foo"});
+        EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         EXPECT_FALSE(error.has_value());
       });
   stream_input->OnAnnounceOkMessage(ok);
@@ -423,14 +423,14 @@
   EXPECT_CALL(mock_session_, GetStreamById(_)).WillOnce(Return(&mock_stream_));
   EXPECT_CALL(mock_stream_,
               Writev(ControlMessageOfType(MoqtMessageType::kUnannounce), _));
-  session_.Unannounce(FullTrackName{"foo"});
+  session_.Unannounce(TrackNamespace{"foo"});
   // State is gone.
-  EXPECT_FALSE(session_.Unannounce(FullTrackName{"foo"}));
+  EXPECT_FALSE(session_.Unannounce(TrackNamespace{"foo"}));
 }
 
 TEST_F(MoqtSessionTest, AnnounceWithError) {
   testing::MockFunction<void(
-      FullTrackName track_namespace,
+      TrackNamespace track_namespace,
       std::optional<MoqtAnnounceErrorReason> error_message)>
       announce_resolved_callback;
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
@@ -438,26 +438,26 @@
   EXPECT_CALL(mock_session_, GetStreamById(_)).WillOnce(Return(&mock_stream_));
   EXPECT_CALL(mock_stream_,
               Writev(ControlMessageOfType(MoqtMessageType::kAnnounce), _));
-  session_.Announce(FullTrackName{"foo"},
+  session_.Announce(TrackNamespace{"foo"},
                     announce_resolved_callback.AsStdFunction(),
                     VersionSpecificParameters());
 
   MoqtAnnounceError error = {
-      /*track_namespace=*/FullTrackName{"foo"},
+      /*track_namespace=*/TrackNamespace{"foo"},
       /*error_code=*/RequestErrorCode::kInternalError,
       /*reason_phrase=*/"Test error",
   };
   EXPECT_CALL(announce_resolved_callback, Call(_, _))
-      .WillOnce([&](FullTrackName track_namespace,
+      .WillOnce([&](TrackNamespace track_namespace,
                     std::optional<MoqtAnnounceErrorReason> error) {
-        EXPECT_EQ(track_namespace, FullTrackName{"foo"});
+        EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
         ASSERT_TRUE(error.has_value());
         EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError);
         EXPECT_EQ(error->reason_phrase, "Test error");
       });
   stream_input->OnAnnounceErrorMessage(error);
   // State is gone.
-  EXPECT_FALSE(session_.Unannounce(FullTrackName{"foo"}));
+  EXPECT_FALSE(session_.Unannounce(TrackNamespace{"foo"}));
 }
 
 TEST_F(MoqtSessionTest, AsynchronousSubscribeReturnsOk) {
@@ -890,7 +890,7 @@
 }
 
 TEST_F(MoqtSessionTest, ReplyToAnnounceWithOkThenUnannounce) {
-  FullTrackName track_namespace{"foo"};
+  TrackNamespace track_namespace{"foo"};
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
   auto parameters = std::make_optional<VersionSpecificParameters>(
@@ -916,7 +916,7 @@
 }
 
 TEST_F(MoqtSessionTest, ReplyToAnnounceWithOkThenAnnounceCancel) {
-  FullTrackName track_namespace{"foo"};
+  TrackNamespace track_namespace{"foo"};
 
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
@@ -943,7 +943,7 @@
 }
 
 TEST_F(MoqtSessionTest, ReplyToAnnounceWithError) {
-  FullTrackName track_namespace{"foo"};
+  TrackNamespace track_namespace{"foo"};
 
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
@@ -971,18 +971,17 @@
 TEST_F(MoqtSessionTest, SubscribeAnnouncesLifeCycle) {
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
-  FullTrackName track_namespace("foo", "bar");
-  track_namespace.NameToNamespace();
+  TrackNamespace track_namespace("foo");
   bool got_callback = false;
   EXPECT_CALL(
       mock_stream_,
       Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnounces), _));
   session_.SubscribeAnnounces(
       track_namespace,
-      [&](const FullTrackName& ftn, std::optional<RequestErrorCode> error,
+      [&](const TrackNamespace& ns, std::optional<RequestErrorCode> error,
           absl::string_view reason) {
         got_callback = true;
-        EXPECT_EQ(track_namespace, ftn);
+        EXPECT_EQ(track_namespace, ns);
         EXPECT_FALSE(error.has_value());
         EXPECT_EQ(reason, "");
       },
@@ -1002,26 +1001,25 @@
 TEST_F(MoqtSessionTest, SubscribeAnnouncesError) {
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
-  FullTrackName track_namespace("foo", "bar");
-  track_namespace.NameToNamespace();
+  TrackNamespace track_namespace("foo");
   bool got_callback = false;
   EXPECT_CALL(
       mock_stream_,
       Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnounces), _));
   session_.SubscribeAnnounces(
       track_namespace,
-      [&](const FullTrackName& ftn, std::optional<RequestErrorCode> error,
+      [&](const TrackNamespace& ns, std::optional<RequestErrorCode> error,
           absl::string_view reason) {
         got_callback = true;
-        EXPECT_EQ(track_namespace, ftn);
+        EXPECT_EQ(track_namespace, ns);
         ASSERT_TRUE(error.has_value());
         EXPECT_EQ(*error, RequestErrorCode::kInvalidRange);
         EXPECT_EQ(reason, "deadbeef");
       },
       VersionSpecificParameters());
   MoqtSubscribeAnnouncesError error = {
-      /*track_namespace=*/track_namespace,
-      /*error_code=*/RequestErrorCode::kInvalidRange,
+      track_namespace,
+      RequestErrorCode::kInvalidRange,
       /*reason_phrase=*/"deadbeef",
   };
   stream_input->OnSubscribeAnnouncesErrorMessage(error);
@@ -2559,7 +2557,7 @@
 }
 
 TEST_F(MoqtSessionTest, IncomingSubscribeAnnounces) {
-  FullTrackName track_namespace = FullTrackName{"foo"};
+  TrackNamespace track_namespace = TrackNamespace{"foo"};
   auto parameters = std::make_optional<VersionSpecificParameters>(
       AuthTokenType::kOutOfBand, "foo");
   MoqtSubscribeAnnounces announces = {
@@ -2577,7 +2575,7 @@
       Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesOk), _));
   stream_input->OnSubscribeAnnouncesMessage(announces);
   MoqtUnsubscribeAnnounces unsubscribe_announces = {
-      /*track_namespace=*/FullTrackName{"foo"},
+      TrackNamespace{"foo"},
   };
   EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback,
               Call(track_namespace, std::optional<VersionSpecificParameters>()))
@@ -2586,7 +2584,7 @@
 }
 
 TEST_F(MoqtSessionTest, IncomingSubscribeAnnouncesWithError) {
-  FullTrackName track_namespace = FullTrackName{"foo"};
+  TrackNamespace track_namespace{"foo"};
   auto parameters = std::make_optional<VersionSpecificParameters>(
       AuthTokenType::kOutOfBand, "foo");
   MoqtSubscribeAnnounces announces = {
@@ -3129,18 +3127,18 @@
                                                &remote_track_visitor,
                                                VersionSpecificParameters()));
   EXPECT_FALSE(session_.SubscribeAnnounces(
-      FullTrackName{"foo"},
-      +[](FullTrackName /*track_namespace*/,
+      TrackNamespace{"foo"},
+      +[](TrackNamespace /*track_namespace*/,
           std::optional<RequestErrorCode> /*error*/,
           absl::string_view /*reason*/) {},
       VersionSpecificParameters()));
   session_.Announce(
-      FullTrackName{"foo"},
-      +[](FullTrackName /*track_namespace*/,
+      TrackNamespace{"foo"},
+      +[](TrackNamespace /*track_namespace*/,
           std::optional<MoqtAnnounceErrorReason> /*error*/) {},
       VersionSpecificParameters());
   EXPECT_FALSE(session_.Fetch(
-      FullTrackName{"foo", "bar"},
+      FullTrackName{TrackNamespace("foo"), "bar"},
       +[](std::unique_ptr<MoqtFetchTask> /*fetch_task*/) {}, Location(0, 0), 5,
       std::nullopt, 127, std::nullopt, VersionSpecificParameters()));
   // Error on additional GOAWAY.
@@ -3171,7 +3169,7 @@
   EXPECT_CALL(mock_stream_,
               Writev(ControlMessageOfType(MoqtMessageType::kAnnounceError), _));
   stream_input->OnAnnounceMessage(
-      MoqtAnnounce(FullTrackName("foo", "bar"), VersionSpecificParameters()));
+      MoqtAnnounce(TrackNamespace("foo"), VersionSpecificParameters()));
   EXPECT_CALL(mock_stream_,
               Writev(ControlMessageOfType(MoqtMessageType::kFetchError), _));
   MoqtFetch fetch = DefaultFetch();
@@ -3182,26 +3180,26 @@
       Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesError),
              _));
   stream_input->OnSubscribeAnnouncesMessage(
-      MoqtSubscribeAnnounces(FullTrackName("foo", "bar")));
+      MoqtSubscribeAnnounces(TrackNamespace("foo")));
   // Block all outgoing SUBSCRIBE, ANNOUNCE, GOAWAY,etc.
   EXPECT_CALL(mock_stream_, Writev).Times(0);
   MockSubscribeRemoteTrackVisitor remote_track_visitor;
-  EXPECT_FALSE(session_.SubscribeCurrentObject(FullTrackName("foo", "bar"),
-                                               &remote_track_visitor,
-                                               VersionSpecificParameters()));
+  EXPECT_FALSE(session_.SubscribeCurrentObject(
+      FullTrackName(TrackNamespace("foo"), "bar"), &remote_track_visitor,
+      VersionSpecificParameters()));
   EXPECT_FALSE(session_.SubscribeAnnounces(
-      FullTrackName{"foo"},
-      +[](FullTrackName /*track_namespace*/,
+      TrackNamespace{"foo"},
+      +[](TrackNamespace /*track_namespace*/,
           std::optional<RequestErrorCode> /*error*/,
           absl::string_view /*reason*/) {},
       VersionSpecificParameters()));
   session_.Announce(
-      FullTrackName{"foo"},
-      +[](FullTrackName /*track_namespace*/,
+      TrackNamespace{"foo"},
+      +[](TrackNamespace /*track_namespace*/,
           std::optional<MoqtAnnounceErrorReason> /*error*/) {},
       VersionSpecificParameters());
   EXPECT_FALSE(session_.Fetch(
-      FullTrackName{"foo", "bar"},
+      FullTrackName(TrackNamespace("foo"), "bar"),
       +[](std::unique_ptr<MoqtFetchTask> /*fetch_task*/) {}, Location(0, 0), 5,
       std::nullopt, 127, std::nullopt, VersionSpecificParameters()));
   session_.GoAway("");
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h
index cf243c9..6614417 100644
--- a/quiche/quic/moqt/test_tools/moqt_test_message.h
+++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -536,7 +536,7 @@
   MoqtSubscribe subscribe_ = {
       /*subscribe_id=*/1,
       /*track_alias=*/2,
-      /*full_track_name=*/FullTrackName({"foo", "abcd"}),
+      FullTrackName("foo", "abcd"),
       /*subscriber_priority=*/0x20,
       /*group_order=*/MoqtDeliveryOrder::kDescending,
       /*forward=*/true,
@@ -839,7 +839,7 @@
   };
 
   MoqtAnnounce announce_ = {
-      /*track_namespace=*/FullTrackName{"foo"},
+      TrackNamespace{"foo"},
       VersionSpecificParameters(AuthTokenType::kOutOfBand, "bar"),
   };
 };
@@ -872,7 +872,7 @@
   };
 
   MoqtAnnounceOk announce_ok_ = {
-      /*track_namespace=*/FullTrackName{"foo"},
+      TrackNamespace("foo"),
   };
 };
 
@@ -914,8 +914,8 @@
   };
 
   MoqtAnnounceError announce_error_ = {
-      /*track_namespace=*/FullTrackName{"foo"},
-      /*error_code=*/RequestErrorCode::kNotSupported,
+      TrackNamespace("foo"),
+      RequestErrorCode::kNotSupported,
       /*reason_phrase=*/"bar",
   };
 };
@@ -958,8 +958,8 @@
   };
 
   MoqtAnnounceCancel announce_cancel_ = {
-      /*track_namespace=*/FullTrackName{"foo"},
-      /*error_code=*/RequestErrorCode::kNotSupported,
+      TrackNamespace("foo"),
+      RequestErrorCode::kNotSupported,
       /*reason_phrase=*/"bar",
   };
 };
@@ -999,7 +999,7 @@
   };
 
   MoqtTrackStatusRequest track_status_request_ = {
-      /*full_track_name=*/FullTrackName({"foo", "abcd"}),
+      FullTrackName("foo", "abcd"),
       VersionSpecificParameters(AuthTokenType::kOutOfBand, "bar"),
   };
 };
@@ -1031,7 +1031,7 @@
   };
 
   MoqtUnannounce unannounce_ = {
-      /*track_namespace=*/FullTrackName{"foo"},
+      TrackNamespace("foo"),
   };
 };
 
@@ -1084,7 +1084,7 @@
   };
 
   MoqtTrackStatus track_status_ = {
-      /*full_track_name=*/FullTrackName({"foo", "abcd"}),
+      FullTrackName("foo", "abcd"),
       /*status_code=*/MoqtTrackStatusCode::kInProgress,
       /*last_group=*/12,
       /*last_object=*/20,
@@ -1157,7 +1157,7 @@
   };
 
   MoqtSubscribeAnnounces subscribe_namespace_ = {
-      /*track_namespace=*/FullTrackName{"foo"},
+      TrackNamespace("foo"),
       VersionSpecificParameters(AuthTokenType::kOutOfBand, "bar"),
   };
 };
@@ -1189,7 +1189,7 @@
   };
 
   MoqtSubscribeAnnouncesOk subscribe_namespace_ok_ = {
-      /*track_namespace=*/FullTrackName{"foo"},
+      TrackNamespace("foo"),
   };
 };
 
@@ -1231,7 +1231,7 @@
   };
 
   MoqtSubscribeAnnouncesError subscribe_namespace_error_ = {
-      /*track_namespace=*/FullTrackName{"foo"},
+      TrackNamespace("foo"),
       /*error_code=*/RequestErrorCode::kUnauthorized,
       /*reason_phrase=*/"bar",
   };
@@ -1264,7 +1264,7 @@
   };
 
   MoqtUnsubscribeAnnounces unsubscribe_namespace_ = {
-      /*track_namespace=*/FullTrackName{"foo"},
+      TrackNamespace("foo"),
   };
 };
 
@@ -1404,7 +1404,7 @@
       /*subscriber_priority=*/2,
       /*group_order=*/MoqtDeliveryOrder::kAscending,
       /*joining_fetch=*/std::optional<JoiningFetch>(),
-      /*full_track_name=*/FullTrackName{"foo", "bar"},
+      FullTrackName("foo", "bar"),
       /*start_object=*/Location{1, 2},
       /*end_group=*/5,
       /*end_object=*/6,
@@ -1503,7 +1503,7 @@
       /*group_order=*/MoqtDeliveryOrder::kAscending,
       /*joining_fetch=*/JoiningFetch{2, 2},
       /* the next four are ignored for joining fetches*/
-      /*full_track_name=*/FullTrackName{"foo", "bar"},
+      FullTrackName("foo", "bar"),
       /*start_object=*/Location{1, 2},
       /*end_group=*/5,
       /*end_object=*/6,
diff --git a/quiche/quic/moqt/tools/chat_client.cc b/quiche/quic/moqt/tools/chat_client.cc
index eb7ac99..f22ffda 100644
--- a/quiche/quic/moqt/tools/chat_client.cc
+++ b/quiche/quic/moqt/tools/chat_client.cc
@@ -39,7 +39,7 @@
 namespace moqt::moq_chat {
 
 std::optional<MoqtAnnounceErrorReason> ChatClient::OnIncomingAnnounce(
-    const moqt::FullTrackName& track_namespace,
+    const moqt::TrackNamespace& track_namespace,
     std::optional<VersionSpecificParameters> parameters) {
   if (track_namespace == GetUserNamespace(my_track_name_)) {
     // Ignore ANNOUNCE for my own track.
@@ -217,7 +217,7 @@
   publisher_.Add(queue_);
   session_->set_publisher(&publisher_);
   MoqtOutgoingAnnounceCallback announce_callback =
-      [this](FullTrackName track_namespace,
+      [this](TrackNamespace track_namespace,
              std::optional<MoqtAnnounceErrorReason> reason) {
         if (reason.has_value()) {
           std::cout << "ANNOUNCE rejected, " << reason->reason_phrase << "\n";
@@ -236,7 +236,7 @@
   // Send SUBSCRIBE_ANNOUNCE. Pop 3 levels of namespace to get to {moq-chat,
   // chat-id}
   MoqtOutgoingSubscribeAnnouncesCallback subscribe_announces_callback =
-      [this](FullTrackName track_namespace,
+      [this](TrackNamespace track_namespace,
              std::optional<RequestErrorCode> error, absl::string_view reason) {
         if (error.has_value()) {
           std::cout << "SUBSCRIBE_ANNOUNCES rejected, " << reason << "\n";
diff --git a/quiche/quic/moqt/tools/chat_client.h b/quiche/quic/moqt/tools/chat_client.h
index 90f8727..93d4ae5 100644
--- a/quiche/quic/moqt/tools/chat_client.h
+++ b/quiche/quic/moqt/tools/chat_client.h
@@ -127,7 +127,7 @@
   void RunEventLoop() { event_loop_->RunEventLoopOnce(kChatEventLoopDuration); }
   // Callback for incoming announces.
   std::optional<MoqtAnnounceErrorReason> OnIncomingAnnounce(
-      const moqt::FullTrackName& track_namespace,
+      const moqt::TrackNamespace& track_namespace,
       std::optional<VersionSpecificParameters> parameters);
 
   // Basic session information
diff --git a/quiche/quic/moqt/tools/chat_server.cc b/quiche/quic/moqt/tools/chat_server.cc
index 08bcd62..c3d9b74 100644
--- a/quiche/quic/moqt/tools/chat_server.cc
+++ b/quiche/quic/moqt/tools/chat_server.cc
@@ -26,7 +26,7 @@
 
 std::optional<MoqtAnnounceErrorReason>
 ChatServer::ChatServerSessionHandler::OnIncomingAnnounce(
-    const moqt::FullTrackName& track_namespace,
+    const moqt::TrackNamespace& track_namespace,
     std::optional<VersionSpecificParameters> parameters) {
   if (track_name_.has_value() &&
       GetUserNamespace(*track_name_) != track_namespace) {
@@ -58,7 +58,7 @@
 }
 
 void ChatServer::ChatServerSessionHandler::OnOutgoingAnnounceReply(
-    FullTrackName track_namespace,
+    TrackNamespace track_namespace,
     std::optional<MoqtAnnounceErrorReason> error_message) {
   // Log the result; the server doesn't really care.
   std::cout << "ANNOUNCE for " << track_namespace.ToString();
@@ -83,7 +83,7 @@
         }
       };
   session_->callbacks().incoming_subscribe_announces_callback =
-      [this](const moqt::FullTrackName& chat_namespace,
+      [this](const moqt::TrackNamespace& chat_namespace,
              std::optional<VersionSpecificParameters> parameters) {
         if (parameters.has_value()) {
           subscribed_namespaces_.insert(chat_namespace);
@@ -198,10 +198,8 @@
   user_queues_[track_name] = std::make_shared<MoqtLiveRelayQueue>(
       track_name, MoqtForwardingPreference::kSubgroup);
   publisher_.Add(user_queues_[track_name]);
-  FullTrackName track_namespace = track_name;
-  track_namespace.NameToNamespace();
   for (auto& session : sessions_) {
-    session.AnnounceIfSubscribed(track_namespace);
+    session.AnnounceIfSubscribed(track_name.track_namespace());
   }
 }
 
@@ -213,7 +211,7 @@
   user_queues_[track_name]->RemoveAllSubscriptions();
   user_queues_.erase(track_name);
   publisher_.Delete(track_name);
-  FullTrackName track_namespace = GetUserNamespace(track_name);
+  TrackNamespace track_namespace = GetUserNamespace(track_name);
   for (auto& session : sessions_) {
     session.UnannounceIfSubscribed(track_namespace);
   }
diff --git a/quiche/quic/moqt/tools/chat_server.h b/quiche/quic/moqt/tools/chat_server.h
index d8c8731..90e83e9 100644
--- a/quiche/quic/moqt/tools/chat_server.h
+++ b/quiche/quic/moqt/tools/chat_server.h
@@ -64,8 +64,9 @@
       it_ = it;
     }
 
-    void AnnounceIfSubscribed(FullTrackName track_namespace) {
-      for (const FullTrackName& subscribed_namespace : subscribed_namespaces_) {
+    void AnnounceIfSubscribed(TrackNamespace track_namespace) {
+      for (const TrackNamespace& subscribed_namespace :
+           subscribed_namespaces_) {
         if (track_namespace.InNamespace(subscribed_namespace)) {
           session_->Announce(
               track_namespace,
@@ -78,8 +79,9 @@
       }
     }
 
-    void UnannounceIfSubscribed(FullTrackName track_namespace) {
-      for (const FullTrackName& subscribed_namespace : subscribed_namespaces_) {
+    void UnannounceIfSubscribed(TrackNamespace track_namespace) {
+      for (const TrackNamespace& subscribed_namespace :
+           subscribed_namespaces_) {
         if (track_namespace.InNamespace(subscribed_namespace)) {
           session_->Unannounce(track_namespace);
           return;
@@ -90,10 +92,10 @@
    private:
     // Callback for incoming announces.
     std::optional<MoqtAnnounceErrorReason> OnIncomingAnnounce(
-        const moqt::FullTrackName& track_namespace,
+        const moqt::TrackNamespace& track_namespace,
         std::optional<VersionSpecificParameters> parameters);
     void OnOutgoingAnnounceReply(
-        FullTrackName track_namespace,
+        TrackNamespace track_namespace,
         std::optional<MoqtAnnounceErrorReason> error_message);
 
     MoqtSession* session_;  // Not owned.
@@ -101,7 +103,7 @@
     // in theory there could be multiple users on one session.
     std::optional<FullTrackName> track_name_;
     ChatServer* server_;  // Not owned.
-    absl::flat_hash_set<FullTrackName> subscribed_namespaces_;
+    absl::flat_hash_set<TrackNamespace> subscribed_namespaces_;
     // The iterator of this entry in ChatServer::sessions_, so it can destroy
     // itself later.
     std::list<ChatServerSessionHandler>::const_iterator it_;
diff --git a/quiche/quic/moqt/tools/moq_chat.cc b/quiche/quic/moqt/tools/moq_chat.cc
index 0ec5b64..ddf349c 100644
--- a/quiche/quic/moqt/tools/moq_chat.cc
+++ b/quiche/quic/moqt/tools/moq_chat.cc
@@ -17,12 +17,12 @@
 
 bool IsValidPath(absl::string_view path) { return path == kWebtransPath; }
 
-bool IsValidNamespace(const FullTrackName& track_namespace) {
-  return track_namespace.tuple().size() == kFullPathLength - 1 &&
+bool IsValidNamespace(const TrackNamespace& track_namespace) {
+  return track_namespace.number_of_elements() == kFullPathLength - 1 &&
          track_namespace.tuple()[0] == kBasePath;
 }
 
-bool IsValidChatNamespace(const FullTrackName& track_namespace) {
+bool IsValidChatNamespace(const TrackNamespace& track_namespace) {
   return track_namespace.tuple().size() == 2 &&
          track_namespace.tuple()[0] == kBasePath;
 }
@@ -30,47 +30,50 @@
 FullTrackName ConstructTrackName(absl::string_view chat_id,
                                  absl::string_view username,
                                  absl::string_view device_id) {
-  return FullTrackName{kBasePath,
-                       chat_id,
-                       username,
-                       device_id,
-                       absl::StrCat(ToUnixSeconds(::absl::Now())),
-                       kNameField};
+  return FullTrackName(
+      TrackNamespace({kBasePath, chat_id, username, device_id,
+                      absl::StrCat(ToUnixSeconds(::absl::Now()))}),
+      kNameField);
 }
 
 std::optional<FullTrackName> ConstructTrackNameFromNamespace(
-    const FullTrackName& track_namespace, absl::string_view chat_id) {
-  if (track_namespace.tuple().size() != kFullPathLength - 1) {
+    const TrackNamespace& track_namespace, absl::string_view chat_id) {
+  if (track_namespace.number_of_elements() != kFullPathLength - 1) {
     return std::nullopt;
   }
   if (track_namespace.tuple()[0] != kBasePath ||
       track_namespace.tuple()[1] != chat_id) {
     return std::nullopt;
   }
-  FullTrackName track_name = track_namespace;
-  track_name.AddElement(kNameField);
-  return track_name;
+  return FullTrackName(track_namespace, kNameField);
 }
 
+absl::string_view GetUsername(const TrackNamespace& track_namespace) {
+  QUICHE_DCHECK(track_namespace.number_of_elements() > 2);
+  return track_namespace.tuple()[2];
+}
 absl::string_view GetUsername(const FullTrackName& track_name) {
-  QUICHE_DCHECK(track_name.tuple().size() > 2);
-  return track_name.tuple()[2];
+  return GetUsername(track_name.track_namespace());
 }
 
+absl::string_view GetChatId(const TrackNamespace& track_namespace) {
+  QUICHE_DCHECK(track_namespace.number_of_elements() > 1);
+  return track_namespace.tuple()[1];
+}
 absl::string_view GetChatId(const FullTrackName& track_name) {
-  QUICHE_DCHECK(track_name.tuple().size() > 1);
-  return track_name.tuple()[1];
+  return GetChatId(track_name.track_namespace());
 }
 
-FullTrackName GetUserNamespace(const FullTrackName& track_name) {
-  QUICHE_DCHECK(track_name.tuple().size() == kFullPathLength);
-  FullTrackName track_namespace = track_name;
-  track_namespace.NameToNamespace();
-  return track_namespace;
+const TrackNamespace& GetUserNamespace(const FullTrackName& track_name) {
+  return track_name.track_namespace();
 }
 
-FullTrackName GetChatNamespace(const FullTrackName& track_name) {
-  return FullTrackName{track_name.tuple()[0], track_name.tuple()[1]};
+TrackNamespace GetChatNamespace(const TrackNamespace& track_namespace) {
+  return TrackNamespace(
+      {track_namespace.tuple()[0], track_namespace.tuple()[1]});
+}
+TrackNamespace GetChatNamespace(const FullTrackName& track_name) {
+  return GetChatNamespace(track_name.track_namespace());
 }
 
 }  // namespace moqt::moq_chat
diff --git a/quiche/quic/moqt/tools/moq_chat.h b/quiche/quic/moqt/tools/moq_chat.h
index 02f23e4..3478b8b 100644
--- a/quiche/quic/moqt/tools/moq_chat.h
+++ b/quiche/quic/moqt/tools/moq_chat.h
@@ -30,8 +30,8 @@
 // Verifies that the WebTransport path matches the spec.
 bool IsValidPath(absl::string_view path);
 
-bool IsValidTrackNamespace(const FullTrackName& track_namespace);
-bool IsValidChatNamespace(const FullTrackName& track_namespace);
+bool IsValidTrackNamespace(const TrackNamespace& track_namespace);
+bool IsValidChatNamespace(const TrackNamespace& track_namespace);
 
 // Given a chat-id and username, returns a full track name for moq-chat.
 FullTrackName ConstructTrackName(absl::string_view chat_id,
@@ -42,16 +42,19 @@
 // is syntactically incorrect, or does not match the expected value of
 // |chat-id|, returns nullopt
 std::optional<FullTrackName> ConstructTrackNameFromNamespace(
-    const FullTrackName& track_namespace, absl::string_view chat_id);
+    const TrackNamespace& track_namespace, absl::string_view chat_id);
 
 // Strips "chat" from the end of |track_name| to use in ANNOUNCE.
-FullTrackName GetUserNamespace(const FullTrackName& track_name);
+const TrackNamespace& GetUserNamespace(const FullTrackName& track_name);
 
 // Returns {"moq-chat", chat-id}, useful for SUBSCRIBE_ANNOUNCES.
-FullTrackName GetChatNamespace(const FullTrackName& track_name);
+TrackNamespace GetChatNamespace(const TrackNamespace& track_name);
+TrackNamespace GetChatNamespace(const FullTrackName& track_name);
 
+absl::string_view GetUsername(const TrackNamespace& track_namespace);
 absl::string_view GetUsername(const FullTrackName& track_name);
 
+absl::string_view GetChatId(const TrackNamespace& track_namespace);
 absl::string_view GetChatId(const FullTrackName& track_name);
 
 }  // namespace moq_chat
diff --git a/quiche/quic/moqt/tools/moq_chat_test.cc b/quiche/quic/moqt/tools/moq_chat_test.cc
index d402054..0579f94 100644
--- a/quiche/quic/moqt/tools/moq_chat_test.cc
+++ b/quiche/quic/moqt/tools/moq_chat_test.cc
@@ -26,42 +26,38 @@
   EXPECT_EQ(GetChatId(name), "chat-id");
   EXPECT_EQ(GetUsername(name), "user");
   // Check that the namespace passes validation.
-  name.NameToNamespace();
-  EXPECT_TRUE(ConstructTrackNameFromNamespace(name, "chat-id").has_value());
+  EXPECT_TRUE(ConstructTrackNameFromNamespace(GetUserNamespace(name), "chat-id")
+                  .has_value());
 }
 
 TEST_F(MoqChatTest, InvalidNamespace) {
-  FullTrackName track_namespace{kBasePath, "chat-id", "username", "device",
-                                "timestamp"};
+  TrackNamespace track_namespace(
+      {kBasePath, "chat-id", "username", "device", "timestamp"});
   // Wrong chat ID.
   EXPECT_FALSE(
       ConstructTrackNameFromNamespace(track_namespace, "chat-id2").has_value());
-  // Namespace includes name
-  track_namespace.AddElement("chat");
-  EXPECT_FALSE(
-      ConstructTrackNameFromNamespace(track_namespace, "chat-id").has_value());
-  track_namespace.NameToNamespace();  // Restore to correct value.
   // Namespace too short.
-  track_namespace.NameToNamespace();
+  TrackNamespace short_base_path({"moq-chat2", "chat-id", "user", "device"});
   EXPECT_FALSE(
-      ConstructTrackNameFromNamespace(track_namespace, "chat-id").has_value());
+      ConstructTrackNameFromNamespace(short_base_path, "chat-id").has_value());
   track_namespace.AddElement("chat");  // Restore to correct value.
   // Base Path is wrong.
-  FullTrackName bad_base_path{"moq-chat2", "chat-id", "user", "device",
-                              "timestamp"};
+  TrackNamespace bad_base_path(
+      {"moq-chat2", "chat-id", "user", "device", "timestamp"});
   EXPECT_FALSE(
       ConstructTrackNameFromNamespace(bad_base_path, "chat-id").has_value());
 }
 
 TEST_F(MoqChatTest, Queries) {
-  FullTrackName local_name{kBasePath, "chat-id",   "user",
-                           "device",  "timestamp", kNameField};
+  FullTrackName local_name(
+      TrackNamespace({kBasePath, "chat-id", "user", "device", "timestamp"}),
+      kNameField);
   EXPECT_EQ(GetChatId(local_name), "chat-id");
   EXPECT_EQ(GetUsername(local_name), "user");
-  FullTrackName track_namespace{"moq-chat", "chat-id", "user", "device",
-                                "timestamp"};
+  TrackNamespace track_namespace(
+      {"moq-chat", "chat-id", "user", "device", "timestamp"});
   EXPECT_EQ(GetUserNamespace(local_name), track_namespace);
-  FullTrackName chat_namespace{"moq-chat", "chat-id"};
+  TrackNamespace chat_namespace({kBasePath, "chat-id"});
   EXPECT_EQ(GetChatNamespace(local_name), chat_namespace);
 }
 
diff --git a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
index 4b4aefc..acc64a0 100644
--- a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
+++ b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
@@ -82,7 +82,7 @@
   return absl::ascii_isalnum(c) || c == '-' || c == '_';
 }
 
-bool IsValidTrackNamespace(FullTrackName track_namespace) {
+bool IsValidTrackNamespace(TrackNamespace track_namespace) {
   for (const auto& element : track_namespace.tuple()) {
     if (!absl::c_all_of(element, IsValidTrackNamespaceChar)) {
       return false;
@@ -91,8 +91,8 @@
   return true;
 }
 
-FullTrackName CleanUpTrackNamespace(FullTrackName track_namespace) {
-  FullTrackName output;
+TrackNamespace CleanUpTrackNamespace(TrackNamespace track_namespace) {
+  TrackNamespace output;
   for (auto& it : track_namespace.tuple()) {
     std::string element = it;
     for (char& c : element) {
@@ -117,7 +117,7 @@
 
   // TODO(martinduke): Handle when |announce| is false (UNANNOUNCE).
   std::optional<MoqtAnnounceErrorReason> OnAnnounceReceived(
-      FullTrackName track_namespace,
+      TrackNamespace track_namespace,
       std::optional<VersionSpecificParameters> /*parameters*/) {
     if (!IsValidTrackNamespace(track_namespace) &&
         !quiche::GetQuicheCommandLineFlag(
@@ -153,8 +153,7 @@
     std::vector<absl::string_view> tracks_to_subscribe =
         absl::StrSplit(track_list, ',', absl::AllowEmpty());
     for (absl::string_view track : tracks_to_subscribe) {
-      FullTrackName full_track_name = track_namespace;
-      full_track_name.AddElement(track);
+      FullTrackName full_track_name(track_namespace, track);
       session_->JoiningFetch(full_track_name, &it->second, 0,
                              VersionSpecificParameters());
     }
@@ -185,8 +184,9 @@
                           MoqtPriority /*publisher_priority*/,
                           MoqtObjectStatus /*status*/, absl::string_view object,
                           bool /*end_of_message*/) override {
-      std::string file_name = absl::StrCat(sequence.group, "-", sequence.object,
-                                           ".", full_track_name.tuple().back());
+      std::string file_name =
+          absl::StrCat(sequence.group, "-", sequence.object, ".",
+                       full_track_name.track_namespace().tuple().back());
       std::string file_path = quiche::JoinPath(directory_, file_name);
       std::ofstream output(file_path, std::ios::binary | std::ios::ate);
       output.write(object.data(), object.size());
@@ -201,7 +201,7 @@
 
   MoqtSession* session_;  // Not owned.
   std::string output_root_;
-  absl::node_hash_map<FullTrackName, NamespaceHandler> subscribed_namespaces_;
+  absl::node_hash_map<TrackNamespace, NamespaceHandler> subscribed_namespaces_;
 };
 
 absl::StatusOr<MoqtConfigureSessionCallback> IncomingSessionHandler(
diff --git a/quiche/quic/moqt/tools/moqt_mock_visitor.h b/quiche/quic/moqt/tools/moqt_mock_visitor.h
index 3b910ee..d45c99a 100644
--- a/quiche/quic/moqt/tools/moqt_mock_visitor.h
+++ b/quiche/quic/moqt/tools/moqt_mock_visitor.h
@@ -31,10 +31,10 @@
   testing::MockFunction<void(absl::string_view)> session_terminated_callback;
   testing::MockFunction<void()> session_deleted_callback;
   testing::MockFunction<std::optional<MoqtAnnounceErrorReason>(
-      const FullTrackName&, std::optional<VersionSpecificParameters>)>
+      const TrackNamespace&, std::optional<VersionSpecificParameters>)>
       incoming_announce_callback;
   testing::MockFunction<std::optional<MoqtSubscribeErrorReason>(
-      FullTrackName, std::optional<VersionSpecificParameters>)>
+      TrackNamespace, std::optional<VersionSpecificParameters>)>
       incoming_subscribe_announces_callback;
 
   MockSessionCallbacks() {