Update MoQT version to draft-13.

Adopt new TRACK_STATUS/OK/ERROR framework -- messages are exactly like SUBSCRIBE.

This change ended up propagating into the TrackPublisher/Session interface, where specific enums for Status codes are gone. APIs for retrieving track information are now safe if the data is being retrieved upstream.

PiperOrigin-RevId: 794588585
diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc
index 15a00d2..c70164c 100644
--- a/quiche/quic/moqt/moqt_framer.cc
+++ b/quiche/quic/moqt/moqt_framer.cc
@@ -399,7 +399,7 @@
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeSubscribe(
-    const MoqtSubscribe& message) {
+    const MoqtSubscribe& message, MoqtMessageType message_type) {
   KeyValuePairList parameters;
   VersionSpecificParametersToKeyValuePairList(message.parameters, parameters);
   if (!ValidateVersionSpecificParameters(parameters,
@@ -434,7 +434,7 @@
       return quiche::QuicheBuffer();
   }
   return SerializeControlMessage(
-      MoqtMessageType::kSubscribe, WireVarInt62(message.request_id),
+      message_type, WireVarInt62(message.request_id),
       WireFullTrackName(message.full_track_name),
       WireUint8(message.subscriber_priority),
       WireDeliveryOrder(message.group_order), WireBoolean(message.forward),
@@ -445,7 +445,7 @@
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeSubscribeOk(
-    const MoqtSubscribeOk& message) {
+    const MoqtSubscribeOk& message, MoqtMessageType message_type) {
   KeyValuePairList parameters;
   VersionSpecificParametersToKeyValuePairList(message.parameters, parameters);
   if (!ValidateVersionSpecificParameters(parameters,
@@ -456,7 +456,7 @@
   }
   if (message.largest_location.has_value()) {
     return SerializeControlMessage(
-        MoqtMessageType::kSubscribeOk, WireVarInt62(message.request_id),
+        message_type, WireVarInt62(message.request_id),
         WireVarInt62(message.track_alias),
         WireVarInt62(message.expires.ToMilliseconds()),
         WireDeliveryOrder(message.group_order), WireUint8(1),
@@ -464,18 +464,18 @@
         WireVarInt62(message.largest_location->object),
         WireKeyValuePairList(parameters));
   }
-  return SerializeControlMessage(
-      MoqtMessageType::kSubscribeOk, WireVarInt62(message.request_id),
-      WireVarInt62(message.track_alias),
-      WireVarInt62(message.expires.ToMilliseconds()),
-      WireDeliveryOrder(message.group_order), WireUint8(0),
-      WireKeyValuePairList(parameters));
+  return SerializeControlMessage(message_type, WireVarInt62(message.request_id),
+                                 WireVarInt62(message.track_alias),
+                                 WireVarInt62(message.expires.ToMilliseconds()),
+                                 WireDeliveryOrder(message.group_order),
+                                 WireUint8(0),
+                                 WireKeyValuePairList(parameters));
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeSubscribeError(
-    const MoqtSubscribeError& message) {
+    const MoqtSubscribeError& message, MoqtMessageType message_type) {
   return SerializeControlMessage(
-      MoqtMessageType::kSubscribeError, WireVarInt62(message.request_id),
+      message_type, WireVarInt62(message.request_id),
       WireVarInt62(message.error_code),
       WireStringWithVarInt62Length(message.reason_phrase));
 }
@@ -558,38 +558,19 @@
       WireStringWithVarInt62Length(message.error_reason));
 }
 
-quiche::QuicheBuffer MoqtFramer::SerializeTrackStatusRequest(
-    const MoqtTrackStatusRequest& message) {
-  KeyValuePairList parameters;
-  VersionSpecificParametersToKeyValuePairList(message.parameters, parameters);
-  if (!ValidateVersionSpecificParameters(
-          parameters, MoqtMessageType::kTrackStatusRequest)) {
-    QUICHE_BUG(QUICHE_BUG_invalid_parameters)
-        << "Serializing invalid MoQT parameters";
-    return quiche::QuicheBuffer();
-  }
-  return SerializeControlMessage(MoqtMessageType::kTrackStatusRequest,
-                                 WireVarInt62(message.request_id),
-                                 WireFullTrackName(message.full_track_name),
-                                 WireKeyValuePairList(parameters));
-}
-
 quiche::QuicheBuffer MoqtFramer::SerializeTrackStatus(
     const MoqtTrackStatus& message) {
-  KeyValuePairList parameters;
-  VersionSpecificParametersToKeyValuePairList(message.parameters, parameters);
-  if (!ValidateVersionSpecificParameters(parameters,
-                                         MoqtMessageType::kTrackStatus)) {
-    QUICHE_BUG(QUICHE_BUG_invalid_parameters)
-        << "Serializing invalid MoQT parameters";
-    return quiche::QuicheBuffer();
-  }
-  return SerializeControlMessage(MoqtMessageType::kTrackStatus,
-                                 WireVarInt62(message.request_id),
-                                 WireVarInt62(message.status_code),
-                                 WireVarInt62(message.largest_location.group),
-                                 WireVarInt62(message.largest_location.object),
-                                 WireKeyValuePairList(parameters));
+  return SerializeSubscribe(message, MoqtMessageType::kTrackStatus);
+}
+
+quiche::QuicheBuffer MoqtFramer::SerializeTrackStatusOk(
+    const MoqtTrackStatusOk& message) {
+  return SerializeSubscribeOk(message, MoqtMessageType::kTrackStatusOk);
+}
+
+quiche::QuicheBuffer MoqtFramer::SerializeTrackStatusError(
+    const MoqtTrackStatusError& message) {
+  return SerializeSubscribeError(message, MoqtMessageType::kTrackStatusError);
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeGoAway(const MoqtGoAway& message) {
diff --git a/quiche/quic/moqt/moqt_framer.h b/quiche/quic/moqt/moqt_framer.h
index b053255..650d75e 100644
--- a/quiche/quic/moqt/moqt_framer.h
+++ b/quiche/quic/moqt/moqt_framer.h
@@ -39,10 +39,15 @@
   quiche::QuicheBuffer SerializeClientSetup(const MoqtClientSetup& message);
   quiche::QuicheBuffer SerializeServerSetup(const MoqtServerSetup& message);
   // Returns an empty buffer if there is an illegal combination of locations.
-  quiche::QuicheBuffer SerializeSubscribe(const MoqtSubscribe& message);
-  quiche::QuicheBuffer SerializeSubscribeOk(const MoqtSubscribeOk& message);
+  quiche::QuicheBuffer SerializeSubscribe(
+      const MoqtSubscribe& message,
+      MoqtMessageType message_type = MoqtMessageType::kSubscribe);
+  quiche::QuicheBuffer SerializeSubscribeOk(
+      const MoqtSubscribeOk& message,
+      MoqtMessageType message_type = MoqtMessageType::kSubscribeOk);
   quiche::QuicheBuffer SerializeSubscribeError(
-      const MoqtSubscribeError& message);
+      const MoqtSubscribeError& message,
+      MoqtMessageType message_type = MoqtMessageType::kSubscribeError);
   quiche::QuicheBuffer SerializeUnsubscribe(const MoqtUnsubscribe& message);
   quiche::QuicheBuffer SerializeSubscribeDone(const MoqtSubscribeDone& message);
   quiche::QuicheBuffer SerializeSubscribeUpdate(
@@ -53,9 +58,10 @@
   quiche::QuicheBuffer SerializeUnannounce(const MoqtUnannounce& message);
   quiche::QuicheBuffer SerializeAnnounceCancel(
       const MoqtAnnounceCancel& message);
-  quiche::QuicheBuffer SerializeTrackStatusRequest(
-      const MoqtTrackStatusRequest& message);
   quiche::QuicheBuffer SerializeTrackStatus(const MoqtTrackStatus& message);
+  quiche::QuicheBuffer SerializeTrackStatusOk(const MoqtTrackStatusOk& message);
+  quiche::QuicheBuffer SerializeTrackStatusError(
+      const MoqtTrackStatusError& message);
   quiche::QuicheBuffer SerializeGoAway(const MoqtGoAway& message);
   quiche::QuicheBuffer SerializeSubscribeNamespace(
       const MoqtSubscribeNamespace& message);
diff --git a/quiche/quic/moqt/moqt_framer_test.cc b/quiche/quic/moqt/moqt_framer_test.cc
index 1d9d547..2da7139 100644
--- a/quiche/quic/moqt/moqt_framer_test.cc
+++ b/quiche/quic/moqt/moqt_framer_test.cc
@@ -39,13 +39,14 @@
       MoqtMessageType::kSubscribeError,
       MoqtMessageType::kUnsubscribe,
       MoqtMessageType::kSubscribeDone,
-      MoqtMessageType::kAnnounceCancel,
-      MoqtMessageType::kTrackStatusRequest,
-      MoqtMessageType::kTrackStatus,
       MoqtMessageType::kAnnounce,
       MoqtMessageType::kAnnounceOk,
       MoqtMessageType::kAnnounceError,
       MoqtMessageType::kUnannounce,
+      MoqtMessageType::kAnnounceCancel,
+      MoqtMessageType::kTrackStatus,
+      MoqtMessageType::kTrackStatusOk,
+      MoqtMessageType::kTrackStatusError,
       MoqtMessageType::kGoAway,
       MoqtMessageType::kSubscribeNamespace,
       MoqtMessageType::kSubscribeNamespaceOk,
@@ -150,22 +151,26 @@
         auto data = std::get<MoqtAnnounceError>(structured_data);
         return framer_.SerializeAnnounceError(data);
       }
-      case moqt::MoqtMessageType::kAnnounceCancel: {
-        auto data = std::get<MoqtAnnounceCancel>(structured_data);
-        return framer_.SerializeAnnounceCancel(data);
-      }
-      case moqt::MoqtMessageType::kTrackStatusRequest: {
-        auto data = std::get<MoqtTrackStatusRequest>(structured_data);
-        return framer_.SerializeTrackStatusRequest(data);
-      }
       case MoqtMessageType::kUnannounce: {
         auto data = std::get<MoqtUnannounce>(structured_data);
         return framer_.SerializeUnannounce(data);
       }
+      case moqt::MoqtMessageType::kAnnounceCancel: {
+        auto data = std::get<MoqtAnnounceCancel>(structured_data);
+        return framer_.SerializeAnnounceCancel(data);
+      }
       case moqt::MoqtMessageType::kTrackStatus: {
         auto data = std::get<MoqtTrackStatus>(structured_data);
         return framer_.SerializeTrackStatus(data);
       }
+      case moqt::MoqtMessageType::kTrackStatusOk: {
+        auto data = std::get<MoqtTrackStatusOk>(structured_data);
+        return framer_.SerializeTrackStatusOk(data);
+      }
+      case moqt::MoqtMessageType::kTrackStatusError: {
+        auto data = std::get<MoqtTrackStatusError>(structured_data);
+        return framer_.SerializeTrackStatusError(data);
+      }
       case moqt::MoqtMessageType::kGoAway: {
         auto data = std::get<MoqtGoAway>(structured_data);
         return framer_.SerializeGoAway(data);
diff --git a/quiche/quic/moqt/moqt_integration_test.cc b/quiche/quic/moqt/moqt_integration_test.cc
index 3325c2e..8c6b55c 100644
--- a/quiche/quic/moqt/moqt_integration_test.cc
+++ b/quiche/quic/moqt/moqt_integration_test.cc
@@ -510,6 +510,10 @@
   MockSubscribeRemoteTrackVisitor client_visitor;
   std::optional<absl::string_view> expected_reason = std::nullopt;
   bool received_ok = false;
+  ON_CALL(*track_publisher, expiration)
+      .WillByDefault(Return(quic::QuicTimeDelta::Zero()));
+  ON_CALL(*track_publisher, delivery_order)
+      .WillByDefault(Return(MoqtDeliveryOrder::kAscending));
   EXPECT_CALL(*track_publisher, AddObjectListener)
       .WillOnce([&](MoqtObjectListener* listener) {
         listener->OnSubscribeAccepted();
@@ -536,6 +540,10 @@
   MockSubscribeRemoteTrackVisitor client_visitor;
   std::optional<absl::string_view> expected_reason = std::nullopt;
   bool received_ok = false;
+  ON_CALL(*track_publisher, expiration)
+      .WillByDefault(Return(quic::QuicTimeDelta::Zero()));
+  ON_CALL(*track_publisher, delivery_order)
+      .WillByDefault(Return(MoqtDeliveryOrder::kAscending));
   EXPECT_CALL(*track_publisher, AddObjectListener)
       .WillOnce([&](MoqtObjectListener* listener) {
         listener->OnSubscribeAccepted();
@@ -562,6 +570,10 @@
   MockSubscribeRemoteTrackVisitor client_visitor;
   std::optional<absl::string_view> expected_reason = std::nullopt;
   bool received_ok = false;
+  ON_CALL(*track_publisher, expiration)
+      .WillByDefault(Return(quic::QuicTimeDelta::Zero()));
+  ON_CALL(*track_publisher, delivery_order)
+      .WillByDefault(Return(MoqtDeliveryOrder::kAscending));
   EXPECT_CALL(*track_publisher, AddObjectListener)
       .WillOnce([&](MoqtObjectListener* listener) {
         listener->OnSubscribeAccepted();
@@ -597,7 +609,8 @@
   MoqtKnownTrackPublisher publisher;
   server_->session()->set_publisher(&publisher);
   auto queue = std::make_shared<MoqtLiveRelayQueue>(
-      full_track_name, MoqtForwardingPreference::kSubgroup);
+      full_track_name, MoqtForwardingPreference::kSubgroup,
+      MoqtDeliveryOrder::kAscending, quic::QuicTime::Infinite());
   publisher.Add(queue);
 
   MockSubscribeRemoteTrackVisitor client_visitor;
@@ -669,6 +682,10 @@
 
   VersionSpecificParameters parameters;
   parameters.oack_window_size = quic::QuicTimeDelta::FromMilliseconds(100);
+  ON_CALL(*track_publisher, expiration)
+      .WillByDefault(Return(quic::QuicTimeDelta::Zero()));
+  ON_CALL(*track_publisher, delivery_order)
+      .WillByDefault(Return(MoqtDeliveryOrder::kAscending));
   client_->session()->SubscribeCurrentObject(full_track_name, &client_visitor,
                                              parameters);
   EXPECT_CALL(monitoring, OnObjectAckSupportKnown(parameters.oack_window_size));
@@ -694,6 +711,7 @@
   server_->session()->set_publisher(&publisher);
   auto queue = std::make_shared<MoqtLiveRelayQueue>(
       full_track_name, MoqtForwardingPreference::kSubgroup,
+      MoqtDeliveryOrder::kAscending, quic::QuicTime::Infinite(),
       test_harness_.simulator().GetClock());
   auto track_publisher = std::make_shared<MockTrackPublisher>(full_track_name);
   publisher.Add(queue);
@@ -743,6 +761,7 @@
   server_->session()->UseAlternateDeliveryTimeout();
   auto queue = std::make_shared<MoqtLiveRelayQueue>(
       full_track_name, MoqtForwardingPreference::kSubgroup,
+      MoqtDeliveryOrder::kAscending, quic::QuicTime::Infinite(),
       test_harness_.simulator().GetClock());
   auto track_publisher = std::make_shared<MockTrackPublisher>(full_track_name);
   publisher.Add(queue);
@@ -755,6 +774,10 @@
   VersionSpecificParameters parameters;
   // Set delivery timeout to ~ 1 RTT: any loss is fatal.
   parameters.delivery_timeout = quic::QuicTimeDelta::FromMilliseconds(100);
+  ON_CALL(*track_publisher, expiration)
+      .WillByDefault(Return(quic::QuicTimeDelta::Zero()));
+  ON_CALL(*track_publisher, delivery_order)
+      .WillByDefault(Return(MoqtDeliveryOrder::kAscending));
   client_->session()->SubscribeCurrentObject(full_track_name, &client_visitor,
                                              parameters);
   bool success =
diff --git a/quiche/quic/moqt/moqt_live_relay_queue.cc b/quiche/quic/moqt/moqt_live_relay_queue.cc
index 3468192..050a740 100644
--- a/quiche/quic/moqt/moqt_live_relay_queue.cc
+++ b/quiche/quic/moqt/moqt_live_relay_queue.cc
@@ -7,16 +7,12 @@
 #include <cstdint>
 #include <memory>
 #include <optional>
-#include <vector>
 
 #include "absl/base/attributes.h"
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "quiche/quic/moqt/moqt_cached_object.h"
 #include "quiche/quic/moqt/moqt_messages.h"
-#include "quiche/quic/moqt/moqt_priority.h"
 #include "quiche/quic/moqt/moqt_publisher.h"
-#include "quiche/quic/moqt/moqt_subscribe_windows.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/quiche_buffer_allocator.h"
 #include "quiche/common/quiche_callbacks.h"
@@ -27,11 +23,9 @@
 namespace moqt {
 
 bool MoqtLiveRelayQueue::AddFin(Location sequence, uint64_t subgroup) {
-  switch (forwarding_preference_) {
-    case MoqtForwardingPreference::kDatagram:
-      return false;
-    case MoqtForwardingPreference::kSubgroup:
-      break;
+  if (!forwarding_preference_.has_value() ||
+      *forwarding_preference_ == MoqtForwardingPreference::kDatagram) {
+    return false;
   }
   auto group_it = queue_.find(sequence.group);
   if (group_it == queue_.end()) {
@@ -39,8 +33,7 @@
     return false;
   }
   Group& group = group_it->second;
-  auto subgroup_it =
-      group.subgroups.find(SubgroupPriority{publisher_priority_, subgroup});
+  auto subgroup_it = group.subgroups.find(subgroup);
   if (subgroup_it == group.subgroups.end()) {
     // Subgroup does not exist.
     return false;
@@ -61,29 +54,27 @@
 }
 
 bool MoqtLiveRelayQueue::OnStreamReset(
-    Location sequence, uint64_t subgroup_id,
+    uint64_t group_id, uint64_t subgroup_id,
     webtransport::StreamErrorCode error_code) {
-  switch (forwarding_preference_) {
-    case MoqtForwardingPreference::kDatagram:
-      return false;
-    case MoqtForwardingPreference::kSubgroup:
-      break;
+  if (!forwarding_preference_.has_value() ||
+      *forwarding_preference_ == MoqtForwardingPreference::kDatagram) {
+    return false;
   }
-  auto group_it = queue_.find(sequence.group);
+  auto group_it = queue_.find(group_id);
   if (group_it == queue_.end()) {
     // Group does not exist.
     return false;
   }
   Group& group = group_it->second;
-  auto subgroup_it =
-      group.subgroups.find(SubgroupPriority{publisher_priority_, subgroup_id});
+  auto subgroup_it = group.subgroups.find(subgroup_id);
   if (subgroup_it == group.subgroups.end()) {
     // Subgroup does not exist.
     return false;
   }
   for (MoqtObjectListener* listener : listeners_) {
-    listener->OnSubgroupAbandoned(sequence.group, subgroup_id, error_code);
+    listener->OnSubgroupAbandoned(group_id, subgroup_id, error_code);
   }
+  group.subgroups.erase(subgroup_id);
   return true;
 }
 
@@ -134,12 +125,15 @@
       return false;
     }
   }
-  // TODO: use `metadata.publisher_priority` instead.
-  auto subgroup_it = group.subgroups.try_emplace(
-      SubgroupPriority{publisher_priority_, metadata.subgroup});
+  auto subgroup_it = group.subgroups.try_emplace(metadata.subgroup);
   auto& subgroup = subgroup_it.first->second;
   if (!subgroup.empty()) {  // Check if the new object is valid
     CachedObject& last_object = subgroup.rbegin()->second;
+    if (last_object.metadata.publisher_priority !=
+        metadata.publisher_priority) {
+      QUICHE_DLOG(INFO) << "Publisher priority changing in a subgroup";
+      return false;
+    }
     if (last_object.fin_after_this) {
       QUICHE_DLOG(INFO) << "Skipping object because it is after the end of the "
                         << "subgroup";
@@ -184,21 +178,21 @@
   subgroup.emplace(sequence.object,
                    CachedObject{metadata, slice, last_object_in_stream});
   for (MoqtObjectListener* listener : listeners_) {
-    listener->OnNewObjectAvailable(sequence, metadata.subgroup);
+    listener->OnNewObjectAvailable(sequence, metadata.subgroup,
+                                   metadata.publisher_priority);
   }
   return true;
 }
 
 std::optional<PublishedObject> MoqtLiveRelayQueue::GetCachedObject(
-    uint64_t group_id, uint64_t subgroup_id, uint64_t object_id) const {
+    uint64_t group_id, uint64_t subgroup_id, uint64_t min_object_id) const {
   auto group_it = queue_.find(group_id);
   if (group_it == queue_.end()) {
     // Group does not exist.
     return std::nullopt;
   }
   const Group& group = group_it->second;
-  auto subgroup_it =
-      group.subgroups.find(SubgroupPriority{publisher_priority_, subgroup_id});
+  auto subgroup_it = group.subgroups.find(subgroup_id);
   if (subgroup_it == group.subgroups.end()) {
     // Subgroup does not exist.
     return std::nullopt;
@@ -207,8 +201,8 @@
   if (subgroup.empty()) {
     return std::nullopt;  // There are no objects.
   }
-  // Find an object with ID of at least sequence.object.
-  auto object_it = subgroup.lower_bound(object_id);
+  // Find an object with ID of at least min_object_id.
+  auto object_it = subgroup.lower_bound(min_object_id);
   if (object_it == subgroup.end()) {
     // No object after the last one received.
     return std::nullopt;
@@ -227,18 +221,10 @@
   }
 }
 
-absl::StatusOr<MoqtTrackStatusCode> MoqtLiveRelayQueue::GetTrackStatus() const {
-  if (end_of_track_.has_value()) {
-    return MoqtTrackStatusCode::kFinished;
-  }
+std::optional<Location> MoqtLiveRelayQueue::largest_location() const {
   if (queue_.empty()) {
-    // TODO(martinduke): Retrieve the track status from upstream.
-    return MoqtTrackStatusCode::kNotYetBegun;
+    return std::nullopt;
   }
-  return MoqtTrackStatusCode::kInProgress;
-}
-
-Location MoqtLiveRelayQueue::GetLargestLocation() const {
   return Location{next_sequence_.group, next_sequence_.object - 1};
 }
 
diff --git a/quiche/quic/moqt/moqt_live_relay_queue.h b/quiche/quic/moqt/moqt_live_relay_queue.h
index eb81b52..2417835 100644
--- a/quiche/quic/moqt/moqt_live_relay_queue.h
+++ b/quiche/quic/moqt/moqt_live_relay_queue.h
@@ -14,10 +14,10 @@
 #include "absl/container/btree_map.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "quiche/quic/core/quic_clock.h"
 #include "quiche/quic/core/quic_default_clock.h"
+#include "quiche/quic/core/quic_time.h"
 #include "quiche/quic/moqt/moqt_cached_object.h"
 #include "quiche/quic/moqt/moqt_failed_fetch.h"
 #include "quiche/quic/moqt/moqt_messages.h"
@@ -41,11 +41,16 @@
 class MoqtLiveRelayQueue : public MoqtTrackPublisher {
  public:
   MoqtLiveRelayQueue(
-      FullTrackName track, MoqtForwardingPreference forwarding_preference,
+      FullTrackName track,
+      std::optional<MoqtForwardingPreference> forwarding_preference,
+      std::optional<MoqtDeliveryOrder> delivery_order,
+      std::optional<quic::QuicTime> expiration = quic::QuicTime::Infinite(),
       const quic::QuicClock* clock = quic::QuicDefaultClock::Get())
       : clock_(clock),
         track_(std::move(track)),
         forwarding_preference_(forwarding_preference),
+        delivery_order_(delivery_order),
+        expiration_(expiration),
         next_sequence_(0, 0) {}
 
   MoqtLiveRelayQueue(const MoqtLiveRelayQueue&) = delete;
@@ -83,16 +88,15 @@
     return AddObject(metadata, object, fin);
   }
 
-  // Record a received FIN that did not come with the last object.
+  // Record a received FIN from upstream that did not come with the last object.
   // If the forwarding preference is kDatagram or kTrack, |sequence| is ignored.
   // Otherwise, |sequence| is used to determine which stream is being FINed. If
   // the object ID does not match the last object ID in the stream, no action
   // is taken.
   bool AddFin(Location sequence, uint64_t subgroup_id);
-  // Record a received RESET_STREAM. |sequence| encodes the group and subgroup
-  // of the stream that is being reset. Returns false on datagram tracks, or if
-  // the stream does not exist.
-  bool OnStreamReset(Location sequence, uint64_t subgroup_id,
+  // Record a received RESET_STREAM from upstream. Returns false on datagram
+  // tracks, or if the stream does not exist.
+  bool OnStreamReset(uint64_t group_id, uint64_t subgroup_id,
                      webtransport::StreamErrorCode error_code);
 
   // MoqtTrackPublisher implementation.
@@ -107,30 +111,41 @@
   void RemoveObjectListener(MoqtObjectListener* listener) override {
     listeners_.erase(listener);
   }
-  absl::StatusOr<MoqtTrackStatusCode> GetTrackStatus() const override;
-  Location GetLargestLocation() const override;
-  MoqtForwardingPreference GetForwardingPreference() const override {
+  std::optional<Location> largest_location() const override;
+  std::optional<MoqtForwardingPreference> forwarding_preference()
+      const override {
     return forwarding_preference_;
   }
-  MoqtPriority GetPublisherPriority() const override {
-    return publisher_priority_;
-  }
-  MoqtDeliveryOrder GetDeliveryOrder() const override {
+  std::optional<MoqtDeliveryOrder> delivery_order() const override {
     return delivery_order_;
   }
+  std::optional<quic::QuicTimeDelta> expiration() const override {
+    if (!expiration_.has_value()) {
+      return std::nullopt;
+    }
+    if (expiration_ == quic::QuicTime::Infinite()) {
+      return quic::QuicTimeDelta::Zero();
+    }
+    if (expiration_ < clock_->Now()) {
+      // TODO(martinduke): Tear everything down; the track is expired.
+      return quic::QuicTimeDelta::Zero();
+    }
+    return clock_->Now() - *expiration_;
+  }
   std::unique_ptr<MoqtFetchTask> StandaloneFetch(
       Location /*start*/, Location /*end*/,
-      MoqtDeliveryOrder /*order*/) override {
+      std::optional<MoqtDeliveryOrder> /*order*/) override {
     return std::make_unique<MoqtFailedFetch>(
         absl::UnimplementedError("Fetch not implemented"));
   }
   std::unique_ptr<MoqtFetchTask> RelativeFetch(
-      uint64_t /*group_diff*/, MoqtDeliveryOrder /*order*/) override {
+      uint64_t /*group_diff*/,
+      std::optional<MoqtDeliveryOrder> /*order*/) override {
     return std::make_unique<MoqtFailedFetch>(
         absl::UnimplementedError("Fetch not implemented"));
   }
   std::unique_ptr<MoqtFetchTask> AbsoluteFetch(
-      uint64_t /*group*/, MoqtDeliveryOrder /*order*/) override {
+      uint64_t /*group*/, std::optional<MoqtDeliveryOrder> /*order*/) override {
     return std::make_unique<MoqtFailedFetch>(
         absl::UnimplementedError("Fetch not implemented"));
   }
@@ -159,14 +174,14 @@
   struct Group {
     uint64_t next_object = 0;
     bool complete = false;  // If true, kEndOfGroup has been received.
-    absl::btree_map<SubgroupPriority, Subgroup> subgroups;
+    absl::btree_map<uint64_t, Subgroup> subgroups;  // Ordered by subgroup id.
   };
 
   const quic::QuicClock* clock_;
   FullTrackName track_;
-  MoqtForwardingPreference forwarding_preference_;
-  MoqtPriority publisher_priority_ = 128;
-  MoqtDeliveryOrder delivery_order_ = MoqtDeliveryOrder::kAscending;
+  std::optional<MoqtForwardingPreference> forwarding_preference_;
+  std::optional<MoqtDeliveryOrder> delivery_order_;
+  std::optional<quic::QuicTime> expiration_;
   absl::btree_map<uint64_t, Group> queue_;  // Ordered by group id.
   absl::flat_hash_set<MoqtObjectListener*> listeners_;
   std::optional<Location> end_of_track_;
diff --git a/quiche/quic/moqt/moqt_live_relay_queue_test.cc b/quiche/quic/moqt/moqt_live_relay_queue_test.cc
index 3ddc2a9..aaee1ac 100644
--- a/quiche/quic/moqt/moqt_live_relay_queue_test.cc
+++ b/quiche/quic/moqt/moqt_live_relay_queue_test.cc
@@ -8,8 +8,10 @@
 #include <optional>
 
 #include "absl/strings/string_view.h"
+#include "quiche/quic/core/quic_time.h"
 #include "quiche/quic/moqt/moqt_cached_object.h"
 #include "quiche/quic/moqt/moqt_messages.h"
+#include "quiche/quic/moqt/moqt_priority.h"
 #include "quiche/quic/moqt/moqt_publisher.h"
 #include "quiche/quic/moqt/moqt_subscribe_windows.h"
 #include "quiche/common/platform/api/quiche_logging.h"
@@ -24,12 +26,14 @@
                                public MoqtObjectListener {
  public:
   TestMoqtLiveRelayQueue()
-      : MoqtLiveRelayQueue(FullTrackName{"test", "track"},
-                           MoqtForwardingPreference::kSubgroup) {
+      : MoqtLiveRelayQueue(
+            FullTrackName{"test", "track"}, MoqtForwardingPreference::kSubgroup,
+            MoqtDeliveryOrder::kAscending, quic::QuicTime::Infinite()) {
     AddObjectListener(this);
   }
 
-  void OnNewObjectAvailable(Location sequence, uint64_t subgroup_id) {
+  void OnNewObjectAvailable(Location sequence, uint64_t subgroup_id,
+                            MoqtPriority /*publisher_priority*/) {
     std::optional<PublishedObject> object =
         GetCachedObject(sequence.group, subgroup_id, sequence.object);
     QUICHE_CHECK(object.has_value());
@@ -64,8 +68,8 @@
   void GetObjectsFromPast(const SubscribeWindow& window) {
     ForAllObjects([&](const CachedObject& object) {
       if (window.InWindow(object.metadata.location)) {
-        OnNewObjectAvailable(object.metadata.location,
-                             object.metadata.subgroup);
+        OnNewObjectAvailable(object.metadata.location, object.metadata.subgroup,
+                             object.metadata.publisher_priority);
       }
     });
   }
@@ -86,9 +90,7 @@
   MOCK_METHOD(void, CloseTrack, (), ());
   MOCK_METHOD(void, OnTrackPublisherGone, (), (override));
   MOCK_METHOD(void, OnSubscribeAccepted, (), (override));
-  MOCK_METHOD(void, OnSubscribeRejected,
-              (MoqtSubscribeErrorReason reason,
-               std::optional<uint64_t> track_alias),
+  MOCK_METHOD(void, OnSubscribeRejected, (MoqtSubscribeErrorReason reason),
               (override));
 };
 
@@ -466,7 +468,7 @@
     EXPECT_CALL(queue, OnSubgroupAbandoned(0, 0, 0x1));
   }
   EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a"));
-  EXPECT_TRUE(queue.OnStreamReset(Location{0, 0}, 0, 0x1));
+  EXPECT_TRUE(queue.OnStreamReset(0, 0, 0x1));
 }
 
 }  // namespace
diff --git a/quiche/quic/moqt/moqt_messages.cc b/quiche/quic/moqt/moqt_messages.cc
index 64e706e..4fb893c 100644
--- a/quiche/quic/moqt/moqt_messages.cc
+++ b/quiche/quic/moqt/moqt_messages.cc
@@ -176,14 +176,14 @@
 const std::array<MoqtMessageType, 8> kAllowsAuthorization = {
     MoqtMessageType::kClientSetup, MoqtMessageType::kServerSetup,
     MoqtMessageType::kSubscribe,   MoqtMessageType::kSubscribeNamespace,
-    MoqtMessageType::kAnnounce,    MoqtMessageType::kTrackStatusRequest,
+    MoqtMessageType::kAnnounce,    MoqtMessageType::kTrackStatus,
     MoqtMessageType::kFetch,       MoqtMessageType::kPublish};
 const std::array<MoqtMessageType, 6> kAllowsDeliveryTimeout = {
     MoqtMessageType::kSubscribe,       MoqtMessageType::kSubscribeOk,
-    MoqtMessageType::kSubscribeUpdate, MoqtMessageType::kTrackStatus,
+    MoqtMessageType::kSubscribeUpdate, MoqtMessageType::kTrackStatusOk,
     MoqtMessageType::kPublish,         MoqtMessageType::kPublishOk};
 const std::array<MoqtMessageType, 4> kAllowsMaxCacheDuration = {
-    MoqtMessageType::kSubscribeOk, MoqtMessageType::kTrackStatus,
+    MoqtMessageType::kSubscribeOk, MoqtMessageType::kTrackStatusOk,
     MoqtMessageType::kFetchOk, MoqtMessageType::kPublish};
 bool ValidateVersionSpecificParameters(const KeyValuePairList& parameters,
                                        MoqtMessageType message_type) {
@@ -232,10 +232,12 @@
       return "SUBSCRIBE_UPDATE";
     case MoqtMessageType::kAnnounceCancel:
       return "ANNOUNCE_CANCEL";
-    case MoqtMessageType::kTrackStatusRequest:
-      return "TRACK_STATUS_REQUEST";
     case MoqtMessageType::kTrackStatus:
       return "TRACK_STATUS";
+    case MoqtMessageType::kTrackStatusOk:
+      return "TRACK_STATUS_OK";
+    case MoqtMessageType::kTrackStatusError:
+      return "TRACK_STATUS_ERROR";
     case MoqtMessageType::kAnnounce:
       return "ANNOUNCE";
     case MoqtMessageType::kAnnounceOk:
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
index 2838975..310778a 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -41,11 +41,11 @@
 }
 
 enum class MoqtVersion : uint64_t {
-  kDraft12 = 0xff00000c,
+  kDraft13 = 0xff00000d,
   kUnrecognizedVersionForTests = 0xfe0000ff,
 };
 
-inline constexpr MoqtVersion kDefaultMoqtVersion = MoqtVersion::kDraft12;
+inline constexpr MoqtVersion kDefaultMoqtVersion = MoqtVersion::kDraft13;
 inline constexpr uint64_t kDefaultInitialMaxRequestId = 100;
 // TODO(martinduke): Implement an auth token cache.
 inline constexpr uint64_t kDefaultMaxAuthTokenCacheSize = 0;
@@ -129,7 +129,8 @@
   static std::optional<MoqtDataStreamType> FromValue(uint64_t value) {
     MoqtDataStreamType stream_type(value);
     if (stream_type.IsFetch() || stream_type.IsPadding() ||
-        stream_type.IsSubgroup()) {
+        (!((value & kSubgroupIdFlag) && (value & kFirstObjectIdFlag)) &&
+         stream_type.IsSubgroup())) {
       return stream_type;
     }
     return std::nullopt;
@@ -161,8 +162,9 @@
   bool IsFetch() const { return value_ == kFetch; }
   bool IsPadding() const { return value_ == kPadding; }
   bool IsSubgroup() const {
-    return (value_ & kSubgroupFlag) && (value_ & ~0x1f) == 0 &&
-           !((value_ & kSubgroupIdFlag) && (value_ & kFirstObjectIdFlag));
+    QUICHE_CHECK(
+        !((value_ & kSubgroupIdFlag) && (value_ & kFirstObjectIdFlag)));
+    return (value_ & kSubgroupFlag) && (value_ & ~0x1f) == 0;
   }
   bool IsSubgroupPresent() const {
     return IsSubgroup() && (value_ & kSubgroupIdFlag);
@@ -240,8 +242,9 @@
   kUnsubscribe = 0x0a,
   kSubscribeDone = 0x0b,
   kAnnounceCancel = 0x0c,
-  kTrackStatusRequest = 0x0d,
-  kTrackStatus = 0x0e,
+  kTrackStatus = 0x0d,
+  kTrackStatusOk = 0x0e,
+  kTrackStatusError = 0x0f,
   kGoAway = 0x10,
   kSubscribeNamespace = 0x11,
   kSubscribeNamespaceOk = 0x12,
@@ -323,7 +326,7 @@
         max_cache_duration(max_cache_duration) {}
   VersionSpecificParameters(AuthTokenType token_type, absl::string_view token) {
     authorization_token.emplace_back(token_type, token);
-  };
+  }
   VersionSpecificParameters(quic::QuicTimeDelta delivery_timeout,
                             AuthTokenType token_type, absl::string_view token)
       : delivery_timeout(delivery_timeout) {
@@ -725,38 +728,21 @@
   std::string error_reason;
 };
 
-enum class QUICHE_EXPORT MoqtTrackStatusCode : uint64_t {
-  kInProgress = 0x0,
-  kDoesNotExist = 0x1,
-  kNotYetBegun = 0x2,
-  kFinished = 0x3,
-  kStatusNotAvailable = 0x4,
+struct QUICHE_EXPORT MoqtTrackStatus : public MoqtSubscribe {
+  MoqtTrackStatus() = default;
+  MoqtTrackStatus(MoqtSubscribe subscribe) : MoqtSubscribe(subscribe) {}
 };
 
-inline bool DoesTrackStatusImplyHavingData(MoqtTrackStatusCode code) {
-  switch (code) {
-    case MoqtTrackStatusCode::kInProgress:
-    case MoqtTrackStatusCode::kFinished:
-      return true;
-    case MoqtTrackStatusCode::kDoesNotExist:
-    case MoqtTrackStatusCode::kNotYetBegun:
-    case MoqtTrackStatusCode::kStatusNotAvailable:
-      return false;
-  }
-  return false;
-}
-
-struct QUICHE_EXPORT MoqtTrackStatusRequest {
-  uint64_t request_id;
-  FullTrackName full_track_name;
-  VersionSpecificParameters parameters;
+struct QUICHE_EXPORT MoqtTrackStatusOk : public MoqtSubscribeOk {
+  MoqtTrackStatusOk() = default;
+  MoqtTrackStatusOk(MoqtSubscribeOk subscribe_ok)
+      : MoqtSubscribeOk(subscribe_ok) {}
 };
 
-struct QUICHE_EXPORT MoqtTrackStatus {
-  uint64_t request_id;
-  MoqtTrackStatusCode status_code;
-  Location largest_location;
-  VersionSpecificParameters parameters;
+struct QUICHE_EXPORT MoqtTrackStatusError : public MoqtSubscribeError {
+  MoqtTrackStatusError() = default;
+  MoqtTrackStatusError(MoqtSubscribeError subscribe_error)
+      : MoqtSubscribeError(subscribe_error) {}
 };
 
 struct QUICHE_EXPORT MoqtGoAway {
diff --git a/quiche/quic/moqt/moqt_outgoing_queue.cc b/quiche/quic/moqt/moqt_outgoing_queue.cc
index 63e0140..8e434e3 100644
--- a/quiche/quic/moqt/moqt_outgoing_queue.cc
+++ b/quiche/quic/moqt/moqt_outgoing_queue.cc
@@ -82,7 +82,8 @@
                               clock_->ApproximateNow()},
       std::make_shared<quiche::QuicheMemSlice>(std::move(payload)), fin});
   for (MoqtObjectListener* listener : listeners_) {
-    listener->OnNewObjectAvailable(sequence, /*subgroup=*/0);
+    listener->OnNewObjectAvailable(sequence, /*subgroup=*/0,
+                                   publisher_priority_);
   }
 }
 
@@ -126,27 +127,15 @@
   return sequences;
 }
 
-absl::StatusOr<MoqtTrackStatusCode> MoqtOutgoingQueue::GetTrackStatus() const {
-  if (closed_) {
-    return MoqtTrackStatusCode::kFinished;
-  }
+std::optional<Location> MoqtOutgoingQueue::largest_location() const {
   if (queue_.empty()) {
-    return MoqtTrackStatusCode::kNotYetBegun;
-  }
-  return MoqtTrackStatusCode::kInProgress;
-}
-
-Location MoqtOutgoingQueue::GetLargestLocation() const {
-  if (queue_.empty()) {
-    QUICHE_BUG(MoqtOutgoingQueue_GetLargestLocation_not_begun)
-        << "Calling GetLargestLocation() on a track that hasn't begun";
-    return Location{0, 0};
+    return std::nullopt;
   }
   return Location{current_group_id_, queue_.back().size() - 1};
 }
 
 std::unique_ptr<MoqtFetchTask> MoqtOutgoingQueue::StandaloneFetch(
-    Location start, Location end, MoqtDeliveryOrder order) {
+    Location start, Location end, std::optional<MoqtDeliveryOrder> order) {
   if (queue_.empty()) {
     return std::make_unique<MoqtFailedFetch>(
         absl::NotFoundError("No objects available on the track"));
@@ -169,21 +158,15 @@
   Location adjusted_end = std::min(end, last_available_object);
   std::vector<Location> objects =
       GetCachedObjectsInRange(adjusted_start, adjusted_end);
+  // Default to ascending order.
   if (order == MoqtDeliveryOrder::kDescending) {
-    absl::c_reverse(objects);
-    for (auto it = objects.begin(); it != objects.end();) {
-      auto start_it = it;
-      while (it != objects.end() && it->group == start_it->group) {
-        ++it;
-      }
-      std::reverse(start_it, it);
-    }
+    ObjectsInDescendingOrder(objects);
   }
   return std::make_unique<FetchTask>(this, std::move(objects));
 }
 
 std::unique_ptr<MoqtFetchTask> MoqtOutgoingQueue::RelativeFetch(
-    uint64_t group_diff, MoqtDeliveryOrder order) {
+    uint64_t group_diff, std::optional<MoqtDeliveryOrder> order) {
   if (queue_.empty()) {
     return std::make_unique<MoqtFailedFetch>(
         absl::NotFoundError("No objects available on the track"));
@@ -204,7 +187,7 @@
 }
 
 std::unique_ptr<MoqtFetchTask> MoqtOutgoingQueue::AbsoluteFetch(
-    uint64_t group, MoqtDeliveryOrder order) {
+    uint64_t group, std::optional<MoqtDeliveryOrder> order) {
   if (queue_.empty()) {
     return std::make_unique<MoqtFailedFetch>(
         absl::NotFoundError("No objects available on the track"));
diff --git a/quiche/quic/moqt/moqt_outgoing_queue.h b/quiche/quic/moqt/moqt_outgoing_queue.h
index 1034792..cadd11c 100644
--- a/quiche/quic/moqt/moqt_outgoing_queue.h
+++ b/quiche/quic/moqt/moqt_outgoing_queue.h
@@ -15,9 +15,9 @@
 #include "absl/container/flat_hash_set.h"
 #include "absl/container/inlined_vector.h"
 #include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "quiche/quic/core/quic_clock.h"
 #include "quiche/quic/core/quic_default_clock.h"
+#include "quiche/quic/core/quic_time.h"
 #include "quiche/quic/moqt/moqt_cached_object.h"
 #include "quiche/quic/moqt/moqt_messages.h"
 #include "quiche/quic/moqt/moqt_priority.h"
@@ -63,23 +63,26 @@
   void RemoveObjectListener(MoqtObjectListener* listener) override {
     listeners_.erase(listener);
   }
-  absl::StatusOr<MoqtTrackStatusCode> GetTrackStatus() const override;
-  Location GetLargestLocation() const override;
-  MoqtForwardingPreference GetForwardingPreference() const override {
+
+  std::optional<Location> largest_location() const override;
+  std::optional<MoqtForwardingPreference> forwarding_preference()
+      const override {
     return forwarding_preference_;
   }
-  MoqtPriority GetPublisherPriority() const override {
-    return publisher_priority_;
-  }
-  MoqtDeliveryOrder GetDeliveryOrder() const override {
+  std::optional<MoqtDeliveryOrder> delivery_order() const override {
     return delivery_order_;
   }
+  std::optional<quic::QuicTimeDelta> expiration() const override {
+    return quic::QuicTimeDelta::Zero();
+  }
+
   std::unique_ptr<MoqtFetchTask> StandaloneFetch(
-      Location start, Location end, MoqtDeliveryOrder order) override;
+      Location start, Location end,
+      std::optional<MoqtDeliveryOrder> order) override;
   std::unique_ptr<MoqtFetchTask> RelativeFetch(
-      uint64_t group_diff, MoqtDeliveryOrder order) override;
+      uint64_t group_diff, std::optional<MoqtDeliveryOrder> order) override;
   std::unique_ptr<MoqtFetchTask> AbsoluteFetch(
-      uint64_t group, MoqtDeliveryOrder order) override;
+      uint64_t group, std::optional<MoqtDeliveryOrder> order) override;
 
   bool HasSubscribers() const { return !listeners_.empty(); }
   void SetDeliveryOrder(MoqtDeliveryOrder order) {
@@ -102,6 +105,9 @@
   std::vector<Location> GetCachedObjectsInRange(Location start,
                                                 Location end) const;
 
+ protected:
+  MoqtPriority publisher_priority() const { return publisher_priority_; }
+
  private:
   // The number of recent groups to keep around for newly joined subscribers.
   static constexpr size_t kMaxQueuedGroups = 3;
@@ -144,7 +150,7 @@
         ok.end_location = *(objects_.cbegin());
       }
       ok.end_of_track =
-          queue_->closed_ && ok.end_location == queue_->GetLargestLocation();
+          queue_->closed_ && ok.end_location == queue_->largest_location();
       std::move(callback)(ok);
     }
 
diff --git a/quiche/quic/moqt/moqt_outgoing_queue_test.cc b/quiche/quic/moqt/moqt_outgoing_queue_test.cc
index 841179c..d08897b 100644
--- a/quiche/quic/moqt/moqt_outgoing_queue_test.cc
+++ b/quiche/quic/moqt/moqt_outgoing_queue_test.cc
@@ -47,7 +47,8 @@
     AddObjectListener(this);
   }
 
-  void OnNewObjectAvailable(Location sequence, uint64_t subgroup) override {
+  void OnNewObjectAvailable(Location sequence, uint64_t subgroup,
+                            MoqtPriority publisher_priority) override {
     std::optional<PublishedObject> object =
         GetCachedObject(sequence.group, subgroup, sequence.object);
     ASSERT_THAT(object,
@@ -66,11 +67,14 @@
   }
 
   void GetObjectsFromPast(const SubscribeWindow& window) {
+    if (!largest_location().has_value()) {
+      return;
+    }
     std::vector<Location> objects =
-        GetCachedObjectsInRange(Location(0, 0), GetLargestLocation());
+        GetCachedObjectsInRange(Location(0, 0), *largest_location());
     for (Location object : objects) {
       if (window.InWindow(object)) {
-        OnNewObjectAvailable(object, 0);
+        OnNewObjectAvailable(object, 0, publisher_priority());
       }
     }
   }
@@ -87,9 +91,7 @@
               ());
   MOCK_METHOD(void, OnTrackPublisherGone, (), (override));
   MOCK_METHOD(void, OnSubscribeAccepted, (), (override));
-  MOCK_METHOD(void, OnSubscribeRejected,
-              (MoqtSubscribeErrorReason reason,
-               std::optional<uint64_t> track_alias),
+  MOCK_METHOD(void, OnSubscribeRejected, (MoqtSubscribeErrorReason reason),
               (override));
 };
 
@@ -448,7 +450,7 @@
   EXPECT_EQ(end_location, Location(1, 0));
 
   queue.Close();  // Create (2, 0)
-  EXPECT_EQ(queue.GetLargestLocation(), Location(2, 0));
+  EXPECT_EQ(queue.largest_location(), Location(2, 0));
   fetch = queue.StandaloneFetch(Location{0, 0}, Location{1, kMaxObjectId},
                                 MoqtDeliveryOrder::kAscending);
   // end_of_track is false if the fetch does not include the last object.
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc
index e7f4a7d..6af3e37 100644
--- a/quiche/quic/moqt/moqt_parser.cc
+++ b/quiche/quic/moqt/moqt_parser.cc
@@ -246,18 +246,21 @@
     case MoqtMessageType::kAnnounceError:
       bytes_read = ProcessAnnounceError(reader);
       break;
-    case MoqtMessageType::kAnnounceCancel:
-      bytes_read = ProcessAnnounceCancel(reader);
-      break;
-    case MoqtMessageType::kTrackStatusRequest:
-      bytes_read = ProcessTrackStatusRequest(reader);
-      break;
     case MoqtMessageType::kUnannounce:
       bytes_read = ProcessUnannounce(reader);
       break;
+    case MoqtMessageType::kAnnounceCancel:
+      bytes_read = ProcessAnnounceCancel(reader);
+      break;
     case MoqtMessageType::kTrackStatus:
       bytes_read = ProcessTrackStatus(reader);
       break;
+    case MoqtMessageType::kTrackStatusOk:
+      bytes_read = ProcessTrackStatusOk(reader);
+      break;
+    case MoqtMessageType::kTrackStatusError:
+      bytes_read = ProcessTrackStatusError(reader);
+      break;
     case MoqtMessageType::kGoAway:
       bytes_read = ProcessGoAway(reader);
       break;
@@ -374,7 +377,8 @@
   return reader.PreviouslyReadPayload().length();
 }
 
-size_t MoqtControlParser::ProcessSubscribe(quic::QuicDataReader& reader) {
+size_t MoqtControlParser::ProcessSubscribe(quic::QuicDataReader& reader,
+                                           MoqtMessageType message_type) {
   MoqtSubscribe subscribe;
   uint64_t filter, group, object;
   uint8_t group_order, forward;
@@ -434,11 +438,16 @@
                                                    subscribe.parameters)) {
     return 0;
   }
-  visitor_.OnSubscribeMessage(subscribe);
+  if (message_type == MoqtMessageType::kTrackStatus) {
+    visitor_.OnTrackStatusMessage(subscribe);
+  } else {
+    visitor_.OnSubscribeMessage(subscribe);
+  }
   return reader.PreviouslyReadPayload().length();
 }
 
-size_t MoqtControlParser::ProcessSubscribeOk(quic::QuicDataReader& reader) {
+size_t MoqtControlParser::ProcessSubscribeOk(quic::QuicDataReader& reader,
+                                             MoqtMessageType message_type) {
   MoqtSubscribeOk subscribe_ok;
   uint64_t milliseconds;
   uint8_t group_order;
@@ -449,6 +458,8 @@
       !reader.ReadUInt8(&content_exists)) {
     return 0;
   }
+  // TODO(martinduke): If track_alias > 0 is an error for TrackStatusOk, then
+  // throw an error here.
   if (content_exists > 1) {
     ParseError("SUBSCRIBE_OK ContentExists has invalid value");
     return 0;
@@ -479,11 +490,16 @@
                                                    subscribe_ok.parameters)) {
     return 0;
   }
-  visitor_.OnSubscribeOkMessage(subscribe_ok);
+  if (message_type == MoqtMessageType::kTrackStatusOk) {
+    visitor_.OnTrackStatusOkMessage(subscribe_ok);
+  } else {
+    visitor_.OnSubscribeOkMessage(subscribe_ok);
+  }
   return reader.PreviouslyReadPayload().length();
 }
 
-size_t MoqtControlParser::ProcessSubscribeError(quic::QuicDataReader& reader) {
+size_t MoqtControlParser::ProcessSubscribeError(quic::QuicDataReader& reader,
+                                                MoqtMessageType message_type) {
   MoqtSubscribeError subscribe_error;
   uint64_t error_code;
   if (!reader.ReadVarInt62(&subscribe_error.request_id) ||
@@ -492,7 +508,11 @@
     return 0;
   }
   subscribe_error.error_code = static_cast<RequestErrorCode>(error_code);
-  visitor_.OnSubscribeErrorMessage(subscribe_error);
+  if (message_type == MoqtMessageType::kTrackStatusError) {
+    visitor_.OnTrackStatusErrorMessage(subscribe_error);
+  } else {
+    visitor_.OnSubscribeErrorMessage(subscribe_error);
+  }
   return reader.PreviouslyReadPayload().length();
 }
 
@@ -605,6 +625,15 @@
   return reader.PreviouslyReadPayload().length();
 }
 
+size_t MoqtControlParser::ProcessUnannounce(quic::QuicDataReader& reader) {
+  MoqtUnannounce unannounce;
+  if (!ReadTrackNamespace(reader, unannounce.track_namespace)) {
+    return 0;
+  }
+  visitor_.OnUnannounceMessage(unannounce);
+  return reader.PreviouslyReadPayload().length();
+}
+
 size_t MoqtControlParser::ProcessAnnounceCancel(quic::QuicDataReader& reader) {
   MoqtAnnounceCancel announce_cancel;
   if (!ReadTrackNamespace(reader, announce_cancel.track_namespace)) {
@@ -620,66 +649,17 @@
   return reader.PreviouslyReadPayload().length();
 }
 
-size_t MoqtControlParser::ProcessTrackStatusRequest(
-    quic::QuicDataReader& reader) {
-  MoqtTrackStatusRequest track_status_request;
-  if (!reader.ReadVarInt62(&track_status_request.request_id)) {
-    return 0;
-  }
-  if (!ReadFullTrackName(reader, track_status_request.full_track_name)) {
-    return 0;
-  }
-  KeyValuePairList parameters;
-  if (!ParseKeyValuePairList(reader, parameters)) {
-    return 0;
-  }
-  if (!ValidateVersionSpecificParameters(
-          parameters, MoqtMessageType::kTrackStatusRequest)) {
-    ParseError("TRACK_STATUS_REQUEST message contains invalid parameters");
-    return 0;
-  }
-  if (!KeyValuePairListToVersionSpecificParameters(
-          parameters, track_status_request.parameters)) {
-    return 0;
-  }
-  visitor_.OnTrackStatusRequestMessage(track_status_request);
-  return reader.PreviouslyReadPayload().length();
-}
-
-size_t MoqtControlParser::ProcessUnannounce(quic::QuicDataReader& reader) {
-  MoqtUnannounce unannounce;
-  if (!ReadTrackNamespace(reader, unannounce.track_namespace)) {
-    return 0;
-  }
-  visitor_.OnUnannounceMessage(unannounce);
-  return reader.PreviouslyReadPayload().length();
-}
-
 size_t MoqtControlParser::ProcessTrackStatus(quic::QuicDataReader& reader) {
-  MoqtTrackStatus track_status;
-  uint64_t status_code;
-  if (!reader.ReadVarInt62(&track_status.request_id) ||
-      !reader.ReadVarInt62(&status_code) ||
-      !reader.ReadVarInt62(&track_status.largest_location.group) ||
-      !reader.ReadVarInt62(&track_status.largest_location.object)) {
-    return 0;
-  }
-  track_status.status_code = static_cast<MoqtTrackStatusCode>(status_code);
-  KeyValuePairList parameters;
-  if (!ParseKeyValuePairList(reader, parameters)) {
-    return 0;
-  }
-  if (!ValidateVersionSpecificParameters(parameters,
-                                         MoqtMessageType::kTrackStatus)) {
-    ParseError("TRACK_STATUS message contains invalid parameters");
-    return 0;
-  }
-  if (!KeyValuePairListToVersionSpecificParameters(parameters,
-                                                   track_status.parameters)) {
-    return 0;
-  }
-  visitor_.OnTrackStatusMessage(track_status);
-  return reader.PreviouslyReadPayload().length();
+  return ProcessSubscribe(reader, MoqtMessageType::kTrackStatus);
+}
+
+size_t MoqtControlParser::ProcessTrackStatusOk(quic::QuicDataReader& reader) {
+  return ProcessSubscribeOk(reader, MoqtMessageType::kTrackStatusOk);
+}
+
+size_t MoqtControlParser::ProcessTrackStatusError(
+    quic::QuicDataReader& reader) {
+  return ProcessSubscribeError(reader, MoqtMessageType::kTrackStatusError);
 }
 
 size_t MoqtControlParser::ProcessGoAway(quic::QuicDataReader& reader) {
diff --git a/quiche/quic/moqt/moqt_parser.h b/quiche/quic/moqt/moqt_parser.h
index f331b9f..aa4d367 100644
--- a/quiche/quic/moqt/moqt_parser.h
+++ b/quiche/quic/moqt/moqt_parser.h
@@ -43,11 +43,12 @@
   virtual void OnAnnounceMessage(const MoqtAnnounce& message) = 0;
   virtual void OnAnnounceOkMessage(const MoqtAnnounceOk& message) = 0;
   virtual void OnAnnounceErrorMessage(const MoqtAnnounceError& message) = 0;
-  virtual void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) = 0;
-  virtual void OnTrackStatusRequestMessage(
-      const MoqtTrackStatusRequest& message) = 0;
   virtual void OnUnannounceMessage(const MoqtUnannounce& message) = 0;
+  virtual void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) = 0;
   virtual void OnTrackStatusMessage(const MoqtTrackStatus& message) = 0;
+  virtual void OnTrackStatusOkMessage(const MoqtTrackStatusOk& message) = 0;
+  virtual void OnTrackStatusErrorMessage(
+      const MoqtTrackStatusError& message) = 0;
   virtual void OnGoAwayMessage(const MoqtGoAway& message) = 0;
   virtual void OnSubscribeNamespaceMessage(
       const MoqtSubscribeNamespace& message) = 0;
@@ -112,19 +113,28 @@
   // otherwise.
   size_t ProcessClientSetup(quic::QuicDataReader& reader);
   size_t ProcessServerSetup(quic::QuicDataReader& reader);
-  size_t ProcessSubscribe(quic::QuicDataReader& reader);
-  size_t ProcessSubscribeOk(quic::QuicDataReader& reader);
-  size_t ProcessSubscribeError(quic::QuicDataReader& reader);
+  // Subscribe formats are used for TrackStatus as well, so take the message
+  // type as an argument, defaulting to the subscribe version.
+  size_t ProcessSubscribe(
+      quic::QuicDataReader& reader,
+      MoqtMessageType message_type = MoqtMessageType::kSubscribe);
+  size_t ProcessSubscribeOk(
+      quic::QuicDataReader& reader,
+      MoqtMessageType message_type = MoqtMessageType::kSubscribeOk);
+  size_t ProcessSubscribeError(
+      quic::QuicDataReader& reader,
+      MoqtMessageType message_type = MoqtMessageType::kSubscribeError);
   size_t ProcessUnsubscribe(quic::QuicDataReader& reader);
   size_t ProcessSubscribeDone(quic::QuicDataReader& reader);
   size_t ProcessSubscribeUpdate(quic::QuicDataReader& reader);
   size_t ProcessAnnounce(quic::QuicDataReader& reader);
   size_t ProcessAnnounceOk(quic::QuicDataReader& reader);
   size_t ProcessAnnounceError(quic::QuicDataReader& reader);
-  size_t ProcessAnnounceCancel(quic::QuicDataReader& reader);
-  size_t ProcessTrackStatusRequest(quic::QuicDataReader& reader);
   size_t ProcessUnannounce(quic::QuicDataReader& reader);
+  size_t ProcessAnnounceCancel(quic::QuicDataReader& reader);
   size_t ProcessTrackStatus(quic::QuicDataReader& reader);
+  size_t ProcessTrackStatusOk(quic::QuicDataReader& reader);
+  size_t ProcessTrackStatusError(quic::QuicDataReader& reader);
   size_t ProcessGoAway(quic::QuicDataReader& reader);
   size_t ProcessSubscribeNamespace(quic::QuicDataReader& reader);
   size_t ProcessSubscribeNamespaceOk(quic::QuicDataReader& reader);
diff --git a/quiche/quic/moqt/moqt_parser_test.cc b/quiche/quic/moqt/moqt_parser_test.cc
index 1ef7ec5..24e5657 100644
--- a/quiche/quic/moqt/moqt_parser_test.cc
+++ b/quiche/quic/moqt/moqt_parser_test.cc
@@ -39,8 +39,9 @@
     MoqtMessageType::kUnsubscribe,
     MoqtMessageType::kSubscribeDone,
     MoqtMessageType::kAnnounceCancel,
-    MoqtMessageType::kTrackStatusRequest,
     MoqtMessageType::kTrackStatus,
+    MoqtMessageType::kTrackStatusOk,
+    MoqtMessageType::kTrackStatusError,
     MoqtMessageType::kAnnounce,
     MoqtMessageType::kAnnounceOk,
     MoqtMessageType::kAnnounceError,
diff --git a/quiche/quic/moqt/moqt_publisher.h b/quiche/quic/moqt/moqt_publisher.h
index a3f2ebc..acd3587 100644
--- a/quiche/quic/moqt/moqt_publisher.h
+++ b/quiche/quic/moqt/moqt_publisher.h
@@ -50,14 +50,13 @@
   virtual void OnSubscribeAccepted() = 0;
   // Called when the publisher is sure that it cannot serve the subscription.
   // This could happen synchronously or asynchronously.
-  virtual void OnSubscribeRejected(
-      MoqtSubscribeErrorReason reason,
-      std::optional<uint64_t> track_alias = std::nullopt) = 0;
+  virtual void OnSubscribeRejected(MoqtSubscribeErrorReason reason) = 0;
 
   // Notifies that a new object is available on the track.  The object payload
   // itself may be retrieved via GetCachedObject method of the associated track
   // publisher.
-  virtual void OnNewObjectAvailable(Location sequence, uint64_t subgroup) = 0;
+  virtual void OnNewObjectAvailable(Location sequence, uint64_t subgroup,
+                                    MoqtPriority publisher_priority) = 0;
   // Notifies that a pure FIN has arrived following |sequence|. Should not be
   // called unless all objects have already been delivered. If not delivered,
   // instead set the fin_after_this flag in the PublishedObject.
@@ -159,31 +158,24 @@
   virtual void AddObjectListener(MoqtObjectListener* listener) = 0;
   virtual void RemoveObjectListener(MoqtObjectListener* listener) = 0;
 
-  virtual absl::StatusOr<MoqtTrackStatusCode> GetTrackStatus() const = 0;
-
-  // Returns the largest (group, object) pair that has been published so far.
-  // This method may only be called if
-  // DoesTrackStatusImplyHavingData(GetTrackStatus()) is true.
-  virtual Location GetLargestLocation() const = 0;
-
-  // Returns the forwarding preference of the track.
-  // This method may only be called if
-  // DoesTrackStatusImplyHavingData(GetTrackStatus()) is true.
-  virtual MoqtForwardingPreference GetForwardingPreference() const = 0;
-
-  // Returns the current forwarding priority of the track.
-  virtual MoqtPriority GetPublisherPriority() const = 0;
-
-  // Returns the publisher-preferred delivery order for the track.
-  virtual MoqtDeliveryOrder GetDeliveryOrder() const = 0;
+  // Methods to return various track properties. Returns nullopt if the value is
+  // not yet available. Guaranteed to be non-null if an object is available
+  // and/or OnSubscribeAccepted() has been called.
+  // Track alias is not present because MoqtSession always uses locally
+  // generated values.
+  virtual std::optional<Location> largest_location() const = 0;
+  virtual std::optional<MoqtForwardingPreference> forwarding_preference()
+      const = 0;
+  virtual std::optional<MoqtDeliveryOrder> delivery_order() const = 0;
+  virtual std::optional<quic::QuicTimeDelta> expiration() const = 0;
 
   // Performs a fetch for the specified range of objects.
   virtual std::unique_ptr<MoqtFetchTask> StandaloneFetch(
-      Location start, Location end, MoqtDeliveryOrder order) = 0;
+      Location start, Location end, std::optional<MoqtDeliveryOrder> order) = 0;
   virtual std::unique_ptr<MoqtFetchTask> RelativeFetch(
-      uint64_t group_diff, MoqtDeliveryOrder order) = 0;
+      uint64_t group_diff, std::optional<MoqtDeliveryOrder> order) = 0;
   virtual std::unique_ptr<MoqtFetchTask> AbsoluteFetch(
-      uint64_t group, MoqtDeliveryOrder order) = 0;
+      uint64_t group, std::optional<MoqtDeliveryOrder> order) = 0;
 };
 
 // MoqtPublisher is an interface to a publisher that allows it to publish
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc
index d68578d..ffa88a1 100644
--- a/quiche/quic/moqt/moqt_session.cc
+++ b/quiche/quic/moqt/moqt_session.cc
@@ -6,11 +6,11 @@
 
 #include <algorithm>
 #include <array>
-#include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <optional>
 #include <string>
+#include <tuple>
 #include <utility>
 #include <variant>
 #include <vector>
@@ -63,11 +63,6 @@
 // send group is always the same.
 constexpr webtransport::SendGroupId kMoqtSendGroupId = 0;
 
-bool PublisherHasData(const MoqtTrackPublisher& publisher) {
-  absl::StatusOr<MoqtTrackStatusCode> status = publisher.GetTrackStatus();
-  return status.ok() && DoesTrackStatusImplyHavingData(*status);
-}
-
 std::optional<SubscribeWindow> SubscribeMessageToWindow(
     const MoqtSubscribe& subscribe) {
   if (!subscribe.forward ||
@@ -1264,6 +1259,12 @@
   session_->outgoing_announces_.erase(it2);
 }
 
+void MoqtSession::ControlStream::OnUnannounceMessage(
+    const MoqtUnannounce& message) {
+  session_->callbacks_.incoming_announce_callback(message.track_namespace,
+                                                  std::nullopt);
+}
+
 void MoqtSession::ControlStream::OnAnnounceCancelMessage(
     const MoqtAnnounceCancel& message) {
   // The spec currently says that if a later SUBSCRIBE arrives for this
@@ -1281,38 +1282,36 @@
   session_->outgoing_announces_.erase(it);
 }
 
-void MoqtSession::ControlStream::OnTrackStatusRequestMessage(
-    const MoqtTrackStatusRequest& message) {
+void MoqtSession::ControlStream::OnTrackStatusMessage(
+    const MoqtTrackStatus& message) {
   if (!session_->ValidateRequestId(message.request_id)) {
     return;
   }
   if (session_->sent_goaway_) {
     QUIC_DLOG(INFO) << ENDPOINT
                     << "Received a TRACK_STATUS_REQUEST after GOAWAY";
-    SendOrBufferMessage(session_->framer_.SerializeTrackStatus(
-        MoqtTrackStatus(message.request_id, MoqtTrackStatusCode::kDoesNotExist,
-                        Location(0, 0))));
+    MoqtTrackStatusError error;
+    error.request_id = message.request_id;
+    error.error_code = RequestErrorCode::kUnauthorized;
+    error.reason_phrase = "TRACK_STATUS_REQUEST after GOAWAY";
+    SendOrBufferMessage(session_->framer_.SerializeTrackStatusError(error));
     return;
   }
   // TODO(martinduke): Handle authentication.
   absl::StatusOr<std::shared_ptr<MoqtTrackPublisher>> track =
       session_->publisher_->GetTrack(message.full_track_name);
   if (!track.ok()) {
-    SendOrBufferMessage(session_->framer_.SerializeTrackStatus(
-        MoqtTrackStatus(message.request_id, MoqtTrackStatusCode::kDoesNotExist,
-                        Location(0, 0))));
+    MoqtTrackStatusError error;
+    error.request_id = message.request_id;
+    error.error_code = RequestErrorCode::kTrackDoesNotExist;
+    error.reason_phrase = "Track does not exist";
+    SendOrBufferMessage(session_->framer_.SerializeTrackStatusError(error));
     return;
   }
-  session_->incoming_track_status_.emplace(
-      std::pair<uint64_t, DownstreamTrackStatus>(
-          message.request_id,
-          DownstreamTrackStatus(message.request_id, session_, track->get())));
-}
-
-void MoqtSession::ControlStream::OnUnannounceMessage(
-    const MoqtUnannounce& message) {
-  session_->callbacks_.incoming_announce_callback(message.track_namespace,
-                                                  std::nullopt);
+  auto [it, inserted] = session_->incoming_track_status_.emplace(
+      message.request_id, std::make_unique<DownstreamTrackStatus>(
+                              message.request_id, session_, track->get()));
+  track->get()->AddObjectListener(it->second.get());
 }
 
 void MoqtSession::ControlStream::OnGoAwayMessage(const MoqtGoAway& message) {
@@ -1467,8 +1466,7 @@
     fetch = (*track_publisher)
                 ->StandaloneFetch(standalone_fetch.start_location,
                                   standalone_fetch.end_location,
-                                  message.group_order.value_or(
-                                      (*track_publisher)->GetDeliveryOrder()));
+                                  message.group_order);
   } else {
     // Joining Fetch processing.
     uint64_t joining_request_id =
@@ -1504,18 +1502,14 @@
       QUIC_DLOG(INFO) << ENDPOINT << "Received a Relative Joining FETCH for "
                       << track_name;
       fetch = it->second->publisher().RelativeFetch(
-          relative_fetch.joining_start,
-          message.group_order.value_or(
-              it->second->publisher().GetDeliveryOrder()));
+          relative_fetch.joining_start, message.group_order);
     } else {
       const JoiningFetchAbsolute& absolute_fetch =
           std::get<JoiningFetchAbsolute>(message.fetch);
       QUIC_DLOG(INFO) << ENDPOINT << "Received a Absolute Joining FETCH for "
                       << track_name;
       fetch = it->second->publisher().AbsoluteFetch(
-          absolute_fetch.joining_start,
-          message.group_order.value_or(
-              it->second->publisher().GetDeliveryOrder()));
+          absolute_fetch.joining_start, message.group_order);
     }
   }
   if (!fetch->GetStatus().ok()) {
@@ -1940,8 +1934,7 @@
   // knowing the forwarding preference in advance, and it might not be known
   // when the subscription is first created.
   if (!lazily_initialized_stream_map_.has_value()) {
-    QUICHE_DCHECK(
-        DoesTrackStatusImplyHavingData(*track_publisher_->GetTrackStatus()));
+    QUICHE_DCHECK(track_publisher_->largest_location().has_value());
     lazily_initialized_stream_map_.emplace();
   }
   return *lazily_initialized_stream_map_;
@@ -1987,9 +1980,8 @@
 void MoqtSession::PublishedSubscription::OnSubscribeAccepted() {
   std::optional<Location> largest_location;
   ControlStream* stream = session_->GetControlStream();
-  if (PublisherHasData(*track_publisher_)) {
-    largest_location = track_publisher_->GetLargestLocation();
-    QUICHE_CHECK(largest_location.has_value());
+  largest_location = track_publisher_->largest_location();
+  if (largest_location.has_value()) {
     if (forward_) {
       switch (filter_type_) {
         case MoqtFilterType::kLatestObject:
@@ -2010,23 +2002,29 @@
   MoqtSubscribeOk subscribe_ok;
   subscribe_ok.request_id = request_id_;
   subscribe_ok.track_alias = session_->next_local_track_alias_++;
-  subscribe_ok.group_order = track_publisher_->GetDeliveryOrder();
+  QUICHE_BUG_IF(quic_bug_subscribe_ok_no_expiration,
+                !track_publisher_->expiration().has_value())
+      << "Request accepted without expiration";
+  subscribe_ok.expires =
+      track_publisher_->expiration().value_or(quic::QuicTimeDelta::Zero());
+  QUICHE_BUG_IF(quic_bug_subscribe_ok_no_delivery_order,
+                !track_publisher_->delivery_order().has_value())
+      << "Request accepted without delivery order";
+  subscribe_ok.group_order = track_publisher_->delivery_order().value_or(
+      MoqtDeliveryOrder::kAscending);
   subscribe_ok.largest_location = largest_location;
   track_alias_.emplace(subscribe_ok.track_alias);
   // TODO(martinduke): Support sending DELIVERY_TIMEOUT parameter as the
   // publisher.
   stream->SendOrBufferMessage(
       session_->framer_.SerializeSubscribeOk(subscribe_ok));
-  if (!PublisherHasData(*track_publisher_)) {
-    return;
-  }
   // TODO(martinduke): If we buffer objects that arrived previously, the arrival
   // of the track alias disambiguates what subscription they belong to. Send
   // them.
 }
 
 void MoqtSession::PublishedSubscription::OnSubscribeRejected(
-    MoqtSubscribeErrorReason reason, std::optional<uint64_t> track_alias) {
+    MoqtSubscribeErrorReason reason) {
   session_->GetControlStream()->SendSubscribeError(
       request_id_, reason.error_code, reason.reason_phrase);
   session_->published_subscriptions_.erase(request_id_);
@@ -2034,20 +2032,20 @@
 }
 
 void MoqtSession::PublishedSubscription::OnNewObjectAvailable(
-    Location sequence, uint64_t subgroup) {
-  if (!InWindow(sequence)) {
+    Location location, uint64_t subgroup, MoqtPriority publisher_priority) {
+  if (!InWindow(location)) {
     return;
   }
-  DataStreamIndex index(sequence.group, subgroup);
+  DataStreamIndex index(location.group, subgroup);
   if (reset_subgroups_.contains(index)) {
     // This subgroup has already been reset, ignore.
     return;
   }
   if (session_->alternate_delivery_timeout_ &&
       !delivery_timeout_.IsInfinite() && largest_sent_.has_value() &&
-      sequence.group >= largest_sent_->group) {
+      location.group >= largest_sent_->group) {
     // Start the delivery timeout timer on all previous groups.
-    for (uint64_t group = first_active_group_; group < sequence.group;
+    for (uint64_t group = first_active_group_; group < location.group;
          ++group) {
       for (webtransport::StreamId stream_id :
            stream_map().GetStreamsForGroup(group)) {
@@ -2063,12 +2061,15 @@
       }
     }
   }
-  QUICHE_DCHECK_GE(sequence.group, first_active_group_);
+  QUICHE_DCHECK_GE(location.group, first_active_group_);
 
-  MoqtForwardingPreference forwarding_preference =
-      track_publisher_->GetForwardingPreference();
-  if (forwarding_preference == MoqtForwardingPreference::kDatagram) {
-    SendDatagram(sequence);
+  std::optional<MoqtForwardingPreference> forwarding_preference =
+      track_publisher_->forwarding_preference();
+  if (!forwarding_preference.has_value()) {
+    return;
+  }
+  if (*forwarding_preference == MoqtForwardingPreference::kDatagram) {
+    SendDatagram(location);
     return;
   }
 
@@ -2079,8 +2080,8 @@
     raw_stream = session_->session_->GetStreamById(*stream_id);
   } else {
     raw_stream = session_->OpenOrQueueDataStream(
-        request_id_,
-        NewStreamParameters(sequence.group, subgroup, sequence.object));
+        request_id_, NewStreamParameters(location.group, subgroup,
+                                         location.object, publisher_priority));
   }
   if (raw_stream == nullptr) {
     return;
@@ -2188,13 +2189,20 @@
 }
 
 webtransport::SendOrder MoqtSession::PublishedSubscription::GetSendOrder(
-    Location sequence, uint64_t subgroup) const {
+    Location sequence, uint64_t subgroup,
+    MoqtPriority publisher_priority) const {
+  QUICHE_BUG_IF(GetSendOrder_no_forwarding_preference,
+                !track_publisher_->forwarding_preference().has_value())
+      << "No forwarding preference";
   MoqtForwardingPreference forwarding_preference =
-      track_publisher_->GetForwardingPreference();
-
-  MoqtPriority publisher_priority = track_publisher_->GetPublisherPriority();
-  MoqtDeliveryOrder delivery_order = subscriber_delivery_order().value_or(
-      track_publisher_->GetDeliveryOrder());
+      track_publisher_->forwarding_preference().value_or(
+          MoqtForwardingPreference::kSubgroup);
+  QUICHE_BUG_IF(GetSendOrder_no_delivery_order,
+                !track_publisher_->delivery_order().has_value())
+      << "No delivery order";
+  MoqtDeliveryOrder delivery_order =
+      track_publisher_->delivery_order().value_or(
+          MoqtDeliveryOrder::kAscending);
   if (forwarding_preference == MoqtForwardingPreference::kDatagram) {
     return SendOrderForDatagram(subscriber_priority_, publisher_priority,
                                 sequence.group, sequence.object,
@@ -2213,7 +2221,7 @@
           : queued_outgoing_data_streams_.rbegin()->first;
   webtransport::SendOrder send_order =
       GetSendOrder(Location(parameters.index.group, parameters.first_object),
-                   parameters.index.subgroup);
+                   parameters.index.subgroup, parameters.publisher_priority);
   // Zero out the subscriber priority bits, since these will be added when
   // updating the session.
   queued_outgoing_data_streams_.emplace(
@@ -2233,7 +2241,7 @@
     QUICHE_BUG(NextQueuedOutgoingDataStream_no_stream)
         << "NextQueuedOutgoingDataStream called when there are no streams "
            "pending.";
-    return NewStreamParameters(0, 0, 0);
+    return NewStreamParameters(0, 0, 0, 0);
   }
   auto it = queued_outgoing_data_streams_.rbegin();
   webtransport::SendOrder old_send_order = FinalizeSendOrder(it->first);
@@ -2280,6 +2288,7 @@
       stream_(stream),
       subscription_id_(subscription.request_id()),
       index_(parameters.index),
+      publisher_priority_(parameters.publisher_priority),
       // Always include extension header length, because it's difficult to know
       // a priori if they're going to appear on a stream.
       stream_type_(MoqtDataStreamType::Subgroup(
@@ -2335,14 +2344,8 @@
   }
 
   PublishedSubscription* subscription = it->second.get();
-  MoqtTrackPublisher& publisher = subscription->publisher();
-  absl::StatusOr<MoqtTrackStatusCode> status = publisher.GetTrackStatus();
-  if (!status.ok()) {
-    // TODO: clean up the subscription.
-    return nullptr;
-  }
-  if (!DoesTrackStatusImplyHavingData(*status)) {
-    QUICHE_BUG(GetSubscriptionIfValid_InvalidTrackStatus)
+  if (!subscription->publisher().largest_location().has_value()) {
+    QUICHE_BUG(GetSubscriptionIfValid_InvalidTrackStatusOk)
         << "The track publisher returned a status indicating that no objects "
            "are available, but a stream for those objects exists.";
     session_->Error(MoqtError::kInternalError,
@@ -2367,7 +2370,7 @@
 
     QUICHE_DCHECK_EQ(object->metadata.location.group, index_.group);
     QUICHE_DCHECK(object->metadata.subgroup == index_.subgroup);
-    QUICHE_DCHECK(subscription.publisher().GetForwardingPreference() ==
+    QUICHE_DCHECK(subscription.publisher().forwarding_preference() ==
                   MoqtForwardingPreference::kSubgroup);
     if (!subscription.InWindow(object->metadata.location)) {
       // It is possible that the next object became irrelevant due to a
@@ -2531,7 +2534,7 @@
   stream_->SetPriority(webtransport::StreamPriority{
       /*send_group_id=*/kMoqtSendGroupId,
       subscription.GetSendOrder(Location(index_.group, next_object_),
-                                index_.subgroup)});
+                                index_.subgroup, publisher_priority_)});
 }
 
 void MoqtSession::OutgoingDataStream::CreateAndSetAlarm(
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h
index 252267e..15d1d62 100644
--- a/quiche/quic/moqt/moqt_session.h
+++ b/quiche/quic/moqt/moqt_session.h
@@ -35,6 +35,7 @@
 #include "quiche/quic/moqt/moqt_track.h"
 #include "quiche/quic/moqt/namespace_tree.h"
 #include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/quiche_buffer_allocator.h"
 #include "quiche/common/quiche_mem_slice.h"
 #include "quiche/common/quiche_weak_ptr.h"
@@ -219,10 +220,13 @@
   struct NewStreamParameters {
     DataStreamIndex index;
     uint64_t first_object;
+    MoqtPriority publisher_priority;
 
     NewStreamParameters(uint64_t group, uint64_t subgroup,
-                        uint64_t first_object)
-        : index(group, subgroup), first_object(first_object) {}
+                        uint64_t first_object, MoqtPriority publisher_priority)
+        : index(group, subgroup),
+          first_object(first_object),
+          publisher_priority(publisher_priority) {}
   };
 
   class QUICHE_EXPORT ControlStream : public webtransport::StreamVisitor,
@@ -250,11 +254,12 @@
     void OnAnnounceMessage(const MoqtAnnounce& message) override;
     void OnAnnounceOkMessage(const MoqtAnnounceOk& message) override;
     void OnAnnounceErrorMessage(const MoqtAnnounceError& message) override;
-    void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) override;
-    void OnTrackStatusRequestMessage(
-        const MoqtTrackStatusRequest& message) override;
     void OnUnannounceMessage(const MoqtUnannounce& /*message*/) override;
-    void OnTrackStatusMessage(const MoqtTrackStatus& message) override {}
+    void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) override;
+    void OnTrackStatusMessage(const MoqtTrackStatus& message) override;
+    void OnTrackStatusOkMessage(const MoqtTrackStatusOk& message) override {}
+    void OnTrackStatusErrorMessage(
+        const MoqtTrackStatusError& message) override {}
     void OnGoAwayMessage(const MoqtGoAway& /*message*/) override;
     void OnSubscribeNamespaceMessage(
         const MoqtSubscribeNamespace& message) override;
@@ -376,11 +381,10 @@
 
     // MoqtObjectListener implementation.
     void OnSubscribeAccepted() override;
-    void OnSubscribeRejected(
-        MoqtSubscribeErrorReason reason,
-        std::optional<uint64_t> track_alias = std::nullopt) override;
+    void OnSubscribeRejected(MoqtSubscribeErrorReason reason) override;
     // This is only called for objects that have just arrived.
-    void OnNewObjectAvailable(Location location, uint64_t subgroup) override;
+    void OnNewObjectAvailable(Location location, uint64_t subgroup,
+                              MoqtPriority publisher_priority) override;
     void OnTrackPublisherGone() override;
     void OnNewFinAvailable(Location location, uint64_t subgroup) override;
     void OnSubgroupAbandoned(uint64_t group, uint64_t subgroup,
@@ -419,8 +423,8 @@
 
     std::vector<webtransport::StreamId> GetAllStreams() const;
 
-    webtransport::SendOrder GetSendOrder(Location sequence,
-                                         uint64_t subgroup) const;
+    webtransport::SendOrder GetSendOrder(Location sequence, uint64_t subgroup,
+                                         MoqtPriority publisher_priority) const;
 
     void AddQueuedOutgoingDataStream(const NewStreamParameters& parameters);
     // Pops the pending outgoing data stream, with the highest send order.
@@ -553,6 +557,7 @@
     webtransport::Stream* stream_;
     uint64_t subscription_id_;
     DataStreamIndex index_;
+    const MoqtPriority publisher_priority_;
     MoqtDataStreamType stream_type_;
     // Minimum object ID that should go out next. The session doesn't know the
     // exact ID of the next object in the stream because the next object could
@@ -622,43 +627,53 @@
     DownstreamTrackStatus(uint64_t request_id,
                           MoqtSession* absl_nonnull session,
                           MoqtTrackPublisher* absl_nonnull publisher)
-        : request_id_(request_id), session_(session), publisher_(publisher) {
-      publisher_->AddObjectListener(this);
-    }
+        : request_id_(request_id), session_(session), publisher_(publisher) {}
     ~DownstreamTrackStatus() {
       if (publisher_ != nullptr) {
         publisher_->RemoveObjectListener(this);
       }
     }
+    DownstreamTrackStatus(const DownstreamTrackStatus&) = delete;
+    DownstreamTrackStatus(DownstreamTrackStatus&&) = delete;
 
     void OnSubscribeAccepted() override {
-      MoqtTrackStatus track_status;
-      track_status.request_id = request_id_;
-      QUICHE_CHECK(publisher_ != nullptr);
-      absl::StatusOr<MoqtTrackStatusCode> status = publisher_->GetTrackStatus();
-      if (!status.ok()) {
-        session_->Error(MoqtError::kInternalError,
-                        "Failed to get track status");
+      if (publisher_ == nullptr) {
+        QUICHE_NOTREACHED();
         return;
       }
-      track_status.status_code = *status;
-      if (*status != MoqtTrackStatusCode::kDoesNotExist &&
-          *status != MoqtTrackStatusCode::kNotYetBegun) {
-        track_status.largest_location = publisher_->GetLargestLocation();
-      }  // Else, leave it at (0,0).
+      MoqtTrackStatusOk track_status_ok;
+      track_status_ok.request_id = request_id_;
+      track_status_ok.track_alias = 0;
+      QUICHE_BUG_IF(quic_bug_track_status_ok_no_expiration,
+                    !publisher_->expiration().has_value())
+          << "Request accepted without expiration";
+      track_status_ok.expires =
+          publisher_->expiration().value_or(quic::QuicTimeDelta::Zero());
+      QUICHE_BUG_IF(quic_bug_track_status_ok_no_delivery_order,
+                    !publisher_->delivery_order().has_value())
+          << "Request accepted without delivery order";
+      track_status_ok.group_order =
+          publisher_->delivery_order().value_or(MoqtDeliveryOrder::kAscending);
+      track_status_ok.largest_location = publisher_->largest_location();
       session_->SendControlMessage(
-          session_->framer_.SerializeTrackStatus(track_status));
+          session_->framer_.SerializeTrackStatusOk(track_status_ok));
       session_->incoming_track_status_.erase(request_id_);
       // No class access below this line!
     }
 
-    // TODO(martinduke): In draft-13, this will trigger TRACK_STATUS_ERROR.
-    void OnSubscribeRejected(MoqtSubscribeErrorReason /*error_code*/,
-                             std::optional<uint64_t> /*track_alias*/) override {
-      OnSubscribeAccepted();
+    void OnSubscribeRejected(MoqtSubscribeErrorReason error_reason) override {
+      MoqtTrackStatusError track_status_error;
+      track_status_error.request_id = request_id_;
+      track_status_error.error_code = error_reason.error_code;
+      track_status_error.reason_phrase = error_reason.reason_phrase;
+      session_->SendControlMessage(
+          session_->framer_.SerializeTrackStatusError(track_status_error));
+      session_->incoming_track_status_.erase(request_id_);
+      // No class access below this line!
     }
 
-    void OnNewObjectAvailable(Location sequence, uint64_t subgroup) override {}
+    void OnNewObjectAvailable(Location sequence, uint64_t subgroup,
+                              MoqtPriority publisher_priority) override {}
     void OnNewFinAvailable(Location location, uint64_t subgroup) override {}
     void OnSubgroupAbandoned(
         uint64_t group, uint64_t subgroup,
@@ -666,13 +681,8 @@
     void OnGroupAbandoned(uint64_t group_id) override {}
     void OnTrackPublisherGone() override {
       publisher_ = nullptr;
-      MoqtTrackStatus track_status;
-      track_status.request_id = request_id_;
-      track_status.status_code = MoqtTrackStatusCode::kDoesNotExist;
-      track_status.largest_location = Location(0, 0);
-      session_->SendControlMessage(
-          session_->framer_.SerializeTrackStatus(track_status));
-      session_->incoming_track_status_.erase(request_id_);
+      OnSubscribeRejected(MoqtSubscribeErrorReason(
+          RequestErrorCode::kTrackDoesNotExist, "Track publisher gone"));
     }
 
    private:
@@ -825,7 +835,8 @@
   absl::flat_hash_map<uint64_t, std::shared_ptr<PublishedFetch>>
       incoming_fetches_;
 
-  absl::flat_hash_map<uint64_t, DownstreamTrackStatus> incoming_track_status_;
+  absl::flat_hash_map<uint64_t, std::unique_ptr<DownstreamTrackStatus>>
+      incoming_track_status_;
 
   // Monitoring interfaces for expected incoming subscriptions.
   absl::flat_hash_map<FullTrackName, MoqtPublishingMonitorInterface*>
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc
index adfb917..c328160 100644
--- a/quiche/quic/moqt/moqt_session_test.cc
+++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -14,7 +14,6 @@
 #include <utility>
 
 #include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "absl/strings/match.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
@@ -27,6 +26,7 @@
 #include "quiche/quic/moqt/moqt_parser.h"
 #include "quiche/quic/moqt/moqt_priority.h"
 #include "quiche/quic/moqt/moqt_publisher.h"
+#include "quiche/quic/moqt/moqt_subscribe_windows.h"
 #include "quiche/quic/moqt/moqt_track.h"
 #include "quiche/quic/moqt/test_tools/moqt_framer_utils.h"
 #include "quiche/quic/moqt/test_tools/moqt_session_peer.h"
@@ -59,6 +59,7 @@
 constexpr uint64_t kDefaultPeerRequestId = 1;
 const MoqtDataStreamType kDefaultSubgroupStreamType =
     MoqtDataStreamType::Subgroup(2, 4, false);
+constexpr MoqtPriority kDefaultPublisherPriority = 0x80;
 
 FullTrackName kDefaultTrackName() { return FullTrackName("foo", "bar"); }
 
@@ -106,12 +107,14 @@
     FullTrackName track_name, MoqtForwardingPreference forwarding_preference,
     Location largest_sequence) {
   auto publisher = std::make_shared<MockTrackPublisher>(std::move(track_name));
-  ON_CALL(*publisher, GetTrackStatus())
-      .WillByDefault(Return(MoqtTrackStatusCode::kInProgress));
-  ON_CALL(*publisher, GetForwardingPreference())
-      .WillByDefault(Return(forwarding_preference));
-  ON_CALL(*publisher, GetLargestLocation())
+  ON_CALL(*publisher, largest_location())
       .WillByDefault(Return(largest_sequence));
+  ON_CALL(*publisher, forwarding_preference())
+      .WillByDefault(Return(forwarding_preference));
+  ON_CALL(*publisher, delivery_order)
+      .WillByDefault(Return(MoqtDeliveryOrder::kAscending));
+  ON_CALL(*publisher, expiration())
+      .WillByDefault(Return(quic::QuicTimeDelta::Zero()));
   return publisher;
 }
 
@@ -136,19 +139,20 @@
   MockTrackPublisher* CreateTrackPublisher() {
     auto publisher = std::make_shared<MockTrackPublisher>(kDefaultTrackName());
     publisher_.Add(publisher);
-    ON_CALL(*publisher, GetTrackStatus())
-        .WillByDefault(Return(MoqtTrackStatusCode::kNotYetBegun));
-    ON_CALL(*publisher, GetForwardingPreference())
-        .WillByDefault(Return(MoqtForwardingPreference::kSubgroup));
-    ON_CALL(*publisher, GetDeliveryOrder)
+    ON_CALL(*publisher, largest_location()).WillByDefault(Return(std::nullopt));
+    ON_CALL(*publisher, forwarding_preference())
+        .WillByDefault(Return(std::nullopt));
+    ON_CALL(*publisher, delivery_order)
         .WillByDefault(Return(MoqtDeliveryOrder::kAscending));
+    ON_CALL(*publisher, expiration())
+        .WillByDefault(Return(quic::QuicTimeDelta::Zero()));
     return publisher.get();
   }
 
   void SetLargestId(MockTrackPublisher* publisher, Location largest_id) {
-    ON_CALL(*publisher, GetTrackStatus())
-        .WillByDefault(Return(MoqtTrackStatusCode::kInProgress));
-    ON_CALL(*publisher, GetLargestLocation()).WillByDefault(Return(largest_id));
+    ON_CALL(*publisher, largest_location()).WillByDefault(Return(largest_id));
+    ON_CALL(*publisher, forwarding_preference)
+        .WillByDefault(Return(MoqtForwardingPreference::kSubgroup));
   }
 
   // The publisher receives SUBSCRIBE and synchronously announces it will
@@ -162,19 +166,14 @@
           listener_ptr = listener;
           listener->OnSubscribeAccepted();
         });
-    absl::StatusOr<MoqtTrackStatusCode> track_status =
-        publisher->GetTrackStatus();
-    if (!track_status.ok()) {
-      return nullptr;
-    }
     MoqtSubscribeOk expected_ok = {
         /*request_id=*/subscribe.request_id,
         track_alias,
-        /*expires=*/quic::QuicTimeDelta::FromMilliseconds(0),
-        /*group_order=*/MoqtDeliveryOrder::kAscending,
-        (*track_status == MoqtTrackStatusCode::kInProgress)
-            ? std::make_optional(publisher->GetLargestLocation())
-            : std::optional<Location>(),
+        /*expires=*/
+        publisher->expiration().value_or(quic::QuicTimeDelta::Zero()),
+        /*group_order=*/
+        publisher->delivery_order().value_or(MoqtDeliveryOrder::kAscending),
+        publisher->largest_location(),
         /*parameters=*/VersionSpecificParameters(),
     };
     EXPECT_CALL(mock_stream_, Writev(SerializedControlMessage(expected_ok), _));
@@ -530,6 +529,25 @@
             nullptr);
 }
 
+TEST_F(MoqtSessionTest, SynchronousSubscribeReturnsError) {
+  std::unique_ptr<MoqtControlParserVisitor> stream_input =
+      MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
+  MoqtSubscribe request = DefaultSubscribe();
+  MockTrackPublisher* track = CreateTrackPublisher();
+  EXPECT_CALL(*track, AddObjectListener)
+      .WillOnce(Invoke([&](MoqtObjectListener* listener) {
+        EXPECT_CALL(
+            mock_stream_,
+            Writev(ControlMessageOfType(MoqtMessageType::kSubscribeError), _));
+        EXPECT_CALL(*track, RemoveObjectListener);
+        listener->OnSubscribeRejected(MoqtSubscribeErrorReason(
+            RequestErrorCode::kInternalError, "Test error"));
+      }));
+  stream_input->OnSubscribeMessage(request);
+  EXPECT_EQ(MoqtSessionPeer::GetSubscription(&session_, kDefaultPeerRequestId),
+            nullptr);
+}
+
 TEST_F(MoqtSessionTest, SubscribeForPast) {
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
@@ -546,14 +564,12 @@
   MoqtSubscribe request = DefaultSubscribe();
   request.forward = false;
   request.filter_type = MoqtFilterType::kLatestObject;
-  EXPECT_CALL(*track, GetTrackStatus)
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kNotYetBegun));
   MoqtObjectListener* listener =
       ReceiveSubscribeSynchronousOk(track, request, stream_input.get());
   // forward=false, so incoming objects are ignored.
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .Times(0);
-  listener->OnNewObjectAvailable(Location(0, 0), 0);
+  listener->OnNewObjectAvailable(Location(0, 0), 0, kDefaultPublisherPriority);
 }
 
 TEST_F(MoqtSessionTest, SubscribeAbsoluteStartNoDataYet) {
@@ -562,14 +578,12 @@
   MockTrackPublisher* track = CreateTrackPublisher();
   MoqtSubscribe request = DefaultSubscribe();
   request.start = Location(1, 0);
-  EXPECT_CALL(*track, GetTrackStatus)
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kNotYetBegun));
   MoqtObjectListener* listener =
       ReceiveSubscribeSynchronousOk(track, request, stream_input.get());
   // Window was not set to (0, 0) by SUBSCRIBE acceptance.
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .Times(0);
-  listener->OnNewObjectAvailable(Location(0, 0), 0);
+  listener->OnNewObjectAvailable(Location(0, 0), 0, kDefaultPublisherPriority);
 }
 
 TEST_F(MoqtSessionTest, SubscribeNextGroup) {
@@ -584,11 +598,12 @@
   // Later objects in group 10 ignored.
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .Times(0);
-  listener->OnNewObjectAvailable(Location(10, 21), 0);
+  listener->OnNewObjectAvailable(Location(10, 21), 0,
+                                 kDefaultPublisherPriority);
   // Group 11 is sent.
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .WillOnce(Return(false));
-  listener->OnNewObjectAvailable(Location(11, 0), 0);
+  listener->OnNewObjectAvailable(Location(11, 0), 0, kDefaultPublisherPriority);
 }
 
 TEST_F(MoqtSessionTest, TwoSubscribesForTrack) {
@@ -1266,7 +1281,8 @@
   EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] {
     return std::optional<PublishedObject>();
   });
-  subscription->OnNewObjectAvailable(Location(5, 0), 0);
+  subscription->OnNewObjectAvailable(Location(5, 0), 0,
+                                     kDefaultPublisherPriority);
   EXPECT_TRUE(correct_message);
   EXPECT_FALSE(fin);
   EXPECT_EQ(MoqtSessionPeer::LargestSentForSubscription(&session_, 0),
@@ -1319,7 +1335,8 @@
   EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] {
     return std::optional<PublishedObject>();
   });
-  subscription->OnNewObjectAvailable(Location(5, 0), 0);
+  subscription->OnNewObjectAvailable(Location(5, 0), 0,
+                                     kDefaultPublisherPriority);
   EXPECT_TRUE(correct_message);
   EXPECT_TRUE(fin);
 }
@@ -1370,7 +1387,8 @@
   EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] {
     return std::optional<PublishedObject>();
   });
-  subscription->OnNewObjectAvailable(Location(5, 0), 0);
+  subscription->OnNewObjectAvailable(Location(5, 0), 0,
+                                     kDefaultPublisherPriority);
   EXPECT_TRUE(correct_message);
   EXPECT_TRUE(fin);
 
@@ -1435,7 +1453,8 @@
   EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] {
     return std::optional<PublishedObject>();
   });
-  subscription->OnNewObjectAvailable(Location(5, 0), 0);
+  subscription->OnNewObjectAvailable(Location(5, 0), 0,
+                                     kDefaultPublisherPriority);
   EXPECT_TRUE(correct_message);
   EXPECT_TRUE(fin);
 
@@ -1502,7 +1521,8 @@
   EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] {
     return std::optional<PublishedObject>();
   });
-  subscription->OnNewObjectAvailable(Location(5, 0), 0);
+  subscription->OnNewObjectAvailable(Location(5, 0), 0,
+                                     kDefaultPublisherPriority);
   EXPECT_TRUE(correct_message);
   EXPECT_TRUE(fin);
   EXPECT_CALL(mock_stream_, ResetWithUserCode(kResetCodeDeliveryTimeout));
@@ -1555,7 +1575,8 @@
   EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] {
     return std::optional<PublishedObject>();
   });
-  subscription->OnNewObjectAvailable(Location(5, 0), 0);
+  subscription->OnNewObjectAvailable(Location(5, 0), 0,
+                                     kDefaultPublisherPriority);
   EXPECT_TRUE(correct_message);
   EXPECT_FALSE(fin);
   fin = false;
@@ -1615,13 +1636,15 @@
   EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] {
     return std::optional<PublishedObject>();
   });
-  subscription->OnNewObjectAvailable(Location(5, 0), 0);
+  subscription->OnNewObjectAvailable(Location(5, 0), 0,
+                                     kDefaultPublisherPriority);
   EXPECT_FALSE(fin);
   // Try to deliver (5,1), but fail.
   EXPECT_CALL(mock_stream_, CanWrite()).WillRepeatedly([&] { return false; });
   EXPECT_CALL(*track, GetCachedObject).Times(0);
   EXPECT_CALL(mock_stream_, Writev).Times(0);
-  subscription->OnNewObjectAvailable(Location(5, 1), 0);
+  subscription->OnNewObjectAvailable(Location(5, 1), 0,
+                                     kDefaultPublisherPriority);
   // Notify that FIN arrived, but do nothing with it because (5, 1) isn't sent.
   EXPECT_CALL(mock_stream_, Writev).Times(0);
   subscription->OnNewFinAvailable(Location(5, 1), 0);
@@ -1699,7 +1722,8 @@
   EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillRepeatedly([] {
     return std::optional<PublishedObject>();
   });
-  subscription->OnNewObjectAvailable(Location(5, 0), 0);
+  subscription->OnNewObjectAvailable(Location(5, 0), 0,
+                                     kDefaultPublisherPriority);
 
   // Abandon the subgroup.
   EXPECT_CALL(mock_stream_, ResetWithUserCode(0x1)).Times(1);
@@ -1718,7 +1742,8 @@
   // Queue the outgoing stream.
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .WillOnce(Return(false));
-  subscription->OnNewObjectAvailable(Location(5, 0), 0);
+  subscription->OnNewObjectAvailable(Location(5, 0), 0,
+                                     kDefaultPublisherPriority);
 
   // Unblock the session, and cause the queued stream to be sent.
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
@@ -1762,8 +1787,10 @@
   // Queue the outgoing stream.
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .WillRepeatedly(Return(false));
-  subscription->OnNewObjectAvailable(Location(5, 0), 0);
-  subscription->OnNewObjectAvailable(Location(6, 0), 0);
+  subscription->OnNewObjectAvailable(Location(5, 0), 0,
+                                     kDefaultPublisherPriority);
+  subscription->OnNewObjectAvailable(Location(6, 0), 0,
+                                     kDefaultPublisherPriority);
   subscription->OnGroupAbandoned(5);
 
   // Unblock the session, and cause the queued stream to be sent. There should
@@ -1836,14 +1863,15 @@
   EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).WillOnce([] {
     return std::optional<PublishedObject>();
   });
-  subscription->OnNewObjectAvailable(Location(5, 0), 0);
-
+  subscription->OnNewObjectAvailable(Location(5, 0), 0,
+                                     kDefaultPublisherPriority);
   // Now that the stream exists and is recorded within subscription, make it
   // disappear by returning nullptr.
   EXPECT_CALL(mock_session_, GetStreamById(kOutgoingUniStreamId))
       .WillRepeatedly(Return(nullptr));
   EXPECT_CALL(*track, GetCachedObject(5, 0, 1)).Times(0);
-  subscription->OnNewObjectAvailable(Location(5, 1), 0);
+  subscription->OnNewObjectAvailable(Location(5, 1), 0,
+                                     kDefaultPublisherPriority);
 }
 
 TEST_F(MoqtSessionTest, OneBidirectionalStreamClient) {
@@ -1954,7 +1982,7 @@
                                 128},
         quiche::QuicheMemSlice::Copy("deadbeef")};
   });
