fix(Mountain): Fix extension location URI marshalling for VS Code renderer

VS Code's URI revival system ignores objects lacking the `$mid === 1` marshalling marker. Without it, extension locations sent to the renderer become plain `UriComponents` bags where `.fsPath` and `.with` are undefined — the sidebar silently filters the entire batch out.

This change adds three functions in Extensions.rs:
- `Normalize_Location_To_UriComponents`: converts the scanner's raw `file://` URL string into VS Code's `UriComponents` object shape
- `Stamp_Mid_Uri`: attaches `$mid: 1` to any UriComponents that lack it
- `Parse_File_Url_To_UriComponents`: parses `file:///absolute/path` URLs into the required structure

Also extends `BuildInitialUrl` to recognize Mountain's own `{ uri: "file://…" }` format (written by the recently opened persistence) alongside VS Code's historical `folderUri`/`workspace.configPath` shapes for backward compatibility with imported profiles.

Extension locations in the sidebar now resolve correctly.

Author: NikolaRHristov

Source/Binary/Build/WindowBuild.rs

@@ -119,6 +119,14 @@ fn BuildInitialUrl(LocalhostUrl:&str) -> String {
 	// broadcast. Probe them in the same priority order the workbench
 	// itself uses in `getRecentlyOpenedWorkspaces`.
 	let Probe = |Entry:&serde_json::Value| -> Option<String> {
+		// Mountain's own writer emits `{ uri: "file://…", label }` (see
+		// `RecentlyOpened.json` on a freshly closed window). VS Code's
+		// historical `folderUri` / `workspace.configPath` shapes are kept
+		// as fallbacks so imported profiles and third-party writers keep
+		// working.
+		if let Some(Uri) = Entry.get("uri").and_then(|V| V.as_str()) {
+			return Some(Uri.to_string());
+		}
 		if let Some(Uri) = Entry.get("folderUri").and_then(|V| V.as_str()) {
 			return Some(Uri.to_string());
 		}

Source/IPC/WindServiceHandlers/Extensions.rs

@@ -9,6 +9,96 @@ use serde_json::{Value, json};
 
 use crate::{dev_log, RunTime::ApplicationRunTime::ApplicationRunTime};
 
+/// `MarshalledId.Uri` from VS Code's `src/vs/base/common/marshallingIds.ts`.
+/// VS Code's `transformAndReviveIncomingURIs` walks every property of every
+/// object returned from the IPC channel and only calls `URI.revive()` on
+/// nested objects that carry `$mid === 1`. Without this marker the extension
+/// location surfaces as a plain `UriComponents` bag; downstream
+/// `resources.joinPath(local.location, …)` then trips on
+/// `uri.with is not a function` the moment the sidebar tries to build an
+/// icon URL. Every UriComponents we produce has to carry `$mid: 1`.
+const MID_URI:u64 = 1;
+
+/// Reshape an `extensionLocation` field into VS Code's `UriComponents` object
+/// form. The extension scanner stores it as a raw `file://` URL string; the
+/// renderer's URI reviver is keyed off the `$mid` marshalling marker and only
+/// revives objects that carry it, so the emitted shape must always include
+/// `$mid: 1` alongside the usual `scheme / authority / path / query /
+/// fragment` fields - otherwise the sidebar silently filters the whole batch
+/// out (no `$mid` ⇒ no revive ⇒ `.fsPath` / `.with` undefined).
+fn Normalize_Location_To_UriComponents(Raw:Option<&Value>) -> Value {
+	let Base = match Raw {
+		Some(Value::Object(Map)) if Map.contains_key("scheme") => Value::Object(Map.clone()),
+		Some(Value::String(Url)) => Parse_File_Url_To_UriComponents(Url),
+		_ => json!({
+			"scheme": "file",
+			"authority": "",
+			"path": "/extensions/unknown",
+			"query": "",
+			"fragment": "",
+		}),
+	};
+	Stamp_Mid_Uri(Base)
+}
+
+/// Attach `$mid: 1` to a `UriComponents` object if it isn't already present.
+/// Guards against both missing markers (the common case; Mountain built the
+/// object ourselves) and pre-marked payloads (passthrough from an upstream
+/// service that already tagged it). Returns the input unchanged for any
+/// non-object value - callers are expected to have already produced a shape.
+fn Stamp_Mid_Uri(Input:Value) -> Value {
+	match Input {
+		Value::Object(mut Map) => {
+			Map.entry("$mid".to_string()).or_insert(json!(MID_URI));
+			Value::Object(Map)
+		}
+		Other => Other,
+	}
+}
+
+/// Minimal `file://` URL → `UriComponents` parser. Accepts
+/// `file:///absolute/path` (authority empty) and preserves the path verbatim.
+/// Non-`file:` schemes are parsed generically (scheme: path).
+fn Parse_File_Url_To_UriComponents(Url:&str) -> Value {
+	if let Some(Rest) = Url.strip_prefix("file://") {
+		// `file:///Volumes/...` → authority="", path="/Volumes/..."
+		let (Authority, Path) = match Rest.find('/') {
+			Some(0) => ("", Rest),
+			Some(Index) => (&Rest[..Index], &Rest[Index..]),
+			None => ("", ""),
+		};
+		return json!({
+			"scheme": "file",
+			"authority": Authority,
+			"path": Path,
+			"query": "",
+			"fragment": "",
+		});
+	}
+	if let Some((Scheme, PathPart)) = Url.split_once(':') {
+		let Trimmed = PathPart.trim_start_matches("//");
+		let (Authority, Path) = match Trimmed.find('/') {
+			Some(0) => ("", Trimmed),
+			Some(Index) => (&Trimmed[..Index], &Trimmed[Index..]),
+			None => ("", Trimmed),
+		};
+		return json!({
+			"scheme": Scheme,
+			"authority": Authority,
+			"path": Path,
+			"query": "",
+			"fragment": "",
+		});
+	}
+	json!({
+		"scheme": "file",
+		"authority": "",
+		"path": Url,
+		"query": "",
+		"fragment": "",
+	})
+}
+
 /// Return scanned extensions reshaped as VS Code's `ILocalExtension[]`
 /// so `ExtensionManagementChannelClient.getInstalled` can destructure
 /// `extension.identifier.id`, `extension.manifest.*`, and
@@ -31,9 +121,18 @@ pub async fn handle_extensions_get_installed(runtime:Arc<ApplicationRunTime>) ->
 			let Name = Manifest.get("name").and_then(Value::as_str).unwrap_or("unknown").to_string();
 			let Id = format!("{}.{}", Publisher, Name);
 
-			let Location = Manifest.get("extensionLocation").cloned().unwrap_or_else(|| {
-				json!({ "scheme": "file", "path": "/extensions/unknown", "authority": "" })
-			});
+			// VS Code's `URI.revive()` is a no-op on strings, so the scanner's
+			// `file://…` raw URL has to be reshaped into `UriComponents` here -
+			// otherwise every `location.fsPath` / `location.scheme` access in
+			// the sidebar silently returns `undefined` and the whole batch is
+			// filtered out. Normalize once, reuse for both the top-level
+			// `location` and the mirror inside `manifest.extensionLocation` so
+			// callers that read either field get the same shape.
+			let Location = Normalize_Location_To_UriComponents(Manifest.get("extensionLocation"));
+			let mut Manifest = Manifest;
+			if let Value::Object(ref mut Map) = Manifest {
+				Map.insert("extensionLocation".to_string(), Location.clone());
+			}
 
 			json!({
 				// IExtension (base)