diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8ceb93a..3857009 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -69,6 +69,48 @@ jobs:
           path: ./test-results/results.trx
           if-no-files-found: warn
 
+  test-e2e:
+    name: E2E (Avalonia headless) / ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: actions/setup-dotnet@v5
+        with:
+          dotnet-version: ${{ env.DOTNET_VERSION }}
+
+      - name: Cache NuGet packages
+        uses: actions/cache@v4
+        with:
+          path: ~/.nuget/packages
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj', '**/*.props') }}
+          restore-keys: ${{ runner.os }}-nuget-
+
+      - name: Restore
+        run: dotnet restore tests/AsyncNavigation.E2E.Tests
+
+      - name: Test
+        run: >
+          dotnet test tests/AsyncNavigation.E2E.Tests
+          --configuration Release
+          --no-restore
+          --logger "console;verbosity=normal"
+          --logger "trx;LogFileName=results.trx"
+          --results-directory ./test-results
+
+      - name: Upload test results
+        uses: actions/upload-artifact@v4
+        if: always()              # upload even when tests fail so we can inspect
+        with:
+          name: e2e-test-results-${{ matrix.os }}
+          path: ./test-results/results.trx
+          if-no-files-found: warn
+
   build-libs:
     name: Build Libraries
     runs-on: ubuntu-latest
@@ -199,6 +241,8 @@ jobs:
       - name: Setup Android SDK
         if: matrix.platform == 'Android'
         uses: android-actions/setup-android@v3
+        with:
+          packages: platform-tools
 
       - name: Install Android workload
         if: matrix.platform == 'Android'
diff --git a/readme.md b/readme.md
index 63d6e23..3adb397 100644
--- a/readme.md
+++ b/readme.md
@@ -94,14 +94,32 @@ var result = await _dialogService.ShowViewDialogAsync("Confirm");
 
 ### 4. React to navigation in view models
 
+View models implement `INavigationAware` directly. `NavigationAwareBase` remains available for compatibility but is obsolete; new code should implement `INavigationAware`. You can define an application base class to share default implementations.
+
 ```csharp
-// Derive from NavigationAwareBase and override only what you need.
-public class HomeViewModel : NavigationAwareBase
+using AsyncNavigation;
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Core;
+using System.Threading;
+using System.Threading.Tasks;
+
+public class HomeViewModel : INavigationAware
 {
-    public override async Task OnNavigatedToAsync(NavigationContext context)
+    public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+
+    public Task InitializeAsync(NavigationContext context) => Task.CompletedTask;
+
+    public Task OnNavigatedToAsync(NavigationContext context)
     {
-        await LoadDataAsync(context.CancellationToken);
+        // Load page data here; use context.CancellationToken for async operations.
+        return Task.CompletedTask;
     }
+
+    public Task OnNavigatedFromAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnUnloadAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+
+    // Allow reuse when caching is enabled; return false to request a new instance.
+    public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(true);
 }
 ```
 
@@ -110,12 +128,21 @@ public class HomeViewModel : NavigationAwareBase
 ## Navigation Guard
 
 ```csharp
-public class EditViewModel : NavigationAwareBase, INavigationGuard
+public class EditViewModel : INavigationAware, INavigationGuard
 {
-    public async Task<bool> CanNavigateAsync(NavigationContext context, CancellationToken ct)
+    public bool HasUnsavedChanges { get; set; }
+    public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+
+    public Task InitializeAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnNavigatedToAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnNavigatedFromAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnUnloadAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+    public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(true);
+
+    public Task<bool> CanNavigateAsync(NavigationContext context, CancellationToken ct)
     {
-        // Return false to cancel — show a confirmation dialog here if needed.
-        return !HasUnsavedChanges;
+        // Return false to cancel; show a confirmation dialog asynchronously here if needed.
+        return Task.FromResult(!HasUnsavedChanges);
     }
 }
 ```
diff --git a/readme_zh-cn.md b/readme_zh-cn.md
index 90be970..11ade05 100644
--- a/readme_zh-cn.md
+++ b/readme_zh-cn.md
@@ -94,14 +94,32 @@ var result = await _dialogService.ShowViewDialogAsync("Confirm");
 
 ### 4. 在视图模型中响应导航
 
+视图模型直接实现 `INavigationAware`。`NavigationAwareBase` 为兼容旧代码而保留，但已标记弃用，建议新代码实现 `INavigationAware`。如需复用默认实现，可以在应用中定义自己的基类。
+
 ```csharp
-// 继承 NavigationAwareBase，按需重写方法即可。
-public class HomeViewModel : NavigationAwareBase
+using AsyncNavigation;
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Core;
+using System.Threading;
+using System.Threading.Tasks;
+
+public class HomeViewModel : INavigationAware
 {
-    public override async Task OnNavigatedToAsync(NavigationContext context)
+    public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+
+    public Task InitializeAsync(NavigationContext context) => Task.CompletedTask;
+
+    public Task OnNavigatedToAsync(NavigationContext context)
     {
-        await LoadDataAsync(context.CancellationToken);
+        // 在此加载页面数据；异步操作可使用 context.CancellationToken。
+        return Task.CompletedTask;
     }
+
+    public Task OnNavigatedFromAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnUnloadAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+
+    // 启用缓存时，允许复用此实例；返回 false 可请求新实例。
+    public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(true);
 }
 ```
 
@@ -110,12 +128,21 @@ public class HomeViewModel : NavigationAwareBase
 ## 导航守卫
 
 ```csharp
-public class EditViewModel : NavigationAwareBase, INavigationGuard
+public class EditViewModel : INavigationAware, INavigationGuard
 {
-    public async Task<bool> CanNavigateAsync(NavigationContext context, CancellationToken ct)
+    public bool HasUnsavedChanges { get; set; }
+    public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+
+    public Task InitializeAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnNavigatedToAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnNavigatedFromAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnUnloadAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+    public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(true);
+
+    public Task<bool> CanNavigateAsync(NavigationContext context, CancellationToken ct)
     {
-        // 返回 false 可取消导航，通常在此弹出确认对话框
-        return !HasUnsavedChanges;
+        // 返回 false 可取消导航；如需确认，可在此异步显示对话框。
+        return Task.FromResult(!HasUnsavedChanges);
     }
 }
 ```
diff --git a/samples/Sample.Avalonia.iOS/Info.plist b/samples/Sample.Avalonia.iOS/Info.plist
index 3fff6e2..91a3c19 100644
--- a/samples/Sample.Avalonia.iOS/Info.plist
+++ b/samples/Sample.Avalonia.iOS/Info.plist
@@ -13,7 +13,7 @@
 	<key>LSRequiresIPhoneOS</key>
 	<true/>
 	<key>MinimumOSVersion</key>
-	<string>13.0</string>
+	<string>15.0</string>
 	<key>UIDeviceFamily</key>
 	<array>
 		<integer>1</integer>
diff --git a/samples/Sample.Avalonia.iOS/Sample.Avalonia.iOS.csproj b/samples/Sample.Avalonia.iOS/Sample.Avalonia.iOS.csproj
index cefb484..08ce307 100644
--- a/samples/Sample.Avalonia.iOS/Sample.Avalonia.iOS.csproj
+++ b/samples/Sample.Avalonia.iOS/Sample.Avalonia.iOS.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net10.0-ios</TargetFramework>
-    <SupportedOSPlatformVersion>13.0</SupportedOSPlatformVersion>
+    <SupportedOSPlatformVersion>15.0</SupportedOSPlatformVersion>
     <Nullable>enable</Nullable>
 	<ValidateXcodeVersion>false</ValidateXcodeVersion>
   </PropertyGroup>
diff --git a/samples/Sample.Avalonia/App.axaml.cs b/samples/Sample.Avalonia/App.axaml.cs
index da64262..5bb8a3b 100644
--- a/samples/Sample.Avalonia/App.axaml.cs
+++ b/samples/Sample.Avalonia/App.axaml.cs
@@ -30,6 +30,7 @@ public override void OnFrameworkInitializationCompleted()
 
         var services = new ServiceCollection();
         services.AddNavigationSupport(navigationOptions)
+                .AddFloatingSupport()
                 .AddSingletonWithAllMembers<MainWindowViewModel>()
                 .RegisterView<LightView, LightViewModel>(nameof(LightView))
                 .RegisterView<ItemsRegionView, ItemsRegionViewModel>(nameof(ItemsRegionView))
@@ -74,7 +75,7 @@ public override void OnFrameworkInitializationCompleted()
 
         if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
         {
-            desktop.MainWindow = new MainWindow
+            desktop.MainWindow = new MainWindow(sp.GetRequiredService<AsyncNavigation.Floating.IViewPlacementService>())
             {
                 DataContext = sp.GetRequiredService<MainWindowViewModel>()
             };
@@ -82,11 +83,11 @@ public override void OnFrameworkInitializationCompleted()
         }
         else if (ApplicationLifetime is ISingleViewApplicationLifetime singleViewPlatform)
         {
-            singleViewPlatform.MainView = new MainView
+            singleViewPlatform.MainView = new MainView(sp.GetRequiredService<AsyncNavigation.Floating.IViewPlacementService>())
             {
                 DataContext = sp.GetRequiredService<MainWindowViewModel>()
             };
         }
         #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/samples/Sample.Avalonia/Sample.Avalonia.csproj b/samples/Sample.Avalonia/Sample.Avalonia.csproj
index 91ca3b0..3c65a09 100644
--- a/samples/Sample.Avalonia/Sample.Avalonia.csproj
+++ b/samples/Sample.Avalonia/Sample.Avalonia.csproj
@@ -30,6 +30,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\AsyncNavigation.Avalonia\AsyncNavigation.Avalonia.csproj" />
+    <ProjectReference Include="..\..\src\AsyncNavigation.Avalonia.Floating\AsyncNavigation.Avalonia.Floating.csproj" />
     <ProjectReference Include="..\Sample.Common\Sample.Common.csproj" />
   </ItemGroup>
 
diff --git a/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml b/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml
index 1208232..0267aaa 100644
--- a/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml
+++ b/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml
@@ -39,6 +39,10 @@
                 Classes="Navigation"
                 Content="ToHeavyView"
                 Tag="HeavyView" />
+            <Button
+                Padding="8,4"
+                Click="FloatChildRegion_Click"
+                Content="Floating: current ChildContentRegion view" />
         </StackPanel>
         <ContentControl an:RegionManager.RegionName="ChildContentRegion" />
     </DockPanel>
diff --git a/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml.cs b/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml.cs
index 8d4eef0..b4b9249 100644
--- a/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml.cs
+++ b/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml.cs
@@ -1,12 +1,43 @@
-using AsyncNavigation.Abstractions;
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Floating;
 using Avalonia.Controls;
+using Avalonia.Interactivity;
+using System;
+using System.Diagnostics;
 
 namespace Sample.Avalonia.Views;
 
 public partial class ChildContentRegionView : UserControl, IView
 {
-    public ChildContentRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public ChildContentRegionView() : this(null)
+    {
+    }
+
+    public ChildContentRegionView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
-}
\ No newline at end of file
+
+    private async void FloatChildRegion_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("ChildContentRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating ChildContentRegion",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            Debug.WriteLine($"Cannot float ChildContentRegion: {ex.Message}");
+        }
+    }
+}
diff --git a/samples/Sample.Avalonia/Views/HeavyView.axaml b/samples/Sample.Avalonia/Views/HeavyView.axaml
index a154016..acab923 100644
--- a/samples/Sample.Avalonia/Views/HeavyView.axaml
+++ b/samples/Sample.Avalonia/Views/HeavyView.axaml
@@ -30,15 +30,25 @@
                 <Button Classes="CloseDialog" />
                 <ItemsControl ItemsSource="{Binding HeavyItems}">
                     <ItemsControl.ItemTemplate>
-                        <DataTemplate>
+                        <DataTemplate x:DataType="vm:HeavyItemViewModel">
                             <Border
                                 Margin="2"
                                 BorderBrush="Black"
                                 BorderThickness="1">
                                 <DockPanel LastChildFill="True">
-                                    <ComboBox Width="50" />
-                                    <Expander Width="50" />
-                                    <DatePicker Width="50" />
+                                    <ComboBox
+                                        Width="100"
+                                        ItemsSource="{Binding Options}"
+                                        SelectedItem="{Binding SelectedOption}" />
+                                    <Expander
+                                        Width="100"
+                                        Header="Details"
+                                        IsExpanded="{Binding IsExpanded}">
+                                        <TextBlock Text="{Binding Value}" />
+                                    </Expander>
+                                    <DatePicker
+                                        Width="140"
+                                        SelectedDate="{Binding AvaloniaSelectedDate}" />
                                 </DockPanel>
                             </Border>
                         </DataTemplate>
diff --git a/samples/Sample.Avalonia/Views/ItemsRegionView.axaml b/samples/Sample.Avalonia/Views/ItemsRegionView.axaml
index d76789c..43cb20d 100644
--- a/samples/Sample.Avalonia/Views/ItemsRegionView.axaml
+++ b/samples/Sample.Avalonia/Views/ItemsRegionView.axaml
@@ -51,6 +51,10 @@
                 Classes="NavigationAndForget"
                 Content="ToLightView:Forget"
                 Tag="LightView" />
+            <Button
+                Padding="8,4"
+                Click="FloatSelectedItem_Click"
+                Content="Floating: selected ItemsRegion view" />
         </StackPanel>
         <ScrollViewer>
             <ItemsControl an:RegionManager.RegionName="ItemsRegion">
diff --git a/samples/Sample.Avalonia/Views/ItemsRegionView.axaml.cs b/samples/Sample.Avalonia/Views/ItemsRegionView.axaml.cs
index a4d5612..295fba6 100644
--- a/samples/Sample.Avalonia/Views/ItemsRegionView.axaml.cs
+++ b/samples/Sample.Avalonia/Views/ItemsRegionView.axaml.cs
@@ -1,17 +1,42 @@
 using AsyncNavigation.Abstractions;
-using Avalonia;
+using AsyncNavigation.Floating;
 using Avalonia.Controls;
+using Avalonia.Interactivity;
+using System;
+using System.Diagnostics;
 
 namespace Sample.Avalonia.Views;
 
 public partial class ItemsRegionView : UserControl, IView
 {
-    public ItemsRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public ItemsRegionView() : this(null)
     {
+    }
+
+    public ItemsRegionView(IViewPlacementService? placementService)
+    {
+        _placementService = placementService;
         InitializeComponent();
     }
-    protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
+    private async void FloatSelectedItem_Click(object? sender, RoutedEventArgs e)
     {
-        base.OnAttachedToVisualTree(e);
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("ItemsRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating ItemsRegion item",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            Debug.WriteLine($"Cannot float ItemsRegion: {ex.Message}");
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml b/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml
index c7406a2..b722b51 100644
--- a/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml
+++ b/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml
@@ -24,6 +24,10 @@
                 Classes="Navigation"
                 Content="ToHeavyView"
                 Tag="HeavyView" />
+            <Button
+                Padding="8,4"
+                Click="FloatSelectedItem_Click"
+                Content="Floating: selected CustomListBoxRegion view" />
         </StackPanel>
         <ListBox an:RegionManager.RegionName="CustomListBoxRegion" />
     </DockPanel>
diff --git a/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml.cs b/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml.cs
index e59925e..a4defcd 100644
--- a/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml.cs
+++ b/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml.cs
@@ -1,12 +1,43 @@
-using AsyncNavigation.Abstractions;
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Floating;
 using Avalonia.Controls;
+using Avalonia.Interactivity;
+using System;
+using System.Diagnostics;
 
 namespace Sample.Avalonia.Views;
 
 public partial class ListBoxRegionView : UserControl, IView
 {
-    public ListBoxRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public ListBoxRegionView() : this(null)
+    {
+    }
+
+    public ListBoxRegionView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
-}
\ No newline at end of file
+
+    private async void FloatSelectedItem_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("CustomListBoxRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating CustomListBoxRegion item",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            Debug.WriteLine($"Cannot float CustomListBoxRegion: {ex.Message}");
+        }
+    }
+}
diff --git a/samples/Sample.Avalonia/Views/MainView.axaml b/samples/Sample.Avalonia/Views/MainView.axaml
index 70df72d..26f5c0f 100644
--- a/samples/Sample.Avalonia/Views/MainView.axaml
+++ b/samples/Sample.Avalonia/Views/MainView.axaml
@@ -10,8 +10,15 @@
     d:DesignWidth="800"
     x:DataType="vm:MainWindowViewModel"
     mc:Ignorable="d">
-    <Grid RowDefinitions="*,30">
+    <Grid RowDefinitions="Auto,*,30">
+        <Border Grid.Row="0" Padding="8">
+            <StackPanel Orientation="Horizontal" Spacing="8">
+                <Button Click="FloatMainRegion_Click" Content="Floating: current MainRegion view" />
+                <TextBlock VerticalAlignment="Center" Text="The same UserControl instance moves to the window; use Dock to region to return it. Closing closes the view." />
+            </StackPanel>
+        </Border>
         <SplitView
+            Grid.Row="1"
             DisplayMode="CompactInline"
             IsPaneOpen="{Binding IsSplitViewPaneOpen}"
             OpenPaneLength="310"
@@ -77,7 +84,7 @@
                             Tag="ItemsRegionView" />
                         <Button
                             Classes="Navigation"
-                            Content="ToTabRegionView"
+                            Content="Floating demo: TabRegion"
                             Tag="TabRegionView" />
                         <Button
                             Classes="Navigation"
@@ -133,7 +140,7 @@
         </SplitView>
         <SelectableTextBlock
             Name="footer"
-            Grid.Row="1"
+            Grid.Row="2"
             HorizontalAlignment="Center"
             VerticalAlignment="Center" />
     </Grid>
diff --git a/samples/Sample.Avalonia/Views/MainView.axaml.cs b/samples/Sample.Avalonia/Views/MainView.axaml.cs
index 4a38b47..0157044 100644
--- a/samples/Sample.Avalonia/Views/MainView.axaml.cs
+++ b/samples/Sample.Avalonia/Views/MainView.axaml.cs
@@ -1,18 +1,49 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Floating;
 using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Data;
+using Avalonia.Interactivity;
 using Sample.Common;
+using System;
+using System.Diagnostics;
 
 namespace Sample.Avalonia.Views;
 
 public partial class MainView : UserControl
 {
-    public MainView()
+    private readonly IViewPlacementService? _placementService;
+
+    public MainView() : this(null)
+    {
+    }
+
+    public MainView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
 
+    private async void FloatMainRegion_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("MainRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating MainRegion",
+                Width = 900,
+                Height = 600
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            Debug.WriteLine($"Cannot float MainRegion: {ex.Message}");
+        }
+    }
+
     protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
     {
         base.OnAttachedToVisualTree(e);
diff --git a/samples/Sample.Avalonia/Views/MainWindow.axaml b/samples/Sample.Avalonia/Views/MainWindow.axaml
index 4342b23..c090e35 100644
--- a/samples/Sample.Avalonia/Views/MainWindow.axaml
+++ b/samples/Sample.Avalonia/Views/MainWindow.axaml
@@ -11,8 +11,6 @@
     xmlns:vm="using:Sample.Common"
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-    xmlns:views="clr-namespace:Sample.Avalonia.Views"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     x:DataType="vm:MainWindowViewModel">
-    <views:MainView />
 </Window>
diff --git a/samples/Sample.Avalonia/Views/MainWindow.axaml.cs b/samples/Sample.Avalonia/Views/MainWindow.axaml.cs
index a157c8b..d5820ac 100644
--- a/samples/Sample.Avalonia/Views/MainWindow.axaml.cs
+++ b/samples/Sample.Avalonia/Views/MainWindow.axaml.cs
@@ -1,16 +1,22 @@
 using Avalonia.Controls;
-using System;
-using System.Diagnostics;
-using System.Threading;
-using System.Threading.Tasks;
+
+using AsyncNavigation.Floating;
 
 namespace Sample.Avalonia.Views
 {
     public partial class MainWindow : Window
     {
-        public MainWindow()
+        public MainWindow() : this(null)
+        {
+        }
+
+        public MainWindow(IViewPlacementService? placementService)
         {
             InitializeComponent();
+            // MainView carries the whole app UI (including the "float MainRegion" demo), shared
+            // as-is with the single-view (browser/mobile) lifetime in App.axaml.cs, so desktop
+            // and single-view platforms show exactly the same floating samples.
+            Content = new MainView(placementService);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/samples/Sample.Avalonia/Views/TabRegionView.axaml b/samples/Sample.Avalonia/Views/TabRegionView.axaml
index 221630d..3bf22f5 100644
--- a/samples/Sample.Avalonia/Views/TabRegionView.axaml
+++ b/samples/Sample.Avalonia/Views/TabRegionView.axaml
@@ -45,6 +45,27 @@
                 Classes="NavigationAndForget"
                 Content="ToLightView:Forget;New"
                 Tag="LightView:New" />
+            <Separator Margin="4" />
+            <TextBlock
+                Width="170"
+                Margin="4"
+                FontWeight="SemiBold"
+                Text="Floating region demo"
+                TextWrapping="Wrap" />
+            <TextBlock
+                Width="170"
+                Margin="4"
+                Text="1. Open LightView or HeavyView.&#x0a;2. Select the tab.&#x0a;3. Float the selected tab."
+                TextWrapping="Wrap" />
+            <Button
+                Padding="8,4"
+                Click="FloatCurrent_Click"
+                Content="Floating: selected TabRegion view" />
+            <TextBlock
+                Width="170"
+                Margin="4"
+                Text="Use Dock to region to restore the tab; closing the window closes it."
+                TextWrapping="Wrap" />
         </StackPanel>
         <ScrollViewer>
             <TabControl
diff --git a/samples/Sample.Avalonia/Views/TabRegionView.axaml.cs b/samples/Sample.Avalonia/Views/TabRegionView.axaml.cs
index 0816009..66460c4 100644
--- a/samples/Sample.Avalonia/Views/TabRegionView.axaml.cs
+++ b/samples/Sample.Avalonia/Views/TabRegionView.axaml.cs
@@ -1,12 +1,43 @@
 using AsyncNavigation.Abstractions;
 using Avalonia.Controls;
+using AsyncNavigation.Floating;
+using Avalonia.Interactivity;
+using System.Diagnostics;
+using System;
 
 namespace Sample.Avalonia.Views;
 
 public partial class TabRegionView : UserControl, IView
 {
-    public TabRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public TabRegionView() : this(null)
+    {
+    }
+
+    public TabRegionView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
-}
\ No newline at end of file
+
+    private async void FloatCurrent_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("TabRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating tab",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            Debug.WriteLine($"Cannot float tab: {ex.Message}");
+        }
+    }
+}
diff --git a/samples/Sample.Common/HeavyViewModel.cs b/samples/Sample.Common/HeavyViewModel.cs
index 8c1aa27..c7e4956 100644
--- a/samples/Sample.Common/HeavyViewModel.cs
+++ b/samples/Sample.Common/HeavyViewModel.cs
@@ -2,13 +2,14 @@
 using AsyncNavigation.Abstractions;
 using AsyncNavigation.Core;
 using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.ComponentModel;
 using System.Collections.ObjectModel;
 
 namespace Sample.Common;
 
 public partial class HeavyViewModel : InstanceCounterViewModel<HeavyViewModel>, IDialogAware, INavigationMetadata
 {
-    public ObservableCollection<byte> HeavyItems
+    public ObservableCollection<HeavyItemViewModel> HeavyItems
     {
         get;
     } = [];
@@ -60,7 +61,26 @@ private void AddItems(int count)
         var rnd = new Random();
         for (int i = 0; i < count; i++)
         {
-            HeavyItems.Add((byte)rnd.Next(0, 256));
+            HeavyItems.Add(new HeavyItemViewModel((byte)rnd.Next(0, 256)));
         }
     }
 }
+
+public partial class HeavyItemViewModel(byte value) : ObservableObject
+{
+    public byte Value { get; } = value;
+
+    public IReadOnlyList<string> Options { get; } = ["Alpha", "Beta", "Gamma"];
+
+    [ObservableProperty]
+    private string? _selectedOption;
+
+    [ObservableProperty]
+    private DateTimeOffset? _avaloniaSelectedDate;
+
+    [ObservableProperty]
+    private DateTime? _wpfSelectedDate;
+
+    [ObservableProperty]
+    private bool _isExpanded;
+}
diff --git a/samples/Sample.Wpf/App.xaml.cs b/samples/Sample.Wpf/App.xaml.cs
index e997c49..cff0c75 100644
--- a/samples/Sample.Wpf/App.xaml.cs
+++ b/samples/Sample.Wpf/App.xaml.cs
@@ -21,6 +21,7 @@ protected override void OnStartup(StartupEventArgs e)
 
         var services = new ServiceCollection();
         services.AddNavigationSupport()
+            .AddFloatingSupport()
             .AddSingleton<MainWindowViewModel>()
             .RegisterRegionAdapter<ListBoxRegionAdapter>()
             .RegisterView<LightView, LightViewModel>(nameof(LightView))
@@ -58,7 +59,7 @@ protected override void OnStartup(StartupEventArgs e)
         base.OnStartup(e);
         var converter = sp.GetRequiredService<IconDescriptorConverter>();
         Application.Current.Resources[nameof(IconDescriptorConverter)] = converter;
-        var mainWindow = new MainWindow
+        var mainWindow = new MainWindow(sp.GetRequiredService<AsyncNavigation.Floating.IViewPlacementService>())
         {
             DataContext = sp.GetRequiredService<MainWindowViewModel>()
         };
diff --git a/samples/Sample.Wpf/MainWindow.xaml b/samples/Sample.Wpf/MainWindow.xaml
index 8917663..8a53434 100644
--- a/samples/Sample.Wpf/MainWindow.xaml
+++ b/samples/Sample.Wpf/MainWindow.xaml
@@ -33,6 +33,10 @@
                     <Button Style="{StaticResource GoBack}" />
                     <Button Style="{StaticResource GoForward}" />
                 </StackPanel>
+                <Button
+                    Padding="8,4"
+                    Click="FloatMainRegion_Click"
+                    Content="Floating: current MainRegion view" />
                 <Button
                     Content="ToLightView"
                     Style="{StaticResource NavigationButton}"
@@ -66,7 +70,7 @@
                     Style="{StaticResource NavigationButton}"
                     Tag="ItemsRegionView" />
                 <Button
-                    Content="ToTabRegionView"
+                    Content="Floating demo: TabRegion"
                     Style="{StaticResource NavigationButton}"
                     Tag="TabRegionView" />
                 <Button
diff --git a/samples/Sample.Wpf/MainWindow.xaml.cs b/samples/Sample.Wpf/MainWindow.xaml.cs
index 9c36752..7ae99a0 100644
--- a/samples/Sample.Wpf/MainWindow.xaml.cs
+++ b/samples/Sample.Wpf/MainWindow.xaml.cs
@@ -1,5 +1,7 @@
 using System.Windows;
 
+using AsyncNavigation.Floating;
+
 namespace Sample.Wpf;
 
 /// <summary>
@@ -7,8 +9,35 @@ namespace Sample.Wpf;
 /// </summary>
 public partial class MainWindow : Window
 {
-    public MainWindow()
+    private readonly IViewPlacementService? _placementService;
+
+    public MainWindow() : this(null)
+    {
+    }
+
+    public MainWindow(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
-}
\ No newline at end of file
+
+    private async void FloatMainRegion_Click(object sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("MainRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating MainRegion",
+                Width = 900,
+                Height = 600
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            MessageBox.Show(ex.Message, "Cannot float MainRegion", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+    }
+}
diff --git a/samples/Sample.Wpf/Sample.Wpf.csproj b/samples/Sample.Wpf/Sample.Wpf.csproj
index bd261a5..cc694f8 100644
--- a/samples/Sample.Wpf/Sample.Wpf.csproj
+++ b/samples/Sample.Wpf/Sample.Wpf.csproj
@@ -19,6 +19,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\AsyncNavigation.Wpf\AsyncNavigation.Wpf.csproj" />
+    <ProjectReference Include="..\..\src\AsyncNavigation.Wpf.Floating\AsyncNavigation.Wpf.Floating.csproj" />
     <ProjectReference Include="..\Sample.Common\Sample.Common.csproj" />
   </ItemGroup>
 
diff --git a/samples/Sample.Wpf/Views/ChildContentRegionView.xaml b/samples/Sample.Wpf/Views/ChildContentRegionView.xaml
index f46dc84..33ebebe 100644
--- a/samples/Sample.Wpf/Views/ChildContentRegionView.xaml
+++ b/samples/Sample.Wpf/Views/ChildContentRegionView.xaml
@@ -38,6 +38,10 @@
                 Content="ToHeavyView"
                 Style="{StaticResource NavigationButton}"
                 Tag="HeavyView" />
+            <Button
+                Padding="8,4"
+                Click="FloatChildRegion_Click"
+                Content="Floating: current ChildContentRegion view" />
         </StackPanel>
         <ContentControl an:RegionManager.RegionName="ChildContentRegion" />
     </DockPanel>
diff --git a/samples/Sample.Wpf/Views/ChildContentRegionView.xaml.cs b/samples/Sample.Wpf/Views/ChildContentRegionView.xaml.cs
index 84ab673..9e832f7 100644
--- a/samples/Sample.Wpf/Views/ChildContentRegionView.xaml.cs
+++ b/samples/Sample.Wpf/Views/ChildContentRegionView.xaml.cs
@@ -1,15 +1,41 @@
-using AsyncNavigation.Abstractions;
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Floating;
+using System.Windows;
 using System.Windows.Controls;
 
 namespace Sample.Wpf.Views;
 
-/// <summary>
-/// Interaction logic for ChildContentRegionView.xaml
-/// </summary>
 public partial class ChildContentRegionView : UserControl, IView
 {
-    public ChildContentRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public ChildContentRegionView() : this(null)
+    {
+    }
+
+    public ChildContentRegionView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
+
+    private async void FloatChildRegion_Click(object sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("ChildContentRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating ChildContentRegion",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            MessageBox.Show(ex.Message, "Cannot float ChildContentRegion", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+    }
 }
diff --git a/samples/Sample.Wpf/Views/HeavyView.xaml b/samples/Sample.Wpf/Views/HeavyView.xaml
index c62b52c..b963cc9 100644
--- a/samples/Sample.Wpf/Views/HeavyView.xaml
+++ b/samples/Sample.Wpf/Views/HeavyView.xaml
@@ -5,6 +5,7 @@
     xmlns:an="https://github.com/NeverMorewd/AsyncNavigation"
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
     xmlns:local="clr-namespace:Sample.Wpf.Views"
+    xmlns:vm="clr-namespace:Sample.Common;assembly=Sample.Common"
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
     d:DesignHeight="450"
     d:DesignWidth="800"
@@ -29,12 +30,22 @@
                 <Button Style="{StaticResource CloseDialog}" />
                 <ItemsControl ItemsSource="{Binding HeavyItems}">
                     <ItemsControl.ItemTemplate>
-                        <DataTemplate>
+                        <DataTemplate DataType="{x:Type vm:HeavyItemViewModel}">
                             <Border BorderBrush="Black" BorderThickness="1">
                                 <DockPanel LastChildFill="True">
-                                    <ComboBox Width="50" />
-                                    <Expander Width="50" />
-                                    <DatePicker Width="50" />
+                                    <ComboBox
+                                        Width="100"
+                                        ItemsSource="{Binding Options}"
+                                        SelectedItem="{Binding SelectedOption}" />
+                                    <Expander
+                                        Width="100"
+                                        Header="Details"
+                                        IsExpanded="{Binding IsExpanded}">
+                                        <TextBlock Text="{Binding Value}" />
+                                    </Expander>
+                                    <DatePicker
+                                        Width="140"
+                                        SelectedDate="{Binding WpfSelectedDate}" />
                                 </DockPanel>
                             </Border>
                         </DataTemplate>
diff --git a/samples/Sample.Wpf/Views/ItemsRegionView.xaml b/samples/Sample.Wpf/Views/ItemsRegionView.xaml
index 0b261aa..208ed3c 100644
--- a/samples/Sample.Wpf/Views/ItemsRegionView.xaml
+++ b/samples/Sample.Wpf/Views/ItemsRegionView.xaml
@@ -50,6 +50,10 @@
                 Content="ToLightView:Forget"
                 Style="{StaticResource NavigationAndForget}"
                 Tag="LightView" />
+            <Button
+                Padding="8,4"
+                Click="FloatSelectedItem_Click"
+                Content="Floating: selected ItemsRegion view" />
         </StackPanel>
         <ScrollViewer>
             <ItemsControl an:RegionManager.RegionName="ItemsRegion">
diff --git a/samples/Sample.Wpf/Views/ItemsRegionView.xaml.cs b/samples/Sample.Wpf/Views/ItemsRegionView.xaml.cs
index 5fad3cf..f349f71 100644
--- a/samples/Sample.Wpf/Views/ItemsRegionView.xaml.cs
+++ b/samples/Sample.Wpf/Views/ItemsRegionView.xaml.cs
@@ -1,4 +1,6 @@
 using AsyncNavigation.Abstractions;
+using AsyncNavigation.Floating;
+using System.Windows;
 using System.Windows.Controls;
 
 namespace Sample.Wpf.Views;
@@ -8,8 +10,35 @@ namespace Sample.Wpf.Views;
 /// </summary>
 public partial class ItemsRegionView : UserControl,IView
 {
-    public ItemsRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public ItemsRegionView() : this(null)
+    {
+    }
+
+    public ItemsRegionView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
+
+    private async void FloatSelectedItem_Click(object sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("ItemsRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating ItemsRegion item",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            MessageBox.Show(ex.Message, "Cannot float ItemsRegion", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+    }
 }
diff --git a/samples/Sample.Wpf/Views/ListBoxRegionView.xaml b/samples/Sample.Wpf/Views/ListBoxRegionView.xaml
index efcc25a..32958d2 100644
--- a/samples/Sample.Wpf/Views/ListBoxRegionView.xaml
+++ b/samples/Sample.Wpf/Views/ListBoxRegionView.xaml
@@ -23,6 +23,10 @@
                 Content="ToHeavyView"
                 Style="{StaticResource NavigationButton}"
                 Tag="HeavyView" />
+            <Button
+                Padding="8,4"
+                Click="FloatSelectedItem_Click"
+                Content="Floating: selected CustomListBoxRegion view" />
         </StackPanel>
         <ListBox an:RegionManager.RegionName="CustomListBoxRegion" />
     </DockPanel>
diff --git a/samples/Sample.Wpf/Views/ListBoxRegionView.xaml.cs b/samples/Sample.Wpf/Views/ListBoxRegionView.xaml.cs
index c67db98..c7ac2d3 100644
--- a/samples/Sample.Wpf/Views/ListBoxRegionView.xaml.cs
+++ b/samples/Sample.Wpf/Views/ListBoxRegionView.xaml.cs
@@ -1,29 +1,41 @@
-using AsyncNavigation.Abstractions;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Floating;
 using System.Windows;
 using System.Windows.Controls;
-using System.Windows.Data;
-using System.Windows.Documents;
-using System.Windows.Input;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Navigation;
-using System.Windows.Shapes;
 
-namespace Sample.Wpf.Views
+namespace Sample.Wpf.Views;
+
+public partial class ListBoxRegionView : UserControl, IView
 {
-    /// <summary>
-    /// Interaction logic for ListBoxRegionView.xaml
-    /// </summary>
-    public partial class ListBoxRegionView : UserControl,IView
+    private readonly IViewPlacementService? _placementService;
+
+    public ListBoxRegionView() : this(null)
+    {
+    }
+
+    public ListBoxRegionView(IViewPlacementService? placementService)
     {
-        public ListBoxRegionView()
+        _placementService = placementService;
+        InitializeComponent();
+    }
+
+    private async void FloatSelectedItem_Click(object sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("CustomListBoxRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating CustomListBoxRegion item",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
         {
-            InitializeComponent();
+            MessageBox.Show(ex.Message, "Cannot float CustomListBoxRegion", MessageBoxButton.OK, MessageBoxImage.Information);
         }
     }
 }
diff --git a/samples/Sample.Wpf/Views/TabRegionView.xaml b/samples/Sample.Wpf/Views/TabRegionView.xaml
index e6b7e1d..7c9502c 100644
--- a/samples/Sample.Wpf/Views/TabRegionView.xaml
+++ b/samples/Sample.Wpf/Views/TabRegionView.xaml
@@ -43,6 +43,27 @@
                 Content="ToLightView:Forget;New"
                 Style="{StaticResource NavigationAndForget}"
                 Tag="LightView:New" />
+            <Separator Margin="4" />
+            <TextBlock
+                Width="170"
+                Margin="4"
+                FontWeight="SemiBold"
+                Text="Floating region demo"
+                TextWrapping="Wrap" />
+            <TextBlock
+                Width="170"
+                Margin="4"
+                Text="1. Open LightView or HeavyView.&#x0a;2. Select the tab.&#x0a;3. Float the selected tab."
+                TextWrapping="Wrap" />
+            <Button
+                Padding="8,4"
+                Click="FloatCurrent_Click"
+                Content="Floating: selected TabRegion view" />
+            <TextBlock
+                Width="170"
+                Margin="4"
+                Text="Use Dock to region to restore the tab; closing the window closes it."
+                TextWrapping="Wrap" />
         </StackPanel>
         <ScrollViewer>
             <TabControl
diff --git a/samples/Sample.Wpf/Views/TabRegionView.xaml.cs b/samples/Sample.Wpf/Views/TabRegionView.xaml.cs
index 6dbd290..a85c408 100644
--- a/samples/Sample.Wpf/Views/TabRegionView.xaml.cs
+++ b/samples/Sample.Wpf/Views/TabRegionView.xaml.cs
@@ -1,5 +1,7 @@
 using AsyncNavigation.Abstractions;
 using System.Windows.Controls;
+using AsyncNavigation.Floating;
+using System.Windows;
 
 namespace Sample.Wpf.Views;
 
@@ -8,8 +10,35 @@ namespace Sample.Wpf.Views;
 /// </summary>
 public partial class TabRegionView : UserControl, IView
 {
-    public TabRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public TabRegionView() : this(null)
+    {
+    }
+
+    public TabRegionView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
+
+    private async void FloatCurrent_Click(object sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("TabRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating tab",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            MessageBox.Show(ex.Message, "Cannot float tab", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+    }
 }
diff --git a/src/AsyncNavigation.Avalonia.Floating/AssemblyInfo.cs b/src/AsyncNavigation.Avalonia.Floating/AssemblyInfo.cs
new file mode 100644
index 0000000..1efb7f6
--- /dev/null
+++ b/src/AsyncNavigation.Avalonia.Floating/AssemblyInfo.cs
@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("AsyncNavigation.E2E.Tests")]
diff --git a/src/AsyncNavigation.Avalonia.Floating/AsyncNavigation.Avalonia.Floating.csproj b/src/AsyncNavigation.Avalonia.Floating/AsyncNavigation.Avalonia.Floating.csproj
new file mode 100644
index 0000000..9c561c5
--- /dev/null
+++ b/src/AsyncNavigation.Avalonia.Floating/AsyncNavigation.Avalonia.Floating.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../../package.props" />
+  <PropertyGroup>
+    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\AsyncNavigation.Avalonia\AsyncNavigation.Avalonia.csproj" />
+    <ProjectReference Include="..\AsyncNavigation.Floating\AsyncNavigation.Floating.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs b/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
new file mode 100644
index 0000000..bd31e6a
--- /dev/null
+++ b/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
@@ -0,0 +1,112 @@
+using AsyncNavigation.Floating;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Threading;
+
+namespace AsyncNavigation.Avalonia.Floating;
+
+internal sealed class AvaloniaFloatingWindowHostFactory : IFloatingWindowHostFactory
+{
+    public IFloatingWindowHost Create(FloatingWindowOptions options)
+    {
+        if (!Dispatcher.UIThread.CheckAccess())
+            throw new InvalidOperationException("Floating windows must be created on the Avalonia UI thread.");
+
+        // Classic desktop hosts get a real OS window; everything else (browser/WASM, mobile
+        // single-view apps) has no windowing system, so floating content is rendered as an
+        // in-page overlay panel instead.
+        return Application.Current?.ApplicationLifetime switch
+        {
+            IClassicDesktopStyleApplicationLifetime => new AvaloniaFloatingWindowHost(options),
+            ISingleViewApplicationLifetime { MainView: { } mainView } => new AvaloniaOverlayFloatingWindowHost(options, mainView),
+            ISingleViewApplicationLifetime => throw new InvalidOperationException(
+                "The single-view application lifetime does not have a MainView to host floating content in."),
+            _ => throw new NotSupportedException(
+                "Floating windows require Avalonia's classic desktop or single-view application lifetime.")
+        };
+    }
+}
+
+internal sealed class AvaloniaFloatingWindowHost : IFloatingWindowHost
+{
+    private readonly Window _window;
+    private bool _allowClose;
+    private readonly ContentControl _content = new();
+
+    public AvaloniaFloatingWindowHost(FloatingWindowOptions options)
+    {
+        _window = new Window
+        {
+            Title = options.Title,
+            Topmost = options.Topmost,
+            SizeToContent = options.Width.HasValue || options.Height.HasValue
+                ? SizeToContent.Manual
+                : SizeToContent.WidthAndHeight
+        };
+        if (options.Width.HasValue) _window.Width = options.Width.Value;
+        if (options.Height.HasValue) _window.Height = options.Height.Value;
+        var dockButton = new Button { Content = "Dock to region", Margin = new Thickness(8) };
+        dockButton.Click += (_, _) => RestoreRequested?.Invoke(this, EventArgs.Empty);
+        DockPanel.SetDock(dockButton, Dock.Top);
+        var panel = new DockPanel { LastChildFill = true };
+        panel.Children.Add(dockButton);
+        panel.Children.Add(_content);
+        _window.Content = panel;
+        _window.Closing += OnClosing;
+    }
+
+    public event EventHandler? RestoreRequested;
+    public event EventHandler? CloseRequested;
+
+    public Task SetContentAsync(object? content, CancellationToken cancellationToken = default) =>
+        InvokeAsync(() => _content.Content = content, cancellationToken);
+
+    public Task ShowAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(_window.Show, cancellationToken);
+
+    public Task ActivateAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() => _window.Activate(), cancellationToken);
+
+    public Task CloseAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() =>
+        {
+            _allowClose = true;
+            _window.Close();
+        }, cancellationToken);
+
+    public async ValueTask DisposeAsync()
+    {
+        await InvokeAsync(() =>
+        {
+            _window.Closing -= OnClosing;
+            if (_window.IsVisible)
+            {
+                _allowClose = true;
+                _window.Close();
+            }
+        }, CancellationToken.None);
+    }
+
+    private void OnClosing(object? sender, WindowClosingEventArgs e)
+    {
+        if (_allowClose)
+            return;
+
+        e.Cancel = true;
+        Dispatcher.UIThread.Post(
+            () => CloseRequested?.Invoke(this, EventArgs.Empty),
+            DispatcherPriority.Normal);
+    }
+
+    private async Task InvokeAsync(Action action, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        if (Dispatcher.UIThread.CheckAccess())
+        {
+            action();
+            return;
+        }
+        await Dispatcher.UIThread.InvokeAsync(action);
+    }
+}
diff --git a/src/AsyncNavigation.Avalonia.Floating/AvaloniaOverlayFloatingWindowHost.cs b/src/AsyncNavigation.Avalonia.Floating/AvaloniaOverlayFloatingWindowHost.cs
new file mode 100644
index 0000000..2d156c1
--- /dev/null
+++ b/src/AsyncNavigation.Avalonia.Floating/AvaloniaOverlayFloatingWindowHost.cs
@@ -0,0 +1,220 @@
+using AsyncNavigation.Floating;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Input;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Threading;
+
+namespace AsyncNavigation.Avalonia.Floating;
+
+/// <summary>
+/// Renders a floating "window" as a draggable, resizable in-page overlay panel instead of a
+/// native OS window. Selected automatically for Avalonia's single-view application lifetime
+/// (browser/WASM, mobile), where there is no windowing system to host a real <see cref="Window"/>.
+/// </summary>
+internal sealed class AvaloniaOverlayFloatingWindowHost : IFloatingWindowHost
+{
+    private const double DefaultWidth = 400;
+    private const double DefaultHeight = 300;
+    private const double MinWidth = 200;
+    private const double MinHeight = 120;
+    private const double CascadeStep = 28;
+    private const int CascadeSlots = 10;
+
+    private static int _cascadeIndex;
+    private static int _nextZIndex = 1;
+
+    private readonly Control _mainView;
+    private readonly ContentControl _content = new();
+    private readonly Border _panel;
+
+    private OverlayLayer? _layer;
+    private bool _dragging;
+    private Point _dragStartPointerPosition;
+    private Point _dragStartPanelPosition;
+    private bool _resizing;
+    private Point _resizeStartPointerPosition;
+    private Size _resizeStartSize;
+
+    public AvaloniaOverlayFloatingWindowHost(FloatingWindowOptions options, Control mainView)
+    {
+        _mainView = mainView;
+
+        var titleText = new TextBlock
+        {
+            Text = options.Title,
+            VerticalAlignment = VerticalAlignment.Center,
+            Margin = new Thickness(8, 0, 0, 0),
+            FontWeight = FontWeight.SemiBold
+        };
+
+        var dockButton = new Button { Content = "Dock", Margin = new Thickness(4, 2) };
+        dockButton.Click += (_, _) => RestoreRequested?.Invoke(this, EventArgs.Empty);
+
+        // A plain ASCII glyph, not "✕": the default WASM/browser font set doesn't cover it and
+        // renders tofu instead.
+        var closeButton = new Button { Content = "X", Margin = new Thickness(0, 2, 4, 2) };
+        closeButton.Click += (_, _) => CloseRequested?.Invoke(this, EventArgs.Empty);
+
+        var titleBarButtons = new StackPanel { Orientation = Orientation.Horizontal };
+        titleBarButtons.Children.Add(dockButton);
+        titleBarButtons.Children.Add(closeButton);
+        Grid.SetColumn(titleBarButtons, 1);
+
+        var titleBar = new Grid
+        {
+            ColumnDefinitions = new ColumnDefinitions("*,Auto"),
+            Background = Brushes.Gainsboro,
+            Cursor = new Cursor(StandardCursorType.SizeAll)
+        };
+        titleBar.Children.Add(titleText);
+        titleBar.Children.Add(titleBarButtons);
+        titleBar.PointerPressed += OnTitleBarPointerPressed;
+        titleBar.PointerMoved += OnTitleBarPointerMoved;
+        titleBar.PointerReleased += OnTitleBarPointerReleased;
+        Grid.SetRow(titleBar, 0);
+
+        Grid.SetRow(_content, 1);
+
+        var body = new Grid { RowDefinitions = new RowDefinitions("Auto,*") };
+        body.Children.Add(titleBar);
+        body.Children.Add(_content);
+
+        var resizeGrip = new Border
+        {
+            Width = 14,
+            Height = 14,
+            Background = Brushes.Transparent,
+            Cursor = new Cursor(StandardCursorType.BottomRightCorner),
+            HorizontalAlignment = HorizontalAlignment.Right,
+            VerticalAlignment = VerticalAlignment.Bottom
+        };
+        resizeGrip.PointerPressed += OnResizeGripPointerPressed;
+        resizeGrip.PointerMoved += OnResizeGripPointerMoved;
+        resizeGrip.PointerReleased += OnResizeGripPointerReleased;
+
+        var root = new Grid();
+        root.Children.Add(body);
+        root.Children.Add(resizeGrip);
+
+        _panel = new Border
+        {
+            Width = options.Width ?? DefaultWidth,
+            Height = options.Height ?? DefaultHeight,
+            BorderBrush = Brushes.DimGray,
+            BorderThickness = new Thickness(1),
+            Background = Brushes.White,
+            Child = root
+        };
+    }
+
+    public event EventHandler? RestoreRequested;
+    public event EventHandler? CloseRequested;
+
+    public Task SetContentAsync(object? content, CancellationToken cancellationToken = default) =>
+        InvokeAsync(() => _content.Content = content, cancellationToken);
+
+    public Task ShowAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() =>
+        {
+            var topLevel = TopLevel.GetTopLevel(_mainView)
+                ?? throw new InvalidOperationException(
+                    "Could not resolve a TopLevel for the current view to host floating content in.");
+            _layer = OverlayLayer.GetOverlayLayer(topLevel)
+                ?? throw new InvalidOperationException("Could not find an overlay layer to host floating content in.");
+
+            if (!_layer.Children.Contains(_panel))
+            {
+                var offset = (_cascadeIndex++ % CascadeSlots) * CascadeStep;
+                Canvas.SetLeft(_panel, offset);
+                Canvas.SetTop(_panel, offset);
+                _layer.Children.Add(_panel);
+            }
+            BringToFront();
+        }, cancellationToken);
+
+    public Task ActivateAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() =>
+        {
+            BringToFront();
+            _panel.Focus();
+        }, cancellationToken);
+
+    public Task CloseAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() => _layer?.Children.Remove(_panel), cancellationToken);
+
+    public ValueTask DisposeAsync()
+    {
+        var task = InvokeAsync(() => _layer?.Children.Remove(_panel), CancellationToken.None);
+        return new ValueTask(task);
+    }
+
+    private void BringToFront() => _panel.ZIndex = _nextZIndex++;
+
+    private void OnTitleBarPointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        if (_layer is null || !e.GetCurrentPoint(_panel).Properties.IsLeftButtonPressed) return;
+        _dragging = true;
+        _dragStartPointerPosition = e.GetPosition(_layer);
+        _dragStartPanelPosition = new Point(Canvas.GetLeft(_panel), Canvas.GetTop(_panel));
+        e.Pointer.Capture((IInputElement)sender!);
+        BringToFront();
+        e.Handled = true;
+    }
+
+    private void OnTitleBarPointerMoved(object? sender, PointerEventArgs e)
+    {
+        if (!_dragging || _layer is null) return;
+        var delta = e.GetPosition(_layer) - _dragStartPointerPosition;
+        var maxLeft = Math.Max(0, _layer.Bounds.Width - _panel.Bounds.Width);
+        var maxTop = Math.Max(0, _layer.Bounds.Height - _panel.Bounds.Height);
+        Canvas.SetLeft(_panel, Math.Clamp(_dragStartPanelPosition.X + delta.X, 0, maxLeft));
+        Canvas.SetTop(_panel, Math.Clamp(_dragStartPanelPosition.Y + delta.Y, 0, maxTop));
+    }
+
+    private void OnTitleBarPointerReleased(object? sender, PointerReleasedEventArgs e)
+    {
+        if (!_dragging) return;
+        _dragging = false;
+        e.Pointer.Capture(null);
+    }
+
+    private void OnResizeGripPointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        if (_layer is null || !e.GetCurrentPoint(_panel).Properties.IsLeftButtonPressed) return;
+        _resizing = true;
+        _resizeStartPointerPosition = e.GetPosition(_layer);
+        _resizeStartSize = new Size(_panel.Width, _panel.Height);
+        e.Pointer.Capture((IInputElement)sender!);
+        BringToFront();
+        e.Handled = true;
+    }
+
+    private void OnResizeGripPointerMoved(object? sender, PointerEventArgs e)
+    {
+        if (!_resizing || _layer is null) return;
+        var delta = e.GetPosition(_layer) - _resizeStartPointerPosition;
+        _panel.Width = Math.Max(MinWidth, _resizeStartSize.Width + delta.X);
+        _panel.Height = Math.Max(MinHeight, _resizeStartSize.Height + delta.Y);
+    }
+
+    private void OnResizeGripPointerReleased(object? sender, PointerReleasedEventArgs e)
+    {
+        if (!_resizing) return;
+        _resizing = false;
+        e.Pointer.Capture(null);
+    }
+
+    private static async Task InvokeAsync(Action action, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        if (Dispatcher.UIThread.CheckAccess())
+        {
+            action();
+            return;
+        }
+        await Dispatcher.UIThread.InvokeAsync(action);
+    }
+}
diff --git a/src/AsyncNavigation.Avalonia.Floating/DependencyInjectionExtensions.cs b/src/AsyncNavigation.Avalonia.Floating/DependencyInjectionExtensions.cs
new file mode 100644
index 0000000..8dc3401
--- /dev/null
+++ b/src/AsyncNavigation.Avalonia.Floating/DependencyInjectionExtensions.cs
@@ -0,0 +1,15 @@
+using AsyncNavigation.Avalonia.Floating;
+using AsyncNavigation.Floating;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace Microsoft.Extensions.DependencyInjection;
+
+public static class FloatingDependencyInjectionExtensions
+{
+    public static IServiceCollection AddFloatingSupport(this IServiceCollection services)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+        services.TryAddSingleton<IFloatingWindowHostFactory, AvaloniaFloatingWindowHostFactory>();
+        return services.AddFloatingSupportCore();
+    }
+}
diff --git a/src/AsyncNavigation.Avalonia/ContentRegion.cs b/src/AsyncNavigation.Avalonia/ContentRegion.cs
index b2cd170..2d4bc6f 100644
--- a/src/AsyncNavigation.Avalonia/ContentRegion.cs
+++ b/src/AsyncNavigation.Avalonia/ContentRegion.cs
@@ -1,11 +1,12 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Abstractions;
 using Avalonia.Controls;
 using Avalonia.Controls.Templates;
 using Avalonia.Data;
 
 namespace AsyncNavigation.Avalonia;
 
-public class ContentRegion : RegionBase<ContentRegion, ContentControl>
+public class ContentRegion : RegionBase<ContentRegion, ContentControl>, IRegionPlacementParticipant
 {
     public ContentRegion(string name, 
         ContentControl contentControl, 
@@ -53,7 +54,33 @@ public override Task ProcessActivateAsync(NavigationContext navigationContext)
 
     public override Task ProcessDeactivateAsync(NavigationContext? navigationContext)
     {
-        _context.Selected = null;
+        if (navigationContext is null || ReferenceEquals(_context.Selected, navigationContext))
+            _context.Selected = null;
         return Task.CompletedTask;
     }
+
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = _context.Selected;
+        if (context is null || navigationId.HasValue && context.NavigationId != navigationId.Value)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, 0, true);
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (!ReferenceEquals(_context.Selected, item.Context))
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+        _context.Selected = null;
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Selected is not null)
+            throw new InvalidOperationException($"Region '{Name}' already contains a navigation item.");
+        _context.Selected = item.Context;
+    }
 }
diff --git a/src/AsyncNavigation.Avalonia/InnerIndicatorHost.cs b/src/AsyncNavigation.Avalonia/InnerIndicatorHost.cs
index 1276783..ec4b23a 100644
--- a/src/AsyncNavigation.Avalonia/InnerIndicatorHost.cs
+++ b/src/AsyncNavigation.Avalonia/InnerIndicatorHost.cs
@@ -4,7 +4,7 @@
 
 namespace AsyncNavigation.Avalonia;
 
-internal sealed class InnerIndicatorHost : IInnerRegionIndicatorHost, IInnerIndicatorProvider
+internal sealed class InnerIndicatorHost : IInnerRegionIndicatorHost, IInnerIndicatorProvider, IRegionPlacementContentHost
 {
     private readonly ContentControl _host;
     private readonly IInnerIndicatorProvider _innerIndicatorProvider;
@@ -24,6 +24,22 @@ public InnerIndicatorHost(IServiceProvider serviceProvider)
 
     public object Host => _host;
 
+    object IRegionPlacementContentHost.DetachContent()
+    {
+        var content = _host.Content
+            ?? throw new InvalidOperationException("The region indicator host does not contain a rendered view.");
+        _host.Content = null;
+        return content;
+    }
+
+    void IRegionPlacementContentHost.AttachContent(object content)
+    {
+        ArgumentNullException.ThrowIfNull(content);
+        if (_host.Content is not null)
+            throw new InvalidOperationException("The region indicator host already contains content.");
+        _host.Content = content;
+    }
+
     Task IRegionIndicator.OnCancelledAsync(NavigationContext context)
     {
         _host.Content = null;
diff --git a/src/AsyncNavigation.Avalonia/ItemsRegionBase.cs b/src/AsyncNavigation.Avalonia/ItemsRegionBase.cs
index 1d0327d..cb5146d 100644
--- a/src/AsyncNavigation.Avalonia/ItemsRegionBase.cs
+++ b/src/AsyncNavigation.Avalonia/ItemsRegionBase.cs
@@ -1,4 +1,5 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Abstractions;
 using Avalonia.Controls;
 using Avalonia.Controls.Templates;
 using Avalonia.Data;
@@ -7,7 +8,7 @@
 namespace AsyncNavigation.Avalonia;
 
 public abstract class ItemsRegionBase<TRegion, TItemsControl>
-    : RegionBase<TRegion, TItemsControl>
+    : RegionBase<TRegion, TItemsControl>, IRegionPlacementParticipant
     where TRegion : ItemsRegionBase<TRegion, TItemsControl>
     where TItemsControl : ItemsControl
 {
@@ -71,4 +72,40 @@ public override void Dispose()
         base.Dispose();
         _context.Clear();
     }
+
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = navigationId.HasValue
+            ? _context.Items.FirstOrDefault(item => item.NavigationId == navigationId.Value)
+            : _context.Selected ?? _context.Items.LastOrDefault();
+        if (context is null)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, _context.Items.IndexOf(context),
+            ReferenceEquals(_context.Selected, context));
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        var index = _context.Items.IndexOf(item.Context);
+        if (index < 0)
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+
+        var wasSelected = ReferenceEquals(_context.Selected, item.Context);
+        _context.Items.RemoveAt(index);
+        if (wasSelected)
+            _context.Selected = _context.Items.Count == 0 ? null : _context.Items[Math.Min(index, _context.Items.Count - 1)];
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Items.Contains(item.Context))
+            throw new InvalidOperationException($"The navigation item is already attached to region '{Name}'.");
+
+        _context.Items.Insert(Math.Clamp(item.Index, 0, _context.Items.Count), item.Context);
+        if (activate || item.WasSelected)
+            _context.Selected = item.Context;
+    }
 }
diff --git a/src/AsyncNavigation.Avalonia/TabRegion.cs b/src/AsyncNavigation.Avalonia/TabRegion.cs
index 275a957..74cf21d 100644
--- a/src/AsyncNavigation.Avalonia/TabRegion.cs
+++ b/src/AsyncNavigation.Avalonia/TabRegion.cs
@@ -1,4 +1,5 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Abstractions;
 using Avalonia.Controls;
 using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Templates;
@@ -6,7 +7,7 @@
 
 namespace AsyncNavigation.Avalonia;
 
-public class TabRegion : RegionBase<TabRegion, TabControl>
+public class TabRegion : RegionBase<TabRegion, TabControl>, IRegionPlacementParticipant
 {
     public TabRegion(string name,
         TabControl tabControl,
@@ -67,6 +68,42 @@ public override Task ProcessDeactivateAsync(NavigationContext? navigationContext
         return Task.CompletedTask;
     }
 
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = navigationId.HasValue
+            ? _context.Items.FirstOrDefault(item => item.NavigationId == navigationId.Value)
+            : _context.Selected ?? _context.Items.LastOrDefault();
+
+        if (context is null)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, _context.Items.IndexOf(context), ReferenceEquals(_context.Selected, context));
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        var index = _context.Items.IndexOf(item.Context);
+        if (index < 0)
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+
+        var wasSelected = ReferenceEquals(_context.Selected, item.Context);
+        _context.Items.RemoveAt(index);
+        if (wasSelected)
+            _context.Selected = _context.Items.Count == 0 ? null : _context.Items[Math.Min(index, _context.Items.Count - 1)];
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Items.Contains(item.Context))
+            throw new InvalidOperationException($"The navigation item is already attached to region '{Name}'.");
+
+        _context.Items.Insert(Math.Clamp(item.Index, 0, _context.Items.Count), item.Context);
+        if (activate || item.WasSelected)
+            _context.Selected = item.Context;
+    }
+
 }
 
 
diff --git a/src/AsyncNavigation.Avalonia/TabbedPageRegion.cs b/src/AsyncNavigation.Avalonia/TabbedPageRegion.cs
index 8a7b335..e324526 100644
--- a/src/AsyncNavigation.Avalonia/TabbedPageRegion.cs
+++ b/src/AsyncNavigation.Avalonia/TabbedPageRegion.cs
@@ -7,7 +7,7 @@
 
 namespace AsyncNavigation.Avalonia;
 
-public class TabbedPageRegion : RegionBase<TabbedPageRegion, TabbedPage>
+public class TabbedPageRegion : RegionBase<TabbedPageRegion, TabbedPage>, IRegionPlacementParticipant
 {
     private readonly IIconResolver<Control> _iconResolver;
     public TabbedPageRegion(string name,
@@ -80,4 +80,40 @@ public override Task ProcessDeactivateAsync(NavigationContext? navigationContext
         return Task.CompletedTask;
     }
 
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = navigationId.HasValue
+            ? _context.Items.FirstOrDefault(item => item.NavigationId == navigationId.Value)
+            : _context.Selected ?? _context.Items.LastOrDefault();
+        if (context is null)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, _context.Items.IndexOf(context),
+            ReferenceEquals(_context.Selected, context));
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        var index = _context.Items.IndexOf(item.Context);
+        if (index < 0)
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+
+        var wasSelected = ReferenceEquals(_context.Selected, item.Context);
+        _context.Items.RemoveAt(index);
+        if (wasSelected)
+            _context.Selected = _context.Items.Count == 0 ? null : _context.Items[Math.Min(index, _context.Items.Count - 1)];
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Items.Contains(item.Context))
+            throw new InvalidOperationException($"The navigation item is already attached to region '{Name}'.");
+
+        _context.Items.Insert(Math.Clamp(item.Index, 0, _context.Items.Count), item.Context);
+        if (activate || item.WasSelected)
+            _context.Selected = item.Context;
+    }
+
 }
diff --git a/src/AsyncNavigation.Floating/AsyncNavigation.Floating.csproj b/src/AsyncNavigation.Floating/AsyncNavigation.Floating.csproj
new file mode 100644
index 0000000..8578d28
--- /dev/null
+++ b/src/AsyncNavigation.Floating/AsyncNavigation.Floating.csproj
@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../../package.props" />
+  <PropertyGroup>
+    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\AsyncNavigation\AsyncNavigation.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/AsyncNavigation.Floating/FloatingServiceCollectionExtensions.cs b/src/AsyncNavigation.Floating/FloatingServiceCollectionExtensions.cs
new file mode 100644
index 0000000..69de01b
--- /dev/null
+++ b/src/AsyncNavigation.Floating/FloatingServiceCollectionExtensions.cs
@@ -0,0 +1,17 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using System.ComponentModel;
+
+namespace AsyncNavigation.Floating;
+
+[EditorBrowsable(EditorBrowsableState.Never)]
+public static class FloatingServiceCollectionExtensions
+{
+    public static IServiceCollection AddFloatingSupportCore(this IServiceCollection services)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+        services.TryAddSingleton<ViewPlacementCoordinator>();
+        services.TryAddSingleton<IViewPlacementService, ViewPlacementService>();
+        return services;
+    }
+}
diff --git a/src/AsyncNavigation.Floating/FloatingWindowOptions.cs b/src/AsyncNavigation.Floating/FloatingWindowOptions.cs
new file mode 100644
index 0000000..946d66c
--- /dev/null
+++ b/src/AsyncNavigation.Floating/FloatingWindowOptions.cs
@@ -0,0 +1,17 @@
+namespace AsyncNavigation.Floating;
+
+public sealed class FloatingWindowOptions
+{
+    public string? Title { get; init; }
+    public double? Width { get; init; }
+    public double? Height { get; init; }
+    public bool Topmost { get; init; }
+
+    internal FloatingWindowOptions WithDefaultTitle(string title) => new()
+    {
+        Title = Title ?? title,
+        Width = Width,
+        Height = Height,
+        Topmost = Topmost
+    };
+}
diff --git a/src/AsyncNavigation.Floating/IFloatingViewSession.cs b/src/AsyncNavigation.Floating/IFloatingViewSession.cs
new file mode 100644
index 0000000..92e3ea2
--- /dev/null
+++ b/src/AsyncNavigation.Floating/IFloatingViewSession.cs
@@ -0,0 +1,12 @@
+namespace AsyncNavigation.Floating;
+
+public interface IFloatingViewSession
+{
+    Guid Id { get; }
+    Guid NavigationId { get; }
+    string OriginRegionName { get; }
+    ViewPlacementState State { get; }
+    Task CloseAsync(CancellationToken cancellationToken = default);
+    Task RestoreAsync(CancellationToken cancellationToken = default);
+    Task ActivateAsync(CancellationToken cancellationToken = default);
+}
diff --git a/src/AsyncNavigation.Floating/IFloatingWindowHost.cs b/src/AsyncNavigation.Floating/IFloatingWindowHost.cs
new file mode 100644
index 0000000..9f990d6
--- /dev/null
+++ b/src/AsyncNavigation.Floating/IFloatingWindowHost.cs
@@ -0,0 +1,16 @@
+namespace AsyncNavigation.Floating;
+
+public interface IFloatingWindowHost : IAsyncDisposable
+{
+    event EventHandler? RestoreRequested;
+    event EventHandler? CloseRequested;
+    Task SetContentAsync(object? content, CancellationToken cancellationToken = default);
+    Task ShowAsync(CancellationToken cancellationToken = default);
+    Task ActivateAsync(CancellationToken cancellationToken = default);
+    Task CloseAsync(CancellationToken cancellationToken = default);
+}
+
+public interface IFloatingWindowHostFactory
+{
+    IFloatingWindowHost Create(FloatingWindowOptions options);
+}
diff --git a/src/AsyncNavigation.Floating/IViewPlacementService.cs b/src/AsyncNavigation.Floating/IViewPlacementService.cs
new file mode 100644
index 0000000..1bb001e
--- /dev/null
+++ b/src/AsyncNavigation.Floating/IViewPlacementService.cs
@@ -0,0 +1,10 @@
+namespace AsyncNavigation.Floating;
+
+public interface IViewPlacementService
+{
+    IReadOnlyCollection<IFloatingViewSession> FloatingViews { get; }
+    Task<IFloatingViewSession> FloatAsync(string regionName, Guid? navigationId = null,
+        FloatingWindowOptions? options = null, CancellationToken cancellationToken = default);
+    Task RestoreAsync(Guid sessionId, CancellationToken cancellationToken = default);
+    bool TryGetSession(Guid sessionId, out IFloatingViewSession? session);
+}
diff --git a/src/AsyncNavigation.Floating/ViewPlacementService.cs b/src/AsyncNavigation.Floating/ViewPlacementService.cs
new file mode 100644
index 0000000..ae3dd25
--- /dev/null
+++ b/src/AsyncNavigation.Floating/ViewPlacementService.cs
@@ -0,0 +1,378 @@
+using AsyncNavigation.Abstractions;
+using System.Collections.Concurrent;
+using System.Diagnostics;
+
+namespace AsyncNavigation.Floating;
+
+internal sealed class ViewPlacementService : IViewPlacementService, IDisposable
+{
+    private readonly ViewPlacementCoordinator _placement;
+    private readonly IRegionManager _regionManager;
+    private readonly IFloatingWindowHostFactory _windowFactory;
+    private readonly ConcurrentDictionary<Guid, FloatingViewSession> _sessions = [];
+    private readonly ConcurrentDictionary<Guid, Guid> _sessionsByNavigationId = [];
+
+    public ViewPlacementService(IRegionManager regionManager, IFloatingWindowHostFactory windowFactory, ViewPlacementCoordinator placement)
+    {
+        _placement = placement;
+        _regionManager = regionManager;
+        _windowFactory = windowFactory;
+    }
+
+    public IReadOnlyCollection<IFloatingViewSession> FloatingViews =>
+        _sessions.Values.Cast<IFloatingViewSession>().ToArray();
+
+    public async Task<IFloatingViewSession> FloatAsync(
+        string regionName,
+        Guid? navigationId = null,
+        FloatingWindowOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(regionName);
+        cancellationToken.ThrowIfCancellationRequested();
+        using var lease = await _placement.EnterAsync(regionName, cancellationToken);
+
+        if (navigationId.HasValue &&
+            _sessionsByNavigationId.TryGetValue(navigationId.Value, out var activeSessionId) &&
+            _sessions.TryGetValue(activeSessionId, out var activeSession))
+        {
+            await activeSession.ActivateAsync(cancellationToken);
+            return activeSession;
+        }
+
+        if (!_regionManager.TryGetRegion(regionName, out var region))
+            throw new InvalidOperationException($"Region '{regionName}' was not found.");
+        if (region is not IRegionPlacementParticipant participant)
+            throw new NotSupportedException($"Region '{regionName}' does not support view placement changes.");
+
+        var item = participant.Capture(navigationId);
+        if (_sessionsByNavigationId.TryGetValue(item.Context.NavigationId, out var existingId) &&
+            _sessions.TryGetValue(existingId, out var existing))
+        {
+            await existing.ActivateAsync(cancellationToken);
+            return existing;
+        }
+
+        options = (options ?? new FloatingWindowOptions()).WithDefaultTitle(item.Context.ViewName);
+        var host = _windowFactory.Create(options);
+        var contentOwner = item.Context.IndicatorHost.Value as IRegionPlacementContentHost;
+        var session = new FloatingViewSession(this, Guid.NewGuid(), regionName, region, item, contentOwner, host);
+
+        if (!_sessionsByNavigationId.TryAdd(item.Context.NavigationId, session.Id))
+        {
+            await host.DisposeAsync();
+            if (_sessionsByNavigationId.TryGetValue(item.Context.NavigationId, out var concurrentId) &&
+                _sessions.TryGetValue(concurrentId, out var concurrentSession))
+            {
+                await concurrentSession.ActivateAsync(cancellationToken);
+                return concurrentSession;
+            }
+            throw new InvalidOperationException("Another floating operation is already in progress for this view.");
+        }
+        if (!_sessions.TryAdd(session.Id, session))
+        {
+            _sessionsByNavigationId.TryRemove(item.Context.NavigationId, out _);
+            await host.DisposeAsync();
+            throw new InvalidOperationException("Could not create a floating view session.");
+        }
+
+        host.RestoreRequested += session.OnRestoreRequested;
+        host.CloseRequested += session.OnCloseRequested;
+        var registered = false;
+        var detached = false;
+        var contentDetached = false;
+        try
+        {
+            if (item.Context.Target.Value is { } view)
+            {
+                _placement.Register(view, session.ActivateAsync);
+                registered = true;
+            }
+            var content = contentOwner?.DetachContent() ?? GetContentHost(item);
+            contentDetached = contentOwner is not null;
+            session.SetContent(content);
+            participant.Detach(item);
+            detached = true;
+            await host.SetContentAsync(content, cancellationToken);
+            await host.ShowAsync(cancellationToken);
+            (region as IRegionPlacementNavigation)?.OnViewDetached(item);
+            return session;
+        }
+        catch
+        {
+            if (registered && item.Context.Target.Value is { } view) _placement.Unregister(view);
+            host.RestoreRequested -= session.OnRestoreRequested;
+            host.CloseRequested -= session.OnCloseRequested;
+            _sessions.TryRemove(session.Id, out _);
+            _sessionsByNavigationId.TryRemove(item.Context.NavigationId, out _);
+            try
+            {
+                await host.SetContentAsync(null, CancellationToken.None);
+                if (detached)
+                    participant.Attach(item, activate: false);
+                if (contentDetached)
+                    contentOwner!.AttachContent(session.Content);
+            }
+            finally
+            {
+                await host.DisposeAsync();
+            }
+            throw;
+        }
+    }
+
+    public Task RestoreAsync(Guid sessionId, CancellationToken cancellationToken = default)
+    {
+        if (!_sessions.TryGetValue(sessionId, out var session))
+            throw new KeyNotFoundException($"Floating view session '{sessionId}' was not found.");
+        return session.RestoreAsync(cancellationToken);
+    }
+
+    public bool TryGetSession(Guid sessionId, out IFloatingViewSession? session)
+    {
+        var found = _sessions.TryGetValue(sessionId, out var value);
+        session = value;
+        return found;
+    }
+
+    internal async Task RestoreCoreAsync(FloatingViewSession session, CancellationToken cancellationToken)
+    {
+        using var lease = await _placement.EnterAsync(session.OriginRegionName, cancellationToken);
+        if (!session.OriginRegion.TryGetTarget(out var originalRegion) ||
+            !_regionManager.TryGetRegion(session.OriginRegionName, out var region) ||
+            region is not IRegionPlacementParticipant participant || !ReferenceEquals(region, originalRegion))
+        {
+            throw new InvalidOperationException($"Origin region '{session.OriginRegionName}' is not available.");
+        }
+
+        var contentAttached = false;
+        async Task TransferContent()
+        {
+            await session.Host.SetContentAsync(null, cancellationToken);
+            session.ContentOwner?.AttachContent(session.Content);
+            contentAttached = true;
+        }
+        async Task RollbackContent()
+        {
+            if (contentAttached && session.ContentOwner is not null)
+                session.ContentOwner.DetachContent();
+            await session.Host.SetContentAsync(session.Content, CancellationToken.None);
+        }
+
+        if (region is IRegionPlacementNavigation navigation)
+        {
+            await navigation.RestorePlacementAsync(session.Item, TransferContent, RollbackContent, cancellationToken);
+        }
+        else
+        {
+            var attached = false;
+            try
+            {
+                await TransferContent();
+                participant.Attach(session.Item, activate: false);
+                attached = true;
+            }
+            catch
+            {
+                if (attached) participant.Detach(session.Item);
+                await RollbackContent();
+                throw;
+            }
+        }
+
+        if (session.Item.Context.Target.Value is { } restoredView) _placement.Unregister(restoredView);
+        _sessions.TryRemove(session.Id, out _);
+        _sessionsByNavigationId.TryRemove(session.NavigationId, out _);
+        session.Host.RestoreRequested -= session.OnRestoreRequested;
+        session.Host.CloseRequested -= session.OnCloseRequested;
+        try
+        {
+            await session.Host.CloseAsync(CancellationToken.None);
+            await session.Host.DisposeAsync();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Could not close floating window for '{session.NavigationId}': {ex}");
+        }
+    }
+
+    internal async Task CloseCoreAsync(FloatingViewSession session, CancellationToken cancellationToken)
+    {
+        using var lease = await _placement.EnterAsync(session.OriginRegionName, cancellationToken);
+        await session.Host.SetContentAsync(null, cancellationToken);
+        try
+        {
+            await session.Host.CloseAsync(CancellationToken.None);
+        }
+        catch
+        {
+            await session.Host.SetContentAsync(session.Content, CancellationToken.None);
+            throw;
+        }
+
+        if (session.Item.Context.Target.Value is { } closedView)
+        {
+            _placement.Unregister(closedView);
+            if (session.OriginRegion.TryGetTarget(out var origin))
+                (origin as IRegionPlacementNavigation)?.OnViewClosed(session.Item);
+            DisposeClosedView(closedView);
+        }
+        _sessions.TryRemove(session.Id, out _);
+        _sessionsByNavigationId.TryRemove(session.NavigationId, out _);
+        session.Host.RestoreRequested -= session.OnRestoreRequested;
+        session.Host.CloseRequested -= session.OnCloseRequested;
+        try
+        {
+            await session.Host.DisposeAsync();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Could not dispose floating window for '{session.NavigationId}': {ex}");
+        }
+    }
+
+    private static void DisposeClosedView(IView view)
+    {
+        foreach (var value in new object?[] { view, view.DataContext }.Distinct(ReferenceEqualityComparer.Instance))
+        {
+            try { (value as IDisposable)?.Dispose(); }
+            catch (Exception ex) { Debug.WriteLine($"Could not dispose closed view: {ex}"); }
+        }
+    }
+
+    public void Dispose()
+    {
+        foreach (var session in _sessions.Values)
+        {
+            if (session.Item.Context.Target.Value is { } view) _placement.Unregister(view);
+            session.Host.RestoreRequested -= session.OnRestoreRequested;
+            session.Host.CloseRequested -= session.OnCloseRequested;
+        }
+        _sessions.Clear();
+        _sessionsByNavigationId.Clear();
+    }
+
+    private static object GetContentHost(RegionPlacementItem item)
+    {
+        if (item.Context.IndicatorHost.Value is not { } host)
+            throw new InvalidOperationException("The navigation item does not have an indicator host.");
+        // Reaching here means the host isn't an IRegionPlacementContentHost, so its content
+        // cannot be detached from its current visual parent. Fail fast instead of proceeding
+        // as if detachment succeeded, which would corrupt the visual tree.
+        throw new NotSupportedException(
+            $"Indicator host '{host.GetType()}' does not implement {nameof(IRegionPlacementContentHost)} " +
+            "and cannot be detached for floating placement.");
+    }
+
+    internal sealed class FloatingViewSession : IFloatingViewSession
+    {
+        private readonly ViewPlacementService _owner;
+        private readonly SemaphoreSlim _gate = new(1, 1);
+
+        internal FloatingViewSession(ViewPlacementService owner, Guid id, string originRegionName, IRegion originRegion,
+            RegionPlacementItem item, IRegionPlacementContentHost? contentOwner, IFloatingWindowHost host)
+        {
+            _owner = owner;
+            Id = id;
+            OriginRegionName = originRegionName;
+            OriginRegion = new WeakReference<IRegion>(originRegion);
+            Item = item;
+            ContentOwner = contentOwner;
+            Host = host;
+        }
+
+        public Guid Id { get; }
+        public Guid NavigationId => Item.Context.NavigationId;
+        public string OriginRegionName { get; }
+        public ViewPlacementState State { get; private set; } = ViewPlacementState.Floating;
+        internal WeakReference<IRegion> OriginRegion { get; }
+        internal RegionPlacementItem Item { get; }
+        internal object Content { get; private set; } = null!;
+        internal IRegionPlacementContentHost? ContentOwner { get; }
+        internal IFloatingWindowHost Host { get; }
+
+        internal void SetContent(object content)
+        {
+            if (Content is not null)
+                throw new InvalidOperationException("Floating session content has already been assigned.");
+            Content = content;
+        }
+
+        public async Task RestoreAsync(CancellationToken cancellationToken = default)
+        {
+            await _gate.WaitAsync(cancellationToken);
+            try
+            {
+                if (State is ViewPlacementState.Restored or ViewPlacementState.Closed)
+                    return;
+                State = ViewPlacementState.Restoring;
+                try
+                {
+                    await _owner.RestoreCoreAsync(this, cancellationToken);
+                    State = ViewPlacementState.Restored;
+                }
+                catch
+                {
+                    State = ViewPlacementState.Floating;
+                    throw;
+                }
+            }
+            finally
+            {
+                _gate.Release();
+            }
+        }
+
+        public async Task CloseAsync(CancellationToken cancellationToken = default)
+        {
+            await _gate.WaitAsync(cancellationToken);
+            try
+            {
+                if (State is ViewPlacementState.Restored or ViewPlacementState.Closed)
+                    return;
+                State = ViewPlacementState.Closing;
+                try
+                {
+                    await _owner.CloseCoreAsync(this, cancellationToken);
+                    State = ViewPlacementState.Closed;
+                }
+                catch
+                {
+                    State = ViewPlacementState.Floating;
+                    throw;
+                }
+            }
+            finally
+            {
+                _gate.Release();
+            }
+        }
+
+        internal async void OnCloseRequested(object? sender, EventArgs e)
+        {
+            try
+            {
+                await CloseAsync();
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"Could not close floating view '{NavigationId}': {ex}");
+            }
+        }
+
+        public Task ActivateAsync(CancellationToken cancellationToken = default) =>
+            Host.ActivateAsync(cancellationToken);
+
+        internal async void OnRestoreRequested(object? sender, EventArgs e)
+        {
+            try
+            {
+                await RestoreAsync();
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"Could not restore floating view '{NavigationId}': {ex}");
+            }
+        }
+    }
+}
diff --git a/src/AsyncNavigation.Floating/ViewPlacementState.cs b/src/AsyncNavigation.Floating/ViewPlacementState.cs
new file mode 100644
index 0000000..2a8f14c
--- /dev/null
+++ b/src/AsyncNavigation.Floating/ViewPlacementState.cs
@@ -0,0 +1,10 @@
+namespace AsyncNavigation.Floating;
+
+public enum ViewPlacementState
+{
+    Floating,
+    Restoring,
+    Restored,
+    Closing,
+    Closed
+}
diff --git a/src/AsyncNavigation.Wpf.Floating/AssemblyInfo.cs b/src/AsyncNavigation.Wpf.Floating/AssemblyInfo.cs
new file mode 100644
index 0000000..4c66b87
--- /dev/null
+++ b/src/AsyncNavigation.Wpf.Floating/AssemblyInfo.cs
@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("AsyncNavigation.Wpf.E2E.Tests")]
diff --git a/src/AsyncNavigation.Wpf.Floating/AsyncNavigation.Wpf.Floating.csproj b/src/AsyncNavigation.Wpf.Floating/AsyncNavigation.Wpf.Floating.csproj
new file mode 100644
index 0000000..3ba14a6
--- /dev/null
+++ b/src/AsyncNavigation.Wpf.Floating/AsyncNavigation.Wpf.Floating.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../../package.props" />
+  <PropertyGroup>
+    <TargetFrameworks>net8.0-windows;net10.0-windows</TargetFrameworks>
+    <UseWPF>true</UseWPF>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\AsyncNavigation.Wpf\AsyncNavigation.Wpf.csproj" />
+    <ProjectReference Include="..\AsyncNavigation.Floating\AsyncNavigation.Floating.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/AsyncNavigation.Wpf.Floating/DependencyInjectionExtensions.cs b/src/AsyncNavigation.Wpf.Floating/DependencyInjectionExtensions.cs
new file mode 100644
index 0000000..52de7e6
--- /dev/null
+++ b/src/AsyncNavigation.Wpf.Floating/DependencyInjectionExtensions.cs
@@ -0,0 +1,15 @@
+using AsyncNavigation.Floating;
+using AsyncNavigation.Wpf.Floating;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace Microsoft.Extensions.DependencyInjection;
+
+public static class FloatingDependencyInjectionExtensions
+{
+    public static IServiceCollection AddFloatingSupport(this IServiceCollection services)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+        services.TryAddSingleton<IFloatingWindowHostFactory, WpfFloatingWindowHostFactory>();
+        return services.AddFloatingSupportCore();
+    }
+}
diff --git a/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs b/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs
new file mode 100644
index 0000000..93353f6
--- /dev/null
+++ b/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs
@@ -0,0 +1,101 @@
+using AsyncNavigation.Floating;
+using System.ComponentModel;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Threading;
+
+namespace AsyncNavigation.Wpf.Floating;
+
+internal sealed class WpfFloatingWindowHostFactory : IFloatingWindowHostFactory
+{
+    public IFloatingWindowHost Create(FloatingWindowOptions options)
+    {
+        var application = Application.Current
+            ?? throw new InvalidOperationException("A WPF Application must be running before a floating window can be created.");
+        if (!application.Dispatcher.CheckAccess())
+            throw new InvalidOperationException("Floating windows must be created on the WPF UI thread.");
+        return new WpfFloatingWindowHost(options);
+    }
+}
+
+internal sealed class WpfFloatingWindowHost : IFloatingWindowHost
+{
+    private readonly Window _window;
+    private bool _allowClose;
+    private readonly ContentControl _content = new();
+
+    public WpfFloatingWindowHost(FloatingWindowOptions options)
+    {
+        _window = new Window
+        {
+            Title = options.Title ?? string.Empty,
+            Topmost = options.Topmost,
+            SizeToContent = options.Width.HasValue || options.Height.HasValue
+                ? SizeToContent.Manual
+                : SizeToContent.WidthAndHeight
+        };
+        if (options.Width.HasValue) _window.Width = options.Width.Value;
+        if (options.Height.HasValue) _window.Height = options.Height.Value;
+        var dockButton = new Button { Content = "Dock to region", Margin = new Thickness(8) };
+        dockButton.Click += (_, _) => RestoreRequested?.Invoke(this, EventArgs.Empty);
+        DockPanel.SetDock(dockButton, Dock.Top);
+        var panel = new DockPanel { LastChildFill = true };
+        panel.Children.Add(dockButton);
+        panel.Children.Add(_content);
+        _window.Content = panel;
+        _window.Closing += OnClosing;
+    }
+
+    public event EventHandler? RestoreRequested;
+    public event EventHandler? CloseRequested;
+
+    public Task SetContentAsync(object? content, CancellationToken cancellationToken = default) =>
+        InvokeAsync(() => _content.Content = content, cancellationToken);
+
+    public Task ShowAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(_window.Show, cancellationToken);
+
+    public Task ActivateAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() => _window.Activate(), cancellationToken);
+
+    public Task CloseAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() =>
+        {
+            _allowClose = true;
+            _window.Close();
+        }, cancellationToken);
+
+    public async ValueTask DisposeAsync()
+    {
+        await InvokeAsync(() =>
+        {
+            _window.Closing -= OnClosing;
+            if (_window.IsVisible)
+            {
+                _allowClose = true;
+                _window.Close();
+            }
+        }, CancellationToken.None);
+    }
+
+    private void OnClosing(object? sender, CancelEventArgs e)
+    {
+        if (_allowClose)
+            return;
+        e.Cancel = true;
+        _ = _window.Dispatcher.InvokeAsync(
+            () => CloseRequested?.Invoke(this, EventArgs.Empty),
+            DispatcherPriority.Normal);
+    }
+
+    private Task InvokeAsync(Action action, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        if (_window.Dispatcher.CheckAccess())
+        {
+            action();
+            return Task.CompletedTask;
+        }
+        return _window.Dispatcher.InvokeAsync(action).Task;
+    }
+}
diff --git a/src/AsyncNavigation.Wpf/ContentRegion.cs b/src/AsyncNavigation.Wpf/ContentRegion.cs
index b489fdb..2eda160 100644
--- a/src/AsyncNavigation.Wpf/ContentRegion.cs
+++ b/src/AsyncNavigation.Wpf/ContentRegion.cs
@@ -1,4 +1,5 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Abstractions;
 using System.Diagnostics;
 using System.Windows;
 using System.Windows.Controls;
@@ -6,7 +7,7 @@
 
 namespace AsyncNavigation.Wpf;
 
-public class ContentRegion : RegionBase<ContentRegion, ContentControl>
+public class ContentRegion : RegionBase<ContentRegion, ContentControl>, IRegionPlacementParticipant
 {
     public ContentRegion(string name, 
         ContentControl contentControl, 
@@ -62,7 +63,33 @@ public override Task ProcessActivateAsync(NavigationContext navigationContext)
 
     public override Task ProcessDeactivateAsync(NavigationContext? navigationContext)
     {
-        _context.Selected = null;
+        if (navigationContext is null || ReferenceEquals(_context.Selected, navigationContext))
+            _context.Selected = null;
         return Task.CompletedTask;
     }
+
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = _context.Selected;
+        if (context is null || navigationId.HasValue && context.NavigationId != navigationId.Value)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, 0, true);
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (!ReferenceEquals(_context.Selected, item.Context))
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+        _context.Selected = null;
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Selected is not null)
+            throw new InvalidOperationException($"Region '{Name}' already contains a navigation item.");
+        _context.Selected = item.Context;
+    }
 }
diff --git a/src/AsyncNavigation.Wpf/InnerIndicatorHost.cs b/src/AsyncNavigation.Wpf/InnerIndicatorHost.cs
index 4a5af23..c53cd98 100644
--- a/src/AsyncNavigation.Wpf/InnerIndicatorHost.cs
+++ b/src/AsyncNavigation.Wpf/InnerIndicatorHost.cs
@@ -5,7 +5,7 @@
 
 namespace AsyncNavigation.Wpf;
 
-internal sealed class InnerIndicatorHost : IInnerRegionIndicatorHost, IInnerIndicatorProvider
+internal sealed class InnerIndicatorHost : IInnerRegionIndicatorHost, IInnerIndicatorProvider, IRegionPlacementContentHost
 {
     private readonly ContentControl _host;
     private readonly IInnerIndicatorProvider _innerIndicatorProvider;
@@ -25,6 +25,22 @@ public InnerIndicatorHost(IServiceProvider serviceProvider)
 
     public object Host => _host;
 
+    object IRegionPlacementContentHost.DetachContent()
+    {
+        var content = _host.Content
+            ?? throw new InvalidOperationException("The region indicator host does not contain a rendered view.");
+        _host.Content = null;
+        return content;
+    }
+
+    void IRegionPlacementContentHost.AttachContent(object content)
+    {
+        ArgumentNullException.ThrowIfNull(content);
+        if (_host.Content is not null)
+            throw new InvalidOperationException("The region indicator host already contains content.");
+        _host.Content = content;
+    }
+
     public UIElement GetErrorIndicator(NavigationContext navigationContext)
     {
         return new Grid();
diff --git a/src/AsyncNavigation.Wpf/ItemsRegion.cs b/src/AsyncNavigation.Wpf/ItemsRegion.cs
index 97343a0..693f8af 100644
--- a/src/AsyncNavigation.Wpf/ItemsRegion.cs
+++ b/src/AsyncNavigation.Wpf/ItemsRegion.cs
@@ -1,4 +1,5 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Abstractions;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
@@ -6,7 +7,7 @@
 
 namespace AsyncNavigation.Wpf;
 
-public class ItemsRegion : RegionBase<ItemsRegion, ItemsControl>
+public class ItemsRegion : RegionBase<ItemsRegion, ItemsControl>, IRegionPlacementParticipant
 {
     public ItemsRegion(string name,
         ItemsControl itemsControl, 
@@ -70,4 +71,40 @@ public override Task ProcessDeactivateAsync(NavigationContext? navigationContext
         _ = _context.Items.Remove(target);
         return Task.CompletedTask;
     }
+
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = navigationId.HasValue
+            ? _context.Items.FirstOrDefault(item => item.NavigationId == navigationId.Value)
+            : _context.Selected ?? _context.Items.LastOrDefault();
+        if (context is null)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, _context.Items.IndexOf(context),
+            ReferenceEquals(_context.Selected, context));
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        var index = _context.Items.IndexOf(item.Context);
+        if (index < 0)
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+
+        var wasSelected = ReferenceEquals(_context.Selected, item.Context);
+        _context.Items.RemoveAt(index);
+        if (wasSelected)
+            _context.Selected = _context.Items.Count == 0 ? null : _context.Items[Math.Min(index, _context.Items.Count - 1)];
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Items.Contains(item.Context))
+            throw new InvalidOperationException($"The navigation item is already attached to region '{Name}'.");
+
+        _context.Items.Insert(Math.Clamp(item.Index, 0, _context.Items.Count), item.Context);
+        if (activate || item.WasSelected)
+            _context.Selected = item.Context;
+    }
 }
diff --git a/src/AsyncNavigation.Wpf/TabRegion.cs b/src/AsyncNavigation.Wpf/TabRegion.cs
index 7a22302..5b7018c 100644
--- a/src/AsyncNavigation.Wpf/TabRegion.cs
+++ b/src/AsyncNavigation.Wpf/TabRegion.cs
@@ -1,4 +1,5 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Abstractions;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
@@ -6,7 +7,7 @@
 
 namespace AsyncNavigation.Wpf;
 
-public class TabRegion : RegionBase<TabRegion, TabControl>
+public class TabRegion : RegionBase<TabRegion, TabControl>, IRegionPlacementParticipant
 {
     public TabRegion(string name, 
         TabControl tabControl, 
@@ -72,6 +73,42 @@ public override Task ProcessDeactivateAsync(NavigationContext? navigationContext
         _ = _context.Items.Remove(target);
         return Task.CompletedTask;
     }
+
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = navigationId.HasValue
+            ? _context.Items.FirstOrDefault(item => item.NavigationId == navigationId.Value)
+            : _context.Selected ?? _context.Items.LastOrDefault();
+
+        if (context is null)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, _context.Items.IndexOf(context), ReferenceEquals(_context.Selected, context));
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        var index = _context.Items.IndexOf(item.Context);
+        if (index < 0)
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+
+        var wasSelected = ReferenceEquals(_context.Selected, item.Context);
+        _context.Items.RemoveAt(index);
+        if (wasSelected)
+            _context.Selected = _context.Items.Count == 0 ? null : _context.Items[Math.Min(index, _context.Items.Count - 1)];
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Items.Contains(item.Context))
+            throw new InvalidOperationException($"The navigation item is already attached to region '{Name}'.");
+
+        _context.Items.Insert(Math.Clamp(item.Index, 0, _context.Items.Count), item.Context);
+        if (activate || item.WasSelected)
+            _context.Selected = item.Context;
+    }
 }
 
 
diff --git a/src/AsyncNavigation.slnx b/src/AsyncNavigation.slnx
index b6deaa7..c7f36a2 100644
--- a/src/AsyncNavigation.slnx
+++ b/src/AsyncNavigation.slnx
@@ -36,7 +36,10 @@
     <Project Path="../tests/AsyncNavigation.Tests/AsyncNavigation.Tests.csproj" />
   </Folder>
   <Project Path="AsyncNavigation.Avalonia/AsyncNavigation.Avalonia.csproj" />
+  <Project Path="AsyncNavigation.Avalonia.Floating/AsyncNavigation.Avalonia.Floating.csproj" />
+  <Project Path="AsyncNavigation.Floating/AsyncNavigation.Floating.csproj" />
   <Project Path="AsyncNavigation.WinUI/AsyncNavigation.WinUI.csproj" Id="c655a876-8f02-42e2-b29e-68e893f26170" />
   <Project Path="AsyncNavigation.Wpf/AsyncNavigation.Wpf.csproj" />
+  <Project Path="AsyncNavigation.Wpf.Floating/AsyncNavigation.Wpf.Floating.csproj" />
   <Project Path="AsyncNavigation/AsyncNavigation.csproj" />
 </Solution>
diff --git a/src/AsyncNavigation/Abstractions/INavigationGuard.cs b/src/AsyncNavigation/Abstractions/INavigationGuard.cs
index 4b8e14c..dd51c1d 100644
--- a/src/AsyncNavigation/Abstractions/INavigationGuard.cs
+++ b/src/AsyncNavigation/Abstractions/INavigationGuard.cs
@@ -6,14 +6,14 @@ namespace AsyncNavigation.Abstractions;
 /// navigations away from the current view (e.g., unsaved-changes confirmation).
 /// </summary>
 /// <example>
+/// Add the following members to a view model implementing both
+/// <see cref="INavigationAware"/> and <see cref="INavigationGuard"/>:
 /// <code>
-/// public class EditViewModel : NavigationAwareBase, INavigationGuard
+/// public bool HasUnsavedChanges { get; set; }
+///
+/// public Task&lt;bool&gt; CanNavigateAsync(NavigationContext context, CancellationToken ct)
 /// {
-///     public async Task&lt;bool&gt; CanNavigateAsync(NavigationContext context, CancellationToken ct)
-///     {
-///         if (!HasUnsavedChanges) return true;
-///         return await _dialogService.ConfirmAsync("Discard unsaved changes?", ct);
-///     }
+///     return Task.FromResult(!HasUnsavedChanges);
 /// }
 /// </code>
 /// </example>
diff --git a/src/AsyncNavigation/Abstractions/IRegionNavigationHistory.cs b/src/AsyncNavigation/Abstractions/IRegionNavigationHistory.cs
index c546fe9..0b77f55 100644
--- a/src/AsyncNavigation/Abstractions/IRegionNavigationHistory.cs
+++ b/src/AsyncNavigation/Abstractions/IRegionNavigationHistory.cs
@@ -10,4 +10,5 @@ internal interface IRegionNavigationHistory
     NavigationContext? GoBack();
     NavigationContext? GoForward();
     void Clear();
+    void RemoveView(IView view);
 }
diff --git a/src/AsyncNavigation/Abstractions/IRegionNavigationService.cs b/src/AsyncNavigation/Abstractions/IRegionNavigationService.cs
index 2142e34..30c9841 100644
--- a/src/AsyncNavigation/Abstractions/IRegionNavigationService.cs
+++ b/src/AsyncNavigation/Abstractions/IRegionNavigationService.cs
@@ -2,7 +2,12 @@
 
 internal interface IRegionNavigationService<in T> : IDisposable where T : IRegionPresenter
 {
-    Task RequestNavigateAsync(NavigationContext navigationContext);
+    void SetCurrent(NavigationContext? context);
+    void DetachCurrent(IView? view);
+    void ForgetView(IView view);
+    Task PreparePlacementAsync(NavigationContext context);
+    Task CommitPlacementAsync(NavigationContext context, bool notify);
+    Task RequestNavigateAsync(NavigationContext navigationContext, Action? onCompleted = null, bool coordinatePlacement = true);
     Task OnNavigateFromAsync(NavigationContext navigationContext);
     Task RevertAsync(NavigationContext? navigationContext);
 }
diff --git a/src/AsyncNavigation/Abstractions/IRegionPlacementContentHost.cs b/src/AsyncNavigation/Abstractions/IRegionPlacementContentHost.cs
new file mode 100644
index 0000000..bd65043
--- /dev/null
+++ b/src/AsyncNavigation/Abstractions/IRegionPlacementContentHost.cs
@@ -0,0 +1,12 @@
+namespace AsyncNavigation.Abstractions;
+
+/// <summary>
+/// Allows a region indicator host to temporarily lend its rendered view to
+/// another visual host without resolving or creating the view again.
+/// </summary>
+public interface IRegionPlacementContentHost
+{
+    object DetachContent();
+
+    void AttachContent(object content);
+}
diff --git a/src/AsyncNavigation/Abstractions/IRegionPlacementNavigation.cs b/src/AsyncNavigation/Abstractions/IRegionPlacementNavigation.cs
new file mode 100644
index 0000000..2192431
--- /dev/null
+++ b/src/AsyncNavigation/Abstractions/IRegionPlacementNavigation.cs
@@ -0,0 +1,11 @@
+namespace AsyncNavigation.Abstractions;
+
+/// <summary>Synchronizes placement changes with a region's current view and history.</summary>
+public interface IRegionPlacementNavigation
+{
+    void OnViewDetached(RegionPlacementItem item);
+    void OnViewClosed(RegionPlacementItem item);
+    /// <summary>Transfers an existing view transactionally. The caller must hold the region placement lease.</summary>
+    Task RestorePlacementAsync(RegionPlacementItem item, Func<Task> transferContent,
+        Func<Task> rollbackContent, CancellationToken cancellationToken = default);
+}
diff --git a/src/AsyncNavigation/Abstractions/IRegionPlacementParticipant.cs b/src/AsyncNavigation/Abstractions/IRegionPlacementParticipant.cs
new file mode 100644
index 0000000..24a635b
--- /dev/null
+++ b/src/AsyncNavigation/Abstractions/IRegionPlacementParticipant.cs
@@ -0,0 +1,18 @@
+namespace AsyncNavigation.Abstractions;
+
+/// <summary>
+/// Provides the minimal operations required to temporarily move a rendered
+/// navigation item out of a region and later put it back.
+/// </summary>
+/// <remarks>
+/// These are low-level visual operations. Use IRegionPlacementNavigation to
+/// coordinate a placement change with current-view state and navigation history.
+/// </remarks>
+public interface IRegionPlacementParticipant
+{
+    RegionPlacementItem Capture(Guid? navigationId = null);
+
+    void Detach(RegionPlacementItem item);
+
+    void Attach(RegionPlacementItem item, bool activate = true);
+}
diff --git a/src/AsyncNavigation/Abstractions/IViewPlacementCache.cs b/src/AsyncNavigation/Abstractions/IViewPlacementCache.cs
new file mode 100644
index 0000000..5e39e77
--- /dev/null
+++ b/src/AsyncNavigation/Abstractions/IViewPlacementCache.cs
@@ -0,0 +1,11 @@
+namespace AsyncNavigation.Abstractions;
+
+/// <summary>Optional instance-aware cache operations used by floating navigation.</summary>
+public interface IViewPlacementCache
+{
+    /// <summary>Finds a reusable instance without creating or initializing a view.</summary>
+    Task<IView?> FindCachedViewAsync(string key, Func<IView, Task<bool>> isNavigationTarget);
+
+    /// <summary>Removes entries for exactly this instance without disposing another same-name view.</summary>
+    void RemoveInstance(IView view);
+}
diff --git a/tests/AsyncNavigation.Tests/Infrastructure/NavigationAwareBase.cs b/src/AsyncNavigation/NavigationAwareBase.cs
similarity index 90%
rename from tests/AsyncNavigation.Tests/Infrastructure/NavigationAwareBase.cs
rename to src/AsyncNavigation/NavigationAwareBase.cs
index fa9878e..ed6d6ef 100644
--- a/tests/AsyncNavigation.Tests/Infrastructure/NavigationAwareBase.cs
+++ b/src/AsyncNavigation/NavigationAwareBase.cs
@@ -1,7 +1,7 @@
-using AsyncNavigation.Abstractions;
+using AsyncNavigation.Abstractions;
 using AsyncNavigation.Core;
 
-namespace AsyncNavigation.Tests.Infrastructure;
+namespace AsyncNavigation;
 
 /// <summary>
 /// Abstract base class that provides no-op default implementations of all
@@ -9,6 +9,7 @@ namespace AsyncNavigation.Tests.Infrastructure;
 /// need to override a subset of the navigation lifecycle methods, avoiding the
 /// boilerplate of empty implementations for the rest.
 /// </summary>
+/// <remarks>Retained for compatibility. New view models should implement INavigationAware directly.</remarks>
 /// <example>
 /// <code>
 /// public class HomeViewModel : NavigationAwareBase
@@ -21,6 +22,7 @@ namespace AsyncNavigation.Tests.Infrastructure;
 /// }
 /// </code>
 /// </example>
+[Obsolete("NavigationAwareBase is retained for compatibility. Implement INavigationAware directly instead.", false)]
 public abstract class NavigationAwareBase : INavigationAware
 {
     /// <inheritdoc/>
diff --git a/src/AsyncNavigation/NavigationContext.cs b/src/AsyncNavigation/NavigationContext.cs
index 92b8f86..6ed7e83 100644
--- a/src/AsyncNavigation/NavigationContext.cs
+++ b/src/AsyncNavigation/NavigationContext.cs
@@ -11,6 +11,9 @@ namespace AsyncNavigation;
 /// </summary>
 public partial class NavigationContext
 {
+    internal bool CacheLookupCompleted { get; set; }
+    internal bool ActivatedExternally { get; set; }
+
     private readonly TaskCompletionSource<bool> _completionTcs = new();
     private readonly ConcurrentBag<Exception> _errors = [];
 
diff --git a/src/AsyncNavigation/RegionBase.cs b/src/AsyncNavigation/RegionBase.cs
index 05937da..bdd64e0 100644
--- a/src/AsyncNavigation/RegionBase.cs
+++ b/src/AsyncNavigation/RegionBase.cs
@@ -5,10 +5,11 @@
 
 namespace AsyncNavigation;
 
-public abstract class RegionBase<TRegion, TControl> : IRegion, IRegionPresenter
+public abstract class RegionBase<TRegion, TControl> : IRegion, IRegionPresenter, IRegionPlacementNavigation
     where TRegion : class, IRegionPresenter
     where TControl : class
 {
+    private readonly ViewPlacementCoordinator? _placement;
     private readonly IRegionNavigationService<TRegion> _regionNavigationService;
     private readonly IRegionNavigationHistory _navigationHistory;
     private readonly IRegionControlAccessor<TControl> _controlAccessor;
@@ -17,6 +18,7 @@ public RegionBase(string name, TControl control, IServiceProvider serviceProvide
     {
         ArgumentNullException.ThrowIfNull(control);
         ArgumentNullException.ThrowIfNull(serviceProvider);
+        _placement = serviceProvider.GetService<ViewPlacementCoordinator>();
         Name = name;
         _controlAccessor = new WeakRegionControlAccessor<TControl>(control);
         _regionNavigationService = serviceProvider.GetRequiredService<IRegionNavigationServiceFactory>().Create((this as TRegion)!);
@@ -52,11 +54,15 @@ protected virtual void InitializeOnRegionCreated(TControl control)
     }
     async Task<NavigationResult> IRegion.ActivateViewAsync(NavigationContext navigationContext)
     {
-        await _regionNavigationService.RequestNavigateAsync(navigationContext);
-        _navigationHistory.Add(navigationContext);
-        navigationContext.UpdateStatus(NavigationStatus.Succeeded);
+        await _regionNavigationService.RequestNavigateAsync(navigationContext, () =>
+        {
+            if (!navigationContext.ActivatedExternally)
+                _navigationHistory.Add(navigationContext);
+            navigationContext.UpdateStatus(NavigationStatus.Succeeded);
+        });
         var result = NavigationResult.Success(navigationContext);
-        RaiseNavigated(navigationContext);
+        if (!navigationContext.ActivatedExternally)
+            RaiseNavigated(navigationContext);
         return result;
     }
     Task<bool> IRegion.CanGoBackAsync()
@@ -66,14 +72,26 @@ Task<bool> IRegion.CanGoBackAsync()
 
     public async Task<NavigationResult> GoBackAsync(CancellationToken cancellationToken = default)
     {
+        using var lease = _placement is null ? null : await _placement.EnterAsync(Name, cancellationToken);
         cancellationToken.ThrowIfCancellationRequested();
         var navigationContext = _navigationHistory.GoBack() ?? throw new NavigationException("Cannot go back!");
         navigationContext.IsBackNavigation = true;
         navigationContext.LinkCancellationToken(cancellationToken);
-        await _regionNavigationService.RequestNavigateAsync(navigationContext);
+        try
+        {
+            await _regionNavigationService.RequestNavigateAsync(navigationContext, coordinatePlacement: false);
+        }
+        catch
+        {
+            _navigationHistory.GoForward();
+            throw;
+        }
+        if (navigationContext.ActivatedExternally)
+            _navigationHistory.GoForward();
         navigationContext.UpdateStatus(NavigationStatus.Succeeded);
         var result = NavigationResult.Success(navigationContext);
-        RaiseNavigated(navigationContext);
+        if (!navigationContext.ActivatedExternally)
+            RaiseNavigated(navigationContext);
         return result;
     }
 
@@ -84,14 +102,26 @@ Task<bool> IRegion.CanGoForwardAsync()
 
     public async Task<NavigationResult> GoForwardAsync(CancellationToken cancellationToken = default)
     {
+        using var lease = _placement is null ? null : await _placement.EnterAsync(Name, cancellationToken);
         cancellationToken.ThrowIfCancellationRequested();
         var navigationContext = _navigationHistory.GoForward() ?? throw new NavigationException("Cannot go forward!");
         navigationContext.IsForwardNavigation = true;
         navigationContext.LinkCancellationToken(cancellationToken);
-        await _regionNavigationService.RequestNavigateAsync(navigationContext);
+        try
+        {
+            await _regionNavigationService.RequestNavigateAsync(navigationContext, coordinatePlacement: false);
+        }
+        catch
+        {
+            _navigationHistory.GoBack();
+            throw;
+        }
+        if (navigationContext.ActivatedExternally)
+            _navigationHistory.GoBack();
         navigationContext.UpdateStatus(NavigationStatus.Succeeded);
         var result = NavigationResult.Success(navigationContext);
-        RaiseNavigated(navigationContext);
+        if (!navigationContext.ActivatedExternally)
+            RaiseNavigated(navigationContext);
         return result;
     }
     Task IRegion.NavigateFromAsync(NavigationContext navigationContext)
@@ -109,6 +139,92 @@ Task IRegion.RevertAsync(NavigationContext? navigationContext)
     {
         return _regionNavigationService.RevertAsync(navigationContext);
     }
+    public void OnViewDetached(RegionPlacementItem item)
+    {
+        _regionNavigationService.DetachCurrent(item.Context.Target.Value);
+        // Multi-item regions can select a different view when an item is detached.
+        if (!IsSinglePageRegion && this is IRegionPlacementParticipant participant)
+        {
+            try { _regionNavigationService.SetCurrent(participant.Capture().Context); }
+            catch (InvalidOperationException) { }
+        }
+    }
+
+    public void OnViewClosed(RegionPlacementItem item)
+    {
+        if (item.Context.Target.Value is not { } view) return;
+        _regionNavigationService.ForgetView(view);
+        _navigationHistory.RemoveView(view);
+    }
+
+    public async Task RestorePlacementAsync(RegionPlacementItem item, Func<Task> transferContent,
+        Func<Task> rollbackContent, CancellationToken cancellationToken = default)
+    {
+        if (this is not IRegionPlacementParticipant participant)
+            throw new NotSupportedException("The region does not support placement.");
+        if (_placement is not null && !_placement.IsHeld(Name))
+            throw new InvalidOperationException(
+                $"RestorePlacementAsync for region '{Name}' must be called while holding the region's placement lease.");
+        RegionPlacementItem? previous = null;
+        try { previous = participant.Capture(); }
+        catch (InvalidOperationException) { }
+
+        var context = new NavigationContext
+        {
+            RegionName = Name,
+            ViewName = item.Context.ViewName,
+            Parameters = item.Context.Parameters
+        };
+        context.Target.Value = item.Context.Target.Value!;
+        context.IndicatorHost.Value = item.Context.IndicatorHost.Value!;
+        context.LinkCancellationToken(cancellationToken);
+        var restored = new RegionPlacementItem(context, item.Index, item.WasSelected);
+        var attached = false;
+        var detached = false;
+        var transferred = false;
+        object? displacedContent = null;
+        var sharedHost = previous is not null &&
+            ReferenceEquals(previous.Context.IndicatorHost.Value, item.Context.IndicatorHost.Value)
+            ? previous.Context.IndicatorHost.Value as IRegionPlacementContentHost : null;
+        try
+        {
+            if (previous is not null)
+                await _regionNavigationService.PreparePlacementAsync(context);
+            cancellationToken.ThrowIfCancellationRequested();
+            if (IsSinglePageRegion && previous is not null)
+            {
+                participant.Detach(previous);
+                detached = true;
+                displacedContent = sharedHost?.DetachContent();
+            }
+            transferred = true;
+            await transferContent();
+            // Let the attach honor whether the item was selected/active when it was originally
+            // detached (restored.WasSelected), instead of forcing selection on every restore.
+            participant.Attach(restored, activate: false);
+            attached = true;
+            await _regionNavigationService.CommitPlacementAsync(context, notify: previous is not null);
+            cancellationToken.ThrowIfCancellationRequested();
+            _navigationHistory.Add(context);
+            context.UpdateStatus(NavigationStatus.Succeeded);
+        }
+        catch (Exception ex)
+        {
+            if (attached) participant.Detach(restored);
+            if (transferred) await rollbackContent();
+            if (displacedContent is not null) sharedHost!.AttachContent(displacedContent);
+            if (detached) participant.Attach(previous!);
+            // Attach(restored, activate: false) only disturbed the current selection when the
+            // restored item itself was selected before it was detached; only then does the
+            // Detach(restored) above (which may have picked an unrelated neighbor) need correcting.
+            else if (attached && restored.WasSelected && previous is not null)
+                await ProcessActivateAsync(previous.Context);
+            _regionNavigationService.SetCurrent(previous?.Context);
+            context.UpdateStatus(ex is OperationCanceledException ? NavigationStatus.Cancelled : NavigationStatus.Failed, ex);
+            throw;
+        }
+    }
+
     public virtual void Dispose()
     {
         GC.SuppressFinalize(this);
diff --git a/src/AsyncNavigation/RegionNavigationHistory.cs b/src/AsyncNavigation/RegionNavigationHistory.cs
index 7f1d890..26a0688 100644
--- a/src/AsyncNavigation/RegionNavigationHistory.cs
+++ b/src/AsyncNavigation/RegionNavigationHistory.cs
@@ -58,6 +58,16 @@ public void Add(NavigationContext context)
         return _history[_currentIndex];
     }
 
+    public void RemoveView(IView view)
+    {
+        for (var i = _history.Count - 1; i >= 0; i--)
+        {
+            if (!ReferenceEquals(_history[i].Target.Value, view)) continue;
+            _history.RemoveAt(i);
+            if (i <= _currentIndex) _currentIndex--;
+        }
+    }
+
     public void Clear()
     {
         _history.Clear();
diff --git a/src/AsyncNavigation/RegionNavigationService.cs b/src/AsyncNavigation/RegionNavigationService.cs
index 632b533..91eeae5 100644
--- a/src/AsyncNavigation/RegionNavigationService.cs
+++ b/src/AsyncNavigation/RegionNavigationService.cs
@@ -7,6 +7,7 @@ namespace AsyncNavigation;
 
 internal sealed class RegionNavigationService<T> : IRegionNavigationService<T> where T : IRegionPresenter
 {
+    private readonly ViewPlacementCoordinator? _placement;
     private readonly IViewManager _viewCacheManager;
     private readonly IRegionIndicatorManager _regionIndicatorManager;
     private readonly IAsyncJobProcessor _navigationJobScheduler;
@@ -15,6 +16,7 @@ internal sealed class RegionNavigationService<T> : IRegionNavigationService<T> w
     private readonly NavigationJobStrategy _navigationJobStrategy;
     public RegionNavigationService(T regionPresenter, IServiceProvider serviceProvider)
     {
+        _placement = serviceProvider.GetService<ViewPlacementCoordinator>();
         _regionPresenter = regionPresenter;
         _navigationJobScheduler = serviceProvider.GetRequiredService<IAsyncJobProcessor>();
         _viewCacheManager = serviceProvider.GetRequiredService<IViewManager>();
@@ -25,20 +27,25 @@ public RegionNavigationService(T regionPresenter, IServiceProvider serviceProvid
     {
         get => _current;
     }
-    public async Task RequestNavigateAsync(NavigationContext navigationContext)
+    public async Task RequestNavigateAsync(NavigationContext navigationContext, Action? onCompleted = null, bool coordinatePlacement = true)
     {
+        navigationContext.ActivatedExternally = false;
         try
         {
-            await _navigationJobScheduler.RunJobAsync(navigationContext, CreateNavigateTask, _navigationJobStrategy);
+            await _navigationJobScheduler.RunJobAsync(navigationContext, async context =>
+            {
+                using var lease = !coordinatePlacement || _placement is null ? null :
+                    await _placement.EnterAsync(context.RegionName, context.CancellationToken);
+                await CreateNavigateTask(context);
+                onCompleted?.Invoke();
+            }, _navigationJobStrategy);
         }
         catch (Exception ex) when (ex is not OperationCanceledException)
         {
-            await _regionIndicatorManager.ShowErrorAsync(navigationContext, ex);
+            if (navigationContext.IndicatorHost.IsSet)
+                await _regionIndicatorManager.ShowErrorAsync(navigationContext, ex);
             throw;
         }
-        finally
-        {
-        }
     }
 
     public Task OnNavigateFromAsync(NavigationContext navigationContext)
@@ -58,6 +65,32 @@ public Task RevertAsync(NavigationContext? navigationContext)
             return _regionPresenter.ProcessDeactivateAsync(navigationContext);
         }
     }
+    public void SetCurrent(NavigationContext? context) =>
+        _current = context?.Target.Value is { } view ? (view, context) : null;
+
+    public void DetachCurrent(IView? view)
+    {
+        if (Current.HasValue && ReferenceEquals(Current.Value.View, view))
+            _current = null;
+    }
+
+    public void ForgetView(IView view)
+    {
+        DetachCurrent(view);
+        (_viewCacheManager as IViewPlacementCache)?.RemoveInstance(view);
+    }
+
+    public Task PreparePlacementAsync(NavigationContext context) => OnBeforeNavigationAsync(context);
+    public async Task CommitPlacementAsync(NavigationContext context, bool notify)
+    {
+        if (notify) await OnAfterNavigationAsync(context);
+        else
+        {
+            SubscribeUnload(context);
+            SetCurrent(context);
+        }
+    }
+
     public void Dispose()
     {
         try
@@ -74,7 +107,30 @@ public void Dispose()
     private async Task CreateNavigateTask(NavigationContext navigationContext)
     {
         var isSinglePageRegion = _regionPresenter!.IsSinglePageRegion;
+        // Set up the indicator host up front so it is always available - even if the
+        // fast path below (cache lookup / TryActivateAsync) throws or short-circuits -
+        // so a failed navigation can still show an error and a successful NavigationResult
+        // always carries a usable IndicatorHost.
         _regionIndicatorManager.Setup(navigationContext, isSinglePageRegion);
+        if (_placement is not null)
+        {
+            // Inspect reusable instances before leaving or rendering the current region.
+            // New views still initialize in the normal pipeline, after the leave guard.
+            if (!navigationContext.Target.IsSet && _regionPresenter.EnableViewCache &&
+                _viewCacheManager is IViewPlacementCache cache)
+            {
+                var cached = await cache.FindCachedViewAsync(navigationContext.ViewName,
+                    view => HandleIsNavigationTargetAsync(view, navigationContext));
+                navigationContext.CacheLookupCompleted = true;
+                if (cached is not null) navigationContext.Target.Value = cached;
+            }
+            if (navigationContext.Target.IsSet && navigationContext.Target.Value is { } target &&
+                await _placement.TryActivateAsync(target, navigationContext.CancellationToken))
+            {
+                navigationContext.ActivatedExternally = true;
+                return;
+            }
+        }
 
         var navigationTask = RunNavigationAsync(navigationContext, _regionPresenter.NavigationPipelineMode);
 
@@ -121,7 +177,7 @@ private async Task OnResolveViewAsync(NavigationContext navigationContext)
             return;
         }
         var view = await _viewCacheManager.ResolveViewAsync(navigationContext.ViewName,
-                                _regionPresenter.EnableViewCache,
+                                _regionPresenter.EnableViewCache && !navigationContext.CacheLookupCompleted,
                                 view => RegionNavigationService<T>.HandleIsNavigationTargetAsync(view, navigationContext),
                                 view => RegionNavigationService<T>.HandleInitializeAsync(view, navigationContext));
         navigationContext.CancellationToken.ThrowIfCancellationRequested();
@@ -157,24 +213,32 @@ private async Task OnAfterNavigationAsync(NavigationContext navigationContext)
     {
         if (navigationContext.TryResolveViewAndAware(out var view,out var aware))
         {
-            var contextSnapshot = navigationContext;
-            WeakUnloadObserver.Subscribe(aware,async a =>
-            {
-                if (Current.HasValue)
-                {
-                    if (ReferenceEquals(Current.Value.View.DataContext, a))
-                        _current = null;
-                }
-
-                await _regionPresenter.ProcessDeactivateAsync(contextSnapshot);
-            });
+            SubscribeUnload(navigationContext);
             await aware.OnNavigatedToAsync(navigationContext);
             navigationContext.CancellationToken.ThrowIfCancellationRequested();
             _current = (view, navigationContext);
         }
+        if (navigationContext.Target.Value is { } target)
+            _current = (target, navigationContext);
         navigationContext.CancellationToken.ThrowIfCancellationRequested();
     }
 
+    private void SubscribeUnload(NavigationContext navigationContext)
+    {
+        if (!navigationContext.TryResolveNavigationAware(out var aware)) return;
+        var contextSnapshot = navigationContext;
+        WeakUnloadObserver.Subscribe(aware,async a =>
+        {
+            if (Current.HasValue)
+            {
+                if (ReferenceEquals(Current.Value.View.DataContext, a))
+                    _current = null;
+            }
+
+            await _regionPresenter.ProcessDeactivateAsync(contextSnapshot);
+        });
+    }
+
     private static Task<bool> HandleIsNavigationTargetAsync(IView view, NavigationContext navigationContext)
     {
         navigationContext.CancellationToken.ThrowIfCancellationRequested();
diff --git a/src/AsyncNavigation/RegionPlacementItem.cs b/src/AsyncNavigation/RegionPlacementItem.cs
new file mode 100644
index 0000000..26dbe1a
--- /dev/null
+++ b/src/AsyncNavigation/RegionPlacementItem.cs
@@ -0,0 +1,21 @@
+namespace AsyncNavigation;
+
+/// <summary>
+/// Describes a rendered navigation item and its original position in a region.
+/// </summary>
+public sealed class RegionPlacementItem
+{
+    public RegionPlacementItem(NavigationContext context, int index, bool wasSelected)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+        Context = context;
+        Index = index;
+        WasSelected = wasSelected;
+    }
+
+    public NavigationContext Context { get; }
+
+    public int Index { get; }
+
+    public bool WasSelected { get; }
+}
diff --git a/src/AsyncNavigation/ViewManager.cs b/src/AsyncNavigation/ViewManager.cs
index 875abf4..ec21bd9 100644
--- a/src/AsyncNavigation/ViewManager.cs
+++ b/src/AsyncNavigation/ViewManager.cs
@@ -5,7 +5,7 @@
 
 namespace AsyncNavigation;
 
-internal sealed class ViewManager : IViewManager
+internal sealed class ViewManager : IViewManager, IViewPlacementCache
 {
     private readonly ConcurrentDictionary<string, WeakReference<IView>> _viewCache = new();
     private readonly LinkedList<string> _lruList = [];
@@ -14,9 +14,11 @@ internal sealed class ViewManager : IViewManager
     private readonly ViewCacheStrategy _strategy;
     private readonly int _maxCacheSize;
     private readonly IViewFactory _viewFactory;
+    private readonly ViewPlacementCoordinator? _placement;
 
-    public ViewManager(NavigationOptions options, IViewFactory viewFactory)
+    public ViewManager(NavigationOptions options, IViewFactory viewFactory, ViewPlacementCoordinator? placement = null)
     {
+        _placement = placement;
         _strategy = options.ViewCacheStrategy;
 #pragma warning disable CS0618 // MaxCachedViews is obsolete but still used internally for view cache size
         _maxCacheSize = options.MaxCachedViews;
@@ -26,22 +28,40 @@ public ViewManager(NavigationOptions options, IViewFactory viewFactory)
 
     public void Clear()
     {
-        var values = _viewCache.Values.ToArray();
-        _viewCache.Clear();
+        var removedViews = new List<IView>();
+        // Remove all eligible entries before invoking user disposal code. A throwing
+        // Dispose must not leave unrelated old entries available for reuse.
         lock (_lruLock)
         {
-            _lruList.Clear();
-            _lruIndex.Clear();
+            foreach (var entry in _viewCache.ToArray())
+            {
+                entry.Value.TryGetTarget(out var view);
+                if (view is not null && _placement?.IsFloating(view) == true)
+                    continue;
+                if (!((ICollection<KeyValuePair<string, WeakReference<IView>>>)_viewCache).Remove(entry))
+                    continue;
+                if (_lruIndex.Remove(entry.Key, out var node))
+                    _lruList.Remove(node);
+                if (view is not null)
+                    removedViews.Add(view);
+            }
         }
 
-        foreach (var viewRef in values)
+        foreach (var view in removedViews)
+            DisposeView(view);
+    }
+
+    public async Task<IView?> FindCachedViewAsync(string key, Func<IView, Task<bool>> isNavigationTarget)
+    {
+        if (_viewCache.TryGetValue(key, out var reference) &&
+            reference.TryGetTarget(out var view) && await isNavigationTarget(view))
         {
-            if (viewRef.TryGetTarget(out var view))
-            {
-                DisposeView(view);
-            }
+            Touch(key);
+            return view;
         }
+        return null;
     }
+
     public async Task<IView> ResolveViewAsync(string key,
         bool useCache,
         Func<IView, Task<bool>>? isNavigationTarget = null,
@@ -82,6 +102,8 @@ public async Task<IView> ResolveViewAsync(string key,
 
     public void Remove(string cacheKey, bool dispose = false)
     {
+        if (_viewCache.TryGetValue(cacheKey, out var pinned) &&
+            pinned.TryGetTarget(out var active) && _placement?.IsFloating(active) == true) return;
         if (_viewCache.TryRemove(cacheKey, out var viewRef))
         {
             lock (_lruLock)
@@ -100,6 +122,15 @@ public void Remove(string cacheKey, bool dispose = false)
         }
     }
 
+    public void RemoveInstance(IView view)
+    {
+        foreach (var entry in _viewCache)
+        {
+            if (entry.Value.TryGetTarget(out var cached) && ReferenceEquals(cached, view))
+                Remove(entry.Key);
+        }
+    }
+
     public void AddView(string cacheKey, IView view)
     {
         if (_strategy == ViewCacheStrategy.UpdateDuplicateKey)
@@ -118,7 +149,7 @@ public void AddView(string cacheKey, IView view)
             }
         }
 
-        TrimCache();
+        TrimCache(cacheKey);
     }
 
     private void AddToLru(string key)
@@ -136,19 +167,26 @@ private void AddToLru(string key)
 
     private void Touch(string key) => AddToLru(key);
 
-    private void TrimCache()
+    private void TrimCache(string protectedKey)
     {
         while (_viewCache.Count > _maxCacheSize)
         {
             string? oldestKey = null;
             lock (_lruLock)
             {
-                if (_lruList.Last != null)
+                var node = _lruList.Last;
+                while (node is not null)
                 {
-                    oldestKey = _lruList.Last.Value;
-                    _lruIndex.Remove(oldestKey);
-                    _lruList.RemoveLast();
+                    if (node.Value != protectedKey &&
+                        (!_viewCache.TryGetValue(node.Value, out var candidate) ||
+                         !candidate.TryGetTarget(out var view) || _placement?.IsFloating(view) != true))
+                        break;
+                    node = node.Previous;
                 }
+                if (node is null) break; // Active windows are pinned, even above the cache limit.
+                oldestKey = node.Value;
+                _lruIndex.Remove(oldestKey);
+                _lruList.Remove(node);
             }
 
             if (oldestKey != null && _viewCache.TryRemove(oldestKey, out var viewRef))
@@ -166,8 +204,9 @@ public void Dispose()
         Clear();
     }
 
-    private static void DisposeView(IView view)
+    private void DisposeView(IView view)
     {
+        if (_placement?.IsFloating(view) == true) return;
         SafeDispose(view, nameof(view));
         SafeDispose(view.DataContext, nameof(view.DataContext));
     }
@@ -182,7 +221,7 @@ private static void SafeDispose(object? obj, string name)
             }
             catch (Exception ex)
             {
-                Debug.Fail($"Dispose {name} error.", ex.ToString());
+                Debug.WriteLine($"Dispose {name} error: {ex}");
                 throw;
             }
         }
diff --git a/src/AsyncNavigation/ViewPlacementCoordinator.cs b/src/AsyncNavigation/ViewPlacementCoordinator.cs
new file mode 100644
index 0000000..b75bf9c
--- /dev/null
+++ b/src/AsyncNavigation/ViewPlacementCoordinator.cs
@@ -0,0 +1,95 @@
+using AsyncNavigation.Abstractions;
+using System.Collections.Concurrent;
+
+namespace AsyncNavigation;
+
+/// <summary>Coordinates navigation and window placement by region and view instance.</summary>
+public sealed class ViewPlacementCoordinator
+{
+    private readonly ConcurrentDictionary<string, RegionGate> _gates = new();
+    private readonly ConcurrentDictionary<IView, Func<CancellationToken, Task>> _floating = new(ReferenceEqualityComparer.Instance);
+
+    /// <summary>
+    /// Acquires the placement lease for a region. Reentrant within the same logical async
+    /// call chain: code that already holds the lease (e.g. a navigation callback that in turn
+    /// triggers a placement change on the same region) re-enters immediately instead of
+    /// deadlocking against itself.
+    /// </summary>
+    /// <remarks>
+    /// Deliberately not an `async` method: AsyncLocal writes made inside an async method are
+    /// invisible to its caller once it returns (the compiler-generated state machine restores
+    /// the caller's captured ExecutionContext), even when the method never actually suspends.
+    /// The uncontended/reentrant fast paths below write <see cref="RegionGate.Depth"/> directly
+    /// in this plain method body so the mark stays visible to the caller's subsequent code -
+    /// which is what lets a nested re-entry on the same region see it. Only the genuinely
+    /// contended wait is delegated to an async helper, where that guarantee no longer holds.
+    /// </remarks>
+    public Task<IDisposable> EnterAsync(string regionName, CancellationToken cancellationToken = default)
+    {
+        var gate = _gates.GetOrAdd(regionName, _ => new RegionGate());
+        if (gate.Depth.Value > 0)
+        {
+            gate.Depth.Value++;
+            return Task.FromResult<IDisposable>(new Lease(gate, reentrant: true));
+        }
+
+        var wait = gate.Semaphore.WaitAsync(cancellationToken);
+        if (wait.IsCompletedSuccessfully)
+        {
+            gate.Depth.Value = 1;
+            return Task.FromResult<IDisposable>(new Lease(gate, reentrant: false));
+        }
+        return EnterSlowAsync(gate, wait);
+    }
+
+    private static async Task<IDisposable> EnterSlowAsync(RegionGate gate, Task wait)
+    {
+        await wait;
+        gate.Depth.Value = 1;
+        return new Lease(gate, reentrant: false);
+    }
+
+    /// <summary>Returns whether the current logical async call chain already holds the placement lease for the region.</summary>
+    public bool IsHeld(string regionName) =>
+        _gates.TryGetValue(regionName, out var gate) && gate.Depth.Value > 0;
+
+    public bool IsFloating(IView view) => _floating.ContainsKey(view);
+
+    public void Register(IView view, Func<CancellationToken, Task> activate)
+    {
+        if (!_floating.TryAdd(view, activate))
+            throw new InvalidOperationException("The view instance is already floating.");
+    }
+
+    public void Unregister(IView view) => _floating.TryRemove(view, out _);
+
+    public async Task<bool> TryActivateAsync(IView view, CancellationToken cancellationToken)
+    {
+        if (!_floating.TryGetValue(view, out var activate)) return false;
+        await activate(cancellationToken);
+        return true;
+    }
+
+    private sealed class RegionGate
+    {
+        public readonly SemaphoreSlim Semaphore = new(1, 1);
+        public readonly AsyncLocal<int> Depth = new();
+    }
+
+    private sealed class Lease(RegionGate gate, bool reentrant) : IDisposable
+    {
+        private RegionGate? _gate = gate;
+        public void Dispose()
+        {
+            var g = Interlocked.Exchange(ref _gate, null);
+            if (g is null) return;
+            if (reentrant)
+                g.Depth.Value--;
+            else
+            {
+                g.Depth.Value = 0;
+                g.Semaphore.Release();
+            }
+        }
+    }
+}
diff --git a/src/AsyncNavigation/WeakUnloadObserver.cs b/src/AsyncNavigation/WeakUnloadObserver.cs
index b548f32..685cdb5 100644
--- a/src/AsyncNavigation/WeakUnloadObserver.cs
+++ b/src/AsyncNavigation/WeakUnloadObserver.cs
@@ -1,5 +1,6 @@
-using AsyncNavigation.Abstractions;
+using AsyncNavigation.Abstractions;
 using AsyncNavigation.Core;
+using System.Runtime.CompilerServices;
 
 namespace AsyncNavigation;
 
@@ -9,8 +10,19 @@ namespace AsyncNavigation;
 /// </summary>
 internal sealed class WeakUnloadObserver
 {
+    // Tracks the currently-subscribed handler per instance so re-subscribing the same
+    // INavigationAware (e.g. after floating and docking a view back) replaces the previous
+    // handler instead of stacking a second one that would fire alongside it.
+    private static readonly ConditionalWeakTable<INavigationAware, AsyncEventHandler<AsyncEventArgs>> _subscriptions = new();
+
     public static void Subscribe(INavigationAware navigationAware, Action<INavigationAware> onUnloadCallback)
     {
+        if (_subscriptions.TryGetValue(navigationAware, out var previousHandler))
+        {
+            navigationAware.AsyncRequestUnloadEvent -= previousHandler;
+            _subscriptions.Remove(navigationAware);
+        }
+
         var weakReference = new WeakReference<INavigationAware>(navigationAware);
 
         async Task HandleRequestUnloadAsync(object? sender, AsyncEventArgs args)
@@ -28,7 +40,7 @@ async Task HandleRequestUnloadAsync(object? sender, AsyncEventArgs args)
             onUnloadCallback?.Invoke(target);
         }
 
+        _subscriptions.Add(navigationAware, HandleRequestUnloadAsync);
         navigationAware.AsyncRequestUnloadEvent += HandleRequestUnloadAsync;
     }
 }
-
diff --git a/tests/AsyncNavigation.E2E.Tests/App.axaml b/tests/AsyncNavigation.E2E.Tests/App.axaml
index c150098..d8633f0 100644
--- a/tests/AsyncNavigation.E2E.Tests/App.axaml
+++ b/tests/AsyncNavigation.E2E.Tests/App.axaml
@@ -2,5 +2,6 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              x:Class="AsyncNavigation.E2E.Tests.App">
 	<Application.Styles>
+        <FluentTheme />
 	</Application.Styles>
 </Application>
\ No newline at end of file
diff --git a/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj b/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
index b890028..def97ef 100644
--- a/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
+++ b/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
@@ -1,24 +1,30 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0-windows</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <OutputType>Exe</OutputType>
 
     <IsPackable>false</IsPackable>
     <IsTestProject>true</IsTestProject>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Avalonia.Headless.XUnit" Version="11.3.6" />
+    <PackageReference Include="Avalonia.Themes.Fluent" Version="12.0.0" />
+    <PackageReference Include="Avalonia.Headless.XUnit" Version="12.0.0" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Include="xunit" Version="2.5.3" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.6" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.4.0" />
+    <PackageReference Include="xunit.v3" Version="3.2.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\AsyncNavigation.Avalonia\AsyncNavigation.Avalonia.csproj" />
+    <ProjectReference Include="..\..\src\AsyncNavigation.Avalonia.Floating\AsyncNavigation.Avalonia.Floating.csproj" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/AsyncNavigation.E2E.Tests/FloatingNavigationTests.cs b/tests/AsyncNavigation.E2E.Tests/FloatingNavigationTests.cs
new file mode 100644
index 0000000..48c6ab6
--- /dev/null
+++ b/tests/AsyncNavigation.E2E.Tests/FloatingNavigationTests.cs
@@ -0,0 +1,113 @@
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Core;
+using AsyncNavigation.Floating;
+using Microsoft.Extensions.DependencyInjection;
+using AsyncNavigation.Avalonia.Floating;
+using Avalonia.Controls;
+using Avalonia.Headless.XUnit;
+using Avalonia.Threading;
+using ControlType = Avalonia.Controls.Control;
+using PlatformContentRegion = AsyncNavigation.Avalonia.ContentRegion;
+using PlatformTabRegion = AsyncNavigation.Avalonia.TabRegion;
+namespace AsyncNavigation.E2E.Tests;
+
+public sealed class FloatingNavigationTests
+{
+    [AvaloniaTheory]
+    [InlineData(false, false)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(true, true)]
+    public Task Floating_navigation_and_docking_preserve_instance_ownership(bool createNew, bool tabs) =>
+        VerifyNavigationAndDock(createNew, tabs);
+    private static async Task VerifyNavigationAndDock(bool createNew, bool tabs)
+    {
+        var services = new ServiceCollection().AddNavigationSupport().AddFloatingSupportCore();
+        services.RegisterView<TestView, Model>("A");
+        services.RegisterView<TestView, Model>("B");
+        services.AddSingleton<IFloatingWindowHostFactory, WindowFactory>();
+        using var provider = services.BuildServiceProvider();
+        var manager = provider.GetRequiredService<IRegionManager>();
+        var placement = provider.GetRequiredService<IViewPlacementService>();
+        var control = tabs ? (ControlType)new TabControl() : new ContentControl();
+        IRegion region = tabs
+            ? new PlatformTabRegion("main", (TabControl)control, provider, true)
+            : new PlatformContentRegion("main", (ContentControl)control, provider, true);
+        manager.AddRegion("main", region);
+        var window = new Window { Content = control, Width = 500, Height = 400 };
+        window.Show();
+        try
+        {
+            var first = await manager.RequestNavigateAsync("main", "A");
+            Assert.True(first.IsSuccessful, first.Exception?.ToString());
+            var a1 = (TestView)first.NavigationContext!.Target.Value!;
+            var session = await placement.FloatAsync("main");
+            var floatingWindow = TopLevel.GetTopLevel(a1) as Window;
+            Assert.NotNull(floatingWindow);
+            Assert.NotSame(window, floatingWindow);
+            var next = await manager.RequestNavigateAsync("main", "B");
+            Assert.True(next.IsSuccessful, next.Exception?.ToString());
+            var b = next.NavigationContext!.Target.Value;
+            var selected = ((IRegionPlacementParticipant)region).Capture().Context;
+
+            if (createNew)
+            {
+                ((Model)a1.DataContext!).Reuse = false;
+                var newA = await manager.RequestNavigateAsync("main", "A");
+                Assert.True(newA.IsSuccessful, newA.Exception?.ToString());
+                Assert.NotSame(a1, newA.NavigationContext!.Target.Value);
+            }
+            else
+            {
+                var reused = await manager.RequestNavigateAsync("main", "A");
+                Assert.True(reused.IsSuccessful, reused.Exception?.ToString());
+                Assert.Same(a1, reused.NavigationContext!.Target.Value);
+                Assert.Same(selected, ((IRegionPlacementParticipant)region).Capture().Context);
+                Assert.Same(floatingWindow, TopLevel.GetTopLevel(a1) as Window);
+            }
+
+            await session.RestoreAsync();
+            Dispatcher.UIThread.RunJobs();
+            Assert.Equal(ViewPlacementState.Restored, session.State);
+            Assert.False(floatingWindow!.IsVisible);
+            Assert.Same(a1, ((IRegionPlacementParticipant)region).Capture().Context.Target.Value);
+            Assert.Same(window, TopLevel.GetTopLevel(a1) as Window);
+            Assert.Equal(1, ((Model)a1.DataContext!).Initializations);
+            if (tabs)
+                Assert.Equal(createNew ? 3 : 2, ((TabControl)control).Items.Count);
+            else
+            {
+                var back = await manager.GoBackAsync("main");
+                Assert.True(back.IsSuccessful, back.Exception?.ToString());
+                Assert.NotSame(a1, ((IRegionPlacementParticipant)region).Capture().Context.Target.Value);
+            }
+        }
+        finally
+        {
+            foreach (var session in placement.FloatingViews.ToArray()) await session.CloseAsync();
+            window.Close();
+        }
+    }
+
+    public sealed class TestView : UserControl, IView
+    {
+        public TestView() => Content = new TextBox { Text = "state survives docking" };
+    }
+
+    public sealed class Model : INavigationAware
+    {
+        public bool Reuse { get; set; } = true;
+        public int Initializations { get; private set; }
+        public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+        public Task InitializeAsync(NavigationContext context) { Initializations++; return Task.CompletedTask; }
+        public Task OnNavigatedToAsync(NavigationContext context) => Task.CompletedTask;
+        public Task OnNavigatedFromAsync(NavigationContext context) => Task.CompletedTask;
+        public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(Reuse);
+        public Task OnUnloadAsync(CancellationToken token) => Task.CompletedTask;
+    }
+
+    private sealed class WindowFactory : IFloatingWindowHostFactory
+    {
+        public IFloatingWindowHost Create(FloatingWindowOptions options) => new AvaloniaFloatingWindowHost(options);
+    }
+}
diff --git a/tests/AsyncNavigation.E2E.Tests/FloatingOverlayWindowTests.cs b/tests/AsyncNavigation.E2E.Tests/FloatingOverlayWindowTests.cs
new file mode 100644
index 0000000..7ec8eab
--- /dev/null
+++ b/tests/AsyncNavigation.E2E.Tests/FloatingOverlayWindowTests.cs
@@ -0,0 +1,72 @@
+using AsyncNavigation.Avalonia.Floating;
+using AsyncNavigation.Floating;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Headless.XUnit;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+
+namespace AsyncNavigation.E2E.Tests;
+
+public sealed class FloatingOverlayWindowTests
+{
+    [AvaloniaTheory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void Overlay_host_renders_in_page_and_raises_separate_requests(bool dock)
+    {
+        var mainView = new Grid();
+        var window = new Window { Content = mainView, Width = 500, Height = 400 };
+        window.Show();
+        try
+        {
+            var content = new Border();
+            var restoreRequested = false;
+            var closeRequested = false;
+            var host = new AvaloniaOverlayFloatingWindowHost(
+                new FloatingWindowOptions { Title = "Overlay lifecycle test", Width = 320, Height = 240 },
+                mainView);
+
+            host.RestoreRequested += (_, _) => restoreRequested = true;
+            host.CloseRequested += (_, _) => closeRequested = true;
+
+            host.SetContentAsync(content).GetAwaiter().GetResult();
+            host.ShowAsync().GetAwaiter().GetResult();
+            Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded);
+
+            var topLevel = TopLevel.GetTopLevel(mainView);
+            var overlay = OverlayLayer.GetOverlayLayer(topLevel!);
+            Assert.NotNull(overlay);
+            // The overlay host must NOT open a separate OS window: floated content stays under
+            // the same TopLevel as the page that hosts it - that is the whole point on WASM.
+            Assert.Same(topLevel, TopLevel.GetTopLevel(content));
+
+            var dockButton = FindButton(overlay!, "Dock");
+            var closeButton = FindButton(overlay!, "X");
+
+            if (dock)
+                dockButton.RaiseEvent(new global::Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+            else
+                closeButton.RaiseEvent(new global::Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+
+            Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded);
+
+            Assert.Equal(dock, restoreRequested);
+            Assert.Equal(!dock, closeRequested);
+
+            host.CloseAsync().GetAwaiter().GetResult();
+            Assert.DoesNotContain(FindButtons(overlay!), b => b == dockButton);
+            host.DisposeAsync().AsTask().GetAwaiter().GetResult();
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    private static Button FindButton(OverlayLayer overlay, string text) =>
+        FindButtons(overlay).First(b => (b.Content as string) == text);
+
+    private static IEnumerable<Button> FindButtons(OverlayLayer overlay) =>
+        overlay.GetVisualDescendants().OfType<Button>();
+}
diff --git a/tests/AsyncNavigation.E2E.Tests/FloatingVisualStateTests.cs b/tests/AsyncNavigation.E2E.Tests/FloatingVisualStateTests.cs
new file mode 100644
index 0000000..9361966
--- /dev/null
+++ b/tests/AsyncNavigation.E2E.Tests/FloatingVisualStateTests.cs
@@ -0,0 +1,76 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Presenters;
+using Avalonia.Controls.Templates;
+using Avalonia.Data;
+using Avalonia.Headless.XUnit;
+using Avalonia.LogicalTree;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+
+namespace AsyncNavigation.E2E.Tests;
+
+public sealed class FloatingVisualStateTests
+{
+    [AvaloniaFact]
+    public void MovingSameViewBetweenWindows_PreservesTemplatedDatePickerState()
+    {
+        var state = new DatePickerState();
+        var presenter = new ContentPresenter
+        {
+            Content = "item",
+            ContentTemplate = new FuncDataTemplate<string>((_, _) =>
+            {
+                var picker = new DatePicker();
+                picker.Bind(DatePicker.SelectedDateProperty, new Binding(nameof(DatePickerState.SelectedDate))
+                {
+                    Source = state,
+                    Mode = BindingMode.TwoWay
+                });
+                return picker;
+            })
+        };
+        var view = new UserControl { Content = presenter };
+        var indicatorHost = new ContentControl { Content = view };
+        var origin = new Window { Width = 800, Height = 600, Content = indicatorHost };
+        var floating = new Window { Width = 800, Height = 600 };
+
+        try
+        {
+            origin.Show();
+            Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded);
+            view.Measure(new Size(800, 600));
+            view.Arrange(new Rect(0, 0, 800, 600));
+            Dispatcher.UIThread.RunJobs();
+
+            var originalPicker = view.GetVisualDescendants().OfType<DatePicker>().Single();
+            var selectedDate = new DateTimeOffset(2026, 9, 1, 0, 0, 0, TimeSpan.Zero);
+            originalPicker.SelectedDate = selectedDate;
+            Assert.Equal(selectedDate, state.SelectedDate);
+
+            indicatorHost.Content = null;
+            origin.Content = null;
+            floating.Content = view;
+            floating.Show();
+            Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded);
+            view.Measure(new Size(800, 600));
+            view.Arrange(new Rect(0, 0, 800, 600));
+            Dispatcher.UIThread.RunJobs();
+
+            var floatingPicker = view.GetVisualDescendants().OfType<DatePicker>().Single();
+            Assert.NotSame(originalPicker, floatingPicker);
+            Assert.Equal(selectedDate, floatingPicker.SelectedDate);
+        }
+        finally
+        {
+            floating.Content = null;
+            floating.Close();
+            origin.Close();
+        }
+    }
+
+    private sealed class DatePickerState
+    {
+        public DateTimeOffset? SelectedDate { get; set; }
+    }
+}
diff --git a/tests/AsyncNavigation.E2E.Tests/FloatingWindowLifecycleTests.cs b/tests/AsyncNavigation.E2E.Tests/FloatingWindowLifecycleTests.cs
new file mode 100644
index 0000000..29c7c25
--- /dev/null
+++ b/tests/AsyncNavigation.E2E.Tests/FloatingWindowLifecycleTests.cs
@@ -0,0 +1,57 @@
+using AsyncNavigation.Avalonia.Floating;
+using AsyncNavigation.Floating;
+using Avalonia.Controls;
+using Avalonia.Headless.XUnit;
+using Avalonia.Threading;
+
+namespace AsyncNavigation.E2E.Tests;
+
+public sealed class FloatingWindowLifecycleTests
+{
+    [AvaloniaTheory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void Dock_and_close_raise_separate_requests(bool dock)
+    {
+        var content = new Border();
+        var restoreRequested = false;
+        var closeRequested = false;
+        var host = new AvaloniaFloatingWindowHost(new FloatingWindowOptions
+        {
+            Title = "Floating lifecycle test",
+            Width = 320,
+            Height = 240
+        });
+
+        host.SetContentAsync(content).GetAwaiter().GetResult();
+        host.ShowAsync().GetAwaiter().GetResult();
+        var window = TopLevel.GetTopLevel(content) as Window
+            ?? throw new InvalidOperationException("The floating window was not created.");
+
+        host.RestoreRequested += (_, _) => restoreRequested = true;
+        host.CloseRequested += async (_, _) =>
+        {
+            closeRequested = true;
+            await host.SetContentAsync(null);
+            await host.CloseAsync();
+            await host.DisposeAsync();
+        };
+
+        if (dock)
+        {
+            var panel = (DockPanel)window.Content!;
+            var button = (Button)panel.Children[0];
+            button.RaiseEvent(new global::Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+        }
+        else
+        {
+            window.Close();
+        }
+        Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded);
+
+        Assert.Equal(dock, restoreRequested);
+        Assert.Equal(!dock, closeRequested);
+        Assert.Equal(dock, window.IsVisible);
+        host.DisposeAsync().AsTask().GetAwaiter().GetResult();
+    }
+}
diff --git a/tests/AsyncNavigation.Tests/AsyncNavigation.Tests.csproj b/tests/AsyncNavigation.Tests/AsyncNavigation.Tests.csproj
index 5d1b44d..bd352f6 100644
--- a/tests/AsyncNavigation.Tests/AsyncNavigation.Tests.csproj
+++ b/tests/AsyncNavigation.Tests/AsyncNavigation.Tests.csproj
@@ -36,6 +36,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\AsyncNavigation\AsyncNavigation.csproj" />
+    <ProjectReference Include="..\..\src\AsyncNavigation.Floating\AsyncNavigation.Floating.csproj" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/AsyncNavigation.Tests/FloatingNavigationTests.cs b/tests/AsyncNavigation.Tests/FloatingNavigationTests.cs
new file mode 100644
index 0000000..11f9d2d
--- /dev/null
+++ b/tests/AsyncNavigation.Tests/FloatingNavigationTests.cs
@@ -0,0 +1,341 @@
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Core;
+using AsyncNavigation.Floating;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+
+namespace AsyncNavigation.Tests;
+
+public sealed class FloatingNavigationTests
+{
+    [Fact]
+    public async Task NavigateToFloatingInstance_ActivatesWindowWithoutLeavingCurrentView()
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        var session = await f.Placement.FloatAsync("main");
+        var b = await f.Navigate("B");
+        b.Model.AllowLeave = false;
+        var selected = f.Region.Selected;
+        var historyCount = f.History.History.Count;
+
+        var reused = await f.Navigate("A");
+
+        Assert.Same(a, reused);
+        Assert.Same(selected, f.Region.Selected);
+        Assert.Same(b, f.Indicator.Content);
+        Assert.Same(a, f.Windows[0].Content);
+        Assert.Equal(1, f.Windows[0].Activations);
+        Assert.Equal(0, b.Model.FromCount);
+        Assert.Equal(historyCount, f.History.History.Count);
+        Assert.Equal(ViewPlacementState.Floating, session.State);
+    }
+
+    [Theory]
+    [InlineData("B")]
+    [InlineData("A")]
+    public async Task DockIntoOccupiedRegion_ReusesOriginalAndUpdatesCurrentAndHistory(string next)
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        var session = await f.Placement.FloatAsync("main");
+        a.Model.Reuse = false;
+        var other = await f.Navigate(next);
+
+        await session.RestoreAsync();
+
+        Assert.NotSame(a, other);
+        Assert.Same(a, f.Indicator.Content);
+        Assert.Same(a, f.Region.Selected!.Target.Value);
+        Assert.Same(f.Region.Selected, f.History.Current);
+        Assert.Equal(1, other.Model.FromCount);
+        Assert.Equal(1, a.Model.InitializeCount);
+        Assert.Equal(2, a.Model.ToCount);
+        Assert.True(f.Windows[0].Closed);
+        Assert.Empty(f.Placement.FloatingViews);
+        await ((IRegion)f.Region).GoBackAsync();
+        Assert.Same(other, f.Indicator.Content);
+        Assert.Equal(1, a.Model.FromCount);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task FailedDock_PreservesBothViewsAndCanBeRetried(bool failAttach)
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        var session = await f.Placement.FloatAsync("main");
+        var b = await f.Navigate("B");
+        var before = f.History.Current;
+        b.Model.AllowLeave = failAttach;
+        f.Region.FailNextAttach = failAttach;
+
+        await Assert.ThrowsAnyAsync<Exception>(() => session.RestoreAsync());
+
+        Assert.Same(b, f.Indicator.Content);
+        Assert.Same(b, f.Region.Selected!.Target.Value);
+        Assert.Same(a, f.Windows[0].Content);
+        Assert.Same(before, f.History.Current);
+        Assert.False(f.Windows[0].Closed);
+        Assert.Equal(ViewPlacementState.Floating, session.State);
+        b.Model.AllowLeave = true;
+        await session.RestoreAsync();
+        Assert.Same(a, f.Indicator.Content);
+    }
+
+    [Fact]
+    public async Task CloseOldInstance_DoesNotRemoveNewInstanceCacheOrHistory()
+    {
+        using var f = new Fixture();
+        var a1 = await f.Navigate("A");
+        var session = await f.Placement.FloatAsync("main");
+        a1.Model.Reuse = false;
+        var a2 = await f.Navigate("A");
+
+        await session.CloseAsync();
+        var reused = await f.Navigate("A");
+
+        Assert.True(a1.Disposed);
+        Assert.False(a2.Disposed);
+        Assert.Same(a2, reused);
+        Assert.Same(a2, f.Indicator.Content);
+        Assert.DoesNotContain(f.History.History, c => ReferenceEquals(c.Target.Value, a1));
+    }
+
+    [Fact]
+    public async Task BackToFloatingView_ActivatesWindowAndKeepsHistoryPosition()
+    {
+        using var f = new Fixture();
+        await f.Navigate("A");
+        await f.Placement.FloatAsync("main");
+        var b = await f.Navigate("B");
+        var current = f.History.Current;
+
+        await ((IRegion)f.Region).GoBackAsync();
+
+        Assert.Same(b, f.Indicator.Content);
+        Assert.Same(current, f.History.Current);
+        Assert.Equal(1, f.Windows[0].Activations);
+    }
+
+    [Fact]
+    public async Task CacheClear_DoesNotDisposeFloatingView()
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        await f.Placement.FloatAsync("main");
+        f.Cache.Clear();
+        Assert.False(a.Disposed);
+        Assert.Same(a, await f.Navigate("A"));
+    }
+
+    [Fact]
+    public async Task NavigationWaitsForDockTransaction()
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        var session = await f.Placement.FloatAsync("main");
+        var b = await f.Navigate("B");
+        var guard = new TaskCompletionSource<bool>();
+        b.Model.GuardTask = guard.Task;
+        var dock = session.RestoreAsync();
+        var navigate = f.Navigate("C");
+        Assert.False(dock.IsCompleted);
+        Assert.False(navigate.IsCompleted);
+        guard.SetResult(true);
+        await dock;
+        var c = await navigate;
+        Assert.Same(c, f.Indicator.Content);
+        Assert.Equal(1, a.Model.FromCount);
+    }
+
+    [Fact]
+    public async Task NavigationCanStillCancelCurrentWhileFloatingEnabled()
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        a.Model.GuardTask = new TaskCompletionSource<bool>().Task;
+        var pending = f.Navigate("B");
+        Assert.False(pending.IsCompleted);
+        a.Model.GuardTask = null;
+        var replacement = f.Navigate("C");
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => pending);
+        var c = await replacement;
+        Assert.Same(c, f.Indicator.Content);
+    }
+
+    [Fact]
+    public async Task CacheEviction_PinsFloatingViewAndDoesNotDisposeNewView()
+    {
+        using var f = new Fixture(maxCacheSize: 1);
+        var a = await f.Navigate("A");
+        await f.Placement.FloatAsync("main");
+        var b = await f.Navigate("B");
+        Assert.False(a.Disposed);
+        Assert.False(b.Disposed);
+        Assert.Same(a, await f.Navigate("A"));
+    }
+
+    [Fact]
+    public async Task CancelledDock_PreservesRegionAndFloatingWindow()
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        var session = await f.Placement.FloatAsync("main");
+        var b = await f.Navigate("B");
+        b.Model.GuardTask = new TaskCompletionSource<bool>().Task;
+        using var cancellation = new CancellationTokenSource();
+        var dock = session.RestoreAsync(cancellation.Token);
+        cancellation.Cancel();
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => dock);
+        Assert.Same(b, f.Indicator.Content);
+        Assert.Same(a, f.Windows[0].Content);
+        Assert.Equal(ViewPlacementState.Floating, session.State);
+    }
+
+    private sealed class Fixture : IDisposable
+    {
+        private readonly ServiceProvider _provider;
+        public Fixture(int maxCacheSize = 20)
+        {
+            var manager = new Mock<IRegionManager>();
+            var windows = new Mock<IFloatingWindowHostFactory>();
+            windows.Setup(x => x.Create(It.IsAny<FloatingWindowOptions>())).Returns(() =>
+            {
+                var window = new WindowHost();
+                Windows.Add(window);
+                return window;
+            });
+            var services = new ServiceCollection()
+                .AddSingleton(new NavigationOptions { ViewCacheStrategy = ViewCacheStrategy.UpdateDuplicateKey, MaxCachedViews = maxCacheSize })
+                .AddSingleton<IViewFactory, ViewFactory>()
+                .AddSingleton<IRegionManager>(manager.Object)
+                .AddSingleton<IFloatingWindowHostFactory>(windows.Object)
+                .AddSingleton<IViewManager, ViewManager>()
+                .AddSingleton<IRegionNavigationHistory, RegionNavigationHistory>()
+                .AddSingleton<IRegionNavigationServiceFactory, RegionNavigationServiceFactory>()
+                .AddTransient<IAsyncJobProcessor, AsyncJobProcessor>()
+                .AddTransient<IRegionIndicatorManager, RegionIndicatorManager>()
+                .AddSingleton<IInnerRegionIndicatorHost>(Indicator)
+                .AddFloatingSupportCore();
+            _provider = services.BuildServiceProvider();
+            Region = new ContentRegion(_provider);
+            IRegion? region = Region;
+            manager.Setup(x => x.TryGetRegion("main", out region)).Returns(true);
+            Placement = _provider.GetRequiredService<IViewPlacementService>();
+            History = _provider.GetRequiredService<IRegionNavigationHistory>();
+            Cache = _provider.GetRequiredService<IViewManager>();
+        }
+        public ContentRegion Region { get; }
+        public IndicatorHost Indicator { get; } = new();
+        public List<WindowHost> Windows { get; } = [];
+        public IViewPlacementService Placement { get; }
+        public IRegionNavigationHistory History { get; }
+        public IViewManager Cache { get; }
+        public async Task<View> Navigate(string name)
+        {
+            var context = new NavigationContext { RegionName = "main", ViewName = name };
+            await ((IRegion)Region).ActivateViewAsync(context);
+            return (View)context.Target.Value!;
+        }
+        public void Dispose() => _provider.Dispose();
+    }
+
+    private sealed class ContentRegion(IServiceProvider provider)
+        : RegionBase<ContentRegion, object>("main", new object(), provider), IRegionPlacementParticipant
+    {
+        public NavigationContext? Selected { get; private set; }
+        public bool FailNextAttach { get; set; }
+        public override NavigationPipelineMode NavigationPipelineMode => NavigationPipelineMode.RenderFirst;
+        protected override void InitializeOnRegionCreated(object control)
+        {
+            EnableViewCache = true;
+            IsSinglePageRegion = true;
+        }
+        public override Task ProcessActivateAsync(NavigationContext context)
+        {
+            Selected = context;
+            return Task.CompletedTask;
+        }
+        public override Task ProcessDeactivateAsync(NavigationContext? context)
+        {
+            if (context is null || ReferenceEquals(Selected, context)) Selected = null;
+            return Task.CompletedTask;
+        }
+        public RegionPlacementItem Capture(Guid? id = null) =>
+            new(Selected ?? throw new InvalidOperationException("empty"), 0, true);
+        public void Detach(RegionPlacementItem item)
+        {
+            Assert.Same(Selected, item.Context);
+            Selected = null;
+        }
+        public void Attach(RegionPlacementItem item, bool activate = true)
+        {
+            if (FailNextAttach)
+            {
+                FailNextAttach = false;
+                throw new InvalidOperationException("attach failed");
+            }
+            Assert.Null(Selected);
+            Selected = item.Context;
+        }
+    }
+
+    private sealed class ViewFactory : IViewFactory
+    {
+        public IView CreateView(string key) => new View();
+        public bool CanCreateView(string key) => true;
+        public void AddView(string key, IView view) => throw new NotSupportedException();
+        public void AddView(string key, Func<string, IView> factory) => throw new NotSupportedException();
+    }
+
+    private sealed class View : IView, IDisposable
+    {
+        public Model Model { get; } = new();
+        public object? DataContext { get => Model; set => throw new NotSupportedException(); }
+        public bool Disposed { get; private set; }
+        public void Dispose() => Disposed = true;
+    }
+    private sealed class Model : INavigationAware, INavigationGuard
+    {
+        public bool AllowLeave { get; set; } = true;
+        public bool Reuse { get; set; } = true;
+        public int InitializeCount { get; private set; }
+        public int ToCount { get; private set; }
+        public int FromCount { get; private set; }
+        public Task<bool>? GuardTask { get; set; }
+        public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+        public Task InitializeAsync(NavigationContext context) { InitializeCount++; return Task.CompletedTask; }
+        public Task OnNavigatedToAsync(NavigationContext context) { ToCount++; return Task.CompletedTask; }
+        public Task OnNavigatedFromAsync(NavigationContext context) { FromCount++; return Task.CompletedTask; }
+        public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(Reuse);
+        public Task OnUnloadAsync(CancellationToken token) => Task.CompletedTask;
+        public Task<bool> CanNavigateAsync(NavigationContext context, CancellationToken token) => GuardTask?.WaitAsync(token) ?? Task.FromResult(AllowLeave);
+    }
+    private sealed class IndicatorHost : IInnerRegionIndicatorHost, IRegionPlacementContentHost
+    {
+        public object Host => this;
+        public object? Content { get; private set; }
+        public object DetachContent() { var content = Content ?? throw new InvalidOperationException("empty"); Content = null; return content; }
+        public void AttachContent(object content) { Assert.Null(Content); Content = content; }
+        public Task ShowContentAsync(NavigationContext context) { Content = context.Target.Value; return Task.CompletedTask; }
+        public Task ShowErrorAsync(NavigationContext context, Exception? exception) => Task.CompletedTask;
+        public Task ShowLoadingAsync(NavigationContext context) => Task.CompletedTask;
+        public Task OnLoadedAsync(NavigationContext context) => Task.CompletedTask;
+        public Task OnCancelledAsync(NavigationContext context) => Task.CompletedTask;
+    }
+    private sealed class WindowHost : IFloatingWindowHost
+    {
+        public event EventHandler? RestoreRequested;
+        public event EventHandler? CloseRequested;
+        public object? Content { get; private set; }
+        public bool Closed { get; private set; }
+        public int Activations { get; private set; }
+        public Task SetContentAsync(object? content, CancellationToken token = default) { Content = content; return Task.CompletedTask; }
+        public Task ShowAsync(CancellationToken token = default) => Task.CompletedTask;
+        public Task ActivateAsync(CancellationToken token = default) { Activations++; return Task.CompletedTask; }
+        public Task CloseAsync(CancellationToken token = default) { Closed = true; return Task.CompletedTask; }
+        public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+    }
+}
diff --git a/tests/AsyncNavigation.Tests/NavigationAwareBaseTests.cs b/tests/AsyncNavigation.Tests/NavigationAwareBaseTests.cs
index 21840c7..2c8cb0f 100644
--- a/tests/AsyncNavigation.Tests/NavigationAwareBaseTests.cs
+++ b/tests/AsyncNavigation.Tests/NavigationAwareBaseTests.cs
@@ -1,9 +1,21 @@
-using AsyncNavigation.Tests.Infrastructure;
+using System.Reflection;
+
+#pragma warning disable CS0618 // Exercise the retained compatibility API.
 
 namespace AsyncNavigation.Tests;
 
 public class NavigationAwareBaseTests
 {
+    [Fact]
+    public void CompatibilityBase_IsInLibraryAndObsoleteWithWarningOnly()
+    {
+        Assert.Same(typeof(NavigationContext).Assembly, typeof(NavigationAwareBase).Assembly);
+        var obsolete = typeof(NavigationAwareBase).GetCustomAttribute<ObsoleteAttribute>();
+        Assert.NotNull(obsolete);
+        Assert.False(obsolete.IsError);
+        Assert.Contains("INavigationAware", obsolete.Message);
+    }
+
     private sealed class TestAware : NavigationAwareBase
     {
         public Task RequestUnload(CancellationToken ct = default) => RequestUnloadAsync(ct);
diff --git a/tests/AsyncNavigation.Tests/ViewManagerExtendedTests.cs b/tests/AsyncNavigation.Tests/ViewManagerExtendedTests.cs
index 5a1ed64..3a21a8f 100644
--- a/tests/AsyncNavigation.Tests/ViewManagerExtendedTests.cs
+++ b/tests/AsyncNavigation.Tests/ViewManagerExtendedTests.cs
@@ -25,10 +25,12 @@ public class ViewManagerExtendedTests
     /// </summary>
     private static (IViewManager Manager, IServiceProvider Provider) BuildManager(
         int max = 10,
-        ViewCacheStrategy strategy = ViewCacheStrategy.IgnoreDuplicateKey)
+        ViewCacheStrategy strategy = ViewCacheStrategy.IgnoreDuplicateKey,
+        ViewPlacementCoordinator? placement = null)
     {
         var sc = new ServiceCollection();
         sc.AddNavigationTestSupport(new NavigationOptions { MaxCachedViews = max, ViewCacheStrategy = strategy });
+        if (placement is not null) sc.AddSingleton(placement);
         sc.RegisterView<TestView, TestNavigationAware>("V1");
         sc.RegisterView<AnotherTestView, TestNavigationAware>("V2");
         var sp = sc.BuildServiceProvider();
@@ -149,6 +151,42 @@ public async Task Clear_DisposesAllViews()
         Assert.True(spy2.Disposed);
     }
 
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task Clear_DisposeFailure_RemovesAllNonFloatingEntries(bool withFloating)
+    {
+        var placement = withFloating ? new ViewPlacementCoordinator() : null;
+        var (manager, _) = BuildManager(placement: placement);
+        var first = await manager.ResolveViewAsync("V1", true);
+        var second = await manager.ResolveViewAsync("V2", true);
+        first.DataContext = new ThrowingDisposable();
+        second.DataContext = new ThrowingDisposable();
+        var floating = new TestView { DataContext = new DisposableSpy() };
+        if (placement is not null)
+        {
+            manager.AddView("floating", floating);
+            placement.Register(floating, _ => Task.CompletedTask);
+        }
+
+        Assert.Throws<InvalidOperationException>(() => manager.Clear());
+        if (placement is not null)
+        {
+            Assert.Same(floating, await manager.ResolveViewAsync("floating", true));
+            Assert.False(((DisposableSpy)floating.DataContext!).Disposed);
+        }
+
+        Assert.Null(await ((IViewPlacementCache)manager).FindCachedViewAsync("V1", _ => Task.FromResult(true)));
+        Assert.Null(await ((IViewPlacementCache)manager).FindCachedViewAsync("V2", _ => Task.FromResult(true)));
+        Assert.NotSame(first, await manager.ResolveViewAsync("V1", true));
+        Assert.NotSame(second, await manager.ResolveViewAsync("V2", true));
+    }
+
+    private sealed class ThrowingDisposable : IDisposable
+    {
+        public void Dispose() => throw new InvalidOperationException("Disposal failed.");
+    }
+
     // -----------------------------------------------------------------------
     // Concurrent access
     // -----------------------------------------------------------------------
diff --git a/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs b/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs
new file mode 100644
index 0000000..ddc7086
--- /dev/null
+++ b/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs
@@ -0,0 +1,249 @@
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Core;
+using AsyncNavigation.Floating;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+
+namespace AsyncNavigation.Tests;
+
+public sealed class ViewPlacementServiceTests
+{
+    [Fact]
+    public async Task FloatAndRestore_MovesTheSameRenderedHostWithoutNavigating()
+    {
+        var fixture = new Fixture();
+
+        var session = await fixture.Service.FloatAsync("main", fixture.Context.NavigationId);
+
+        Assert.Equal(1, fixture.Region.DetachCount);
+        Assert.Same(fixture.RenderedView, fixture.Window.Content);
+        Assert.Null(fixture.Indicator.Content);
+        Assert.True(fixture.Window.WasShown);
+        Assert.Single(fixture.Service.FloatingViews);
+
+        await session.RestoreAsync();
+
+        Assert.Equal(1, fixture.Region.AttachCount);
+        Assert.Null(fixture.Window.Content);
+        Assert.Same(fixture.RenderedView, fixture.Indicator.Content);
+        Assert.Equal("selected-value", fixture.RenderedView.Selection);
+        Assert.True(fixture.Window.WasClosed);
+        Assert.Empty(fixture.Service.FloatingViews);
+        Assert.Equal(ViewPlacementState.Restored, session.State);
+    }
+
+    [Fact]
+    public async Task FloatWithSameNavigationId_ActivatesExistingSession()
+    {
+        var fixture = new Fixture();
+
+        var first = await fixture.Service.FloatAsync("main", fixture.Context.NavigationId);
+        var second = await fixture.Service.FloatAsync("main", fixture.Context.NavigationId);
+
+        Assert.Same(first, second);
+        Assert.Equal(1, fixture.Window.ActivateCount);
+        Assert.Equal(1, fixture.Region.CaptureCount);
+        Assert.Equal(1, fixture.Region.DetachCount);
+    }
+
+    [Fact]
+    public async Task FailedWindowShow_RestoresItemAndRemovesSession()
+    {
+        var fixture = new Fixture();
+        fixture.Window.ShowException = new InvalidOperationException("show failed");
+
+        await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            fixture.Service.FloatAsync("main", fixture.Context.NavigationId));
+
+        Assert.Equal(1, fixture.Region.AttachCount);
+        Assert.Null(fixture.Window.Content);
+        Assert.Same(fixture.RenderedView, fixture.Indicator.Content);
+        Assert.Empty(fixture.Service.FloatingViews);
+        Assert.True(fixture.Window.WasDisposed);
+    }
+
+    [Fact]
+    public async Task UserClose_RemovesSessionWithoutRestoringContent()
+    {
+        var fixture = new Fixture();
+        var session = await fixture.Service.FloatAsync("main", fixture.Context.NavigationId);
+
+        fixture.Window.RequestClose();
+        await session.CloseAsync();
+        await session.RestoreAsync();
+
+        Assert.Equal(ViewPlacementState.Closed, session.State);
+        Assert.Equal(0, fixture.Region.AttachCount);
+        Assert.Null(fixture.Window.Content);
+        Assert.Null(fixture.Indicator.Content);
+        Assert.True(fixture.Window.WasClosed);
+        Assert.True(fixture.Window.WasDisposed);
+        Assert.Empty(fixture.Service.FloatingViews);
+        Assert.False(fixture.Service.TryGetSession(session.Id, out _));
+    }
+
+    [Fact]
+    public async Task DockRequest_RestoresContentWithoutClosingSessionAsClosed()
+    {
+        var fixture = new Fixture();
+        var session = await fixture.Service.FloatAsync("main", fixture.Context.NavigationId);
+
+        fixture.Window.RequestRestore();
+        await session.RestoreAsync();
+        await session.CloseAsync();
+
+        Assert.Equal(ViewPlacementState.Restored, session.State);
+        Assert.Equal(1, fixture.Region.AttachCount);
+        Assert.Same(fixture.RenderedView, fixture.Indicator.Content);
+    }
+
+    private sealed class Fixture
+    {
+        public Fixture()
+        {
+            RenderedView = new StatefulRenderedView { Selection = "selected-value" };
+            Context = new NavigationContext { RegionName = "main", ViewName = "editor" };
+            Indicator = new FakeIndicatorHost(RenderedView);
+            Context.IndicatorHost.Value = Indicator;
+            Context.Target.Value = RenderedView;
+            Item = new RegionPlacementItem(Context, 2, true);
+
+            Region = new FakeRegion(Item);
+
+            IRegion? regionValue = Region;
+            var manager = new Mock<IRegionManager>();
+            manager.Setup(x => x.TryGetRegion("main", out regionValue)).Returns(true);
+
+            Window = new FakeWindowHost();
+            var factory = new Mock<IFloatingWindowHostFactory>();
+            factory.Setup(x => x.Create(It.IsAny<FloatingWindowOptions>())).Returns(Window);
+
+            var provider = new ServiceCollection()
+                .AddSingleton(manager.Object)
+                .AddSingleton(factory.Object)
+                .AddFloatingSupportCore()
+                .BuildServiceProvider();
+            Service = provider.GetRequiredService<IViewPlacementService>();
+        }
+
+        public StatefulRenderedView RenderedView { get; }
+        public FakeIndicatorHost Indicator { get; }
+        public NavigationContext Context { get; }
+        public RegionPlacementItem Item { get; }
+        public FakeRegion Region { get; }
+        public FakeWindowHost Window { get; }
+        public IViewPlacementService Service { get; }
+    }
+
+    private sealed class StatefulRenderedView : IView
+    {
+        public object? DataContext { get; set; }
+        public string? Selection { get; set; }
+    }
+
+    private sealed class FakeIndicatorHost(object content)
+        : IInnerRegionIndicatorHost, IRegionPlacementContentHost
+    {
+        private readonly object _host = new();
+
+        public object Host => _host;
+        public object? Content { get; private set; } = content;
+
+        public object DetachContent()
+        {
+            var current = Content ?? throw new InvalidOperationException();
+            Content = null;
+            return current;
+        }
+
+        public void AttachContent(object content)
+        {
+            if (Content is not null)
+                throw new InvalidOperationException();
+            Content = content;
+        }
+
+        public Task ShowContentAsync(NavigationContext context) => Task.CompletedTask;
+        public Task ShowLoadingAsync(NavigationContext context) => Task.CompletedTask;
+        public Task ShowErrorAsync(NavigationContext context, Exception? innerException) => Task.CompletedTask;
+        public Task OnLoadedAsync(NavigationContext context) => Task.CompletedTask;
+        public Task OnCancelledAsync(NavigationContext context) => Task.CompletedTask;
+    }
+
+    private sealed class FakeRegion : IRegion, IRegionPlacementParticipant
+    {
+        private readonly RegionPlacementItem _item;
+
+        public FakeRegion(RegionPlacementItem item) => _item = item;
+
+        public int CaptureCount { get; private set; }
+        public int DetachCount { get; private set; }
+        public int AttachCount { get; private set; }
+        public string Name => "main";
+        public event EventHandler<NavigationEventArgs>? Navigated;
+        IRegionPresenter IRegion.RegionPresenter => throw new NotSupportedException();
+
+        public RegionPlacementItem Capture(Guid? navigationId = null)
+        {
+            CaptureCount++;
+            return _item;
+        }
+
+        public void Detach(RegionPlacementItem item) => DetachCount++;
+        public void Attach(RegionPlacementItem item, bool activate = true) => AttachCount++;
+        public Task NavigateFromAsync(NavigationContext navigationContext) => Task.CompletedTask;
+        public Task<NavigationResult> ActivateViewAsync(NavigationContext navigationContext) => throw new NotSupportedException();
+        public Task<bool> CanGoBackAsync() => Task.FromResult(false);
+        public Task<NavigationResult> GoBackAsync(CancellationToken cancellationToken = default) => throw new NotSupportedException();
+        public Task<bool> CanGoForwardAsync() => Task.FromResult(false);
+        public Task<NavigationResult> GoForwardAsync(CancellationToken cancellationToken = default) => throw new NotSupportedException();
+        public Task RevertAsync(NavigationContext? navigationContext) => Task.CompletedTask;
+        public void Dispose() { }
+    }
+
+    private sealed class FakeWindowHost : IFloatingWindowHost
+    {
+        public event EventHandler? RestoreRequested;
+        public event EventHandler? CloseRequested;
+        public void RequestClose() => CloseRequested?.Invoke(this, EventArgs.Empty);
+        public object? Content { get; private set; }
+        public bool WasShown { get; private set; }
+        public bool WasClosed { get; private set; }
+        public bool WasDisposed { get; private set; }
+        public int ActivateCount { get; private set; }
+        public Exception? ShowException { get; set; }
+
+        public Task SetContentAsync(object? content, CancellationToken cancellationToken = default)
+        {
+            Content = content;
+            return Task.CompletedTask;
+        }
+
+        public Task ShowAsync(CancellationToken cancellationToken = default)
+        {
+            if (ShowException is not null) throw ShowException;
+            WasShown = true;
+            return Task.CompletedTask;
+        }
+
+        public Task ActivateAsync(CancellationToken cancellationToken = default)
+        {
+            ActivateCount++;
+            return Task.CompletedTask;
+        }
+
+        public Task CloseAsync(CancellationToken cancellationToken = default)
+        {
+            WasClosed = true;
+            return Task.CompletedTask;
+        }
+
+        public ValueTask DisposeAsync()
+        {
+            WasDisposed = true;
+            return ValueTask.CompletedTask;
+        }
+
+        public void RequestRestore() => RestoreRequested?.Invoke(this, EventArgs.Empty);
+    }
+}
diff --git a/tests/AsyncNavigation.Wpf.E2E.Tests/AsyncNavigation.Wpf.E2E.Tests.csproj b/tests/AsyncNavigation.Wpf.E2E.Tests/AsyncNavigation.Wpf.E2E.Tests.csproj
new file mode 100644
index 0000000..98b8728
--- /dev/null
+++ b/tests/AsyncNavigation.Wpf.E2E.Tests/AsyncNavigation.Wpf.E2E.Tests.csproj
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0-windows</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <OutputType>Exe</OutputType>
+    <UseWPF>true</UseWPF>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.6" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.4.0" />
+    <PackageReference Include="xunit.v3" Version="3.2.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\AsyncNavigation.Wpf.Floating\AsyncNavigation.Wpf.Floating.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingNavigationTests.cs b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingNavigationTests.cs
new file mode 100644
index 0000000..efd13b6
--- /dev/null
+++ b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingNavigationTests.cs
@@ -0,0 +1,136 @@
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Core;
+using AsyncNavigation.Floating;
+using Microsoft.Extensions.DependencyInjection;
+using AsyncNavigation.Wpf.Floating;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Threading;
+using System.Runtime.ExceptionServices;
+using ControlType = System.Windows.Controls.Control;
+using PlatformContentRegion = AsyncNavigation.Wpf.ContentRegion;
+using PlatformTabRegion = AsyncNavigation.Wpf.TabRegion;
+namespace AsyncNavigation.Wpf.E2E.Tests;
+
+public sealed class FloatingNavigationTests
+{
+    [Theory]
+    [InlineData(false, false)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(true, true)]
+    public void Floating_navigation_and_docking_preserve_instance_ownership(bool createNew, bool tabs) =>
+        RunOnSta(() => VerifyNavigationAndDock(createNew, tabs));
+    private static async Task VerifyNavigationAndDock(bool createNew, bool tabs)
+    {
+        var services = new ServiceCollection().AddNavigationSupport().AddFloatingSupportCore();
+        services.RegisterView<TestView, Model>("A");
+        services.RegisterView<TestView, Model>("B");
+        services.AddSingleton<IFloatingWindowHostFactory, WindowFactory>();
+        using var provider = services.BuildServiceProvider();
+        var manager = provider.GetRequiredService<IRegionManager>();
+        var placement = provider.GetRequiredService<IViewPlacementService>();
+        var control = tabs ? (ControlType)new TabControl() : new ContentControl();
+        IRegion region = tabs
+            ? new PlatformTabRegion("main", (TabControl)control, provider, true)
+            : new PlatformContentRegion("main", (ContentControl)control, provider, true);
+        manager.AddRegion("main", region);
+        var window = new Window { Content = control, Width = 500, Height = 400 };
+        window.Show();
+        try
+        {
+            var first = await manager.RequestNavigateAsync("main", "A");
+            Assert.True(first.IsSuccessful, first.Exception?.ToString());
+            var a1 = (TestView)first.NavigationContext!.Target.Value!;
+            var session = await placement.FloatAsync("main");
+            var floatingWindow = Window.GetWindow(a1);
+            Assert.NotNull(floatingWindow);
+            Assert.NotSame(window, floatingWindow);
+            var next = await manager.RequestNavigateAsync("main", "B");
+            Assert.True(next.IsSuccessful, next.Exception?.ToString());
+            var b = next.NavigationContext!.Target.Value;
+            var selected = ((IRegionPlacementParticipant)region).Capture().Context;
+
+            if (createNew)
+            {
+                ((Model)a1.DataContext!).Reuse = false;
+                var newA = await manager.RequestNavigateAsync("main", "A");
+                Assert.True(newA.IsSuccessful, newA.Exception?.ToString());
+                Assert.NotSame(a1, newA.NavigationContext!.Target.Value);
+            }
+            else
+            {
+                var reused = await manager.RequestNavigateAsync("main", "A");
+                Assert.True(reused.IsSuccessful, reused.Exception?.ToString());
+                Assert.Same(a1, reused.NavigationContext!.Target.Value);
+                Assert.Same(selected, ((IRegionPlacementParticipant)region).Capture().Context);
+                Assert.Same(floatingWindow, Window.GetWindow(a1));
+            }
+
+            await session.RestoreAsync();
+            Dispatcher.CurrentDispatcher.Invoke(static () => { }, DispatcherPriority.ApplicationIdle);
+            Assert.Equal(ViewPlacementState.Restored, session.State);
+            Assert.False(floatingWindow!.IsVisible);
+            Assert.Same(a1, ((IRegionPlacementParticipant)region).Capture().Context.Target.Value);
+            Assert.Same(window, Window.GetWindow(a1));
+            Assert.Equal(1, ((Model)a1.DataContext!).Initializations);
+            if (tabs)
+                Assert.Equal(createNew ? 3 : 2, ((TabControl)control).Items.Count);
+            else
+            {
+                var back = await manager.GoBackAsync("main");
+                Assert.True(back.IsSuccessful, back.Exception?.ToString());
+                Assert.NotSame(a1, ((IRegionPlacementParticipant)region).Capture().Context.Target.Value);
+            }
+        }
+        finally
+        {
+            foreach (var session in placement.FloatingViews.ToArray()) await session.CloseAsync();
+            window.Close();
+        }
+    }
+
+    public sealed class TestView : UserControl, IView
+    {
+        public TestView() => Content = new TextBox { Text = "state survives docking" };
+    }
+
+    public sealed class Model : INavigationAware
+    {
+        public bool Reuse { get; set; } = true;
+        public int Initializations { get; private set; }
+        public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+        public Task InitializeAsync(NavigationContext context) { Initializations++; return Task.CompletedTask; }
+        public Task OnNavigatedToAsync(NavigationContext context) => Task.CompletedTask;
+        public Task OnNavigatedFromAsync(NavigationContext context) => Task.CompletedTask;
+        public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(Reuse);
+        public Task OnUnloadAsync(CancellationToken token) => Task.CompletedTask;
+    }
+
+    private sealed class WindowFactory : IFloatingWindowHostFactory
+    {
+        public IFloatingWindowHost Create(FloatingWindowOptions options) => new WpfFloatingWindowHost(options);
+    }
+    private static void RunOnSta(Func<Task> action)
+    {
+        Exception? failure = null;
+        var thread = new Thread(() =>
+        {
+            SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext());
+            var frame = new DispatcherFrame();
+            async void Run()
+            {
+                try { await action(); }
+                catch (Exception ex) { failure = ex; }
+                finally { frame.Continue = false; }
+            }
+            Dispatcher.CurrentDispatcher.BeginInvoke((Action)Run);
+            Dispatcher.PushFrame(frame);
+            Dispatcher.CurrentDispatcher.InvokeShutdown();
+        });
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.Start();
+        thread.Join();
+        if (failure is not null) ExceptionDispatchInfo.Capture(failure).Throw();
+    }
+}
diff --git a/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingVisualStateTests.cs b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingVisualStateTests.cs
new file mode 100644
index 0000000..df73ce4
--- /dev/null
+++ b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingVisualStateTests.cs
@@ -0,0 +1,202 @@
+using System.ComponentModel;
+using System.Runtime.ExceptionServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Threading;
+
+namespace AsyncNavigation.Wpf.E2E.Tests;
+
+public sealed class FloatingVisualStateTests
+{
+    [Fact]
+    public void Unbound_date_survives_moving_the_same_view_between_windows()
+    {
+        RunOnStaThread(() =>
+        {
+            var selectedDate = new DateTime(2026, 9, 1);
+            var view = CreateTemplatedView(new object());
+
+            using var mainWindow = new TestWindow();
+            using var floatingWindow = new TestWindow();
+
+            mainWindow.Content = view;
+            mainWindow.Show();
+            FlushDispatcher();
+
+            var originalDatePicker = FindVisualChild<DatePicker>(view)
+                ?? throw new InvalidOperationException("The DatePicker was not created.");
+
+            originalDatePicker.SelectedDate = selectedDate;
+            MoveToFloatingWindowAndBack(
+                view,
+                originalDatePicker,
+                selectedDate,
+                mainWindow,
+                floatingWindow);
+        });
+    }
+
+    [Fact]
+    public void Bound_date_survives_moving_the_same_view_between_windows()
+    {
+        RunOnStaThread(() =>
+        {
+            var selectedDate = new DateTime(2026, 9, 1);
+            var state = new ViewState();
+            var view = CreateTemplatedView(state, nameof(ViewState.SelectedDate));
+
+            using var mainWindow = new TestWindow();
+            using var floatingWindow = new TestWindow();
+
+            mainWindow.Content = view;
+            mainWindow.Show();
+            FlushDispatcher();
+
+            var originalDatePicker = FindVisualChild<DatePicker>(view)
+                ?? throw new InvalidOperationException("The DatePicker was not created.");
+
+            originalDatePicker.SelectedDate = selectedDate;
+            FlushDispatcher();
+            Assert.Equal(selectedDate, state.SelectedDate);
+
+            MoveToFloatingWindowAndBack(
+                view,
+                originalDatePicker,
+                selectedDate,
+                mainWindow,
+                floatingWindow);
+            Assert.Equal(selectedDate, state.SelectedDate);
+        });
+    }
+
+    private static void MoveToFloatingWindowAndBack(
+        UserControl view,
+        DatePicker originalDatePicker,
+        DateTime selectedDate,
+        TestWindow mainWindow,
+        TestWindow floatingWindow)
+    {
+        mainWindow.Content = null;
+        floatingWindow.Content = view;
+        floatingWindow.Show();
+        FlushDispatcher();
+
+        var floatingDatePicker = FindVisualChild<DatePicker>(view)
+            ?? throw new InvalidOperationException("The DatePicker was not found in the floating window.");
+        Assert.Same(originalDatePicker, floatingDatePicker);
+        Assert.Equal(selectedDate, floatingDatePicker.SelectedDate);
+
+        floatingWindow.Content = null;
+        mainWindow.Content = view;
+        FlushDispatcher();
+
+        var restoredDatePicker = FindVisualChild<DatePicker>(view)
+            ?? throw new InvalidOperationException("The DatePicker was not found after restoration.");
+        Assert.Same(originalDatePicker, restoredDatePicker);
+        Assert.Equal(selectedDate, restoredDatePicker.SelectedDate);
+    }
+
+    private static UserControl CreateTemplatedView(object state, string? selectedDatePath = null)
+    {
+        var datePickerFactory = new FrameworkElementFactory(typeof(DatePicker));
+        if (selectedDatePath is not null)
+        {
+            datePickerFactory.SetBinding(
+                DatePicker.SelectedDateProperty,
+                new Binding(selectedDatePath)
+                {
+                    Mode = BindingMode.TwoWay,
+                    UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged
+                });
+        }
+
+        var presenter = new ContentPresenter
+        {
+            Content = state,
+            ContentTemplate = new DataTemplate { VisualTree = datePickerFactory }
+        };
+
+        return new UserControl { Content = presenter };
+    }
+
+    private static T? FindVisualChild<T>(DependencyObject parent)
+        where T : DependencyObject
+    {
+        for (var i = 0; i < System.Windows.Media.VisualTreeHelper.GetChildrenCount(parent); i++)
+        {
+            var child = System.Windows.Media.VisualTreeHelper.GetChild(parent, i);
+            if (child is T match)
+            {
+                return match;
+            }
+
+            var descendant = FindVisualChild<T>(child);
+            if (descendant is not null)
+            {
+                return descendant;
+            }
+        }
+
+        return null;
+    }
+
+    private static void FlushDispatcher() =>
+        Dispatcher.CurrentDispatcher.Invoke(static () => { }, DispatcherPriority.ApplicationIdle);
+
+    private static void RunOnStaThread(Action action)
+    {
+        Exception? failure = null;
+        var thread = new Thread(() =>
+        {
+            try
+            {
+                action();
+            }
+            catch (Exception exception)
+            {
+                failure = exception;
+            }
+            finally
+            {
+                Dispatcher.CurrentDispatcher.InvokeShutdown();
+            }
+        });
+
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.Start();
+        thread.Join();
+
+        if (failure is not null)
+        {
+            ExceptionDispatchInfo.Capture(failure).Throw();
+        }
+    }
+
+    private sealed class TestWindow : Window, IDisposable
+    {
+        public void Dispose() => Close();
+    }
+
+    private sealed class ViewState : INotifyPropertyChanged
+    {
+        private DateTime? _selectedDate;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public DateTime? SelectedDate
+        {
+            get => _selectedDate;
+            set
+            {
+                if (_selectedDate == value)
+                {
+                    return;
+                }
+
+                _selectedDate = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(SelectedDate)));
+            }
+        }
+    }
+}
diff --git a/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingWindowLifecycleTests.cs b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingWindowLifecycleTests.cs
new file mode 100644
index 0000000..994fc29
--- /dev/null
+++ b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingWindowLifecycleTests.cs
@@ -0,0 +1,93 @@
+using AsyncNavigation.Floating;
+using AsyncNavigation.Wpf.Floating;
+using System.Runtime.ExceptionServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Threading;
+
+namespace AsyncNavigation.Wpf.E2E.Tests;
+
+public sealed class FloatingWindowLifecycleTests
+{
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void Dock_and_close_raise_separate_requests(bool dock)
+    {
+        RunOnStaThread(() =>
+        {
+            var content = new Border();
+            var restoreRequested = false;
+            var closeRequested = false;
+            var host = new WpfFloatingWindowHost(new FloatingWindowOptions
+            {
+                Title = "Floating lifecycle test",
+                Width = 320,
+                Height = 240
+            });
+
+            host.SetContentAsync(content).GetAwaiter().GetResult();
+            host.ShowAsync().GetAwaiter().GetResult();
+            var window = Window.GetWindow(content)
+                ?? throw new InvalidOperationException("The floating window was not created.");
+
+            host.RestoreRequested += (_, _) => restoreRequested = true;
+            host.CloseRequested += async (_, _) =>
+            {
+                closeRequested = true;
+                await host.SetContentAsync(null);
+                await host.CloseAsync();
+                await host.DisposeAsync();
+            };
+
+            if (dock)
+            {
+                var panel = (DockPanel)window.Content!;
+                var button = (Button)panel.Children[0];
+                button.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            }
+            else
+            {
+                window.Close();
+            }
+            FlushDispatcher();
+
+            Assert.Equal(dock, restoreRequested);
+            Assert.Equal(!dock, closeRequested);
+            Assert.Equal(dock, window.IsVisible);
+            host.DisposeAsync().AsTask().GetAwaiter().GetResult();
+        });
+    }
+
+    private static void FlushDispatcher() =>
+        Dispatcher.CurrentDispatcher.Invoke(static () => { }, DispatcherPriority.ApplicationIdle);
+
+    private static void RunOnStaThread(Action action)
+    {
+        Exception? failure = null;
+        var thread = new Thread(() =>
+        {
+            try
+            {
+                action();
+            }
+            catch (Exception exception)
+            {
+                failure = exception;
+            }
+            finally
+            {
+                Dispatcher.CurrentDispatcher.InvokeShutdown();
+            }
+        });
+
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.Start();
+        thread.Join();
+
+        if (failure is not null)
+        {
+            ExceptionDispatchInfo.Capture(failure).Throw();
+        }
+    }
+}
diff --git a/tests/AsyncNavigation.Wpf.E2E.Tests/README.md b/tests/AsyncNavigation.Wpf.E2E.Tests/README.md
new file mode 100644
index 0000000..af7f5de
--- /dev/null
+++ b/tests/AsyncNavigation.Wpf.E2E.Tests/README.md
@@ -0,0 +1,30 @@
+# WPF floating reference test
+
+This Windows-only test documents how WPF behaves when the same view is moved
+between two top-level windows. It intentionally lives outside
+`src/AsyncNavigation.slnx`, so normal solution builds and CI test runs do not
+execute it.
+
+Run it explicitly on an interactive Windows machine:
+
+```powershell
+dotnet test tests/AsyncNavigation.Wpf.E2E.Tests/AsyncNavigation.Wpf.E2E.Tests.csproj
+```
+
+The tests do not use UI Automation. They run WPF directly on an STA thread and
+check the generated `DatePicker` instance and its date before floating, while
+floating, and after restoration. Both unbound UI state and TwoWay-bound MVVM
+state are covered.
+
+The lifecycle regression tests verify that the Dock to region button requests
+restoration, while the normal window close button requests closure without
+restoring content. Closure is deferred to avoid re-entering `Window.Close()`
+inside WPF's synchronous `Closing` event.
+
+The navigation integration tests exercise both ContentRegion and TabRegion with
+real views and windows. They verify that navigating to a cached floating instance
+activates its existing window, while a new instance can open in the main region.
+Docking into an occupied content region switches to the original instance and
+keeps the previous view available through Back. Docking into a tab region keeps
+other tabs and selects the restored tab. Equivalent tests run in the Avalonia
+headless suite with Fluent templates.