-  listener->OnNewObjectAvailable(Location(5, 0), 0);
+  listener->OnNewObjectAvailable(Location(5, 0), 0, kDefaultPublisherPriority);
   EXPECT_TRUE(correct_message);
 }
 
@@ -2065,19 +2093,20 @@
   FullTrackName ftn("foo", "bar");
   auto track =
       SetupPublisher(ftn, MoqtForwardingPreference::kSubgroup, Location(0, 0));
-  EXPECT_CALL(*track, GetTrackStatus())
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kNotYetBegun));
   MoqtObjectListener* subscription =
       MoqtSessionPeer::AddSubscription(&session_, track, 0, 14, 0, 0);
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .WillOnce(Return(false))
       .WillOnce(Return(false))
       .WillOnce(Return(false));
-  EXPECT_CALL(*track, GetTrackStatus())
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress));
-  subscription->OnNewObjectAvailable(Location(1, 0), 0);
-  subscription->OnNewObjectAvailable(Location(0, 0), 0);
-  subscription->OnNewObjectAvailable(Location(2, 0), 0);
+  EXPECT_CALL(*track, forwarding_preference())
+      .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup));
+  subscription->OnNewObjectAvailable(Location(1, 0), 0,
+                                     kDefaultPublisherPriority);
+  subscription->OnNewObjectAvailable(Location(0, 0), 0,
+                                     kDefaultPublisherPriority);
+  subscription->OnNewObjectAvailable(Location(2, 0), 0,
+                                     kDefaultPublisherPriority);
   // These should be opened in the sequence (0, 0), (1, 0), (2, 0).
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .WillRepeatedly(Return(true));
@@ -2160,15 +2189,14 @@
   FullTrackName ftn("foo", "bar");
   auto track =
       SetupPublisher(ftn, MoqtForwardingPreference::kSubgroup, Location(0, 0));
