406 map commands phase 3 expose a single tauri command surface

host/conductora/src/map_commands/mod.rs

@@ -1,13 +1,5 @@
-pub mod all_spaces;
-pub mod root_space;
 pub mod serde_test;
-pub mod map_request;
 pub mod status;
-pub mod debug_serde;
 
-pub(crate) use root_space::*;
-pub(crate) use all_spaces::*;
 pub(crate) use status::*;
 pub(crate) use serde_test::*;
-pub(crate) use map_request::*;
-

host/conductora/src/map_commands/serde_test.rs

@@ -1,6 +1,5 @@
-
-use holons_client::shared_types::map_request::MapRequestWire;
-use tauri::{command };
+use map_commands::wire::MapIpcRequest;
+use tauri::command;
 
 #[command]
 pub async fn serde_test(
@@ -21,8 +20,7 @@ pub async fn serde_test(
         }
     }
 
-    //HERE add the type you want to check against in the from_str<>
-    match serde_json::from_str::<MapRequestWire>(&request_json) {
+    match serde_json::from_str::<MapIpcRequest>(&request_json) {
         Ok(request) => {
             tracing::info!("[TEST] Successfully parsed: {:?}", request);
             Ok("Parsed successfully".to_string())
@@ -57,20 +55,20 @@ pub async fn serde_test(
                     .nth(1)
                     .and_then(|s| s.split('`').next())
                     .unwrap_or("unknown");
-                format!("\n🔍 Missing field: `{}`", field_name)
+                format!("\nMissing field: `{}`", field_name)
             } else if error_string.contains("invalid type") {
                 format!(
-                    "\n🔍 Type mismatch - check field types match between TypeScript and Rust"
+                    "\nType mismatch - check field types match between TypeScript and Rust"
                 )
             } else {
                 String::new()
             };
 
             let error_msg = format!(
                 "Parse error at position {} (line {}, column {}):\n\
-                 📋 Error: {}\n\
-                 🏷️  Type: {}{}\n\
-                 📍 Context around column {}:\n{}",
+                 Error: {}\n\
+                 Type: {}{}\n\
+                 Context around column {}:\n{}",
                 column, line, column, e, classification, path_hint, column, error_snippet
             );
 
@@ -82,5 +80,5 @@ pub async fn serde_test(
             Err(short_error)
         }
     }
-    
+
 }

host/conductora/src/map_commands/status.rs

@@ -1,27 +1,18 @@
 use crate::runtime::RuntimeState;
-use holons_receptor::ReceptorFactory;
 use tauri::{command, State};
 
 #[command]
 pub async fn is_service_ready(
-    receptor_factory: State<'_, ReceptorFactory>,
     runtime_state: State<'_, RuntimeState>,
 ) -> Result<bool, String> {
     tracing::debug!("[TAURI COMMAND] 'is_service_ready' command invoked");
 
-    let receptors_loaded = receptor_factory.are_receptors_loaded();
-    let runtime_ready = runtime_state
+    let is_ready = runtime_state
         .read()
         .map(|guard| guard.is_some())
         .unwrap_or(false);
 
-    let is_ready = receptors_loaded && runtime_ready;
-    tracing::debug!(
-        "Service ready: {} (receptors={}, runtime={})",
-        is_ready,
-        receptors_loaded,
-        runtime_ready,
-    );
+    tracing::debug!("Service ready: {}", is_ready);
 
     Ok(is_ready)
-}
+}

host/conductora/src/setup/app_builder.rs

@@ -7,15 +7,13 @@ use crate::{
         app_config::load_storage_config, providers::holochain::holochain_plugin, storage_config::{StorageConfig, StorageProvider}
     },
     setup::{
-        holochain_setup::{ConductorClientState, HolochainSetup, HolochainWindowSetup}, local_setup::LocalSetup, window_setup::DefaultWindowSetup},
+        holochain_setup::{ConductorClientState, HolochainSetup, HolochainWindowSetup}, window_setup::DefaultWindowSetup},
 };
 
 use crate::setup::window_setup::ProviderWindowSetup;
-use crate::setup::receptor_config_registry::ReceptorConfigRegistry;
 use holons_client::init_client_runtime;
 use holons_trust_channel::TrustChannel;
 use map_commands::dispatch::{Runtime, RuntimeSession};
-use holons_receptor::ReceptorFactory;
 use tauri::{AppHandle, Manager, Listener};
 
 pub struct AppBuilder;
@@ -29,16 +27,10 @@ impl AppBuilder {
         // Base builder without setup
         let base = tauri::Builder::default()
             .manage(storage_cfg.clone())
-            .manage(ReceptorFactory::new())
-            .manage(ReceptorConfigRegistry::new())
             .manage::<ConductorClientState>(RwLock::new(None))
             .manage::<runtime::RuntimeState>(RwLock::new(None))
             .invoke_handler(tauri::generate_handler![
-                commands::root_space,
-                //commands::load_holons,
                 commands::serde_test,
-                commands::map_request,
-                commands::all_spaces,
                 commands::is_service_ready,
                 runtime::dispatch_map_command::dispatch_map_command,
             ]);
@@ -87,12 +79,6 @@ impl AppBuilder {
             tracing::error!("[APP BUILDER] Provider setup failed: {}", e);
         }
 
-        // Load receptor configs into factory
-        if let Err(e) = Self::load_receptor_configs(handle).await {
-            tracing::error!("[APP BUILDER] Failed to load receptor configs: {}", e);
-            return;
-        }
-
         // Construct the MAP Commands Runtime (if conductor client is available)
         Self::initialize_runtime(handle);
 
@@ -105,18 +91,6 @@ impl AppBuilder {
         tracing::info!("[APP BUILDER] Setup completed successfully.");
     }
 
-    /// Load receptor configs from registry into factory
-    async fn load_receptor_configs(handle: &AppHandle) -> Result<(), Box<dyn std::error::Error>> {
-        if let Some(registry) = handle.try_state::<ReceptorConfigRegistry>() {
-            let configs = registry.all();
-            if let Some(factory) = handle.try_state::<ReceptorFactory>() {
-                factory.load_from_configs(configs).await?;
-                tracing::debug!("[APP BUILDER] ReceptorFactory loaded from configs.");
-            }
-        }
-        Ok(())
-    }
-
     /// Apply provider-specific plugins based on the storage configuration
     fn apply_plugins(
         mut builder: tauri::Builder<tauri::Wry>,
@@ -163,10 +137,6 @@ impl AppBuilder {
 
         for (_name, provider) in storage_cfg.get_enabled_providers() {
             match provider.provider_type() {
-                "local" => {
-                    tracing::info!("[APP BUILDER] Running Local storage setup");
-                    LocalSetup::setup(handle.clone(), provider).await?;
-                }
                 "holochain" => {
                     tracing::info!("[APP BUILDER] Running Holochain setup");
                     HolochainSetup::setup(handle.clone(), provider).await?;