chore(Mountain): standardize naming conventions and directory structure

- Rename `AppState` to `ApplicationState` across Mountain component to align with Land's architectural documentation
- Refactor `handlers` directory to `Handler` following project's PascalCase convention for core modules
- Update `runtime` references to `RunTime` matching updated terminology in README.md
- Normalize gRPC-related abbreviations (e.g. `VineGRPC` -> `VinegRPC`) per style guidelines
- Reorganize environment provider implementations to match `Common` trait definitions
- Adjust module declarations to use consistent naming for Effect-TS alignment

This restructuring improves codebase consistency with Land's final architecture while maintaining all existing functionality for Cocoon integration and gRPC communication.

Author: NikolaRHristov

README.md

@@ -40,21 +40,21 @@ frontend and the `Cocoon` extension host.
 
 - **Declarative Effect System:** Built on a custom Rust `ActionEffect` system
   defined in the `Common` crate. All business logic is described as declarative,
-  composable effects, which are executed by a central `AppRuntime`.
+  composable effects, which are executed by a central `ApplicationRunTime`.
 - **gRPC-Powered IPC:** Hosts a `tonic`-based gRPC server (`Vine`) to provide a
   strongly-typed, high-performance communication channel for the `Cocoon`
   extension host.
 - **Centralized State Management:** Utilizes a thread-safe, Tauri-managed
-  `AppState` to act as the single source of truth for the entire application's
-  state, from open documents to provider registrations.
+  `ApplicationState` to act as the single source of truth for the entire
+  application's state, from open documents to provider registrations.
 - **Native PTY Management:** Implements a full-featured integrated terminal
   service by spawning and managing native pseudo-terminals (`PTY`) using the
   `portable-pty` crate.
 - **Secure Storage Integration:** Leverages the native OS keychain via the
   `keyring` crate to securely store sensitive data like authentication tokens.
 - **Robust Command Dispatching:** A central `Track` dispatcher intelligently
   routes all incoming requests from the UI (`Wind`) and extensions (`Cocoon`) to
-  the appropriate native handlers or effects.
+  the appropriate native Handler or effects.
 
 ---
 
@@ -63,11 +63,11 @@ frontend and the `Cocoon` extension host.
 | Principle                       | Description                                                                                                                                        | Key Components Involved                             |
 | :------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------- |
 | **Implementation of Contracts** | Faithfully implement the abstract service `trait`s defined in the `Common` crate, providing the concrete logic for the application's architecture. | `environment/*` providers                           |
-| **Separation of Concerns**      | Isolate business logic in `handlers` modules, keeping the `environment` provider implementations clean and focused on delegation.                  | `environment/*`, `handlers/*`                       |
-| **Declarative Logic**           | Express all operations as `ActionEffect`s, which are executed by the `AppRuntime`. This makes logic composable, testable, and robust.              | `runtime/*`, `track/*`, `Common::effect`            |
-| **Centralized State**           | Maintain a single, thread-safe `AppState` struct managed by Tauri to ensure data consistency across the entire application.                        | `app_state/*`                                       |
+| **Separation of Concerns**      | Isolate business logic in `Handler` modules, keeping the `environment` provider implementations clean and focused on delegation.                  | `environment/*`, `Handler/*`                       |
+| **Declarative Logic**           | Express all operations as `ActionEffect`s, which are executed by the `ApplicationRunTime`. This makes logic composable, testable, and robust.              | `RunTime/*`, `track/*`, `Common::effect`            |
+| **Centralized State**           | Maintain a single, thread-safe `ApplicationState` struct managed by Tauri to ensure data consistency across the entire application.                | `app_state/*`                                       |
 | **Secure & Performant IPC**     | Utilize gRPC for all communication with the `Cocoon` sidecar, ensuring a well-defined and high-performance API boundary.                           | `vine/*`                                            |
-| **UI-Backend Decoupling**       | Interact with the `Wind` frontend exclusively through asynchronous Tauri commands and events, ensuring the backend is UI-agnostic.                 | `main.rs` (invoke handler), `handlers/*` (emitters) |
+| **UI-Backend Decoupling**       | Interact with the `Wind` frontend exclusively through asynchronous Tauri commands and events, ensuring the backend is UI-agnostic.                 | `main.rs` (invoke handler), `Handler/*` (emitters) |
 
 ---
 