-  EXPECT_CALL(*track, GetTrackStatus())
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kNotYetBegun));
   MoqtObjectListener* subscription =
       MoqtSessionPeer::AddSubscription(&session_, track, 0, 14, 0, 0);
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .WillOnce(Return(false));
-  EXPECT_CALL(*track, GetTrackStatus())
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress));
-  subscription->OnNewObjectAvailable(Location(0, 0), 0);
+  EXPECT_CALL(*track, forwarding_preference())
+      .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup));
+  subscription->OnNewObjectAvailable(Location(0, 0), 0,
+                                     kDefaultPublisherPriority);
 
   // Delete the subscription, then grant stream credit.
   MoqtSessionPeer::DeleteSubscription(&session_, 0);
@@ -2185,10 +2213,6 @@
   FullTrackName ftn2("dead", "beef");
   auto track2 =
       SetupPublisher(ftn2, MoqtForwardingPreference::kSubgroup, Location(0, 0));
-  EXPECT_CALL(*track1, GetTrackStatus())
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kNotYetBegun));
-  EXPECT_CALL(*track2, GetTrackStatus())
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kNotYetBegun));
   MoqtObjectListener* subscription0 =
       MoqtSessionPeer::AddSubscription(&session_, track1, 0, 14, 0, 0);
   MoqtObjectListener* subscription1 =
