fix(Mountain): align provider selector format and add language inference

Fix the provider registration and lookup chain:
- Update CocoonService.RegisterProvider to use canonical selector format [{ "language": ... }] matching ProviderLookup's expectations
- Change SideCarIdentifier to always route to "cocoon-main" instead of extension_id, enabling FeatureMethods to invoke providers correctly
- Add language inference fallback in ProviderLookup: if document not in open state, derive language from file extension (.rs→rust, .ts→typescript, etc.)

This resolves provider lookup failures for language features like hover, completion, etc.

Author: NikolaRHristov

Source/Environment/LanguageFeatureProvider/ProviderLookup.rs

@@ -29,22 +29,83 @@ pub(super) async fn get_matching_provider(
 		.lock()
 		.map_err(MapApplicationStateLockErrorToCommonError)?;
 
-	if let Some(document) = open_documents.get(document_uri.as_str()) {
-		for provider in providers.values() {
-			if provider.ProviderType == feature_type {
-				if let Some(selector_array) = provider.Selector.as_array() {
-					for selector in selector_array {
-						if let Some(language) = selector.get("language").and_then(|l| l.as_str()) {
-							if language == document.LanguageIdentifier {
-								return Ok(Some(provider.clone()));
-							}
-						}
-					}
+	// Derive language: prefer DocumentState record, fall back to URI extension.
+	let LanguageId:String = if let Some(Document) = open_documents.get(document_uri.as_str()) {
+		Document.LanguageIdentifier.clone()
+	} else {
+		// Document not yet opened via model:open — infer from file extension.
+		document_uri
+			.path()
+			.split('.')
+			.next_back()
+			.map(|Ext| match Ext {
+				"rs" => "rust",
+				"ts" | "tsx" => "typescript",
+				"js" | "jsx" | "mjs" | "cjs" => "javascript",
+				"json" | "jsonc" => "json",
+				"toml" => "toml",
+				"yaml" | "yml" => "yaml",
+				"md" => "markdown",
+				"py" => "python",
+				"go" => "go",
+				"c" | "h" => "c",
+				"cpp" | "cc" | "cxx" | "hpp" => "cpp",
+				Other => Other,
+			})
+			.unwrap_or("plaintext")
+			.to_string()
+	};
+
+	for Provider in providers.values() {
+		if Provider.ProviderType != feature_type {
+			continue;
+		}
+		// Selector shapes (all stored as JSON from CocoonService.RegisterProvider):
+		//   Canonical: [{ "language": "typescript" }]
+		//   Wildcard:  [{ "language": "*" }]
+		//   Legacy obj: { "language": ["typescript"] }
+		//   Plain str: "*"
+		let Matched = if let Some(SelectorArray) = Provider.Selector.as_array() {
+			SelectorArray.iter().any(|S| {
+				match S.get("language") {
+					Some(L) if L.as_str() == Some(&LanguageId) => true,
+					Some(L) if L.as_str() == Some("*") => true,
+					Some(L) => L
+						.as_array()
+						.map(|Arr| {
+							Arr.iter().any(|Item| {
+								Item.as_str() == Some(&LanguageId) || Item.as_str() == Some("*")
+							})
+						})
+						.unwrap_or(false),
+					None => false,
 				}
-			}
+			})
+		} else if let Some(LangValue) = Provider.Selector.get("language") {
+			LangValue.as_str() == Some(&LanguageId)
+				|| LangValue.as_str() == Some("*")
+				|| LangValue
+					.as_array()
+					.map(|Arr| {
+						Arr.iter().any(|Item| {
+							Item.as_str() == Some(&LanguageId) || Item.as_str() == Some("*")
+						})
+					})
+					.unwrap_or(false)
+		} else if let Some(LangStr) = Provider.Selector.as_str() {
+			LangStr == &LanguageId || LangStr == "*"
+		} else {
+			false
+		};
+
+		if Matched {
+			return Ok(Some(Provider.clone()));
 		}
 	}
 
-	warn!("No provider found for {:?} on document {}", feature_type, document_uri);
+	warn!(
+		"[ProviderLookup] No {:?} provider for language '{}' (uri={})",
+		feature_type, LanguageId, document_uri
+	);
 	Ok(None)
 }

Source/RPC/CocoonService.rs

@@ -320,11 +320,15 @@ impl CocoonServiceImpl {
 	/// - `language_selector`: Language scope (e.g. "typescript")
 	/// - `extension_id`: Extension that registered this provider
 	fn RegisterProvider(&self, handle:u32, provider_type:ProviderType, language_selector:&str, extension_id:&str) {
+		// SideCarIdentifier = "cocoon-main" so FeatureMethods::invoke_provider can
+		// route back via Vine::Client::SendRequestToSideCar("cocoon-main", ...).
+		// Selector stored as array so ProviderLookup::get_matching_provider's
+		// `.as_array()` call finds the language entry: [{ "language": "typescript" }].
 		let dto = ProviderRegistrationDTO {
 			Handle:handle,
 			ProviderType:provider_type,
-			Selector:json!({ "language": [language_selector] }),
-			SideCarIdentifier:extension_id.to_string(),
+			Selector:json!([{ "language": language_selector }]),
+			SideCarIdentifier:"cocoon-main".to_string(),
 			ExtensionIdentifier:json!(extension_id),
 			Options:None,
 		};