feat(detach): hand birth_content the window's real size

Now that geometry restores a detached window's remembered size inside
open_detached's build(), DetachSpec's width/height describe only the
never-popped-before case — but all three consumers computed their docked
content's birth rect from exactly those constants, so a re-popped tab's
content sat visibly the wrong size until detach.html reported the true
hole.

Pass the built window's real logical inner size into birth_content rather
than documenting the trap: a caller can no longer use the stale value
without reaching past the one it was handed. A failed geometry query
falls back to spec's size — a stale birth rect costs one frame, refusing
to dock costs the pop-out.

Author: Lockyc

CLAUDE.md

@@ -218,11 +218,15 @@ regardless of what it hosts. It is NOT a place to abstract things that merely *l
       launch and orphan an entry each time. Every consumer already derives it from a stable
       identity (warden hashes `origin_label:tab_key`; curator and lector hash the tab's own label),
       and each pins that determinism with its own test.
-    - **`DetachSpec`'s `width`/`height` are the first-pop-out default only.** Restore overwrites
-      them inside `open_detached`'s `build()` for any tab popped out before, so a consumer sizing
-      its docked content must read the built window's real `inner_size()` inside `birth_content`,
-      never the constants it passed in. warden hit exactly this: its reparented native surface was
-      born at the default rect and only snapped right once `detach.html` reported the true hole.
+    - **`DetachSpec`'s `width`/`height` are the first-pop-out default only** — restore overwrites
+      them inside `open_detached`'s `build()` for any tab popped out before. So `birth_content` is
+      handed the window's **real** logical inner size as its second argument, and a consumer sizes
+      its docked content from that. All three consumers computed a birth rect from the constants
+      before this, and all three were wrong the moment geometry started being remembered; handing
+      the fact over beats documenting the trap, since the stale value is now the one you'd have to
+      reach past. (The cost of getting it wrong is bounded — one frame, until `detach.html`'s
+      `set_hole_rect` reports the true hole — which is also why a failed geometry query falls back
+      to `spec`'s size rather than failing the pop-out.)
   - **A banner-only shell page** (`detach.html` — title + origin accent, no sidebar), served over
     its own custom protocol `DETACH_SCHEME`, registered on the `Builder` by
     `register_detach_protocol` (chained into `register_plugins` alongside `home`'s). Same reasoning

src/detach.rs

@@ -65,8 +65,8 @@ const DETACH_HTML: &str = include_str!("detach.html");
 ///
 /// `width`/`height` are the **first-pop-out default only**. Once this tab has been popped out and
 /// resized, [`crate::geometry`] restores its remembered size and position over them during
-/// [`open_detached`]'s `build()` — so a caller sizing its own content off these constants rather
-/// than off the built window's real `inner_size()` will get it wrong for every subsequent pop-out.
+/// [`open_detached`]'s `build()`. That is why `birth_content` is handed the window's real size —
+/// size docked content from *that*, never from these fields.
 pub struct DetachSpec {
     pub title: String,
     pub colour: Option<String>,
@@ -125,6 +125,15 @@ pub(crate) fn register_detach_protocol<R: tauri::Runtime>(
 /// rect) — on `Err`, the freshly-built window is closed and the error propagated, so a failed dock
 /// never leaves an empty banner-only window behind. On success, returns the window's label so the
 /// caller can look it up again (e.g. to call [`wire_return`]).
+///
+/// **`birth_content` is handed the window's real logical inner size, and must size its content
+/// from that rather than from the `spec` it passed in.** By the time the closure runs,
+/// [`crate::geometry`] has already restored this tab's remembered size over `spec`'s — its
+/// `on_window_ready` hook runs inside `build()` — so `spec.width`/`spec.height` describe only the
+/// never-popped-before case. Every consumer computes a birth rect for its docked content, and all
+/// three got this wrong from the constants before the size was passed in: handing over the fact
+/// beats documenting the trap, since a caller cannot use the stale value without reaching past the
+/// one it was given. Falls back to `spec`'s size if the window's geometry can't be queried.
 pub fn open_detached<R, F>(
     app: &tauri::AppHandle<R>,
     token: &str,
@@ -134,7 +143,7 @@ pub fn open_detached<R, F>(
 ) -> tauri::Result<String>
 where
     R: tauri::Runtime,
-    F: FnOnce(&tauri::WebviewWindow<R>) -> tauri::Result<()>,
+    F: FnOnce(&tauri::WebviewWindow<R>, tauri::LogicalSize<f64>) -> tauri::Result<()>,
 {
     let label = detached_label(token);
     let payload = detach_payload_json(spec, app_name);
@@ -158,7 +167,16 @@ where
             ))
             .build()?;
 
-    if let Err(e) = birth_content(&window) {
+    // The size the window ACTUALLY has, which is `spec`'s only when this tab has no remembered
+    // geometry — see this function's doc. A failed query falls back to `spec`'s size rather than
+    // erroring: a birth rect that is merely stale costs one frame (`detach.html`'s `set_hole_rect`
+    // corrects it), where refusing to dock would cost the whole pop-out.
+    let real_size = window
+        .scale_factor()
+        .and_then(|scale| window.inner_size().map(|s| s.to_logical::<f64>(scale)))
+        .unwrap_or_else(|_| tauri::LogicalSize::new(spec.width, spec.height));
+
+    if let Err(e) = birth_content(&window, real_size) {
         let _ = window.close();
         return Err(e);
     }