@@ -2202,14 +2226,18 @@
       .WillOnce(Return(false))
       .WillOnce(Return(false))
       .WillOnce(Return(false));
-  EXPECT_CALL(*track1, GetTrackStatus())
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress));
-  EXPECT_CALL(*track2, GetTrackStatus())
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress));
-  subscription0->OnNewObjectAvailable(Location(0, 0), 0);
-  subscription1->OnNewObjectAvailable(Location(0, 0), 0);
-  subscription0->OnNewObjectAvailable(Location(1, 0), 0);
-  subscription1->OnNewObjectAvailable(Location(1, 0), 0);
+  EXPECT_CALL(*track1, forwarding_preference())
+      .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup));
+  EXPECT_CALL(*track2, forwarding_preference())
+      .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup));
+  subscription0->OnNewObjectAvailable(Location(0, 0), 0,
+                                      kDefaultPublisherPriority);
+  subscription1->OnNewObjectAvailable(Location(0, 0), 0,
+                                      kDefaultPublisherPriority);
+  subscription0->OnNewObjectAvailable(Location(1, 0), 0,
+                                      kDefaultPublisherPriority);
+  subscription1->OnNewObjectAvailable(Location(1, 0), 0,
+                                      kDefaultPublisherPriority);
 
   // Allow one stream to be opened. It will be group 0, subscription 0.
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
@@ -2830,7 +2858,7 @@
       [&](std::unique_ptr<MoqtFetchTask> task) {
         fetch_task = std::move(task);
       },
