refactor(Wind): Refine Effect services and remove local dependency submodules

This commit refines the newly adopted Effect-TS architecture in the `Wind` service layer and shifts the dependency strategy for the core Effect libraries.

**Dependency Management:**
Removes `Module/effect` and `Module/effect-website` Git submodules and the `.gitmodules` configuration. This indicates a shift to managing these libraries via standard package management (npm/pnpm) rather than local source pinning, simplifying the repository structure and build process.

**Service Robustness:**
- **Health:** Refactored service checks to consistently use `Effect.succeed` or `Effect.fail`, ensuring predictable error channels. Simplified `checkAllServices` logic to directly invoke the checker instance.
- **IPC:** Added strict typing for `InvokeArgs` from Tauri. Improved error mapping with explicit `mapError` pipelines and fixed promise handling in `listen` to prevent hanging fibers.
- **Error Handling:** Added `override name` getters to custom errors in `IPC`, `Mountain`, and `Telemetry` services for better stack trace clarity.

**Type Safety & Hygiene:**
- Renamed `SyncResult` to `MountainSyncResult` in `MountainSync` to prevent naming collisions.
- Removed unused imports (e.g., `pipe` from `effect`) and stale exports (e.g., `ConfigurationWithSyncLive`) from the public barrel.
- Updated `Bootstrap` to use native method-chaining `.pipe()` over the functional utility import.

These changes stabilize the post-migration codebase, improve developer experience with better error reporting, and align dependency management with standard Node.js practices.

Author: NikolaRHristov

.gitmodules

@@ -14,11 +14,11 @@
  * - Stage 6: Health checks (via Health service)
  */
 
-import { Effect, Layer, pipe, Context } from "effect";
+import { Effect, Layer, Context } from "effect";
 import { EnvironmentTag, type EnvironmentInfo } from "./Environment.js";
-import { Telemetry, withSpan } from "./Telemetry.js";
-import { Sandbox } from "./Sandbox.js";
-import { Configuration } from "./Configuration.js";
+import { Telemetry, TelemetryTag, withSpan } from "./Telemetry.js";
+import { Sandbox, type SandboxService } from "./Sandbox.js";
+import { Configuration, ConfigurationTag } from "./Configuration.js";
 import { MountainTag } from "./Mountain.js";
 import { HealthTag } from "./Health.js";
 
@@ -49,7 +49,7 @@ export interface BootstrapResult {
 }
 
 export interface BootstrapService {
-	readonly run: (options?: BootstrapOptions) => Effect.Effect<BootstrapResult>;
+	readonly run: (options?: BootstrapOptions) => Effect.Effect<BootstrapResult, never, typeof Sandbox | typeof TelemetryTag | typeof EnvironmentTag | typeof MountainTag | typeof HealthTag | typeof ConfigurationTag>;
 }
 
 // ============================================================================
