@@ -1246,9 +1246,9 @@ test("the Windows titlebar menu pastes through the desktop edit action", async (
   await expect(page.getByRole("status", { name: "Desktop menu actions" })).toHaveText("edit.paste")
 })
 
-// A submenu must survive the pointer taking the natural path to its last item: down the parent menu
-// first, then across. Moving down crosses the parent's other items, which closes the submenu before
-// the pointer reaches the last row.
+// A submenu must survive a normal-speed diagonal move from its trigger to the last item.
+// Kobalte lets a sibling open while the pointer crosses it; the settle guard keeps the active
+// submenu until the pointer actually stops on the sibling.
 test("the Windows titlebar menu keeps a submenu open while the pointer moves to its last item", async ({ page }) => {
   await mockWorkspace(page, { name: "WindowsMenuHover", sessions: [] })
   await page.goto(`/e2e/utils/windows-menu.html?${new URLSearchParams({ server: SERVER })}`)
@@ -1265,24 +1265,41 @@ test("the Windows titlebar menu keeps a submenu open while the pointer moves to
 
   if (!trigger || !last) throw new Error("Expected visible Edit trigger and Select All item")
 
-  const x = trigger.x + trigger.width / 2
-  const y = last.y + last.height / 2
+  const start = { x: trigger.x + trigger.width / 2, y: trigger.y + trigger.height / 2 }
+  const end = { x: last.x + last.width / 2, y: last.y + last.height / 2 }
+  const steps = 25
 
-  await page.mouse.move(x, trigger.y + trigger.height / 2)
-  await page.mouse.move(x, y, { steps: 10 })
-  await expect(edit).toHaveAttribute("aria-expanded", "true")
+  await page.mouse.move(start.x, start.y)
+
+  for (let step = 1; step <= steps; step++) {
+    const progress = step / steps
 
-  await page.mouse.move(last.x + last.width / 2, y, { steps: 10 })
+    await page.mouse.move(start.x + (end.x - start.x) * progress, start.y + (end.y - start.y) * progress)
+    // The issue reproduces at normal hand speed; this paces input, it is not a readiness wait.
+    await page.waitForTimeout(16)
+  }
+
+  await expect(edit).toHaveAttribute("aria-expanded", "true")
   await expect(selectAll).toBeVisible()
   await expect(selectAll).toHaveAttribute("data-highlighted", "")
 
+  // A deliberate hover on a sibling still switches the submenu.
+  const view = page.getByRole("menuitem", { name: "View", exact: true })
+  const viewBox = await view.boundingBox()
+
+  if (!viewBox) throw new Error("Expected visible View trigger")
+
+  await page.mouse.move(viewBox.x + viewBox.width / 2, viewBox.y + viewBox.height / 2)
+  await expect(view).toHaveAttribute("aria-expanded", "true")
+  await expect(edit).toHaveAttribute("aria-expanded", "false")
+
   // Leaving the menu still closes the submenu; the grace belongs to the traversal, not a pinned menu.
   const outside = await page.getByRole("main").boundingBox()
 
   if (!outside) throw new Error("Expected visible main content")
 
   await page.mouse.move(outside.x + outside.width / 2, outside.y + outside.height / 2)
-  await expect(edit).toHaveAttribute("aria-expanded", "false")
+  await expect(view).toHaveAttribute("aria-expanded", "false")
   await expect(selectAll).toBeHidden()
 })
 
 
@@ -23,6 +23,10 @@ import { useMenubarItems } from "@/runtime/plugin/menubar-items"
 // Keep the submenu through that crossing and close it only after the pointer leaves both menus.
 const SUBMENU_CLOSE_DELAY = 300
 
+// A sibling's open request is held while the pointer is crossing the parent menu toward the active
+// submenu. It is accepted after the pointer rests on the sibling.
+const SUBMENU_OPEN_SETTLE = 150
+
 const accelerators = DESKTOP_MENU.flatMap((menu) => menu.items ?? []).flatMap((entry) => {
   if (entry.type === "separator" || !entry.action || !entry.accelerator?.windows) return []
 
@@ -36,6 +40,60 @@ export function windowsMenuAccelerator(event: KeyboardEvent) {
   return accelerators.find((entry) => matchKeybind(entry.keybind, event))?.action
 }
 
+function pointInPolygon(x: number, y: number, polygon: readonly (readonly [number, number])[]) {
+  let inside = false
+
+  for (let index = 0, previous = polygon.length - 1; index < polygon.length; previous = index++) {
+    const [xi, yi] = polygon[index]!
+    const [xj, yj] = polygon[previous]!
+
+    if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi) inside = !inside
+  }
+
+  return inside
+}
+
+// The corridor between a trigger and its submenu content. It starts at the trigger's far edge so a
+// normal diagonal from the parent item into the last row stays inside it.
+function intentPolygon(trigger: DOMRect, content: DOMRect): [number, number][] {
+  const triggerX = trigger.left + trigger.width / 2
+  const triggerY = trigger.top + trigger.height / 2
+  const contentX = content.left + content.width / 2
+  const contentY = content.top + content.height / 2
+
+  if (Math.abs(contentX - triggerX) >= Math.abs(contentY - triggerY)) {
+    if (contentX >= triggerX)
+      return [
+        [trigger.left, trigger.top],
+        [trigger.left, trigger.bottom],
+        [content.left, content.bottom],
+        [content.left, content.top],
+      ]
+
+    return [
+      [trigger.right, trigger.top],
+      [trigger.right, trigger.bottom],
+      [content.right, content.bottom],
+      [content.right, content.top],
+    ]
+  }
+
+  if (contentY >= triggerY)
+    return [
+      [trigger.left, trigger.top],
+      [trigger.right, trigger.top],
+      [content.right, content.top],
+      [content.left, content.top],
+    ]
+
+  return [
+    [trigger.left, trigger.bottom],
+    [trigger.right, trigger.bottom],
+    [content.right, content.bottom],
+    [content.left, content.bottom],
+  ]
+}
+
 export function WindowsAppMenu(props: {
   command: ReturnType<typeof useCommand>
   platform: ReturnType<typeof usePlatform>
@@ -45,10 +103,15 @@ export function WindowsAppMenu(props: {
   const menubar = useMenubarItems()
   const [activeSubmenu, setActiveSubmenu] = createSignal<string>()
   const submenuContents = new Map<string, HTMLElement>()
+  const submenuTriggers = new Map<string, HTMLElement>()
   let menuContent: HTMLElement | undefined
   let pointer = { x: -1, y: -1 }
   let lastInput: "pointer" | "keyboard" = "pointer"
+  let lastPointerDownAt = Number.NEGATIVE_INFINITY
+  let pressedSubmenu: string | undefined
   let closeTimer: number | undefined
+  let pendingSubmenu: string | undefined
+  let openTimer: number | undefined
 
   const pointerInside = (element: HTMLElement | undefined) => {
     if (!element?.isConnected) return false
@@ -66,13 +129,46 @@ export function WindowsAppMenu(props: {
     return active !== undefined && pointerInside(submenuContents.get(active))
   }
 
+  const pointerInsideIntent = (id: string) => {
+    const trigger = submenuTriggers.get(id)
+    const content = submenuContents.get(id)
+
+    if (!trigger?.isConnected || !content?.isConnected) return false
+
+    const triggerRect = trigger.getBoundingClientRect()
+    const contentRect = content.getBoundingClientRect()
+
+    if (!triggerRect.width || !contentRect.width) return false
+
+    return pointInPolygon(pointer.x, pointer.y, intentPolygon(triggerRect, contentRect))
+  }
+
+  const cancelPendingOpen = () => {
+    if (openTimer !== undefined) window.clearTimeout(openTimer)
+    openTimer = undefined
+    pendingSubmenu = undefined
+  }
+
+  const schedulePendingOpen = () => {
+    if (openTimer !== undefined) window.clearTimeout(openTimer)
+    openTimer = window.setTimeout(() => {
+      openTimer = undefined
+
+      const pending = pendingSubmenu
+      pendingSubmenu = undefined
+
+      if (pending && pointerInside(submenuTriggers.get(pending))) openSubmenu(pending)
+    }, SUBMENU_OPEN_SETTLE)
+  }
+
   const cancelSubmenuClose = () => {
     if (closeTimer !== undefined) window.clearTimeout(closeTimer)
     closeTimer = undefined
   }
 
   const closeSubmenu = () => {
     cancelSubmenuClose()
+    cancelPendingOpen()
     setActiveSubmenu(undefined)
   }
 
@@ -87,10 +183,13 @@ export function WindowsAppMenu(props: {
 
   const openSubmenu = (id: string) => {
     cancelSubmenuClose()
+    cancelPendingOpen()
     setActiveSubmenu(id)
   }
 
   const requestSubmenuClose = (id: string) => {
+    if (pendingSubmenu === id) cancelPendingOpen()
+
     if (activeSubmenu() !== id) return
 
     if (lastInput === "keyboard") return closeSubmenu()
@@ -100,6 +199,24 @@ export function WindowsAppMenu(props: {
     scheduleSubmenuClose()
   }
 
+  const requestSubmenuOpen = (id: string) => {
+    if (activeSubmenu() === id) return
+
+    const active = activeSubmenu()
+
+    if (
+      active === undefined ||
+      lastInput === "keyboard" ||
+      (pressedSubmenu === id && performance.now() - lastPointerDownAt < 500)
+    )
+      return openSubmenu(id)
+
+    if (!pointerInsideIntent(active)) return openSubmenu(id)
+
+    pendingSubmenu = id
+    schedulePendingOpen()
+  }
+
   const entries = (menu: DesktopMenu) =>
     desktopMenuWithPlugins(
       (menu.items ?? [])
@@ -172,6 +289,15 @@ export function WindowsAppMenu(props: {
         pointer = { x: event.clientX, y: event.clientY }
         lastInput = "pointer"
 
+        if (pendingSubmenu !== undefined) {
+          const pending = pendingSubmenu
+          const active = activeSubmenu()
+
+          if (!pointerInside(submenuTriggers.get(pending))) cancelPendingOpen()
+          else if (active !== undefined && !pointerInsideIntent(active)) openSubmenu(pending)
+          else schedulePendingOpen()
+        }
+
         if (activeSubmenu() === undefined) return
 
         if (pointerInsideMenu()) return cancelSubmenuClose()
@@ -181,15 +307,46 @@ export function WindowsAppMenu(props: {
       { capture: true },
     )
 
-    makeEventListener(window, "pointerdown", () => (lastInput = "pointer"), { capture: true })
-    makeEventListener(window, "keydown", () => (lastInput = "keyboard"), { capture: true })
+    makeEventListener(
+      window,
+      "pointerdown",
+      (event) => {
+        const target = event.target
+
+        pointer = { x: event.clientX, y: event.clientY }
+        lastInput = "pointer"
+        lastPointerDownAt = performance.now()
+        pressedSubmenu =
+          target instanceof Node
+            ? Array.from(submenuTriggers).find(([, trigger]) => trigger.contains(target))?.[0]
+            : undefined
+
+        if (pendingSubmenu !== undefined && pointerInside(submenuTriggers.get(pendingSubmenu)))
+          openSubmenu(pendingSubmenu)
+      },
+      { capture: true },
+    )
+
+    makeEventListener(
+      window,
+      "keydown",
+      () => {
+        lastInput = "keyboard"
+        cancelPendingOpen()
+      },
+      { capture: true },
+    )
 
     // The pointer left the window; no further move can keep the submenu open.
     makeEventListener(
       window,
       "pointerout",
       (event) => {
-        if (event.relatedTarget === null && activeSubmenu() !== undefined) scheduleSubmenuClose()
+        if (event.relatedTarget !== null) return
+
+        cancelPendingOpen()
+
+        if (activeSubmenu() !== undefined) scheduleSubmenuClose()
       },
       { capture: true },
     )
@@ -228,11 +385,15 @@ export function WindowsAppMenu(props: {
                 <DesktopMenuSubmenu
                   label={language.t(menu.labelKey)}
                   open={activeSubmenu() === menu.id}
-                  onOpenChange={(open) => (open ? openSubmenu(menu.id) : requestSubmenuClose(menu.id))}
+                  onOpenChange={(open) => (open ? requestSubmenuOpen(menu.id) : requestSubmenuClose(menu.id))}
                   onContent={(element) => {
                     if (element) submenuContents.set(menu.id, element)
                     else submenuContents.delete(menu.id)
                   }}
+                  onTrigger={(element) => {
+                    if (element) submenuTriggers.set(menu.id, element)
+                    else submenuTriggers.delete(menu.id)
+                  }}
                 >
                   <For each={entries(menu)}>
                     {(item) => {
@@ -284,11 +445,12 @@ function DesktopMenuSubmenu(props: {
   open: boolean
   onOpenChange: (open: boolean) => void
   onContent: (element: HTMLElement | undefined) => void
+  onTrigger: (element: HTMLElement | undefined) => void
   children: JSX.Element
 }) {
   return (
     <Menu.Sub open={props.open} onOpenChange={props.onOpenChange}>
-      <Menu.SubTrigger>{props.label}</Menu.SubTrigger>
+      <Menu.SubTrigger ref={(element: HTMLElement) => props.onTrigger(element)}>{props.label}</Menu.SubTrigger>
       <Menu.Portal>
         <Menu.SubContent
           ref={(element: HTMLElement) => props.onContent(element)}