Stop the terminal and Files panes refusing drops onto their own chrome

The z-order gate added last round asked `el.contains(elementFromPoint(x, y))`
— "is the thing painted here mine?" — and was handed `TerminalView`'s inner
xterm host while every overlay in that pane is a *sibling* of it. So any point
under the pane's own chrome answered "not mine" and the drop was refused, with
no message and no log line. The "▼ Following / ▽ Paused" toggle is rendered
unconditionally at `absolute top-2 right-4`, and `ToastHost` is `fixed
bottom-4 right-4` 24rem wide with error cards that never time out: two corners
of the terminal, and one of the Files pane, that could not accept a file for
as long as the app was running.

It shipped green because jsdom has no `elementFromPoint`, so not one of the 81
drop tests entered that branch. The tests here install one.

The question the gate asks is now "is a *blocking overlay* painted here?".
Chrome the pane paints over itself is not one; a dialog backdrop is, and
`ui/Modal` marks its own backdrop so the element `elementFromPoint` actually
returns is the one carrying the marker. `classifyDrop` also separates "aimed at
me and swallowed" from "not my drop", so the first gets a toast and a log line
and the second stays silent.

Three defects around it:

- **A dialog now refuses only the points it covers.** `dropIsBlocked` is
  document-wide and `ui/Modal` portals to `document.body`, so any open dialog
  refused every drop in the window. The deeper half of that is that a dialog
  opened in project A really was still on screen after a tab switch — the pane
  hides itself with a `hidden` class, which a portal does not inherit — so
  `PaneVisibility` lets `App` tell a `Modal` its pane stepped aside, and a
  hidden one paints nothing, traps no focus, answers no Escape and blocks no
  drop while staying mounted with its state intact.

- **`devicePixelRatio` is applied on Windows only.** Only wry's WebView2
  backend hands over physical pixels; the macOS and GTK ones deliver logical
  points and `tauri-runtime-wry` does not rescale them. Halving those was
  survivable while the test was a bare rect and is a refused drop once z-order
  joins in. Read from the wry/tauri sources, not verified on a HiDPI Mac or
  GTK box.

- **`isFileExistsError` can no longer be forged by a filename.** It matched
  `fileexists` anywhere in a normalised error, so uploading a host file called
  `file-exists.txt` turned *any* failure into a collision — and Replace
  re-invoked the upload with `overwrite: true`. The marker now has to stand
  alone in the backend's canonical form, or be a whole discriminant value.

- **A refused compaction or cache-clear keeps its dialog.** `reclaim` reports
  refusals inside `Ok`, so "did it throw" read one as success: the dialog
  closed, the tick list was dropped, and the explanation appeared in the
  outcome panel several screens above the row that was clicked. The dialog now
  stays put and renders the backend's own sentence verbatim.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GBq2rGum6GX7xXgsas1fDc

app/src/lib/uploadErrors.ts

@@ -25,6 +25,26 @@
  * a `#[derive(Serialize)]` error enum, or an `Error` if a JS layer wrapped it
  * on the way through. All three are the same refusal, and the UI must not
  * behave differently depending on which one a future refactor produces.
+ *
+ * **Tolerant about shape is not the same as tolerant about content.** This
+ * used to normalise the whole error (lower-case, `_`/`-` stripped) and ask
+ * whether `fileexists` appeared *anywhere* in it — which a host file named
+ * `file-exists.txt` satisfies on its way through any error at all. Uploading
+ * that file and hitting "permission denied" therefore raised the overwrite
+ * prompt, and answering Replace re-invoked the upload with `overwrite: true`:
+ * an unrelated failure silently promoted into an overwrite of whatever shared
+ * the name in the container. So the marker now has to appear in a form a
+ * *filename* cannot produce:
+ *
+ * - in prose, the canonical `FILE_EXISTS` (or `FILE-EXISTS`) in upper case,
+ *   standing alone — end of string, or followed by the `:`/`=` of the agreed
+ *   `FILE_EXISTS: <path>` form. `file-exists.txt`, `FILE_EXISTS.txt` and
+ *   `/workspace/FILE_EXISTS` all fail that, because a filename brings its own
+ *   extension, quote or path separator along with it.
+ * - in a discriminant field, the *whole* value, case- and separator-insensitive
+ *   (`FileExists`, `file_exists`, `file-exists`, `FileExistsError`) — a
+ *   discriminant is a variant name, not a sentence, so equality is the right
+ *   test and a filename never gets to be one.
  */
 
 /** Marker the backend puts in the error for "a file with this name is already there". */
