feat(Wind): Add History, Label, Model, and TextModelResolver services

Implement four new Effect-TS service layers in Wind that connect to Mountain via Tauri IPC:

- **HistoryService**: Manages editor navigation stack for back/forward traversal. IPC: history:goBack, goForward, canGoBack, canGoForward, push, clear, getStack.

- **LabelService**: Resolves human-readable display labels for URIs, workspace roots, and filenames (used in explorer, tabs, breadcrumbs). IPC: label:getUri, getWorkspace, getBase.

- **ModelService**: Lightweight in-memory text model registry. Maintains open documents with content/version/languageId. IPC: model:open, close, get, getAll, updateContent.

- **TextModelResolverService**: Resolves URIs to text model references with reference-counting dispose pattern (VS Code IReference<ITextModel>). Delegates to ModelService with ref counting.

Each service includes interface, stub implementation, live IPC layer, mock layer, Effect Context tag, and problem types following Wind's established pattern.

Also refactor TauriIPC invoke to use unified "mountain_ipc_invoke" command with {method, params} structure, and update all layer composition files to use Layer.provideMerge() chaining.

Author: NikolaRHristov

Source/Effect/History/History.ts

@@ -0,0 +1,6 @@
+export type { HistoryProblem } from "./Type/HistoryProblem.js";
+export type { HistoryService } from "./Interface/HistoryService.js";
+export { HistoryServiceTag, History } from "./Tag/HistoryServiceTag.js";
+export { StubHistoryService } from "./Implementation/HistoryStub.js";
+export { default as LiveHistoryServiceLayer } from "./Live.js";
+export { default as MockHistoryServiceLayer } from "./Mock.js";

Source/Effect/History/Implementation/HistoryStub.ts

@@ -0,0 +1,15 @@
+import { Effect } from "effect";
+
+import type { HistoryService } from "../Interface/HistoryService.js";
+
+export const StubHistoryService: HistoryService = {
+	GoBack: () => Effect.void,
+	GoForward: () => Effect.void,
+	CanGoBack: () => Effect.succeed(false),
+	CanGoForward: () => Effect.succeed(false),
+	Push: (_uri) => Effect.void,
+	Clear: () => Effect.void,
+	GetStack: () => Effect.succeed([]),
+};
+
+export default StubHistoryService;

Source/Effect/History/Interface/HistoryService.ts

@@ -0,0 +1,33 @@
+import type { Effect } from "effect";
+
+import type { HistoryProblem } from "../Type/HistoryProblem.js";
+
+/**
+ * Navigation history service interface.
+ * Microsoft VSCode Reference: IHistoryService from vs/workbench/services/history/browser/historyService.ts
+ *
+ * Tracks the editor navigation stack and allows back/forward traversal
+ * across recently visited files and cursor positions.
+ */
+export interface HistoryService {
+	/** Navigate to the previous location in the history stack. */
+	readonly GoBack: () => Effect.Effect<void, HistoryProblem>;
+
+	/** Navigate to the next location in the history stack. */
+	readonly GoForward: () => Effect.Effect<void, HistoryProblem>;
+
+	/** Returns true if there is a previous location to navigate to. */
+	readonly CanGoBack: () => Effect.Effect<boolean, HistoryProblem>;
+
+	/** Returns true if there is a next location to navigate to. */
+	readonly CanGoForward: () => Effect.Effect<boolean, HistoryProblem>;
+
+	/** Push a new URI onto the navigation stack, clearing forward history. */
+	readonly Push: (uri: string) => Effect.Effect<void, HistoryProblem>;
+
+	/** Clear the entire navigation history stack. */
+	readonly Clear: () => Effect.Effect<void, HistoryProblem>;
+
+	/** Return the full history stack as a list of URIs (oldest first). */
+	readonly GetStack: () => Effect.Effect<readonly string[], HistoryProblem>;
+}

Source/Effect/History/Live.ts

@@ -0,0 +1,86 @@
+/**
+ * @module Effect/History/Live
+ * @description
+ * Live implementation of HistoryService backed by Mountain's navigation
+ * history store via Tauri IPC. Drives back/forward navigation in the editor.
+ *
+ * IPC channels (WindServiceHandlers.rs):
+ *   history:goBack      → navigate to previous location
+ *   history:goForward   → navigate to next location
+ *   history:canGoBack   → whether back navigation is available
+ *   history:canGoForward → whether forward navigation is available
+ *   history:push        → push a URI onto the stack
+ *   history:clear       → clear the navigation stack
+ *   history:getStack    → return the full history stack
+ */
+
+import { Effect, Layer } from "effect";
+
+import { IPC } from "../IPC.js";
+import type { HistoryService } from "./Interface/HistoryService.js";
+import { HistoryServiceTag } from "./Tag/HistoryServiceTag.js";
+import type { HistoryProblem } from "./Type/HistoryProblem.js";
+
+const MakeHistoryProblem = (error: unknown): HistoryProblem => ({
+	_tag: "HistoryOperationFailed",
+	error: error instanceof Error ? error : new Error(String(error)),
+});
+
+export const LiveHistoryServiceLayer = Layer.effect(
+	HistoryServiceTag,
+	Effect.gen(function* () {
+		const IPCService = yield* IPC;
+
+		const Service: HistoryService = {
+			GoBack: () =>
+				IPCService.invoke("history:goBack")([]).pipe(
+					Effect.map(() => undefined as void),
+					Effect.mapError(MakeHistoryProblem),
+				),
+
+			GoForward: () =>
+				IPCService.invoke("history:goForward")([]).pipe(
+					Effect.map(() => undefined as void),
+					Effect.mapError(MakeHistoryProblem),
+				),
+
+			CanGoBack: () =>
+				IPCService.invoke("history:canGoBack")([]).pipe(
+					Effect.map((Result) => Result === true),
+					Effect.mapError(MakeHistoryProblem),
+				),
+
+			CanGoForward: () =>
+				IPCService.invoke("history:canGoForward")([]).pipe(
+					Effect.map((Result) => Result === true),
+					Effect.mapError(MakeHistoryProblem),
+				),
+
+			Push: (uri) =>
+				IPCService.invoke("history:push")([uri]).pipe(
+					Effect.map(() => undefined as void),
+					Effect.mapError(MakeHistoryProblem),
+				),
+
+			Clear: () =>
+				IPCService.invoke("history:clear")([]).pipe(
+					Effect.map(() => undefined as void),
+					Effect.mapError(MakeHistoryProblem),
+				),
+
+			GetStack: () =>
+				IPCService.invoke("history:getStack")([]).pipe(
+					Effect.map((Result) =>
+						Array.isArray(Result)
+							? (Result as readonly string[])
+							: [],
+					),
+					Effect.mapError(MakeHistoryProblem),
+				),
+		};
+
+		return Service;
+	}),
+);
+
+export default LiveHistoryServiceLayer;