@@ -76,8 +76,8 @@ frontend and the `Cocoon` extension host.
 To understand how `Mountain`'s internal components are structured and how they
 implement the application's core logic, please refer to the detailed technical
 breakdown in [`docs/Deep Dive.md`](docs/Deep%20Dive.md). This document explains
-the roles of the `AppRuntime`, `AppState`, `handlers`, `environment`, and the
-`Vine` gRPC layer.
+the roles of the `ApplicationRunTime`, `ApplicationState`, `Handler`, `environment`,
+and the `Vine` gRPC layer.
 
 ---
 
@@ -96,17 +96,17 @@ graph LR
 
     subgraph "Mountain (Native Rust/Tauri Backend)"
         TauriRuntime[Tauri App & Window]:::mountain
-        AppRuntime[AppRuntime Engine]:::mountain
-        AppState["AppState (Shared State)"]:::mountain
+        ApplicationRunTime[ApplicationRunTime Engine]:::mountain
+        ApplicationState["ApplicationState (Shared State)"]:::mountain
         TrackDispatcher[Track Dispatcher]:::mountain
-        VineGRPC[Vine gRPC Server]:::ipc
+        VinegRPC[Vine gRPC Server]:::ipc
         NativeHandlers[Native Logic Handlers]:::mountain
         CommonCrate["Common Crate (Traits & DTOs)"]:::common
 
-        TauriRuntime -- Manages --> AppState
-        TauriRuntime -- Manages --> AppRuntime
-        AppRuntime -- Executes effects via --> NativeHandlers
-        TrackDispatcher -- Routes requests to --> AppRuntime
+        TauriRuntime -- Manages --> ApplicationState
+        TauriRuntime -- Manages --> ApplicationRunTime
+        ApplicationRunTime -- Executes effects via --> NativeHandlers
+        TrackDispatcher -- Routes requests to --> ApplicationRunTime
     end
 
     subgraph "Clients"
@@ -118,8 +118,8 @@ graph LR
     WindUI -- Tauri Commands --> TrackDispatcher
     TrackDispatcher -- Tauri Events --> WindUI
 
-    VineGRPC -- gRPC Protocol <--> CocoonSidecar; class VineGRPC,CocoonSidecar ipc
-    VineGRPC -- Forwards requests to --> TrackDispatcher
+    VinegRPC -- gRPC Protocol <--> CocoonSidecar; class VinegRPC,CocoonSidecar ipc
+    VinegRPC -- Forwards requests to --> TrackDispatcher
 
     NativeHandlers -- Implements traits from --> CommonCrate
 ```
@@ -134,13 +134,13 @@ the architectural patterns defined in `Common`.
 ```
 Mountain/
 ├── Source/
-│   ├── main.rs                      # Tauri application entry point and setup.
-│   ├── app_state/                   # The central, thread-safe state store for the application.
-│   ├── environment/                 # Concrete implementations of the `Common` provider traits.
-│   ├── handlers/                    # The detailed business logic for each service domain.
-│   ├── runtime/                     # The `AppRuntime` engine that executes effects.
-│   ├── track/                       # The central request dispatcher.
-│   └── vine/                        # The gRPC server implementation (using `tonic`).
+│   ├── Binary.rs                    # Tauri application entry point and setup.
+│   ├── ApplicationState/            # The central, thread-safe state store for the application.
+│   ├── Environment/                 # Concrete implementations of the `Common` provider traits.
+│   ├── Handlers/                    # The detailed business logic for each service domain.
+│   ├── Runtime/                     # The `ApplicationRunTime` engine that executes effects.
+│   ├── Track/                       # The central request dispatcher.
+│   └── Vine/                        # The gRPC server implementation (using `tonic`).
 ├── proto/
 │   └── vine.proto                   # The gRPC contract definition file.
 └── build.rs                         # Build script to compile the .proto file into Rust code.
@@ -158,7 +158,7 @@ set up, build, and run the entire application.
 **Key Dependencies:**
 
 - `tauri`: `^2.x`