@@ -234,7 +234,7 @@ const stage6_HealthCheck = withSpan(
 // ============================================================================
 
 const makeBootstrap = (): BootstrapService => ({
-	run: (options): Effect.Effect<BootstrapResult, never, never> =>
+	run: (options): Effect.Effect<BootstrapResult, never, typeof Sandbox | typeof TelemetryTag | typeof EnvironmentTag | typeof MountainTag | typeof HealthTag | typeof ConfigurationTag> =>
 		Effect.gen(function* () {
 			const telemetry = yield* Telemetry;
 
@@ -344,10 +344,9 @@ export const BootstrapMock = Layer.effect(BootstrapTag, Effect.succeed(makeMockB
 // ============================================================================
 
 export const runBootstrap = (options?: BootstrapOptions) =>
-	pipe(
-		Effect.gen(function* () {
-			const bootstrap = yield* BootstrapTag;
-			return yield* bootstrap.run(options);
-		}),
+	Effect.gen(function* () {
+		const bootstrap = yield* BootstrapTag;
+		return yield* bootstrap.run(options);
+	}).pipe(
 		Effect.provide(BootstrapLive),
-	);
+	);

Module/effect

@@ -300,14 +300,15 @@ export const makeMockConfiguration = (
 	overrides?: Partial<ISandboxConfiguration>,
 ): ConfigurationService => {
 	const mockConfig: ISandboxConfiguration = {
-		zoomLevel: 0,
-		userEnv: {},
-		workspace: {
-			id: "mock-workspace",
-			uri: "mock://workspace",
-		},
-		...overrides,
-	};
+	zoomLevel: 0,
+	userEnv: {},
+	workspace: {
+		id: "mock-workspace",
+		uri: "mock://workspace",
+		name: "Mock Workspace",
+	},
+	...overrides,
+};
 
 	return {
 		get: Effect.succeed(mockConfig),

Module/effect-website

@@ -39,13 +39,13 @@ export interface SystemHealth {
 }
 
 export interface HealthService {
-	readonly checkService: (serviceName: string) => Effect.Effect<ServiceHealth>;
-	readonly checkAllServices: () => Effect.Effect<SystemHealth>;
-	readonly getOverallStatus: () => Effect.Effect<HealthStatus>;
+	readonly checkService: (serviceName: string) => Effect.Effect<ServiceHealth, never>;
+	readonly checkAllServices: () => Effect.Effect<SystemHealth, never>;
+	readonly getOverallStatus: () => Effect.Effect<HealthStatus, never>;
 	readonly monitorService: (
 		serviceName: string,
 		intervalMs: number,
-	) => Effect.Effect<void>;
+	) => Effect.Effect<void, never>;
 }
 
 // ============================================================================
@@ -80,13 +80,13 @@ const createServiceHealthWithNoResponseTime = (
 	name: string,
 	status: HealthStatus,
 	message: string,
-	details?: Readonly<Record<string, unknown>>,
-): Omit<ServiceHealth, "responseTime"> => ({
+): ServiceHealth => ({
 	serviceName: name,
 	status,
 	message,
 	lastChecked: Date.now(),
-	details,
+	responseTime: 0,
+	details: undefined,
 });
 
 const makeHealthChecker = (): HealthService => ({
@@ -101,22 +101,26 @@ const makeHealthChecker = (): HealthService => ({
 				case "environment":
 					// Environment is always available
 					const envTime = Date.now() - startTime;
-					return createServiceHealth(
-						"Environment",
-						"healthy",
-						"Environment service available",
-						envTime,
+					return Effect.succeed(
+						createServiceHealth(
+							"Environment",
+							"healthy",
+							"Environment service available",
+							envTime,
+						),
 					);
 
 				case "telemetry":
 					// Check telemetry by logging a metric
 					yield* telemetry.log("info", "[Health] Telemetry health check");
 					const telemetryTime = Date.now() - startTime;
-					return createServiceHealth(
-						"Telemetry",
-						"healthy",
-						"Telemetry service available",
-						telemetryTime,
+					return Effect.succeed(
+						createServiceHealth(
+							"Telemetry",
+							"healthy",
+							"Telemetry service available",
+							telemetryTime,
+						),
 					);
 
 				case "mountain": {
@@ -134,7 +138,7 @@ const makeHealthChecker = (): HealthService => ({
 						);
 					}).pipe(
 						Effect.catchAll((error) =>
-							Effect.sync(() =>
+							Effect.succeed(
 								createServiceHealth(
 									"Mountain",
 									"unhealthy",
@@ -148,7 +152,7 @@ const makeHealthChecker = (): HealthService => ({
 
 				case "ipc": {
 					// Check IPC by invoking a lightweight command
-					const ipc = yield* IPCTag;
+					const _ipc = yield* IPCTag;
 					const ipcTime = Date.now() - startTime;
 					return yield* Effect.tryPromise({
 						try: async () => {
@@ -160,19 +164,19 @@ const makeHealthChecker = (): HealthService => ({
 								ipcTime,
 							);
 						},
-						catch: (error) =>
+						catch: () =>
 							createServiceHealth(
 								"IPC",
 								"unhealthy",
-								`IPC service error: ${String(error)}`,
+								"IPC service error",
 								Date.now() - startTime,
 							),
 					});
 				}
 
 				case "configuration": {
 					// Check Configuration service
-					const config = yield* ConfigurationTag;
+					const _config = yield* ConfigurationTag;
 					const configTime = Date.now() - startTime;
 					return yield* Effect.tryPromise({
 						try: async () => {
@@ -184,18 +188,18 @@ const makeHealthChecker = (): HealthService => ({
 								configTime,
 							);
 						},
-						catch: (error) =>
+						catch: () =>
 							createServiceHealth(
 								"Configuration",
 								"unhealthy",
-								`Configuration service error: ${String(error)}`,
+								"Configuration service error",
 								Date.now() - startTime,
 							),
 					});
 				}
 
 				default:
-					return Effect.sync(() =>
+					return Effect.succeed(
 						createServiceHealthWithNoResponseTime(
 							serviceName,
 							"unknown",
@@ -210,21 +214,13 @@ const makeHealthChecker = (): HealthService => ({
 			const env = yield* EnvironmentTag;
 			const envInfo = yield* env.getInfo;
 			const services = ["environment", "telemetry", "mountain", "ipc", "configuration"] as const;
+			const healthChecker = makeHealthChecker();
 
 			const serviceHealthChecks = services.map((service) =>
-				Effect.all([
-					Effect.succeed(service).pipe(Effect.flatMap((serviceName) =>
-						// Need to pass the service to checkService
-						Effect.succeed(serviceName).pipe(Effect.flatMap((s) =>
-							// Recursively call checkAllServices to simulate the check
-							Effect.succeed(createServiceHealth(s, "healthy", "Service available", 0)),
-						)),
-					)),
-				]),
+				healthChecker.checkService(service),
 			);
 
-			const results = yield* Effect.all(serviceHealthChecks);
-			const healthResults = results.flat();
+			const healthResults = yield* Effect.all(serviceHealthChecks);
 
 			// Determine overall status
 			const unhealthyCount = healthResults.filter((h) => h.status === "unhealthy").length;
@@ -258,7 +254,7 @@ const makeHealthChecker = (): HealthService => ({
 
 	monitorService: (serviceName: string, intervalMs: number) =>
 		Effect.gen(function* () {
-			// Periodic health check using Effect.schedule
+			// Periodic health check using Effect.repeat
 			yield* makeHealthChecker().checkService(serviceName).pipe(
 				Effect.repeat(Schedule.spaced(`${intervalMs} millis`)),
 			);
@@ -317,13 +313,7 @@ export const makeMockHealth = (overrides?: Partial<Record<string, HealthStatus>>
 
 	getOverallStatus: () => Effect.succeed("healthy" as const),
 
-	monitorService: (serviceName: string, intervalMs: number) =>
-		Effect.gen(function* () {
-			yield* Effect.repeat(
-				Effect.succeed(serviceName),
-				Schedule.spaced(`${intervalMs} millis`),
-			);
-		}),
+	monitorService: () => Effect.void,
 });
 
 export const HealthMock = Layer.effect(HealthTag, Effect.succeed(makeMockHealth()));

Source/Effect/Bootstrap.ts

@@ -7,6 +7,7 @@
 
 import { emit, listen } from "@tauri-apps/api/event";
 import { invoke as tauriInvoke } from "@tauri-apps/api/core";
+import type { InvokeArgs } from "@tauri-apps/api/core";
 import { Context, Effect, Layer, Stream } from "effect";
 
 import { SandboxNotReadyError, type IPCMessage } from "../Types/Sandbox.js";
@@ -28,8 +29,9 @@ export class IPCInvokeError extends Error {
 		this._cause = cause;
 		Object.setPrototypeOf(this, IPCInvokeError.prototype);
 	}
+	override get name() { return "IPCInvokeError"; }
 	get channel() { return this._channel; }
-	get cause() { return this._cause; }
+	override get cause() { return this._cause; }
 }
 
 export class IPCSendError extends Error {
@@ -45,8 +47,9 @@ export class IPCSendError extends Error {
 		this._cause = cause;
 		Object.setPrototypeOf(this, IPCSendError.prototype);
 	}
+	override get name() { return "IPCSendError"; }
 	get channel() { return this._channel; }
-	get cause() { return this._cause; }
+	override get cause() { return this._cause; }
 }
 
 export class IPCSubscriptionError extends Error {
@@ -55,7 +58,7 @@ export class IPCSubscriptionError extends Error {
 	readonly _cause: unknown;
 	constructor(
 		channel: string,
-		cause: unknown,
+			cause: unknown,
 	) {
 		super(
 			`IPC subscription failed on channel '${channel}': ${String(cause)}`,
@@ -64,8 +67,9 @@ export class IPCSubscriptionError extends Error {
 		this._cause = cause;
 		Object.setPrototypeOf(this, IPCSubscriptionError.prototype);
 	}
+	override get name() { return "IPCSubscriptionError"; }
 	get channel() { return this._channel; }
-	get cause() { return this._cause; }
+	override get cause() { return this._cause; }
 }
 
 // ============================================================================
@@ -114,11 +118,11 @@ export const IPCTauriLive = Layer.effect(
 	IPC,
 	Effect.gen(function* () {
 		// Verify Tauri is available
-		const isTauri =
+		const isTauriAvailable =
 			typeof window !== "undefined" &&
 			(window as any).__TAURI__ !== undefined;
 
-		if (!isTauri) {
+		if (!isTauriAvailable) {
 			return yield* Effect.die(new SandboxNotReadyError());
 		}
 
@@ -127,12 +131,19 @@ export const IPCTauriLive = Layer.effect(
 			Effect.try({
 				try: () => emit(channel, args.length === 1 ? args[0] : args),
 				catch: (error) => new IPCSendError(channel, error),
-			});
+			}).pipe(
+				Effect.mapError((error) => new IPCSendError(channel, error)),
+			);
 
 		// Atom: invoke
 		const invoke_ = (channel: string) => (args: ReadonlyArray<unknown>) =>
 			Effect.tryPromise({
-				try: () => tauriInvoke(channel, args.length === 1 ? args[0] : args),
+				try: () => {
+					const invokeArgs: InvokeArgs | undefined = args.length === 1
+						? (args[0] as InvokeArgs)
+						: (args as unknown as InvokeArgs);
+					return tauriInvoke(channel, invokeArgs);
+				},
 				catch: (error) => new IPCInvokeError(channel, error),
 			});
 
@@ -164,18 +175,14 @@ export const IPCTauriLive = Layer.effect(
 			channel: string,
 		): Effect.Effect<IPCMessage, IPCSubscriptionError> =>
 			Effect.async((resume) => {
-				listen(
-					channel,
-					(event) => {
-						resume(
-							Effect.succeed({
-								channel,
-								args: [event.payload],
-							}),
-						);
-					},
-					{ once: true },
-				).catch((error) => {
+				listen(channel, (event) => {
+					resume(
+						Effect.succeed({
+							channel,
+							args: [event.payload],
+						}),
+					);
+				}).catch((error) => {
 					resume(
 						Effect.fail(new IPCSubscriptionError(channel, error)),
 					);