@@ -38,6 +38,9 @@ int main() {
   bool over_dock = false;
   // Hiding the panel on drop hands focus to the dock; that is not a press.
   bool dropping = false;
+  // Focus changes are not always presses (and arrive late on some platforms),
+  // so a tear-off only happens once the cursor moves with the button down.
+  bool tear_off_pending = false;
 
   auto contains = [](const nativeapi::Rectangle& r, const Point& p) {
     return p.x >= r.x && p.y >= r.y && p.x < r.x + r.width && p.y < r.y + r.height;
@@ -55,18 +58,25 @@ int main() {
       session->Start(panel, {cursor.x - position.x, cursor.y - position.y});
     } else if (event.GetWindowId() == dock->GetId() && docked &&
                contains(dock->GetContentBounds(), cursor)) {
+      // Follow the pointer; the panel only comes out once it moves.
+      tear_off_pending = session->Start(nullptr, {0, 0});
+    }
+  });
+
+  session->AddListener<WindowDragMovedEvent>([&](const WindowDragMovedEvent& event) {
+    if (tear_off_pending) {
       // Tear off: bring the panel back under the cursor, grabbed by its title bar.
+      tear_off_pending = false;
+      Point cursor = event.GetCursorPosition();
       Point anchor{130, 12};
       panel->SetPosition({cursor.x - anchor.x, cursor.y - anchor.y});
       panel->Show();
       docked = false;
       session->Start(panel, anchor);
       dock->SetTitle("Dock - drop the panel here");
       std::cout << "Panel torn off" << std::endl;
+      return;
     }
-  });
-
-  session->AddListener<WindowDragMovedEvent>([&](const WindowDragMovedEvent& event) {
     auto target = window_manager.GetWindowAtPoint(event.GetCursorPosition(), panel->GetId());
     bool now_over_dock = target && target->GetId() == dock->GetId();
     if (now_over_dock != over_dock) {
@@ -77,6 +87,10 @@ int main() {
   });
 
   session->AddListener<WindowDragEndedEvent>([&](const WindowDragEndedEvent& event) {
+    if (tear_off_pending) {
+      tear_off_pending = false;  // Released without moving: just a click.
+      return;
+    }
     Point cursor = event.GetCursorPosition();
     std::cout << "Drag ended at (" << cursor.x << ", " << cursor.y << ")" << std::endl;
     panel->SetOpacity(1.0f);
@@ -91,8 +105,10 @@ int main() {
     }
   });
 
-  session->AddListener<WindowDragCancelledEvent>(
-      [&](const WindowDragCancelledEvent&) { std::cout << "Drag cancelled" << std::endl; });
+  session->AddListener<WindowDragCancelledEvent>([&](const WindowDragCancelledEvent&) {
+    tear_off_pending = false;
+    std::cout << "Drag cancelled" << std::endl;
+  });
 
   std::cout << "Press inside the Panel window and drag it onto the Dock window to dock it."
             << std::endl;
 
@@ -26,11 +26,16 @@ static WindowId GetWindowIdFromHwnd(HWND hwnd) {
     return IdAllocator::kInvalidId;
   }
 
-  // First, try to get window ID from HWND's custom property
+  // First, try to get window ID from HWND's custom property. A window can carry
+  // an ID without being registered (created by Window(), or wrapped by a
+  // binding), so make sure WindowManager::Get() can find it either way.
   HANDLE prop_handle = GetPropW(hwnd, kWindowIdProperty);
   if (prop_handle) {
     WindowId window_id = static_cast<WindowId>(reinterpret_cast<uintptr_t>(prop_handle));
     if (window_id != IdAllocator::kInvalidId && window_id != 0) {
+      if (!WindowRegistry::GetInstance().Get(window_id)) {
+        WindowRegistry::GetInstance().Add(window_id, std::make_shared<Window>(hwnd));
+      }
       return window_id;
     }
   }
@@ -459,18 +464,43 @@ WindowManager::~WindowManager() {
   StopEventListening();
 }
 
+namespace {
+
+struct WindowIdSearch {
+  WindowId id;
+  HWND found;
+};
+
+// Finds this process's top-level window carrying an ID, visible or not.
+BOOL CALLBACK FindWindowWithId(HWND hwnd, LPARAM data) {
+  auto* search = reinterpret_cast<WindowIdSearch*>(data);
+  if (!IsOwnProcessWindow(hwnd)) {
+    return TRUE;
+  }
+  HANDLE prop_handle = GetPropW(hwnd, kWindowIdProperty);
+  if (prop_handle && static_cast<WindowId>(reinterpret_cast<uintptr_t>(prop_handle)) == search->id) {
+    search->found = hwnd;
+    return FALSE;
+  }
+  return TRUE;
+}
+
+}  // namespace
+
 std::shared_ptr<Window> WindowManager::Get(WindowId id) {
   // First try to get from registry
   auto window = WindowRegistry::GetInstance().Get(id);
   if (window) {
     return window;
   }
 
-  // If not in registry, enumerate all windows to find it
-  // This will create and register the window if it exists
-  GetAll();
-
-  // Try again after enumeration
+  // Not registered yet: the window may still exist, hidden or untitled (which
+  // GetAll() skips), so look for the ID on this process's windows directly.
+  WindowIdSearch search = {id, nullptr};
+  EnumWindows(FindWindowWithId, reinterpret_cast<LPARAM>(&search));
+  if (search.found) {
+    GetWindowIdFromHwnd(search.found);
+  }
   return WindowRegistry::GetInstance().Get(id);
 }
 
@@ -573,41 +603,38 @@ POINT LogicalToPhysicalScreenPoint(Point point) {
           static_cast<LONG>(std::lround(point.y * scale))};
 }
 
-struct HitTestSearch {
-  POINT point;
-  HWND excluded;
-  HWND found;
-};
-
-// EnumWindows visits top-level windows in z-order, topmost first, so the first
-// window that is actually painted at the point is the one the user sees there.
-BOOL CALLBACK HitTestTopLevelWindow(HWND hwnd, LPARAM data) {
-  auto* search = reinterpret_cast<HitTestSearch*>(data);
-  if (hwnd == search->excluded || !IsWindowVisible(hwnd) || IsIconic(hwnd)) {
-    return TRUE;
+// Whether `hwnd`, a top-level window, visibly covers `point`. Used below the
+// window excluded from a hit test, where the system's own hit test cannot look.
+bool CoversPoint(HWND hwnd, POINT point) {
+  if (!IsWindowVisible(hwnd) || IsIconic(hwnd)) {
+    return false;
   }
   LONG ex_style = GetWindowLongW(hwnd, GWL_EXSTYLE);
-  if ((ex_style & WS_EX_LAYERED) && (ex_style & WS_EX_TRANSPARENT)) {
-    return TRUE;  // Click-through overlay.
+  if (ex_style & WS_EX_LAYERED) {
+    if (ex_style & WS_EX_TRANSPARENT) {
+      return false;  // Click-through overlay.
+    }
+    BYTE alpha = 255;
+    DWORD flags = 0;
+    if (GetLayeredWindowAttributes(hwnd, nullptr, &alpha, &flags) && (flags & LWA_ALPHA) &&
+        alpha == 0) {
+      return false;  // Fully transparent.
+    }
   }
   BOOL cloaked = FALSE;
   if (SUCCEEDED(DwmGetWindowAttribute(hwnd, DWMWA_CLOAKED, &cloaked, sizeof(cloaked))) &&
       cloaked) {
-    return TRUE;  // On another virtual desktop, or a suspended UWP frame.
+    return false;  // On another virtual desktop, or a suspended UWP frame.
   }
   // The extended frame excludes the invisible resize borders that
   // GetWindowRect() includes on Windows 10 and later.
   RECT rect;
   if (FAILED(DwmGetWindowAttribute(hwnd, DWMWA_EXTENDED_FRAME_BOUNDS, &rect, sizeof(rect)))) {
     if (!GetWindowRect(hwnd, &rect)) {
-      return TRUE;
+      return false;
     }
   }
-  if (!PtInRect(&rect, search->point)) {
-    return TRUE;
-  }
-  search->found = hwnd;
-  return FALSE;
+  return PtInRect(&rect, point) != FALSE;
 }
 
 }  // namespace
@@ -619,13 +646,32 @@ std::shared_ptr<Window> WindowManager::GetWindowAtPoint(Point point, WindowId ex
       excluded = static_cast<HWND>(window->GetNativeObject());
     }
   }
-
-  HitTestSearch search = {LogicalToPhysicalScreenPoint(point), excluded, nullptr};
-  EnumWindows(HitTestTopLevelWindow, reinterpret_cast<LPARAM>(&search));
-  if (!search.found || !IsOwnProcessWindow(search.found)) {
+  const POINT physical = LogicalToPhysicalScreenPoint(point);
+
+  // Ask the system first: WindowFromPoint() is the window a click would reach,
+  // so it looks through click-through overlays (layered windows with
+  // transparent pixels, like game or capture overlays) that cover the screen.
+  HWND found = WindowFromPoint(physical);
+  if (found) {
+    found = GetAncestor(found, GA_ROOT);
+  }
+  if (found && found == excluded) {
+    // The excluded window, typically the one being dragged, is right under the
+    // point. Walk down the stack beneath it instead.
+    found = nullptr;
+    for (HWND below = GetWindow(excluded, GW_HWNDNEXT); below;
+         below = GetWindow(below, GW_HWNDNEXT)) {
+      if (CoversPoint(below, physical)) {
+        found = below;
+        break;
+      }
+    }
+  }
+  // Another application's window on top means the point is covered.
+  if (!found || !IsOwnProcessWindow(found)) {
     return nullptr;
   }
-  WindowId window_id = GetWindowIdFromHwnd(search.found);
+  WindowId window_id = GetWindowIdFromHwnd(found);
   if (window_id == IdAllocator::kInvalidId) {
     return nullptr;
   }
 
@@ -17,9 +17,11 @@ bool WindowDragSession::Start(std::shared_ptr<Window> window, Point anchor) {
   anchor_ = anchor;
   last_cursor_position_ = cursor_position;
   active_ = true;
-  ++generation_;
 
-  if (window_) {
+  // A gesture can be recognized after the button was already released; the
+  // first tick reports the end then, and the window must not jump to wherever
+  // the cursor has gone meanwhile.
+  if (window_ && primary_button_down) {
     MoveWindow(*window_, cursor_position);
   }
   StartTicking();
@@ -67,24 +69,21 @@ void WindowDragSession::HandleTick() {
     return;
   }
 
+  // Released: the drag is over where the cursor was last followed. Moving now
+  // would carry the window to wherever the cursor went after the release.
+  if (!primary_button_down) {
+    Finish(false, cursor_position);
+    return;
+  }
+
   const bool moved = std::fabs(cursor_position.x - last_cursor_position_.x) >= 0.5 ||
                      std::fabs(cursor_position.y - last_cursor_position_.y) >= 0.5;
   if (moved) {
     last_cursor_position_ = cursor_position;
     if (window_) {
       MoveWindow(*window_, cursor_position);
     }
-    const unsigned long generation = generation_;
     Emit<WindowDragMovedEvent>(window_id_, cursor_position);
-    // A listener restarted or stopped the session; the release below, if any,
-    // belongs to whatever state it left behind and is picked up next tick.
-    if (generation != generation_ || !active_) {
-      return;
-    }
-  }
-
-  if (!primary_button_down) {
-    Finish(false, cursor_position);
   }
 }
 
@@ -93,7 +92,6 @@ void WindowDragSession::Finish(bool cancelled, Point cursor_position) {
     return;
   }
   active_ = false;
-  ++generation_;
   StopTicking();
 
   const WindowId window_id = window_id_;
 
@@ -127,8 +127,9 @@ class WindowDragSession : public EventEmitter<WindowDragEvent> {
    *        point inside the content.
    * @return false if the platform cannot track the cursor globally.
    *
-   * If the primary button is not held down when the session first samples the
-   * pointer, the session ends right away with a WindowDragEndedEvent.
+   * If the primary button is not held down when the session starts, the window
+   * is left where it is and the session ends right away with a
+   * WindowDragEndedEvent.
    *
    * Calling Start() on an active session retargets it: the previous target is
    * released without a WindowDragEndedEvent or WindowDragCancelledEvent, so the
@@ -182,9 +183,6 @@ class WindowDragSession : public EventEmitter<WindowDragEvent> {
   Point anchor_{0, 0};
   Point last_cursor_position_{0, 0};
   bool active_ = false;
-  // Incremented by every Start()/Finish() so a tick can tell whether a
-  // listener it called restarted or stopped the session.
-  unsigned long generation_ = 0;
 };
 
 }  // namespace nativeapi