diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index 3c3e65b..bc4f685 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -1,5 +1,5 @@
 name: Bug report
-description: Report a reproducible Bare Browser bug.
+description: Report a reproducible Lumen Browser bug.
 title: "[Bug]: "
 labels:
   - bug
@@ -21,7 +21,7 @@ body:
       label: Steps to Reproduce
       description: List the smallest reliable reproduction steps.
       placeholder: |
-        1. Open Bare Browser
+        1. Open Lumen Browser
         2. ...
         3. ...
     validations:
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml
index 150e93e..e99a00e 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -1,5 +1,5 @@
 name: Feature request
-description: Suggest an improvement for Bare Browser.
+description: Suggest an improvement for Lumen Browser.
 title: "[Feature]: "
 labels:
   - enhancement
@@ -15,7 +15,7 @@ body:
     id: proposal
     attributes:
       label: Proposal
-      description: What should Bare Browser do?
+      description: What should Lumen Browser do?
     validations:
       required: true
   - type: textarea
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index 9c6fbe5..a4081ae 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -1,6 +1,6 @@
 # Code of Conduct
 
-Bare Browser aims to be a practical, respectful open-source project.
+Lumen Browser aims to be a practical, respectful open-source project.
 
 ## Expected Behavior
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0f0f589..9f04c5a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,6 +1,6 @@
 # Contributing
 
-Thanks for helping improve Bare Browser.
+Thanks for helping improve Lumen Browser.
 
 ## Development Setup
 
@@ -32,7 +32,7 @@ To launch the app as a foreground macOS bundle:
 - `Tests/MeridianBrowserTests`: unit tests.
 - `Docs`: architecture, threat model, release checklist, test plan, and WebKit limitations.
 
-The public product name is Bare Browser. The Swift package and modules still use the historical `Meridian*` names.
+The public product name is Lumen Browser. The Swift package and modules still use the historical `Meridian*` names.
 
 ## Pull Requests
 
diff --git a/DebugFixtures/download-context-menu.html b/DebugFixtures/download-context-menu.html
index cd14aa3..fcbe2a2 100644
--- a/DebugFixtures/download-context-menu.html
+++ b/DebugFixtures/download-context-menu.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
   <meta charset="utf-8">