-- `tokio`: For the asynchronous runtime.
+- `tokio`: For the asynchronous RunTime.
 - `tonic`: For the gRPC server implementation.
 - `serde` & `serde_json`: For serialization.
 - `log` & `env_logger`: For logging.

SECURITY.md

@@ -59,7 +59,7 @@ not limited to):**
 - **Denial of Service (DoS):** If an Element can be made unresponsive or crash
   due to specially crafted input or excessive resource consumption.
 - **Path Traversal/Arbitrary File Access:** For Elements interacting with the
-  filesystem (like `River`, `Sun`, or `Mountain`'s FS handlers), ensuring that
+  filesystem (like `River`, `Sun`, or `Mountain`'s FS Handler), ensuring that
   path inputs are properly sanitized.
 - **Insecure IPC/Communication:** For Elements involved in inter-process
   communication (`Vine`, `Track`, `Echo`, `Mist`), vulnerabilities in the

Source/ApplicationState/ApplicationState.rs

@@ -9,18 +9,18 @@ use std::{
 };
 
 use log::{error, info, warn};
-use tauri::{AppHandle, Manager, Wry};
+use tauri::{ApplicationHandle, Manager, Wry};
 
-/// @module AppState
-/// @description Defines the main `AppState` struct, which is the central,
-/// shared, thread-safe state for the entire Mountain application. It is managed
-/// by Tauri and accessible to all commands and environment providers.
-use super::{Dto::*, Internal};
-use crate::handlers::commands::CommandHandler;
+// @module ApplicationState
+// @description Defines the main `ApplicationState` struct, which is the central,
+// shared, thread-safe state for the entire Mountain application. It is managed
+// by Tauri and accessible to all commands and environment providers.
+use super::{DTO::*, Internal};
+use crate::Handler::commands::CommandHandler;
 
-/// The central, shared, thread-safe state for the entire Mountain application.
+// The central, shared, thread-safe state for the entire Mountain application.
 #[derive(Clone)]
-pub struct AppState {
+pub struct ApplicationState {
 	// Workspace State
 	pub WorkspaceFolders:Arc<StdMutex<Vec<WorkspaceFolderStateDto>>>,
 	pub WorkspaceConfigurationPath:Arc<StdMutex<Option<PathBuf>>>,
@@ -59,21 +59,21 @@ pub struct AppState {
 	>,
 }
 
-impl Default for AppState {
+impl Default for ApplicationState {
 	fn default() -> Self {
-		info!("[AppState] Initializing default application state...");
+		info!("[ApplicationState] Initializing default application state...");
 		let AppNameForPaths = env!("CARGO_PKG_NAME");
 		let AppDataDirectoryPath = dirs::config_dir().map(|p| p.join(AppNameForPaths)).unwrap_or_else(|| {
-			warn!("[AppState] Could not get config dir. Using relative path.");
+			warn!("[ApplicationState] Could not get config dir. Using relative path.");
 			PathBuf::from(format!(".{}-appdata", AppNameForPaths))
 		});
 		Internal::EnsureDirectoryExists(&AppDataDirectoryPath);
 
 		let GlobalMementoFilePath = Internal::ResolveMementoStorageFilePath(&AppDataDirectoryPath, true, "");
 		let InitialGlobalMementoMap = Internal::LoadInitialMementoFromDisk(&GlobalMementoFilePath);
-		let InitialCommandRegistryMap = crate::handlers::commands::RegisterNativeCommands();
+		let InitialCommandRegistryMap = crate::Handler::commands::RegisterNativeCommands();
 
-		info!("[AppState] Default state initialization complete.");
+		info!("[ApplicationState] Default state initialization complete.");
 		Self {
 			WorkspaceFolders:Arc::new(StdMutex::new(Vec::new())),
 			WorkspaceConfigurationPath:Arc::new(StdMutex::new(None)),
@@ -104,7 +104,7 @@ impl Default for AppState {
 	}
 }
 
-impl AppState {
+impl ApplicationState {
 	// All helper methods from the provided source are preserved here...
 	pub fn GetWorkspaceIdentifier(&self) -> Result<String, String> {
 		// ...
@@ -120,7 +120,7 @@ impl AppState {
 
 	pub fn GetNextTerminalIdentifier(&self) -> u64 { self.NextTerminalIdentifier.fetch_add(1, AtomicOrdering::Relaxed) }
 
-	pub async fn ScanExtensions(&self, AppHandle:&AppHandle<Wry>) { /* ... */
+	pub async fn ScanExtensions(&self, ApplicationHandle:&ApplicationHandle<Wry>) { /* ...// 
 	}
 
 	pub fn UpdateWorkspaceMementoPathAndReload(&self, AppDataDirectory:&Path) -> Result<(), String> {

Source/ApplicationState/DTO/CustomDocumentStateDTO.rs

@@ -1,43 +1,42 @@
-
-
-/**
- * @module CustomDocumentStateDto
- * @description Defines the Data Transfer Object for storing the state of a single
- * custom editor document.
- */
+// @module CustomDocumentStateDto
+// @description Defines the Data Transfer Object for storing the state of a
+// single custom editor document.
+//
 
 #![allow(non_snake_case, non_camel_case_types)]
 
-use super::super::Internal::UrlSerdeHelper;
-use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
 use url::Url;
 
-/**
- * A struct that holds the state for a document being handled by a custom editor.
- * This is stored in `AppState` to track the lifecycle of custom documents.
- */
+use super::super::Internal::UrlSerdeHelper;
+
+// A struct that holds the state for a document being handled by a custom
+// editor. This is stored in `ApplicationState` to track the lifecycle of custom
+// documents.
+//
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "PascalCase")]
 pub struct CustomDocumentStateDto {
-    /// The URI of the document resource being edited.
-    #[serde(with = "UrlSerdeHelper")]
-    pub Uri: Url,
+	// The URI of the document resource being edited.
+	#[serde(with = "UrlSerdeHelper")]
+	pub Uri:Url,
 
-    /// The view type of the custom editor responsible for this document.
-    pub ViewType: String,
+	// The view type of the custom editor responsible for this document.
+	pub ViewType:String,
 
-    /// The identifier of the sidecar process where the custom editor provider lives.
-    pub SidecarIdentifier: String,
+	// The identifier of the sidecar process where the custom editor provider lives.
+	pub SidecarIdentifier:String,
 
-    /// A flag indicating if the document is currently editable by the user.
-    pub IsEditable: bool,
+	// A flag indicating if the document is currently editable by the user.
+	pub IsEditable:bool,
 
-    /// An optional identifier for a backup copy of the file's content.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub BackupId: Option<String>,
+	// An optional identifier for a backup copy of the file's content.
+	#[serde(skip_serializing_if = "Option::is_none")]
+	pub BackupId:Option<String>,
 
-    /// A map to store edit history or other versioning information.
-    /// In a real implementation, this might hold a more structured edit type.
-    pub Edits: HashMap<u32, serde_json::Value>,
+	// A map to store edit history or other versioning information.
+	// In a real implementation, this might hold a more structured edit type.
+	pub Edits:HashMap<u32, serde_json::Value>,
 }

Source/ApplicationState/DTO/WebViewStateDto.rs

@@ -1,47 +1,44 @@
-
-
-/**
- * @module WebviewStateDto
- * @description Defines the Data Transfer Object for storing the state of a single
- * active webview panel.
- */
+// @module WebviewStateDto
+// @description Defines the Data Transfer Object for storing the state of a
+// single active webview panel.
+//
 
 #![allow(non_snake_case, non_camel_case_types)]
 
 use Common::webview::dto::{WebviewContentOptionsDto, WebviewPanelOptionsDto};
 use serde::{Deserialize, Serialize};
 
-/**
- * A struct that holds the complete state for a single webview panel instance.
- * This is stored in `AppState` to track all active webviews managed by the host.
- */
+// A struct that holds the complete state for a single webview panel instance.
+// This is stored in `ApplicationState` to track all active webviews managed by
+// the host.
+//
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "PascalCase")]
 pub struct WebviewStateDto {
-    /// A unique UUID handle for this webview instance.
-    pub Handle: String,
+	// A unique UUID handle for this webview instance.
+	pub Handle:String,
 
-    /// The view type of this webview panel, as defined by the extension.
-    pub ViewType: String,
+	// The view type of this webview panel, as defined by the extension.
+	pub ViewType:String,
 
-    /// The current title of the webview panel.
-    pub Title: String,
+	// The current title of the webview panel.
+	pub Title:String,
 
-    /// The content and security options for the webview's content.
-    pub ContentOptions: WebviewContentOptionsDto,
+	// The content and security options for the webview's content.
+	pub ContentOptions:WebviewContentOptionsDto,
 
-    /// The options controlling the behavior of the webview panel itself.
-    pub PanelOptions: WebviewPanelOptionsDto,
+	// The options controlling the behavior of the webview panel itself.
+	pub PanelOptions:WebviewPanelOptionsDto,
 
-    /// The identifier of the sidecar process that owns this webview.
-    pub SidecarIdentifier: String,
+	// The identifier of the sidecar process that owns this webview.
+	pub SidecarIdentifier:String,
 
-    /// The identifier of the extension that owns this webview.
-    pub ExtensionId: String,
+	// The identifier of the extension that owns this webview.
+	pub ExtensionId:String,
 
-    /// A flag indicating if the webview panel currently has focus.
-    pub IsActive: bool,
+	// A flag indicating if the webview panel currently has focus.
+	pub IsActive:bool,
 
-    /// A flag indicating if the webview panel is currently visible in the UI.
-    pub IsVisible: bool,
+	// A flag indicating if the webview panel is currently visible in the UI.
+	pub IsVisible:bool,
 }

Source/ApplicationState/DTO/mod.rs

@@ -1,10 +1,8 @@
-
-
-/**
- * @module Dto (AppState)
- * @description This module aggregates and re-exports all Data Transfer Objects (DTOs)
- * that are used to represent the various components of the application's central state.
- */
+// @module DTO (ApplicationState)
+// @description This module aggregates and re-exports all Data Transfer Objects
+// (DTOs) that are used to represent the various components of the application's
+// central state.
+//
 
 #![allow(non_snake_case, non_camel_case_types)]
 
@@ -25,17 +23,19 @@ mod WindowStateDto;
 mod WorkspaceFolderStateDto;
 
 // --- Public Re-exports (alphabetical) ---
-pub use self::ConfigurationStateDto::MergedConfigurationStateDto;
-pub use self::CustomDocumentStateDto::CustomDocumentStateDto;
-pub use self::DocumentStateDto::DocumentStateDto;
-pub use self::ExtensionDescriptionStateDto::ExtensionDescriptionStateDto;
-pub use self::HierarchySessionContextDto::HierarchySessionContextDto;
-pub use self::MarkerDataDto::MarkerDataDto;
-pub use self::OutputChannelStateDto::OutputChannelStateDto;
-pub use self::ProviderRegistrationDto::ProviderRegistrationDto;
-pub use self::RpcModelContentChangeDto::{RpcModelContentChangeDto, RpcRangeDto};
-pub use self::TerminalStateDto::TerminalStateDto;
-pub use self::TreeViewStateDto::TreeViewStateDto;
-pub use self::WebviewStateDto::WebviewStateDto;
-pub use self::WindowStateDto::WindowStateDto;
-pub use self::WorkspaceFolderStateDto::WorkspaceFolderStateDto;
+pub use self::{
+	ConfigurationStateDto::MergedConfigurationStateDto,
+	CustomDocumentStateDto::CustomDocumentStateDto,
+	DocumentStateDto::DocumentStateDto,
+	ExtensionDescriptionStateDto::ExtensionDescriptionStateDto,
+	HierarchySessionContextDto::HierarchySessionContextDto,
+	MarkerDataDto::MarkerDataDto,
+	OutputChannelStateDto::OutputChannelStateDto,
+	ProviderRegistrationDto::ProviderRegistrationDto,
+	RpcModelContentChangeDto::{RpcModelContentChangeDto, RpcRangeDto},
+	TerminalStateDto::TerminalStateDto,
+	TreeViewStateDto::TreeViewStateDto,
+	WebviewStateDto::WebviewStateDto,
+	WindowStateDto::WindowStateDto,
+	WorkspaceFolderStateDto::WorkspaceFolderStateDto,
+};