@@ -47,6 +67,26 @@ function normaliseKind(value: string): string {
 
 const KIND_NEEDLE = normaliseKind(FILE_EXISTS_MARKER);
 
+/**
+ * The marker standing on its own inside a sentence.
+ *
+ * Derived from `FILE_EXISTS_MARKER` so the two cannot drift. Upper case is
+ * load-bearing (a lower-case `file-exists` is a plausible filename, the
+ * upper-case token is not), and so is the lookahead: the marker must end the
+ * string or be followed by the `:`/`=` that introduces the path. That is what
+ * a path or a filename cannot forge — `FILE_EXISTS.txt`, `"FILE_EXISTS"` and
+ * `/workspace/FILE_EXISTS` are each rejected by one end or the other.
+ */
+const PROSE_MARKER = new RegExp(
+  `(?:^|[\\s:;(\\[{"'\`])${FILE_EXISTS_MARKER.replace(/_/g, "[_-]")}(?=$|[\\s:=])`,
+);
+
+/** A discriminant *is* the refusal, rather than mentioning it. */
+function isFileExistsDiscriminant(value: string): boolean {
+  const normalised = normaliseKind(value);
+  return normalised === KIND_NEEDLE || normalised === `${KIND_NEEDLE}error`;
+}
+
 function asRecord(e: unknown): Record<string, unknown> | null {
   return typeof e === "object" && e !== null ? (e as Record<string, unknown>) : null;
 }
@@ -57,17 +97,40 @@ function asRecord(e: unknown): Record<string, unknown> | null {
  * because a wrapped error (`{ error: { kind: … } }`) is the same refusal.
  */
 function stringsIn(e: unknown, depth = 0): string[] {
-  if (typeof e === "string") return [e];
-  if (e instanceof Error) return [e.message, e.name];
+  const { prose, kinds } = partitionStrings(e, depth);
+  return [...prose, ...kinds];
+}
+
+/**
+ * The same flattening, but keeping track of *where* each string came from.
+ *
+ * A discriminant field and a message field are held to different standards
+ * (see the module comment), so they cannot be pooled. `error` is listed as a
+ * discriminant field and yet routinely carries a whole sentence, which is why
+ * a kind string is tested against both rules and a prose string only against
+ * the prose one.
+ */
+function partitionStrings(
+  e: unknown,
+  depth = 0,
+): { prose: string[]; kinds: string[] } {
+  if (typeof e === "string") return { prose: [e], kinds: [] };
+  if (e instanceof Error) return { prose: [e.message], kinds: [e.name] };
   const record = asRecord(e);
-  if (!record || depth > 1) return [];
-  const out: string[] = [];
-  for (const field of [...KIND_FIELDS, ...MESSAGE_FIELDS]) {
-    const value = record[field];
-    if (typeof value === "string") out.push(value);
-    else if (value !== undefined) out.push(...stringsIn(value, depth + 1));
-  }
-  return out;
+  if (!record || depth > 1) return { prose: [], kinds: [] };
+  const prose: string[] = [];
+  const kinds: string[] = [];
+  const walk = (value: unknown, into: string[]) => {
+    if (typeof value === "string") into.push(value);
+    else if (value !== undefined) {
+      const nested = partitionStrings(value, depth + 1);
+      prose.push(...nested.prose);
+      kinds.push(...nested.kinds);
+    }
+  };
+  for (const field of KIND_FIELDS) walk(record[field], kinds);
+  for (const field of MESSAGE_FIELDS) walk(record[field], prose);
+  return { prose, kinds };
 }
 
 /**
@@ -78,7 +141,11 @@ function stringsIn(e: unknown, depth = 0): string[] {
  * to work.
  */
 export function isFileExistsError(e: unknown): boolean {
-  return stringsIn(e).some((s) => normaliseKind(s).includes(KIND_NEEDLE));
+  const { prose, kinds } = partitionStrings(e);
+  return (
+    kinds.some((s) => isFileExistsDiscriminant(s) || PROSE_MARKER.test(s)) ||
+    prose.some((s) => PROSE_MARKER.test(s))
+  );
 }
 
 /**