Simplify endpoint outcome state handling

src/protocol/tests/call.rs

@@ -4,7 +4,7 @@ use core::convert::Infallible;
 use rkyv::{Archive, Deserialize, Serialize};
 
 use crate::protocol::tree::{
-    Call, CallLeaf, ChildRoute, ConnectionState, Ingress, LeafRuntime, ProtocolEndpoint,
+    Call, CallLeaf, ChildRoute, EndpointOutcome, Ingress, LeafRuntime, ProtocolEndpoint,
     decode_call_input, encode_call_reply,
 };
 use crate::protocol::{PacketType, decode_frame};
@@ -64,7 +64,7 @@ fn leaf_runtime_dispatches_generated_call_procedure() {
         None,
         vec![ChildRoute {
             path: path(&["agent"]),
-            state: ConnectionState::Registered,
+            registered: true,
         }],
         Vec::new(),
     );
@@ -81,7 +81,7 @@ fn leaf_runtime_dispatches_generated_call_procedure() {
             .expect("request should encode"),
         )
         .expect("call should encode");
-    let Some((_, frame)) = controller_outcome.forward else {
+    let EndpointOutcome::Forward { frame, .. } = controller_outcome else {
         panic!("controller should forward call to child");
     };
 

src/protocol/tests/procedure.rs

@@ -2,7 +2,7 @@ use alloc::{borrow::ToOwned, collections::BTreeMap, format, string::String, vec,
 use core::convert::Infallible;
 
 use crate::protocol::tree::{
-    Call, ChildRoute, ConnectionState, Endpoint, HookKey, Ingress, OutgoingData, Procedure,
+    Call, ChildRoute, Endpoint, EndpointOutcome, HookKey, Ingress, OutgoingData, Procedure,
     ProcedureEffect, ProcedureRuntime, ProcedureStore, ProtocolEndpoint, encode_call_reply,
 };
 use crate::protocol::{PacketType, decode_frame};
@@ -80,7 +80,7 @@ fn procedure_runtime_routes_data_to_stored_session() {
         None,
         vec![ChildRoute {
             path: path(&["agent"]),
-            state: ConnectionState::Registered,
+            registered: true,
         }],
         Vec::new(),
     );
@@ -94,7 +94,10 @@ fn procedure_runtime_routes_data_to_stored_session() {
             encode_call_reply(&String::from("prefix:")).expect("procedure input should encode"),
         )
         .expect("open call should encode");
-    let Some((_, open_frame)) = open.forward else {
+    let EndpointOutcome::Forward {
+        frame: open_frame, ..
+    } = open
+    else {
         panic!("controller should forward opening call");
     };
     runtime
@@ -110,7 +113,10 @@ fn procedure_runtime_routes_data_to_stored_session() {
             true,
         )
         .expect("data should encode");
-    let Some((_, data_frame)) = data.forward else {
+    let EndpointOutcome::Forward {
+        frame: data_frame, ..
+    } = data
+    else {
         panic!("controller should forward data frame");
     };
     let outcome = runtime
@@ -129,7 +135,7 @@ fn procedure_runtime_routes_data_to_stored_session() {
     let forwarded = controller
         .receive(&Ingress::Child(path(&["agent"])), response_frame.clone())
         .expect("controller should receive session response");
-    assert!(forwarded.event.is_some());
+    assert!(matches!(forwarded, EndpointOutcome::Local(_)));
     assert!(runtime.leaf_mut().procedure_sessions().is_empty());
 }
 
@@ -204,7 +210,7 @@ fn procedure_runtime_keeps_session_after_local_end_until_explicit_close() {
         None,
         vec![ChildRoute {
             path: path(&["agent"]),
-            state: ConnectionState::Registered,
+            registered: true,
         }],
         Vec::new(),
     );
@@ -218,7 +224,10 @@ fn procedure_runtime_keeps_session_after_local_end_until_explicit_close() {
             encode_call_reply(&()).expect("unit call should encode"),
         )
         .expect("open call should encode");
-    let Some((_, open_frame)) = open.forward else {
+    let EndpointOutcome::Forward {
+        frame: open_frame, ..
+    } = open
+    else {
         panic!("controller should forward opening call");
     };
     runtime
@@ -234,7 +243,10 @@ fn procedure_runtime_keeps_session_after_local_end_until_explicit_close() {
             false,
         )
         .expect("local end trigger should encode");
-    let Some((_, local_end_frame)) = local_end.forward else {
+    let EndpointOutcome::Forward {
+        frame: local_end_frame, ..
+    } = local_end
+    else {
         panic!("controller should forward local end trigger");
     };
     let outcome = runtime

src/protocol/tests/tree.rs

@@ -1,8 +1,8 @@
 use alloc::{borrow::ToOwned, string::String, vec, vec::Vec};
 
 use crate::protocol::tree::{
-    ChildRoute, DefaultRouteProvider, Endpoint, Ingress, LeafNode, LeafSpec, LocalEvent,
-    ProtocolEndpoint, RouteDecision, RouteProvider, TreeNode,
+    ChildRoute, DefaultRouteProvider, Endpoint, EndpointOutcome, Ingress, LeafNode, LeafSpec,
+    LocalEvent, ProtocolEndpoint, RouteDecision, RouteProvider, TreeNode,
 };
 use crate::protocol::{
     DataMessage, EndpointIntrospection, FaultMessage, PacketHeader, PacketType, ProtocolFault,
@@ -76,13 +76,11 @@ fn protocol_endpoint_introspection_returns_leaf_summary() {
         .receive(&Ingress::Local, frame)
         .expect("endpoint should handle introspection");
 
-    assert!(outcome.forward.is_none());
-
-    let LocalEvent::Data {
+    let EndpointOutcome::Local(LocalEvent::Data {
         header,
         message: response,
         ..
-    } = outcome.event.as_ref().expect("expected local data event")
+    }) = &outcome
     else {
         panic!("expected local data event");
     };
@@ -167,10 +165,8 @@ fn invalid_hook_peer_emits_local_fault_event() {
         .receive(&Ingress::Child(path(&["intruder"])), frame)
         .expect("invalid peer should be handled");
 
-    assert!(outcome.forward.is_none());
-    assert!(!outcome.dropped);
-
-    match outcome.event.as_ref().expect("expected local fault event") {
+    match &outcome {
+        EndpointOutcome::Local(event) => match event {
         LocalEvent::Fault {
             header, message, ..
         } => {
@@ -184,6 +180,8 @@ fn invalid_hook_peer_emits_local_fault_event() {
             );
         }
         other => panic!("expected fault event, got {other:?}"),
+        },
+        other => panic!("expected local fault event, got {other:?}"),
     }
 }
 
@@ -302,7 +300,7 @@ fn pending_hook_fault_is_delivered_before_activation() {
         )
         .expect("introspection should handle pending hook");
 
-    assert!(outcome.forward.is_some() || outcome.event.is_some());
+    assert!(!matches!(outcome, EndpointOutcome::Dropped));
 }
 
 #[test]