-      Location(0, 0), 4, std::nullopt, 128, std::nullopt,
+      Location(0, 0), 4, std::nullopt, kDefaultPublisherPriority, std::nullopt,
       VersionSpecificParameters());
   MoqtFetchOk ok = {
       /*request_id=*/0,
@@ -2860,7 +2888,7 @@
       [&](std::unique_ptr<MoqtFetchTask> task) {
         fetch_task = std::move(task);
       },
-      Location(0, 0), 4, std::nullopt, 128, std::nullopt,
+      Location(0, 0), 4, std::nullopt, kDefaultPublisherPriority, std::nullopt,
       VersionSpecificParameters());
   MoqtFetchError error = {
       /*request_id=*/0,
@@ -2898,7 +2926,7 @@
           } while (result != MoqtFetchTask::GetNextObjectResult::kPending);
         });
       },
-      Location(0, 0), 4, std::nullopt, 128, std::nullopt,
+      Location(0, 0), 4, std::nullopt, kDefaultPublisherPriority, std::nullopt,
       VersionSpecificParameters());
   // Build queue of packets to arrive.
   std::queue<quiche::QuicheBuffer> headers;
@@ -2969,7 +2997,7 @@
         fetch_task->SetObjectAvailableCallback(
             [&]() { objects_available = true; });
       },