-  <title>Bare Browser Download Context Menu Fixture</title>
+  <title>Lumen Browser Download Context Menu Fixture</title>
   <style>
     body {
       font-family: system-ui, sans-serif;
diff --git a/Docs/Architecture.md b/Docs/Architecture.md
index df97a10..0d9cd10 100644
--- a/Docs/Architecture.md
+++ b/Docs/Architecture.md
@@ -1,6 +1,6 @@
-# Bare Browser Architecture
+# Lumen Browser Architecture
 
-Bare Browser is a native macOS, SwiftUI-first, WebKit-based browser. The early codebase is package-first so model, security, command routing, and WebKit boundary code can build and test before release packaging is added.
+Lumen Browser is a native macOS, SwiftUI-first, WebKit-based browser. The early codebase is package-first so model, security, command routing, and WebKit boundary code can build and test before release packaging is added.
 
 ## Targets
 
diff --git a/Docs/ThreatModel.md b/Docs/ThreatModel.md
index 33528ae..b1c798e 100644
--- a/Docs/ThreatModel.md
+++ b/Docs/ThreatModel.md
@@ -23,7 +23,7 @@
 - URL navigation is centralized in `URLSecurityPolicy`.
 - Unsafe script/data schemes are blocked.
 - External app and `file://` links create a pending native confirmation before any external handoff, retaining the target URL for approval while reducing source page context to a sanitized host or scheme label.
-- Non-local HTTP main-frame navigations are HTTPS-first where practical: explicit opens and WebKit main-frame HTTP actions first attempt the HTTPS equivalent, while localhost and loopback URLs remain HTTP for local development. If a tracked HTTPS upgrade attempt falls back to HTTP, Bare Browser shows the generic insecure-transport status message without embedding the full URL.
+- Non-local HTTP main-frame navigations are HTTPS-first where practical: explicit opens and WebKit main-frame HTTP actions first attempt the HTTPS equivalent, while localhost and loopback URLs remain HTTP for local development. If a tracked HTTPS upgrade attempt falls back to HTTP, Lumen Browser shows the generic insecure-transport status message without embedding the full URL.
 - TLS certificate failures are not silently downgraded to HTTP fallback.
 - WebKit downloads are routed through a native save-location confirmation before bytes are written.
 - The download policy sanitizes candidate filenames, avoids existing destination paths, blocks installer-like packages, and requires explicit confirmation for executable-like extensions.
@@ -39,11 +39,11 @@
 - Pop-up/new-window requests and WebKit media-capture permission callbacks are routed through store state before any grant; unsupported permission kinds are denied with an explicit message.
 - Autoplay is configured to require a user gesture by default.
 - Password form submissions can create a native save prompt for HTTPS origins and loopback HTTP development origins. Accepted credentials are scoped to the current persistent profile and stored in the local macOS Keychain with this-device-only accessibility; private profiles do not prompt or persist passwords.
-- Profile isolation covers website sessions and Bare Browser-managed Keychain credentials. macOS/WebKit Password AutoFill suggestions are device-wide system behavior and are not claimed as profile-isolated; Bare Browser does not use fragile webpage-specific suppression to hide them.
+- Profile isolation covers website sessions and Lumen Browser-managed Keychain credentials. macOS/WebKit Password AutoFill suggestions are device-wide system behavior and are not claimed as profile-isolated; Lumen Browser does not use fragile webpage-specific suppression to hide them.
 - The command bar returns open-tab matches only from the active profile. The intentional all-profile Activity view labels profile ownership and selects a matching space before navigation.
 - App Sandbox entitlement file includes only sandbox and outbound network client entitlement.
 - A small `WKContentRuleList` blocks common tracker/ad endpoints without request interception hacks.
-- Bare Browser does not collect product analytics, browsing telemetry, page contents, URLs, cookies, tokens, or private browsing data; website passwords are stored only after explicit local confirmation, and developer log modes stream only local OS logs.
+- Lumen Browser does not collect product analytics, browsing telemetry, page contents, URLs, cookies, tokens, or private browsing data; website passwords are stored only after explicit local confirmation, and developer log modes stream only local OS logs.
 
 ## Required Follow-Up
 
diff --git a/Docs/WebKitLimitations.md b/Docs/WebKitLimitations.md
index d474b75..d5513ab 100644
--- a/Docs/WebKitLimitations.md
+++ b/Docs/WebKitLimitations.md
@@ -1,6 +1,6 @@
 # WebKit Limitations
 
-Bare Browser uses `WKWebView`, not Safari's full browser process or Chromium. Known limitations must be visible in product and engineering decisions.
+Lumen Browser uses `WKWebView`, not Safari's full browser process or Chromium. Known limitations must be visible in product and engineering decisions.
 
 ## Current Known Limitations
 
@@ -8,15 +8,15 @@ Bare Browser uses `WKWebView`, not Safari's full browser process or Chromium. Kn
 - Chrome extension compatibility is not available and should not be claimed.
 - Safari Web Extensions require a dedicated extension architecture and are not part of this scaffold.
 - Per-profile isolation depends on WebKit support for identified website data stores. Persistent profiles use `WKWebsiteDataStore(forIdentifier:)`; each private profile reuses one `.nonPersistent()` store until that private profile closes.
-- macOS Password AutoFill suggestions can be surfaced by WebKit independently of Bare Browser's profile-scoped Keychain credential store. These device-wide suggestions are outside the profile-isolation guarantee; webpage-specific suppression would be incomplete and fragile, so the UI distinguishes the two instead.
-- Fine-grained permission APIs vary by macOS/WebKit version. In the macOS 26.2 SDK used for this slice, `WKUIDelegate` exposes media-capture permission callbacks for camera/microphone; Bare Browser routes those through `SitePermissionPolicy`.
-- Public-profile allow/deny decisions for supported site permissions can persist in Bare Browser's session store. Private-profile permission decisions are session-only and filtered before disk writes.
-- Bare Browser's active-site permission menu can manage only WebKit delegate-backed permissions. Unsupported or configuration-only permissions are shown as limited instead of writing ineffective per-site settings.
-- Geolocation and notification permission prompts do not have equivalent public macOS `WKUIDelegate` callbacks in this SDK, so Bare Browser marks them unsupported and denies them conservatively until a safe API is available.
+- macOS Password AutoFill suggestions can be surfaced by WebKit independently of Lumen Browser's profile-scoped Keychain credential store. These device-wide suggestions are outside the profile-isolation guarantee; webpage-specific suppression would be incomplete and fragile, so the UI distinguishes the two instead.
+- Fine-grained permission APIs vary by macOS/WebKit version. In the macOS 26.2 SDK used for this slice, `WKUIDelegate` exposes media-capture permission callbacks for camera/microphone; Lumen Browser routes those through `SitePermissionPolicy`.
+- Public-profile allow/deny decisions for supported site permissions can persist in Lumen Browser's session store. Private-profile permission decisions are session-only and filtered before disk writes.
+- Lumen Browser's active-site permission menu can manage only WebKit delegate-backed permissions. Unsupported or configuration-only permissions are shown as limited instead of writing ineffective per-site settings.
+- Geolocation and notification permission prompts do not have equivalent public macOS `WKUIDelegate` callbacks in this SDK, so Lumen Browser marks them unsupported and denies them conservatively until a safe API is available.
 - Autoplay is controlled at `WKWebViewConfiguration` level by requiring a user gesture for media playback rather than by per-site WebKit callbacks.
 - TLS error handling must never be bypassed silently. The scaffold does not yet add custom override UI.
 - HTTPS-first fallback is scoped to tracked main-frame upgrade attempts. Certificate trust failures are not downgraded to HTTP; fixture coverage for WebKit delegate edge cases should be added once the signed UI test host is available.
-- Web process lifecycle and memory pressure behavior are controlled partly by WebKit; Bare Browser should layer tab unloading and restore metadata on top.
+- Web process lifecycle and memory pressure behavior are controlled partly by WebKit; Lumen Browser should layer tab unloading and restore metadata on top.
 
 ## Engineering Rule
 
diff --git a/README.md b/README.md
index 5c6fa03..8367a63 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
-# Bare Browser
+# Lumen Browser
 
-Bare Browser is an open-source, native macOS browser project built with SwiftUI
+Lumen Browser is an open-source, native macOS browser project built with SwiftUI
 and WebKit.
 
 It exists because a certain kind of browser user got left hanging.
@@ -18,7 +18,7 @@ browser that is open source, sidebar-first, WebKit-based, SwiftUI/AppKit-native,
 and shaped like it actually belongs on macOS instead of feeling like a
 cross-platform skin.
 
-Bare Browser is the reaction to that gap.
+Lumen Browser is the reaction to that gap.
 
 It is not an Arc clone. It uses original branding, assets, text, and
 implementation. The goal is to keep the part that mattered: spaces,
@@ -72,7 +72,7 @@ history results.
 
 ## Repository Notes
 
-The public product name is Bare Browser. The Swift package, module names, and
+The public product name is Lumen Browser. The Swift package, module names, and
 some internal symbols still use the historical `Meridian*` naming.
 
 First-party app assets live under `Resources/`. Do not add third-party assets
@@ -87,7 +87,7 @@ swift test
 ```
 
 `script/build_and_run.sh` stages the SwiftPM GUI executable into
-`dist/Bare Browser.app` before launching it, which gives the app foreground
+`dist/Lumen Browser.app` before launching it, which gives the app foreground
 macOS bundle behavior that `swift run MeridianBrowser` does not reliably provide.
 It also supports `--debug`, `--logs`, `--subsystem-logs`, and `--verify`.
 
@@ -100,15 +100,15 @@ the Xcode app/UI test host and owner-approved signing setup are available.
 
 ## Privacy And Diagnostics
 
-Bare Browser does not collect product analytics, browsing telemetry, page contents,
+Lumen Browser does not collect product analytics, browsing telemetry, page contents,
 URLs, cookies, tokens, or private browsing data. Website passwords are stored only
 after explicit user confirmation, only for persistent profiles, and only in the
 local macOS Keychain with this-device-only accessibility. The current app has no
 analytics SDK, tracking endpoint, or network reporting path.
 
 Developer diagnostics are local only. `script/build_and_run.sh --logs` streams
-local OS log entries for the Bare Browser process, and `--subsystem-logs` streams
-local OS log entries for Bare Browser's bundle subsystem. These modes do not send
+local OS log entries for the Lumen Browser process, and `--subsystem-logs` streams
+local OS log entries for Lumen Browser's bundle subsystem. These modes do not send
 diagnostic data off the machine.
 
 ## Documentation
@@ -129,4 +129,4 @@ diagnostic data off the machine.
 
 ## License
 
-Bare Browser is released under the MIT License. See [LICENSE](LICENSE).
+Lumen Browser is released under the MIT License. See [LICENSE](LICENSE).
diff --git a/Resources/LumenIconSources/LumenDark.png b/Resources/LumenIconSources/LumenDark.png
new file mode 100644
index 0000000..7fedb46
Binary files /dev/null and b/Resources/LumenIconSources/LumenDark.png differ
diff --git a/Resources/LumenIconSources/LumenLight.png b/Resources/LumenIconSources/LumenLight.png
new file mode 100644
index 0000000..c9b0ebe
Binary files /dev/null and b/Resources/LumenIconSources/LumenLight.png differ
diff --git a/Resources/LumenLogo.icon/Assets/LumenDark.png b/Resources/LumenLogo.icon/Assets/LumenDark.png
new file mode 100644
index 0000000..7fedb46
Binary files /dev/null and b/Resources/LumenLogo.icon/Assets/LumenDark.png differ
diff --git a/Resources/LumenLogo.icon/Assets/LumenLight.png b/Resources/LumenLogo.icon/Assets/LumenLight.png
new file mode 100644
index 0000000..c9b0ebe
Binary files /dev/null and b/Resources/LumenLogo.icon/Assets/LumenLight.png differ
diff --git a/Resources/LumenLogo.icon/icon.json b/Resources/LumenLogo.icon/icon.json
new file mode 100644
index 0000000..7d7f4e7
--- /dev/null
+++ b/Resources/LumenLogo.icon/icon.json
@@ -0,0 +1,47 @@
+{
+  "fill" : {
+    "automatic-gradient" : "extended-srgb:0.00000,0.53333,1.00000,1.00000"
+  },
+  "groups" : [
+    {
+      "layers" : [
+        {
+          "image-name" : "LumenDark.png",
+          "name" : "LumenDark",
+          "opacity-specializations" : [
+            {
+              "value" : 0
+            },
+            {
+              "appearance" : "dark",
+              "value" : 1
+            },
+            {
+              "appearance" : "tinted",
+              "value" : 0
+            }
+          ]
+        },
+        {
+          "image-name" : "LumenLight.png",
+          "name" : "LumenLight"
+        }
+      ],
+      "name" : "Lumen Artwork",
+      "shadow" : {
+        "kind" : "neutral",
+        "opacity" : 0.5
+      },
+      "translucency" : {
+        "enabled" : false,
+        "value" : 0.5
+      }
+    }
+  ],
+  "supported-platforms" : {
+    "circles" : [
+      "watchOS"
+    ],
+    "squares" : "shared"
+  }
+}
\ No newline at end of file
diff --git a/Resources/MammothLogo.icon/Assets/Image.png b/Resources/MammothLogo.icon/Assets/Image.png
deleted file mode 100644
index 66d9fe9..0000000
Binary files a/Resources/MammothLogo.icon/Assets/Image.png and /dev/null differ
diff --git a/Resources/MammothLogo.icon/Assets/mammoth_blue.png b/Resources/MammothLogo.icon/Assets/mammoth_blue.png
deleted file mode 100644
index 5b02f38..0000000
Binary files a/Resources/MammothLogo.icon/Assets/mammoth_blue.png and /dev/null differ
diff --git a/Resources/MammothLogo.icon/Assets/mammoth_lime.png b/Resources/MammothLogo.icon/Assets/mammoth_lime.png
deleted file mode 100644
index 2fe6009..0000000
Binary files a/Resources/MammothLogo.icon/Assets/mammoth_lime.png and /dev/null differ
diff --git a/Resources/MammothLogo.icon/Assets/mammoth_teal.png b/Resources/MammothLogo.icon/Assets/mammoth_teal.png
deleted file mode 100644
index d21f253..0000000
Binary files a/Resources/MammothLogo.icon/Assets/mammoth_teal.png and /dev/null differ
diff --git a/Resources/MammothLogo.icon/Assets/small-dock-mammoth-silhouette-with-eye.png b/Resources/MammothLogo.icon/Assets/small-dock-mammoth-silhouette-with-eye.png
deleted file mode 100644
index 6cf26ec..0000000
Binary files a/Resources/MammothLogo.icon/Assets/small-dock-mammoth-silhouette-with-eye.png and /dev/null differ
diff --git a/Resources/MammothLogo.icon/icon.json b/Resources/MammothLogo.icon/icon.json
deleted file mode 100644
index 9f3ba53..0000000
--- a/Resources/MammothLogo.icon/icon.json
+++ /dev/null
@@ -1,119 +0,0 @@
-{
-  "fill" : "automatic",
-  "groups" : [
-    {
-      "layers" : [
-        {
-          "fill-specializations" : [
-            {
-              "value" : {
-                "solid" : "display-p3:0.00000,0.00000,0.00000,1.00000"
-              }
-            },
-            {
-              "appearance" : "dark",
-              "value" : {
-                "solid" : "display-p3:0.98230,1.00000,0.98895,0.82311"
-              }
-            },
-            {
-              "appearance" : "tinted",
-              "value" : {
-                "solid" : "display-p3:0.82039,0.82039,0.82039,1.00000"
-              }
-            }
-          ],
-          "glass" : true,
-          "hidden" : false,
-          "image-name" : "small-dock-mammoth-silhouette-with-eye.png",
-          "name" : "small-dock-mammoth-silhouette-with-eye",
-          "position" : {
-            "scale" : 0.89,
-            "translation-in-points" : [
-              26.049999999999898,
-              4.840000000000089
-            ]
-          }
-        },
-        {
-          "fill" : {
-            "solid" : "display-p3:0.96783,0.23682,0.50625,1.00000"
-          },
-          "hidden" : true,
-          "image-name" : "Image.png",
-          "name" : "Image",
-          "position" : {
-            "scale" : 0.89,
-            "translation-in-points" : [
-              26.05000000000001,
-              4.8400000000001455
-            ]
-          }
-        },
-        {
-          "blend-mode" : "plus-darker",
-          "fill" : {
-            "solid" : "extended-srgb:0.00000,0.53333,1.00000,1.00000"
-          },
-          "glass" : true,
-          "hidden" : true,
-          "image-name" : "mammoth_blue.png",
-          "name" : "Blue mammoth",
-          "opacity" : 0.57,
-          "position" : {
-            "scale" : 1,
-            "translation-in-points" : [
-              2.9500000000000455,
-              5.2000000000000455
-            ]
-          }
-        },
-        {
-          "blend-mode" : "normal",
-          "glass" : true,
-          "hidden" : true,
-          "image-name" : "mammoth_teal.png",
-          "name" : "Teal offset",
-          "opacity" : 0.73,
-          "position" : {
-            "scale" : 1,
-            "translation-in-points" : [
-              0,
-              0
-            ]
-          }
-        },
-        {
-          "blend-mode" : "normal",
-          "fill" : "none",
-          "glass" : true,
-          "hidden" : true,
-          "image-name" : "mammoth_lime.png",
-          "name" : "Lime offset",
-          "opacity" : 0.31,
-          "position" : {
-            "scale" : 1,
-            "translation-in-points" : [
-              0,
-              0
-            ]
-          }
-        }
-      ],
-      "shadow" : {
-        "kind" : "neutral",
-        "opacity" : 0.25
-      },
-      "translucency" : {
-        "enabled" : false,
-        "value" : 0
-      }
-    }
-  ],
-  "supported-platforms" : {
-    "circles" : [
-      "watchOS"
-    ],
-    "squares" : "shared"
-  }
-}
\ No newline at end of file
diff --git a/Resources/README.md b/Resources/README.md
index d3156fc..5cc7237 100644
--- a/Resources/README.md
+++ b/Resources/README.md
@@ -1,10 +1,11 @@
 # Resources
 
-This directory contains first-party Bare Browser app assets.
+This directory contains first-party Lumen Browser app assets.
 
 Current assets:
 
-- `MammothLogo.icon`: app icon source consumed by `script/build_and_run.sh`.
+- `LumenLogo.icon`: native Liquid Glass app icon source consumed by `script/build_and_run.sh`.
+- `LumenIconSources/`: byte-identical light and dark source artwork used by Icon Composer.
 
 Unless a file in this directory says otherwise, these assets are distributed under the repository license.
 
diff --git a/SECURITY.md b/SECURITY.md
index a465622..5422b27 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,6 +1,6 @@
 # Security Policy
 
-Bare Browser is an early-stage macOS browser project. Security reports are welcome and should be handled privately before public disclosure.
+Lumen Browser is an early-stage macOS browser project. Security reports are welcome and should be handled privately before public disclosure.
 
 ## Supported Versions
 
@@ -37,7 +37,7 @@ In scope:
 Out of scope:
 
 - Vulnerabilities solely in websites loaded by the browser.
-- Issues requiring malicious local code execution outside Bare Browser.
+- Issues requiring malicious local code execution outside Lumen Browser.
 - Denial-of-service reports without a security or privacy impact.
 
 ## Disclosure
diff --git a/SUPPORT.md b/SUPPORT.md
index 74b0015..4463bf0 100644
--- a/SUPPORT.md
+++ b/SUPPORT.md
@@ -1,6 +1,6 @@
 # Support
 
-Bare Browser is an early-stage open-source project, not a supported release product.
+Lumen Browser is an early-stage open-source project, not a supported release product.
 
 Use GitHub issues for reproducible bugs, feature requests, documentation problems, and build failures. Include your macOS, Xcode, and Swift versions when reporting build or runtime issues.
 
diff --git a/Sources/MeridianBrowser/MeridianBrowserApp.swift b/Sources/MeridianBrowser/MeridianBrowserApp.swift
index 952bbd7..f32e9ca 100644
--- a/Sources/MeridianBrowser/MeridianBrowserApp.swift
+++ b/Sources/MeridianBrowser/MeridianBrowserApp.swift
@@ -43,7 +43,7 @@ struct MeridianBrowserApp: App {
     }
 
     var body: some Scene {
-        WindowGroup("Bare Browser") {
+        WindowGroup("Lumen Browser") {
             BrowserWindowView(store: store)
                 .frame(minWidth: 900, minHeight: 620)
                 .onChange(of: scenePhase) { _, phase in
diff --git a/Sources/MeridianCore/Models/ProfileIsolation.swift b/Sources/MeridianCore/Models/ProfileIsolation.swift
index 043dd15..44fd068 100644
--- a/Sources/MeridianCore/Models/ProfileIsolation.swift
+++ b/Sources/MeridianCore/Models/ProfileIsolation.swift
@@ -82,9 +82,9 @@ public struct SessionIntegrityRepairReport: Codable, Equatable, Sendable {
             return nil
         }
         if duplicateWebsiteDataStoresIsolated > 0 {
-            return "Bare Browser separated profiles that were sharing website data. Some affected profiles were signed out for safety."
+            return "Lumen Browser separated profiles that were sharing website data. Some affected profiles were signed out for safety."
         }
-        return "Bare Browser repaired saved profile and space assignments before restoring this session."
+        return "Lumen Browser repaired saved profile and space assignments before restoring this session."
     }
 }
 
@@ -166,7 +166,7 @@ public struct ProfileIsolationDiagnostics: Equatable, Sendable {
         } ?? "none"
 
         return """
-        Bare Browser Profile Isolation Diagnostics
+        Lumen Browser Profile Isolation Diagnostics
         Generated: \(generatedAt.formatted(.iso8601))
         App: \(version) (\(build))
         OS: \(os)
diff --git a/Sources/MeridianCore/Security/DownloadConfirmationRequest.swift b/Sources/MeridianCore/Security/DownloadConfirmationRequest.swift
index 708e8c2..5baff59 100644
--- a/Sources/MeridianCore/Security/DownloadConfirmationRequest.swift
+++ b/Sources/MeridianCore/Security/DownloadConfirmationRequest.swift
@@ -76,7 +76,7 @@ public struct DownloadConfirmationRequest: Identifiable, Equatable, Sendable {
 
     public var confirmationMessage: String {
         var lines = [
-            "Bare Browser will only save this download after you choose a destination.",
+            "Lumen Browser will only save this download after you choose a destination.",
             "",
             "File: \(sanitizedFilename)",
             "Source: \(sourceDescription)"
diff --git a/Sources/MeridianCore/Security/DownloadSafetyPolicy.swift b/Sources/MeridianCore/Security/DownloadSafetyPolicy.swift
index 2b1a63d..6562035 100644
--- a/Sources/MeridianCore/Security/DownloadSafetyPolicy.swift
+++ b/Sources/MeridianCore/Security/DownloadSafetyPolicy.swift
@@ -143,7 +143,7 @@ public struct DownloadSafetyPolicy: Sendable {
         let timestamp = String(Int(date.timeIntervalSince1970), radix: 16)
         let origin = sourceMetadata.quarantineOrigin
             .flatMap { quarantineMetadataOrigin(from: URL(string: $0)) } ?? ""
-        return "0083;\(timestamp);Bare Browser;\(origin)"
+        return "0083;\(timestamp);Lumen Browser;\(origin)"
     }
 
     private func sourceDisplayDescription(from sourceURL: URL) -> String {
diff --git a/Sources/MeridianCore/Security/PasswordCredentialStore.swift b/Sources/MeridianCore/Security/PasswordCredentialStore.swift
index dd3fd42..2c74dd3 100644
--- a/Sources/MeridianCore/Security/PasswordCredentialStore.swift
+++ b/Sources/MeridianCore/Security/PasswordCredentialStore.swift
@@ -253,12 +253,15 @@ public extension PasswordCredentialPersisting {
 }
 
 public final class KeychainPasswordCredentialStore: PasswordCredentialPersisting {
-    public static let defaultServicePrefix = "BareBrowser.WebsitePasswords"
-    public static let legacyServicePrefixes = ["MeridianBrowser.WebsitePasswords"]
+    public static let defaultServicePrefix = "LumenBrowser.WebsitePasswords"
+    public static let legacyServicePrefixes = [
+        "BareBrowser.WebsitePasswords",
+        "MeridianBrowser.WebsitePasswords"
+    ]
 
     private let servicePrefix: String
     private let legacyServicePrefixes: [String]
-    private let keychainLabelPrefix = "Bare Browser password for "
+    private let keychainLabelPrefix = "Lumen Browser password for "
     private let keychainDescription = "Website password"
 
     public init(
diff --git a/Sources/MeridianCore/Security/SitePermissionPolicy.swift b/Sources/MeridianCore/Security/SitePermissionPolicy.swift
index 7ec05ee..1172e2c 100644
--- a/Sources/MeridianCore/Security/SitePermissionPolicy.swift
+++ b/Sources/MeridianCore/Security/SitePermissionPolicy.swift
@@ -267,6 +267,6 @@ public struct SitePermissionPolicy: Sendable {
     }
 
     private func unsupportedReason(for kind: SitePermissionKind) -> String {
-        "\(kind.displayTitle) permissions are not supported by Bare Browser on this WebKit version."
+        "\(kind.displayTitle) permissions are not supported by Lumen Browser on this WebKit version."
     }
 }
diff --git a/Sources/MeridianCore/Security/URLConfirmationRequest.swift b/Sources/MeridianCore/Security/URLConfirmationRequest.swift
index a39b6c6..f5e8c94 100644
--- a/Sources/MeridianCore/Security/URLConfirmationRequest.swift
+++ b/Sources/MeridianCore/Security/URLConfirmationRequest.swift
@@ -112,9 +112,9 @@ public struct URLConfirmationRequest: Identifiable, Equatable, Sendable {
     public var confirmationMessage: String {
         switch kind {
         case .externalApplication:
-            return "Bare Browser will hand this link to another app only if you approve.\n\nLink: \(displayURL)\nSource: \(sourceDescription)"
+            return "Lumen Browser will hand this link to another app only if you approve.\n\nLink: \(displayURL)\nSource: \(sourceDescription)"
         case .localFile:
-            return "Bare Browser blocked local file access until you approve opening it outside the web view.\n\nFile: \(displayURL)\nSource: \(sourceDescription)"
+            return "Lumen Browser blocked local file access until you approve opening it outside the web view.\n\nFile: \(displayURL)\nSource: \(sourceDescription)"
         }
     }
 
diff --git a/Sources/MeridianCore/Services/SQLiteLocalHistoryPersistenceStore.swift b/Sources/MeridianCore/Services/SQLiteLocalHistoryPersistenceStore.swift
index 797ead1..adea3f0 100644
--- a/Sources/MeridianCore/Services/SQLiteLocalHistoryPersistenceStore.swift
+++ b/Sources/MeridianCore/Services/SQLiteLocalHistoryPersistenceStore.swift
@@ -13,7 +13,7 @@ public enum LocalHistoryPersistenceRecoveryReason: Equatable, Sendable {
         case .noSavedHistory:
             return nil
         case .unreadableStore, .corruptPayload, .unsupportedSchema, .repairedHistory:
-            return "Bare Browser restored local history from a clean state because saved history was unavailable."
+            return "Lumen Browser restored local history from a clean state because saved history was unavailable."
         }
     }
 }
@@ -42,8 +42,11 @@ public final class SQLiteLocalHistoryPersistenceStore: LocalHistoryPersisting {
     public static let currentSchemaVersion = 1
 
     private static let recordID = "main"
-    private static let supportDirectoryName = "Bare Browser"
-    private static let legacySupportDirectoryName = "Meridian Browser"
+    private static let supportDirectoryName = "Lumen Browser"
+    private static let legacySupportDirectoryNames = [
+        "Bare Browser",
+        "Meridian Browser"
+    ]
     private static let sqliteTransient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
 
     public let databaseURL: URL
@@ -86,11 +89,17 @@ public final class SQLiteLocalHistoryPersistenceStore: LocalHistoryPersisting {
             return currentURL
         }
 
-        let legacyURL = applicationSupport
-            .appendingPathComponent(legacySupportDirectoryName, isDirectory: true)
-            .appendingPathComponent(databaseFilename, isDirectory: false)
+        for legacySupportDirectoryName in legacySupportDirectoryNames {
+            let legacyURL = applicationSupport
+                .appendingPathComponent(legacySupportDirectoryName, isDirectory: true)
+                .appendingPathComponent(databaseFilename, isDirectory: false)
+
+            if fileManager.fileExists(atPath: legacyURL.path) {
+                return legacyURL
+            }
+        }
 
-        return fileManager.fileExists(atPath: legacyURL.path) ? legacyURL : currentURL
+        return currentURL
     }
 
     public func loadHistory(profiles: [BrowserProfile]) -> LocalHistoryPersistenceLoadResult {
diff --git a/Sources/MeridianCore/Services/SQLiteSessionPersistenceStore.swift b/Sources/MeridianCore/Services/SQLiteSessionPersistenceStore.swift
index dc48888..2c10e68 100644
--- a/Sources/MeridianCore/Services/SQLiteSessionPersistenceStore.swift
+++ b/Sources/MeridianCore/Services/SQLiteSessionPersistenceStore.swift
@@ -15,7 +15,7 @@ public enum SessionPersistenceRecoveryReason: Equatable, Sendable {
         case .repairedSnapshot:
             return nil
         case .unreadableStore, .corruptPayload, .unsupportedSchema:
-            return "Bare Browser restored a clean browser session because saved session state was unavailable."
+            return "Lumen Browser restored a clean browser session because saved session state was unavailable."
         }
     }
 }
@@ -47,8 +47,11 @@ public final class SQLiteSessionPersistenceStore: SessionSnapshotPersisting {
     public static let currentSchemaVersion = 1
 
     private static let recordID = "main"
-    private static let supportDirectoryName = "Bare Browser"
-    private static let legacySupportDirectoryName = "Meridian Browser"
+    private static let supportDirectoryName = "Lumen Browser"
+    private static let legacySupportDirectoryNames = [
+        "Bare Browser",
+        "Meridian Browser"
+    ]
     private static let sqliteTransient = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
 
     public let databaseURL: URL
@@ -91,11 +94,17 @@ public final class SQLiteSessionPersistenceStore: SessionSnapshotPersisting {
             return currentURL
         }
 
-        let legacyURL = applicationSupport
-            .appendingPathComponent(legacySupportDirectoryName, isDirectory: true)
-            .appendingPathComponent(databaseFilename, isDirectory: false)
+        for legacySupportDirectoryName in legacySupportDirectoryNames {
+            let legacyURL = applicationSupport
+                .appendingPathComponent(legacySupportDirectoryName, isDirectory: true)
+                .appendingPathComponent(databaseFilename, isDirectory: false)
+
+            if fileManager.fileExists(atPath: legacyURL.path) {
+                return legacyURL
+            }
+        }
 
-        return fileManager.fileExists(atPath: legacyURL.path) ? legacyURL : currentURL
+        return currentURL
     }
 
     public func loadSnapshot(
diff --git a/Sources/MeridianCore/Services/SessionIntegrityRepair.swift b/Sources/MeridianCore/Services/SessionIntegrityRepair.swift
index f8e6d93..00580c5 100644
--- a/Sources/MeridianCore/Services/SessionIntegrityRepair.swift
+++ b/Sources/MeridianCore/Services/SessionIntegrityRepair.swift
@@ -109,7 +109,7 @@ enum SessionIntegrityRepair {
             repaired.state = .failed
             repaired.updatedAt = snapshot.capturedAt
             repaired.completedAt = snapshot.capturedAt
-            repaired.failureMessage = "Download was interrupted when Bare Browser closed."
+            repaired.failureMessage = "Download was interrupted when Lumen Browser closed."
             return repaired
         }
 
diff --git a/Sources/MeridianCore/Stores/BrowserStore.swift b/Sources/MeridianCore/Stores/BrowserStore.swift
index 8584c61..f9ec551 100644
--- a/Sources/MeridianCore/Stores/BrowserStore.swift
+++ b/Sources/MeridianCore/Stores/BrowserStore.swift
@@ -2590,7 +2590,7 @@ public final class BrowserStore: ObservableObject {
                 fallback: SessionSnapshotFactory.initial(date: date)
             )
         } catch {
-            lastUserMessage = "Session changes could not be saved. Bare Browser will keep browsing state in memory for this run."
+            lastUserMessage = "Session changes could not be saved. Lumen Browser will keep browsing state in memory for this run."
         }
     }
 
@@ -2602,7 +2602,7 @@ public final class BrowserStore: ObservableObject {
         do {
             try localHistoryPersistence.saveHistory(localHistoryStore.entries, profiles: profiles)
         } catch {
-            lastUserMessage = "History changes could not be saved. Bare Browser will keep history in memory for this run."
+            lastUserMessage = "History changes could not be saved. Lumen Browser will keep history in memory for this run."
         }
     }
 
diff --git a/Sources/MeridianCore/Views/Browser/ProfileManagementView.swift b/Sources/MeridianCore/Views/Browser/ProfileManagementView.swift
index 7169db5..cbc7544 100644
--- a/Sources/MeridianCore/Views/Browser/ProfileManagementView.swift
+++ b/Sources/MeridianCore/Views/Browser/ProfileManagementView.swift
@@ -68,7 +68,7 @@ struct ProfileManagementView: View {
             Divider()
 
             HStack {
-                Text("Profiles keep website sessions, history, Bare Browser-managed passwords, and supported site permissions separate. macOS AutoFill suggestions are device-wide.")
+                Text("Profiles keep website sessions, history, Lumen Browser-managed passwords, and supported site permissions separate. macOS AutoFill suggestions are device-wide.")
                     .font(.caption)
                     .foregroundStyle(.secondary)
 
diff --git a/Sources/MeridianCore/Views/BrowserWindowView.swift b/Sources/MeridianCore/Views/BrowserWindowView.swift
index cf43328..aa66338 100644
--- a/Sources/MeridianCore/Views/BrowserWindowView.swift
+++ b/Sources/MeridianCore/Views/BrowserWindowView.swift
@@ -115,7 +115,7 @@ public struct BrowserWindowView: View {
                 }
                 Button("OK", role: .cancel) {}
             } message: {
-                Text(store.profileIsolationRepairReport.userMessage ?? "Bare Browser repaired saved profile assignments before browsing began.")
+                Text(store.profileIsolationRepairReport.userMessage ?? "Lumen Browser repaired saved profile assignments before browsing began.")
             }
             .overlay {
                 if store.isCommandBarPresented {
@@ -744,7 +744,7 @@ private struct PasswordSavePromptLayer: View {
                         VStack(alignment: .leading, spacing: 3) {
                             Text("Save this password?")
                                 .font(.title3.weight(.semibold))
-                            Text("Store this sign-in locally in your macOS Keychain for autofill in Bare Browser.")
+                            Text("Store this sign-in locally in your macOS Keychain for autofill in Lumen Browser.")
                                 .font(.callout)
                                 .foregroundStyle(.secondary)
                                 .fixedSize(horizontal: false, vertical: true)
@@ -1855,7 +1855,7 @@ private struct WindowChromeController: NSViewRepresentable {
 
 private extension NSWindow {
     func applyMeridianChrome() {
-        title = "Bare Browser"
+        title = "Lumen Browser"
         titleVisibility = .hidden
         titlebarAppearsTransparent = true
         titlebarSeparatorStyle = .none
diff --git a/Sources/MeridianCore/Views/Sidebar/SidebarSpaceCreationPull.swift b/Sources/MeridianCore/Views/Sidebar/SidebarSpaceCreationPull.swift
new file mode 100644
index 0000000..4028bd7
--- /dev/null
+++ b/Sources/MeridianCore/Views/Sidebar/SidebarSpaceCreationPull.swift
@@ -0,0 +1,380 @@
+import SwiftUI
+
+struct SidebarSpaceCreationPullEligibility {
+    static func canBegin(
+        creationIsAvailable: Bool,
+        gestureOrigin: SidebarSpacePagerPhysicalGestureOrigin,
+        currentOffsetX: CGFloat,
+        lastPageOffsetX: CGFloat,
+        lastPageIndex: Int
+    ) -> Bool {
+        guard creationIsAvailable,
+              currentOffsetX.isFinite,
+              lastPageOffsetX.isFinite,
+              lastPageIndex >= 0 else {
+            return false
+        }
+
+        if gestureOrigin.anchoredPageIndex == lastPageIndex {
+            return true
+        }
+
+        return gestureOrigin.scrollWasIdle
+            && abs(currentOffsetX - lastPageOffsetX)
+                <= SidebarSpacePagerMetrics.creationSettledOffsetTolerance
+    }
+}
+
+enum SidebarSpaceCreationPullDisposition: Equatable, Sendable {
+    case pulling
+    case cancelled
+}
+
+struct SidebarSpaceCreationPullUpdate: Equatable, Sendable {
+    let disposition: SidebarSpaceCreationPullDisposition
+    let displayedDistance: CGFloat
+    let progress: CGFloat
+}
+
+enum SidebarSpaceCreationPullReleaseOutcome: Equatable, Sendable {
+    case none
+    case cancel
+    case create
+}
+
+struct SidebarSpaceCreationPullState: Equatable, Sendable {
+    private(set) var unresistedDistance: CGFloat = 0
+    private(set) var displayedDistance: CGFloat = 0
+    private(set) var progress: CGFloat = 0
+    private var isActive = false
+
+    mutating func begin(
+        initialForwardDistance: CGFloat,
+        pageWidth: CGFloat
+    ) -> SidebarSpaceCreationPullUpdate? {
+        guard initialForwardDistance.isFinite,
+              initialForwardDistance > 0 else {
+            return nil
+        }
+
+        isActive = true
+        unresistedDistance = 0
+        return applyForwardDistance(initialForwardDistance, pageWidth: pageWidth)
+    }
+
+    mutating func consumeAdjustedDelta(
+        _ adjustedDeltaX: CGFloat,
+        pageWidth: CGFloat
+    ) -> SidebarSpaceCreationPullUpdate? {
+        guard isActive,
+              adjustedDeltaX.isFinite else {
+            return nil
+        }
+
+        let proposedDistance = unresistedDistance + adjustedDeltaX
+        guard proposedDistance > 0 else {
+            cancel()
+            return SidebarSpaceCreationPullUpdate(
+                disposition: .cancelled,
+                displayedDistance: 0,
+                progress: 0
+            )
+        }
+
+        return applyForwardDistance(proposedDistance, pageWidth: pageWidth)
+    }
+
+    mutating func release() -> SidebarSpaceCreationPullReleaseOutcome {
+        guard isActive else {
+            return .none
+        }
+
+        isActive = false
+        return progress >= 1 ? .create : .cancel
+    }
+
+    mutating func cancel() {
+        isActive = false
+        unresistedDistance = 0
+        displayedDistance = 0
+        progress = 0
+    }
+
+    static func resistedDistance(for distance: CGFloat, pageWidth: CGFloat) -> CGFloat {
+        guard distance.isFinite,
+              distance > 0,
+              pageWidth.isFinite,
+              pageWidth > 0 else {
+            return 0
+        }
+
+        let coefficient = SidebarSpacePagerMetrics.creationPullResistance
+        let resistedDistance = (distance * pageWidth * coefficient)
+            / (pageWidth + coefficient * distance)
+        return min(resistedDistance, SidebarSpacePagerMetrics.creationRailMaximumWidth)
+    }
+
+    private mutating func applyForwardDistance(
+        _ distance: CGFloat,
+        pageWidth: CGFloat
+    ) -> SidebarSpaceCreationPullUpdate {
+        unresistedDistance = distance
+        displayedDistance = Self.resistedDistance(for: distance, pageWidth: pageWidth)
+        progress = min(
+            max(distance / SidebarSpacePagerMetrics.creationPullThreshold, 0),
+            1
+        )
+        return SidebarSpaceCreationPullUpdate(
+            disposition: .pulling,
+            displayedDistance: displayedDistance,
+            progress: progress
+        )
+    }
+}
+
+enum SidebarSpaceCreationGestureMode: Equatable, Sendable {
+    case disabled
+    case pendingDirection
+    case pulling
+    case pagingBackward
+    case cancelled
+}
+
+enum SidebarSpaceCreationGestureRouting: Equatable, Sendable {
+    case pending
+    case pagingBackward
+    case pulling(SidebarSpaceCreationPullUpdate)
+    case cancelled
+}
+
+/// Owns only the pull-past-the-last-space state machine. AppKit event routing,
+/// pager snapping, and SwiftUI presentation side effects remain outside it.
+struct SidebarSpaceCreationGestureSession: Equatable, Sendable {
+    private(set) var mode = SidebarSpaceCreationGestureMode.disabled
+    private(set) var pullState = SidebarSpaceCreationPullState()
+    private var pendingAdjustedDisplacementX: CGFloat = 0
+
+    var isPendingDirection: Bool { mode == .pendingDirection }
+    var isPulling: Bool { mode == .pulling }
+    var isCancelled: Bool { mode == .cancelled }
+    var routesBoundaryInput: Bool { mode != .disabled }
+
+    mutating func begin(canPullForward: Bool) {
+        reset()
+        guard canPullForward else {
+            return
+        }
+
+        mode = .pendingDirection
+    }
+
+    mutating func routeAdjustedDelta(
+        _ adjustedDeltaX: CGFloat,
+        pageWidth: CGFloat,
+        minimumDisplacement: CGFloat = SidebarSpacePagerMetrics.creationDirectionInferenceDistance
+    ) -> SidebarSpaceCreationGestureRouting {
+        switch mode {
+        case .disabled:
+            return .pagingBackward
+        case .pagingBackward:
+            return .pagingBackward
+        case .cancelled:
+            return .cancelled
+        case .pulling:
+            guard let update = pullState.consumeAdjustedDelta(
+                adjustedDeltaX,
+                pageWidth: pageWidth
+            ) else {
+                return .cancelled
+            }
+            if update.disposition == .cancelled {
+                mode = .cancelled
+                return .cancelled
+            }
+            return .pulling(update)
+        case .pendingDirection:
+            guard adjustedDeltaX.isFinite else {
+                return .pending
+            }
+            pendingAdjustedDisplacementX += adjustedDeltaX
+        }
+
+        guard let intent = SidebarSpacePagerHorizontalIntent.intent(
+            forAdjustedDisplacement: pendingAdjustedDisplacementX,
+            minimumDisplacement: minimumDisplacement
+        ) else {
+            return .pending
+        }
+
+        switch intent {
+        case .backward:
+            mode = .pagingBackward
+            clearPendingDirection()
+            return .pagingBackward
+        case .forward:
+            guard let update = pullState.begin(
+                initialForwardDistance: pendingAdjustedDisplacementX,
+                pageWidth: pageWidth
+            ) else {
+                return .pending
+            }
+
+            mode = .pulling
+            clearPendingDirection()
+            return .pulling(update)
+        }
+    }
+
+    mutating func finishPull(cancelled: Bool) -> SidebarSpaceCreationPullReleaseOutcome {
+        switch mode {
+        case .pulling:
+            return cancelled ? cancelPull() : pullState.release()
+        case .cancelled:
+            pullState.cancel()
+            return .cancel
+        case .disabled, .pendingDirection, .pagingBackward:
+            pullState.cancel()
+            return .none
+        }
+    }
+
+    mutating func end() {
+        mode = .disabled
+        clearPendingDirection()
+    }
+
+    mutating func reset() {
+        mode = .disabled
+        pullState.cancel()
+        clearPendingDirection()
+    }
+
+    private mutating func cancelPull() -> SidebarSpaceCreationPullReleaseOutcome {
+        pullState.cancel()
+        return .cancel
+    }
+
+    private mutating func clearPendingDirection() {
+        pendingAdjustedDisplacementX = 0
+    }
+}
+
+struct SidebarSpaceCreationPullPresentation: Equatable, Sendable {
+    var displayedDistance: CGFloat = 0
+    var progress: CGFloat = 0
+
+    var isArmed: Bool {
+        progress >= 1
+    }
+}
+
+struct SidebarSpaceCreationAffordanceLayout {
+    static func revealScale(forDisplayedDistance displayedDistance: CGFloat) -> CGFloat {
+        guard displayedDistance.isFinite else {
+            return 0
+        }
+
+        let availableWidth = max(
+            displayedDistance - SidebarSpacePagerMetrics.creationRailTrailingPadding,
+            0
+        )
+        return min(
+            availableWidth / SidebarSpacePagerMetrics.creationAffordanceDiameter,
+            1
+        )
+    }
+}
+
+@MainActor
+final class SidebarSpaceCreationPullController: ObservableObject {
+    @Published private(set) var presentation = SidebarSpaceCreationPullPresentation()
+
+    func update(displayedDistance: CGFloat, progress: CGFloat) {
+        let presentation = SidebarSpaceCreationPullPresentation(
+            displayedDistance: max(displayedDistance, 0),
+            progress: min(max(progress, 0), 1)
+        )
+        guard self.presentation != presentation else {
+            return
+        }
+        self.presentation = presentation
+    }
+
+    func returnToRest(animated: Bool) {
+        let update = {
+            self.presentation = SidebarSpaceCreationPullPresentation()
+        }
+        if animated {
+            withAnimation(SidebarSpacePagerMetrics.creationReturnAnimation, update)
+        } else {
+            update()
+        }
+    }
+}
+
+private struct SidebarSpaceCreationRailView: View {
+    let presentation: SidebarSpaceCreationPullPresentation
+    let foregroundColor: Color
+
+    var body: some View {
+        let revealScale = SidebarSpaceCreationAffordanceLayout.revealScale(
+            forDisplayedDistance: presentation.displayedDistance
+        )
+
+        HStack(spacing: 0) {
+            Spacer(minLength: 0)
+
+            ZStack {
+                Circle()
+                    .stroke(foregroundColor.opacity(0.20), lineWidth: 2.2)
+
+                Circle()
+                    .trim(from: 0, to: presentation.progress)
+                    .stroke(
+                        foregroundColor.opacity(presentation.isArmed ? 1 : 0.84),
+                        style: StrokeStyle(lineWidth: 2.4, lineCap: .round)
+                    )
+                    .rotationEffect(.degrees(-90))
+
+                Image(systemName: "plus")
+                    .font(.system(size: 12, weight: .semibold))
+                    .foregroundStyle(foregroundColor.opacity(presentation.isArmed ? 1 : 0.78))
+            }
+            .frame(
+                width: SidebarSpacePagerMetrics.creationAffordanceDiameter,
+                height: SidebarSpacePagerMetrics.creationAffordanceDiameter
+            )
+            // Keep the complete circular affordance inside the revealed gap.
+            // The former rectangular clip sliced through the ring and exposed
+            // its darker gradient backing as a visible square.
+            .scaleEffect(revealScale, anchor: .trailing)
+            .opacity(revealScale)
+
+            Spacer()
+                .frame(width: SidebarSpacePagerMetrics.creationRailTrailingPadding)
+        }
+        .allowsHitTesting(false)
+        .accessibilityHidden(true)
+    }
+}
+
+struct SidebarSpaceCreationPullPresentationModifier: ViewModifier {
+    @ObservedObject var controller: SidebarSpaceCreationPullController
+    let foregroundColor: Color
+
+    func body(content: Content) -> some View {
+        let presentation = controller.presentation
+
+        ZStack(alignment: .trailing) {
+            SidebarSpaceCreationRailView(
+                presentation: presentation,
+                foregroundColor: foregroundColor
+            )
+            .frame(width: SidebarSpacePagerMetrics.creationRailMaximumWidth)
+
+            content
+                .offset(x: -presentation.displayedDistance)
+        }
+        .clipped()
+    }
+}
diff --git a/Sources/MeridianCore/Views/Sidebar/SidebarSpacePagerInput.swift b/Sources/MeridianCore/Views/Sidebar/SidebarSpacePagerInput.swift
new file mode 100644
index 0000000..cf3a2ca
--- /dev/null
+++ b/Sources/MeridianCore/Views/Sidebar/SidebarSpacePagerInput.swift
@@ -0,0 +1,474 @@
+import AppKit
+import SwiftUI
+
+struct SidebarSpacePagerScrollInputScalingInstaller: NSViewRepresentable {
+    let sensitivity: CGFloat
+    let pageWidth: CGFloat
+    let pageCount: Int
+    let creationIsAvailable: Bool
+    let geometryTracker: SidebarSpacePagerGeometryTracker
+    let creationPullController: SidebarSpaceCreationPullController
+    let createSpace: () -> Void
+
+    func makeNSView(context: Context) -> SidebarSpacePagerScrollInputScalingView {
+        let view = SidebarSpacePagerScrollInputScalingView()
+        view.geometryTracker = geometryTracker
+        view.creationPullController = creationPullController
+        view.createSpace = createSpace
+        view.sensitivity = sensitivity
+        view.pageWidth = pageWidth
+        view.pageCount = pageCount
+        view.creationIsAvailable = creationIsAvailable
+        return view
+    }
+
+    func updateNSView(_ nsView: SidebarSpacePagerScrollInputScalingView, context: Context) {
+        nsView.geometryTracker = geometryTracker
+        nsView.creationPullController = creationPullController
+        nsView.createSpace = createSpace
+        nsView.sensitivity = sensitivity
+        nsView.pageWidth = pageWidth
+        nsView.pageCount = pageCount
+        nsView.creationIsAvailable = creationIsAvailable
+        nsView.installIfNeeded()
+    }
+
+    static func dismantleNSView(
+        _ nsView: SidebarSpacePagerScrollInputScalingView,
+        coordinator: ()
+    ) {
+        nsView.tearDown()
+    }
+}
+
+enum SidebarSpacePagerPhysicalGestureEndReason: Equatable, Sendable {
+    case physicalEnded
+    case physicalCancelled
+    case momentumBegan
+    case unphasedInput
+}
+
+/// Tracks physical finger ownership with monotonically increasing identities so
+/// a deferred completion from one gesture cannot terminate a newer gesture.
+struct SidebarSpacePagerPhysicalGestureLifecycle: Equatable, Sendable {
+    private(set) var activeGestureID: UInt64?
+    private var nextGestureID: UInt64 = 0
+
+    var isActive: Bool {
+        activeGestureID != nil
+    }
+
+    mutating func begin() -> UInt64 {
+        nextGestureID &+= 1
+        activeGestureID = nextGestureID
+        return nextGestureID
+    }
+
+    func shouldFinish(for reason: SidebarSpacePagerPhysicalGestureEndReason) -> Bool {
+        isActive
+    }
+
+    @discardableResult
+    mutating func finish(for reason: SidebarSpacePagerPhysicalGestureEndReason) -> UInt64? {
+        guard shouldFinish(for: reason),
+              let activeGestureID else {
+            return nil
+        }
+        self.activeGestureID = nil
+        return activeGestureID
+    }
+
+    @discardableResult
+    mutating func reset() -> UInt64? {
+        defer { activeGestureID = nil }
+        return activeGestureID
+    }
+}
+
+
+final class SidebarSpacePagerScrollInputScalingView: NSView {
+    weak var geometryTracker: SidebarSpacePagerGeometryTracker?
+    weak var creationPullController: SidebarSpaceCreationPullController?
+    var createSpace: (() -> Void)?
+    var sensitivity: CGFloat = 1
+    var pageWidth: CGFloat = 0 {
+        didSet {
+            guard oldValue > 0,
+                  abs(oldValue - pageWidth) > 0.5 else {
+                return
+            }
+
+            ignoreRemainderOfPhysicalGesture()
+        }
+    }
+    var pageCount = 0 {
+        didSet {
+            guard oldValue > 0,
+                  oldValue != pageCount else {
+                return
+            }
+            cancelCreationInteraction(animated: false)
+        }
+    }
+    var creationIsAvailable = false {
+        didSet {
+            if !creationIsAvailable, !gestureLifecycle.isActive {
+                cancelCreationInteraction(animated: false)
+            }
+        }
+    }
+
+    private weak var configuredScrollView: NSScrollView?
+    private var eventMonitor: Any?
+    private var deferredInstallationIsScheduled = false
+    private var gestureLifecycle = SidebarSpacePagerPhysicalGestureLifecycle()
+    private var gestureGate = SidebarSpacePagerPhysicalGestureGate()
+    private var inputScalingState = SidebarSpacePagerScrollInputScalingState()
+    private var horizontalGestureAccumulator =
+        SidebarSpacePagerHorizontalGestureAccumulator()
+    private var creationSession = SidebarSpaceCreationGestureSession()
+    private var suppressesCreationMomentum = false
+
+    override func viewDidMoveToWindow() {
+        super.viewDidMoveToWindow()
+        installIfNeeded()
+    }
+
+    override func viewDidMoveToSuperview() {
+        super.viewDidMoveToSuperview()
+        installIfNeeded()
+    }
+
+    override func viewWillMove(toWindow newWindow: NSWindow?) {
+        super.viewWillMove(toWindow: newWindow)
+        if newWindow == nil {
+            tearDown()
+        }
+    }
+
+    override func layout() {
+        super.layout()
+        installIfNeeded()
+    }
+
+    deinit {
+        MainActor.assumeIsolated {
+            tearDown()
+        }
+    }
+
+    func installIfNeeded() {
+        guard window != nil else {
+            return
+        }
+
+        let candidateScrollView = nearestScrollView
+        if let configuredScrollView,
+           configuredScrollView === candidateScrollView {
+            installEventMonitorIfNeeded()
+            return
+        }
+
+        let replacedConfiguredScrollView = configuredScrollView != nil
+        clearConfiguredScrollView()
+        if replacedConfiguredScrollView {
+            ignoreRemainderOfPhysicalGesture()
+        } else {
+            resetLocalGestureState()
+        }
+
+        guard let candidateScrollView else {
+            scheduleDeferredInstallation()
+            return
+        }
+
+        configuredScrollView = candidateScrollView
+        installEventMonitorIfNeeded()
+    }
+
+    func tearDown() {
+        clearConfiguredScrollView()
+        removeEventMonitor()
+        resetLocalGestureState()
+        deferredInstallationIsScheduled = false
+    }
+
+    private var nearestScrollView: NSScrollView? {
+        var candidate: NSView? = self
+        while let current = candidate {
+            if let scrollView = current as? NSScrollView {
+                return scrollView
+            }
+            candidate = current.superview
+        }
+
+        return enclosingScrollView
+    }
+
+    private func scheduleDeferredInstallation() {
+        guard !deferredInstallationIsScheduled else {
+            return
+        }
+
+        deferredInstallationIsScheduled = true
+        DispatchQueue.main.async { [weak self] in
+            guard let self else {
+                return
+            }
+
+            self.deferredInstallationIsScheduled = false
+            self.installIfNeeded()
+        }
+    }
+
+    private func installEventMonitorIfNeeded() {
+        guard eventMonitor == nil else {
+            return
+        }
+
+        eventMonitor = NSEvent.addLocalMonitorForEvents(matching: .scrollWheel) { [weak self] event in
+            guard let self else {
+                return event
+            }
+            return self.eventForPagerInput(from: event)
+        }
+    }
+
+    private func removeEventMonitor() {
+        if let eventMonitor {
+            NSEvent.removeMonitor(eventMonitor)
+            self.eventMonitor = nil
+        }
+    }
+
+    private func clearConfiguredScrollView() {
+        configuredScrollView = nil
+    }
+
+    private func eventForPagerInput(from event: NSEvent) -> NSEvent? {
+        guard let scrollView = configuredScrollView,
+              event.window === scrollView.window else {
+            return event
+        }
+
+        if !event.momentumPhase.isEmpty {
+            if suppressesCreationMomentum {
+                if event.momentumPhase.contains(.ended) || event.momentumPhase.contains(.cancelled) {
+                    suppressesCreationMomentum = false
+                }
+                return nil
+            }
+            finishPhysicalGesture(cancelled: false, reason: .momentumBegan)
+            return event
+        }
+
+        let phase = event.phase
+        guard !phase.isEmpty else {
+            finishPhysicalGesture(cancelled: false, reason: .unphasedInput)
+            return event
+        }
+        guard event.hasPreciseScrollingDeltas else {
+            finishPhysicalGesture(cancelled: true, reason: .physicalCancelled)
+            return event
+        }
+
+        if phase.contains(.mayBegin) || phase.contains(.began) {
+            beginGestureIfInsidePager(event, scrollView: scrollView)
+        }
+
+        if phase.contains(.ended) || phase.contains(.cancelled) {
+            let cancelled = phase.contains(.cancelled)
+            finishPhysicalGesture(
+                cancelled: cancelled,
+                reason: cancelled ? .physicalCancelled : .physicalEnded
+            )
+            return event
+        }
+
+        guard !gestureGate.ignoresChangedEvents else {
+            return event
+        }
+
+        guard phase.contains(.began) || phase.contains(.changed) else {
+            return event
+        }
+
+        if !gestureLifecycle.isActive {
+            guard phase.contains(.changed),
+                  eventIsInsidePager(event, scrollView: scrollView) else {
+                return event
+            }
+
+            beginGesture()
+        }
+
+        guard gestureLifecycle.isActive,
+              let horizontalInput = SidebarSpacePagerHorizontalInputSample(
+                scrollingDeltaX: event.scrollingDeltaX
+              ),
+              let scaledEvent = inputScalingState.scaledEvent(
+                from: event,
+                sensitivity: sensitivity
+              ) else {
+            return event
+        }
+
+        horizontalGestureAccumulator.append(horizontalInput)
+        geometryTracker?.adjustedGestureDisplacementX =
+            horizontalGestureAccumulator.cumulativeAdjustedDisplacementX
+
+        if creationSession.routesBoundaryInput {
+            let wasCancelled = creationSession.isCancelled
+            switch creationSession.routeAdjustedDelta(
+                horizontalInput.adjustedDisplacementX,
+                pageWidth: pageWidth
+            ) {
+            case .pending, .pagingBackward:
+                return scaledEvent
+            case .pulling(let update):
+                geometryTracker?.setCreationPullLocksLastPage(true)
+                creationPullController?.update(
+                    displayedDistance: update.displayedDistance,
+                    progress: update.progress
+                )
+                return nil
+            case .cancelled:
+                if !wasCancelled {
+                    creationPullController?.returnToRest(animated: true)
+                }
+                // Once a creation pull reverses past its origin, this physical
+                // gesture is cancelled and remains locked to the last page.
+                return nil
+            }
+        }
+
+        return scaledEvent
+    }
+
+    private func beginGestureIfInsidePager(_ event: NSEvent, scrollView: NSScrollView) {
+        guard eventIsInsidePager(event, scrollView: scrollView) else {
+            resetLocalGestureState()
+            return
+        }
+
+        if !gestureLifecycle.isActive {
+            beginGesture()
+        }
+    }
+
+    private func beginGesture() {
+        gestureGate.begin()
+        let gestureID = gestureLifecycle.begin()
+        inputScalingState.reset()
+        horizontalGestureAccumulator.reset()
+        suppressesCreationMomentum = false
+        creationPullController?.returnToRest(animated: false)
+
+        // Use the same logical origin as normal paging. If this gesture
+        // interrupts an arrival animation, the previous resolved destination
+        // is authoritative even though the clip view has not reached it yet.
+        let gestureOrigin = geometryTracker?.beginPhysicalGesture(id: gestureID)
+        let canPullPastLastPage: Bool
+        let currentOffsetX = configuredScrollView?.contentView.bounds.origin.x
+        if let gestureOrigin,
+           let currentOffsetX,
+           let lastPageOffsetX,
+           let lastPageIndex {
+            canPullPastLastPage = SidebarSpaceCreationPullEligibility.canBegin(
+                creationIsAvailable: creationIsAvailable,
+                gestureOrigin: gestureOrigin,
+                currentOffsetX: currentOffsetX,
+                lastPageOffsetX: lastPageOffsetX,
+                lastPageIndex: lastPageIndex
+            )
+        } else {
+            canPullPastLastPage = false
+        }
+        creationSession.begin(canPullForward: canPullPastLastPage)
+    }
+
+    private func eventIsInsidePager(_ event: NSEvent, scrollView: NSScrollView) -> Bool {
+        let localPoint = scrollView.convert(event.locationInWindow, from: nil)
+        return scrollView.bounds.contains(localPoint)
+    }
+
+    private func resetLocalGestureState() {
+        cancelCreationInteraction(animated: false)
+        suppressesCreationMomentum = false
+        gestureGate.end()
+        clearLocalGestureState()
+    }
+
+    private func finishPhysicalGesture(
+        cancelled: Bool,
+        reason: SidebarSpacePagerPhysicalGestureEndReason
+    ) {
+        guard let gestureID = gestureLifecycle.finish(for: reason) else {
+            return
+        }
+
+        let consumedCreationInput = creationSession.isPulling || creationSession.isCancelled
+        if consumedCreationInput {
+            let outcome = creationSession.finishPull(cancelled: cancelled)
+            suppressesCreationMomentum = true
+            switch outcome {
+            case .none:
+                creationPullController?.returnToRest(animated: false)
+            case .cancel:
+                creationPullController?.returnToRest(animated: true)
+            case .create:
+                let createSpace = createSpace
+                DispatchQueue.main.async { [weak creationPullController] in
+                    createSpace?()
+                    creationPullController?.returnToRest(animated: true)
+                }
+            }
+        } else {
+            creationSession.reset()
+            creationPullController?.returnToRest(animated: false)
+            geometryTracker?.setCreationPullLocksLastPage(false)
+        }
+
+        creationSession.end()
+        gestureGate.end()
+        inputScalingState.reset()
+        horizontalGestureAccumulator.reset()
+
+        let geometryTracker = geometryTracker
+        DispatchQueue.main.async { [weak geometryTracker] in
+            geometryTracker?.endPhysicalGesture(id: gestureID)
+        }
+    }
+
+    private var lastPageOffsetX: CGFloat? {
+        guard let lastPageIndex,
+              pageWidth.isFinite,
+              pageWidth > 0 else {
+            return nil
+        }
+        return CGFloat(lastPageIndex) * pageWidth
+    }
+
+    private var lastPageIndex: Int? {
+        pageCount > 0 ? pageCount - 1 : nil
+    }
+
+    private func cancelCreationInteraction(animated: Bool) {
+        creationSession.reset()
+        geometryTracker?.setCreationPullLocksLastPage(false)
+        creationPullController?.returnToRest(animated: animated)
+    }
+
+    private func ignoreRemainderOfPhysicalGesture() {
+        gestureGate.ignoreChangedEventsUntilNextGesture()
+        cancelCreationInteraction(animated: false)
+        clearLocalGestureState()
+    }
+
+    private func clearLocalGestureState() {
+        _ = gestureLifecycle.reset()
+        geometryTracker?.cancelDirectionalSnap()
+        inputScalingState.reset()
+        horizontalGestureAccumulator.reset()
+    }
+}
diff --git a/Sources/MeridianCore/Views/Sidebar/SidebarSpacePagerModels.swift b/Sources/MeridianCore/Views/Sidebar/SidebarSpacePagerModels.swift
new file mode 100644
index 0000000..d1318b8
--- /dev/null
+++ b/Sources/MeridianCore/Views/Sidebar/SidebarSpacePagerModels.swift
@@ -0,0 +1,294 @@
+import Foundation
+
+enum SidebarSpacePagerPageID: Hashable, Sendable {
+    case activity
+    case space(SpaceID)
+
+    var spaceID: SpaceID? {
+        if case .space(let id) = self {
+            return id
+        }
+        return nil
+    }
+}
+
+struct SidebarSpacePagerNavigationRequest: Equatable, Sendable {
+    let id = UUID()
+    let pageID: SidebarSpacePagerPageID
+}
+
+struct SidebarSpacePagerSnapshot: Equatable, Sendable {
+    let selectedSpacePageID: SidebarSpacePagerPageID?
+    let selectedAuxiliaryPageID: SidebarSpacePagerPageID?
+    let spaceCount: Int
+    let pages: [SidebarSpacePagerPageSnapshot]
+
+    var pageCount: Int {
+        pages.count
+    }
+}
+
+enum SidebarSpacePagerPageSnapshot: Identifiable, Equatable, Sendable {
+    case activity(SidebarActivityPageSnapshot)
+    case space(SidebarSpacePageSnapshot)
+
+    var id: SidebarSpacePagerPageID {
+        switch self {
+        case .activity:
+            return .activity
+        case .space(let page):
+            return .space(page.id)
+        }
+    }
+
+    var space: BrowserSpace? {
+        if case .space(let page) = self {
+            return page.space
+        }
+        return nil
+    }
+
+    var chromeTheme: SidebarChromeTheme {
+        switch self {
+        case .activity:
+            return .standard
+        case .space(let page):
+            return SidebarChromeTheme.theme(for: page.space)
+        }
+    }
+}
+
+struct SidebarActivityPageSnapshot: Equatable, Sendable {
+    let profiles: [BrowserProfile]
+    let downloads: [BrowserDownload]
+    let historyEntries: [BrowserHistoryEntry]
+}
+
+struct SidebarSpacePageSnapshot: Identifiable, Equatable, Sendable {
+    var id: SpaceID { space.id }
+
+    let index: Int
+    let space: BrowserSpace
+    let favoriteTabs: [SidebarTabItemSnapshot]
+    let pinnedTabs: [SidebarTabItemSnapshot]
+    let folders: [SidebarFolderItemSnapshot]
+    let regularTabs: [SidebarTabItemSnapshot]
+}
+
+struct SidebarFolderItemSnapshot: Identifiable, Equatable, Sendable {
+    var id: FolderID { folder.id }
+
+    let folder: BrowserFolder
+    let tabs: [SidebarTabItemSnapshot]
+    let childFolders: [SidebarFolderItemSnapshot]
+
+    static func == (lhs: SidebarFolderItemSnapshot, rhs: SidebarFolderItemSnapshot) -> Bool {
+        lhs.folder == rhs.folder
+            && lhs.tabs == rhs.tabs
+            && lhs.childFolders == rhs.childFolders
+    }
+}
+
+struct SidebarTabItemSnapshot: Identifiable, Equatable, Sendable {
+    var id: TabID { tab.id }
+
+    let tab: BrowserTab
+    let isSelected: Bool
+    let hasLiveSession: Bool
+    let canClose: Bool
+    let canMoveUp: Bool
+    let canMoveDown: Bool
+
+    init(
+        tab: BrowserTab,
+        isSelected: Bool,
+        hasLiveSession: Bool = false,
+        canClose: Bool = true,
+        canMoveUp: Bool,
+        canMoveDown: Bool
+    ) {
+        self.tab = tab
+        self.isSelected = isSelected
+        self.hasLiveSession = hasLiveSession
+        self.canClose = canClose
+        self.canMoveUp = canMoveUp
+        self.canMoveDown = canMoveDown
+    }
+}
+
+struct SidebarSpacePageSectionVisibility {
+    static func showsEmptyFavoriteTabDropSection(
+        for page: SidebarSpacePageSnapshot,
+        isDragging: Bool
+    ) -> Bool {
+        isDragging && page.favoriteTabs.isEmpty && hasTabsOutsideFavorites(in: page)
+    }
+
+    static func showsEmptyPinnedTabDropSection(
+        for page: SidebarSpacePageSnapshot,
+        isDragging: Bool
+    ) -> Bool {
+        isDragging && page.pinnedTabs.isEmpty && hasTabsOutsidePinnedList(in: page)
+    }
+
+    static func showsEmptyRegularTabDropSection(
+        for page: SidebarSpacePageSnapshot,
+        isDragging: Bool
+    ) -> Bool {
+        isDragging && page.regularTabs.isEmpty && hasTabsOutsideRegular(in: page)
+    }
+
+    private static func hasTabsOutsideFavorites(in page: SidebarSpacePageSnapshot) -> Bool {
+        !page.pinnedTabs.isEmpty
+            || !page.regularTabs.isEmpty
+            || page.folders.contains(where: folderContainsTabs)
+    }
+
+    private static func hasTabsOutsidePinnedList(in page: SidebarSpacePageSnapshot) -> Bool {
+        !page.favoriteTabs.isEmpty
+            || !page.regularTabs.isEmpty
+            || page.folders.contains(where: folderContainsTabs)
+    }
+
+    private static func hasTabsOutsideRegular(in page: SidebarSpacePageSnapshot) -> Bool {
+        !page.favoriteTabs.isEmpty
+            || !page.pinnedTabs.isEmpty
+            || page.folders.contains(where: folderContainsTabs)
+    }
+
+    private static func folderContainsTabs(_ folder: SidebarFolderItemSnapshot) -> Bool {
+        !folder.tabs.isEmpty || folder.childFolders.contains(where: folderContainsTabs)
+    }
+}
+
+
+struct SidebarSpacePagerFocus {
+    static func focusedTabID(
+        for space: BrowserSpace,
+        folders: [BrowserFolder],
+        tabsByID: [TabID: BrowserTab]
+    ) -> TabID? {
+        BrowserSpaceFocusedTabResolver.focusedTabID(for: space, folders: folders, tabsByID: tabsByID)
+    }
+
+    static func isFocused(tabID: TabID, focusedTabID: TabID?) -> Bool {
+        tabID == focusedTabID
+    }
+}
+
+struct SidebarSpacePageSnapshotBuilder {
+    static func spacePages(
+        activeSpaces: [BrowserSpace],
+        folders: [BrowserFolder],
+        tabs: [BrowserTab],
+        liveSessionTabIDs: Set<TabID> = []
+    ) -> [SidebarSpacePageSnapshot] {
+        let pageSpaceIDs = Set(activeSpaces.map(\.id))
+        let foldersByID = Dictionary(
+            uniqueKeysWithValues: folders
+                .lazy
+                .filter { pageSpaceIDs.contains($0.parentSpaceID) }
+                .map { ($0.id, $0) }
+        )
+        let foldersBySpaceID = Dictionary(grouping: foldersByID.values, by: \.parentSpaceID)
+        let directTabIDs = activeSpaces.flatMap { space in
+            space.favoriteTabIDs + space.pinnedTabIDs + space.regularTabIDs
+        }
+        let folderTabIDs = foldersByID.values.flatMap(\.tabIDs)
+        let visibleTabIDs = Set(directTabIDs + folderTabIDs)
+        let tabsByID = Dictionary(
+            uniqueKeysWithValues: tabs
+                .lazy
+                .filter { visibleTabIDs.contains($0.id) }
+                .map { ($0.id, $0) }
+        )
+
+        return activeSpaces.indices.map { index in
+            let space = activeSpaces[index]
+            let focusedTabID = SidebarSpacePagerFocus.focusedTabID(
+                for: space,
+                folders: foldersBySpaceID[space.id, default: []],
+                tabsByID: tabsByID
+            )
+
+            return SidebarSpacePageSnapshot(
+                index: index,
+                space: space,
+                favoriteTabs: tabItems(
+                    for: space.favoriteTabIDs,
+                    focusedTabID: focusedTabID,
+                    tabsByID: tabsByID,
+                    liveSessionTabIDs: liveSessionTabIDs
+                ),
+                pinnedTabs: tabItems(
+                    for: space.pinnedTabIDs,
+                    focusedTabID: focusedTabID,
+                    tabsByID: tabsByID,
+                    liveSessionTabIDs: liveSessionTabIDs
+                ),
+                folders: folderItems(
+                    for: space.folderIDs,
+                    focusedTabID: focusedTabID,
+                    foldersByID: foldersByID,
+                    tabsByID: tabsByID,
+                    liveSessionTabIDs: liveSessionTabIDs
+                ),
+                regularTabs: tabItems(
+                    for: space.regularTabIDs,
+                    focusedTabID: focusedTabID,
+                    tabsByID: tabsByID,
+                    liveSessionTabIDs: liveSessionTabIDs
+                )
+            )
+        }
+    }
+
+    private static func tabItems(
+        for ids: [TabID],
+        focusedTabID: TabID?,
+        tabsByID: [TabID: BrowserTab],
+        liveSessionTabIDs: Set<TabID>
+    ) -> [SidebarTabItemSnapshot] {
+        let orderedTabs = ids.compactMap { tabsByID[$0] }
+        return orderedTabs.enumerated().map { index, tab in
+            SidebarTabItemSnapshot(
+                tab: tab,
+                isSelected: SidebarSpacePagerFocus.isFocused(tabID: tab.id, focusedTabID: focusedTabID),
+                hasLiveSession: liveSessionTabIDs.contains(tab.id),
+                canMoveUp: index > 0,
+                canMoveDown: index < orderedTabs.count - 1
+            )
+        }
+    }
+
+    private static func folderItems(
+        for ids: [FolderID],
+        focusedTabID: TabID?,
+        foldersByID: [FolderID: BrowserFolder],
+        tabsByID: [TabID: BrowserTab],
+        liveSessionTabIDs: Set<TabID>
+    ) -> [SidebarFolderItemSnapshot] {
+        ids.compactMap { id in
+            guard let folder = foldersByID[id] else {
+                return nil
+            }
+
+            return SidebarFolderItemSnapshot(
+                folder: folder,
+                tabs: tabItems(
+                    for: folder.tabIDs,
+                    focusedTabID: focusedTabID,
+                    tabsByID: tabsByID,
+                    liveSessionTabIDs: liveSessionTabIDs
+                ),
+                childFolders: folderItems(
+                    for: folder.childFolderIDs,
+                    focusedTabID: focusedTabID,
+                    foldersByID: foldersByID,
+                    tabsByID: tabsByID,
+                    liveSessionTabIDs: liveSessionTabIDs
+                )
+            )
+        }
+    }
+}
diff --git a/Sources/MeridianCore/Views/Sidebar/SidebarSpacePagerPolicy.swift b/Sources/MeridianCore/Views/Sidebar/SidebarSpacePagerPolicy.swift
new file mode 100644
index 0000000..a966607
--- /dev/null
+++ b/Sources/MeridianCore/Views/Sidebar/SidebarSpacePagerPolicy.swift
@@ -0,0 +1,579 @@
+import AppKit
+import SwiftUI
+
+enum SidebarSpacePagerMetrics {
+    static let selectionAnimation: Animation = .smooth(duration: 0.18, extraBounce: 0)
+    static let activeScrollSensitivity: CGFloat = 0.35
+    static let directionalDistanceThresholdInPages: CGFloat = 0.0025
+    static let directionalVelocityThreshold: CGFloat = 20
+    static let creationDirectionInferenceDistance: CGFloat = 2
+    static let creationSettledOffsetTolerance: CGFloat = 0.75
+    static let creationPullThreshold: CGFloat = 160
+    static let creationPullResistance: CGFloat = 0.55
+    static let creationRailMaximumWidth: CGFloat = 72
+    static let creationAffordanceDiameter: CGFloat = 32
+    static let creationRailTrailingPadding: CGFloat = 12
+    static let creationReturnAnimation: Animation = .smooth(duration: 0.24, extraBounce: 0.08)
+}
+
+enum SidebarSpacePagerHorizontalIntent: Equatable, Sendable {
+    case backward
+    case forward
+
+    static func intent(
+        forAdjustedDisplacement displacement: CGFloat,
+        minimumDisplacement: CGFloat
+    ) -> Self? {
+        guard displacement.isFinite,
+              minimumDisplacement.isFinite,
+              abs(displacement) >= max(minimumDisplacement, 0),
+              displacement != 0 else {
+            return nil
+        }
+        return displacement > 0 ? .forward : .backward
+    }
+}
+
+/// Converts AppKit wheel coordinates into the pager's content coordinates.
+/// `NSScrollView` moves its horizontal content offset opposite to
+/// `NSEvent.scrollingDeltaX`, so this conversion is the only place where that
+/// sign inversion belongs.
+struct SidebarSpacePagerHorizontalInputSample: Equatable, Sendable {
+    let adjustedDisplacementX: CGFloat
+
+    init?(scrollingDeltaX: CGFloat) {
+        guard scrollingDeltaX.isFinite else {
+            return nil
+        }
+        adjustedDisplacementX = -scrollingDeltaX
+    }
+}
+
+struct SidebarSpacePagerHorizontalGestureAccumulator: Equatable, Sendable {
+    private(set) var cumulativeAdjustedDisplacementX: CGFloat = 0
+
+    mutating func append(_ sample: SidebarSpacePagerHorizontalInputSample) {
+        cumulativeAdjustedDisplacementX += sample.adjustedDisplacementX
+    }
+
+    mutating func reset() {
+        cumulativeAdjustedDisplacementX = 0
+    }
+}
+
+struct SidebarSpacePagerPhysicalGestureOrigin: Equatable, Sendable {
+    let scrollWasIdle: Bool
+    let anchoredPageIndex: Int?
+}
+
+/// Non-observable gesture geometry shared by SwiftUI's phase callbacks and the
+/// scroll-target policy. Live samples never invalidate the pager view tree.
+final class SidebarSpacePagerGeometryTracker {
+    var visibleFractionalPageIndex: CGFloat?
+    var gestureStartFractionalPageIndex: CGFloat?
+    var gestureSourcePageIndex: Int?
+    var adjustedGestureDisplacementX: CGFloat?
+    var acceptsDirectionalSnap = false
+    private(set) var resolvedTargetPageIndex: Int?
+    private(set) var creationPullLocksLastPage = false
+    private(set) var activePhysicalGestureID: UInt64?
+    private var scrollPhase = ScrollPhase.idle
+
+    var scrollIsIdle: Bool {
+        scrollPhase == .idle && activePhysicalGestureID == nil
+    }
+
+    func transition(from oldPhase: ScrollPhase, to newPhase: ScrollPhase) {
+        scrollPhase = newPhase
+        switch newPhase {
+        case .tracking:
+            if activePhysicalGestureID == nil {
+                beginDirectionalSnap(
+                    sourcePageIndex: interruptedTargetPageIndex(after: oldPhase)
+                )
+            } else {
+                acceptsDirectionalSnap = true
+            }
+        case .interacting:
+            if activePhysicalGestureID != nil {
+                acceptsDirectionalSnap = true
+            } else if oldPhase != .tracking {
+                beginDirectionalSnap(
+                    sourcePageIndex: interruptedTargetPageIndex(after: oldPhase)
+                )
+            } else {
+                acceptsDirectionalSnap = true
+            }
+        case .decelerating:
+            acceptsDirectionalSnap = true
+        case .animating:
+            // Preserve the captured gesture origin through SwiftUI's alignment
+            // animation. Programmatic animations opt out of the active snap but
+            // retain their destination so a physical interruption can anchor to it.
+            if oldPhase == .idle, activePhysicalGestureID == nil {
+                resetDirectionalSnap(preservingResolvedTarget: true)
+            }
+        case .idle:
+            if activePhysicalGestureID == nil {
+                resetDirectionalSnap()
+            }
+        }
+    }
+
+    func cancelDirectionalSnap() {
+        activePhysicalGestureID = nil
+        resetDirectionalSnap()
+    }
+
+    @discardableResult
+    func beginPhysicalGesture(id: UInt64) -> SidebarSpacePagerPhysicalGestureOrigin {
+        let origin = SidebarSpacePagerPhysicalGestureOrigin(
+            scrollWasIdle: scrollIsIdle,
+            anchoredPageIndex: resolvedTargetPageIndex
+        )
+        activePhysicalGestureID = id
+        creationPullLocksLastPage = false
+        beginDirectionalSnap(sourcePageIndex: resolvedTargetPageIndex)
+        return origin
+    }
+
+    func endPhysicalGesture(id: UInt64) {
+        guard activePhysicalGestureID == id else {
+            return
+        }
+
+        activePhysicalGestureID = nil
+        if scrollPhase == .idle {
+            resetDirectionalSnap()
+        }
+    }
+
+    func setCreationPullLocksLastPage(_ isLocked: Bool) {
+        creationPullLocksLastPage = isLocked
+    }
+
+    func clearAdjustedGestureDisplacement() {
+        adjustedGestureDisplacementX = nil
+    }
+
+    func recordResolvedTargetPageIndex(_ pageIndex: Int) {
+        resolvedTargetPageIndex = pageIndex
+    }
+
+    func prepareForProgrammaticNavigation(to pageIndex: Int) {
+        activePhysicalGestureID = nil
+        resetDirectionalSnap()
+        resolvedTargetPageIndex = pageIndex
+    }
+
+    private func resetDirectionalSnap(preservingResolvedTarget: Bool = false) {
+        acceptsDirectionalSnap = false
+        gestureStartFractionalPageIndex = nil
+        gestureSourcePageIndex = nil
+        adjustedGestureDisplacementX = nil
+        if !preservingResolvedTarget {
+            resolvedTargetPageIndex = nil
+        }
+        creationPullLocksLastPage = false
+    }
+
+    private func interruptedTargetPageIndex(after phase: ScrollPhase) -> Int? {
+        switch phase {
+        case .animating, .decelerating:
+            return resolvedTargetPageIndex
+        case .idle, .tracking, .interacting:
+            return nil
+        }
+    }
+
+    private func beginDirectionalSnap(sourcePageIndex: Int?) {
+        gestureStartFractionalPageIndex = visibleFractionalPageIndex
+        gestureSourcePageIndex = sourcePageIndex
+        adjustedGestureDisplacementX = nil
+        acceptsDirectionalSnap = true
+    }
+}
+
+/// Rewrites only the active horizontal displacement fields. Gesture direction
+/// accumulation is deliberately owned by `SidebarSpacePagerHorizontalGestureAccumulator`.
+struct SidebarSpacePagerScrollInputScalingState {
+    private var pointDeltaResidualX = 0.0
+
+    mutating func scaledEvent(
+        from event: NSEvent,
+        sensitivity: CGFloat
+    ) -> NSEvent? {
+        guard event.type == .scrollWheel,
+              let copiedCGEvent = event.cgEvent?.copy() else {
+            return nil
+        }
+
+        let normalizedSensitivity = Self.normalizedSensitivity(sensitivity)
+        let originalFixedPointDeltaX = copiedCGEvent.getDoubleValueField(
+            .scrollWheelEventFixedPtDeltaAxis2
+        )
+        let originalPointDeltaX = copiedCGEvent.getIntegerValueField(
+            .scrollWheelEventPointDeltaAxis2
+        )
+        if originalFixedPointDeltaX.isFinite {
+            copiedCGEvent.setDoubleValueField(
+                .scrollWheelEventFixedPtDeltaAxis2,
+                value: originalFixedPointDeltaX * normalizedSensitivity
+            )
+        }
+        copiedCGEvent.setIntegerValueField(
+            .scrollWheelEventPointDeltaAxis2,
+            value: Self.scaledIntegralDelta(
+                originalPointDeltaX,
+                sensitivity: normalizedSensitivity,
+                residual: &pointDeltaResidualX
+            )
+        )
+
+        return NSEvent(cgEvent: copiedCGEvent)
+    }
+
+    mutating func reset() {
+        pointDeltaResidualX = 0
+    }
+
+    static func normalizedSensitivity(_ sensitivity: CGFloat) -> Double {
+        guard sensitivity.isFinite else {
+            return 1
+        }
+
+        return Double(min(max(sensitivity, 0), 1))
+    }
+
+    private static func scaledIntegralDelta(
+        _ delta: Int64,
+        sensitivity: Double,
+        residual: inout Double
+    ) -> Int64 {
+        let exactValue = Double(delta) * sensitivity + residual
+        guard exactValue.isFinite,
+              exactValue > Double(Int64.min),
+              exactValue < Double(Int64.max) else {
+            residual = 0
+            return delta
+        }
+
+        let scaledValue = Int64(exactValue.rounded(.toNearestOrAwayFromZero))
+        residual = exactValue - Double(scaledValue)
+        return scaledValue
+    }
+}
+
+struct SidebarSpacePagerPhysicalGestureGate {
+    private(set) var ignoresChangedEvents = false
+
+    mutating func begin() {
+        ignoresChangedEvents = false
+    }
+
+    mutating func ignoreChangedEventsUntilNextGesture() {
+        ignoresChangedEvents = true
+    }
+
+    mutating func end() {
+        ignoresChangedEvents = false
+    }
+}
+
+struct SidebarSpacePagerFixedChromeTarget {
+    static func pageID(
+        visibleFractionalPageIndex: CGFloat,
+        gestureStartFractionalPageIndex: CGFloat?,
+        gestureSourcePageIndex: Int? = nil,
+        adjustedGestureDisplacementX: CGFloat?,
+        pageWidth: CGFloat,
+        pages: [SidebarSpacePagerPageSnapshot]
+    ) -> SidebarSpacePagerPageID? {
+        guard !pages.isEmpty,
+              visibleFractionalPageIndex.isFinite,
+              pageWidth.isFinite,
+              pageWidth > 0 else {
+            return nil
+        }
+
+        let gestureOrigin: CGFloat
+        if let gestureStartFractionalPageIndex,
+           gestureStartFractionalPageIndex.isFinite {
+            gestureOrigin = gestureStartFractionalPageIndex
+        } else {
+            gestureOrigin = visibleFractionalPageIndex.rounded()
+        }
+
+        let pageIndex = SidebarSpacePagerSnap.targetPageIndex(
+            originalOffsetX: gestureOrigin * pageWidth,
+            proposedOffsetX: visibleFractionalPageIndex * pageWidth,
+            gestureStartFractionalPageIndex: gestureOrigin,
+            gestureSourcePageIndex: gestureSourcePageIndex,
+            visibleFractionalPageIndex: visibleFractionalPageIndex,
+            adjustedGestureDisplacementX: adjustedGestureDisplacementX,
+            velocityX: 0,
+            pageWidth: pageWidth,
+            pageCount: pages.count
+        )
+        return pages[pageIndex].id
+    }
+}
+
+struct SidebarSpacePagerChrome {
+    static func shouldDeferSettledStyle(
+        from currentPageID: SidebarSpacePagerPageID?,
+        to targetPageID: SidebarSpacePagerPageID?
+    ) -> Bool {
+        guard let targetPageID else {
+            return false
+        }
+        return currentPageID != targetPageID
+    }
+
+    static func theme(
+        for pageID: SidebarSpacePagerPageID?,
+        in pages: [SidebarSpacePagerPageSnapshot]
+    ) -> SidebarChromeTheme? {
+        guard let pageID else {
+            return nil
+        }
+        return pages.first(where: { $0.id == pageID })?.chromeTheme
+    }
+
+    static func color(
+        for pageID: SidebarSpacePagerPageID?,
+        in pages: [SidebarSpacePagerPageSnapshot]
+    ) -> SidebarChromeColor? {
+        theme(for: pageID, in: pages).map(SidebarChromeColor.init(theme:))
+    }
+
+    static func liveStyle(
+        for pageID: SidebarSpacePagerPageID?,
+        in pages: [SidebarSpacePagerPageSnapshot]
+    ) -> SidebarChromeLiveStyle? {
+        theme(for: pageID, in: pages).map(SidebarChromeLiveStyle.init(theme:))
+    }
+
+    static func liveColor(
+        at fractionalPageIndex: CGFloat,
+        in pages: [SidebarSpacePagerPageSnapshot]
+    ) -> SidebarChromeColor? {
+        liveColor(at: fractionalPageIndex, themes: pages.map(\.chromeTheme))
+    }
+
+    static func liveColor(
+        at fractionalPageIndex: CGFloat,
+        themes: [SidebarChromeTheme]
+    ) -> SidebarChromeColor? {
+        SidebarChromeColor.interpolated(
+            themes: themes,
+            fractionalIndex: Double(fractionalPageIndex)
+        )
+    }
+
+    static func liveStyle(
+        at fractionalPageIndex: CGFloat,
+        themes: [SidebarChromeTheme]
+    ) -> SidebarChromeLiveStyle? {
+        SidebarChromeLiveStyle.interpolated(
+            themes: themes,
+            fractionalIndex: Double(fractionalPageIndex)
+        )
+    }
+
+    static func liveStyle(
+        at fractionalPageIndex: CGFloat,
+        styles: [SidebarChromeLiveStyle]
+    ) -> SidebarChromeLiveStyle? {
+        SidebarChromeLiveStyle.interpolated(
+            styles: styles,
+            fractionalIndex: Double(fractionalPageIndex)
+        )
+    }
+}
+
+struct SidebarSpacePagerSelection {
+    static func committedPageID(
+        scrollPositionPageID: SidebarSpacePagerPageID?,
+        selectedPageID: SidebarSpacePagerPageID?,
+        pageIDs: [SidebarSpacePagerPageID]
+    ) -> SidebarSpacePagerPageID? {
+        guard let scrollPositionPageID,
+              scrollPositionPageID != selectedPageID,
+              pageIDs.contains(scrollPositionPageID) else {
+            return nil
+        }
+        return scrollPositionPageID
+    }
+}
+
+struct SidebarSpacePagerPreview {
+    static func spaceID(
+        for targetPageID: SidebarSpacePagerPageID,
+        selectedPageID: SidebarSpacePagerPageID?
+    ) -> SpaceID? {
+        guard targetPageID != selectedPageID,
+              case .space(let spaceID) = targetPageID else {
+            return nil
+        }
+        return spaceID
+    }
+}
+
+struct SidebarAdjacentPageScrollTargetBehavior: ScrollTargetBehavior {
+    let pageCount: Int
+    let geometryTracker: SidebarSpacePagerGeometryTracker
+
+    func updateTarget(_ target: inout ScrollTarget, context: TargetContext) {
+        guard context.axes.contains(.horizontal),
+              pageCount > 0 else {
+            return
+        }
+
+        let pageWidth = context.containerSize.width
+        guard pageWidth.isFinite,
+              pageWidth > 0 else {
+            return
+        }
+
+        let targetPageIndex: Int
+        if geometryTracker.creationPullLocksLastPage {
+            targetPageIndex = pageCount - 1
+        } else if geometryTracker.acceptsDirectionalSnap {
+            targetPageIndex = SidebarSpacePagerSnap.targetPageIndex(
+                originalOffsetX: context.originalTarget.rect.minX,
+                proposedOffsetX: target.rect.minX,
+                gestureStartFractionalPageIndex: geometryTracker.gestureStartFractionalPageIndex,
+                gestureSourcePageIndex: geometryTracker.gestureSourcePageIndex,
+                visibleFractionalPageIndex: geometryTracker.visibleFractionalPageIndex,
+                adjustedGestureDisplacementX: geometryTracker.adjustedGestureDisplacementX,
+                velocityX: context.velocity.dx,
+                pageWidth: pageWidth,
+                pageCount: pageCount
+            )
+        } else {
+            targetPageIndex = SidebarSpacePagerSnap.nearestPageIndex(
+                offsetX: target.rect.minX,
+                pageWidth: pageWidth,
+                pageCount: pageCount
+            )
+        }
+
+        geometryTracker.recordResolvedTargetPageIndex(targetPageIndex)
+        target.rect.origin.x = CGFloat(targetPageIndex) * pageWidth
+        target.anchor = .topLeading
+    }
+}
+
+struct SidebarSpacePagerSnap {
+    static func targetPageIndex(
+        originalOffsetX: CGFloat,
+        proposedOffsetX: CGFloat,
+        gestureStartFractionalPageIndex: CGFloat? = nil,
+        gestureSourcePageIndex: Int? = nil,
+        visibleFractionalPageIndex: CGFloat?,
+        adjustedGestureDisplacementX: CGFloat? = nil,
+        velocityX: CGFloat,
+        pageWidth: CGFloat,
+        pageCount: Int
+    ) -> Int {
+        guard pageCount > 0,
+              pageWidth.isFinite,
+              pageWidth > 0 else {
+            return 0
+        }
+
+        let originalPagePosition = finiteOffset(originalOffsetX) / pageWidth
+        let gestureStartPagePosition = finiteValue(gestureStartFractionalPageIndex)
+            ?? originalPagePosition
+        let currentPageIndex = clampedPageIndex(
+            gestureSourcePageIndex ?? Int(gestureStartPagePosition.rounded()),
+            pageCount: pageCount
+        )
+        let proposedDirection: Int?
+        if originalOffsetX.isFinite, proposedOffsetX.isFinite {
+            let proposedPagePosition = proposedOffsetX / pageWidth
+            proposedDirection = pageDirection(from: proposedPagePosition - gestureStartPagePosition)
+        } else {
+            proposedDirection = nil
+        }
+
+        let visibleDirection: Int?
+        if let visibleFractionalPageIndex,
+           visibleFractionalPageIndex.isFinite {
+            visibleDirection = pageDirection(
+                from: visibleFractionalPageIndex - gestureStartPagePosition
+            )
+        } else {
+            visibleDirection = nil
+        }
+
+        let adjustedGestureDirection: Int?
+        if let adjustedGestureDisplacementX,
+           adjustedGestureDisplacementX.isFinite {
+            adjustedGestureDirection = pageDirection(
+                from: adjustedGestureDisplacementX / pageWidth
+            )
+        } else {
+            adjustedGestureDirection = nil
+        }
+
+        let pageStep = proposedDirection
+            ?? velocityDirection(from: velocityX)
+            ?? adjustedGestureDirection
+            ?? visibleDirection
+            ?? 0
+        return clampedPageIndex(currentPageIndex + pageStep, pageCount: pageCount)
+    }
+
+    static func nearestPageIndex(
+        offsetX: CGFloat,
+        pageWidth: CGFloat,
+        pageCount: Int
+    ) -> Int {
+        guard pageCount > 0,
+              pageWidth.isFinite,
+              pageWidth > 0 else {
+            return 0
+        }
+
+        return clampedPageIndex(
+            Int((finiteOffset(offsetX) / pageWidth).rounded()),
+            pageCount: pageCount
+        )
+    }
+
+    private static func finiteOffset(_ offset: CGFloat) -> CGFloat {
+        offset.isFinite ? offset : 0
+    }
+
+    private static func finiteValue(_ value: CGFloat?) -> CGFloat? {
+        guard let value,
+              value.isFinite else {
+            return nil
+        }
+        return value
+    }
+
+    private static func pageDirection(from delta: CGFloat) -> Int? {
+        guard let intent = SidebarSpacePagerHorizontalIntent.intent(
+            forAdjustedDisplacement: delta,
+            minimumDisplacement: SidebarSpacePagerMetrics.directionalDistanceThresholdInPages
+        ) else {
+            return nil
+        }
+        return intent == .forward ? 1 : -1
+    }
+
+    private static func velocityDirection(from velocityX: CGFloat) -> Int? {
+        guard velocityX.isFinite,
+              abs(velocityX) >= SidebarSpacePagerMetrics.directionalVelocityThreshold else {
+            return nil
+        }
+        return velocityX > 0 ? 1 : -1
+    }
+
+    private static func clampedPageIndex(_ pageIndex: Int, pageCount: Int) -> Int {
+        min(max(pageIndex, 0), pageCount - 1)
+    }
+}
diff --git a/Sources/MeridianCore/Views/Sidebar/SidebarView.swift b/Sources/MeridianCore/Views/Sidebar/SidebarView.swift
index 3b8ba44..45ba29a 100644
--- a/Sources/MeridianCore/Views/Sidebar/SidebarView.swift
+++ b/Sources/MeridianCore/Views/Sidebar/SidebarView.swift
@@ -117,13 +117,6 @@ private struct SidebarFixedChromeForeground<Content: View>: View {
             .environment(\.sidebarForegroundColor, foregroundColor)
             .environment(\.sidebarForegroundWhiteAmount, whiteAmount)
             .environment(\.sidebarUsesDarkForeground, whiteAmount < 0.5)
-            // The target changes once when the gesture acquires a direction,
-            // not for every pixel of travel. SwiftUI can therefore animate the
-            // small fixed chrome without re-entering its render loop at 120 Hz.
-            .animation(
-                SidebarSpacePagerMetrics.fixedChromeThemeAnimation,
-                value: whiteAmount
-            )
     }
 }
 
@@ -622,6 +615,7 @@ public struct SidebarView: View {
             revealDownload: { revealDownload($0) },
             selectSpace: { selectSpace($0) },
             selectAuxiliaryPage: { selectAuxiliaryPage($0) },
+            createSpace: { _ = store.createSpace(name: "New Space") },
             previewSpace: { setPreviewSpace($0) },
             sidebarIsPinned: store.sidebarIsLockedOpen,
             updateSidebarFixedChromeLiveStyle: {
@@ -774,6 +768,114 @@ struct SidebarAddressMorphState: Equatable, Sendable {
     let progress: Double
 }
 
+struct SidebarAddressMorphPlan: Equatable, Sendable {
+    let sharedPrefixCount: Int
+    let sourceChangedCount: Int
+    let destinationChangedCount: Int
+    let sharedSuffixCount: Int
+
+    init(sourceText: String, destinationText: String) {
+        let sourceCharacters = Array(sourceText)
+        let destinationCharacters = Array(destinationText)
+        let sharedPrefixCount = zip(sourceCharacters, destinationCharacters)
+            .prefix { $0 == $1 }
+            .count
+        let remainingSource = sourceCharacters.dropFirst(sharedPrefixCount)
+        let remainingDestination = destinationCharacters.dropFirst(sharedPrefixCount)
+        let sharedSuffixCount = zip(remainingSource.reversed(), remainingDestination.reversed())
+            .prefix { $0 == $1 }
+            .count
+
+        self.sharedPrefixCount = sharedPrefixCount
+        self.sharedSuffixCount = sharedSuffixCount
+        sourceChangedCount = max(sourceCharacters.count - sharedPrefixCount - sharedSuffixCount, 0)
+        destinationChangedCount = max(destinationCharacters.count - sharedPrefixCount - sharedSuffixCount, 0)
+    }
+}
+
+enum SidebarAddressGlyphRole: Equatable, Sendable {
+    case source
+    case destination
+}
+
+struct SidebarAddressGlyphRenderState: Equatable, Sendable {
+    let opacity: Double
+    let translationY: CGFloat
+    let blurProgress: Double
+}
+
+enum SidebarAddressGlyphMorph {
+    static func state(
+        progress: Double,
+        role: SidebarAddressGlyphRole,
+        sliceIndex: Int,
+        sliceCount: Int,
+        morphPlan: SidebarAddressMorphPlan
+    ) -> SidebarAddressGlyphRenderState {
+        guard sliceCount > 0,
+              sliceIndex >= 0,
+              sliceIndex < sliceCount else {
+            return SidebarAddressGlyphRenderState(opacity: 0, translationY: 0, blurProgress: 0)
+        }
+
+        let clampedProgress = min(max(progress, 0), 1)
+        let smoothProgress = clampedProgress * clampedProgress * (3 - 2 * clampedProgress)
+        let prefixCount = min(morphPlan.sharedPrefixCount, sliceCount)
+        let suffixCount = min(
+            morphPlan.sharedSuffixCount,
+            max(sliceCount - prefixCount, 0)
+        )
+        let changedRange = prefixCount..<max(sliceCount - suffixCount, prefixCount)
+
+        // The common prefix occupies the same leading coordinates in both
+        // strings. Draw it once from the source layout so it never doubles or
+        // flickers while the changed portion morphs.
+        if sliceIndex < prefixCount {
+            return SidebarAddressGlyphRenderState(
+                opacity: role == .source ? 1 : 0,
+                translationY: 0,
+                blurProgress: 0
+            )
+        }
+
+        // A shared suffix can have a different x origin when the changed text
+        // has a different width. Cross-fade the two exact positions; never
+        // leave either endpoint translated or scaled.
+        guard changedRange.contains(sliceIndex) else {
+            return SidebarAddressGlyphRenderState(
+                opacity: role == .source ? 1 - smoothProgress : smoothProgress,
+                translationY: 0,
+                blurProgress: 0
+            )
+        }
+
+        let changedCount = max(changedRange.count, 1)
+        let sequencePosition = changedCount > 1
+            ? Double(sliceIndex - changedRange.lowerBound) / Double(changedCount - 1)
+            : 0
+        let delay = sequencePosition * 0.18
+        let localProgress = min(max((clampedProgress - delay) / (1 - 0.18), 0), 1)
+        let easedProgress = localProgress * localProgress * (3 - 2 * localProgress)
+        let visibility = role == .source ? 1 - easedProgress : easedProgress
+        let blurProgress = role == .source ? easedProgress : 1 - easedProgress
+        let verticalDirection = role == .source ? -1.0 : 1.0
+
+        if visibility <= 0 {
+            return SidebarAddressGlyphRenderState(
+                opacity: 0,
+                translationY: 0,
+                blurProgress: 0
+            )
+        }
+
+        return SidebarAddressGlyphRenderState(
+            opacity: visibility,
+            translationY: verticalDirection * blurProgress * 1.5,
+            blurProgress: blurProgress
+        )
+    }
+}
+
 enum SidebarAddressScrollMorph {
     static func state(
         at fractionalPageIndex: CGFloat,
@@ -863,16 +965,23 @@ private struct SidebarAddressMorphingText: View {
     var body: some View {
         ZStack(alignment: .leading) {
             if let state = controller.state {
+                let morphPlan = SidebarAddressMorphPlan(
+                    sourceText: state.sourceText,
+                    destinationText: state.destinationText
+                )
+
                 Text(state.sourceText)
                     .textRenderer(SidebarAddressGlyphRenderer(
                         progress: state.progress,
-                        role: .source
+                        role: .source,
+                        morphPlan: morphPlan
                     ))
 
                 Text(state.destinationText)
                     .textRenderer(SidebarAddressGlyphRenderer(
                         progress: state.progress,
-                        role: .destination
+                        role: .destination,
+                        morphPlan: morphPlan
                     ))
             } else {
                 Text(settledText)
@@ -884,36 +993,37 @@ private struct SidebarAddressMorphingText: View {
 }
 
 private struct SidebarAddressGlyphRenderer: TextRenderer {
-    enum Role {
-        case source
-        case destination
-    }
-
     let progress: Double
-    let role: Role
+    let role: SidebarAddressGlyphRole
+    let morphPlan: SidebarAddressMorphPlan
 
     func draw(layout: Text.Layout, in context: inout GraphicsContext) {
         let slices = layout.sidebarFlattenedRunSlices
-        let lastSliceIndex = max(slices.count - 1, 1)
+        guard !slices.isEmpty else {
+            return
+        }
 
         for (index, slice) in slices.enumerated() {
-            let sequencePosition = Double(index) / Double(lastSliceIndex)
-            let delay = sequencePosition * 0.22
-            let localProgress = min(max((progress - delay) / (1 - 0.22), 0), 1)
-            let easedProgress = localProgress * localProgress * (3 - 2 * localProgress)
-            let visibility = role == .source ? 1 - easedProgress : easedProgress
-            let blurProgress = role == .source ? easedProgress : 1 - easedProgress
-            let verticalDirection = role == .source ? -1.0 : 1.0
-
             var copy = context
-            copy.opacity = visibility
-            copy.translateBy(
-                x: 0,
-                y: verticalDirection * blurProgress * 1.5
+            let renderState = SidebarAddressGlyphMorph.state(
+                progress: progress,
+                role: role,
+                sliceIndex: index,
+                sliceCount: slices.count,
+                morphPlan: morphPlan
             )
-            copy.addFilter(.blur(
-                radius: slice.typographicBounds.rect.height / 14 * blurProgress
-            ))
+            guard renderState.opacity > 0.001 else {
+                continue
+            }
+
+            copy.opacity = renderState.opacity
+            copy.translateBy(x: 0, y: renderState.translationY)
+            if renderState.blurProgress > 0.001 {
+                copy.addFilter(.blur(
+                    radius: slice.typographicBounds.rect.height / 14
+                        * renderState.blurProgress
+                ))
+            }
             copy.draw(slice, options: .disablesSubpixelQuantization)
         }
     }
@@ -2826,167 +2936,6 @@ private struct WindowReader: NSViewRepresentable {
     }
 }
 
-enum SidebarSpacePagerPageID: Hashable, Sendable {
-    case activity
-    case space(SpaceID)
-
-    var spaceID: SpaceID? {
-        if case .space(let id) = self {
-            return id
-        }
-        return nil
-    }
-}
-
-struct SidebarSpacePagerNavigationRequest: Equatable, Sendable {
-    let id = UUID()
-    let pageID: SidebarSpacePagerPageID
-}
-
-struct SidebarSpacePagerSnapshot: Equatable, Sendable {
-    let selectedSpacePageID: SidebarSpacePagerPageID?
-    let selectedAuxiliaryPageID: SidebarSpacePagerPageID?
-    let spaceCount: Int
-    let pages: [SidebarSpacePagerPageSnapshot]
-
-    var pageCount: Int {
-        pages.count
-    }
-}
-
-enum SidebarSpacePagerPageSnapshot: Identifiable, Equatable, Sendable {
-    case activity(SidebarActivityPageSnapshot)
-    case space(SidebarSpacePageSnapshot)
-
-    var id: SidebarSpacePagerPageID {
-        switch self {
-        case .activity:
-            return .activity
-        case .space(let page):
-            return .space(page.id)
-        }
-    }
-
-    var space: BrowserSpace? {
-        if case .space(let page) = self {
-            return page.space
-        }
-        return nil
-    }
-
-    var chromeTheme: SidebarChromeTheme {
-        switch self {
-        case .activity:
-            return .standard
-        case .space(let page):
-            return SidebarChromeTheme.theme(for: page.space)
-        }
-    }
-}
-
-struct SidebarActivityPageSnapshot: Equatable, Sendable {
-    let profiles: [BrowserProfile]
-    let downloads: [BrowserDownload]
-    let historyEntries: [BrowserHistoryEntry]
-}
-
-struct SidebarSpacePageSnapshot: Identifiable, Equatable, Sendable {
-    var id: SpaceID { space.id }
-
-    let index: Int
-    let space: BrowserSpace
-    let favoriteTabs: [SidebarTabItemSnapshot]
-    let pinnedTabs: [SidebarTabItemSnapshot]
-    let folders: [SidebarFolderItemSnapshot]
-    let regularTabs: [SidebarTabItemSnapshot]
-}
-
-struct SidebarFolderItemSnapshot: Identifiable, Equatable, Sendable {
-    var id: FolderID { folder.id }
-
-    let folder: BrowserFolder
-    let tabs: [SidebarTabItemSnapshot]
-    let childFolders: [SidebarFolderItemSnapshot]
-
-    static func == (lhs: SidebarFolderItemSnapshot, rhs: SidebarFolderItemSnapshot) -> Bool {
-        lhs.folder == rhs.folder
-            && lhs.tabs == rhs.tabs
-            && lhs.childFolders == rhs.childFolders
-    }
-}
-
-struct SidebarTabItemSnapshot: Identifiable, Equatable, Sendable {
-    var id: TabID { tab.id }
-
-    let tab: BrowserTab
-    let isSelected: Bool
-    let hasLiveSession: Bool
-    let canClose: Bool
-    let canMoveUp: Bool
-    let canMoveDown: Bool
-
-    init(
-        tab: BrowserTab,
-        isSelected: Bool,
-        hasLiveSession: Bool = false,
-        canClose: Bool = true,
-        canMoveUp: Bool,
-        canMoveDown: Bool
-    ) {
-        self.tab = tab
-        self.isSelected = isSelected
-        self.hasLiveSession = hasLiveSession
-        self.canClose = canClose
-        self.canMoveUp = canMoveUp
-        self.canMoveDown = canMoveDown
-    }
-}
-
-struct SidebarSpacePageSectionVisibility {
-    static func showsEmptyFavoriteTabDropSection(
-        for page: SidebarSpacePageSnapshot,
-        isDragging: Bool
-    ) -> Bool {
-        isDragging && page.favoriteTabs.isEmpty && hasTabsOutsideFavorites(in: page)
-    }
-
-    static func showsEmptyPinnedTabDropSection(
-        for page: SidebarSpacePageSnapshot,
-        isDragging: Bool
-    ) -> Bool {
-        isDragging && page.pinnedTabs.isEmpty && hasTabsOutsidePinnedList(in: page)
-    }
-
-    static func showsEmptyRegularTabDropSection(
-        for page: SidebarSpacePageSnapshot,
-        isDragging: Bool
-    ) -> Bool {
-        isDragging && page.regularTabs.isEmpty && hasTabsOutsideRegular(in: page)
-    }
-
-    private static func hasTabsOutsideFavorites(in page: SidebarSpacePageSnapshot) -> Bool {
-        !page.pinnedTabs.isEmpty
-            || !page.regularTabs.isEmpty
-            || page.folders.contains(where: folderContainsTabs)
-    }
-
-    private static func hasTabsOutsidePinnedList(in page: SidebarSpacePageSnapshot) -> Bool {
-        !page.favoriteTabs.isEmpty
-            || !page.regularTabs.isEmpty
-            || page.folders.contains(where: folderContainsTabs)
-    }
-
-    private static func hasTabsOutsideRegular(in page: SidebarSpacePageSnapshot) -> Bool {
-        !page.favoriteTabs.isEmpty
-            || !page.pinnedTabs.isEmpty
-            || page.folders.contains(where: folderContainsTabs)
-    }
-
-    private static func folderContainsTabs(_ folder: SidebarFolderItemSnapshot) -> Bool {
-        !folder.tabs.isEmpty || folder.childFolders.contains(where: folderContainsTabs)
-    }
-}
-
 private struct SidebarSpacePagerView: View {
     let snapshot: SidebarSpacePagerSnapshot
     let navigationRequest: SidebarSpacePagerNavigationRequest?
@@ -3003,6 +2952,7 @@ private struct SidebarSpacePagerView: View {
     let revealDownload: (BrowserDownload) -> Void
     let selectSpace: (SpaceID) -> Void
     let selectAuxiliaryPage: (SidebarSpacePagerPageID?) -> Void
+    let createSpace: () -> Void
     let previewSpace: (SpaceID?) -> Void
     let sidebarIsPinned: Bool
     let updateSidebarFixedChromeLiveStyle: (SidebarChromeLiveStyle?) -> Void
@@ -3017,6 +2967,7 @@ private struct SidebarSpacePagerView: View {
     // This tracker is deliberately non-observable. The target behavior needs the
     // latest offset, but publishing every offset would rebuild the pager per frame.
     @State private var geometryTracker = SidebarSpacePagerGeometryTracker()
+    @StateObject private var creationPullController = SidebarSpaceCreationPullController()
 
     var body: some View {
         GeometryReader { proxy in
@@ -3027,6 +2978,14 @@ private struct SidebarSpacePagerView: View {
             let pageChromeLiveStyles = snapshot.pages.map {
                 SidebarChromeLiveStyle(theme: $0.chromeTheme)
             }
+            let creationRailWhiteAmount = SidebarForegroundPalette.whiteAmount(
+                for: pageChromeLiveStyles.last ?? SidebarChromeLiveStyle(theme: .standard),
+                isPinned: sidebarIsPinned,
+                colorScheme: colorScheme
+            )
+            let creationRailForegroundColor = SidebarForegroundPalette.color(
+                whiteAmount: creationRailWhiteAmount
+            )
 
             ScrollView(.horizontal, showsIndicators: false) {
                 LazyHStack(spacing: 0) {
@@ -3043,7 +3002,11 @@ private struct SidebarSpacePagerView: View {
                         SidebarSpacePagerScrollInputScalingInstaller(
                             sensitivity: SidebarSpacePagerMetrics.activeScrollSensitivity,
                             pageWidth: pageWidth,
-                            geometryTracker: geometryTracker
+                            pageCount: snapshot.pageCount,
+                            creationIsAvailable: creationIsAvailable,
+                            geometryTracker: geometryTracker,
+                            creationPullController: creationPullController,
+                            createSpace: createSpace
                         )
                         .allowsHitTesting(false)
                     }
@@ -3107,7 +3070,7 @@ private struct SidebarSpacePagerView: View {
                 if pageTravelIsRequired(to: request.pageID) {
                     settledStyleAwaitsScrollIdle = true
                 }
-                geometryTracker.cancelDirectionalSnap()
+                prepareGeometryTrackerForProgrammaticNavigation(to: request.pageID)
                 if case .space = request.pageID {
                     selectAuxiliaryPage(nil)
                 } else {
@@ -3194,30 +3157,31 @@ private struct SidebarSpacePagerView: View {
                     )
                 )
 
-                // The full scroll-linked style terminates at retained layers.
-                // Fixed controls receive the exact adjacent endpoint instead;
-                // their controller deduplicates the hundreds of later samples.
+                // Keep the fixed controls on the same live interpolation path
+                // as the retained glass treatment so text and icon colors track
+                // the gesture linearly instead of easing toward one endpoint.
                 updateSidebarChromeLiveStyle(
                     SidebarSpacePagerChrome.liveStyle(
                         at: newState,
                         styles: pageChromeLiveStyles
                     )
                 )
+                updateSidebarFixedChromeLiveStyle(
+                    SidebarSpacePagerChrome.liveStyle(
+                        at: newState,
+                        styles: pageChromeLiveStyles
+                    )
+                )
                 if geometryTracker.acceptsDirectionalSnap,
                    let targetPageID = SidebarSpacePagerFixedChromeTarget.pageID(
                     visibleFractionalPageIndex: newState,
                     gestureStartFractionalPageIndex: geometryTracker.gestureStartFractionalPageIndex,
                     gestureSourcePageIndex: geometryTracker.gestureSourcePageIndex,
-                    rawGestureDisplacementX: geometryTracker.rawGestureDisplacementX,
+                    adjustedGestureDisplacementX:
+                        geometryTracker.adjustedGestureDisplacementX,
                     pageWidth: pageWidth,
                     pages: snapshot.pages
                 ) {
-                    updateSidebarFixedChromeLiveStyle(
-                        SidebarSpacePagerChrome.liveStyle(
-                            for: targetPageID,
-                            in: snapshot.pages
-                        )
-                    )
                     previewSpace(
                         SidebarSpacePagerPreview.spaceID(
                             for: targetPageID,
@@ -3228,11 +3192,16 @@ private struct SidebarSpacePagerView: View {
             }
             .onDisappear {
                 geometryTracker.cancelDirectionalSnap()
+                creationPullController.returnToRest(animated: false)
                 updateSidebarChromeLiveStyle(nil)
                 updateSidebarFixedChromeLiveStyle(nil)
                 updateAddressMorph(nil)
                 previewSpace(nil)
             }
+            .modifier(SidebarSpaceCreationPullPresentationModifier(
+                controller: creationPullController,
+                foregroundColor: creationRailForegroundColor
+            ))
         }
     }
 
@@ -3294,6 +3263,14 @@ private struct SidebarSpacePagerView: View {
         snapshot.selectedAuxiliaryPageID ?? snapshot.selectedSpacePageID
     }
 
+    private var creationIsAvailable: Bool {
+        guard let lastPageID = snapshot.pages.last?.id,
+              case .space = lastPageID else {
+            return false
+        }
+        return true
+    }
+
     private func pageTravelIsRequired(to pageID: SidebarSpacePagerPageID?) -> Bool {
         guard let pageID,
               let targetIndex = snapshot.pages.firstIndex(where: { $0.id == pageID }) else {
@@ -3312,22 +3289,26 @@ private struct SidebarSpacePagerView: View {
     }
 
     private func syncScrollPositionToSelection(animated: Bool) {
-        geometryTracker.cancelDirectionalSnap()
-        guard let selectedPageID,
-              scrollPositionPageID != selectedPageID else {
+        guard let selectedPageID else {
+            geometryTracker.cancelDirectionalSnap()
             return
         }
-
-        if !animated,
-           let selectedPageIndex = snapshot.pages.firstIndex(where: { $0.id == selectedPageID }) {
-            geometryTracker.visibleFractionalPageIndex = CGFloat(selectedPageIndex)
+        guard scrollPositionPageID != selectedPageID else {
+            return
         }
 
         if animated {
+            prepareGeometryTrackerForProgrammaticNavigation(to: selectedPageID)
             withAnimation(SidebarSpacePagerMetrics.selectionAnimation) {
                 scrollPositionPageID = selectedPageID
             }
         } else {
+            geometryTracker.cancelDirectionalSnap()
+            if let selectedPageIndex = snapshot.pages.firstIndex(
+                where: { $0.id == selectedPageID }
+            ) {
+                geometryTracker.visibleFractionalPageIndex = CGFloat(selectedPageIndex)
+            }
             scrollPositionPageID = selectedPageID
         }
     }
@@ -3341,6 +3322,17 @@ private struct SidebarSpacePagerView: View {
         geometryTracker.visibleFractionalPageIndex = CGFloat(pageIndex)
     }
 
+    private func prepareGeometryTrackerForProgrammaticNavigation(
+        to pageID: SidebarSpacePagerPageID
+    ) {
+        guard let pageIndex = snapshot.pages.firstIndex(where: { $0.id == pageID }) else {
+            geometryTracker.cancelDirectionalSnap()
+            return
+        }
+
+        geometryTracker.prepareForProgrammaticNavigation(to: pageIndex)
+    }
+
     private func commitPageIfNeeded(_ pageID: SidebarSpacePagerPageID?) {
         guard let committedPageID = SidebarSpacePagerSelection.committedPageID(
             scrollPositionPageID: pageID,
@@ -3360,629 +3352,6 @@ private struct SidebarSpacePagerView: View {
     }
 }
 
-final class SidebarSpacePagerGeometryTracker {
-    var visibleFractionalPageIndex: CGFloat?
-    var gestureStartFractionalPageIndex: CGFloat?
-    var gestureSourcePageIndex: Int?
-    var rawGestureDisplacementX: CGFloat?
-    var acceptsDirectionalSnap = false
-    private(set) var resolvedTargetPageIndex: Int?
-    private var physicalGestureStartIsPending = false
-
-    func transition(from oldPhase: ScrollPhase, to newPhase: ScrollPhase) {
-        switch newPhase {
-        case .tracking:
-            if !consumePendingPhysicalGestureStart() {
-                beginDirectionalSnap(
-                    sourcePageIndex: interruptedTargetPageIndex(after: oldPhase)
-                )
-            }
-        case .interacting:
-            if oldPhase != .tracking {
-                if !consumePendingPhysicalGestureStart() {
-                    beginDirectionalSnap(
-                        sourcePageIndex: interruptedTargetPageIndex(after: oldPhase)
-                    )
-                }
-            } else {
-                physicalGestureStartIsPending = false
-                acceptsDirectionalSnap = true
-            }
-        case .decelerating:
-            acceptsDirectionalSnap = true
-        case .animating:
-            // A short trackpad swipe can transition directly from interaction
-            // into SwiftUI's page-alignment animation. Keep the captured origin
-            // and direction alive for that animation so a second target pass
-            // cannot reinterpret the damped offset as a non-gesture resize and
-            // snap back to the page we started on. Programmatic animations begin
-            // from idle (and callers also cancel explicitly), so they remain
-            // non-directional.
-            if oldPhase == .idle {
-                cancelDirectionalSnap()
-            }
-        case .idle:
-            cancelDirectionalSnap()
-        }
-    }
-
-    func cancelDirectionalSnap() {
-        acceptsDirectionalSnap = false
-        gestureStartFractionalPageIndex = nil
-        gestureSourcePageIndex = nil
-        rawGestureDisplacementX = nil
-        resolvedTargetPageIndex = nil
-        physicalGestureStartIsPending = false
-    }
-
-    func beginPhysicalGesture() {
-        beginDirectionalSnap(sourcePageIndex: resolvedTargetPageIndex)
-        physicalGestureStartIsPending = true
-    }
-
-    func recordResolvedTargetPageIndex(_ pageIndex: Int) {
-        resolvedTargetPageIndex = pageIndex
-    }
-
-    private func interruptedTargetPageIndex(after phase: ScrollPhase) -> Int? {
-        switch phase {
-        case .animating, .decelerating:
-            return resolvedTargetPageIndex
-        case .idle, .tracking, .interacting:
-            return nil
-        }
-    }
-
-    private func beginDirectionalSnap(sourcePageIndex: Int?) {
-        gestureStartFractionalPageIndex = visibleFractionalPageIndex
-        gestureSourcePageIndex = sourcePageIndex
-        rawGestureDisplacementX = nil
-        acceptsDirectionalSnap = true
-    }
-
-    private func consumePendingPhysicalGestureStart() -> Bool {
-        guard physicalGestureStartIsPending else {
-            return false
-        }
-
-        physicalGestureStartIsPending = false
-        acceptsDirectionalSnap = true
-        return true
-    }
-}
-
-struct SidebarSpacePagerScrollInputScalingState {
-    private var pointDeltaResidualX = 0.0
-    private(set) var cumulativeRawDisplacementX: CGFloat = 0
-
-    mutating func scaledEvent(
-        from event: NSEvent,
-        sensitivity: CGFloat
-    ) -> NSEvent? {
-        guard event.type == .scrollWheel,
-              let copiedCGEvent = event.cgEvent?.copy() else {
-            return nil
-        }
-
-        if event.scrollingDeltaX.isFinite {
-            cumulativeRawDisplacementX += event.scrollingDeltaX
-        }
-
-        let normalizedSensitivity = Self.normalizedSensitivity(sensitivity)
-        let originalFixedPointDeltaX = copiedCGEvent.getDoubleValueField(
-            .scrollWheelEventFixedPtDeltaAxis2
-        )
-        let originalPointDeltaX = copiedCGEvent.getIntegerValueField(
-            .scrollWheelEventPointDeltaAxis2
-        )
-        // For precise input AppKit reads active displacement from the fixed
-        // and point fields. Leave the legacy, raw, and accelerated fields
-        // untouched so the system retains the physical release velocity.
-        if originalFixedPointDeltaX.isFinite {
-            copiedCGEvent.setDoubleValueField(
-                .scrollWheelEventFixedPtDeltaAxis2,
-                value: originalFixedPointDeltaX * normalizedSensitivity
-            )
-        }
-        copiedCGEvent.setIntegerValueField(
-            .scrollWheelEventPointDeltaAxis2,
-            value: Self.scaledIntegralDelta(
-                originalPointDeltaX,
-                sensitivity: normalizedSensitivity,
-                residual: &pointDeltaResidualX
-            )
-        )
-
-        return NSEvent(cgEvent: copiedCGEvent)
-    }
-
-    mutating func reset() {
-        pointDeltaResidualX = 0
-        cumulativeRawDisplacementX = 0
-    }
-
-    static func normalizedSensitivity(_ sensitivity: CGFloat) -> Double {
-        guard sensitivity.isFinite else {
-            return 1
-        }
-
-        return Double(min(max(sensitivity, 0), 1))
-    }
-
-    private static func scaledIntegralDelta(
-        _ delta: Int64,
-        sensitivity: Double,
-        residual: inout Double
-    ) -> Int64 {
-        let exactValue = Double(delta) * sensitivity + residual
-        guard exactValue.isFinite,
-              exactValue > Double(Int64.min),
-              exactValue < Double(Int64.max) else {
-            residual = 0
-            return delta
-        }
-
-        let scaledValue = Int64(exactValue.rounded(.toNearestOrAwayFromZero))
-        residual = exactValue - Double(scaledValue)
-        return scaledValue
-    }
-}
-
-struct SidebarSpacePagerPhysicalGestureGate {
-    private(set) var ignoresChangedEvents = false
-
-    mutating func begin() {
-        ignoresChangedEvents = false
-    }
-
-    mutating func ignoreChangedEventsUntilNextGesture() {
-        ignoresChangedEvents = true
-    }
-
-    mutating func end() {
-        ignoresChangedEvents = false
-    }
-}
-
-struct SidebarSpacePagerFixedChromeTarget {
-    static func pageID(
-        visibleFractionalPageIndex: CGFloat,
-        gestureStartFractionalPageIndex: CGFloat?,
-        gestureSourcePageIndex: Int? = nil,
-        rawGestureDisplacementX: CGFloat?,
-        pageWidth: CGFloat,
-        pages: [SidebarSpacePagerPageSnapshot]
-    ) -> SidebarSpacePagerPageID? {
-        guard !pages.isEmpty,
-              visibleFractionalPageIndex.isFinite,
-              pageWidth.isFinite,
-              pageWidth > 0 else {
-            return nil
-        }
-
-        let gestureOrigin: CGFloat
-        if let gestureStartFractionalPageIndex,
-           gestureStartFractionalPageIndex.isFinite {
-            gestureOrigin = gestureStartFractionalPageIndex
-        } else {
-            gestureOrigin = visibleFractionalPageIndex.rounded()
-        }
-
-        let pageIndex = SidebarSpacePagerSnap.targetPageIndex(
-            originalOffsetX: gestureOrigin * pageWidth,
-            proposedOffsetX: visibleFractionalPageIndex * pageWidth,
-            gestureStartFractionalPageIndex: gestureOrigin,
-            gestureSourcePageIndex: gestureSourcePageIndex,
-            visibleFractionalPageIndex: visibleFractionalPageIndex,
-            rawGestureDisplacementX: rawGestureDisplacementX,
-            velocityX: 0,
-            pageWidth: pageWidth,
-            pageCount: pages.count
-        )
-        return pages[pageIndex].id
-    }
-}
-
-struct SidebarSpacePagerChrome {
-    static func shouldDeferSettledStyle(
-        from currentPageID: SidebarSpacePagerPageID?,
-        to targetPageID: SidebarSpacePagerPageID?
-    ) -> Bool {
-        guard let targetPageID else {
-            return false
-        }
-
-        return currentPageID != targetPageID
-    }
-
-    static func theme(
-        for pageID: SidebarSpacePagerPageID?,
-        in pages: [SidebarSpacePagerPageSnapshot]
-    ) -> SidebarChromeTheme? {
-        guard let pageID else {
-            return nil
-        }
-
-        return pages.first(where: { $0.id == pageID })?.chromeTheme
-    }
-
-    static func color(
-        for pageID: SidebarSpacePagerPageID?,
-        in pages: [SidebarSpacePagerPageSnapshot]
-    ) -> SidebarChromeColor? {
-        theme(for: pageID, in: pages).map(SidebarChromeColor.init(theme:))
-    }
-
-    static func liveStyle(
-        for pageID: SidebarSpacePagerPageID?,
-        in pages: [SidebarSpacePagerPageSnapshot]
-    ) -> SidebarChromeLiveStyle? {
-        theme(for: pageID, in: pages).map(SidebarChromeLiveStyle.init(theme:))
-    }
-
-    static func liveColor(
-        at fractionalPageIndex: CGFloat,
-        in pages: [SidebarSpacePagerPageSnapshot]
-    ) -> SidebarChromeColor? {
-        liveColor(
-            at: fractionalPageIndex,
-            themes: pages.map(\.chromeTheme)
-        )
-    }
-
-    static func liveColor(
-        at fractionalPageIndex: CGFloat,
-        themes: [SidebarChromeTheme]
-    ) -> SidebarChromeColor? {
-        SidebarChromeColor.interpolated(
-            themes: themes,
-            fractionalIndex: Double(fractionalPageIndex)
-        )
-    }
-
-    static func liveStyle(
-        at fractionalPageIndex: CGFloat,
-        themes: [SidebarChromeTheme]
-    ) -> SidebarChromeLiveStyle? {
-        SidebarChromeLiveStyle.interpolated(
-            themes: themes,
-            fractionalIndex: Double(fractionalPageIndex)
-        )
-    }
-
-    static func liveStyle(
-        at fractionalPageIndex: CGFloat,
-        styles: [SidebarChromeLiveStyle]
-    ) -> SidebarChromeLiveStyle? {
-        SidebarChromeLiveStyle.interpolated(
-            styles: styles,
-            fractionalIndex: Double(fractionalPageIndex)
-        )
-    }
-}
-
-struct SidebarSpacePagerSelection {
-    static func committedPageID(
-        scrollPositionPageID: SidebarSpacePagerPageID?,
-        selectedPageID: SidebarSpacePagerPageID?,
-        pageIDs: [SidebarSpacePagerPageID]
-    ) -> SidebarSpacePagerPageID? {
-        guard let scrollPositionPageID,
-              scrollPositionPageID != selectedPageID,
-              pageIDs.contains(scrollPositionPageID) else {
-            return nil
-        }
-
-        return scrollPositionPageID
-    }
-}
-
-struct SidebarSpacePagerPreview {
-    static func spaceID(
-        for targetPageID: SidebarSpacePagerPageID,
-        selectedPageID: SidebarSpacePagerPageID?
-    ) -> SpaceID? {
-        guard targetPageID != selectedPageID,
-              case .space(let spaceID) = targetPageID else {
-            return nil
-        }
-
-        return spaceID
-    }
-}
-
-private struct SidebarAdjacentPageScrollTargetBehavior: ScrollTargetBehavior {
-    let pageCount: Int
-    let geometryTracker: SidebarSpacePagerGeometryTracker
-
-    func updateTarget(_ target: inout ScrollTarget, context: TargetContext) {
-        guard context.axes.contains(.horizontal),
-              pageCount > 0 else {
-            return
-        }
-
-        let pageWidth = context.containerSize.width
-        guard pageWidth.isFinite,
-              pageWidth > 0 else {
-            return
-        }
-
-        let targetPageIndex: Int
-        if geometryTracker.acceptsDirectionalSnap {
-            targetPageIndex = SidebarSpacePagerSnap.targetPageIndex(
-                originalOffsetX: context.originalTarget.rect.minX,
-                proposedOffsetX: target.rect.minX,
-                gestureStartFractionalPageIndex: geometryTracker.gestureStartFractionalPageIndex,
-                gestureSourcePageIndex: geometryTracker.gestureSourcePageIndex,
-                visibleFractionalPageIndex: geometryTracker.visibleFractionalPageIndex,
-                rawGestureDisplacementX: geometryTracker.rawGestureDisplacementX,
-                velocityX: context.velocity.dx,
-                pageWidth: pageWidth,
-                pageCount: pageCount
-            )
-        } else {
-            // SwiftUI also asks target behaviors to resolve container-size
-            // changes. Keep those updates page-aligned without interpreting a
-            // resize or programmatic animation as a directional gesture.
-            targetPageIndex = SidebarSpacePagerSnap.nearestPageIndex(
-                offsetX: target.rect.minX,
-                pageWidth: pageWidth,
-                pageCount: pageCount
-            )
-        }
-
-        geometryTracker.recordResolvedTargetPageIndex(targetPageIndex)
-        target.rect.origin.x = CGFloat(targetPageIndex) * pageWidth
-        target.anchor = .topLeading
-    }
-}
-
-struct SidebarSpacePagerSnap {
-    static func targetPageIndex(
-        originalOffsetX: CGFloat,
-        proposedOffsetX: CGFloat,
-        gestureStartFractionalPageIndex: CGFloat? = nil,
-        gestureSourcePageIndex: Int? = nil,
-        visibleFractionalPageIndex: CGFloat?,
-        rawGestureDisplacementX: CGFloat? = nil,
-        velocityX: CGFloat,
-        pageWidth: CGFloat,
-        pageCount: Int
-    ) -> Int {
-        guard pageCount > 0,
-              pageWidth.isFinite,
-              pageWidth > 0 else {
-            return 0
-        }
-
-        let originalPagePosition = finiteOffset(originalOffsetX) / pageWidth
-        let gestureStartPagePosition = finiteValue(gestureStartFractionalPageIndex)
-            ?? originalPagePosition
-        let currentPageIndex = clampedPageIndex(
-            gestureSourcePageIndex ?? Int(gestureStartPagePosition.rounded()),
-            pageCount: pageCount
-        )
-        let proposedDirection: Int?
-        if originalOffsetX.isFinite, proposedOffsetX.isFinite {
-            let proposedPagePosition = proposedOffsetX / pageWidth
-            proposedDirection = pageDirection(from: proposedPagePosition - gestureStartPagePosition)
-        } else {
-            proposedDirection = nil
-        }
-
-        let visibleDirection: Int?
-        if let visibleFractionalPageIndex,
-           visibleFractionalPageIndex.isFinite {
-            visibleDirection = pageDirection(
-                from: visibleFractionalPageIndex - gestureStartPagePosition
-            )
-        } else {
-            visibleDirection = nil
-        }
-
-        let rawGestureDirection: Int?
-        if let rawGestureDisplacementX,
-           rawGestureDisplacementX.isFinite {
-            rawGestureDirection = pageDirection(from: rawGestureDisplacementX / pageWidth)
-        } else {
-            rawGestureDirection = nil
-        }
-
-        // A short release can be quantized back to its origin before this hook
-        // runs. Prefer SwiftUI's proposed direction, then a meaningful release
-        // reversal, and finally recover a slow drag from its unscaled intent.
-        let pageStep = proposedDirection
-            ?? velocityDirection(from: velocityX)
-            ?? rawGestureDirection
-            ?? visibleDirection
-            ?? 0
-        return clampedPageIndex(currentPageIndex + pageStep, pageCount: pageCount)
-    }
-
-    static func nearestPageIndex(
-        offsetX: CGFloat,
-        pageWidth: CGFloat,
-        pageCount: Int
-    ) -> Int {
-        guard pageCount > 0,
-              pageWidth.isFinite,
-              pageWidth > 0 else {
-            return 0
-        }
-
-        return clampedPageIndex(
-            Int((finiteOffset(offsetX) / pageWidth).rounded()),
-            pageCount: pageCount
-        )
-    }
-
-    private static func finiteOffset(_ offset: CGFloat) -> CGFloat {
-        offset.isFinite ? offset : 0
-    }
-
-    private static func finiteValue(_ value: CGFloat?) -> CGFloat? {
-        guard let value,
-              value.isFinite else {
-            return nil
-        }
-
-        return value
-    }
-
-    private static func pageDirection(from delta: CGFloat) -> Int? {
-        guard delta.isFinite,
-              abs(delta) >= SidebarSpacePagerMetrics.directionalDistanceThresholdInPages else {
-            return nil
-        }
-
-        return delta > 0 ? 1 : -1
-    }
-
-    private static func velocityDirection(from velocityX: CGFloat) -> Int? {
-        guard velocityX.isFinite,
-              abs(velocityX) >= SidebarSpacePagerMetrics.directionalVelocityThreshold else {
-            return nil
-        }
-
-        return velocityX > 0 ? 1 : -1
-    }
-
-    private static func clampedPageIndex(_ pageIndex: Int, pageCount: Int) -> Int {
-        min(max(pageIndex, 0), pageCount - 1)
-    }
-}
-
-struct SidebarSpacePagerFocus {
-    static func focusedTabID(
-        for space: BrowserSpace,
-        folders: [BrowserFolder],
-        tabsByID: [TabID: BrowserTab]
-    ) -> TabID? {
-        BrowserSpaceFocusedTabResolver.focusedTabID(for: space, folders: folders, tabsByID: tabsByID)
-    }
-
-    static func isFocused(tabID: TabID, focusedTabID: TabID?) -> Bool {
-        tabID == focusedTabID
-    }
-}
-
-struct SidebarSpacePageSnapshotBuilder {
-    static func spacePages(
-        activeSpaces: [BrowserSpace],
-        folders: [BrowserFolder],
-        tabs: [BrowserTab],
-        liveSessionTabIDs: Set<TabID> = []
-    ) -> [SidebarSpacePageSnapshot] {
-        let pageSpaceIDs = Set(activeSpaces.map(\.id))
-        let foldersByID = Dictionary(
-            uniqueKeysWithValues: folders
-                .lazy
-                .filter { pageSpaceIDs.contains($0.parentSpaceID) }
-                .map { ($0.id, $0) }
-        )
-        let foldersBySpaceID = Dictionary(grouping: foldersByID.values, by: \.parentSpaceID)
-        let directTabIDs = activeSpaces.flatMap { space in
-            space.favoriteTabIDs + space.pinnedTabIDs + space.regularTabIDs
-        }
-        let folderTabIDs = foldersByID.values.flatMap(\.tabIDs)
-        let visibleTabIDs = Set(directTabIDs + folderTabIDs)
-        let tabsByID = Dictionary(
-            uniqueKeysWithValues: tabs
-                .lazy
-                .filter { visibleTabIDs.contains($0.id) }
-                .map { ($0.id, $0) }
-        )
-
-        return activeSpaces.indices.map { index in
-            let space = activeSpaces[index]
-            let focusedTabID = SidebarSpacePagerFocus.focusedTabID(
-                for: space,
-                folders: foldersBySpaceID[space.id, default: []],
-                tabsByID: tabsByID
-            )
-
-            return SidebarSpacePageSnapshot(
-                index: index,
-                space: space,
-                favoriteTabs: tabItems(
-                    for: space.favoriteTabIDs,
-                    focusedTabID: focusedTabID,
-                    tabsByID: tabsByID,
-                    liveSessionTabIDs: liveSessionTabIDs
-                ),
-                pinnedTabs: tabItems(
-                    for: space.pinnedTabIDs,
-                    focusedTabID: focusedTabID,
-                    tabsByID: tabsByID,
-                    liveSessionTabIDs: liveSessionTabIDs
-                ),
-                folders: folderItems(
-                    for: space.folderIDs,
-                    focusedTabID: focusedTabID,
-                    foldersByID: foldersByID,
-                    tabsByID: tabsByID,
-                    liveSessionTabIDs: liveSessionTabIDs
-                ),
-                regularTabs: tabItems(
-                    for: space.regularTabIDs,
-                    focusedTabID: focusedTabID,
-                    tabsByID: tabsByID,
-                    liveSessionTabIDs: liveSessionTabIDs
-                )
-            )
-        }
-    }
-
-    private static func tabItems(
-        for ids: [TabID],
-        focusedTabID: TabID?,
-        tabsByID: [TabID: BrowserTab],
-        liveSessionTabIDs: Set<TabID>
-    ) -> [SidebarTabItemSnapshot] {
-        let orderedTabs = ids.compactMap { tabsByID[$0] }
-        return orderedTabs.enumerated().map { index, tab in
-            SidebarTabItemSnapshot(
-                tab: tab,
-                isSelected: SidebarSpacePagerFocus.isFocused(tabID: tab.id, focusedTabID: focusedTabID),
-                hasLiveSession: liveSessionTabIDs.contains(tab.id),
-                canMoveUp: index > 0,
-                canMoveDown: index < orderedTabs.count - 1
-            )
-        }
-    }
-
-    private static func folderItems(
-        for ids: [FolderID],
-        focusedTabID: TabID?,
-        foldersByID: [FolderID: BrowserFolder],
-        tabsByID: [TabID: BrowserTab],
-        liveSessionTabIDs: Set<TabID>
-    ) -> [SidebarFolderItemSnapshot] {
-        ids.compactMap { id in
-            guard let folder = foldersByID[id] else {
-                return nil
-            }
-
-            return SidebarFolderItemSnapshot(
-                folder: folder,
-                tabs: tabItems(
-                    for: folder.tabIDs,
-                    focusedTabID: focusedTabID,
-                    tabsByID: tabsByID,
-                    liveSessionTabIDs: liveSessionTabIDs
-                ),
-                childFolders: folderItems(
-                    for: folder.childFolderIDs,
-                    focusedTabID: focusedTabID,
-                    foldersByID: foldersByID,
-                    tabsByID: tabsByID,
-                    liveSessionTabIDs: liveSessionTabIDs
-                )
-            )
-        }
-    }
-}
-
 private enum SidebarActivityMode: CaseIterable, Identifiable {
     case history
     case downloads
@@ -4699,299 +4068,6 @@ private struct SidebarSpacePageView: View, Equatable {
     }
 }
 
-private struct SidebarSpacePagerScrollInputScalingInstaller: NSViewRepresentable {
-    let sensitivity: CGFloat
-    let pageWidth: CGFloat
-    let geometryTracker: SidebarSpacePagerGeometryTracker
-
-    func makeNSView(context: Context) -> SidebarSpacePagerScrollInputScalingView {
-        let view = SidebarSpacePagerScrollInputScalingView()
-        view.geometryTracker = geometryTracker
-        view.sensitivity = sensitivity
-        view.pageWidth = pageWidth
-        return view
-    }
-
-    func updateNSView(_ nsView: SidebarSpacePagerScrollInputScalingView, context: Context) {
-        nsView.geometryTracker = geometryTracker
-        nsView.sensitivity = sensitivity
-        nsView.pageWidth = pageWidth
-        nsView.installIfNeeded()
-    }
-
-    static func dismantleNSView(
-        _ nsView: SidebarSpacePagerScrollInputScalingView,
-        coordinator: ()
-    ) {
-        nsView.tearDown()
-    }
-}
-
-private final class SidebarSpacePagerScrollInputScalingView: NSView {
-    weak var geometryTracker: SidebarSpacePagerGeometryTracker?
-    var sensitivity: CGFloat = 1
-    var pageWidth: CGFloat = 0 {
-        didSet {
-            guard oldValue > 0,
-                  abs(oldValue - pageWidth) > 0.5 else {
-                return
-            }
-
-            ignoreRemainderOfPhysicalGesture()
-            geometryTracker?.cancelDirectionalSnap()
-        }
-    }
-
-    private weak var configuredScrollView: NSScrollView?
-    private var eventMonitor: Any?
-    private var deferredInstallationIsScheduled = false
-    private var ownsPhysicalGesture = false
-    private var gestureGate = SidebarSpacePagerPhysicalGestureGate()
-    private var inputScalingState = SidebarSpacePagerScrollInputScalingState()
-
-    override func viewDidMoveToWindow() {
-        super.viewDidMoveToWindow()
-        installIfNeeded()
-    }
-
-    override func viewDidMoveToSuperview() {
-        super.viewDidMoveToSuperview()
-        installIfNeeded()
-    }
-
-    override func viewWillMove(toWindow newWindow: NSWindow?) {
-        super.viewWillMove(toWindow: newWindow)
-        if newWindow == nil {
-            tearDown()
-        }
-    }
-
-    override func layout() {
-        super.layout()
-        installIfNeeded()
-    }
-
-    deinit {
-        MainActor.assumeIsolated {
-            tearDown()
-        }
-    }
-
-    func installIfNeeded() {
-        guard window != nil else {
-            return
-        }
-
-        let candidateScrollView = nearestScrollView
-        if let configuredScrollView,
-           configuredScrollView === candidateScrollView {
-            installEventMonitorIfNeeded()
-            return
-        }
-
-        let replacedConfiguredScrollView = configuredScrollView != nil
-        stopObservingConfiguredScrollView()
-        if replacedConfiguredScrollView {
-            ignoreRemainderOfPhysicalGesture()
-            geometryTracker?.cancelDirectionalSnap()
-        } else {
-            resetLocalGestureState()
-        }
-
-        guard let candidateScrollView else {
-            scheduleDeferredInstallation()
-            return
-        }
-
-        configuredScrollView = candidateScrollView
-        NotificationCenter.default.addObserver(
-            self,
-            selector: #selector(scrollViewDidEndLiveScroll(_:)),
-            name: NSScrollView.didEndLiveScrollNotification,
-            object: candidateScrollView
-        )
-        installEventMonitorIfNeeded()
-    }
-
-    func tearDown() {
-        stopObservingConfiguredScrollView()
-        removeEventMonitor()
-        resetLocalGestureState()
-        deferredInstallationIsScheduled = false
-    }
-
-    private var nearestScrollView: NSScrollView? {
-        var candidate: NSView? = self
-        while let current = candidate {
-            if let scrollView = current as? NSScrollView {
-                return scrollView
-            }
-            candidate = current.superview
-        }
-
-        return enclosingScrollView
-    }
-
-    private func scheduleDeferredInstallation() {
-        guard !deferredInstallationIsScheduled else {
-            return
-        }
-
-        deferredInstallationIsScheduled = true
-        DispatchQueue.main.async { [weak self] in
-            guard let self else {
-                return
-            }
-
-            self.deferredInstallationIsScheduled = false
-            self.installIfNeeded()
-        }
-    }
-
-    private func installEventMonitorIfNeeded() {
-        guard eventMonitor == nil else {
-            return
-        }
-
-        eventMonitor = NSEvent.addLocalMonitorForEvents(matching: .scrollWheel) { [weak self] event in
-            self?.eventForPagerInput(from: event) ?? event
-        }
-    }
-
-    private func removeEventMonitor() {
-        if let eventMonitor {
-            NSEvent.removeMonitor(eventMonitor)
-            self.eventMonitor = nil
-        }
-    }
-
-    private func stopObservingConfiguredScrollView() {
-        if let configuredScrollView {
-            NotificationCenter.default.removeObserver(
-                self,
-                name: NSScrollView.didEndLiveScrollNotification,
-                object: configuredScrollView
-            )
-        }
-        configuredScrollView = nil
-    }
-
-    private func eventForPagerInput(from event: NSEvent) -> NSEvent {
-        guard let scrollView = configuredScrollView,
-              event.window === scrollView.window else {
-            return event
-        }
-
-        if !event.momentumPhase.isEmpty {
-            resetLocalGestureState()
-            return event
-        }
-
-        let phase = event.phase
-        guard !phase.isEmpty else {
-            resetLocalGestureState()
-            return event
-        }
-        guard event.hasPreciseScrollingDeltas else {
-            resetLocalGestureState()
-            return event
-        }
-
-        if phase.contains(.mayBegin) || phase.contains(.began) {
-            beginGestureIfInsidePager(event, scrollView: scrollView)
-        }
-
-        if phase.contains(.ended) || phase.contains(.cancelled) {
-            resetLocalGestureState()
-            return event
-        }
-
-        guard !gestureGate.ignoresChangedEvents else {
-            return event
-        }
-
-        guard phase.contains(.began) || phase.contains(.changed) else {
-            return event
-        }
-
-        if !ownsPhysicalGesture {
-            guard phase.contains(.changed),
-                  eventIsInsidePager(event, scrollView: scrollView) else {
-                return event
-            }
-
-            beginGesture()
-        }
-
-        guard ownsPhysicalGesture,
-              let scaledEvent = inputScalingState.scaledEvent(
-                from: event,
-                sensitivity: sensitivity
-              ) else {
-            return event
-        }
-
-        geometryTracker?.rawGestureDisplacementX =
-            inputScalingState.cumulativeRawDisplacementX
-
-        // Scale before NSScrollView sees the event. The previous implementation
-        // let AppKit scroll at full strength and then corrected the clip view,
-        // forcing two pager layout/compositing passes per trackpad sample.
-        // Momentum and phase-ended events return above unchanged, preserving the
-        // native release velocity and adjacent-page spring.
-        return scaledEvent
-    }
-
-    private func beginGestureIfInsidePager(_ event: NSEvent, scrollView: NSScrollView) {
-        guard eventIsInsidePager(event, scrollView: scrollView) else {
-            resetLocalGestureState()
-            return
-        }
-
-        beginGesture()
-    }
-
-    private func beginGesture() {
-        gestureGate.begin()
-        ownsPhysicalGesture = true
-        inputScalingState.reset()
-        // AppKit exposes a new physical trackpad gesture even when SwiftUI keeps
-        // the scroll phase in `decelerating`. Capture that boundary directly so
-        // a rapid follow-up swipe gets its own origin and advances from the
-        // previous gesture's resolved destination.
-        geometryTracker?.beginPhysicalGesture()
-    }
-
-    private func eventIsInsidePager(_ event: NSEvent, scrollView: NSScrollView) -> Bool {
-        let localPoint = scrollView.convert(event.locationInWindow, from: nil)
-        return scrollView.bounds.contains(localPoint)
-    }
-
-    @objc
-    private func scrollViewDidEndLiveScroll(_ notification: Notification) {
-        guard notification.object as? NSScrollView === configuredScrollView else {
-            return
-        }
-
-        resetLocalGestureState()
-    }
-
-    private func resetLocalGestureState() {
-        gestureGate.end()
-        clearLocalGestureState()
-    }
-
-    private func ignoreRemainderOfPhysicalGesture() {
-        gestureGate.ignoreChangedEventsUntilNextGesture()
-        clearLocalGestureState()
-    }
-
-    private func clearLocalGestureState() {
-        ownsPhysicalGesture = false
-        inputScalingState.reset()
-    }
-}
-
 private struct ScrollIndicatorHiderOverlay: View {
     var axes: ScrollIndicatorHiderAxes = .all
 
@@ -5376,11 +4452,3 @@ private struct SidebarFolderNodeView: View {
         }
     }
 }
-
-enum SidebarSpacePagerMetrics {
-    static let selectionAnimation: Animation = .smooth(duration: 0.18, extraBounce: 0)
-    static let fixedChromeThemeAnimation: Animation = .smooth(duration: 0.18, extraBounce: 0)
-    static let activeScrollSensitivity: CGFloat = 0.35
-    static let directionalDistanceThresholdInPages: CGFloat = 0.0025
-    static let directionalVelocityThreshold: CGFloat = 20
-}
diff --git a/Sources/MeridianCore/WebKit/WebViewHost.swift b/Sources/MeridianCore/WebKit/WebViewHost.swift
index ea8ab75..883a3b3 100644
--- a/Sources/MeridianCore/WebKit/WebViewHost.swift
+++ b/Sources/MeridianCore/WebKit/WebViewHost.swift
@@ -526,7 +526,7 @@ enum BrowserPasswordCaptureScript {
             }
 
             accountPickerContainer = document.createElement("div");
-            accountPickerContainer.id = "bare-browser-password-account-picker";
+            accountPickerContainer.id = "lumen-browser-password-account-picker";
             accountPickerContainer.setAttribute("role", "listbox");
             accountPickerContainer.style.cssText = [
                 "all: initial",
@@ -3113,7 +3113,7 @@ struct NavigationFailureDiagnostics {
         }
 
         guard error.domain == NSURLErrorDomain else {
-            return "Navigation failed. Check Bare Browser logs for details."
+            return "Navigation failed. Check Lumen Browser logs for details."
         }
 
         switch error.code {
@@ -3136,7 +3136,7 @@ struct NavigationFailureDiagnostics {
              NSURLErrorClientCertificateRequired:
             return "Navigation failed: secure connection could not be verified."
         default:
-            return "Navigation failed. Check Bare Browser logs for details."
+            return "Navigation failed. Check Lumen Browser logs for details."
         }
     }
 
diff --git a/Tests/MeridianBrowserTests/BrowserStoreTests.swift b/Tests/MeridianBrowserTests/BrowserStoreTests.swift
index e1788e8..6c81982 100644
--- a/Tests/MeridianBrowserTests/BrowserStoreTests.swift
+++ b/Tests/MeridianBrowserTests/BrowserStoreTests.swift
@@ -1820,12 +1820,12 @@ final class BrowserStoreTests: XCTestCase {
 
         XCTAssertEqual(
             result,
-            .deny(reason: "Notifications permissions are not supported by Bare Browser on this WebKit version.")
+            .deny(reason: "Notifications permissions are not supported by Lumen Browser on this WebKit version.")
         )
         XCTAssertNil(store.pendingSitePermissionRequest)
         XCTAssertEqual(
             store.lastUserMessage,
-            "Notifications permissions are not supported by Bare Browser on this WebKit version."
+            "Notifications permissions are not supported by Lumen Browser on this WebKit version."
         )
     }
 
@@ -1885,7 +1885,7 @@ final class BrowserStoreTests: XCTestCase {
         XCTAssertFalse(store.setSitePermissionDecision(.allow, for: .notifications, origin: origin, profileID: profileID))
         XCTAssertEqual(
             store.lastUserMessage,
-            "Notifications permissions are not supported by Bare Browser on this WebKit version."
+            "Notifications permissions are not supported by Lumen Browser on this WebKit version."
         )
 
         XCTAssertFalse(store.setSitePermissionDecision(.allow, for: .autoplay, origin: origin, profileID: profileID))
diff --git a/Tests/MeridianBrowserTests/BrowserUserAgentTests.swift b/Tests/MeridianBrowserTests/BrowserUserAgentTests.swift
index fc91ef6..3ad601c 100644
--- a/Tests/MeridianBrowserTests/BrowserUserAgentTests.swift
+++ b/Tests/MeridianBrowserTests/BrowserUserAgentTests.swift
@@ -11,7 +11,7 @@ final class BrowserUserAgentTests: XCTestCase {
         XCTAssertTrue(userAgent.contains("AppleWebKit/605.1.15"))
         XCTAssertTrue(userAgent.contains("Version/26.4"))
         XCTAssertTrue(userAgent.hasSuffix("Safari/605.1.15"))
-        XCTAssertFalse(userAgent.contains("Bare Browser"))
+        XCTAssertFalse(userAgent.contains("Lumen Browser"))
         XCTAssertFalse(userAgent.contains("MeridianBrowser"))
     }
 
diff --git a/Tests/MeridianBrowserTests/DownloadSafetyPolicyTests.swift b/Tests/MeridianBrowserTests/DownloadSafetyPolicyTests.swift
index 6d4ed68..c895689 100644
--- a/Tests/MeridianBrowserTests/DownloadSafetyPolicyTests.swift
+++ b/Tests/MeridianBrowserTests/DownloadSafetyPolicyTests.swift
@@ -47,7 +47,7 @@ final class DownloadSafetyPolicyTests: XCTestCase {
             date: Date(timeIntervalSince1970: 16)
         )
 
-        XCTAssertEqual(value, "0083;10;Bare Browser;https://example.com:8443")
+        XCTAssertEqual(value, "0083;10;Lumen Browser;https://example.com:8443")
     }
 
     func testBuildsSanitizedDownloadSourceMetadata() {
@@ -79,7 +79,7 @@ final class DownloadSafetyPolicyTests: XCTestCase {
             date: Date(timeIntervalSince1970: 16)
         )
 
-        XCTAssertEqual(value, "0083;10;Bare Browser;https://example.com")
+        XCTAssertEqual(value, "0083;10;Lumen Browser;https://example.com")
         XCTAssertFalse(value.contains("user"))
         XCTAssertFalse(value.contains("password"))
         XCTAssertFalse(value.contains("private"))
@@ -96,7 +96,7 @@ final class DownloadSafetyPolicyTests: XCTestCase {
             date: Date(timeIntervalSince1970: 16)
         )
 
-        XCTAssertEqual(value, "0083;10;Bare Browser;")
+        XCTAssertEqual(value, "0083;10;Lumen Browser;")
     }
 
     private func makeTemporaryDirectory() throws -> URL {
diff --git a/Tests/MeridianBrowserTests/NavigationFailureDiagnosticsTests.swift b/Tests/MeridianBrowserTests/NavigationFailureDiagnosticsTests.swift
index 123526a..98f9785 100644
--- a/Tests/MeridianBrowserTests/NavigationFailureDiagnosticsTests.swift
+++ b/Tests/MeridianBrowserTests/NavigationFailureDiagnosticsTests.swift
@@ -40,6 +40,6 @@ final class NavigationFailureDiagnosticsTests: XCTestCase {
 
         let diagnostics = NavigationFailureDiagnostics(error: error)
 
-        XCTAssertEqual(diagnostics.userMessage, "Navigation failed. Check Bare Browser logs for details.")
+        XCTAssertEqual(diagnostics.userMessage, "Navigation failed. Check Lumen Browser logs for details.")
     }
 }
diff --git a/Tests/MeridianBrowserTests/PasswordAutofillScriptTests.swift b/Tests/MeridianBrowserTests/PasswordAutofillScriptTests.swift
index f2c6018..47c9623 100644
--- a/Tests/MeridianBrowserTests/PasswordAutofillScriptTests.swift
+++ b/Tests/MeridianBrowserTests/PasswordAutofillScriptTests.swift
@@ -13,7 +13,7 @@ final class PasswordAutofillScriptTests: XCTestCase {
     func testAutofillInstallsVisibleAccountPickerBeforePasswordValueCheck() throws {
         let source = BrowserPasswordCaptureScript.source
 
-        XCTAssertTrue(source.contains("bare-browser-password-account-picker"))
+        XCTAssertTrue(source.contains("lumen-browser-password-account-picker"))
         XCTAssertTrue(source.contains("showAccountPicker"))
         XCTAssertTrue(source.contains("input.addEventListener(\"focus\", showAccountPickerForInput, true);"))
         XCTAssertTrue(source.contains("backdrop-filter: blur(42px) saturate(1.95) contrast(1.08)"))
diff --git a/Tests/MeridianBrowserTests/PasswordCredentialStoreTests.swift b/Tests/MeridianBrowserTests/PasswordCredentialStoreTests.swift
index b5da59f..1245095 100644
--- a/Tests/MeridianBrowserTests/PasswordCredentialStoreTests.swift
+++ b/Tests/MeridianBrowserTests/PasswordCredentialStoreTests.swift
@@ -3,9 +3,15 @@ import MeridianCore
 import XCTest
 
 final class PasswordCredentialStoreTests: XCTestCase {
-    func testKeychainStoreUsesBareBrowserServicePrefixAndKeepsLegacyMeridianLookup() {
-        XCTAssertEqual(KeychainPasswordCredentialStore.defaultServicePrefix, "BareBrowser.WebsitePasswords")
-        XCTAssertEqual(KeychainPasswordCredentialStore.legacyServicePrefixes, ["MeridianBrowser.WebsitePasswords"])
+    func testKeychainStoreUsesLumenBrowserServicePrefixAndKeepsLegacyLookups() {
+        XCTAssertEqual(KeychainPasswordCredentialStore.defaultServicePrefix, "LumenBrowser.WebsitePasswords")
+        XCTAssertEqual(
+            KeychainPasswordCredentialStore.legacyServicePrefixes,
+            [
+                "BareBrowser.WebsitePasswords",
+                "MeridianBrowser.WebsitePasswords"
+            ]
+        )
     }
 
     func testCandidateNormalizesHTTPSOriginAndKeepsSecretOutOfPromptText() throws {
diff --git a/Tests/MeridianBrowserTests/ProfileIsolationWebKitIntegrationTests.swift b/Tests/MeridianBrowserTests/ProfileIsolationWebKitIntegrationTests.swift
index 3162515..9604af3 100644
--- a/Tests/MeridianBrowserTests/ProfileIsolationWebKitIntegrationTests.swift
+++ b/Tests/MeridianBrowserTests/ProfileIsolationWebKitIntegrationTests.swift
@@ -310,7 +310,7 @@ private final class ProfileFixtureNavigationWaiter: NSObject, WKNavigationDelega
 
 private final class LoopbackProfileFixtureServer: @unchecked Sendable {
     private let listener: NWListener
-    private let queue = DispatchQueue(label: "BareBrowser.ProfileIsolationFixture")
+    private let queue = DispatchQueue(label: "LumenBrowser.ProfileIsolationFixture")
     private var startContinuation: CheckedContinuation<URL, Error>?
 
     init() throws {
diff --git a/Tests/MeridianBrowserTests/SessionPersistenceBoundaryTests.swift b/Tests/MeridianBrowserTests/SessionPersistenceBoundaryTests.swift
index 12f3758..72aca5b 100644
--- a/Tests/MeridianBrowserTests/SessionPersistenceBoundaryTests.swift
+++ b/Tests/MeridianBrowserTests/SessionPersistenceBoundaryTests.swift
@@ -108,7 +108,7 @@ final class SessionPersistenceBoundaryTests: XCTestCase {
         let persistedInterrupted = try XCTUnwrap(persisted.downloads.first { $0.id == interruptedDownload.id })
         XCTAssertEqual(persistedInterrupted.state, .failed)
         XCTAssertEqual(persistedInterrupted.completedAt, Date(timeIntervalSince1970: 10))
-        XCTAssertEqual(persistedInterrupted.failureMessage, "Download was interrupted when Bare Browser closed.")
+        XCTAssertEqual(persistedInterrupted.failureMessage, "Download was interrupted when Lumen Browser closed.")
         XCTAssertEqual(persisted.sitePermissionSettings.count, 1)
         XCTAssertEqual(persisted.sitePermissionSettings.first?.origin.serializedOrigin, "https://camera.example")
         XCTAssertEqual(persisted.sitePermissionSettings.first?.profileID, publicProfileID)
diff --git a/Tests/MeridianBrowserTests/SidebarSpacePagerGestureTests.swift b/Tests/MeridianBrowserTests/SidebarSpacePagerGestureTests.swift
new file mode 100644
index 0000000..07ea5c8
--- /dev/null
+++ b/Tests/MeridianBrowserTests/SidebarSpacePagerGestureTests.swift
@@ -0,0 +1,344 @@
+import Foundation
+@testable import MeridianCore
+import XCTest
+
+final class SidebarSpacePagerGestureTests: XCTestCase {
+    func testPhysicalGestureLifecycleIssuesMonotonicTokens() throws {
+        var lifecycle = SidebarSpacePagerPhysicalGestureLifecycle()
+
+        let firstID = lifecycle.begin()
+        XCTAssertEqual(lifecycle.activeGestureID, firstID)
+        XCTAssertEqual(
+            try XCTUnwrap(lifecycle.finish(for: .physicalEnded)),
+            firstID
+        )
+        XCTAssertFalse(lifecycle.isActive)
+
+        let secondID = lifecycle.begin()
+        XCTAssertGreaterThan(secondID, firstID)
+        XCTAssertEqual(
+            try XCTUnwrap(lifecycle.finish(for: .physicalCancelled)),
+            secondID
+        )
+    }
+
+    func testPhysicalEventBoundariesEndPhysicalTrackpadGesture() throws {
+        let reasons: [SidebarSpacePagerPhysicalGestureEndReason] = [
+            .physicalEnded,
+            .physicalCancelled,
+            .momentumBegan,
+            .unphasedInput
+        ]
+
+        for reason in reasons {
+            var lifecycle = SidebarSpacePagerPhysicalGestureLifecycle()
+            let gestureID = lifecycle.begin()
+
+            XCTAssertEqual(
+                try XCTUnwrap(lifecycle.finish(for: reason)),
+                gestureID
+            )
+            XCTAssertFalse(lifecycle.isActive)
+        }
+    }
+
+    func testAdjustedDeltaHasOneDeterministicDirectionContract() {
+        XCTAssertEqual(
+            SidebarSpacePagerHorizontalIntent.intent(
+                forAdjustedDisplacement: -3,
+                minimumDisplacement: 2
+            ),
+            .backward
+        )
+        XCTAssertEqual(
+            SidebarSpacePagerHorizontalIntent.intent(
+                forAdjustedDisplacement: 3,
+                minimumDisplacement: 2
+            ),
+            .forward
+        )
+        XCTAssertNil(SidebarSpacePagerHorizontalIntent.intent(
+            forAdjustedDisplacement: 1,
+            minimumDisplacement: 2
+        ))
+    }
+
+    func testAppKitWheelDirectionRoutesForwardToCreationAndBackwardToPaging() throws {
+        let forwardInput = try XCTUnwrap(SidebarSpacePagerHorizontalInputSample(
+            scrollingDeltaX: -3
+        ))
+        let backwardInput = try XCTUnwrap(SidebarSpacePagerHorizontalInputSample(
+            scrollingDeltaX: 3
+        ))
+
+        var forwardSession = SidebarSpaceCreationGestureSession()
+        forwardSession.begin(canPullForward: true)
+        guard case .pulling = forwardSession.routeAdjustedDelta(
+            forwardInput.adjustedDisplacementX,
+            pageWidth: 300
+        ) else {
+            return XCTFail("Forward AppKit input must enter creation")
+        }
+
+        var backwardSession = SidebarSpaceCreationGestureSession()
+        backwardSession.begin(canPullForward: true)
+        XCTAssertEqual(
+            backwardSession.routeAdjustedDelta(
+                backwardInput.adjustedDisplacementX,
+                pageWidth: 300
+            ),
+            .pagingBackward
+        )
+    }
+
+    func testForwardWheelInputCanCreateUnlimitedConsecutiveSpaces() throws {
+        var pageCount = 3
+        var selectedPageIndex = pageCount - 1
+        let initialForwardInput = try XCTUnwrap(
+            SidebarSpacePagerHorizontalInputSample(scrollingDeltaX: -3)
+        )
+        let remainingForwardInput = try XCTUnwrap(
+            SidebarSpacePagerHorizontalInputSample(
+                scrollingDeltaX:
+                    -(SidebarSpacePagerMetrics.creationPullThreshold - 3)
+            )
+        )
+
+        for _ in 0..<12 {
+            XCTAssertEqual(selectedPageIndex, pageCount - 1)
+
+            var session = SidebarSpaceCreationGestureSession()
+            session.begin(canPullForward: true)
+            guard case .pulling = session.routeAdjustedDelta(
+                initialForwardInput.adjustedDisplacementX,
+                pageWidth: 300
+            ) else {
+                return XCTFail("Every final page must allow another creation pull")
+            }
+            guard case .pulling(let update) = session.routeAdjustedDelta(
+                remainingForwardInput.adjustedDisplacementX,
+                pageWidth: 300
+            ) else {
+                return XCTFail("Creation pull must stay forward")
+            }
+            XCTAssertEqual(update.progress, 1, accuracy: 0.0001)
+            XCTAssertEqual(session.finishPull(cancelled: false), .create)
+
+            pageCount += 1
+            selectedPageIndex = pageCount - 1
+        }
+
+        XCTAssertEqual(pageCount, 15)
+        XCTAssertEqual(selectedPageIndex, 14)
+    }
+
+    func testNarratedLastSpaceSequenceRemainsDeterministicWhenRepeated() throws {
+        var session = SidebarSpaceCreationGestureSession()
+
+        for _ in 0..<4 {
+            session.begin(canPullForward: true)
+            XCTAssertEqual(
+                session.routeAdjustedDelta(-3, pageWidth: 300),
+                .pagingBackward
+            )
+            XCTAssertEqual(
+                session.routeAdjustedDelta(100, pageWidth: 300),
+                .pagingBackward
+            )
+            session.end()
+
+            session.begin(canPullForward: true)
+            guard case .pulling = session.routeAdjustedDelta(3, pageWidth: 300) else {
+                return XCTFail("Forward input from the final space must start creation")
+            }
+            guard case .pulling(let update) = session.routeAdjustedDelta(
+                SidebarSpacePagerMetrics.creationPullThreshold - 3,
+                pageWidth: 300
+            ) else {
+                return XCTFail("Established creation must remain creation")
+            }
+            XCTAssertEqual(update.progress, 1, accuracy: 0.0001)
+            XCTAssertEqual(session.finishPull(cancelled: false), .create)
+            session.end()
+        }
+
+        session.begin(canPullForward: true)
+        XCTAssertEqual(
+            session.routeAdjustedDelta(-3, pageWidth: 300),
+            .pagingBackward
+        )
+    }
+
+    func testBackwardInputRoutesBeforeAnyGeometryCanParticipate() {
+        var session = SidebarSpaceCreationGestureSession()
+        session.begin(canPullForward: true)
+
+        XCTAssertEqual(
+            session.routeAdjustedDelta(-2, pageWidth: 300),
+            .pagingBackward
+        )
+        XCTAssertFalse(session.isPulling)
+        XCTAssertEqual(session.finishPull(cancelled: false), .none)
+    }
+
+    func testSubthresholdInputIsNotForcedIntoCreationOnRelease() {
+        var session = SidebarSpaceCreationGestureSession()
+        session.begin(canPullForward: true)
+
+        XCTAssertEqual(
+            session.routeAdjustedDelta(1, pageWidth: 300),
+            .pending
+        )
+        XCTAssertEqual(session.finishPull(cancelled: false), .none)
+    }
+
+    func testCreationPullReversalCancelsForRemainderOfPhysicalGesture() {
+        var session = SidebarSpaceCreationGestureSession()
+        session.begin(canPullForward: true)
+
+        guard case .pulling = session.routeAdjustedDelta(30, pageWidth: 300) else {
+            return XCTFail("Expected creation pull")
+        }
+        XCTAssertEqual(
+            session.routeAdjustedDelta(-31, pageWidth: 300),
+            .cancelled
+        )
+        XCTAssertEqual(
+            session.routeAdjustedDelta(200, pageWidth: 300),
+            .cancelled
+        )
+        XCTAssertTrue(session.isCancelled)
+        XCTAssertEqual(session.finishPull(cancelled: false), .cancel)
+    }
+
+    func testSwiftUIIdleCannotClearAnActivePhysicalGesture() {
+        let tracker = SidebarSpacePagerGeometryTracker()
+        tracker.visibleFractionalPageIndex = 2
+        tracker.beginPhysicalGesture(id: 1)
+        tracker.adjustedGestureDisplacementX = 12
+
+        tracker.transition(from: .interacting, to: .idle)
+
+        XCTAssertEqual(tracker.activePhysicalGestureID, 1)
+        XCTAssertTrue(tracker.acceptsDirectionalSnap)
+        XCTAssertEqual(tracker.gestureStartFractionalPageIndex, 2)
+        XCTAssertEqual(tracker.adjustedGestureDisplacementX, 12)
+
+        tracker.endPhysicalGesture(id: 1)
+        XCTAssertNil(tracker.activePhysicalGestureID)
+        XCTAssertFalse(tracker.acceptsDirectionalSnap)
+    }
+
+    func testDeferredCompletionCannotEndANewerGesture() {
+        let tracker = SidebarSpacePagerGeometryTracker()
+        tracker.visibleFractionalPageIndex = 1
+        tracker.beginPhysicalGesture(id: 7)
+        tracker.recordResolvedTargetPageIndex(2)
+
+        tracker.visibleFractionalPageIndex = 1.2
+        tracker.beginPhysicalGesture(id: 8)
+        tracker.endPhysicalGesture(id: 7)
+
+        XCTAssertEqual(tracker.activePhysicalGestureID, 8)
+        XCTAssertTrue(tracker.acceptsDirectionalSnap)
+        XCTAssertEqual(tracker.gestureSourcePageIndex, 2)
+
+        tracker.endPhysicalGesture(id: 8)
+        XCTAssertNil(tracker.activePhysicalGestureID)
+    }
+
+    func testCreationCanInterruptNaturalArrivalAtFinalPage() throws {
+        let tracker = SidebarSpacePagerGeometryTracker()
+        tracker.visibleFractionalPageIndex = 1
+        tracker.beginPhysicalGesture(id: 1)
+        tracker.transition(from: .idle, to: .interacting)
+        tracker.recordResolvedTargetPageIndex(2)
+        tracker.transition(from: .interacting, to: .animating)
+        tracker.endPhysicalGesture(id: 1)
+
+        tracker.visibleFractionalPageIndex = 1.35
+        let origin = tracker.beginPhysicalGesture(id: 2)
+
+        XCTAssertFalse(origin.scrollWasIdle)
+        XCTAssertEqual(origin.anchoredPageIndex, 2)
+        XCTAssertTrue(SidebarSpaceCreationPullEligibility.canBegin(
+            creationIsAvailable: true,
+            gestureOrigin: origin,
+            currentOffsetX: 405,
+            lastPageOffsetX: 600,
+            lastPageIndex: 2
+        ))
+
+        let forwardInput = try XCTUnwrap(SidebarSpacePagerHorizontalInputSample(
+            scrollingDeltaX: -3
+        ))
+        var session = SidebarSpaceCreationGestureSession()
+        session.begin(canPullForward: true)
+        guard case .pulling = session.routeAdjustedDelta(
+            forwardInput.adjustedDisplacementX,
+            pageWidth: 300
+        ) else {
+            return XCTFail("Forward interruption at the final target must create")
+        }
+    }
+
+    func testCreationCanInterruptProgrammaticArrivalAtNewFinalPage() {
+        let tracker = SidebarSpacePagerGeometryTracker()
+        tracker.visibleFractionalPageIndex = 2
+        tracker.prepareForProgrammaticNavigation(to: 3)
+        tracker.transition(from: .idle, to: .animating)
+
+        tracker.visibleFractionalPageIndex = 2.2
+        let origin = tracker.beginPhysicalGesture(id: 10)
+
+        XCTAssertFalse(origin.scrollWasIdle)
+        XCTAssertEqual(origin.anchoredPageIndex, 3)
+        XCTAssertTrue(SidebarSpaceCreationPullEligibility.canBegin(
+            creationIsAvailable: true,
+            gestureOrigin: origin,
+            currentOffsetX: 660,
+            lastPageOffsetX: 900,
+            lastPageIndex: 3
+        ))
+    }
+
+    func testAnimationTowardNonfinalPageCannotEnableCreation() {
+        let tracker = SidebarSpacePagerGeometryTracker()
+        tracker.visibleFractionalPageIndex = 1
+        tracker.prepareForProgrammaticNavigation(to: 2)
+        tracker.transition(from: .idle, to: .animating)
+
+        let origin = tracker.beginPhysicalGesture(id: 20)
+
+        XCTAssertFalse(SidebarSpaceCreationPullEligibility.canBegin(
+            creationIsAvailable: true,
+            gestureOrigin: origin,
+            currentOffsetX: 330,
+            lastPageOffsetX: 900,
+            lastPageIndex: 3
+        ))
+    }
+
+    func testVisualLastPageCanEnableCreationWithoutSelectionState() {
+        XCTAssertTrue(SidebarSpaceCreationPullEligibility.canBegin(
+            creationIsAvailable: true,
+            gestureOrigin: SidebarSpacePagerPhysicalGestureOrigin(
+                scrollWasIdle: true,
+                anchoredPageIndex: nil
+            ),
+            currentOffsetX: 600,
+            lastPageOffsetX: 600,
+            lastPageIndex: 2
+        ))
+        XCTAssertFalse(SidebarSpaceCreationPullEligibility.canBegin(
+            creationIsAvailable: false,
+            gestureOrigin: SidebarSpacePagerPhysicalGestureOrigin(
+                scrollWasIdle: true,
+                anchoredPageIndex: nil
+            ),
+            currentOffsetX: 600,
+            lastPageOffsetX: 600,
+            lastPageIndex: 2
+        ))
+    }
+}
diff --git a/Tests/MeridianBrowserTests/SidebarSpacePagerSelectionTests.swift b/Tests/MeridianBrowserTests/SidebarSpacePagerSelectionTests.swift
index 005dd7f..351b17b 100644
--- a/Tests/MeridianBrowserTests/SidebarSpacePagerSelectionTests.swift
+++ b/Tests/MeridianBrowserTests/SidebarSpacePagerSelectionTests.swift
@@ -238,6 +238,88 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
         ))
     }
 
+    func testAddressMorphPlanPreservesSharedPrefixAndSuffix() {
+        let plan = SidebarAddressMorphPlan(
+            sourceText: "https://one.example/page",
+            destinationText: "https://two.example/page"
+        )
+
+        XCTAssertEqual(plan.sharedPrefixCount, "https://".count)
+        XCTAssertEqual(plan.sharedSuffixCount, ".example/page".count)
+        XCTAssertEqual(plan.sourceChangedCount, 3)
+        XCTAssertEqual(plan.destinationChangedCount, 3)
+    }
+
+    func testAddressGlyphMorphRendersExactSourceAtBeginning() {
+        let source = "https://one.example/page"
+        let destination = "https://two.example/page"
+        let plan = SidebarAddressMorphPlan(
+            sourceText: source,
+            destinationText: destination
+        )
+
+        for index in 0..<source.count {
+            let state = SidebarAddressGlyphMorph.state(
+                progress: 0,
+                role: .source,
+                sliceIndex: index,
+                sliceCount: source.count,
+                morphPlan: plan
+            )
+            XCTAssertEqual(state.opacity, 1, accuracy: 0.0001)
+            XCTAssertEqual(state.translationY, 0, accuracy: 0.0001)
+            XCTAssertEqual(state.blurProgress, 0, accuracy: 0.0001)
+        }
+
+        for index in 0..<destination.count {
+            let state = SidebarAddressGlyphMorph.state(
+                progress: 0,
+                role: .destination,
+                sliceIndex: index,
+                sliceCount: destination.count,
+                morphPlan: plan
+            )
+            XCTAssertEqual(state.opacity, 0, accuracy: 0.0001)
+        }
+    }
+
+    func testAddressGlyphMorphRendersExactDestinationAtEnd() {
+        let source = "https://short.test/path"
+        let destination = "https://considerably-longer.test/path"
+        let plan = SidebarAddressMorphPlan(
+            sourceText: source,
+            destinationText: destination
+        )
+
+        for index in 0..<source.count {
+            let state = SidebarAddressGlyphMorph.state(
+                progress: 1,
+                role: .source,
+                sliceIndex: index,
+                sliceCount: source.count,
+                morphPlan: plan
+            )
+            let expectedOpacity = index < plan.sharedPrefixCount ? 1.0 : 0.0
+            XCTAssertEqual(state.opacity, expectedOpacity, accuracy: 0.0001)
+            XCTAssertEqual(state.translationY, 0, accuracy: 0.0001)
+            XCTAssertEqual(state.blurProgress, 0, accuracy: 0.0001)
+        }
+
+        for index in 0..<destination.count {
+            let state = SidebarAddressGlyphMorph.state(
+                progress: 1,
+                role: .destination,
+                sliceIndex: index,
+                sliceCount: destination.count,
+                morphPlan: plan
+            )
+            let expectedOpacity = index < plan.sharedPrefixCount ? 0.0 : 1.0
+            XCTAssertEqual(state.opacity, expectedOpacity, accuracy: 0.0001)
+            XCTAssertEqual(state.translationY, 0, accuracy: 0.0001)
+            XCTAssertEqual(state.blurProgress, 0, accuracy: 0.0001)
+        }
+    }
+
     func testChromeHandoffDefersExactStyleOnlyWhenPageTravelIsRequired() {
         let first = SidebarSpacePagerPageID.space(UUID())
         let second = SidebarSpacePagerPageID.space(UUID())
@@ -262,7 +344,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
             SidebarSpacePagerFixedChromeTarget.pageID(
                 visibleFractionalPageIndex: 1.08,
                 gestureStartFractionalPageIndex: 1,
-                rawGestureDisplacementX: 24,
+                adjustedGestureDisplacementX: 24,
                 pageWidth: 300,
                 pages: pages
             ),
@@ -272,7 +354,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
             SidebarSpacePagerFixedChromeTarget.pageID(
                 visibleFractionalPageIndex: 0.92,
                 gestureStartFractionalPageIndex: 1,
-                rawGestureDisplacementX: -24,
+                adjustedGestureDisplacementX: -24,
                 pageWidth: 300,
                 pages: pages
             ),
@@ -292,7 +374,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
             SidebarSpacePagerFixedChromeTarget.pageID(
                 visibleFractionalPageIndex: 1.0005,
                 gestureStartFractionalPageIndex: 1,
-                rawGestureDisplacementX: 0.1,
+                adjustedGestureDisplacementX: 0.1,
                 pageWidth: 300,
                 pages: pages
             ),
@@ -302,7 +384,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
             SidebarSpacePagerFixedChromeTarget.pageID(
                 visibleFractionalPageIndex: -0.08,
                 gestureStartFractionalPageIndex: 0,
-                rawGestureDisplacementX: -24,
+                adjustedGestureDisplacementX: -24,
                 pageWidth: 300,
                 pages: pages
             ),
@@ -312,7 +394,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
             SidebarSpacePagerFixedChromeTarget.pageID(
                 visibleFractionalPageIndex: 0,
                 gestureStartFractionalPageIndex: 0,
-                rawGestureDisplacementX: nil,
+                adjustedGestureDisplacementX: nil,
                 pageWidth: 0,
                 pages: pages
             )
@@ -373,7 +455,6 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
             scaledEvent.isDirectionInvertedFromDevice,
             originalEvent.isDirectionInvertedFromDevice
         )
-        XCTAssertEqual(state.cumulativeRawDisplacementX, 40, accuracy: 0.0001)
     }
 
     func testPagerInputScalingCarriesSubpointRemaindersAcrossEvents() throws {
@@ -389,7 +470,6 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
         }
 
         XCTAssertEqual(deliveredDisplacementX, 7, accuracy: 0.0001)
-        XCTAssertEqual(state.cumulativeRawDisplacementX, 20, accuracy: 0.0001)
     }
 
     func testPagerInputScalingPreservesSignedReversals() throws {
@@ -404,7 +484,6 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
         ))
 
         XCTAssertEqual(forward.scrollingDeltaX + reverse.scrollingDeltaX, 0, accuracy: 0.0001)
-        XCTAssertEqual(state.cumulativeRawDisplacementX, 0, accuracy: 0.0001)
     }
 
     func testPagerInputScalingClampsSensitivityAndResets() throws {
@@ -419,7 +498,6 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
         )
 
         state.reset()
-        XCTAssertEqual(state.cumulativeRawDisplacementX, 0, accuracy: 0.0001)
         XCTAssertEqual(
             try XCTUnwrap(state.scaledEvent(
                 from: scrollEvent(horizontalDelta: 10),
@@ -431,6 +509,37 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
         XCTAssertEqual(SidebarSpacePagerScrollInputScalingState.normalizedSensitivity(.nan), 1)
     }
 
+    func testPagerHorizontalInputConvertsAppKitWheelToContentCoordinates() throws {
+        XCTAssertEqual(
+            try XCTUnwrap(SidebarSpacePagerHorizontalInputSample(
+                scrollingDeltaX: -40
+            )).adjustedDisplacementX,
+            40
+        )
+        XCTAssertEqual(
+            try XCTUnwrap(SidebarSpacePagerHorizontalInputSample(
+                scrollingDeltaX: 40
+            )).adjustedDisplacementX,
+            -40
+        )
+        XCTAssertNil(SidebarSpacePagerHorizontalInputSample(scrollingDeltaX: .nan))
+    }
+
+    func testPagerHorizontalGestureAccumulatorOwnsSemanticDisplacement() throws {
+        var accumulator = SidebarSpacePagerHorizontalGestureAccumulator()
+        accumulator.append(try XCTUnwrap(SidebarSpacePagerHorizontalInputSample(
+            scrollingDeltaX: -40
+        )))
+        accumulator.append(try XCTUnwrap(SidebarSpacePagerHorizontalInputSample(
+            scrollingDeltaX: 10
+        )))
+
+        XCTAssertEqual(accumulator.cumulativeAdjustedDisplacementX, 30)
+
+        accumulator.reset()
+        XCTAssertEqual(accumulator.cumulativeAdjustedDisplacementX, 0)
+    }
+
     func testPagerGestureCancellationIgnoresChangesUntilNextBegin() {
         var gate = SidebarSpacePagerPhysicalGestureGate()
         XCTAssertFalse(gate.ignoresChangedEvents)
@@ -446,13 +555,217 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
         XCTAssertFalse(gate.ignoresChangedEvents)
     }
 
-    func testPagerUsesUnscaledGestureDirectionWhenDisplayedMovementIsSubthreshold() {
+    func testPagerHorizontalIntentUsesAdjustedDeltaConvention() {
+        XCTAssertEqual(
+            SidebarSpacePagerHorizontalIntent.intent(
+                forAdjustedDisplacement: -24,
+                minimumDisplacement: 2
+            ),
+            .backward
+        )
+        XCTAssertEqual(
+            SidebarSpacePagerHorizontalIntent.intent(
+                forAdjustedDisplacement: 24,
+                minimumDisplacement: 2
+            ),
+            .forward
+        )
+    }
+
+    func testPagerHorizontalIntentWaitsForMeaningfulInput() {
+        XCTAssertNil(SidebarSpacePagerHorizontalIntent.intent(
+            forAdjustedDisplacement: 0.5,
+            minimumDisplacement: 2
+        ))
+        XCTAssertNil(SidebarSpacePagerHorizontalIntent.intent(
+            forAdjustedDisplacement: .nan,
+            minimumDisplacement: 2
+        ))
+    }
+
+    func testCreationPullBeginsOnlyFromSettledLastPage() {
+        XCTAssertTrue(SidebarSpaceCreationPullEligibility.canBegin(
+            creationIsAvailable: true,
+            gestureOrigin: SidebarSpacePagerPhysicalGestureOrigin(
+                scrollWasIdle: true,
+                anchoredPageIndex: nil
+            ),
+            currentOffsetX: 800,
+            lastPageOffsetX: 800,
+            lastPageIndex: 4
+        ))
+        XCTAssertFalse(SidebarSpaceCreationPullEligibility.canBegin(
+            creationIsAvailable: true,
+            gestureOrigin: SidebarSpacePagerPhysicalGestureOrigin(
+                scrollWasIdle: true,
+                anchoredPageIndex: nil
+            ),
+            currentOffsetX: 600,
+            lastPageOffsetX: 800,
+            lastPageIndex: 4
+        ))
+        XCTAssertFalse(SidebarSpaceCreationPullEligibility.canBegin(
+            creationIsAvailable: true,
+            gestureOrigin: SidebarSpacePagerPhysicalGestureOrigin(
+                scrollWasIdle: false,
+                anchoredPageIndex: nil
+            ),
+            currentOffsetX: 800,
+            lastPageOffsetX: 800,
+            lastPageIndex: 4
+        ))
+    }
+
+    func testForwardCreationPullUsesAdjustedDeltaAndReversesNaturally() throws {
+        var pull = SidebarSpaceCreationPullState()
+        let initial = try XCTUnwrap(pull.begin(
+            initialForwardDistance: 40,
+            pageWidth: 300
+        ))
+        let continued = try XCTUnwrap(pull.consumeAdjustedDelta(40, pageWidth: 300))
+        let reversed = try XCTUnwrap(pull.consumeAdjustedDelta(-20, pageWidth: 300))
+
+        XCTAssertEqual(initial.progress, 0.25, accuracy: 0.0001)
+        XCTAssertEqual(continued.progress, 0.5, accuracy: 0.0001)
+        XCTAssertEqual(reversed.progress, 0.375, accuracy: 0.0001)
+        XCTAssertLessThan(reversed.progress, continued.progress)
+        XCTAssertEqual(reversed.disposition, .pulling)
+    }
+
+    func testCreationPullHasIncreasingNonlinearResistance() throws {
+        var pull = SidebarSpaceCreationPullState()
+        let first = try XCTUnwrap(pull.begin(
+            initialForwardDistance: 40,
+            pageWidth: 300
+        ))
+        let second = try XCTUnwrap(pull.consumeAdjustedDelta(40, pageWidth: 300))
+        let third = try XCTUnwrap(pull.consumeAdjustedDelta(40, pageWidth: 300))
+
+        let firstDisplayedIncrement = first.displayedDistance
+        let secondDisplayedIncrement = second.displayedDistance - first.displayedDistance
+        let thirdDisplayedIncrement = third.displayedDistance - second.displayedDistance
+        XCTAssertGreaterThan(firstDisplayedIncrement, secondDisplayedIncrement)
+        XCTAssertGreaterThan(secondDisplayedIncrement, thirdDisplayedIncrement)
+        XCTAssertLessThan(third.displayedDistance, pull.unresistedDistance)
+        XCTAssertGreaterThan(third.progress, second.progress)
+    }
+
+    func testBackwardInputCannotCreateProgressWithoutForwardBoundaryInference() {
+        var pull = SidebarSpaceCreationPullState()
+
+        XCTAssertNil(pull.consumeAdjustedDelta(-40, pageWidth: 300))
+        XCTAssertEqual(pull.progress, 0)
+        XCTAssertEqual(pull.release(), .none)
+    }
+
+    func testCreationPullReversalPastOriginCancelsAtLastPage() throws {
+        var pull = SidebarSpaceCreationPullState()
+        _ = try XCTUnwrap(pull.begin(
+            initialForwardDistance: 30,
+            pageWidth: 300
+        ))
+        let update = try XCTUnwrap(pull.consumeAdjustedDelta(-40, pageWidth: 300))
+
+        XCTAssertEqual(update.disposition, .cancelled)
+        XCTAssertEqual(update.displayedDistance, 0)
+        XCTAssertEqual(update.progress, 0)
+        XCTAssertEqual(pull.release(), .none)
+    }
+
+    func testBelowThresholdCreationPullCancels() throws {
+        var pull = SidebarSpaceCreationPullState()
+        _ = try XCTUnwrap(pull.begin(
+            initialForwardDistance: SidebarSpacePagerMetrics.creationPullThreshold - 1,
+            pageWidth: 300
+        ))
+
+        XCTAssertEqual(pull.release(), .cancel)
+        XCTAssertEqual(pull.release(), .none)
+    }
+
+    func testAboveThresholdCreationPullCreatesExactlyOnce() throws {
+        var pull = SidebarSpaceCreationPullState()
+        _ = try XCTUnwrap(pull.begin(
+            initialForwardDistance: SidebarSpacePagerMetrics.creationPullThreshold,
+            pageWidth: 300
+        ))
+        var creationCount = 0
+
+        if pull.release() == .create {
+            creationCount += 1
+        }
+        if pull.release() == .create {
+            creationCount += 1
+        }
+
+        XCTAssertEqual(creationCount, 1)
+    }
+
+    func testCreationPresentationDoesNotAdvanceAddressMorphPastLastRealPage() throws {
+        var pull = SidebarSpaceCreationPullState()
+        _ = try XCTUnwrap(pull.begin(
+            initialForwardDistance: SidebarSpacePagerMetrics.creationPullThreshold,
+            pageWidth: 300
+        ))
+        let addressState = try XCTUnwrap(SidebarAddressScrollMorph.state(
+            at: 2,
+            pageTexts: ["Activity", "https://one.example", "https://two.example"]
+        ))
+
+        XCTAssertEqual(pull.progress, 1)
+        XCTAssertEqual(addressState.sourceText, "https://two.example")
+        XCTAssertEqual(addressState.destinationText, "https://two.example")
+        XCTAssertEqual(addressState.progress, 0)
+    }
+
+    func testCreationAffordanceAlwaysFitsInsideRevealedGap() {
+        for displayedDistance in stride(
+            from: CGFloat(0),
+            through: SidebarSpacePagerMetrics.creationRailMaximumWidth,
+            by: 0.5
+        ) {
+            let revealScale = SidebarSpaceCreationAffordanceLayout.revealScale(
+                forDisplayedDistance: displayedDistance
+            )
+            let availableWidth = max(
+                displayedDistance - SidebarSpacePagerMetrics.creationRailTrailingPadding,
+                0
+            )
+            let scaledDiameter =
+                SidebarSpacePagerMetrics.creationAffordanceDiameter * revealScale
+
+            XCTAssertGreaterThanOrEqual(revealScale, 0)
+            XCTAssertLessThanOrEqual(revealScale, 1)
+            XCTAssertLessThanOrEqual(scaledDiameter, availableWidth + 0.0001)
+        }
+    }
+
+    func testCreationAffordanceBecomesFullyVisibleWithoutNonfiniteLayout() {
+        let fullyVisibleDistance =
+            SidebarSpacePagerMetrics.creationRailTrailingPadding
+            + SidebarSpacePagerMetrics.creationAffordanceDiameter
+
+        XCTAssertEqual(
+            SidebarSpaceCreationAffordanceLayout.revealScale(
+                forDisplayedDistance: fullyVisibleDistance
+            ),
+            1
+        )
+        XCTAssertEqual(
+            SidebarSpaceCreationAffordanceLayout.revealScale(
+                forDisplayedDistance: .nan
+            ),
+            0
+        )
+    }
+
+    func testPagerUsesAdjustedGestureDirectionWhenDisplayedMovementIsSubthreshold() {
         XCTAssertEqual(
             SidebarSpacePagerSnap.targetPageIndex(
                 originalOffsetX: 200,
                 proposedOffsetX: 200,
                 visibleFractionalPageIndex: 1.001,
-                rawGestureDisplacementX: 1,
+                adjustedGestureDisplacementX: 1,
                 velocityX: 0,
                 pageWidth: 200,
                 pageCount: 5
@@ -464,7 +777,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
                 originalOffsetX: 200,
                 proposedOffsetX: 200,
                 visibleFractionalPageIndex: 0.999,
-                rawGestureDisplacementX: -1,
+                adjustedGestureDisplacementX: -1,
                 velocityX: 0,
                 pageWidth: 200,
                 pageCount: 5
@@ -476,17 +789,23 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
     func testPagerSensitivityDoesNotChangeSlowDragDestination() throws {
         func destination(sensitivity: CGFloat) throws -> Int {
             var state = SidebarSpacePagerScrollInputScalingState()
+            var accumulator = SidebarSpacePagerHorizontalGestureAccumulator()
+            let input = try XCTUnwrap(SidebarSpacePagerHorizontalInputSample(
+                scrollingDeltaX: -1
+            ))
+            accumulator.append(input)
             let scaledEvent = try XCTUnwrap(state.scaledEvent(
-                from: scrollEvent(horizontalDelta: 1),
+                from: scrollEvent(horizontalDelta: -1),
                 sensitivity: sensitivity
             ))
-            let displayedOffset = 200 + scaledEvent.scrollingDeltaX
+            let displayedOffset = 200 - scaledEvent.scrollingDeltaX
 
             return SidebarSpacePagerSnap.targetPageIndex(
                 originalOffsetX: 200,
                 proposedOffsetX: 200,
                 visibleFractionalPageIndex: displayedOffset / 200,
-                rawGestureDisplacementX: state.cumulativeRawDisplacementX,
+                adjustedGestureDisplacementX:
+                    accumulator.cumulativeAdjustedDisplacementX,
                 velocityX: 0,
                 pageWidth: 200,
                 pageCount: 5
@@ -584,7 +903,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
                 originalOffsetX: 200,
                 proposedOffsetX: 200,
                 visibleFractionalPageIndex: 1.01,
-                rawGestureDisplacementX: 20,
+                adjustedGestureDisplacementX: 20,
                 velocityX: -5_000,
                 pageWidth: 200,
                 pageCount: 5
@@ -599,7 +918,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
                 originalOffsetX: 200,
                 proposedOffsetX: 201,
                 visibleFractionalPageIndex: 0.99,
-                rawGestureDisplacementX: -20,
+                adjustedGestureDisplacementX: -20,
                 velocityX: -5_000,
                 pageWidth: 200,
                 pageCount: 5
@@ -691,7 +1010,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
         tracker.transition(from: .idle, to: .tracking)
         XCTAssertTrue(tracker.acceptsDirectionalSnap)
         XCTAssertEqual(tracker.gestureStartFractionalPageIndex, 1.75)
-        tracker.rawGestureDisplacementX = 12
+        tracker.adjustedGestureDisplacementX = 12
 
         tracker.visibleFractionalPageIndex = 1.8
         tracker.transition(from: .tracking, to: .interacting)
@@ -702,12 +1021,12 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
 
         tracker.transition(from: .decelerating, to: .interacting)
         XCTAssertEqual(tracker.gestureStartFractionalPageIndex, 1.8)
-        XCTAssertNil(tracker.rawGestureDisplacementX)
+        XCTAssertNil(tracker.adjustedGestureDisplacementX)
 
         tracker.transition(from: .interacting, to: .idle)
         XCTAssertFalse(tracker.acceptsDirectionalSnap)
         XCTAssertNil(tracker.gestureStartFractionalPageIndex)
-        XCTAssertNil(tracker.rawGestureDisplacementX)
+        XCTAssertNil(tracker.adjustedGestureDisplacementX)
 
         tracker.transition(from: .idle, to: .tracking)
         tracker.transition(from: .tracking, to: .animating)
@@ -724,14 +1043,14 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
         tracker.visibleFractionalPageIndex = 2
 
         tracker.transition(from: .idle, to: .tracking)
-        tracker.rawGestureDisplacementX = 18
+        tracker.adjustedGestureDisplacementX = 18
         tracker.visibleFractionalPageIndex = 2.04
         tracker.transition(from: .tracking, to: .interacting)
         tracker.transition(from: .interacting, to: .animating)
 
         XCTAssertTrue(tracker.acceptsDirectionalSnap)
         XCTAssertEqual(tracker.gestureStartFractionalPageIndex, 2)
-        XCTAssertEqual(tracker.rawGestureDisplacementX, 18)
+        XCTAssertEqual(tracker.adjustedGestureDisplacementX, 18)
     }
 
     func testPagerAnchorsGestureInterruptingAnimationToPreviousDestination() {
@@ -747,7 +1066,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
 
         XCTAssertEqual(tracker.gestureStartFractionalPageIndex, 1.2)
         XCTAssertEqual(tracker.gestureSourcePageIndex, 2)
-        XCTAssertNil(tracker.rawGestureDisplacementX)
+        XCTAssertNil(tracker.adjustedGestureDisplacementX)
         XCTAssertTrue(tracker.acceptsDirectionalSnap)
     }
 
@@ -755,12 +1074,12 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
         let tracker = SidebarSpacePagerGeometryTracker()
         tracker.visibleFractionalPageIndex = 1
 
-        tracker.beginPhysicalGesture()
+        tracker.beginPhysicalGesture(id: 1)
         tracker.transition(from: .idle, to: .interacting)
         tracker.recordResolvedTargetPageIndex(2)
 
         tracker.visibleFractionalPageIndex = 1.2
-        tracker.beginPhysicalGesture()
+        tracker.beginPhysicalGesture(id: 2)
 
         XCTAssertEqual(tracker.gestureStartFractionalPageIndex, 1.2)
         XCTAssertEqual(tracker.gestureSourcePageIndex, 2)
@@ -773,7 +1092,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
                 gestureStartFractionalPageIndex: tracker.gestureStartFractionalPageIndex,
                 gestureSourcePageIndex: tracker.gestureSourcePageIndex,
                 visibleFractionalPageIndex: 1.205,
-                rawGestureDisplacementX: 1,
+                adjustedGestureDisplacementX: 1,
                 velocityX: 0,
                 pageWidth: 200,
                 pageCount: 5
@@ -790,7 +1109,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
                 gestureStartFractionalPageIndex: 1.2,
                 gestureSourcePageIndex: 2,
                 visibleFractionalPageIndex: 1.205,
-                rawGestureDisplacementX: 1,
+                adjustedGestureDisplacementX: 1,
                 velocityX: 0,
                 pageWidth: 200,
                 pageCount: 5
@@ -804,7 +1123,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
                 gestureStartFractionalPageIndex: 1.2,
                 gestureSourcePageIndex: 2,
                 visibleFractionalPageIndex: 1.195,
-                rawGestureDisplacementX: -1,
+                adjustedGestureDisplacementX: -1,
                 velocityX: 0,
                 pageWidth: 200,
                 pageCount: 5
@@ -821,7 +1140,7 @@ final class SidebarSpacePagerSelectionTests: XCTestCase {
 
         XCTAssertFalse(tracker.acceptsDirectionalSnap)
         XCTAssertNil(tracker.gestureStartFractionalPageIndex)
-        XCTAssertNil(tracker.rawGestureDisplacementX)
+        XCTAssertNil(tracker.adjustedGestureDisplacementX)
     }
 
     func testPagerCanMoveInwardFromBothEdges() {
diff --git a/Tests/MeridianBrowserTests/SitePermissionPolicyTests.swift b/Tests/MeridianBrowserTests/SitePermissionPolicyTests.swift
index 68a6756..e223b30 100644
--- a/Tests/MeridianBrowserTests/SitePermissionPolicyTests.swift
+++ b/Tests/MeridianBrowserTests/SitePermissionPolicyTests.swift
@@ -61,7 +61,7 @@ final class SitePermissionPolicyTests: XCTestCase {
         XCTAssertEqual(policy.evaluation(for: cameraRequest, settings: []), .ask)
         XCTAssertEqual(
             policy.evaluation(for: locationRequest, settings: []),
-            .deny(reason: "Location permissions are not supported by Bare Browser on this WebKit version.")
+            .deny(reason: "Location permissions are not supported by Lumen Browser on this WebKit version.")
         )
         XCTAssertTrue(policy.requiresUserActionForAutoplay)
     }
diff --git a/script/build_and_run.sh b/script/build_and_run.sh
index a37f7fe..38bcf99 100755
--- a/script/build_and_run.sh
+++ b/script/build_and_run.sh
@@ -1,15 +1,17 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-PRODUCT_NAME="Bare Browser"
+PRODUCT_NAME="Lumen Browser"
 MODE="${1:-run}"
 SWIFT_PRODUCT_NAME="MeridianBrowser"
-LEGACY_EXECUTABLE_NAME="MeridianBrowser"
+LEGACY_EXECUTABLE_NAMES=("Bare Browser" "MeridianBrowser")
 EXECUTABLE_NAME="$PRODUCT_NAME"
+# Application identity is compatibility-stable across the public rebrand so
+# existing WebKit data stores, permissions, preferences, and Keychain ACLs survive.
 BUNDLE_ID="app.barebrowser.BareBrowser"
 MIN_SYSTEM_VERSION="26.0"
 SWIFT_CONFIGURATION="debug"
-APP_ICON_NAME="MammothLogo"
+APP_ICON_NAME="LumenLogo"
 APP_ICON_FILE="$APP_ICON_NAME.icon"
 
 ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
@@ -20,10 +22,14 @@ APP_MACOS="$APP_CONTENTS/MacOS"
 APP_RESOURCES="$APP_CONTENTS/Resources"
 APP_BINARY="$APP_MACOS/$EXECUTABLE_NAME"
 INFO_PLIST="$APP_CONTENTS/Info.plist"
-BUILD_STAMP="$DIST_DIR/.BareBrowserBuildConfiguration"
+BUILD_STAMP="$DIST_DIR/.LumenBrowserBuildConfiguration"
+LEGACY_APP_BUNDLE="$DIST_DIR/Bare Browser.app"
+LEGACY_BUILD_STAMP="$DIST_DIR/.BareBrowserBuildConfiguration"
 APP_ICON_SOURCE="$ROOT_DIR/Resources/$APP_ICON_FILE"
 APP_ICON_PARTIAL_PLIST="$DIST_DIR/AppIconPartialInfo.plist"
 APP_ICON_ACTOOL_OUTPUT="$DIST_DIR/AppIconActoolOutput.plist"
+# Keep the established local certificate for the same continuity guarantees as
+# the stable bundle identifier. This is a development implementation detail.
 DEV_SIGNING_IDENTITY="Bare Browser Local Development"
 DEV_SIGNING_DIR="$DIST_DIR/Signing"
 DEV_SIGNING_KEYCHAIN="$DEV_SIGNING_DIR/BareBrowserLocalDevelopment.keychain-db"
@@ -45,7 +51,7 @@ app_bundle_is_current() {
   local source_paths=("$ROOT_DIR/Package.swift" "$ROOT_DIR/Sources" "$ROOT_DIR/Resources" "$ROOT_DIR/script/build_and_run.sh")
   local newest_source
 
-  [[ "${BARE_BROWSER_FORCE_BUILD:-0}" != "1" ]] || return 1
+  [[ "${LUMEN_BROWSER_FORCE_BUILD:-0}" != "1" ]] || return 1
   [[ -x "$APP_BINARY" && -f "$INFO_PLIST" && -f "$BUILD_STAMP" ]] || return 1
   [[ "$(cat "$BUILD_STAMP")" == "$(build_stamp_value)" ]] || return 1
   [[ -f "$ROOT_DIR/Package.resolved" ]] && source_paths+=("$ROOT_DIR/Package.resolved")
@@ -57,7 +63,7 @@ app_bundle_is_current() {
 reuse_current_app_if_possible() {
   app_bundle_is_current || return 1
 
-  echo "Reusing current signed app bundle. Set BARE_BROWSER_FORCE_BUILD=1 to rebuild."
+  echo "Reusing current signed app bundle. Set LUMEN_BROWSER_FORCE_BUILD=1 to rebuild."
   case "$MODE" in
     run|--release|release)
       /usr/bin/open -n "$APP_BUNDLE"
@@ -87,9 +93,11 @@ reuse_current_app_if_possible() {
 }
 
 pkill -x "$EXECUTABLE_NAME" >/dev/null 2>&1 || true
-if [[ "$LEGACY_EXECUTABLE_NAME" != "$EXECUTABLE_NAME" ]]; then
-  pkill -x "$LEGACY_EXECUTABLE_NAME" >/dev/null 2>&1 || true
-fi
+for legacy_executable_name in "${LEGACY_EXECUTABLE_NAMES[@]}"; do
+  [[ "$legacy_executable_name" == "$EXECUTABLE_NAME" ]] \
+    || pkill -x "$legacy_executable_name" >/dev/null 2>&1 \
+    || true
+done
 
 if reuse_current_app_if_possible; then
   exit 0
@@ -98,7 +106,8 @@ fi
 swift build -c "$SWIFT_CONFIGURATION"
 BUILD_BINARY="$(swift build -c "$SWIFT_CONFIGURATION" --show-bin-path)/$SWIFT_PRODUCT_NAME"
 
-rm -rf "$APP_BUNDLE"
+rm -rf "$APP_BUNDLE" "$LEGACY_APP_BUNDLE"
+rm -f "$LEGACY_BUILD_STAMP"
 mkdir -p "$APP_MACOS" "$APP_RESOURCES"
 cp "$BUILD_BINARY" "$APP_BINARY"
 chmod +x "$APP_BINARY"
@@ -150,13 +159,13 @@ cat >"$INFO_PLIST" <<PLIST
         <string>public.data</string>
       </array>
       <key>UTTypeDescription</key>
-      <string>Bare Browser Sidebar Space Identifier</string>
+      <string>Lumen Browser Sidebar Space Identifier</string>
       <key>UTTypeIdentifier</key>
-      <string>com.meridianbrowser.sidebar-space-id</string>
+      <string>app.lumenbrowser.sidebar-space-id</string>
       <key>UTTypeTagSpecification</key>
       <dict>
         <key>public.mime-type</key>
-        <string>application/x-bare-browser-sidebar-space-id</string>
+        <string>application/x-lumen-browser-sidebar-space-id</string>
       </dict>
     </dict>
   </array>
@@ -317,7 +326,7 @@ sign_with_local_identity() {
 }
 
 sign_app() {
-  local identity="${BARE_BROWSER_CODESIGN_IDENTITY:-}"
+  local identity="${LUMEN_BROWSER_CODESIGN_IDENTITY:-}"
 
   if [[ -z "$identity" ]]; then
     identity="$(