Source/Effect/History/Mock.ts

@@ -0,0 +1,11 @@
+import { Layer } from "effect";
+
+import { StubHistoryService } from "./Implementation/HistoryStub.js";
+import { HistoryServiceTag } from "./Tag/HistoryServiceTag.js";
+
+export const MockHistoryServiceLayer = Layer.succeed(
+	HistoryServiceTag,
+	StubHistoryService,
+);
+
+export default MockHistoryServiceLayer;

Source/Effect/History/Tag/HistoryServiceTag.ts

@@ -0,0 +1,11 @@
+import { Context } from "effect";
+
+import type { HistoryService } from "../Interface/HistoryService.js";
+
+export class HistoryServiceTag extends Context.Tag(
+	"Application/HistoryService",
+)<HistoryServiceTag, HistoryService>() {}
+
+export const History = HistoryServiceTag;
+
+export default HistoryServiceTag;

Source/Effect/History/Type/HistoryProblem.ts

@@ -0,0 +1,3 @@
+export type HistoryProblem =
+	| { readonly _tag: "HistoryOperationFailed"; readonly error: Error }
+	| { readonly _tag: "HistoryStackEmpty" };

Source/Effect/IPC/Implementation/TauriIPC.ts

@@ -48,11 +48,21 @@ export const TauriIPCLive = Effect.gen(function* () {
 		invoke: (channel: string) => (args: ReadonlyArray<unknown>) =>
 			Effect.tryPromise({
 				try: () => {
-					const invokeArgs: InvokeArgs | undefined =
-						args.length === 1
-							? (args[0] as InvokeArgs)
-							: (args as unknown as InvokeArgs);
-					return tauriInvoke(channel, invokeArgs);
+					// All Wind IPC calls route through the single MountainIPCInvoke
+					// Tauri command (registered as "mountain_ipc_invoke").
+					// Mountain receives: method = channel name, params = args array.
+					// Send as array so Mountain can always destructure positionally.
+					// Single-element arrays are preserved; empty stays [].
+					const params: unknown =
+						args.length === 0
+							? []
+							: args.length === 1
+								? args[0]
+								: Array.from(args);
+					return tauriInvoke("mountain_ipc_invoke", {
+						method: channel,
+						params,
+					});
 				},
 				catch: (error) => CreateIPCInvokeError(channel, error),
 			}),

Source/Effect/Label/Implementation/LabelStub.ts

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+
+import type { LabelService } from "../Interface/LabelService.js";
+
+export const StubLabelService: LabelService = {
+	GetUriLabel: (uri, _options) => Effect.succeed(uri),
+	GetWorkspaceLabel: () => Effect.succeed(""),
+	GetBaseLabel: (uri) => Effect.succeed(uri.split("/").pop() ?? uri),
+};
+
+export default StubLabelService;

Source/Effect/Label/Interface/LabelService.ts

@@ -0,0 +1,33 @@
+import type { Effect } from "effect";
+
+import type { LabelProblem } from "../Type/LabelProblem.js";
+
+/**
+ * Label service interface.
+ * Microsoft VSCode Reference: ILabelService from vs/platform/label/common/label.ts
+ *
+ * Resolves human-readable display labels for URIs, workspace folders,
+ * and file paths. Used in the explorer tree, tabs, and breadcrumbs.
+ */
+export interface LabelService {
+	/**
+	 * Resolve a display label for a URI.
+	 * @param uri - The URI to label (e.g. "file:///home/user/project/src/foo.ts")
+	 * @param options.relative - When true, return path relative to workspace root
+	 */
+	readonly GetUriLabel: (
+		uri: string,
+		options?: { readonly relative?: boolean },
+	) => Effect.Effect<string, LabelProblem>;
+
+	/**
+	 * Return a human-readable label for the current workspace root.
+	 * Returns the workspace folder name, or empty string if no workspace is open.
+	 */
+	readonly GetWorkspaceLabel: () => Effect.Effect<string, LabelProblem>;
+
+	/**
+	 * Return only the base name (filename + extension) of a URI.
+	 */
+	readonly GetBaseLabel: (uri: string) => Effect.Effect<string, LabelProblem>;
+}