@@ -839,6 +839,7 @@ void Window::SetContentSize(Size size) {
   if (pimpl_->widget_ && GTK_IS_WINDOW(pimpl_->widget_)) {
     size.width += linux_shadow::Gutter(pimpl_->widget_) * 2;
     size.height += linux_shadow::Gutter(pimpl_->widget_) * 2;
+    linux_shadow::NoteRequestedSize(pimpl_->widget_, (gint)size.width, (gint)size.height);
     GtkWindow* gtk_window = GTK_WINDOW(pimpl_->widget_);
     if (!gtk_window_get_resizable(gtk_window)) {
       // GTK derives a non-resizable window's fixed geometry from its default
@@ -1310,10 +1311,14 @@ static void EnsureNoShadowRule(GtkWidget* widget) {
   }
   installed = true;
   GtkCssProvider* provider = gtk_css_provider_new();
+  // The margin too: the theme's decoration node reserves one for its shadow (10 px in
+  // Adwaita), GTK counts it as shadow width, and drops it the moment the compositor
+  // reports the window tiled or maximized - on Hyprland that is every window, right
+  // after it maps, so a popup would lay itself out twice on every show.
   gtk_css_provider_load_from_data(provider,
                                   "window.nativeapi-no-shadow decoration,"
                                   "window.nativeapi-no-shadow decoration:backdrop {"
-                                  "  box-shadow: none; border: none; }",
+                                  "  box-shadow: none; border: none; margin: 0; }",
                                   -1, nullptr);
   gtk_style_context_add_provider_for_screen(gtk_widget_get_screen(widget),
                                             GTK_STYLE_PROVIDER(provider),
 
@@ -26,7 +26,12 @@ inline int ReservedMargin() {
 // States in which the window manager fits the whole surface to the space it gives the
 // window - a tiling window manager's tiles, maximized, full screen. The gutter is then
 // no shadow, only a band of empty window around the content, so it is taken away
-// while the window is in one of them.
+// while the window is in one of them - when the window manager really sized the
+// surface. Hyprland reports every toplevel as maximized and tiled, floating ones too,
+// so that it draws no client-side shadow, and leaves the size to the client: nothing
+// is painted in the gutter then, but the gutter stays, because GDK takes no resize
+// while those states stand and taking the border away would hand the content the
+// whole surface. The declared window geometry excludes the gutter either way.
 constexpr int kFittedStates =
     GDK_WINDOW_STATE_MAXIMIZED | GDK_WINDOW_STATE_FULLSCREEN | GDK_WINDOW_STATE_TILED |
     GDK_WINDOW_STATE_TOP_TILED | GDK_WINDOW_STATE_RIGHT_TILED |
@@ -39,16 +44,31 @@ struct State {
   int margin = ReservedMargin();
   std::shared_ptr<WindowShadow> custom;
   bool enabled = true;
+  // The window manager's states say fitted: nothing is painted in the gutter.
   bool fitted = false;
+  // The surface carries the gutter: the container border is the margin.
+  bool gutter = false;
+  // The surface size last allocated or asked for, to tell a surface the window manager
+  // sized for a fitted state from one its states merely relabelled.
+  int surface_width = 0, surface_height = 0;
+  // Whether to carry a gutter at all is decided once the compositor's states are
+  // known (see Decide()); until then neither border nor size is touched.
+  bool decided = false;
+  gulong decide_on_map = 0;
+  guint decide_timeout = 0;
   bool dirty = true;
   int width = 0, height = 0;
   WindowShape polygon;
   cairo_surface_t* image = nullptr;
   ~State() {
+    if (decide_timeout)
+      g_source_remove(decide_timeout);
     if (image)
       cairo_surface_destroy(image);
   }
 };
+inline void Decide(GtkWidget* widget, State* state);
+inline void Trace(const char* where, GtkWidget* widget, State* state);
 inline State* Get(GtkWidget* widget) {
   return widget ? static_cast<State*>(g_object_get_data(G_OBJECT(widget), kState)) : nullptr;
 }
@@ -57,7 +77,28 @@ inline int Gutter(GtkWidget* widget) {
   auto* state = Get(widget);
   if (!state)
     return 0;
-  return state->fitted ? static_cast<int>(state->original_border) : state->margin;
+  return state->gutter ? state->margin : static_cast<int>(state->original_border);
+}
+// What the surface is about to be sized to (SetContentSize), so that a configure
+// echoing it is not taken for the window manager's own size.
+inline void NoteRequestedSize(GtkWidget* widget, int width, int height) {
+  if (auto* state = Get(widget)) {
+    state->surface_width = width;
+    state->surface_height = height;
+  }
+}
+inline bool SurfaceSizedByWindowManager(GtkWidget* widget, State* state) {
+  int width = 0, height = 0;
+  gtk_window_get_size(GTK_WINDOW(widget), &width, &height);
+  return state->surface_width > 0 &&
+         (width != state->surface_width || height != state->surface_height);
+}
+inline void SetGutter(GtkWidget* widget, State* state, bool gutter) {
+  if (state->gutter == gutter)
+    return;
+  state->gutter = gutter;
+  gtk_container_set_border_width(GTK_CONTAINER(widget),
+                                 gutter ? state->margin : state->original_border);
 }
 inline bool IsFitted(GtkWidget* widget) {
   auto* window = gtk_widget_get_window(widget);
@@ -159,7 +200,9 @@ inline void DeclareGutter(GtkWidget* widget) {
     return;
   gdk_window_set_shadow_width(window, x, right, y, bottom);
 }
-inline void Allocated(GtkWidget* widget, GtkAllocation*, gpointer) {
+inline void Allocated(GtkWidget* widget, GtkAllocation*, gpointer data) {
+  auto* state = static_cast<State*>(data);
+  gtk_window_get_size(GTK_WINDOW(widget), &state->surface_width, &state->surface_height);
   RefreshShadowInput(widget);
   DeclareGutter(widget);
 }
@@ -191,17 +234,32 @@ inline void ClearGutterBackground(GtkWidget* widget) {
   }
   gtk_style_context_add_class(gtk_widget_get_style_context(widget), kGutterStyleClass);
 }
-// The window manager has already sized the surface for the new state; changing the
-// border only moves the content edge to the surface edge, or back in.
+// Into a fitted state the window manager has already sized the surface, and changing
+// the border only moves the content edge to the surface edge; out of one it restores
+// the surface it had, gutter included, and the border moves the edge back in. A fitted
+// state that came with no size of the window manager's (Hyprland, see kFittedStates)
+// keeps the gutter: the surface is what the client asked for, and GDK would not
+// shrink it now anyway.
 inline gboolean StateChanged(GtkWidget* widget, GdkEventWindowState* event, gpointer data) {
   auto* state = static_cast<State*>(data);
-  const bool fitted = (event->new_window_state & kFittedStates) != 0;
-  if (fitted != state->fitted) {
-    state->fitted = fitted;
-    gtk_container_set_border_width(GTK_CONTAINER(widget),
-                                   fitted ? state->original_border : state->margin);
-    gtk_widget_queue_draw(widget);
+  Trace("state-event", widget, state);
+  if (!state->decided) {
+    // The compositor's first configure brings the states: a fitted one, or none, in
+    // which case the focus GDK assumed on show goes away. GDK's own show-time event
+    // (WITHDRAWN cleared, FOCUSED set) is not an answer.
+    const bool fitted_changed = (event->changed_mask & kFittedStates) != 0;
+    const bool focus_withdrawn = (event->changed_mask & GDK_WINDOW_STATE_FOCUSED) &&
+                                 !(event->new_window_state & GDK_WINDOW_STATE_FOCUSED);
+    if (fitted_changed || focus_withdrawn)
+      Decide(widget, state);
+    return FALSE;
   }
+  const bool fitted = (event->new_window_state & kFittedStates) != 0;
+  if (fitted == state->fitted)
+    return FALSE;
+  state->fitted = fitted;
+  SetGutter(widget, state, !fitted || !SurfaceSizedByWindowManager(widget, state));
+  gtk_widget_queue_draw(widget);
   return FALSE;
 }
 inline void Remove(GtkWidget* widget) {
@@ -229,6 +287,85 @@ inline void Remove(GtkWidget* widget) {
   g_object_set_data(G_OBJECT(widget), kState, nullptr);
   gtk_widget_queue_draw(widget);
 }
+// Grows the surface by the margin on every side, around the content as it is, and
+// moves it back so the content stays put. Only once the window manager's states are
+// known: on a compositor that reports every window as tiled (see kFittedStates) GDK
+// takes no resize afterwards, and a gutter added before would hand the content the
+// whole surface for good.
+inline void AddGutter(GtkWidget* widget, State* state) {
+  int width = 0, height = 0;
+  int x = 0, y = 0;
+  gtk_window_get_position(GTK_WINDOW(widget), &x, &y);
+  gtk_window_get_size(GTK_WINDOW(widget), &width, &height);
+  SetGutter(widget, state, true);
+  const int extra = state->margin - state->original_border;
+  NoteRequestedSize(widget, width + extra * 2, height + extra * 2);
+  gtk_window_resize(GTK_WINDOW(widget), width + extra * 2, height + extra * 2);
+  gtk_window_move(GTK_WINDOW(widget), x - extra, y - extra);
+}
+inline void Trace(const char* where, GtkWidget* widget, State* state) {
+  static const bool on = g_getenv("NATIVEAPI_SHADOW_TRACE") != nullptr;
+  if (!on) return;
+  auto* window = gtk_widget_get_window(widget);
+  int w = 0, h = 0;
+  gtk_window_get_size(GTK_WINDOW(widget), &w, &h);
+  g_printerr("[shadow %ld] %s: state 0x%x mapped %d decided %d fitted %d gutter %d size %dx%d\n",
+             (long)(g_get_monotonic_time() / 1000), where,
+             window ? (unsigned)gdk_window_get_state(window) : 0u, gtk_widget_get_mapped(widget),
+             state->decided, state->fitted, state->gutter, w, h);
+}
+inline void Decide(GtkWidget* widget, State* state) {
+  if (state->decided)
+    return;
+  Trace("decide", widget, state);
+  state->decided = true;
+  if (state->decide_on_map) {
+    g_signal_handler_disconnect(widget, state->decide_on_map);
+    state->decide_on_map = 0;
+  }
+  if (state->decide_timeout) {
+    g_source_remove(state->decide_timeout);
+    state->decide_timeout = 0;
+  }
+  state->fitted = IsFitted(widget);
+  if (!state->fitted)
+    AddGutter(widget, state);
+  gtk_widget_queue_draw(widget);
+}
+inline gboolean DecideOnTimeout(gpointer data) {
+  auto* state = static_cast<State*>(data);
+  state->decide_timeout = 0;
+  Trace("timeout", state->target, state);
+  Decide(state->target, state);
+  return G_SOURCE_REMOVE;
+}
+// A window that is on screen but reports no state (floating, unfocused) gets no
+// configure of its own accord: decide for it after a moment.
+constexpr guint kDecideTimeoutMs = 300;
+inline void ArmDecideTimeout(State* state) {
+  if (!state->decided && !state->decide_timeout)
+    state->decide_timeout = g_timeout_add(kDecideTimeoutMs, DecideOnTimeout, state);
+}
+inline gboolean ArmDecideOnMap(GtkWidget*, GdkEvent*, gpointer data) {
+  ArmDecideTimeout(static_cast<State*>(data));
+  return FALSE;
+}
+// Decide now when the window already reports a fitted state; otherwise at the
+// window-state event that brings the compositor's answer (StateChanged), or shortly
+// after the window is mapped. Not at the first configure-event: GTK emits one for its
+// own initial size before the compositor has answered. Not on any state event either:
+// GDK marks a toplevel focused as it shows it, before the compositor has said so.
+inline void DecideWhenKnown(GtkWidget* widget, State* state) {
+  if (IsFitted(widget)) {
+    Decide(widget, state);
+    return;
+  }
+  if (gtk_widget_get_mapped(widget))
+    ArmDecideTimeout(state);
+  else
+    state->decide_on_map = g_signal_connect(widget, "map-event", G_CALLBACK(ArmDecideOnMap), state);
+}
+
 inline State* Ensure(GtkWidget* widget) {
   if (auto* state = Get(widget))
     return state;
@@ -266,26 +403,18 @@ inline State* Ensure(GtkWidget* widget) {
     state->custom = std::make_shared<WindowShadow>(*config);
   }
   state->original_border = gtk_container_get_border_width(GTK_CONTAINER(widget));
-  state->fitted = IsFitted(widget);
+  state->fitted = IsFitted(widget);  // final once Decide() has run
   g_object_set_data_full(G_OBJECT(widget), kState, state,
                          [](gpointer p) { delete static_cast<State*>(p); });
   g_signal_connect_after(widget, "draw", G_CALLBACK(Draw), state);
   g_signal_connect_after(widget, "size-allocate", G_CALLBACK(Allocated), state);
   g_signal_connect(widget, "window-state-event", G_CALLBACK(StateChanged), state);
   if (CanBeTranslucent(widget))
     ClearGutterBackground(widget);
-  if (state->fitted)
-    return state;
   // The gutter belongs to GTK, not the application's render tree. Keeping it
   // reserved while disabled avoids geometry changes when toggling the shadow.
-  int width = 0, height = 0;
-  int x = 0, y = 0;
-  gtk_window_get_position(GTK_WINDOW(widget), &x, &y);
-  gtk_window_get_size(GTK_WINDOW(widget), &width, &height);
-  gtk_container_set_border_width(GTK_CONTAINER(widget), state->margin);
-  const int extra = state->margin - state->original_border;
-  gtk_window_resize(GTK_WINDOW(widget), width + extra * 2, height + extra * 2);
-  gtk_window_move(GTK_WINDOW(widget), x - extra, y - extra);
+  Trace("ensure", widget, state);
+  DecideWhenKnown(widget, state);
   return state;
 }
 inline void Configure(GtkWidget* widget, std::shared_ptr<WindowShadow> custom) {
 
@@ -165,6 +165,13 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
   target_link_libraries(window_restore_linux_test PRIVATE nativeapi)
 endif()
 
+# Explicit desktop integration test; requires a running compositor (meant for one that
+# sends tiled states to floating windows, such as Hyprland).
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+  add_executable(window_shadow_remap_linux_test window_shadow_remap_linux_test.cpp)
+  target_link_libraries(window_shadow_remap_linux_test PRIVATE nativeapi)
+endif()
+
 # Explicit desktop integration test; creates windows but sends no input.
 if(WIN32 OR (APPLE AND NOT CMAKE_SYSTEM_NAME STREQUAL "iOS"))
   if(APPLE)