-      Location(0, 0), 4, std::nullopt, 128, std::nullopt,
+      Location(0, 0), 4, std::nullopt, kDefaultPublisherPriority, std::nullopt,
       VersionSpecificParameters());
   // Build queue of packets to arrive.
   std::queue<quiche::QuicheBuffer> headers;
@@ -3111,8 +3139,8 @@
 TEST_F(MoqtSessionTest, DeliveryTimeoutExpiredOnArrival) {
   auto track_publisher =
       std::make_shared<MockTrackPublisher>(FullTrackName("foo", "bar"));
-  EXPECT_CALL(*track_publisher, GetTrackStatus())
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress));
+  EXPECT_CALL(*track_publisher, forwarding_preference())
+      .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup));
   MoqtObjectListener* subscription =
       MoqtSessionPeer::AddSubscription(&session_, track_publisher, 1, 2, 0, 0);
   ASSERT_NE(subscription, nullptr);
@@ -3120,7 +3148,7 @@
                                       quic::QuicTimeDelta::FromSeconds(1));
 
   webtransport::test::MockStream data_mock;
-  EXPECT_CALL(*track_publisher, GetForwardingPreference())
+  EXPECT_CALL(*track_publisher, forwarding_preference())
       .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup));
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .WillOnce(Return(true));
@@ -3154,13 +3182,21 @@
         stream_visitor.reset();
       }));
   // Arrival time is very old; reset immediately.
-  subscription->OnNewObjectAvailable(Location(0, 0), 0);
+  ON_CALL(*track_publisher, largest_location)
+      .WillByDefault(Return(Location(0, 0)));
+  subscription->OnNewObjectAvailable(Location(0, 0), 0,
+                                     kDefaultPublisherPriority);
   // Subsequent objects for that subgroup are ignored.
   EXPECT_CALL(*track_publisher, GetCachedObject).Times(0);
   EXPECT_CALL(mock_session_, GetStreamById(_)).Times(0);
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .Times(0);
-  subscription->OnNewObjectAvailable(Location(0, 1), 0);
+  EXPECT_CALL(*track_publisher, forwarding_preference())
+      .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup));
+  ON_CALL(*track_publisher, largest_location)
+      .WillByDefault(Return(Location(0, 1)));
+  subscription->OnNewObjectAvailable(Location(0, 1), 0,
+                                     kDefaultPublisherPriority);
   // Check that reset_subgroups_ is pruned.
   EXPECT_TRUE(MoqtSessionPeer::SubgroupHasBeenReset(subscription,
                                                     DataStreamIndex(0, 0)));
@@ -3172,8 +3208,8 @@
 TEST_F(MoqtSessionTest, DeliveryTimeoutAfterIntegratedFin) {
   auto track_publisher =
       std::make_shared<MockTrackPublisher>(FullTrackName("foo", "bar"));
-  EXPECT_CALL(*track_publisher, GetTrackStatus())
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress));
+  EXPECT_CALL(*track_publisher, forwarding_preference())
+      .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup));
   MoqtObjectListener* subscription =
       MoqtSessionPeer::AddSubscription(&session_, track_publisher, 1, 2, 0, 0);
   ASSERT_NE(subscription, nullptr);
@@ -3181,7 +3217,7 @@
                                       quic::QuicTimeDelta::FromSeconds(1));
 
   webtransport::test::MockStream data_mock;
-  EXPECT_CALL(*track_publisher, GetForwardingPreference())
+  EXPECT_CALL(*track_publisher, forwarding_preference())
       .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup));
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .WillOnce(Return(true));
@@ -3208,7 +3244,10 @@
       .WillOnce(Return(std::nullopt));
   EXPECT_CALL(data_mock, Writev(_, _)).WillOnce(Return(absl::OkStatus()));
   EXPECT_CALL(data_mock, ResetWithUserCode(kResetCodeDeliveryTimeout)).Times(0);
-  subscription->OnNewObjectAvailable(Location(0, 0), 0);
+  ON_CALL(*track_publisher, largest_location)
+      .WillByDefault(Return(Location(0, 0)));
+  subscription->OnNewObjectAvailable(Location(0, 0), 0,
+                                     kDefaultPublisherPriority);
   auto* delivery_alarm = static_cast<quic::test::MockAlarmFactory::TestAlarm*>(
       MoqtSessionPeer::GetAlarm(stream_visitor.get()));
   EXPECT_CALL(data_mock, ResetWithUserCode(kResetCodeDeliveryTimeout))
@@ -3221,8 +3260,8 @@
 TEST_F(MoqtSessionTest, DeliveryTimeoutAfterSeparateFin) {
   auto track_publisher =
       std::make_shared<MockTrackPublisher>(FullTrackName("foo", "bar"));
-  EXPECT_CALL(*track_publisher, GetTrackStatus())
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress));
+  EXPECT_CALL(*track_publisher, forwarding_preference())
+      .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup));
   MoqtObjectListener* subscription =
       MoqtSessionPeer::AddSubscription(&session_, track_publisher, 1, 2, 0, 0);
   ASSERT_NE(subscription, nullptr);
@@ -3230,7 +3269,7 @@
                                       quic::QuicTimeDelta::FromSeconds(1));
 
   webtransport::test::MockStream data_mock;
-  EXPECT_CALL(*track_publisher, GetForwardingPreference())
+  EXPECT_CALL(*track_publisher, forwarding_preference())
       .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup));
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .WillOnce(Return(true));
@@ -3258,7 +3297,10 @@
           quiche::QuicheMemSlice(), false}))
       .WillOnce(Return(std::nullopt));
   EXPECT_CALL(data_mock, Writev(_, _)).WillOnce(Return(absl::OkStatus()));
-  subscription->OnNewObjectAvailable(Location(0, 0), 0);
+  ON_CALL(*track_publisher, largest_location())
+      .WillByDefault(Return(Location(0, 0)));
+  subscription->OnNewObjectAvailable(Location(0, 0), 0,
+                                     kDefaultPublisherPriority);
 
   EXPECT_CALL(data_mock, Writev(_, _)).WillOnce(Return(absl::OkStatus()));
   subscription->OnNewFinAvailable(Location(0, 0), 0);
@@ -3275,8 +3317,8 @@
   session_.UseAlternateDeliveryTimeout();
   auto track_publisher =
       std::make_shared<MockTrackPublisher>(FullTrackName("foo", "bar"));
-  EXPECT_CALL(*track_publisher, GetTrackStatus())
-      .WillRepeatedly(Return(MoqtTrackStatusCode::kInProgress));
+  EXPECT_CALL(*track_publisher, forwarding_preference())
+      .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup));
   MoqtObjectListener* subscription =
       MoqtSessionPeer::AddSubscription(&session_, track_publisher, 1, 2, 0, 0);
   ASSERT_NE(subscription, nullptr);
@@ -3284,7 +3326,7 @@
                                       quic::QuicTimeDelta::FromSeconds(1));
 
   webtransport::test::MockStream data_mock1;
