@reddb-io/ui 0.3.1 → 0.3.3

package/src/lib/index.ts

@@ -9,6 +9,13 @@ export { default as ConnectDropdown } from "./ConnectDropdown.svelte";
 export { default as EmptyState } from "./EmptyState.svelte";
 export { default as GlobalProgressBar } from "./GlobalProgressBar.svelte";
 export { default as LiveChanges } from "./LiveChanges.svelte";
+export { default as LoadingOverlay } from "./LoadingOverlay.svelte";
+export {
+  loading,
+  formatElapsed,
+  type LoadingStep,
+  type LoadingStepStatus,
+} from "./loading.svelte";
 export { default as MasterPasswordDialog } from "./MasterPasswordDialog.svelte";
 export { default as PageHeader } from "./PageHeader.svelte";
 export { default as PendingChangesPanel } from "./PendingChangesPanel.svelte";

package/src/lib/loading.svelte.ts

@@ -0,0 +1,142 @@
+// Connect/boot loading model (#127). Slow opens (sidecar spawn, readiness,
+// handshake, initial schema/stats fetch) get real, timestamped feedback: a
+// started-at, an ordered log of steps (each with a label, optional detail, and
+// its own start time + outcome), and a "current" step that stays on screen —
+// with its elapsed time — while it's still running (a stalled step reads AS
+// stalled). Live-or-empty applies: steps are appended by the actual connect
+// sequence, never synthesized to fake progress.
+//
+// `$state` is compiled here (`.svelte.ts`), so the model is reactive and the
+// overlay re-renders as steps land. Writes are wrapped in `untrack()` because
+// the connect sequence commonly runs from inside a Svelte `$effect` (the
+// layout's auto-refresh); an untracked write keeps our own mutations from
+// re-firing that effect.
+
+import { untrack } from "svelte";
+
+export type LoadingStepStatus = "active" | "done" | "error";
+
+export interface LoadingStep {
+  id: number;
+  label: string;
+  detail?: string;
+  /** Absolute wall-clock time the step was appended. */
+  startedAt: number;
+  /** Wall-clock duration once the step resolves; null while still active. */
+  durationMs: number | null;
+  status: LoadingStepStatus;
+  error?: string;
+}
+
+/**
+ * Format a millisecond elapsed value for the overlay badge and per-step timing.
+ * Sub-second reads as fractional seconds ("0.4s"); longer as one-decimal
+ * seconds ("12.3s"). Kept pure so the render is unit-testable without a clock.
+ */
+export function formatElapsed(ms: number): string {
+  const clamped = Math.max(0, ms);
+  return `${(clamped / 1000).toFixed(1)}s`;
+}
+
+class LoadingStore {
+  /** Wall-clock time the current open began; null when nothing is opening. */
+  startedAt = $state<number | null>(null);
+  /** Headline for what's being opened, e.g. "Opening Docker primary". */
+  label = $state<string | null>(null);
+  /** Ordered, timestamped step log for the current open. */
+  steps = $state<LoadingStep[]>([]);
+  private nextId = 1;
+
+  /** True while an open is in progress. Gates the overlay. */
+  get active(): boolean {
+    return this.startedAt !== null;
+  }
+
+  /** The step currently on screen — the last appended one, if any. */
+  get current(): LoadingStep | null {
+    return this.steps.length ? this.steps[this.steps.length - 1] : null;
+  }
+
+  /** Elapsed time since the open began, for the ticking badge. */
+  elapsedMs(now = Date.now()): number {
+    return this.startedAt === null ? 0 : Math.max(0, now - this.startedAt);
+  }
+
+  /**
+   * Begin a fresh open. Resets the log and stamps the start. Any subsequent
+   * `step()` calls append to this open until `succeed`/`fail` finishes it.
+   */
+  begin(label: string, now = Date.now()): void {
+    untrack(() => {
+      this.startedAt = now;
+      this.label = label;
+      this.steps = [];
+      this.nextId = 1;
+    });
+  }
+
+  /**
+   * Append a step and mark it the current (active) one, closing out the
+   * previous active step as done. No-op if no open is in progress — steps are
+   * only ever real work inside an open.
+   */
+  step(label: string, detail?: string, now = Date.now()): void {
+    untrack(() => {
+      if (this.startedAt === null) return;
+      const closed = this.steps.map((s) =>
+        s.status === "active"
+          ? { ...s, status: "done" as const, durationMs: now - s.startedAt }
+          : s
+      );
+      this.steps = [
+        ...closed,
+        {
+          id: this.nextId++,
+          label,
+          ...(detail ? { detail } : {}),
+          startedAt: now,
+          durationMs: null,
+          status: "active",
+        },
+      ];
+    });
+  }
+
+  /** Finish the open successfully: close the active step and hide the overlay. */
+  succeed(now = Date.now()): void {
+    untrack(() => {
+      this.#closeActive(now);
+      this.startedAt = null;
+    });
+  }
+
+  /**
+   * Finish the open with a failure: mark the active step errored and hide the
+   * overlay (the Connect flow surfaces the error separately).
+   */
+  fail(error?: string, now = Date.now()): void {
+    untrack(() => {
+      this.steps = this.steps.map((s) =>
+        s.status === "active"
+          ? {
+              ...s,
+              status: "error" as const,
+              durationMs: now - s.startedAt,
+              ...(error ? { error } : {}),
+            }
+          : s
+      );
+      this.startedAt = null;
+    });
+  }
+
+  #closeActive(now: number): void {
+    this.steps = this.steps.map((s) =>
+      s.status === "active"
+        ? { ...s, status: "done" as const, durationMs: now - s.startedAt }
+        : s
+    );
+  }
+}
+
+export const loading = new LoadingStore();

