diff --git a/modules/javafx.base/src/main/java/com/sun/javafx/event/EventUtil.java b/modules/javafx.base/src/main/java/com/sun/javafx/event/EventUtil.java
index 10f9fa05a2b..f0c02172a37 100644
--- a/modules/javafx.base/src/main/java/com/sun/javafx/event/EventUtil.java
+++ b/modules/javafx.base/src/main/java/com/sun/javafx/event/EventUtil.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -39,19 +39,34 @@ public final class EventUtil {
             new AtomicBoolean();
 
     public static Event fireEvent(EventTarget eventTarget, Event event) {
+        return fireEvent(eventTarget, null, event);
+    }
+
+    /**
+     * Dispatches an event to the specified {@code eventTarget}, optionally extending the event
+     * dispatch chain up to the {@code delegateTarget}. The delegate target must be a descendant
+     * of the {@code eventTarget}.
+     *
+     * @param eventTarget    the event target, not {@code null}
+     * @param delegateTarget the delegate event target, may be {@code null}
+     * @param event          the event
+     * @return the event after processing, or {@code null}
+     */
+    public static Event fireEvent(EventTarget eventTarget, EventTarget delegateTarget, Event event) {
         if (event.getTarget() != eventTarget) {
             event = event.copyFor(event.getSource(), eventTarget);
         }
 
+        EventTarget actualTarget = delegateTarget != null ? delegateTarget : eventTarget;
+
         if (eventDispatchChainInUse.getAndSet(true)) {
             // the member event dispatch chain is in use currently, we need to
             // create a new instance for this call
-            return fireEventImpl(new EventDispatchChainImpl(),
-                                 eventTarget, event);
+            return fireEventImpl(new EventDispatchChainImpl(), actualTarget, event);
         }
 
         try {
-            return fireEventImpl(eventDispatchChain, eventTarget, event);
+            return fireEventImpl(eventDispatchChain, actualTarget, event);
         } finally {
             // need to do reset after use to remove references to event
             // dispatchers from the chain
diff --git a/modules/javafx.controls/src/main/java/com/sun/javafx/scene/control/behavior/SpinnerBehavior.java b/modules/javafx.controls/src/main/java/com/sun/javafx/scene/control/behavior/SpinnerBehavior.java
index fed927a8af2..9c8670bd623 100644
--- a/modules/javafx.controls/src/main/java/com/sun/javafx/scene/control/behavior/SpinnerBehavior.java
+++ b/modules/javafx.controls/src/main/java/com/sun/javafx/scene/control/behavior/SpinnerBehavior.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -31,14 +31,11 @@
 import javafx.scene.control.Spinner;
 import javafx.scene.control.SpinnerValueFactory;
 import com.sun.javafx.scene.control.inputmap.InputMap;
+import javafx.scene.input.KeyCode;
 import javafx.scene.input.KeyEvent;
 import javafx.util.Duration;
-
 import java.util.List;
 
-import static javafx.scene.input.KeyCode.*;
-import static com.sun.javafx.scene.control.inputmap.InputMap.KeyMapping;
-
 public class SpinnerBehavior<T> extends BehaviorBase<Spinner<T>> {
 
     // this specifies how long the mouse has to be pressed on a button
@@ -69,7 +66,20 @@ public class SpinnerBehavior<T> extends BehaviorBase<Spinner<T>> {
         }
     };
 
+    private final EventHandler<KeyEvent> spinnerKeyHandler = e -> {
+        boolean arrowsAreVertical = arrowsAreVertical();
+        KeyCode increment = arrowsAreVertical ? KeyCode.UP : KeyCode.RIGHT;
+        KeyCode decrement = arrowsAreVertical ? KeyCode.DOWN : KeyCode.LEFT;
 
+        if (e.getCode() == increment) {
+            increment(1);
+            e.consume();
+        }
+        else if (e.getCode() == decrement) {
+            decrement(1);
+            e.consume();
+        }
+    };
 
     /***************************************************************************
      *                                                                         *
@@ -84,24 +94,14 @@ public SpinnerBehavior(Spinner<T> spinner) {
         // InputMap installed on the control, if it is non-null, allowing us to pick up any user-specified mappings)
         spinnerInputMap = createInputMap();
 
-        // then spinner-specific mappings for key and mouse input
-        addDefaultMapping(spinnerInputMap,
-            new KeyMapping(UP, KeyEvent.KEY_PRESSED, e -> {
-                if (arrowsAreVertical()) increment(1); else FocusTraversalInputMap.traverseUp(e);
-            }),
-            new KeyMapping(RIGHT, KeyEvent.KEY_PRESSED, e -> {
-                if (! arrowsAreVertical()) increment(1); else FocusTraversalInputMap.traverseRight(e);
-            }),
-            new KeyMapping(LEFT, KeyEvent.KEY_PRESSED, e -> {
-                if (! arrowsAreVertical()) decrement(1); else FocusTraversalInputMap.traverseLeft(e);
-            }),
-            new KeyMapping(DOWN, KeyEvent.KEY_PRESSED, e -> {
-                if (arrowsAreVertical()) decrement(1); else FocusTraversalInputMap.traverseDown(e);
-            })
-        );
+        spinner.addEventFilter(KeyEvent.KEY_PRESSED, spinnerKeyHandler);
     }
 
-
+    @Override
+    public void dispose() {
+        getNode().removeEventFilter(KeyEvent.KEY_PRESSED, spinnerKeyHandler);
+        super.dispose();
+    }
 
     /***************************************************************************
      *                                                                         *
diff --git a/modules/javafx.controls/src/main/java/javafx/scene/control/Control.java b/modules/javafx.controls/src/main/java/javafx/scene/control/Control.java
index 1c0b796b63d..c71a36cc13d 100644
--- a/modules/javafx.controls/src/main/java/javafx/scene/control/Control.java
+++ b/modules/javafx.controls/src/main/java/javafx/scene/control/Control.java
@@ -595,6 +595,11 @@ protected Control() {
         }
     }
 
+    @Override
+    protected boolean isFocusScope() {
+        return true;
+    }
+
     /* *************************************************************************
      * Implementation of layout bounds for the Control. We want to preserve    *
      * the lazy semantics of layout bounds. So whenever the width/height       *
@@ -634,6 +639,15 @@ protected Skin<?> createDefaultSkin() {
         return null;
     }
 
+    @Override
+    protected Node getFocusDelegate(Node hoistingNode) {
+        if (skinBase != null) {
+            return skinBase.getFocusDelegate(hoistingNode);
+        }
+
+        return null;
+    }
+
     /* *************************************************************************
      *                                                                         *
      * Package API for SkinBase                                                *
diff --git a/modules/javafx.controls/src/main/java/javafx/scene/control/SkinBase.java b/modules/javafx.controls/src/main/java/javafx/scene/control/SkinBase.java
index cd21a42cd70..0be430c842e 100644
--- a/modules/javafx.controls/src/main/java/javafx/scene/control/SkinBase.java
+++ b/modules/javafx.controls/src/main/java/javafx/scene/control/SkinBase.java
@@ -43,6 +43,7 @@
 import javafx.scene.AccessibleAction;
 import javafx.scene.AccessibleAttribute;
 import javafx.scene.Node;
+import javafx.scene.Parent;
 import javafx.scene.input.MouseEvent;
 import javafx.scene.layout.Region;
 
@@ -190,6 +191,18 @@ public final ObservableList<Node> getChildren() {
         return children;
     }
 
+    /**
+     * Overriding this method allows skins to specify the {@link Parent#getFocusDelegate(Node)}.
+     *
+     * @param hoistingNode the descendant of this skin that hoisted the focus request
+     *                     (not necessarily the focus delegate), or {@code null}
+     * @return the focus delegate
+     * @since 24
+     */
+    protected Node getFocusDelegate(Node hoistingNode) {
+        return null;
+    }
+
     /**
      * Called during the layout pass of the scenegraph.
      * @param contentX the x position
diff --git a/modules/javafx.controls/src/main/java/javafx/scene/control/Spinner.java b/modules/javafx.controls/src/main/java/javafx/scene/control/Spinner.java
index bc2a42a95cc..95a32da52bc 100644
--- a/modules/javafx.controls/src/main/java/javafx/scene/control/Spinner.java
+++ b/modules/javafx.controls/src/main/java/javafx/scene/control/Spinner.java
@@ -24,7 +24,6 @@
  */
 package javafx.scene.control;
 
-import com.sun.javafx.scene.control.FakeFocusTextField;
 import javafx.beans.property.StringProperty;
 import javafx.scene.control.skin.SpinnerSkin;
 import javafx.beans.NamedArg;
@@ -37,7 +36,6 @@
 import javafx.beans.value.ChangeListener;
 import javafx.beans.value.ObservableValue;
 import javafx.beans.value.WritableValue;
-import javafx.collections.MapChangeListener;
 import javafx.collections.ObservableList;
 import javafx.scene.AccessibleAction;
 import javafx.scene.AccessibleAttribute;
@@ -153,17 +151,6 @@ public Spinner() {
 
         value.addListener((o, oldValue, newValue) -> setText(newValue));
 
-        // Fix for JDK-8115009
-        getProperties().addListener((MapChangeListener<Object, Object>) change -> {
-            if (change.wasAdded()) {
-                if (change.getKey() == "FOCUSED") {
-                    setFocused((Boolean)change.getValueAdded());
-                    getProperties().remove("FOCUSED");
-                }
-            }
-        });
-        // End of fix for JDK-8115009
-
         focusedProperty().addListener(o -> {
             if (!isFocused()) {
                 try {
@@ -610,7 +597,7 @@ public final BooleanProperty editableProperty() {
     public final ReadOnlyObjectProperty<TextField> editorProperty() {
         if (editor == null) {
             editor = new ReadOnlyObjectWrapper<>(this, "editor");
-            textField = new FakeFocusTextField();
+            textField = new TextField();
             textField.tooltipProperty().bind(tooltipProperty());
             editor.set(textField);
         }
diff --git a/modules/javafx.controls/src/main/java/javafx/scene/control/skin/SpinnerSkin.java b/modules/javafx.controls/src/main/java/javafx/scene/control/skin/SpinnerSkin.java
index 57ec53793aa..602122dbcf5 100644
--- a/modules/javafx.controls/src/main/java/javafx/scene/control/skin/SpinnerSkin.java
+++ b/modules/javafx.controls/src/main/java/javafx/scene/control/skin/SpinnerSkin.java
@@ -42,7 +42,6 @@
 import javafx.scene.layout.StackPane;
 
 import com.sun.javafx.scene.ParentHelper;
-import com.sun.javafx.scene.control.FakeFocusTextField;
 import com.sun.javafx.scene.control.ListenerHelper;
 import com.sun.javafx.scene.control.behavior.SpinnerBehavior;
 import com.sun.javafx.scene.traversal.Algorithm;
@@ -106,6 +105,7 @@ public SpinnerSkin(Spinner<T> control) {
         behavior = new SpinnerBehavior<>(control);
 
         textField = control.getEditor();
+        textField.setHoistFocus(true);
 
         ListenerHelper lh = ListenerHelper.get(this);
 
@@ -116,6 +116,7 @@ public SpinnerSkin(Spinner<T> control) {
 
         // increment / decrement arrows
         incrementArrow = new Region();
+        incrementArrow.setHoistFocus(true);
         incrementArrow.setFocusTraversable(false);
         incrementArrow.getStyleClass().setAll("increment-arrow");
         incrementArrow.setMaxWidth(Region.USE_PREF_SIZE);
@@ -132,6 +133,7 @@ public void executeAccessibleAction(AccessibleAction action, Object... parameter
             }
         };
         incrementArrowButton.setAccessibleRole(AccessibleRole.INCREMENT_BUTTON);
+        incrementArrowButton.setHoistFocus(true);
         incrementArrowButton.setFocusTraversable(false);
         incrementArrowButton.getStyleClass().setAll("increment-arrow-button");
         incrementArrowButton.getChildren().add(incrementArrow);
@@ -142,6 +144,7 @@ public void executeAccessibleAction(AccessibleAction action, Object... parameter
         incrementArrowButton.setOnMouseReleased(e -> behavior.stopSpinning());
 
         decrementArrow = new Region();
+        decrementArrow.setHoistFocus(true);
         decrementArrow.setFocusTraversable(false);
         decrementArrow.getStyleClass().setAll("decrement-arrow");
         decrementArrow.setMaxWidth(Region.USE_PREF_SIZE);
@@ -158,6 +161,7 @@ public void executeAccessibleAction(AccessibleAction action, Object... parameter
             }
         };
         decrementArrowButton.setAccessibleRole(AccessibleRole.DECREMENT_BUTTON);
+        decrementArrowButton.setHoistFocus(true);
         decrementArrowButton.setFocusTraversable(false);
         decrementArrowButton.getStyleClass().setAll("decrement-arrow-button");
         decrementArrowButton.getChildren().add(decrementArrow);
@@ -169,56 +173,8 @@ public void executeAccessibleAction(AccessibleAction action, Object... parameter
 
         getChildren().addAll(incrementArrowButton, decrementArrowButton);
 
-        // Fixes in the same vein as ComboBoxListViewSkin
-
-        // move fake focus in to the textfield if the spinner is editable
-        lh.addChangeListener(control.focusedProperty(), (op) -> {
-            // Fix for the regression noted in a comment in JDK-8115009.
-            ((FakeFocusTextField)textField).setFakeFocus(control.isFocused());
-        });
-
-        lh.addEventFilter(control, KeyEvent.ANY, (ke) -> {
-            if (control.isEditable()) {
-                // This prevents a stack overflow from our rebroadcasting of the
-                // event to the textfield that occurs in the final else statement
-                // of the conditions below.
-                if (ke.getTarget().equals(textField)) return;
-
-                // Fix for JDK-8095537 which led to a stack overflow
-                if (ke.getCode() == KeyCode.ESCAPE) return;
-
-                // This and the additional check of isIncDecKeyEvent in
-                // textField's event filter fix JDK-8185937.
-                if (isIncDecKeyEvent(ke)) return;
-
-                // Fix for the regression noted in a comment in JDK-8115009.
-                // This forwards the event down into the TextField when
-                // the key event is actually received by the Spinner.
-                textField.fireEvent(ke.copyFor(textField, textField));
-
-                if (ke.getCode() == KeyCode.ENTER) return;
-
-                ke.consume();
-            }
-        });
-
-        // This event filter is to enable keyboard events being delivered to the
-        // spinner when the user has mouse clicked into the TextField area of the
-        // Spinner control. Without this the up/down/left/right arrow keys don't
-        // work when you click inside the TextField area (but they do in the case
-        // of tabbing in).
-        lh.addEventFilter(textField, KeyEvent.ANY, (ke) -> {
-            if (! control.isEditable() || isIncDecKeyEvent(ke)) {
-                control.fireEvent(ke.copyFor(control, control));
-                ke.consume();
-            }
-        });
-
         lh.addChangeListener(textField.focusedProperty(), (op) -> {
             boolean hasFocus = textField.isFocused();
-            // Fix for JDK-8115009
-            control.getProperties().put("FOCUSED", hasFocus);
-            // --- end of JDK-8115009
 
             // JDK-8120120 starts here
             if (! hasFocus) {
@@ -229,8 +185,6 @@ public void executeAccessibleAction(AccessibleAction action, Object... parameter
             // --- end of JDK-8120120
         });
 
-        // end of comboBox-esque fixes
-
         textField.focusTraversableProperty().bind(control.editableProperty());
 
         // Following code borrowed from ComboBoxPopupControl, to resolve the
@@ -292,6 +246,11 @@ public void dispose() {
         super.dispose();
     }
 
+    @Override
+    protected Node getFocusDelegate(Node hoistingNode) {
+        return textField;
+    }
+
     /** {@inheritDoc} */
     @Override protected void layoutChildren(final double x, final double y,
                                             final double w, final double h) {
diff --git a/modules/javafx.graphics/src/main/java/javafx/scene/Node.java b/modules/javafx.graphics/src/main/java/javafx/scene/Node.java
index 57dcc6835bf..8811373803c 100644
--- a/modules/javafx.graphics/src/main/java/javafx/scene/Node.java
+++ b/modules/javafx.graphics/src/main/java/javafx/scene/Node.java
@@ -107,6 +107,7 @@
 import javafx.stage.Window;
 import javafx.util.Callback;
 
+import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -634,7 +635,7 @@ public Map<StyleableProperty<?>, List<Style>> findStyles(Node node,
 
             @Override
             public void requestFocusVisible(Node node) {
-                node.requestFocusVisible();
+                node.requestFocus(null, true);
             }
 
             @Override
@@ -8248,6 +8249,11 @@ protected boolean notifyListeners() {
     final void setFocusQuietly(boolean focused, boolean focusVisible) {
         this.focused.set(focused);
         this.focusVisible.set(focused && focusVisible);
+
+        Node delegate = getFocusDelegate(this.focused.getHoistingNode());
+        if (delegate != null) {
+            delegate.setFocusQuietly(focused, focusVisible);
+        }
     }
 
     /**
@@ -8256,6 +8262,11 @@ final void setFocusQuietly(boolean focused, boolean focusVisible) {
      * are fired on the current node and on all of its parents, if necessary.
      */
     final void notifyFocusListeners() {
+        Node delegate = getFocusDelegate(focused.getHoistingNode());
+        if (delegate != null) {
+            delegate.notifyFocusListeners();
+        }
+
         focused.notifyListeners();
         focusVisible.notifyListeners();
 
@@ -8310,7 +8321,11 @@ private void updateParentsFocusWithin(Node oldParent, Node newParent) {
      * @see #requestFocus()
      * @defaultValue false
      */
-    private final FocusPropertyBase focused = new FocusPropertyBase() {
+    private final FocusedProperty focused = new FocusedProperty();
+
+    private final class FocusedProperty extends FocusPropertyBase {
+        private WeakReference<Node> hoistingNode;
+
         @Override
         protected PseudoClass getPseudoClass() {
             return FOCUSED_PSEUDOCLASS_STATE;
@@ -8333,6 +8348,10 @@ protected boolean notifyListeners() {
         @Override
         public void set(boolean value) {
             if (get() != value) {
+                if (!value) {
+                    hoistingNode = null;
+                }
+
                 super.set(value);
 
                 int change = value ? 1 : -1;
@@ -8344,6 +8363,39 @@ public void set(boolean value) {
                 } while (node != null);
             }
         }
+
+        private void setHoistingNode(Node hoistingNode) {
+            this.hoistingNode = new WeakReference<>(hoistingNode);
+        }
+
+        /**
+         * Resolves the hoisting node of this focused node, which is always a descendant of this node.
+         * <p>
+         * Note that the hoisting node is tracked as a snapshot in time, which means that when we are trying
+         * to resolve it, it might already have been removed from the scene graph, or moved to a different
+         * place so that is is no longer a descendant of this node.
+         *
+         * @return the hoisting node, or {@code null} if no hoisting node is tracked or if the tracked
+         *         node is not a descendant of this node
+         */
+        private Node getHoistingNode() {
+            Node hoistingNode = this.hoistingNode != null ? this.hoistingNode.get() : null;
+            if (hoistingNode == null) {
+                return null;
+            }
+
+            Node parent = hoistingNode.getParent();
+            while (parent != null) {
+                if (parent == Node.this) {
+                    return hoistingNode;
+                }
+
+                parent = parent.getParent();
+            }
+
+            this.hoistingNode = null;
+            return null;
+        }
     };
 
     protected final void setFocused(boolean value) {
@@ -8486,6 +8538,117 @@ public String getName() {
         return focusTraversable;
     }
 
+    /**
+     * Specifies whether this {@code Node} should hoist focus requests to its closest focus scope.
+     * When this property is set to {@code true}, calling the {@link #requestFocus()} method has no
+     * effect on this node, but is equivalent to requesting focus for the closest ancestor for which
+     * {@link #isFocusScope()} is {@code true}.
+     *
+     * @since 24
+     */
+    private BooleanProperty hoistFocus;
+
+    public final boolean isHoistFocus() {
+        return hoistFocus == null ? false : hoistFocus.get();
+    }
+
+    public final void setHoistFocus(boolean value) {
+        if (value || hoistFocus != null) {
+            hoistFocusProperty().set(value);
+        }
+    }
+
+    public final BooleanProperty hoistFocusProperty() {
+        if (hoistFocus == null) {
+            hoistFocus = new BooleanPropertyBase() {
+                @Override
+                public Object getBean() {
+                    return Node.this;
+                }
+
+                @Override
+                public String getName() {
+                    return "hoistFocus";
+                }
+            };
+        }
+
+        return hoistFocus;
+    }
+
+    /**
+     * Indicates whether this {@code Node} is eligible to receive focus when a child node {@link #hoistFocus hoists}
+     * a focus request. A node that receives a focus hoisting request may decide to hoist the request even further
+     * up the scene graph.
+     * <p>
+     * Focus scoping is a technique employed by controls that need to isolate their internal structure (which may
+     * be defined by a skin) from their external representation. Consider a control with an internal structure
+     * that contains an interactive and independently focusable control. When a user clicks on the internal
+     * interactive control, it is often desired that the external representation receive the input focus, so
+     * that users of the control can reason about it as a monolith instead of a composite with unknown parts.
+     * <p>
+     * Focus scoping is often combined with {@link #getFocusDelegate() focus delegation}.
+     *
+     * @return {@code true} if this {@code Node} is eligible to receive hoisted focus requests;
+     *         {@code false} otherwise
+     * @since 24
+     */
+    boolean isFocusScope() {
+        return false;
+    }
+
+    /**
+     * Gets the focus delegate for this {@code Node}, which must be a descendant of this {@code Node}.
+     * <p>
+     * Focus delegation allows nodes to delegate events targeted at them to one of their descendants. This is
+     * a technique employed by controls that need to isolate their internal structure (which may be defined by
+     * a skin) from their external representation. The external representation delegates the input focus to an
+     * internal control by returning the internal control from the {@link #getFocusDelegate()} method. In this
+     * case, when the external control receives the input focus, the internal control is focused as well. When
+     * an input event is sent to the focused control, the external control receives the event first. If the
+     * event is not consumed, it is dispatched to the focus delegate. A focus delegate might delegate the input
+     * focus even further, forming a chain of focus delegates.
+     * <p>
+     * If an implementation returns a node from this method that is not a descendant of this {@code Node},
+     * JavaFX ignores the returned value and treats this {@code Node} as having no focus delegate.
+     * <p>
+     * Focus delegation is often combined with {@link #isFocusScope() focus scoping}.
+     *
+     * @param hoistingNode the descendant of this {@code Node} that hoisted the focus request
+     *                     (not necessarily the focus delegate), or {@code null}
+     * @return the focus delegate, which is a descendant of this {@code Node}
+     * @since 24
+     */
+    Node getFocusDelegate(Node hoistingNode) {
+        return null;
+    }
+
+    /**
+     * Resolves a chain of focus delegates.
+     * This method also verifies that a focus delegate is a descendant of this node.
+     *
+     * @return the final focus delegate, or {@code null} if this node has no focus delegate,
+     *         or if the focus delegate is not a descendant of this node
+     */
+    final Node resolveFocusDelegate() {
+        Node delegate = getFocusDelegate(focused.getHoistingNode());
+        if (delegate == null) {
+            return null;
+        }
+
+        Node parent = delegate.getParent();
+        while (parent != this && parent != null) {
+            parent = parent.getParent();
+        }
+
+        if (parent == null) {
+            return null;
+        }
+
+        Node nextDelegate = delegate.resolveFocusDelegate();
+        return nextDelegate != null ? nextDelegate : delegate;
+    }
+
     /**
      * Called when something has changed on this node that *may* have made the
      * scene's focus dirty. This covers the cases where this node is the focus
@@ -8516,19 +8679,27 @@ private void focusSetDirty(Scene s) {
      * <p>This method will clear the {@link #focusVisible} flag.
      */
     public void requestFocus() {
-        if (getScene() != null) {
-            getScene().requestFocus(this, false);
-        }
+        requestFocus(null, false);
     }
 
-    /**
-     * Requests focus as if by calling {@link #requestFocus()}, and additionally
-     * sets the {@link #focusVisible} flag.
-     */
-    private void requestFocusVisible() {
-        if (getScene() != null) {
-            getScene().requestFocus(this, true);
+    private void requestFocus(Node hoistingNode, boolean focusVisible) {
+        var scene = getScene();
+        if (scene == null) {
+            return;
         }
+
+        focused.setHoistingNode(hoistingNode);
+
+        if (isHoistFocus()) {
+            for (Node node = getParent(); node != null; node = node.getParent()) {
+                if (node.isFocusScope()) {
+                    node.requestFocus(this, focusVisible);
+                    return;
+                }
+            }
+        }
+
+        scene.requestFocus(this, focusVisible);
     }
 
     /**
@@ -8946,18 +9117,25 @@ public EventDispatchChain buildEventDispatchChain(
         tail = tail.prepend(preprocessMouseEventDispatcher);
 
         // prepend all event dispatchers from this node to the root
-        Node curNode = this;
-        do {
-            if (curNode.eventDispatcher != null) {
-                final EventDispatcher eventDispatcherValue =
-                        curNode.eventDispatcher.get();
-                if (eventDispatcherValue != null) {
-                    tail = tail.prepend(eventDispatcherValue);
+        for (Node curNode = this, curParent = getParent();
+             curNode != null;
+             curNode = curParent != null ? curParent : curNode.getSubScene(),
+             curParent = curNode != null ? curNode.getParent() : null) {
+
+            // If our parent has a focus delegate, we need to use a special dispatcher that can retarget
+            // the event to the focus delegate (even if this node doesn't have an event dispatcher itself).
+            if (curParent != null && curParent.getFocusDelegate(focused.getHoistingNode()) != null) {
+                tail = tail.prepend(curNode::dispatchRetargetedEvent);
+            } else {
+                EventDispatcher dispatcher = curNode.eventDispatcher != null
+                    ? curNode.eventDispatcher.get()
+                    : null;
+
+                if (dispatcher != null) {
+                    tail = tail.prepend(dispatcher);
                 }
             }
-            final Node curParent = curNode.getParent();
-            curNode = curParent != null ? curParent : curNode.getSubScene();
-        } while (curNode != null);
+        }
 
         if (getScene() != null) {
             // prepend scene's dispatch chain
@@ -8967,6 +9145,36 @@ public EventDispatchChain buildEventDispatchChain(
         return tail;
     }
 
+    private Event dispatchRetargetedEvent(Event event, EventDispatchChain tail) {
+        Node parent = getParent();
+        boolean retarget = false;
+
+        // Focus delegation is the only scenario in which the event target may be the parent node.
+        // Since we are in the capturing phase, we need to retarget the event to the focus delegate.
+        if (event.getTarget() == parent) {
+            retarget = true;
+            event = event.copyFor(event.getSource(), parent.getFocusDelegate(focused.getHoistingNode()));
+        }
+
+        // Dispatch the event to our event dispatcher, or if this node doesn't have one,
+        // directly to the rest of the event dispatch chain.
+        EventDispatcher dispatcher = eventDispatcher != null ? eventDispatcher.get() : null;
+        if (dispatcher != null) {
+            event = dispatcher.dispatchEvent(event, tail);
+        } else {
+            event = tail.dispatchEvent(event);
+        }
+
+        // The event was consumed, nothing left to do.
+        if (event == null) {
+            return null;
+        }
+
+        // Now we are in the bubbling phase. If we retargeted the capturing event earlier,
+        // we now need to retarget the bubbling event back to its original target.
+        return retarget ? event.copyFor(event.getSource(), parent) : event;
+    }
+
     // PENDING_DOC_REVIEW
     /**
      * Fires the specified event. By default the event will travel through the
diff --git a/modules/javafx.graphics/src/main/java/javafx/scene/Parent.java b/modules/javafx.graphics/src/main/java/javafx/scene/Parent.java
index 725af3a6cde..081a70bd60c 100644
--- a/modules/javafx.graphics/src/main/java/javafx/scene/Parent.java
+++ b/modules/javafx.graphics/src/main/java/javafx/scene/Parent.java
@@ -1499,6 +1499,16 @@ void nodeResolvedOrientationChanged() {
         }
     }
 
+    @Override
+    protected boolean isFocusScope() { // Overridden to make the method protected
+        return false;
+    }
+
+    @Override
+    protected Node getFocusDelegate(Node hoistingNode) { // Overridden to make the method protected
+        return null;
+    }
+
     /* *************************************************************************
      *                                                                         *
      *                         Bounds Computations                             *
diff --git a/modules/javafx.graphics/src/main/java/javafx/scene/Scene.java b/modules/javafx.graphics/src/main/java/javafx/scene/Scene.java
index bf939193c21..f8c35386cf8 100644
--- a/modules/javafx.graphics/src/main/java/javafx/scene/Scene.java
+++ b/modules/javafx.graphics/src/main/java/javafx/scene/Scene.java
@@ -1944,8 +1944,11 @@ private void processMenuEvent(double x2, double y2, double xAbs, double yAbs, bo
             final double xOffset = xAbs - x2;
             final double yOffset = yAbs - y2;
             if (sceneFocusOwner != null) {
-                final Bounds bounds = sceneFocusOwner.localToScene(
-                        sceneFocusOwner.getBoundsInLocal());
+                Node delegate = sceneFocusOwner.resolveFocusDelegate();
+                Bounds bounds = delegate != null
+                        ? delegate.localToScene(delegate.getBoundsInLocal())
+                        : sceneFocusOwner.localToScene(sceneFocusOwner.getBoundsInLocal());
+
                 x2 = bounds.getMinX() + bounds.getWidth() / 4;
                 y2 = bounds.getMinY() + bounds.getHeight() / 2;
                 eventTarget = sceneFocusOwner;
@@ -1969,9 +1972,10 @@ private void processMenuEvent(double x2, double y2, double xAbs, double yAbs, bo
         }
 
         if (eventTarget != null) {
+            Node delegate = eventTarget instanceof Node node ? node.resolveFocusDelegate() : null;
             ContextMenuEvent context = new ContextMenuEvent(ContextMenuEvent.CONTEXT_MENU_REQUESTED,
                     x2, y2, xAbs, yAbs, isKeyboardTrigger, res);
-            Event.fireEvent(eventTarget, context);
+            EventUtil.fireEvent(eventTarget, delegate, context);
         }
         Scene.inMousePick = false;
     }
@@ -2237,7 +2241,8 @@ boolean processKeyEvent(KeyEvent e) {
 
         // send the key event to the current focus owner or to scene if
         // the focus owner is not set
-        return EventUtil.fireEvent(eventTarget, e) == null;
+        Node delegate = eventTarget instanceof Node node ? node.resolveFocusDelegate() : null;
+        return EventUtil.fireEvent(eventTarget, delegate, e) == null;
     }
 
     void requestFocus(Node node, boolean focusVisible) {
@@ -2270,8 +2275,9 @@ InputMethodStateManager getInputMethodStateManager() {
       */
     private FocusOwnerProperty focusOwner = new FocusOwnerProperty();
 
-    private class FocusOwnerProperty extends ReadOnlyObjectWrapper<Node> {
-        Node oldFocusOwner;
+    private final class FocusOwnerProperty extends ReadOnlyObjectPropertyBase<Node> {
+        private Node currentValue;
+        private int scope = 0;
 
         /**
          * Stores whether the current focus owner visibly indicates focus.
@@ -2291,50 +2297,61 @@ public String getName() {
         }
 
         @Override
-        protected void invalidated() {
-            if (oldFocusOwner != null) {
-                oldFocusOwner.setFocusQuietly(false, false);
-            }
-            Node value = get();
-            if (value != null) {
-                value.setFocusQuietly(windowFocused, focusVisible);
-                if (value != oldFocusOwner) {
-                    InputMethodStateManager manager = value.getScene().getInputMethodStateManager();
+        public Node get() {
+            return currentValue;
+        }
+
+        public void set(Node newValue) {
+            if (currentValue != null && currentValue != newValue) {
+                currentValue.setFocusQuietly(false, false);
+            }
+
+            if (newValue != null) {
+                newValue.setFocusQuietly(windowFocused, focusVisible);
+
+                if (currentValue != newValue) {
+                    InputMethodStateManager manager = newValue.getScene().getInputMethodStateManager();
                     if (manager != null) {
-                        manager.focusOwnerChanged(oldFocusOwner, value);
+                        manager.focusOwnerChanged(currentValue, newValue);
                     }
                 }
             }
-            // for the rest of the method we need to update the oldFocusOwner
+
+            // for the rest of the method we need to update the currentValue
             // and use a local copy of it because the user handlers can cause
             // recurrent calls of requestFocus
-            Node localOldOwner = oldFocusOwner;
-            oldFocusOwner = value;
-            if (localOldOwner != null) {
-                localOldOwner.notifyFocusListeners();
-            }
-            if (value != null) {
-                value.notifyFocusListeners();
-            }
-            PlatformLogger logger = Logging.getFocusLogger();
-            if (logger.isLoggable(Level.FINE)) {
-                if (value == get()) {
-                    logger.fine("Changed focus from "
-                            + localOldOwner + " to " + value);
-                } else {
-                    logger.fine("Changing focus from "
-                            + localOldOwner + " to " + value
-                            + " canceled by nested requestFocus");
+            Node oldValue = currentValue;
+            currentValue = newValue;
+
+            try {
+                scope++;
+
+                if (oldValue != null) {
+                    oldValue.notifyFocusListeners();
+                }
+
+                if (newValue != null) {
+                    newValue.notifyFocusListeners();
+                }
+            } finally {
+                if (--scope == 0 && currentValue != oldValue) {
+                    if (accessible != null) {
+                        accessible.sendNotification(AccessibleAttribute.FOCUS_NODE);
+                    }
+
+                    PlatformLogger logger = Logging.getFocusLogger();
+                    if (logger.isLoggable(Level.FINE)) {
+                        logger.fine("Changed focus from " + oldValue + " to " + currentValue);
+                    }
+
+                    fireValueChangedEvent();
                 }
-            }
-            if (accessible != null) {
-                accessible.sendNotification(AccessibleAttribute.FOCUS_NODE);
             }
         }
     };
 
     public final ReadOnlyObjectProperty<Node> focusOwnerProperty() {
-        return focusOwner.getReadOnlyProperty();
+        return focusOwner;
     }
 
     public final Node getFocusOwner() {
@@ -2345,25 +2362,14 @@ private void setFocusOwner(Node node, boolean focusVisible) {
         // Cancel IM composition if there is one in progress.
         // This needs to be done before the focus owner is switched as it
         // generates event that needs to be delivered to the old focus owner.
-        if (focusOwner.oldFocusOwner != null) {
+        if (focusOwner.currentValue != null) {
             getInputMethodStateManager().focusOwnerWillChangeForScene(this);
         }
 
         // Store the current focusVisible state of the focus owner in case it needs to be
         // restored when a window loses and re-gains focus.
         focusOwner.focusVisible = focusVisible;
-
-        if (focusOwner.get() != node) {
-            // If the focus owner has changed, FocusOwnerProperty::invalidated will update
-            // the node's focusVisible flag.
-            focusOwner.set(node);
-        } else if (node != null) {
-            // If the focus owner has not changed (i.e. only focusVisible has changed),
-            // FocusOwnerProperty::invalidated will not be called, therefore we need to
-            // update the node's focusVisible flag manually.
-            node.focusVisible.set(focusVisible);
-            node.focusVisible.notifyListeners();
-        }
+        focusOwner.set(node);
     }
 
     // For testing.
@@ -2374,7 +2380,7 @@ void focusCleanup() {
     private void processInputMethodEvent(InputMethodEvent e) {
         Node node = getFocusOwner();
         if (node != null) {
-            node.fireEvent(e);
+            EventUtil.fireEvent(node, node.resolveFocusDelegate(), e);
         }
     }
 
diff --git a/modules/javafx.graphics/src/shims/java/javafx/scene/NodeShim.java b/modules/javafx.graphics/src/shims/java/javafx/scene/NodeShim.java
index 651608d9375..c1e34753fcc 100644
--- a/modules/javafx.graphics/src/shims/java/javafx/scene/NodeShim.java
+++ b/modules/javafx.graphics/src/shims/java/javafx/scene/NodeShim.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -90,6 +90,14 @@ public static void setTreeVisible(Node n, boolean visible) {
         n.setTreeVisible(visible);
     }
 
+    public static void setFocusQuietly(Node n, boolean focused, boolean focusVisible) {
+        n.setFocusQuietly(focused, focusVisible);
+    }
+
+    public static void notifyFocusListeners(Node n) {
+        n.notifyFocusListeners();
+    }
+
     public static List<TransitionDefinition> getTransitionDefinitions(Node n) {
         return n.getTransitionDefinitions();
     }
diff --git a/modules/javafx.graphics/src/shims/java/javafx/scene/SceneShim.java b/modules/javafx.graphics/src/shims/java/javafx/scene/SceneShim.java
index d2f9b8f8f50..cc89e8c562a 100644
--- a/modules/javafx.graphics/src/shims/java/javafx/scene/SceneShim.java
+++ b/modules/javafx.graphics/src/shims/java/javafx/scene/SceneShim.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,8 +25,14 @@
 
 package javafx.scene;
 
+import javafx.scene.input.KeyEvent;
+
 public class SceneShim {
 
+    public static void processKeyEvent(Scene s, KeyEvent e) {
+        s.processKeyEvent(e);
+    }
+
     public static void focusCleanup(Scene s) {
         s.focusCleanup();
     }
diff --git a/modules/javafx.graphics/src/test/java/test/javafx/scene/FocusTest.java b/modules/javafx.graphics/src/test/java/test/javafx/scene/FocusTest.java
index 36d84a038ce..8e3287467a4 100644
--- a/modules/javafx.graphics/src/test/java/test/javafx/scene/FocusTest.java
+++ b/modules/javafx.graphics/src/test/java/test/javafx/scene/FocusTest.java
@@ -28,6 +28,7 @@
 import com.sun.javafx.scene.SceneHelper;
 import javafx.event.Event;
 import javafx.event.EventTarget;
+import javafx.scene.NodeShim;
 import javafx.scene.input.KeyCode;
 import javafx.scene.input.KeyEvent;
 import test.com.sun.javafx.pgstub.StubScene;
@@ -37,6 +38,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.stream.Stream;
 
 import javafx.scene.Group;
 import javafx.scene.Node;
@@ -54,13 +56,10 @@
 
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertSame;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 public class FocusTest {
 
@@ -121,6 +120,12 @@ private void assertIsFocused(Node n) {
         assertTrue(n.getPseudoClassStates().stream().anyMatch(pc -> pc.getPseudoClassName().equals("focused")));
     }
 
+    private void assertIsFocused(Node... ns) {
+        for (Node n : ns) {
+            assertIsFocused(n);
+        }
+    }
+
     private void assertIsFocused(Scene s, Node n) {
         assertEquals(n, s.getFocusOwner());
         assertIsFocused(n);
@@ -131,6 +136,12 @@ private void assertNotFocused(Node n) {
         assertFalse(n.getPseudoClassStates().stream().anyMatch(pc -> pc.getPseudoClassName().equals("focused")));
     }
 
+    private void assertNotFocused(Node... ns) {
+        for (Node n : ns) {
+            assertNotFocused(n);
+        }
+    }
+
     private void assertNotFocused(Scene s, Node n) {
         assertTrue(n != s.getFocusOwner());
         assertNotFocused(n);
@@ -1161,4 +1172,378 @@ class N extends Group {
         assertNotFocusWithin(node2);
     }
 
+    @Nested
+    class FocusDelegateTest {
+        static class N extends Group {
+            final Node delegate;
+            final String name;
+
+            N(String name, Node child, Node delegate) {
+                super(child == null ? new Node[0] : new Node[] { child });
+                this.delegate = delegate;
+                this.name = name;
+            }
+
+            N(Node child, Node delegate) {
+                this(null, child, delegate);
+            }
+
+            @Override
+            protected Node getFocusDelegate(Node hoistingNode) {
+                return delegate;
+            }
+
+            @Override
+            public String toString() {
+                return name;
+            }
+        }
+
+        static class Trace extends ArrayList<String> {
+            Trace(Node... nodes) {
+                for (Node node : nodes) {
+                    node.addEventFilter(
+                        Event.ANY,
+                        e -> add(String.format("EventFilter[source=%s, target=%s]", e.getSource(), e.getTarget())));
+
+                    node.addEventHandler(
+                        Event.ANY,
+                        e -> add(String.format("EventHandler[source=%s, target=%s]", e.getSource(), e.getTarget())));
+                }
+            }
+        }
+
+        /**
+         * Focusing a node that delegates focus to a descendant will focus both the original node
+         * and its descendant. This test asserts that this also works in nested scenarios, when the
+         * delegation target delegates focus further down the scene graph.
+         */
+        @Test
+        void focusIsDelegatedToDescendants() {
+            N node1, node2, node3, node4, node5;
+
+            // node1 . . . . . . . . . focusDelegate = node3
+            // └── node2
+            //     └── node3 . . . . . focusDelegate = node5
+            //         └── node4
+            //             └── node5
+            scene.setRoot(
+                node1 = new N(
+                    node2 = new N(
+                        node3 = new N(
+                            node4 = new N(
+                                node5 = new N(null, null), null
+                            ), node5
+                        ), null
+                    ), node3
+                ));
+
+            assertNotFocused(node1, node2, node3, node4, node5);
+
+            node1.requestFocus();
+
+            assertIsFocused(node1, node3, node5);
+            assertIsFocused(scene, node1);
+        }
+
+        /**
+         * This test is similar to {@link #focusIsDelegatedToDescendants()}, except that instead of
+         * focusing the root node, the intermediate focus delegate is focused. This will result in
+         * the root node being unfocused, while the intermediate focus delegate and its delegation
+         * target are focused.
+         */
+        @Test
+        void focusIsDelegatedToSubtreeDescendants() {
+            N node1, node2, node3, node4, node5;
+
+            // node1 . . . . . . . . . focusDelegate = node3
+            // └── node2
+            //     └── node3 . . . . . focusDelegate = node5
+            //         └── node4
+            //             └── node5
+            scene.setRoot(
+                node1 = new N(
+                    node2 = new N(
+                        node3 = new N(
+                            node4 = new N(
+                                node5 = new N(null, null), null
+                            ), node5
+                        ), null
+                    ), node3
+                ));
+
+            assertNotFocused(node1, node2, node3, node4, node5);
+
+            node3.requestFocus();
+
+            assertIsFocused(node3, node5);
+            assertIsFocused(scene, node3);
+        }
+
+        /**
+         * When a scene sends a key event to the focus owner, it is delivered up to the final target
+         * of delegation. The event target changes as the event travels through the scene graph:
+         * First, the event is targeted at the focus owner. For each descendant node, the event is
+         * targeted at the next focus delegate. When the capturing phase completes and the event starts
+         * to bubble up, it is targeted back to its original targets as it crosses the boundary between
+         * focus delegates.
+         */
+        @Test
+        void keyEventIsDeliveredToFocusedDescendants() {
+            N node1, node2, node3, node4, node5;
+
+            // node1 . . . . . . . . . focusDelegate = node3, focusOwner
+            // └── node2
+            //     └── node3 . . . . . focusDelegate = node5
+            //         └── node4
+            //             └── node5
+            scene.setRoot(
+                node1 = new N("node1",
+                    node2 = new N("node2",
+                        node3 = new N("node3",
+                            node4 = new N("node4",
+                                node5 = new N("node5",null, null), null
+                            ), node5
+                        ), null
+                    ), node3
+                ));
+
+            node1.requestFocus();
+
+            var trace = new Trace(node1, node2, node3, node4, node5);
+
+            SceneShim.processKeyEvent(
+                scene, new KeyEvent(KeyEvent.KEY_PRESSED, null, null, KeyCode.A, false, false, false, false));
+
+            assertEquals(
+                List.of(
+                    "EventFilter[source=node1, target=node1]", // <-- target is node1 (focusOwner)
+                    "EventFilter[source=node2, target=node3]", // <-- change target to node3 (delegate)
+                    "EventFilter[source=node3, target=node3]",
+                    "EventFilter[source=node4, target=node5]", // <-- change target to node5 (delegate)
+                    "EventFilter[source=node5, target=node5]",
+                    "EventHandler[source=node5, target=node5]",
+                    "EventHandler[source=node4, target=node5]",
+                    "EventHandler[source=node3, target=node3]", // <-- change target back to node3
+                    "EventHandler[source=node2, target=node3]",
+                    "EventHandler[source=node1, target=node1]" // <-- change target back to node1
+                ),
+                trace
+            );
+        }
+    }
+
+    @Nested
+    class FocusScopeTest {
+        static class N extends Group {
+            final boolean focusScope;
+
+            N(boolean focusScope, boolean hoistFocus, Node child) {
+                super(child == null ? new Node[0] : new Node[] { child });
+                this.focusScope = focusScope;
+                setHoistFocus(hoistFocus);
+            }
+
+            @Override
+            protected boolean isFocusScope() {
+                return focusScope;
+            }
+
+            Node getHoistingNode() {
+                try {
+                    var method = focusedProperty().getClass().getDeclaredMethod("getHoistingNode");
+                    method.setAccessible(true);
+                    return (Node)method.invoke(focusedProperty(), (Object[])null);
+                } catch (ReflectiveOperationException e) {
+                    throw new AssertionError(e);
+                }
+            }
+        }
+
+        /**
+         * A node with the {@link Node#hoistFocusProperty()} flag will hoist a focus request to the next
+         * focus scope. The result is that the node that defines the focus scope is focused, and the node
+         * that initially received the focus request is not.
+         */
+        @Test
+        void hoistFocusRequestToNextScope() {
+            N node1, node2, node3, node4, node5;
+
+            // node1 . . . . . . . . . . [hoistFocus]
+            // └── node2 . . . . . . . . [hoistFocus]
+            //     └── node3 . . . . . . [focusScope, hoistFocus]
+            //         └── node4 . . . . [hoistFocus]
+            //             └── node5 . . [hoistFocus]
+            scene.setRoot(
+                node1 = new N(false, false,
+                    node2 = new N(false, true,
+                        node3 = new N(true, true,
+                            node4 = new N(false, true,
+                                node5 = new N(false, true, null)
+                            )
+                        )
+                    )
+                ));
+
+            node4.requestFocus();
+            assertIsFocused(node3);
+            assertNotFocused(node1, node2, node4, node5);
+            assertTrue(Stream.of(node1, node2, node4, node5).allMatch(n -> n.getHoistingNode() == null));
+            assertSame(node4, node3.getHoistingNode());
+
+            node5.requestFocus();
+            assertIsFocused(node3);
+            assertNotFocused(node1, node2, node4, node5);
+            assertTrue(Stream.of(node1, node2, node4, node5).allMatch(n -> n.getHoistingNode() == null));
+            assertSame(node5, node3.getHoistingNode());
+        }
+
+        /**
+         * A node with the {@link Node#hoistFocusProperty()} flag will hoist a focus request to the next
+         * focus scope. In this test, the result is that the node that defines the outermost focus scope
+         * is focused, and all other nodes are not focused (this includes the intermediate focus scope).
+         */
+        @Test
+        void hoistFocusRequestToOutermostScope() {
+            N node1, node2, node3, node4, node5;
+
+            // node1 . . . . . . . . . . [focusScope]
+            // └── node2 . . . . . . . . [hoistFocus]
+            //     └── node3 . . . . . . [focusScope, hoistFocus]
+            //         └── node4 . . . . [hoistFocus]
+            //             └── node5 . . [hoistFocus]
+            scene.setRoot(
+                node1 = new N(true, false,
+                    node2 = new N(false, true,
+                        node3 = new N(true, true,
+                            node4 = new N(false, true,
+                                node5 = new N(false, true, null)
+                            )
+                        )
+                    )
+                ));
+
+            node4.requestFocus();
+            assertIsFocused(node1);
+            assertNotFocused(node2, node3, node4, node5);
+            assertTrue(Stream.of(node2, node4, node5).allMatch(n -> n.getHoistingNode() == null));
+            assertSame(node4, node3.getHoistingNode());
+            assertSame(node3, node1.getHoistingNode());
+
+            node5.requestFocus();
+            assertIsFocused(node1);
+            assertNotFocused(node2, node3, node4, node5);
+            assertTrue(Stream.of(node2, node4, node5).allMatch(n -> n.getHoistingNode() == null));
+            assertSame(node5, node3.getHoistingNode());
+            assertSame(node3, node1.getHoistingNode());
+        }
+
+        /**
+         * A node with the {@link Node#hoistFocusProperty()} flag will hoist a focus request to the next
+         * focus scope. If the next focus scope does not have the {@link Node#hoistFocusProperty()} flag,
+         * the focus request will not be hoisted again, even when an ancestor defines another focus scope.
+         */
+        @Test
+        void hoistFocusRequestStopsWhenHoistFocusIsFalse() {
+            N node1, node2, node3, node4, node5;
+
+            // node1 . . . . . . . . . . [focusScope]
+            // └── node2 . . . . . . . . [hoistFocus]
+            //     └── node3 . . . . . . [focusScope]
+            //         └── node4 . . . . [hoistFocus]
+            //             └── node5 . . [hoistFocus]
+            scene.setRoot(
+                node1 = new N(true, false,
+                    node2 = new N(false, true,
+                        node3 = new N(true, false,
+                            node4 = new N(false, true,
+                                node5 = new N(false, true, null)
+                            )
+                        )
+                    )
+                ));
+
+            node4.requestFocus();
+            assertIsFocused(node3);
+            assertNotFocused(node1, node2, node4, node5);
+            assertTrue(Stream.of(node1, node2, node4, node5).allMatch(n -> n.getHoistingNode() == null));
+            assertSame(node4, node3.getHoistingNode());
+
+            node5.requestFocus();
+            assertIsFocused(node3);
+            assertNotFocused(node1, node2, node4, node5);
+            assertTrue(Stream.of(node1, node2, node4, node5).allMatch(n -> n.getHoistingNode() == null));
+            assertSame(node5, node3.getHoistingNode());
+        }
+
+        /**
+         * When a node hoists a focus request to its focus scope, the receiving node will track the hoisting
+         * node internally. Once the focus scope node loses focus, it will clear the reference to the node
+         * that hoisted the focus request.
+         */
+        @Test
+        void losingFocusClearsTrackedHoistingNode() {
+            N node1, node2, node3;
+
+            // node1 . . . . . . . . . . [focusScope]
+            // └── node2 . . . . . . . . [hoistFocus]
+            //     └── node3 . . . . . . [hoistFocus]
+            scene.setRoot(
+                node1 = new N(true, false,
+                    node2 = new N(false, true,
+                        node3 = new N(false, true, null)
+                    )
+                ));
+
+            node3.requestFocus();
+            assertIsFocused(node1);
+            assertNotFocused(node2, node3);
+            assertTrue(Stream.of(node2, node3).allMatch(n -> n.getHoistingNode() == null));
+            assertSame(node3, node1.getHoistingNode());
+
+            NodeShim.setFocusQuietly(node1, false, false);
+            NodeShim.notifyFocusListeners(node1);
+            assertNotFocused(node1, node2, node3);
+            assertTrue(Stream.of(node1, node2, node3).allMatch(n -> n.getHoistingNode() == null));
+        }
+
+        /**
+         * When a node hoists a focus request to its focus scope, the receiving node will track the hoisting
+         * node internally. If the hoisting node is moved to a different place in the scene graph such that
+         * it is no longer a descendant of the focus scope node, the tracking is cleared.
+         */
+        @Test
+        void hoistingNodeIsNotResolvedWhenMovedOutOfDescendantSubtree() {
+            N node1, node2, node3, node4;
+
+            // node1 . . . . . . . . . . []
+            // └── node2 . . . . . . . . [focusScope]
+            //     └── node3 . . . . . . [hoistFocus]
+            //         └── node4 . . . . [hoistFocus]
+            scene.setRoot(
+                node1 = new N(false, false,
+                    node2 = new N(true, false,
+                        node3 = new N(false, true,
+                            node4 = new N(false, true, null)
+                        )
+                    )
+                ));
+
+            node4.requestFocus();
+            assertIsFocused(node2);
+            assertNotFocused(node1, node3, node4);
+            assertTrue(Stream.of(node1, node3, node4).allMatch(n -> n.getHoistingNode() == null));
+            assertSame(node4, node2.getHoistingNode());
+
+            // node1 . . . . . . . . . . []
+            // └── node2 . . . . . . . . [focusScope]
+            // |   └── node3 . . . . . . [hoistFocus]
+            // └── node4 . . . . . . . . [hoistFocus]
+            node3.getChildren().clear();
+            node1.getChildren().add(node4);
+            assertIsFocused(node2);
+            assertNotFocused(node1, node3, node4);
+            assertTrue(Stream.of(node1, node2, node3, node4).allMatch(n -> n.getHoistingNode() == null));
+        }
+    }
 }