-  EXPECT_CALL(*track_publisher, GetForwardingPreference())
+  EXPECT_CALL(*track_publisher, forwarding_preference())
       .WillRepeatedly(Return(MoqtForwardingPreference::kSubgroup));
   EXPECT_CALL(mock_session_, CanOpenNextOutgoingUnidirectionalStream())
       .WillRepeatedly(Return(true));
@@ -3312,7 +3354,10 @@
           quiche::QuicheMemSlice(), false}))
       .WillOnce(Return(std::nullopt));
   EXPECT_CALL(data_mock1, Writev(_, _)).WillOnce(Return(absl::OkStatus()));
-  subscription->OnNewObjectAvailable(Location(0, 0), 0);
+  ON_CALL(*track_publisher, largest_location)
+      .WillByDefault(Return(Location(0, 0)));
+  subscription->OnNewObjectAvailable(Location(0, 0), 0,
+                                     kDefaultPublisherPriority);
 
   webtransport::test::MockStream data_mock2;
   EXPECT_CALL(mock_session_, OpenOutgoingUnidirectionalStream())
@@ -3339,7 +3384,10 @@
           quiche::QuicheMemSlice(), false}))
       .WillOnce(Return(std::nullopt));
   EXPECT_CALL(data_mock2, Writev(_, _)).WillOnce(Return(absl::OkStatus()));
-  subscription->OnNewObjectAvailable(Location(1, 0), 0);
+  ON_CALL(*track_publisher, largest_location)
+      .WillByDefault(Return(Location(1, 0)));
+  subscription->OnNewObjectAvailable(Location(1, 0), 0,
+                                     kDefaultPublisherPriority);
 
   // Group 1 should start the timer on the Group 0 stream.
   auto* delivery_alarm = static_cast<quic::test::MockAlarmFactory::TestAlarm*>(
@@ -3416,6 +3464,12 @@
       Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceError),
              _));
   stream_input->OnSubscribeNamespaceMessage(MoqtSubscribeNamespace(7));
+  MoqtTrackStatus track_status = DefaultSubscribe();
+  track_status.request_id = 9;
+  EXPECT_CALL(
+      mock_stream_,
+      Writev(ControlMessageOfType(MoqtMessageType::kTrackStatusError), _));
+  stream_input->OnTrackStatusMessage(track_status);
   // Block all outgoing SUBSCRIBE, ANNOUNCE, GOAWAY,etc.
   EXPECT_CALL(mock_stream_, Writev).Times(0);
   MockSubscribeRemoteTrackVisitor remote_track_visitor;
@@ -3788,6 +3842,107 @@
   EXPECT_TRUE(IsInvalidArgument(task->GetStatus()));
 }
 
+TEST_F(MoqtSessionTest, IncomingTrackStatusThenSynchronousOk) {
+  webtransport::test::MockStream control_stream;
+  std::unique_ptr<MoqtControlParserVisitor> stream_input =
+      MoqtSessionPeer::CreateControlStream(&session_, &control_stream);
+  auto* track = CreateTrackPublisher();
+
+  MoqtTrackStatus track_status = DefaultSubscribe();
+  EXPECT_CALL(*track, AddObjectListener)
+      .WillOnce(Invoke([&](MoqtObjectListener* listener) {
+        EXPECT_CALL(*track, expiration)
+            .WillRepeatedly(
+                Return(quic::QuicTimeDelta::FromMilliseconds(10000)));
+        EXPECT_CALL(*track, delivery_order)
+            .WillRepeatedly(Return(MoqtDeliveryOrder::kAscending));
+        EXPECT_CALL(*track, largest_location)
+            .WillRepeatedly(Return(std::nullopt));
+        MoqtTrackStatusOk expected_ok;
+        expected_ok.request_id = track_status.request_id;
+        expected_ok.track_alias = 0;
+        expected_ok.expires = quic::QuicTimeDelta::FromMilliseconds(10000);
+        expected_ok.group_order = MoqtDeliveryOrder::kAscending;
+        expected_ok.largest_location = std::nullopt;
+        EXPECT_CALL(control_stream,
+                    Writev(SerializedControlMessage(expected_ok), _));
+        EXPECT_CALL(*track, RemoveObjectListener);
+        listener->OnSubscribeAccepted();
+      }));
+  stream_input->OnTrackStatusMessage(track_status);
+}
+
+TEST_F(MoqtSessionTest, IncomingTrackStatusThenAsynchronousOk) {
+  webtransport::test::MockStream control_stream;
+  std::unique_ptr<MoqtControlParserVisitor> stream_input =
+      MoqtSessionPeer::CreateControlStream(&session_, &control_stream);
+  auto* track = CreateTrackPublisher();
+
+  MoqtTrackStatus track_status = DefaultSubscribe();
+  MoqtObjectListener* listener = nullptr;
+  EXPECT_CALL(*track, AddObjectListener)
+      .WillOnce(testing::SaveArg<0>(&listener));
+  stream_input->OnTrackStatusMessage(track_status);
+  ASSERT_NE(listener, nullptr);
+  EXPECT_CALL(*track, expiration)
+      .WillRepeatedly(Return(quic::QuicTimeDelta::FromMilliseconds(10000)));
+  EXPECT_CALL(*track, delivery_order)
+      .WillRepeatedly(Return(MoqtDeliveryOrder::kAscending));
+  EXPECT_CALL(*track, largest_location).WillRepeatedly(Return(std::nullopt));
+  MoqtTrackStatusOk expected_ok;
+  expected_ok.request_id = track_status.request_id;
+  expected_ok.track_alias = 0;
+  expected_ok.expires = quic::QuicTimeDelta::FromMilliseconds(10000);
+  expected_ok.group_order = MoqtDeliveryOrder::kAscending;
+  expected_ok.largest_location = std::nullopt;
+  EXPECT_CALL(control_stream, Writev(SerializedControlMessage(expected_ok), _));
+  EXPECT_CALL(*track, RemoveObjectListener(listener));
+  listener->OnSubscribeAccepted();
+}
+
+TEST_F(MoqtSessionTest, IncomingTrackStatusThenSynchronousError) {
+  webtransport::test::MockStream control_stream;
+  std::unique_ptr<MoqtControlParserVisitor> stream_input =
+      MoqtSessionPeer::CreateControlStream(&session_, &control_stream);
+  auto* track = CreateTrackPublisher();
+
+  MoqtTrackStatus track_status = DefaultSubscribe();
+  bool executed_AddObjectListener = false;
+  EXPECT_CALL(*track, AddObjectListener)
+      .WillOnce(Invoke([&](MoqtObjectListener* listener) {
+        EXPECT_CALL(
+            control_stream,
+            Writev(ControlMessageOfType(MoqtMessageType::kTrackStatusError),
+                   _));
+        EXPECT_CALL(*track, RemoveObjectListener);
+        listener->OnSubscribeRejected(MoqtSubscribeErrorReason(
+            RequestErrorCode::kInternalError, "Test error"));
+        executed_AddObjectListener = true;
+      }));
+  stream_input->OnTrackStatusMessage(track_status);
+  EXPECT_TRUE(executed_AddObjectListener);
+}
+
+TEST_F(MoqtSessionTest, IncomingTrackStatusThenAsynchronousError) {
+  webtransport::test::MockStream control_stream;
+  std::unique_ptr<MoqtControlParserVisitor> stream_input =
+      MoqtSessionPeer::CreateControlStream(&session_, &control_stream);
+  auto* track = CreateTrackPublisher();
+
+  MoqtTrackStatus track_status = DefaultSubscribe();
+  MoqtObjectListener* listener;
+  EXPECT_CALL(*track, AddObjectListener)
+      .WillOnce(testing::SaveArg<0>(&listener));
+  stream_input->OnTrackStatusMessage(track_status);
+  ASSERT_NE(listener, nullptr);
+  EXPECT_CALL(
+      control_stream,
+      Writev(ControlMessageOfType(MoqtMessageType::kTrackStatusError), _));
+  EXPECT_CALL(*track, RemoveObjectListener(listener));
+  listener->OnSubscribeRejected(
+      MoqtSubscribeErrorReason(RequestErrorCode::kInternalError, "Test error"));
+}
+
 // TODO: re-enable this test once this behavior is re-implemented.
 #if 0
 TEST_F(MoqtSessionTest, SubscribeUpdateClosesSubscription) {
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
index f6b14b4..7656a9f 100644
--- a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
+++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
@@ -25,99 +25,6 @@
 
 namespace {
 
-struct TypeVisitor {
-  MoqtMessageType operator()(const MoqtClientSetup&) {
-    return MoqtMessageType::kClientSetup;
-  }
-  MoqtMessageType operator()(const MoqtServerSetup&) {
-    return MoqtMessageType::kServerSetup;
-  }
-  MoqtMessageType operator()(const MoqtSubscribe&) {
-    return MoqtMessageType::kSubscribe;
-  }
-  MoqtMessageType operator()(const MoqtSubscribeOk&) {
-    return MoqtMessageType::kSubscribeOk;
-  }
-  MoqtMessageType operator()(const MoqtSubscribeError&) {
-    return MoqtMessageType::kSubscribeError;
-  }
-  MoqtMessageType operator()(const MoqtUnsubscribe&) {
-    return MoqtMessageType::kUnsubscribe;
-  }
-  MoqtMessageType operator()(const MoqtSubscribeDone&) {
-    return MoqtMessageType::kSubscribeDone;
-  }
-  MoqtMessageType operator()(const MoqtSubscribeUpdate&) {
-    return MoqtMessageType::kSubscribeUpdate;
-  }
-  MoqtMessageType operator()(const MoqtAnnounce&) {
-    return MoqtMessageType::kAnnounce;
-  }
-  MoqtMessageType operator()(const MoqtAnnounceOk&) {
-    return MoqtMessageType::kAnnounceOk;
-  }
-  MoqtMessageType operator()(const MoqtAnnounceError&) {
-    return MoqtMessageType::kAnnounceError;
-  }
-  MoqtMessageType operator()(const MoqtAnnounceCancel&) {
-    return MoqtMessageType::kAnnounceCancel;
-  }
-  MoqtMessageType operator()(const MoqtTrackStatusRequest&) {
-    return MoqtMessageType::kTrackStatusRequest;
-  }
-  MoqtMessageType operator()(const MoqtUnannounce&) {
-    return MoqtMessageType::kUnannounce;
-  }
-  MoqtMessageType operator()(const MoqtTrackStatus&) {
-    return MoqtMessageType::kTrackStatus;
-  }
-  MoqtMessageType operator()(const MoqtGoAway&) {
-    return MoqtMessageType::kGoAway;
-  }
-  MoqtMessageType operator()(const MoqtSubscribeNamespace&) {
-    return MoqtMessageType::kSubscribeNamespace;
-  }
-  MoqtMessageType operator()(const MoqtSubscribeNamespaceOk&) {
-    return MoqtMessageType::kSubscribeNamespaceOk;
-  }
-  MoqtMessageType operator()(const MoqtSubscribeNamespaceError&) {
-    return MoqtMessageType::kSubscribeNamespaceError;
-  }
-  MoqtMessageType operator()(const MoqtUnsubscribeNamespace&) {
-    return MoqtMessageType::kUnsubscribeNamespace;
-  }
-  MoqtMessageType operator()(const MoqtMaxRequestId&) {
-    return MoqtMessageType::kMaxRequestId;
-  }
-  MoqtMessageType operator()(const MoqtFetch&) {
-    return MoqtMessageType::kFetch;
-  }
-  MoqtMessageType operator()(const MoqtFetchCancel&) {
-    return MoqtMessageType::kFetchCancel;
-  }
-  MoqtMessageType operator()(const MoqtFetchOk&) {
-    return MoqtMessageType::kFetchOk;
-  }
-  MoqtMessageType operator()(const MoqtFetchError&) {
-    return MoqtMessageType::kFetchError;
-  }
-  MoqtMessageType operator()(const MoqtRequestsBlocked&) {
-    return MoqtMessageType::kRequestsBlocked;
-  }
-  MoqtMessageType operator()(const MoqtPublish&) {
-    return MoqtMessageType::kPublish;
-  }
-  MoqtMessageType operator()(const MoqtPublishOk&) {
-    return MoqtMessageType::kPublishOk;
-  }
-  MoqtMessageType operator()(const MoqtPublishError&) {
-    return MoqtMessageType::kPublishError;
-  }
-  MoqtMessageType operator()(const MoqtObjectAck&) {
-    return MoqtMessageType::kObjectAck;
-  }
-};
-
 struct FramingVisitor {
   quiche::QuicheBuffer operator()(const MoqtClientSetup& message) {
     return framer.SerializeClientSetup(message);
@@ -152,18 +59,21 @@
   quiche::QuicheBuffer operator()(const MoqtAnnounceError& message) {
     return framer.SerializeAnnounceError(message);
   }
-  quiche::QuicheBuffer operator()(const MoqtAnnounceCancel& message) {
-    return framer.SerializeAnnounceCancel(message);
-  }
-  quiche::QuicheBuffer operator()(const MoqtTrackStatusRequest& message) {
-    return framer.SerializeTrackStatusRequest(message);
-  }
   quiche::QuicheBuffer operator()(const MoqtUnannounce& message) {
     return framer.SerializeUnannounce(message);
   }
+  quiche::QuicheBuffer operator()(const MoqtAnnounceCancel& message) {
+    return framer.SerializeAnnounceCancel(message);
+  }
   quiche::QuicheBuffer operator()(const MoqtTrackStatus& message) {
     return framer.SerializeTrackStatus(message);
   }
+  quiche::QuicheBuffer operator()(const MoqtTrackStatusOk& message) {
+    return framer.SerializeTrackStatusOk(message);
+  }
+  quiche::QuicheBuffer operator()(const MoqtTrackStatusError& message) {
+    return framer.SerializeTrackStatusError(message);
+  }
   quiche::QuicheBuffer operator()(const MoqtGoAway& message) {
     return framer.SerializeGoAway(message);
   }
@@ -211,6 +121,7 @@
   }
 
   MoqtFramer& framer;
+  bool is_track_status;
 };
 
 class GenericMessageParseVisitor : public MoqtControlParserVisitor {
@@ -251,18 +162,21 @@
   void OnAnnounceErrorMessage(const MoqtAnnounceError& message) {
     frames_.push_back(message);
   }
-  void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) {
-    frames_.push_back(message);
-  }
-  void OnTrackStatusRequestMessage(const MoqtTrackStatusRequest& message) {
-    frames_.push_back(message);
-  }
   void OnUnannounceMessage(const MoqtUnannounce& message) {
     frames_.push_back(message);
   }
+  void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) {
+    frames_.push_back(message);
+  }
   void OnTrackStatusMessage(const MoqtTrackStatus& message) {
     frames_.push_back(message);
   }
+  void OnTrackStatusOkMessage(const MoqtTrackStatusOk& message) {
+    frames_.push_back(message);
+  }
+  void OnTrackStatusErrorMessage(const MoqtTrackStatusError& message) {
+    frames_.push_back(message);
+  }
   void OnGoAwayMessage(const MoqtGoAway& message) {
     frames_.push_back(message);
   }
@@ -324,10 +238,6 @@
   return std::string(std::visit(FramingVisitor{framer}, frame).AsStringView());
 }
 
-MoqtMessageType MessageTypeForGenericMessage(const MoqtGenericFrame& frame) {
-  return std::visit(TypeVisitor(), frame);
-}
-
 std::vector<MoqtGenericFrame> ParseGenericMessage(absl::string_view body) {
   std::vector<MoqtGenericFrame> result;
   GenericMessageParseVisitor visitor(&result);
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.h b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
index 54a704c..b75a0c5 100644
--- a/quiche/quic/moqt/test_tools/moqt_framer_utils.h
+++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
@@ -25,19 +25,16 @@
 
 // TODO: remove MoqtObject from TestMessageBase::MessageStructuredData and merge
 // those two types.
-using MoqtGenericFrame =
-    std::variant<MoqtClientSetup, MoqtServerSetup, MoqtSubscribe,
-                 MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe,
-                 MoqtSubscribeDone, MoqtSubscribeUpdate, MoqtAnnounce,
-                 MoqtAnnounceOk, MoqtAnnounceError, MoqtAnnounceCancel,
-                 MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus,
-                 MoqtGoAway, MoqtSubscribeNamespace, MoqtSubscribeNamespaceOk,
-                 MoqtSubscribeNamespaceError, MoqtUnsubscribeNamespace,
-                 MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk,
-                 MoqtFetchError, MoqtRequestsBlocked, MoqtPublish,
-                 MoqtPublishOk, MoqtPublishError, MoqtObjectAck>;
-
-MoqtMessageType MessageTypeForGenericMessage(const MoqtGenericFrame& frame);
+using MoqtGenericFrame = std::variant<
+    MoqtClientSetup, MoqtServerSetup, MoqtSubscribe, MoqtSubscribeOk,
+    MoqtSubscribeError, MoqtUnsubscribe, MoqtSubscribeDone, MoqtSubscribeUpdate,
+    MoqtAnnounce, MoqtAnnounceOk, MoqtAnnounceError, MoqtUnannounce,
+    MoqtAnnounceCancel, MoqtTrackStatus, MoqtTrackStatusOk,
+    MoqtTrackStatusError, MoqtGoAway, MoqtSubscribeNamespace,
+    MoqtSubscribeNamespaceOk, MoqtSubscribeNamespaceError,
+    MoqtUnsubscribeNamespace, MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel,
+    MoqtFetchOk, MoqtFetchError, MoqtRequestsBlocked, MoqtPublish,
+    MoqtPublishOk, MoqtPublishError, MoqtObjectAck>;
 
 std::string SerializeGenericMessage(const MoqtGenericFrame& frame,
                                     bool use_webtrans = false);
diff --git a/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h b/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h
index c29edb6..76ca1fa 100644
--- a/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h
+++ b/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h
@@ -75,19 +75,21 @@
   void OnAnnounceErrorMessage(const MoqtAnnounceError& message) override {
     OnControlMessage(message);
   }
-  void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) override {
-    OnControlMessage(message);
-  }
-  void OnTrackStatusRequestMessage(
-      const MoqtTrackStatusRequest& message) override {
-    OnControlMessage(message);
-  }
   void OnUnannounceMessage(const MoqtUnannounce& message) override {
     OnControlMessage(message);
   }
+  void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) override {
+    OnControlMessage(message);
+  }
   void OnTrackStatusMessage(const MoqtTrackStatus& message) override {
     OnControlMessage(message);
   }
+  void OnTrackStatusOkMessage(const MoqtTrackStatusOk& message) override {
+    OnControlMessage(message);
+  }
+  void OnTrackStatusErrorMessage(const MoqtTrackStatusError& message) override {
+    OnControlMessage(message);
+  }
   void OnGoAwayMessage(const MoqtGoAway& message) override {
     OnControlMessage(message);
   }
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h
index 55edb39..bfe3d95 100644
--- a/quiche/quic/moqt/test_tools/moqt_test_message.h
+++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -61,17 +61,16 @@
  public:
   virtual ~TestMessageBase() = default;
 
