refactor(desktop): give the Firefox read path a tagged error

The Firefox branch failed with an anonymous `{ reason, cause }` literal, and
typing the shared `read` value as that shape erased `ChromiumCookieReadError`'s
tag from the error channel — neither branch could then be handled with
`Effect.catchTags`.

`FirefoxCookieReadError` mirrors its Chromium counterpart, so the union stays
structurally identifiable.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: juliusmarminge

apps/desktop/src/preview/BrowserImport/BrowserImport.ts

@@ -22,9 +22,9 @@ import * as Scope from "effect/Scope";
 import { HostProcessExecutablePath, HostProcessPlatform } from "@t3tools/shared/hostProcess";
 
 import * as BrowserSession from "../BrowserSession.ts";
-import { readChromiumCookies } from "./ChromiumCookies.ts";
+import { ChromiumCookieReadError, readChromiumCookies } from "./ChromiumCookies.ts";
 import type { ImportedCookie } from "./CookieDatabase.ts";
-import { readFirefoxCookies } from "./FirefoxCookies.ts";
+import { FirefoxCookieReadError, readFirefoxCookies } from "./FirefoxCookies.ts";
 import {
   BROWSER_IMPORT_SOURCES,
   cookieDatabasePath,
@@ -98,7 +98,8 @@ export const make = Effect.gen(function* BrowserImportMake() {
         name: definition.name,
         // Listing profiles touches the source's own files, so skip it when the
         // source is unusable anyway.
-        profiles: unavailable === undefined ? yield* listSourceProfiles(definition, pathContext) : [],
+        profiles:
+          unavailable === undefined ? yield* listSourceProfiles(definition, pathContext) : [],
         ...(unavailable === undefined ? {} : { unavailable }),
       } satisfies BrowserImportSource;
     }),
@@ -159,23 +160,23 @@ export const make = Effect.gen(function* BrowserImportMake() {
       });
     }
 
+    // Both branches fail with a tagged error carrying a `reason`, so the union
+    // stays structurally identifiable rather than collapsing to an anonymous
+    // shape that `Effect.catchTags` could not tell apart.
     const read: Effect.Effect<
       ReadonlyArray<ImportedCookie>,
-      { readonly reason: BrowserImportFailureReason },
+      ChromiumCookieReadError | FirefoxCookieReadError,
       FileSystem.FileSystem | Path.Path | Scope.Scope
-    > =
-      definition.engine === "firefox"
-        ? readFirefoxCookies(databasePath).pipe(
-            Effect.mapError((cause) => ({ reason: "readFailed" as const, cause })),
-          )
-        : readChromiumCookies({
-            cookieDatabasePath: databasePath,
-            // Only reached on macOS: `unavailableReason` rejects Chromium
-            // elsewhere until those key stores are implemented.
-            keychainService: definition.keychainService ?? "",
-            keychainAccount: definition.keychainAccount ?? "",
-            platform,
-          });
+    > = definition.engine === "firefox"
+      ? readFirefoxCookies(databasePath)
+      : readChromiumCookies({
+          cookieDatabasePath: databasePath,
+          // Only reached on macOS: `unavailableReason` rejects Chromium
+          // elsewhere until those key stores are implemented.
+          keychainService: definition.keychainService ?? "",
+          keychainAccount: definition.keychainAccount ?? "",
+          platform,
+        });
 
     const cookies = yield* read.pipe(
       Effect.scoped,

apps/desktop/src/preview/BrowserImport/FirefoxCookies.ts

@@ -22,6 +22,27 @@ import { snapshotCookieDatabase, type ImportedCookie } from "./CookieDatabase.ts
  * that is the modern default, and guessing "none" would widen a cookie's scope
  * on import.
  */
+export const FirefoxCookieReadReason = Schema.Literals(["readFailed"]);
+export type FirefoxCookieReadReason = typeof FirefoxCookieReadReason.Type;
+
+/**
+ * Mirrors `ChromiumCookieReadError` so both engines fail with a tagged error
+ * the service can tell apart, rather than one of them widening the channel to
+ * an anonymous shape.
+ */
+export class FirefoxCookieReadError extends Schema.TaggedErrorClass<FirefoxCookieReadError>()(
+  "FirefoxCookieReadError",
+  {
+    reason: FirefoxCookieReadReason,
+    /** Kept for the log; never surfaced to the user. */
+    cause: Schema.optional(Schema.Defect()),
+  },
+) {
+  override get message(): string {
+    return `Could not read Firefox cookies: ${this.reason}.`;
+  }
+}
+
 const sameSiteFromColumn = (value: number): ImportedCookie["sameSite"] => {
   if (value === 0) return "no_restriction";
   if (value === 2) return "strict";
@@ -45,7 +66,9 @@ const decodeCookieRows = Schema.decodeUnknownEffect(Schema.Array(CookieRow));
 export const readFirefoxCookies = Effect.fn("FirefoxCookies.readFirefoxCookies")(function* (
   cookieDatabasePath: string,
 ) {
-  const snapshotPath = yield* snapshotCookieDatabase(cookieDatabasePath);
+  const snapshotPath = yield* snapshotCookieDatabase(cookieDatabasePath).pipe(
+    Effect.mapError((cause) => new FirefoxCookieReadError({ reason: "readFailed", cause })),
+  );
 
   const rows = yield* Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
@@ -60,7 +83,10 @@ export const readFirefoxCookies = Effect.fn("FirefoxCookies.readFirefoxCookies")
        where originAttributes = ''
     `;
     return yield* decodeCookieRows(raw);
-  }).pipe(Effect.provide(NodeSqliteClient.layer({ filename: snapshotPath, readonly: true })));
+  }).pipe(
+    Effect.provide(NodeSqliteClient.layer({ filename: snapshotPath, readonly: true })),
+    Effect.mapError((cause) => new FirefoxCookieReadError({ reason: "readFailed", cause })),
+  );
 
   return rows.map((row) => {
     const secure = row.isSecure === 1;