Compose cold-start resources under Runtime Supervisor ownership

crates/lazaret-host-coordinator/tests/lifecycle.rs

@@ -31,6 +31,32 @@ impl LifecycleAdapter for RecordingAdapter {
     }
 }
 
+struct PublicationFailureAdapter;
+
+impl LifecycleAdapter for PublicationFailureAdapter {
+    type Error = &'static str;
+
+    fn execute(
+        &mut self,
+        _action: LifecycleAction,
+        _generation: &Generation,
+    ) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn after_commit(
+        &mut self,
+        action: LifecycleAction,
+        _generation: &Generation,
+    ) -> Result<(), Self::Error> {
+        if action == LifecycleAction::PublishDomain {
+            Err("exposure failed")
+        } else {
+            Ok(())
+        }
+    }
+}
+
 #[derive(Clone)]
 struct TestAdmission {
     session: Session,
@@ -272,6 +298,58 @@ fn exact_start_join_disconnect_and_teardown_actions_are_ordered() {
     );
 }
 
+#[test]
+fn cold_start_entry_reaches_publication_in_exact_modeled_order() {
+    let directory = tempfile::tempdir().unwrap();
+    let store = open_store(&directory);
+    let (domain_adapter, session_adapter) = adapters();
+    let mut lifecycle = HostCoordinatorLifecycle::new(&store, domain_adapter, session_adapter);
+
+    lifecycle
+        .bootstrap_new_domain(generation(1), session(10, 1))
+        .unwrap();
+
+    assert_eq!(lifecycle.phase(), DomainPhase::Ready);
+    assert!(lifecycle.is_published());
+    assert_eq!(
+        lifecycle.into_adapters().0.actions.lock().unwrap().clone(),
+        vec![
+            LifecycleAction::StartNewDomain,
+            LifecycleAction::CreateTrustAnchor,
+            LifecycleAction::StartRuntimeSupervisor,
+            LifecycleAction::LeasePreparedLower,
+            LifecycleAction::MountStateAnchor,
+            LifecycleAction::StartSidecar,
+            LifecycleAction::StartConnectivityHelper,
+            LifecycleAction::MarkNetworkReady,
+            LifecycleAction::ArmRuntimeCausalEdge,
+            LifecycleAction::StartSandbox,
+            LifecycleAction::PublishDomain,
+        ]
+    );
+}
+
+#[test]
+fn publication_exposure_failure_retains_recoverable_durable_decision() {
+    let directory = tempfile::tempdir().unwrap();
+    let store = open_store(&directory);
+    let (_, session_adapter) = adapters();
+    let mut lifecycle =
+        HostCoordinatorLifecycle::new(&store, PublicationFailureAdapter, session_adapter);
+
+    assert!(
+        lifecycle
+            .bootstrap_new_domain(generation(1), session(10, 1))
+            .is_err()
+    );
+    assert_eq!(lifecycle.phase(), DomainPhase::Failed);
+    assert!(!lifecycle.is_published());
+    assert_eq!(
+        store.snapshot().unwrap().generations[0].durable_decision,
+        DurableDecision::Published
+    );
+}
+
 #[test]
 fn publication_and_invalid_transitions_fail_before_adapter_execution() {
     let directory = tempfile::tempdir().unwrap();