-  using MessageStructuredData =
-      std::variant<MoqtClientSetup, MoqtServerSetup, MoqtObject, MoqtSubscribe,
-                   MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe,
-                   MoqtSubscribeDone, MoqtSubscribeUpdate, MoqtAnnounce,
-                   MoqtAnnounceOk, MoqtAnnounceError, MoqtAnnounceCancel,
-                   MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus,
-                   MoqtGoAway, MoqtSubscribeNamespace, MoqtSubscribeNamespaceOk,
-                   MoqtSubscribeNamespaceError, MoqtUnsubscribeNamespace,
-                   MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk,
-                   MoqtFetchError, MoqtRequestsBlocked, MoqtPublish,
-                   MoqtPublishOk, MoqtPublishError, MoqtObjectAck>;
+  using MessageStructuredData = std::variant<
+      MoqtClientSetup, MoqtServerSetup, MoqtObject, MoqtSubscribe,
+      MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe, MoqtSubscribeDone,
+      MoqtSubscribeUpdate, MoqtAnnounce, MoqtAnnounceOk, MoqtAnnounceError,
+      MoqtUnannounce, MoqtAnnounceCancel, MoqtTrackStatus, MoqtTrackStatusOk,
+      MoqtTrackStatusError, MoqtGoAway, MoqtSubscribeNamespace,
+      MoqtSubscribeNamespaceOk, MoqtSubscribeNamespaceError,
+      MoqtUnsubscribeNamespace, MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel,
+      MoqtFetchOk, MoqtFetchError, MoqtRequestsBlocked, MoqtPublish,
+      MoqtPublishOk, MoqtPublishError, MoqtObjectAck>;
 
   // The total actual size of the message.
   size_t total_message_size() const { return wire_image_size_; }
@@ -116,6 +115,7 @@
     memcpy(wire_image_, wire_image, wire_image_size);
     wire_image_size_ = wire_image_size;
   }
+  void SetByte(size_t offset, char value) { wire_image_[offset] = value; }
 
   // Expands all the varints in the message, alternating between making them 2,
   // 4, and 8 bytes long. Updates length fields accordingly.
@@ -629,6 +629,20 @@
     return TestMessageBase::MessageStructuredData(subscribe_);
   }
 
+ protected:
+  MoqtSubscribe subscribe_ = {
+      /*request_id=*/1,
+      FullTrackName("foo", "abcd"),
+      /*subscriber_priority=*/0x20,
+      /*group_order=*/MoqtDeliveryOrder::kDescending,
+      /*forward=*/true,
+      /*filter_type=*/MoqtFilterType::kAbsoluteStart,
+      /*start=*/Location(4, 1),
+      /*end_group=*/std::nullopt,
+      VersionSpecificParameters(quic::QuicTimeDelta::FromMilliseconds(10000),
+                                AuthTokenType::kOutOfBand, "bar"),
+  };
+
  private:
   uint8_t raw_packet_[31] = {
       0x03,
@@ -664,19 +678,6 @@
       0x61,
       0x72,  // authorization_tag = "bar"
   };
-
-  MoqtSubscribe subscribe_ = {
-      /*request_id=*/1,
-      FullTrackName("foo", "abcd"),
-      /*subscriber_priority=*/0x20,
-      /*group_order=*/MoqtDeliveryOrder::kDescending,
-      /*forward=*/true,
-      /*filter_type=*/MoqtFilterType::kAbsoluteStart,
-      /*start=*/Location(4, 1),
-      /*end_group=*/std::nullopt,
-      VersionSpecificParameters(quic::QuicTimeDelta::FromMilliseconds(10000),
-                                AuthTokenType::kOutOfBand, "bar"),
-  };
 };
 
 class QUICHE_NO_EXPORT SubscribeOkMessage : public TestMessageBase {
@@ -730,16 +731,8 @@
     SetWireImage(raw_packet_, sizeof(raw_packet_));
   }
 
- private:
-  uint8_t raw_packet_[17] = {
-      0x04, 0x00, 0x0e, 0x01, 0x02, 0x03,  // request_id, alias, expires
-      0x02, 0x01,                          // group_order = 2, content exists
-      0x0c, 0x14,                          // largest_location = (12, 20)
-      0x02,                                // 2 parameters
-      0x02, 0x67, 0x10,                    // delivery_timeout = 10000
-      0x04, 0x67, 0x10,                    // max_cache_duration = 10000
-  };
-
+ protected:
+  // This is protected so that TrackStatusOk can edit the fields.
   MoqtSubscribeOk subscribe_ok_ = {
       /*request_id=*/1,
       /*track_alias=*/2,
@@ -749,6 +742,16 @@
       VersionSpecificParameters(quic::QuicTimeDelta::FromMilliseconds(10000),
                                 quic::QuicTimeDelta::FromMilliseconds(10000)),
   };
+
+ private:
+  uint8_t raw_packet_[17] = {
+      0x04, 0x00, 0x0e, 0x01, 0x02, 0x03,  // request_id, alias, expires
+      0x02, 0x01,                          // group_order = 2, content exists
+      0x0c, 0x14,                          // largest_location = (12, 20)
+      0x02,                                // 2 parameters
+      0x02, 0x67, 0x10,                    // delivery_timeout = 10000
+      0x04, 0x67, 0x10,                    // max_cache_duration = 10000
+  };
 };
 
 class QUICHE_NO_EXPORT SubscribeErrorMessage : public TestMessageBase {
@@ -780,6 +783,13 @@
     return TestMessageBase::MessageStructuredData(subscribe_error_);
   }
 
+ protected:
+  MoqtSubscribeError subscribe_error_ = {
+      /*request_id=*/2,
+      /*error_code=*/RequestErrorCode::kInvalidRange,
+      /*reason_phrase=*/"bar",
+  };
+
  private:
   uint8_t raw_packet_[9] = {
       0x05, 0x00, 0x06,
@@ -787,12 +797,6 @@
       0x05,                    // error_code = 5
       0x03, 0x62, 0x61, 0x72,  // reason_phrase = "bar"
   };
-
-  MoqtSubscribeError subscribe_error_ = {
-      /*request_id=*/2,
-      /*error_code=*/RequestErrorCode::kInvalidRange,
-      /*reason_phrase=*/"bar",
-  };
 };
 
 class QUICHE_NO_EXPORT UnsubscribeMessage : public TestMessageBase {
@@ -1053,6 +1057,37 @@
   };
 };
 
+class QUICHE_NO_EXPORT UnannounceMessage : public TestMessageBase {
+ public:
+  UnannounceMessage() : TestMessageBase() {
+    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  }
+
+  bool EqualFieldValues(MessageStructuredData& values) const override {
+    auto cast = std::get<MoqtUnannounce>(values);
+    if (cast.track_namespace != unannounce_.track_namespace) {
+      QUIC_LOG(INFO) << "UNANNOUNCE track namespace mismatch";
+      return false;
+    }
+    return true;
+  }
+
+  void ExpandVarints() override { ExpandVarintsImpl("vv---"); }
+
+  MessageStructuredData structured_data() const override {
+    return TestMessageBase::MessageStructuredData(unannounce_);
+  }
+
+ private:
+  uint8_t raw_packet_[8] = {
+      0x09, 0x00, 0x05, 0x01, 0x03, 0x66, 0x6f, 0x6f,  // track_namespace
+  };
+
+  MoqtUnannounce unannounce_ = {
+      TrackNamespace("foo"),
+  };
+};
+
 class QUICHE_NO_EXPORT AnnounceCancelMessage : public TestMessageBase {
  public:
   AnnounceCancelMessage() : TestMessageBase() {
@@ -1097,131 +1132,66 @@
   };
 };
 
-class QUICHE_NO_EXPORT TrackStatusRequestMessage : public TestMessageBase {
+class QUICHE_NO_EXPORT TrackStatusMessage : public SubscribeMessage {
  public:
-  TrackStatusRequestMessage() : TestMessageBase() {
-    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  TrackStatusMessage() : SubscribeMessage() {
+    SetByte(0, static_cast<uint8_t>(MoqtMessageType::kTrackStatus));
   }
 
   bool EqualFieldValues(MessageStructuredData& values) const override {
-    auto cast = std::get<MoqtTrackStatusRequest>(values);
-    if (cast.request_id != track_status_request_.request_id) {
-      QUIC_LOG(INFO) << "TRACK STATUS REQUEST request ID mismatch";
-      return false;
-    }
-    if (cast.full_track_name != track_status_request_.full_track_name) {
-      QUIC_LOG(INFO) << "TRACK STATUS REQUEST track name mismatch";
-      return false;
-    }
-    if (cast.parameters != track_status_request_.parameters) {
-      QUIC_LOG(INFO) << "TRACK STATUS REQUEST parameter mismatch";
-      return false;
-    }
-    return true;
+    auto value = std::get<MoqtTrackStatus>(values);
+    auto* subscribe = reinterpret_cast<MoqtSubscribe*>(&value);
+    MessageStructuredData structured_data =
+        TestMessageBase::MessageStructuredData(*subscribe);
+    return SubscribeMessage::EqualFieldValues(structured_data);
   }
 
-  void ExpandVarints() override { ExpandVarintsImpl("vvv---v----vvv-----"); }
-
   MessageStructuredData structured_data() const override {
-    return TestMessageBase::MessageStructuredData(track_status_request_);
+    return TestMessageBase::MessageStructuredData(MoqtTrackStatus(subscribe_));
   }
-
- private:
-  uint8_t raw_packet_[22] = {
-      0x0d, 0x00, 0x13, 0x02,                    // request_id = 2
-      0x01, 0x03, 0x66, 0x6f, 0x6f,              // track_namespace = "foo"
-      0x04, 0x61, 0x62, 0x63, 0x64,              // track_name = "abcd"
-      0x01,                                      // 1 parameter
-      0x03, 0x05, 0x03, 0x00, 0x62, 0x61, 0x72,  // authorization_tag = "bar"
-  };
-
-  MoqtTrackStatusRequest track_status_request_ = {
-      /*request_id=*/2,
-      FullTrackName("foo", "abcd"),
-      VersionSpecificParameters(AuthTokenType::kOutOfBand, "bar"),
-  };
 };
 
-class QUICHE_NO_EXPORT UnannounceMessage : public TestMessageBase {
+class QUICHE_NO_EXPORT TrackStatusOkMessage : public SubscribeOkMessage {
  public:
-  UnannounceMessage() : TestMessageBase() {
-    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  TrackStatusOkMessage() : SubscribeOkMessage() {
+    SetByte(0, static_cast<uint8_t>(MoqtMessageType::kTrackStatusOk));
+    // Track alias is zero.
+    SetByte(4, 0x00);
+    subscribe_ok_.track_alias = 0;
   }
 
   bool EqualFieldValues(MessageStructuredData& values) const override {
-    auto cast = std::get<MoqtUnannounce>(values);
-    if (cast.track_namespace != unannounce_.track_namespace) {
-      QUIC_LOG(INFO) << "UNANNOUNCE track namespace mismatch";
-      return false;
-    }
-    return true;
+    auto value = std::get<MoqtTrackStatusOk>(values);
+    auto* subscribe = reinterpret_cast<MoqtSubscribeOk*>(&value);
+    MessageStructuredData structured_data =
+        TestMessageBase::MessageStructuredData(*subscribe);
+    return SubscribeOkMessage::EqualFieldValues(structured_data);
   }
 
-  void ExpandVarints() override { ExpandVarintsImpl("vv---"); }
-
   MessageStructuredData structured_data() const override {
-    return TestMessageBase::MessageStructuredData(unannounce_);
+    return TestMessageBase::MessageStructuredData(
+        MoqtTrackStatusOk(subscribe_ok_));
   }
-
- private:
-  uint8_t raw_packet_[8] = {
-      0x09, 0x00, 0x05, 0x01, 0x03, 0x66, 0x6f, 0x6f,  // track_namespace
-  };
-
-  MoqtUnannounce unannounce_ = {
-      TrackNamespace("foo"),
-  };
 };
 
-class QUICHE_NO_EXPORT TrackStatusMessage : public TestMessageBase {
+class QUICHE_NO_EXPORT TrackStatusErrorMessage : public SubscribeErrorMessage {
  public:
-  TrackStatusMessage() : TestMessageBase() {
-    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  TrackStatusErrorMessage() : SubscribeErrorMessage() {
+    SetByte(0, static_cast<uint8_t>(MoqtMessageType::kTrackStatusError));
   }
 
   bool EqualFieldValues(MessageStructuredData& values) const override {
-    auto cast = std::get<MoqtTrackStatus>(values);
-    if (cast.request_id != track_status_.request_id) {
-      QUIC_LOG(INFO) << "TRACK STATUS request ID mismatch";
-      return false;
-    }
-    if (cast.status_code != track_status_.status_code) {
-      QUIC_LOG(INFO) << "TRACK STATUS code mismatch";
-      return false;
-    }
-    if (cast.largest_location != track_status_.largest_location) {
-      QUIC_LOG(INFO) << "TRACK STATUS largest location mismatch";
-      return false;
-    }
-    if (cast.parameters != track_status_.parameters) {
-      QUIC_LOG(INFO) << "TRACK STATUS parameters mismatch";
-      return false;
-    }
-    return true;
+    auto value = std::get<MoqtTrackStatusError>(values);
+    auto* subscribe = reinterpret_cast<MoqtSubscribeError*>(&value);
+    MessageStructuredData structured_data =
+        TestMessageBase::MessageStructuredData(*subscribe);
+    return SubscribeErrorMessage::EqualFieldValues(structured_data);
   }
 
-  void ExpandVarints() override { ExpandVarintsImpl("v-vvvv--v--"); }
-
   MessageStructuredData structured_data() const override {
-    return TestMessageBase::MessageStructuredData(track_status_);
+    return TestMessageBase::MessageStructuredData(
+        MoqtTrackStatusError(subscribe_error_));
   }
-
- private:
-  uint8_t raw_packet_[14] = {
-      0x0e, 0x00, 0x0b, 0x02,  // request_id = 2
-      0x00, 0x0c, 0x14,        // status, last_group, last_object
-      0x02,                    // 2 parameters
-      0x02, 0x67, 0x10,        // Delivery Timeout = 10000
-      0x04, 0x67, 0x10,        // Max Cache Duration = 10000
-  };
-
-  MoqtTrackStatus track_status_ = {
-      /*request_id=*/2,
-      /*status_code=*/MoqtTrackStatusCode::kInProgress,
-      /*largest_location=*/Location(12, 20),
-      VersionSpecificParameters(quic::QuicTimeDelta::FromMilliseconds(10000),
-                                quic::QuicTimeDelta::FromMilliseconds(10000)),
-  };
 };
 
 class QUICHE_NO_EXPORT GoAwayMessage : public TestMessageBase {
@@ -2067,14 +2037,16 @@
       return std::make_unique<AnnounceOkMessage>();
     case MoqtMessageType::kAnnounceError:
       return std::make_unique<AnnounceErrorMessage>();
-    case MoqtMessageType::kAnnounceCancel:
-      return std::make_unique<AnnounceCancelMessage>();
-    case MoqtMessageType::kTrackStatusRequest:
-      return std::make_unique<TrackStatusRequestMessage>();
     case MoqtMessageType::kUnannounce:
       return std::make_unique<UnannounceMessage>();
+    case MoqtMessageType::kAnnounceCancel:
+      return std::make_unique<AnnounceCancelMessage>();
     case MoqtMessageType::kTrackStatus:
       return std::make_unique<TrackStatusMessage>();
+    case MoqtMessageType::kTrackStatusOk:
+      return std::make_unique<TrackStatusOkMessage>();
+    case MoqtMessageType::kTrackStatusError:
+      return std::make_unique<TrackStatusErrorMessage>();
     case MoqtMessageType::kGoAway:
       return std::make_unique<GoAwayMessage>();
     case MoqtMessageType::kSubscribeNamespace:
diff --git a/quiche/quic/moqt/tools/chat_server.cc b/quiche/quic/moqt/tools/chat_server.cc
index acc818c..4c64466 100644
--- a/quiche/quic/moqt/tools/chat_server.cc
+++ b/quiche/quic/moqt/tools/chat_server.cc
@@ -15,6 +15,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "quiche/quic/core/crypto/proof_source.h"
+#include "quiche/quic/core/quic_time.h"
 #include "quiche/quic/moqt/moqt_live_relay_queue.h"
 #include "quiche/quic/moqt/moqt_messages.h"
 #include "quiche/quic/moqt/moqt_priority.h"
@@ -197,7 +198,8 @@
 void ChatServer::AddUser(FullTrackName track_name) {
   // Add a local track.
   user_queues_[track_name] = std::make_shared<MoqtLiveRelayQueue>(
-      track_name, MoqtForwardingPreference::kSubgroup);
+      track_name, MoqtForwardingPreference::kSubgroup,
+      MoqtDeliveryOrder::kAscending, quic::QuicTime::Infinite());
   publisher_.Add(user_queues_[track_name]);
   for (auto& session : sessions_) {
     session.AnnounceIfSubscribed(track_name.track_namespace());
diff --git a/quiche/quic/moqt/tools/moqt_mock_visitor.h b/quiche/quic/moqt/tools/moqt_mock_visitor.h
index f786918..b3ff683 100644
--- a/quiche/quic/moqt/tools/moqt_mock_visitor.h
+++ b/quiche/quic/moqt/tools/moqt_mock_visitor.h
@@ -58,7 +58,7 @@
  public:
   explicit MockTrackPublisher(FullTrackName name)
       : track_name_(std::move(name)) {
-    ON_CALL(*this, GetDeliveryOrder())
+    ON_CALL(*this, delivery_order())
         .WillByDefault(testing::Return(MoqtDeliveryOrder::kAscending));
   }
   const FullTrackName& GetTrackName() const override { return track_name_; }
@@ -69,19 +69,20 @@
               (override));
   MOCK_METHOD(void, RemoveObjectListener, (MoqtObjectListener * listener),
               (override));
-  MOCK_METHOD(absl::StatusOr<MoqtTrackStatusCode>, GetTrackStatus, (),
+  MOCK_METHOD(std::optional<Location>, largest_location, (), (const, override));
+  MOCK_METHOD(std::optional<MoqtForwardingPreference>, forwarding_preference,
+              (), (const, override));
+  MOCK_METHOD(std::optional<MoqtDeliveryOrder>, delivery_order, (),
               (const, override));
-  MOCK_METHOD(Location, GetLargestLocation, (), (const, override));
-  MOCK_METHOD(MoqtForwardingPreference, GetForwardingPreference, (),
+  MOCK_METHOD(std::optional<quic::QuicTimeDelta>, expiration, (),
               (const, override));
-  MOCK_METHOD(MoqtPriority, GetPublisherPriority, (), (const, override));
-  MOCK_METHOD(MoqtDeliveryOrder, GetDeliveryOrder, (), (const, override));
   MOCK_METHOD(std::unique_ptr<MoqtFetchTask>, StandaloneFetch,
-              (Location, Location, MoqtDeliveryOrder), (override));
+              (Location, Location, std::optional<MoqtDeliveryOrder>),
+              (override));
   MOCK_METHOD(std::unique_ptr<MoqtFetchTask>, RelativeFetch,
-              (uint64_t, MoqtDeliveryOrder), (override));
+              (uint64_t, std::optional<MoqtDeliveryOrder>), (override));
   MOCK_METHOD(std::unique_ptr<MoqtFetchTask>, AbsoluteFetch,
-              (uint64_t, MoqtDeliveryOrder), (override));
+              (uint64_t, std::optional<MoqtDeliveryOrder>), (override));
 
  private:
   FullTrackName track_name_;