package/src/lib/reddb/client.ts

@@ -15,6 +15,7 @@ import type {
 import type { ClusterStatus, ReplicationStatus } from "./cluster-status";
 import type { MetricDescriptor, PromResponse } from "./analytics";
 import type { AskResponse, AskOptions } from "./ask";
+import { devConsole, sanitizePayload } from "./dev-console";
 
 export interface QueryRow {
   values: Record<string, unknown>;
@@ -293,6 +294,25 @@ async function* parseNdjsonFrames(
 
 const SELECT_RE = /^\s*select\b/i;
 
+/**
+ * Pull a row count out of a parsed response for the developer console (#128).
+ * Recognises the `/query` envelope (`record_count`, else the length of
+ * `result.records`) and a bare array; returns `undefined` when the shape
+ * carries no notion of rows. Purely structural — never throws.
+ */
+export function extractRowCount(data: unknown): number | undefined {
+  if (Array.isArray(data)) return data.length;
+  if (data && typeof data === "object") {
+    const d = data as {
+      record_count?: unknown;
+      result?: { records?: unknown };
+    };
+    if (typeof d.record_count === "number") return d.record_count;
+    if (Array.isArray(d.result?.records)) return d.result.records.length;
+  }
+  return undefined;
+}
+
 /**
  * Extract a human-readable message from any thrown value. Tauri's `invoke` and
  * the HTTP plugin reject with plain strings or bare objects (not `Error`), so
@@ -374,14 +394,66 @@ export class RedClient {
     Object.assign(headers, this.headers as Record<string, string> | undefined);
     Object.assign(headers, init?.headers as Record<string, string> | undefined);
 
-    const res = await this.fetcher(url, { ...init, headers });
+    // Developer console instrumentation (#128). Every HTTP call the client
+    // makes is timed and logged from this single seam, so every Surface is
+    // covered without touching each caller. The request body is sanitized
+    // before it lands in an entry — a copy action can never leak a secret.
+    const verb = init?.method ?? "GET";
+    const startedAt = Date.now();
+    const start = performance.now();
+    const payload = sanitizePayload(init?.body);
+    const elapsed = () => Math.round(performance.now() - start);
+
+    let res: Response;
+    try {
+      res = await this.fetcher(url, { ...init, headers });
+    } catch (e) {
+      devConsole.record({
+        kind: "http",
+        verb,
+        target: path,
+        startedAt,
+        durationMs: elapsed(),
+        ok: false,
+        payload,
+        error: errorText(e),
+      });
+      throw e;
+    }
+
     if (!res.ok) {
       const body = await res.text().catch(() => "");
-      throw new Error(
-        `${init?.method ?? "GET"} ${path} → ${res.status} ${body.slice(0, 200)}`
-      );
+      const message = `${verb} ${path} → ${res.status} ${body.slice(0, 200)}`;
+      devConsole.record({
+        kind: "http",
+        verb,
+        target: path,
+        startedAt,
+        durationMs: elapsed(),
+        ok: false,
+        status: res.status,
+        payload,
+        error: message,
+      });
+      throw new Error(message);
     }
-    return res.json() as Promise<T>;
+
+    const data = (await res.json()) as T;
+    const rowCount = extractRowCount(data);
+    devConsole.record({
+      // A response carrying a row count is a query round-trip; everything else
+      // is a plain HTTP call. This is how `/query` entries mark themselves.
+      kind: rowCount === undefined ? "http" : "query",
+      verb,
+      target: path,
+      startedAt,
+      durationMs: elapsed(),
+      ok: true,
+      status: res.status,
+      ...(rowCount === undefined ? {} : { rowCount }),
+      payload,
+    });
+    return data;
   }
 
   async stats(): Promise<Stats> {
@@ -588,17 +660,51 @@ export class RedClient {
     };
     Object.assign(headers, this.headers as Record<string, string> | undefined);
 
-    const res = await this.fetcher(`${this.baseUrl}/query/stream`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ query }),
-      signal: opts.signal,
-    });
+    // Developer console instrumentation (#128). The streaming endpoint skips
+    // `json()`, so it logs its own query round-trip here (verb `POST`, target
+    // `/query/stream`) with the collected row count.
+    const startedAt = Date.now();
+    const start = performance.now();
+    const body = JSON.stringify({ query });
+    const payload = sanitizePayload(body);
+    const elapsed = () => Math.round(performance.now() - start);
+
+    let res: Response;
+    try {
+      res = await this.fetcher(`${this.baseUrl}/query/stream`, {
+        method: "POST",
+        headers,
+        body,
+        signal: opts.signal,
+      });
+    } catch (e) {
+      devConsole.record({
+        kind: "query",
+        verb: "POST",
+        target: "/query/stream",
+        startedAt,
+        durationMs: elapsed(),
+        ok: false,
+        payload,
+        error: errorText(e),
+      });
+      throw e;
+    }
     if (!res.ok || !res.body) {
-      const body = res.body ? await res.text().catch(() => "") : "";
-      throw new Error(
-        `POST /query/stream → ${res.status} ${body.slice(0, 200)}`
-      );
+      const errBody = res.body ? await res.text().catch(() => "") : "";
+      const message = `POST /query/stream → ${res.status} ${errBody.slice(0, 200)}`;
+      devConsole.record({
+        kind: "query",
+        verb: "POST",
+        target: "/query/stream",
+        startedAt,
+        durationMs: elapsed(),
+        ok: false,
+        status: res.status,
+        payload,
+        error: message,
+      });
+      throw new Error(message);
     }
 
     const out: StreamedQueryResult = {
@@ -626,6 +732,18 @@ export class RedClient {
       }
     }
 
+    devConsole.record({
+      kind: "query",
+      verb: "POST",
+      target: "/query/stream",
+      startedAt,
+      durationMs: elapsed(),
+      ok: true,
+      status: res.status,
+      rowCount: out.rowCount,
+      payload,
+    });
+
     // We stopped early with more rows on the server — release the pinned cursor.
     if (out.truncated && out.cursor) {
       await this.cancelQueryStream(out.cursor).catch(() => {

package/src/lib/reddb/desktop-error.ts

@@ -0,0 +1,89 @@
+// The single classifier for desktop-command failures (#115).
+//
+// Tauri's `invoke` rejects with whatever the Rust `Err` serialized to. Every
+// desktop command now returns a structured `{ code, message, detail? }` shape
+// (see apps/desktop/src-tauri/src/lib.rs), but older builds and Tauri's own
+// plugin/runtime failures can still reject with a bare string or an `Error`.
+// This module is the ONE place that inspects the raw thrown value and
+// normalizes it, so the standalone-Surface adapters never re-implement the
+// `e instanceof Error ? … : String(e)` coercion dance.
+
+/** The serializable error shape returned by Rust desktop commands. */
+export interface DesktopCommandError {
+  /** Stable machine token, e.g. `KEYCHAIN`, `EMBEDDED_TIMEOUT`, `SIDECAR_SPAWN`. */
+  code: string;
+  /** Human-readable summary. */
+  message: string;
+  /** Underlying cause (OS/keyring/serde message) when the command had one. */
+  detail?: string;
+}
+
+/** Code used for legacy string errors and anything not shaped as a command error. */
+export const UNKNOWN_DESKTOP_ERROR_CODE = "UNKNOWN";
+
+/** Type guard for the structured shape a desktop command rejects with. */
+export function isDesktopCommandError(x: unknown): x is DesktopCommandError {
+  return (
+    typeof x === "object" &&
+    x !== null &&
+    typeof (x as DesktopCommandError).code === "string" &&
+    typeof (x as DesktopCommandError).message === "string"
+  );
+}
+
+/**
+ * Normalize any value thrown by a desktop command into a `DesktopCommandError`.
+ * Structured errors pass through (with an empty/absent `detail` dropped); bare
+ * strings, `Error` instances, and everything else collapse to the `UNKNOWN`
+ * code so callers always get a `{ code, message }` pair.
+ */
+export function classifyDesktopError(e: unknown): DesktopCommandError {
+  if (isDesktopCommandError(e)) {
+    const detail = e.detail;
+    return {
+      code: e.code,
+      message: e.message,
+      ...(typeof detail === "string" && detail.length > 0 ? { detail } : {}),
+    };
+  }
+  if (typeof e === "string") {
+    return { code: UNKNOWN_DESKTOP_ERROR_CODE, message: e };
+  }
+  if (e instanceof Error) {
+    return { code: UNKNOWN_DESKTOP_ERROR_CODE, message: e.message || String(e) };
+  }
+  return { code: UNKNOWN_DESKTOP_ERROR_CODE, message: String(e) };
+}
+
+/** Human-readable one-liner for a classified desktop error. */
+export function desktopErrorMessage(e: unknown): string {
+  const c = classifyDesktopError(e);
+  return c.detail ? `${c.message}: ${c.detail}` : c.message;
+}
+
+/**
+ * An `Error` carrying the classified `code`/`detail`, with `message` set to the
+ * human-readable one-liner. Adapters throw this so downstream consumers (e.g.
+ * the connection provider) can read `.message` without any coercion, while
+ * still being able to branch on `.code`.
+ */
+export class DesktopError extends Error {
+  readonly code: string;
+  readonly detail?: string;
+
+  constructor(classified: DesktopCommandError) {
+    super(
+      classified.detail
+        ? `${classified.message}: ${classified.detail}`
+        : classified.message
+    );
+    this.name = "DesktopError";
+    this.code = classified.code;
+    this.detail = classified.detail;
+  }
+
+  /** Classify a raw thrown value and wrap it. */
+  static from(e: unknown): DesktopError {
+    return e instanceof DesktopError ? e : new DesktopError(classifyDesktopError(e));
+  }
+}

package/src/lib/reddb/dev-console.ts

@@ -0,0 +1,186 @@
+// Instrumented developer console (#128). A deliberately framework-agnostic,
+// rune-free observable store so the data layer (`RedClient`, transports) can
+// log every query and HTTP call *without* importing Svelte — the client seam
+// must not depend on the UI runtime. The Svelte panel bridges this store into
+// reactivity by subscribing and copying the snapshot into `$state`.
+//
+// Every entry is one round-trip the client made: the verb (HTTP method /
+// statement head), the target (path or endpoint), how long it took, how many
+// rows came back, and a *sanitized* payload — secrets are redacted before an
+// entry is ever stored, so a copy action can never leak a token.
+
+/** What kind of round-trip an entry records. */
+export type ConsoleEntryKind = "query" | "http";
+
+export interface ConsoleEntry {
+  /** Monotonic id, assigned on record. Stable for keying/dedup in the panel. */
+  id: number;
+  kind: ConsoleEntryKind;
+  /** HTTP method or statement head, e.g. `POST`, `GET`, `SELECT`. */
+  verb: string;
+  /** Endpoint path or logical target the call hit, e.g. `/query`. */
+  target: string;
+  /** Absolute wall-clock time the call started. */
+  startedAt: number;
+  /** Round-trip duration in milliseconds. */
+  durationMs: number;
+  /** True when the call succeeded (2xx / resolved). */
+  ok: boolean;
+  /** HTTP status code when one is known. */
+  status?: number;
+  /** Rows returned, when the response carries a row/record count. */
+  rowCount?: number;
+  /** Sanitized request payload or query text — copyable, never contains secrets. */
+  payload?: string;
+  /** Error text when the call failed. */
+  error?: string;
+}
+
+/** A record as handed to the store — the store owns `id`. */
+export type ConsoleEntryInput = Omit<ConsoleEntry, "id">;
+
+/**
+ * A per-entry tap on the console. Unlike `subscribe` (which observes the whole
+ * snapshot for rendering), a sink receives each entry exactly once, as it is
+ * recorded — the shape an embedding host wants for mirroring red-ui's traffic
+ * into its own developer console.
+ */
+export type ConsoleSink = (entry: ConsoleEntry) => void;
+
+type Listener = (entries: readonly ConsoleEntry[]) => void;
+
+/** Keys whose values are always masked, matched case-insensitively as substrings. */
+const SENSITIVE_KEY_RE =
+  /pass(word)?|secret|token|api[-_]?key|authorization|auth|credential|cookie|session|bearer|private[-_]?key|mfa/i;
+
+const REDACTED = "«redacted»";
+
+/**
+ * Recursively redact sensitive values from an arbitrary structure, returning a
+ * plain clone safe to stringify. A value under a sensitive key is replaced with
+ * a marker rather than dropped, so the reader still sees *that* a field existed.
+ * Depth- and breadth-bounded so a pathological payload can't blow the console.
+ */
+export function redactSecrets(value: unknown, depth = 0): unknown {
+  if (depth > 6) return "«…»";
+  if (Array.isArray(value)) {
+    return value.slice(0, 100).map((v) => redactSecrets(v, depth + 1));
+  }
+  if (value && typeof value === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      out[k] = SENSITIVE_KEY_RE.test(k)
+        ? REDACTED
+        : redactSecrets(v, depth + 1);
+    }
+    return out;
+  }
+  return value;
+}
+
+/**
+ * Turn a request body (a JSON string, an object, or anything else) into a
+ * sanitized, human-readable string for the entry's copyable payload. Parses
+ * JSON so keys can be redacted; falls back to a truncated raw string when the
+ * body isn't JSON. Returns `undefined` for an absent body.
+ */
+export function sanitizePayload(body: unknown): string | undefined {
+  if (body === undefined || body === null) return undefined;
+  let parsed: unknown = body;
+  if (typeof body === "string") {
+    if (body.length === 0) return undefined;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      return body.length > 2000 ? `${body.slice(0, 2000)}…` : body;
+    }
+  }
+  try {
+    const json = JSON.stringify(redactSecrets(parsed), null, 2);
+    return json.length > 4000 ? `${json.slice(0, 4000)}…` : json;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * The developer console log. A bounded ring of entries with a minimal
+ * subscribe/emit surface — no framework, no runes. `record` is the single
+ * write path the client seam calls; `subscribe` is how the panel observes.
+ */
+export class DevConsoleStore {
+  private entries: ConsoleEntry[] = [];
+  private readonly listeners = new Set<Listener>();
+  private readonly sinks = new Set<ConsoleSink>();
+  private nextId = 1;
+
+  /** Cap on retained entries; oldest are dropped past this. */
+  constructor(private readonly capacity = 500) {}
+
+  /** Append one round-trip. Assigns the id, trims to capacity, notifies. */
+  record(input: ConsoleEntryInput): ConsoleEntry {
+    const entry: ConsoleEntry = { ...input, id: this.nextId++ };
+    this.entries.push(entry);
+    if (this.entries.length > this.capacity) {
+      this.entries.splice(0, this.entries.length - this.capacity);
+    }
+    this.emit();
+    for (const sink of this.sinks) {
+      try {
+        sink(entry);
+      } catch {
+        // A host-owned sink must never be able to break the client seam.
+      }
+    }
+    return entry;
+  }
+
+  /**
+   * Tap every future entry. Entries recorded before the sink was added are
+   * not replayed — a host mirrors live traffic, it doesn't import history.
+   * Returns an unsubscribe.
+   */
+  addSink(sink: ConsoleSink): () => void {
+    this.sinks.add(sink);
+    return () => {
+      this.sinks.delete(sink);
+    };
+  }
+
+  /** A frozen, newest-last snapshot of the log. */
+  snapshot(): readonly ConsoleEntry[] {
+    return this.entries.slice();
+  }
+
+  /** Number of retained entries. */
+  get size(): number {
+    return this.entries.length;
+  }
+
+  /** Drop every entry and notify. */
+  clear(): void {
+    if (this.entries.length === 0) return;
+    this.entries = [];
+    this.emit();
+  }
+
+  /**
+   * Observe the log. The listener fires immediately with the current snapshot
+   * and again on every change. Returns an unsubscribe.
+   */
+  subscribe(listener: Listener): () => void {
+    this.listeners.add(listener);
+    listener(this.snapshot());
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  private emit(): void {
+    const snap = this.snapshot();
+    for (const listener of this.listeners) listener(snap);
+  }
+}
+
+/** The singleton the client seam records into and the panel observes. */
+export const devConsole = new DevConsoleStore();

package/src/lib/reddb/index.ts

@@ -4,6 +4,7 @@ export * from "./cluster-status";
 export * from "./analytics";
 export * from "./ask";
 export * from "./client";
+export * from "./dev-console";
 export * from "./connection-provider";
 export * from "./local-url-provider";
 export * from "./injected-client-provider";
@@ -15,3 +16,4 @@ export * from "./cdc-stream-client";
 export * from "./secure-store";
 export * from "./web-encrypted-store";
 export * from "./tauri-encrypted-store";
+export * from "./desktop-error";

package/src/lib/reddb/local-url-provider.ts

@@ -181,14 +181,10 @@ export class LocalUrlProvider implements ConnectionProvider {
       try {
         clientUrl = await this.embeddedResolver(target.url);
       } catch (e) {
-        // Tauri's `invoke` rejects with a plain string (the Rust `Err`), not an
-        // Error — so read the message defensively instead of assuming `.message`.
-        const reason =
-          e instanceof Error
-            ? e.message
-            : typeof e === "string"
-              ? e
-              : String(e);
+        // The resolver (the standalone-Surface adapter) already classified the
+        // command failure into an Error with a human-readable message — no
+        // defensive shape-coercion here; just carry the reason through.
+        const reason = e instanceof Error ? e.message : String(e);
         throw new UnreachableConnectionError(target.id, reason);
       }
     }

package/src/lib/reddb/tauri-encrypted-store.ts

@@ -1,4 +1,5 @@
 import { type EncryptedStore, SecureStoreError } from './secure-store'
+import { desktopErrorMessage } from './desktop-error'
 
 export type TauriInvoke = <T = unknown>(cmd: string, args?: Record<string, unknown>) => Promise<T>
 
@@ -35,7 +36,7 @@ export class TauriEncryptedStore implements EncryptedStore {
     try {
       await this.invoke<void>('keychain_set', { service: this.service, key, value })
     } catch (e) {
-      throw new SecureStoreError('BACKEND_FAILURE', `keychain_set failed: ${stringifyError(e)}`)
+      throw new SecureStoreError('BACKEND_FAILURE', `keychain_set failed: ${desktopErrorMessage(e)}`)
     }
   }
 
@@ -44,7 +45,7 @@ export class TauriEncryptedStore implements EncryptedStore {
       const v = await this.invoke<string | null>('keychain_get', { service: this.service, key })
       return v ?? null
     } catch (e) {
-      throw new SecureStoreError('BACKEND_FAILURE', `keychain_get failed: ${stringifyError(e)}`)
+      throw new SecureStoreError('BACKEND_FAILURE', `keychain_get failed: ${desktopErrorMessage(e)}`)
     }
   }
 
@@ -52,13 +53,7 @@ export class TauriEncryptedStore implements EncryptedStore {
     try {
       await this.invoke<void>('keychain_delete', { service: this.service, key })
     } catch (e) {
-      throw new SecureStoreError('BACKEND_FAILURE', `keychain_delete failed: ${stringifyError(e)}`)
+      throw new SecureStoreError('BACKEND_FAILURE', `keychain_delete failed: ${desktopErrorMessage(e)}`)
     }
   }
 }
-
-function stringifyError(e: unknown): string {
-  if (e instanceof Error) return e.message
-  if (typeof e === 'string') return e
-  try { return JSON.stringify(e) } catch { return String(e) }
-}