@@ -26,7 +26,6 @@ import {
 } from "@t3tools/contracts";
 import { SshHttpBridgeError } from "@t3tools/ssh/errors";
 import { resolveLoopbackSshHttpBaseUrl } from "@t3tools/ssh/tunnel";
-import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 
@@ -35,10 +34,12 @@ import * as DesktopIpc from "../DesktopIpc.ts";
 import * as DesktopSshEnvironment from "../../ssh/DesktopSshEnvironment.ts";
 import * as DesktopSshPasswordPrompts from "../../ssh/DesktopSshPasswordPrompts.ts";
 
-type DesktopSshEnvironmentRequestOperation =
-  | "fetch-environment-descriptor"
-  | "bootstrap-bearer-session"
-  | "fetch-session-state";
+const DesktopSshEnvironmentRequestOperation = Schema.Literals([
+  "fetch-environment-descriptor",
+  "bootstrap-bearer-session",
+  "fetch-session-state",
+]);
+type DesktopSshEnvironmentRequestOperation = typeof DesktopSshEnvironmentRequestOperation.Type;
 
 type DesktopSshEnvironmentRequestCause = RemoteEnvironmentAuthError | SshHttpBridgeError;
 
@@ -47,12 +48,13 @@ const isEnvironmentInternalError = Schema.is(EnvironmentInternalError);
 const isEnvironmentOperationForbiddenError = Schema.is(EnvironmentOperationForbiddenError);
 const isEnvironmentRequestInvalidError = Schema.is(EnvironmentRequestInvalidError);
 const isEnvironmentScopeRequiredError = Schema.is(EnvironmentScopeRequiredError);
+const isRemoteEnvironmentAuthUndeclaredStatusError = Schema.is(
+  RemoteEnvironmentAuthUndeclaredStatusError,
+);
+const isSshHttpBridgeError = Schema.is(SshHttpBridgeError);
 
 function readSshHttpStatus(cause: DesktopSshEnvironmentRequestCause): number | null {
-  if (
-    cause instanceof RemoteEnvironmentAuthUndeclaredStatusError ||
-    cause instanceof SshHttpBridgeError
-  ) {
+  if (isRemoteEnvironmentAuthUndeclaredStatusError(cause) || isSshHttpBridgeError(cause)) {
     return cause.status ?? null;
   }
   if (isEnvironmentRequestInvalidError(cause)) {
@@ -73,13 +75,14 @@ function readSshHttpStatus(cause: DesktopSshEnvironmentRequestCause): number | n
   return null;
 }
 
-export class DesktopSshEnvironmentRequestError extends Data.TaggedError(
+export class DesktopSshEnvironmentRequestError extends Schema.TaggedError<DesktopSshEnvironmentRequestError>()(
   "DesktopSshEnvironmentRequestError",
-)<{
-  readonly operation: DesktopSshEnvironmentRequestOperation;
-  readonly cause: DesktopSshEnvironmentRequestCause;
-  readonly sshHttpStatus: number | null;
-}> {
+  {
+    operation: DesktopSshEnvironmentRequestOperation,
+    cause: Schema.Defect(),
+    sshHttpStatus: Schema.NullOr(Schema.Number),
+  },
+) {
   // The web client matches "[ssh_http:500]" to explain version-skewed SSH pairing.
   override get message() {
     const prefix = this.sshHttpStatus === null ? "" : `[ssh_http:${this.sshHttpStatus}] `;
 
@@ -1872,7 +1872,9 @@ it.effect("capture fails closed while snapshots are disabled", () => {
 
 it.effect("points capture setup failures at SnapShot settings", () => {
   vi.stubEnv("XDG_SESSION_TYPE", "wayland");
-  linuxCaptureMock.mockRejectedValueOnce(new CaptureSetupRequiredError("Install the helper."));
+  linuxCaptureMock.mockRejectedValueOnce(
+    new CaptureSetupRequiredError({ state: "Install the helper." }),
+  );
   return Effect.scoped(
     Effect.gen(function* () {
       const service = yield* DesktopSnapShot.make;
 
@@ -94,6 +94,8 @@ import {
 import * as HostProcess from "@t3tools/shared/HostProcess";
 import { readImageDimensions } from "@t3tools/shared/imageDimensions";
 
+const isCaptureSetupRequiredError = Schema.is(CaptureSetupRequiredError);
+
 const MAX_CAPTURE_WIDTH = 2_560;
 const MAX_CAPTURE_HEIGHT = 1_600;
 const SHORTCUT_COOLDOWN_NS = 200_000_000n;
@@ -180,7 +182,7 @@ const shortcutFailure = (cause: unknown) => new SnapShotShortcutError({ cause })
 
 function captureFailure(cause: unknown, captureId?: string): DesktopSnapShotError {
   if (isDesktopSnapShotError(cause)) return cause;
-  const operation = cause instanceof CaptureSetupRequiredError ? "setup-required" : "capture";
+  const operation = isCaptureSetupRequiredError(cause) ? "setup-required" : "capture";
   return new DesktopSnapShotError({ operation, captureId, cause });
 }
 
 
@@ -171,11 +171,11 @@ export async function captureHyprlandWindow(
   let state = await setup.state();
   if (state.status === "update-required") {
     await setup.perform("install-hyprland-helper").catch((cause: unknown) => {
-      throw new CaptureSetupRequiredError(state.message, { cause });
+      throw new CaptureSetupRequiredError({ state: state.message, cause });
     });
     state = await setup.state();
   }
-  if (state.status !== "ready") throw new CaptureSetupRequiredError(state.message);
+  if (state.status !== "ready") throw new CaptureSetupRequiredError({ state: state.message });
   const executable = hyprlandCaptureExecutable(paths);
   const directory = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-hyprland-capture-"));
   const cleanup = () => NodeFSP.rm(directory, { recursive: true, force: true });
 
@@ -215,7 +215,7 @@ export async function captureKdeWindow(
   options?: { readonly flash: boolean; readonly animate: boolean },
 ): Promise<LinuxWindowSnapshot> {
   const state = await new KdeCaptureSetup(paths).state();
-  if (state.status !== "ready") throw new CaptureSetupRequiredError(state.message);
+  if (state.status !== "ready") throw new CaptureSetupRequiredError({ state: state.message });
   const { executable } = kdeCapturePaths(paths);
   const directory = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-kde-capture-"));
   let retained = false;
 
@@ -2,15 +2,19 @@
 import * as NodeFSP from "node:fs/promises";
 import * as NodeURL from "node:url";
 import type { SnapShotKeyChord } from "@t3tools/contracts";
+import * as Schema from "effect/Schema";
 import { nativeImage } from "electron";
 
 // Keep dbus-next out of desktop detection and PNG reads in the main process.
 
 export const HYPRLAND_CAPTURE_ACTION = "capture-window";
 
-export class CaptureSetupRequiredError extends Error {
-  constructor(state: string, options?: ErrorOptions) {
-    super(`${state} Open Settings → SnapShots to continue setup.`, options);
+export class CaptureSetupRequiredError extends Schema.TaggedError<CaptureSetupRequiredError>()(
+  "CaptureSetupRequiredError",
+  { state: Schema.String, cause: Schema.optional(Schema.Defect()) },
+) {
+  override get message(): string {
+    return `${this.state} Open Settings → SnapShots to continue setup.`;
   }
 }
 export const NIRI_CAPTURE_PATH = "/com/t3tools/SnapShot";
 
@@ -23,6 +23,7 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
 import * as HttpClient from "effect/http/HttpClient";
 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
 
@@ -74,11 +75,13 @@ function discoverDesktopSshHostsEffect(input?: { readonly homeDir?: string }) {
   return discoverSshHosts(input ?? {});
 }
 
+const isSshPasswordPromptError = Schema.is(SshPasswordPromptError);
+
 export function isDesktopSshPasswordPromptCancellation(
   error: unknown,
 ): error is SshPasswordPromptError {
   return (
-    error instanceof SshPasswordPromptError &&
+    isSshPasswordPromptError(error) &&
     DesktopSshPasswordPrompts.isDesktopSshPasswordPromptCancellation(error.cause)
   );
 }
 
@@ -1,3 +1,4 @@
+import * as Schema from "effect/Schema";
 import * as Dialog from "./ui/Dialog";
 import { useContext, useEffect, useEffectEvent, useState } from "react";
 import { Platform } from "react-native";
@@ -21,15 +22,17 @@ export type {
   ResolvedFilePreviewSource,
 } from "./FilePreviewModal.types";
 
-class PreviewResolutionError extends Error {
-  constructor(
-    override readonly cause: unknown,
-    readonly fallbackMessage: string,
-  ) {
-    super(fallbackMessage, { cause });
+class PreviewResolutionError extends Schema.TaggedError<PreviewResolutionError>()(
+  "PreviewResolutionError",
+  { cause: Schema.Defect(), fallbackMessage: Schema.String },
+) {
+  override get message(): string {
+    return this.fallbackMessage;
   }
 }
 
+const isPreviewResolutionError = Schema.is(PreviewResolutionError);
+
 interface ResolvedPreviewUri {
   readonly uri: string;
   readonly dispose?: () => void;
@@ -42,7 +45,10 @@ async function resolvePreviewUri(
   if ("uri" in item) return { uri: item.uri };
   if ("attachment" in item) {
     return loadLocalAttachmentPreview(item.attachment, signal).catch((error: unknown) => {
-      throw new PreviewResolutionError(error, "Attach the file again and retry.");
+      throw new PreviewResolutionError({
+        cause: error,
+        fallbackMessage: "Attach the file again and retry.",
+      });
     });
   }
   // Refresh expired URLs before handing them to Quick Look or ACTION_VIEW, which retain them.
@@ -52,10 +58,11 @@ async function resolvePreviewUri(
       return value;
     })
     .catch((error: unknown) => {
-      throw new PreviewResolutionError(
-        error,
-        "Reconnect to this environment and try again. The file may have been moved or deleted.",
-      );
+      throw new PreviewResolutionError({
+        cause: error,
+        fallbackMessage:
+          "Reconnect to this environment and try again. The file may have been moved or deleted.",
+      });
     });
   return { uri: url + (item.srcFragment ?? "") };
 }
@@ -99,9 +106,9 @@ function ResolvedFilePreview(props: {
           if (progressiveGallery && index !== selectedIndex) return settle(index, null);
           controller.abort();
           onResolutionError(
-            error instanceof PreviewResolutionError
+            isPreviewResolutionError(error)
               ? error
-              : new PreviewResolutionError(error, "Try again."),
+              : new PreviewResolutionError({ cause: error, fallbackMessage: "Try again." }),
           );
         },
       );
 
@@ -1,6 +1,5 @@
 import * as Digest from "effect/crypto/Digest";
 import * as SecureRandom from "effect/crypto/SecureRandom";
-import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Base64Url from "effect/encoding/Base64Url";
 import * as Hex from "effect/encoding/Hex";
@@ -13,10 +12,10 @@ import { DpopProof } from "@t3tools/client-runtime/relay";
 import { DpopPublicJwk } from "@t3tools/shared/dpopCommon";
 import * as Layer from "effect/Layer";
 
-export class CloudDpopError extends Data.TaggedError("CloudDpopError")<{
-  readonly message: string;
-  readonly cause?: unknown;
-}> {}
+export class CloudDpopError extends Schema.TaggedError<CloudDpopError>()("CloudDpopError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect()),
+}) {}
 
 function cloudDpopError(message: string) {
   return (cause: unknown) => new CloudDpopError({ message, cause });
 
@@ -1,4 +1,3 @@
-import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import { HttpClient } from "effect/http";
@@ -26,11 +25,14 @@ function readRelayUrl(): string | null {
   return resolveCloudPublicConfig().relay.url;
 }
 
-export class CloudEnvironmentLinkError extends Data.TaggedError("CloudEnvironmentLinkError")<{
-  readonly message: string;
-  readonly cause?: unknown;
-  readonly traceId?: string;
-}> {}
+export class CloudEnvironmentLinkError extends Schema.TaggedError<CloudEnvironmentLinkError>()(
+  "CloudEnvironmentLinkError",
+  {
+    message: Schema.String,
+    cause: Schema.optional(Schema.Defect()),
+    traceId: Schema.optional(Schema.String),
+  },
+) {}
 
 const isEnvironmentCloudApiError = Schema.is(
   Schema.Union([