diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
index c8a15afb191..90bac911835 100644
--- a/RELEASE_NOTES.md
+++ b/RELEASE_NOTES.md
@@ -13,9 +13,12 @@ This serves two purposes:
 - Added a new `\Hyde\Framework\Actions\PreBuildTasks\TransferMediaAssets` build task handle media assets transfers for site builds.
 
 ### Changed
+- **Breaking:** The internals of the navigation system has been rewritten into a new Navigation API. This change is breaking for custom navigation implementations. For more information, see below.
+- Minor: Navigation menu items are now no longer filtered by duplicates (meaning two items with the same label can now exist in the same menu) in https://github.com/hydephp/develop/pull/1573
+- Minor: Due to changes in the navigation system, it is possible that existing configuration files will need to be adjusted in order for menus to look the same (in terms of ordering etc.)
+- Minor: The documentation article component now supports disabling the semantic rendering using a falsy value in https://github.com/hydephp/develop/pull/1566
 - Changed how the documentation search is generated, to be an `InMemoryPage` instead of a post-build task.
 - Media asset files are now copied using the new build task instead of the deprecated `BuildService::transferMediaAssets()` method.
-- Minor: The documentation article component now supports disabling the semantic rendering using a falsy value in https://github.com/hydephp/develop/pull/1566
 
 ### Deprecated
 - for soon-to-be removed features.
@@ -41,6 +44,32 @@ Please see the "Breaking changes & upgrade guide" section below for more informa
 
 Please read through this section to ensure your site upgrades smoothly.
 
+## High impact
+
+### Navigation system rewrite
+
+The navigation system has been rewritten into a new Navigation API. This change is breaking for custom navigation implementations, see more down below.
+
+For most users, the only impact will be that configuration files need to be updated to use the new configuration format. Due to the internal changes,
+it's also possible that menu items will be in a slightly different order than before, depending on your setup. Please verify that your site's menus
+look as expected after upgrading, and adjust the configuration files if necessary, before deploying to production.
+
+### Navigation and sidebar configuration changes
+
+The navigation and sidebar configuration files have been updated to use the new Navigation API.
+This means that you will need to update your configuration files to use the new format.
+
+The easiest way to upgrade is to publish updated configuration files (`hyde.php` and `docs.php`) and copy over your customizations.
+
+The following configuration entries have been updated:
+
+-  Changed configuration option `docs.sidebar_order` to `docs.sidebar.order` in https://github.com/hydephp/develop/pull/1583
+-  Upgrade path: Move the `sidebar_order` option's array in the `config/docs.php` file into the `sidebar` array in the same file.
+
+-  Changed configuration option `docs.table_of_contents` to `docs.sidebar.table_of_contents` in https://github.com/hydephp/develop/pull/1584
+-  Upgrade path: Move the `table_of_contents` option's array in the `config/docs.php` file into the `sidebar` array in the same file.
+
+
 ## General impact
 
 ### Documentation search page changes
@@ -49,26 +78,55 @@ The documentation search page and search index have been changed to be generated
 
 The main impact noticeable to most users by this is the implicit changes, like the pages showing up in the dashboard and route list command.
 
-In case you have customized the `GenerateSearch` post-build task you may, depending on what you were trying to do, 
+In case you have customized the `GenerateSearch` post-build task you may, depending on what you were trying to do,
 want to adapt your code to interact with the new `InMemoryPage`, which is generated in the `HydeCoreExtension` class.
 
 For more information, see https://github.com/hydephp/develop/pull/1498.
 
 ## Low impact
 
+### Navigation internal changes
+
+The navigation system has been rewritten into a new Navigation API. This change is breaking for custom navigation implementations.
+
+If you have previously in your custom code done any of the following, or similar, you will need to adapt your code to use the new Navigation API:
+- Created custom navigation menus or Blade components
+- Extended or called the navigation related classes directly
+- Customized the navigation system in any way beyond the standard configuration
+
+
+#### Upgrade guide
+
+Due to the scope of the rewrite, the easiest and fastest way to upgrade your code is to recreate it using the new Navigation API.
+
+- For a full comparison of the changes, you may see the PR that introduced the new API: https://github.com/hydephp/develop/pull/1568/files
+- For information on how to use the new Navigation API, see the documentation: https://hydephp.com/docs/2.x/navigation-api
+
+### HTML ID changes
+
+Some HTML IDs have been renamed to follow a more consistent naming convention.
+
+If you have used any of the following selectors in custom code you wrote yourself, you will need to update to use the new changed IDs.
+
+#### https://github.com/hydephp/develop/pull/1622
+- Rename HTML ID `#searchMenu` to `#search-menu`
+- Rename HTML ID `#searchMenuButton` to `#search-menu-button`
+- Rename HTML ID `#searchMenuButtonMobile` to `#search-menu-button-mobile`
+
+
 ### New documentation search implementation
 
 As the new documentation search implementation brings changes to their code API you may need to adapt your code
 according to the information below in case you wrote custom code that interacted with these parts of the codebase.
 
-- The `GenerateSearch` post-build task has been removed. If you have previously extended or customized this class, 
+- The `GenerateSearch` post-build task has been removed. If you have previously extended or customized this class,
   you will need to adapt your code, as the search index files are now handled implicitly during the standard build process,
   as the search pages are now added to the kernel page and route collection. (https://github.com/hydephp/develop/pull/1498)
 
 - If your site has a custom documentation search page, for example `_docs/search.md` or `_pages/docs/search.blade.php`,
-  that page will no longer be built when using the specific `build:search` command. It will, of course, 
+  that page will no longer be built when using the specific `build:search` command. It will, of course,
   be built using the standard `build` command. https://github.com/hydephp/develop/commit/82dc71f4a0e7b6be7a9f8d822fbebe39d2289ced
- 
+
 - In the highly unlikely event your site customizes any of the search pages by replacing them in the kernel route collection,
   you would now need to do that in the kernel page collection due to the search pages being generated earlier in the lifecycle.
   https://github.com/hydephp/develop/commit/82dc71f4a0e7b6be7a9f8d822fbebe39d2289ced
diff --git a/_ide_helper.php b/_ide_helper.php
index 7d868d7bbb5..8cc231f850f 100644
--- a/_ide_helper.php
+++ b/_ide_helper.php
@@ -22,6 +22,11 @@
 /** @var string $routeKey The route key for the page being compiled/previewed */
 $routeKey = \Hyde\Support\Facades\Render::getRouteKey();
 
+// Variables available only to some page types
+
+/** @var \Hyde\Framework\Features\Navigation\DocumentationSidebar $sidebar */
+$sidebar = app('navigation.sidebar');
+
 // Facades (aliased in app/config.php)
 
 /** @mixin \Hyde\Foundation\HydeKernel */
diff --git a/app/config.php b/app/config.php
index 9af0e0cdf05..627c80c2d13 100644
--- a/app/config.php
+++ b/app/config.php
@@ -73,6 +73,7 @@
         Hyde\Foundation\Providers\ConfigurationServiceProvider::class,
         Hyde\Framework\HydeServiceProvider::class,
         Hyde\Foundation\Providers\ViewServiceProvider::class,
+        Hyde\Foundation\Providers\NavigationServiceProvider::class,
         Hyde\Console\ConsoleServiceProvider::class,
     ],
 
diff --git a/config/docs.php b/config/docs.php
index fab400e973d..4ac1dd70706 100644
--- a/config/docs.php
+++ b/config/docs.php
@@ -30,49 +30,49 @@
         // When using a grouped sidebar, should the groups be collapsible?
         'collapsible' => true,
 
-        // Should the sidebar footer be shown? You can also set this to a string
-        // of Markdown to show in the footer. Set to `false` to disable.
-        'footer' => true,
-    ],
-
-    /*
-    |--------------------------------------------------------------------------
-    | Sidebar Page Order
-    |--------------------------------------------------------------------------
-    |
-    | In the generated Documentation pages the navigation links in the sidebar
-    | default to sort alphabetically. You can reorder the page identifiers
-    | in the list below, and the links will get sorted in that order.
-    |
-    | The items will get a priority of 500 plus the order its found in the list.
-    | Pages without a priority will fall back to the default priority of 999.
-    |
-    | You can also set explicit priorities in front matter or by specifying
-    | a value to the array key in the list to override the inferred value.
-    |
-    */
-
-    'sidebar_order' => [
-        'readme',
-        'installation',
-        'getting-started',
-    ],
-
-    /*
-    |--------------------------------------------------------------------------
-    | Table of Contents Settings
-    |--------------------------------------------------------------------------
-    |
-    | The Hyde Documentation Module comes with a fancy Sidebar that, by default,
-    | has a Table of Contents included. Here, you can configure its behavior,
-    | content, look and feel. You can also disable the feature completely.
-    |
-    */
+        // A string of Markdown to show in the footer. Set to `false` to disable.
+        'footer' => '[Back to home page](../)',
+
+        /*
+        |--------------------------------------------------------------------------
+        | Sidebar Page Order
+        |--------------------------------------------------------------------------
+        |
+        | In the generated Documentation pages the navigation links in the sidebar
+        | default to sort alphabetically. You can reorder the page identifiers
+        | in the list below, and the links will get sorted in that order.
+        |
+        | The items will get a priority of 500 plus the order its found in the list.
+        | Pages without a priority will fall back to the default priority of 999.
+        |
+        | You can also set explicit priorities in front matter or by specifying
+        | a value to the array key in the list to override the inferred value.
+        |
+        */
+
+        'order' => [
+            'readme',
+            'installation',
+            'getting-started',
+        ],
+
+        /*
+        |--------------------------------------------------------------------------
+        | Table of Contents Settings
+        |--------------------------------------------------------------------------
+        |
+        | The Hyde Documentation Module comes with a fancy Sidebar that, by default,
+        | has a Table of Contents included. Here, you can configure its behavior,
+        | content, look and feel. You can also disable the feature completely.
+        |
+        */
+
+        'table_of_contents' => [
+            'enabled' => true,
+            'min_heading_level' => 2,
+            'max_heading_level' => 4,
+        ],
 
-    'table_of_contents' => [
-        'enabled' => true,
-        'min_heading_level' => 2,
-        'max_heading_level' => 4,
     ],
 
     /*
diff --git a/config/hyde.php b/config/hyde.php
index 9cbbe1cceb3..c91370adce7 100644
--- a/config/hyde.php
+++ b/config/hyde.php
@@ -350,7 +350,7 @@
         // To get started quickly, you can uncomment the defaults here.
         // See the documentation link above for more information.
         'custom' => [
-            // NavItem::forLink('https://github.com/hydephp/hyde', 'GitHub', 200),
+            // NavigationItem::create('https://github.com/hydephp/hyde', 'GitHub', 200),
         ],
 
         // How should pages in subdirectories be displayed in the menu?
diff --git a/docs/advanced-features/navigation-api.md b/docs/advanced-features/navigation-api.md
new file mode 100644
index 00000000000..9c5fcad14d2
--- /dev/null
+++ b/docs/advanced-features/navigation-api.md
@@ -0,0 +1,433 @@
+---
+navigation:
+    label: "Navigation API"
+---
+
+# Navigation API
+
+>warning This article covers advanced information that is only relevant if you want to create custom navigation menus. Instead, you may want to read the [Navigation](navigation) article for a general overview.
+
+
+## Abstract
+
+This article describes the Navigation API introduced in HydePHP v2. Both the main navigation menu and the documentation sidebar bundled with HydePHP are built with this API.
+However, if you are interested in creating your own custom navigation menus, you can also utilize this API - and this article will show you how.
+
+This article is intended for advanced users, as most users will not need to create custom navigation menus.
+For this reason, the documentation is very code-driven due to the technical nature of the API.
+We'll also be mixing in some practical examples of Blade and PHP code to illustrate how you can use the API in your own projects.
+
+
+## Overview
+
+The Navigation API consists of a set of classes within the `Hyde\Framework\Features\Navigation` namespace.
+
+Together, these form an object-oriented way to create and interact with navigation menus and their items.
+
+In short, a navigation menu is an instance of the `NavigationMenu` class. Each menu contains a collection of `NavigationItem` or `NavigationGroup` classes.
+The former represents a single item in the menu, while the latter represents a group of items.
+
+### Visualisation
+
+Here is a visual representation of the structure of a navigation menu:
+
+```php
+namespace Hyde\Framework\Features\Navigation;
+
+class NavigationMenu {
+    protected Collection $items = [
+        new NavigationItem(destination: 'index.html', label: 'Home'),
+        new NavigationItem(destination: 'posts.html', label: 'Blog'),
+        new NavigationGroup(label: 'About', items: [
+            new NavigationItem(destination: 'about.html', label: 'About Us'),
+            new NavigationItem(destination: 'team.html', label: 'Our Team'),
+        ]),
+    ];
+}
+```
+
+### Built-in Menus
+
+HydePHP comes with two built-in menus: the main navigation menu and the documentation sidebar, both represented as child classes of the `NavigationMenu` class.
+They are bound into the service container as singletons and can be accessed through dependency injection.
+
+```php
+use Hyde\Framework\Features\Navigation\MainNavigationMenu;
+use Hyde\Framework\Features\Navigation\DocumentationSidebar;
+
+/** @var \Hyde\Framework\Features\Navigation\MainNavigationMenu $menu */
+$menu = app('navigation.main')
+
+/** @var DocumentationSidebar $sidebar */
+$sidebar= app('navigation.sidebar')
+```
+
+You can also get them through the static `get` helpers on the menu classes themselves.
+
+```php
+use Hyde\Framework\Features\Navigation\MainNavigationMenu;
+use Hyde\Framework\Features\Navigation\DocumentationSidebar;
+
+$menu = MainNavigationMenu::get();
+$sidebar = DocumentationSidebar::get();
+```
+
+>info Developer tip: The menus are only generated *after* the Hyde Kernel is booted. If you are getting BindingResolutionExceptions, ensure that you are not trying to access the menus too early in the application lifecycle. (Consider using the `booted` event.)
+
+
+## Creating Custom Menus
+
+### Introduction Overview
+
+When creating a custom menu, there are two ways to go about it:
+
+1. You can construct a NavigationMenu instance directly and add items to it. This works great for smaller menus that don't need any special logic, for example a footer menu or social media links.
+2. You can create a custom class that extends the NavigationMenu class. This is useful for larger menus that require more complex logic, or that you want to reuse in multiple places in your application or in a package.
+
+In both cases, the underlying API is the same, and you can use the helper methods and features provided by the APIs.
+
+In this section, you will first see some high level overviews of how the API can be used, then we'll dive in deeper and take a look at each class and method in detail.
+
+### High Level Example
+
+To illustrate how you can create a custom menu, let's make something useful: A footer menu with social media links.
+
+#### Step 1: Create the Menu
+
+To create our menu, we start by constructing a new NavigationMenu instance.
+We can then add our social media links as NavigationItem instances to the menu.
+
+```php
+$menu = new NavigationMenu();
+
+$menu->add([
+    // The first parameter is the URL, and the second is the label.
+    NavigationItem::create('https://twitter.com/hydephp', 'Twitter'),
+    NavigationItem::create('https://github.com/hydephp', 'GitHub'),
+    NavigationItem::create('https://hydephp.com', 'Website'),
+]);
+```
+
+#### Step 2: Display the Menu
+
+We can now iterate over the menu items to render them in our footer.
+
+```blade
+<footer>
+    <ul>
+        @foreach ($menu->getItems() as $item)
+            <li><a href="{{ $item->getLink() }}">{{ $item->getLabel() }}</a></li>
+        @endforeach
+    </ul>
+</footer>
+```
+
+This will result in the following HTML:
+
+```html
+<footer>
+    <ul>
+        <li><a href="https://twitter.com/hydephp">Twitter</a></li>
+        <li><a href="https://github.com/hydephp">GitHub</a></li>
+        <li><a href="https://hydephp.com">Website</a></li>
+    </ul>
+</footer>
+```
+
+#### Next Steps & Tips
+
+Of course, this is an incredibly simplistic example to illustrate the core concepts.
+Where the Navigation API really shines is in more complex scenarios where you want to utilize things like
+HydePHP Routes to resolve dynamic relative urls, and to use features like groups, priorities, and active states helpers to check if a menu item is the current page being viewed.
+
+The object-oriented nature of the API also makes this perfect for package developers wanting to create dynamic and reusable navigation menus that even can be further extended and customized by the end user.
+
+Here are some general tips to keep in mind when working with the Navigation API:
+- You can use the `add` method to add single items or arrays of items. You can also pass an array of items directly to the menu constructor.
+- The navigation menu items is stored in a Laravel Collection, and is type safe to support both `NavigationItem` and `NavigationGroup` instances.
+- You can also construct NavigationItem instances directly, but the `create` method is a convenient shorthand, and can fill in data from routes, if you use them.
+- It's also possible to set an item's priority as the third parameter, but here we don't need it, as they default to the order they are added.
+
+
+## Class Reference
+
+Below is a reference of the classes and methods available in the Navigation API.
+
+
+## NavigationMenu
+
+The `NavigationMenu` class represents a navigation menu. It contains a collection of items, which can be either `NavigationItem` or `NavigationGroup` instances.
+
+### Quick Reference
+
+Here is a quick reference of the methods available on the NavigationMenu class:
+
+```php
+use Hyde\Framework\Features\Navigation\NavigationMenu;
+
+// Create a new NavigationMenu instance, optionally providing an array of items.
+$menu = new NavigationMenu($items = []);
+
+// Add a single item or an array of items to the menu.
+$menu->add(new NavigationItem());
+$menu->add([new NavigationItem()]);
+
+// Get all items in the menu as a sorted Collection.
+$menu->getItems(): Collection<NavigationItem|NavigationGroup>
+```
+
+### Creating Navigation Menus
+
+You can create a new NavigationMenu instance by simply calling the constructor, optionally providing an array of items.
+
+```php
+use Hyde\Framework\Features\Navigation\NavigationMenu;
+
+$menu = new NavigationMenu($items = []);
+```
+
+Here is how to provide an array or Collection of `NavigationItem` and/or `NavigationGroup` instances directly to the constructor.
+
+```php
+use Hyde\Framework\Features\Navigation\NavigationMenu;
+use Hyde\Framework\Features\Navigation\NavigationItem;
+use Hyde\Framework\Features\Navigation\NavigationGroup;
+
+$menu = new NavigationMenu([
+    new NavigationItem('index.html', 'Home'),
+    new NavigationItem('posts.html', 'Blog'),
+    new NavigationGroup('About', [
+        new NavigationItem('about.html', 'About Us'),
+        new NavigationItem('team.html', 'Our Team'),
+    ]),
+]);
+```
+
+### Adding Items to the Menu
+
+You can also add items to the menu after it has been created by using the `add` method which can take a single item or an array of items, and can be fluently chained.
+
+```php
+$menu = (new NavigationMenu())
+    ->add(new NavigationItem('contact.html', 'Contact Us'))
+    ->add([
+        new NavigationItem('privacy.html', 'Privacy Policy'),
+        new NavigationItem('terms.html', 'Terms of Service'),
+    ]);
+```
+
+### Accessing Items in the Menu
+
+You can access all items in the menu by calling the `getItems` method, which will return a `Collection` of all items in the menu.
+
+```php
+$items = $menu->getItems();
+```
+
+The items will automatically be sorted by their priority, with lower numbers coming first, defaulting to the order they were added if no priority is set.
+
+## NavigationItem
+
+The `NavigationItem` class is an abstraction for a navigation menu item containing useful information like the destination, label, and priority.
+
+### Quick Reference
+
+Here is a quick reference of the methods available on the `NavigationItem` class:
+
+```php
+use Hyde\Framework\Features\Navigation\NavigationItem;
+
+// Create a new NavigationItem instance.
+$item = NavigationItem::create($destination, $label, $priority): NavigationItem;
+$item = new NavigationItem($destination, $label, $priority); // Same as above.
+
+// Get the link of the item.
+$item->getLink(): string;
+
+// Get the label of the item.
+$item->getLabel(): string;
+
+// Get the priority of the item.
+$item->getPriority(): int;
+
+// Check if the item is active. (Only works when the destination is a route)
+$item->isActive(): bool; 
+```
+
+### Blade Example
+
+Here is an example of how you can put it all together in a Blade template:
+
+```blade
+<a href="{{ $item->getLink() }}" @class(['active' => $item->isActive()])>
+    {{ $item->getLabel() }}
+</a>
+```
+
+This will output an anchor tag with the correct link and label, and if the item is active, it will add an `active` class to the tag.
+
+### Creating Navigation Items
+
+There are two syntaxes for creating `NavigationItem` instances, you can use a standard constructor or the static create method.
+Both options provide the exact same signature and functionality, so it's just a matter of preference which one you use.
+
+The constructors take three parameters: the destination, the label, and the optional priority.
+The destination can be a `Route` instance, a route key string, or an external URL.
+
+```php
+use Hyde\Framework\Features\Navigation\NavigationItem;
+
+$item = new NavigationItem($destination, $label, $priority);
+$item = NavigationItem::create($destination, $label, $priority);
+```
+
+#### Using Routes
+
+Using the HydePHP routing system is the recommended way to create navigation items leading to pages within your project,
+as they will automatically have links resolved to the correct URL, and Hyde can check if the items are active.
+Additionally, Hyde will use the page data as the label and priority defaults unless you override them.
+
+You can create routed navigation items by providing either a `Route` instance or a route key string as the destination.
+
+```php
+// Using a route key string.
+new NavigationItem('index');
+
+// Using the Routes facade to get a Route instance.
+new NavigationItem(Routes::get('index'));
+
+// Setting the label and/or priorities will override inferred data.
+new NavigationItem(Routes::get('index'), 'Custom Label', 25);
+```
+
+Using a route key is more concise, but will not provide type safety as it will be treated as a link if the route does not exist,
+whereas providing an invalid route key to the `Routes` facade will throw an exception. It's up to you which one you prefer.
+
+#### Using External URLs
+
+You can also create navigation items that link to external URLs by providing a full URL as the destination.
+
+If you do not set a label for links, the label will default to the URL, and if you do not set a priority, it will default to `500`.
+
+```php
+// This will lead directly to the link, and use it as the label with a priority of 500.
+new NavigationItem('https://example.com');
+
+// You can also set a custom label and priority to override the defaults.
+new NavigationItem('https://example.com', 'External Link', 25);
+```
+
+While it is discouraged to use external URLs for internal pages, as Hyde won't be able to resolve relative links or check active states,
+they are excellent for any time you want an absolute link to an external site or resource.
+
+Note that Hyde will not validate or modify the URL, so you are responsible for ensuring it's correct.
+
+### Accessing the resolved links
+
+The `getLink` method is designed to return a link that can be used in the `href` attribute of an anchor tag.
+
+If the destination is a route, the link will be resolved to the correct URL, using relative paths if possible. It will also respect the pretty URL setting.
+
+```php
+$item = new NavigationItem(Routes::get('index'));
+$item->getLink(); // Outputs 'index.html' 
+
+$item = new NavigationItem('https://example.com');
+$item->getLink(); // Outputs 'https://example.com'
+```
+
+**Tip:** The item instances automatically turns into the resolved link when cast to a string. Perfect for your Blade templates!
+
+```blade
+<a href="{{ $item }}">{{ $item->getLabel() }}</a>
+```
+
+### Accessing the label
+
+The `getLabel` method returns the label of the item. This is the text that will be displayed in the navigation menu.
+
+```php
+$item = new NavigationItem('index', 'Home');
+$item->getLabel(); // Outputs 'Home'
+```
+
+### Accessing the priority
+
+The `getPriority` method returns the priority of the item. This is a number that determines the order in which the items are displayed in the menu, where lower numbers come first.
+
+```php
+$item = new NavigationItem('index', 'Home', 25);
+$item->getPriority(); // Outputs 25
+```
+
+### Checking if the item is active
+
+The `isActive` method checks if the item is active (by comparing it to the Hyde page being compiled at the moment). This is useful for highlighting the current page in the navigation menu.
+
+```php
+$item = new NavigationItem('index');
+$item->isActive(); // Outputs true if the item is the current page, otherwise false.
+```
+
+<!--
+Generated by Copilot, kinda cool, maybe something to implement?
+
+### Advanced Usage
+
+#### Customizing the Active State
+
+By default, the `isActive` method will check if the item's destination matches the current page being compiled.
+
+However, you can also provide a custom callback to the method to determine if the item is active.
+
+```php
+$item = new NavigationItem('index');
+$item->isActive(fn($item) => $item->getLink() === 'index.html');
+```
+
+This is useful if you want to check for a specific query parameter, or if you want to check if the item is active based on a more complex condition.
+-->
+
+
+## NavigationGroup
+
+The `NavigationGroup` class represents a group of items in a navigation menu. It contains a label, priority, and a collection of navigation items.
+This class is often used to create submenus or dropdowns in a navigation menu.
+
+The `NavigationGroup` class extends the `NavigationMenu` class, and thus inherits the same base methods and functionality,
+while also having shared methods with the `NavigationItem` class to render the groups in a Blade view.
+
+### Quick Reference
+
+Here is a quick reference of the methods available on the `NavigationGroup` class:
+
+```php
+use Hyde\Framework\Features\Navigation\NavigationGroup;
+
+// Create a new NavigationGroup instance.
+$group = new NavigationGroup($label, $items = [], $priority = 500);
+
+// Add a single item or an array of items to the group.
+$group->add(new NavigationItem());
+$group->add([new NavigationItem()]);
+
+// Get all items in the group as a Collection sorted by priority.
+$group->getItems(): Collection<NavigationItem|NavigationGroup>
+
+// Get the label of the group.
+$group->getLabel(): string;
+
+// Get the priority of the group.
+$group->getPriority(): int;
+
+// Get the group key, which is a normalized kebab-case version of the label.
+$group->getGroupKey(): string;
+```
+
+As the `NavigationGroup` class extends the `NavigationMenu` class, please see the `NavigationMenu` section for detailed information of the methods available.
+
+### Usage Scenarios
+
+HydePHP uses the `NavigationGroup` class to create dropdowns in the main navigation menu and the category groups in the documentation sidebar.
+
+In your own custom menus, you can use this class for the same types of functionality, and you can even nest groups within groups to create complex navigation structures.
diff --git a/docs/creating-content/documentation-pages.md b/docs/creating-content/documentation-pages.md
index c1f0cdfdbd0..1e9839e8539 100644
--- a/docs/creating-content/documentation-pages.md
+++ b/docs/creating-content/documentation-pages.md
@@ -223,10 +223,12 @@ To quickly arrange the order of items in the sidebar, you can reorder the page i
 Link items without an entry here will fall back to the default priority of 999, putting them last.
 
 ```php
-'sidebar_order' => [
-    'readme',
-    'installation',
-    'getting-started',
+'sidebar' => [
+    'order' => [
+        'readme',
+        'installation',
+        'getting-started',
+    ],
 ]
 ```
 
@@ -256,10 +258,12 @@ In the `config/docs.php` file you can configure the behaviour, content, and the
 You can also disable the feature completely.
 
 ```php
-'table_of_contents' => [
-    'enabled' => true,
-    'min_heading_level' => 2,
-    'max_heading_level' => 4,
+'sidebar' => [
+    'table_of_contents' => [
+        'enabled' => true,
+        'min_heading_level' => 2,
+        'max_heading_level' => 4,
+    ],
 ],
 ```
 
diff --git a/docs/digging-deeper/customization.md b/docs/digging-deeper/customization.md
index 8f8c455bc60..0ec2b9c934d 100644
--- a/docs/digging-deeper/customization.md
+++ b/docs/digging-deeper/customization.md
@@ -259,7 +259,7 @@ Learn more in the [Navigation Menu](navigation) documentation.
 
 #### Customizing the documentation sidebar
 
-- To customize the sidebar, use the setting `sidebar_order` in the `docs.php` config.
+- To customize the sidebar, use the setting `sidebar.order` in the `docs.php` config.
 - When customizing the sidebar, can use the route key, or just the [page identifier](core-concepts#page-identifiers) of the page.
 
 Learn more in the [Documentation Pages](documentation-pages) documentation.
diff --git a/docs/digging-deeper/navigation.md b/docs/digging-deeper/navigation.md
index a9d865d45df..ff515caf30b 100644
--- a/docs/digging-deeper/navigation.md
+++ b/docs/digging-deeper/navigation.md
@@ -122,12 +122,12 @@ Next up, let's look at how to customize the navigation menus using the config fi
 - To customize the navigation menu, use the setting `navigation.order` in the `hyde.php` config.
 - When customizing the navigation menu, you should use the [route key](core-concepts#route-keys) of the page.
 
-- To customize the sidebar, use the setting `sidebar_order` in the `docs.php` config.
+- To customize the sidebar, use the setting `sidebar.order` in the `docs.php` config.
 - When customizing the sidebar, can use the route key, or just the [page identifier](core-concepts#page-identifiers) of the page.
 
 ### Changing the priorities
 
-The `navigation.order` and `sidebar_order` settings allow you to customize the order of the pages in the navigation menus.
+The `navigation.order` and `sidebar.order` settings allow you to customize the order of the pages in the navigation menus.
 
 #### Basic syntax for changing the priorities
 
@@ -149,10 +149,12 @@ The offset is added to make it easier to place pages earlier in the list using f
 ```php
 // filepath: config/docs.php
 
-'sidebar_order' => [
-    'readme', // Gets priority 500
-    'installation', // Gets priority 501
-    'getting-started', // Gets priority 502
+'sidebar' => [
+    'order' => [
+        'readme', // Gets priority 500
+        'installation', // Gets priority 501
+        'getting-started', // Gets priority 502
+    ]
 ]
 ```
 
@@ -175,10 +177,12 @@ You can also specify explicit priorities by adding a value to the array key:
 ```php
 // filepath: config/docs.php
 
-'sidebar_order' => [
-    'readme' => 10, // Gets priority 10
-    'installation' => 15, // Gets priority 15
-    'getting-started' => 20, // Gets priority 20
+'sidebar' => [
+    'order' => [
+        'readme' => 10, // Gets priority 10
+        'installation' => 15, // Gets priority 15
+        'getting-started' => 20, // Gets priority 20
+    ]
 ]
 ```
 
@@ -226,18 +230,18 @@ To remove items from being automatically added, simply add the page's route key
 
 ### Adding Custom Navigation Menu Links
 
-You can easily add custom navigation menu links similar to how we add Authors. Simply add a `NavItem` model to the `navigation.custom` array.
+You can easily add custom navigation menu links similar to how we add Authors. Simply add a `NavigationItem` model to the `navigation.custom` array.
 
-When linking to an external site, you should use the `NavItem::forLink()` method facade. The first two arguments are the
+When linking to an external site, you should use the `NavigationItem::create()` method facade. The first two arguments are the
 destination and label, both required. The third argument is the priority, which is optional, and defaults to `500`.
 
 ```php
 // filepath config/hyde.php
-use Hyde\Framework\Features\Navigation\NavItem;
+use Hyde\Framework\Features\Navigation\NavigationItem;
 
 'navigation' => [
     'custom' => [
-        NavItem::forLink('https://github.com/hydephp/hyde', 'GitHub', 200),
+        NavigationItem::create('https://github.com/hydephp/hyde', 'GitHub', 200),
     ]
 ]
 ```
@@ -290,30 +294,41 @@ For example: `_docs/getting-started/installation.md` will be placed in a group c
 
 >info Tip: When using subdirectory-based dropdowns, you can set their priority using the directory name as the array key.
 
+#### Dropdown menu notes
+
+Here are some things to keep in mind when using dropdown menus, regardless of the configuration:
+- Dropdowns take priority over standard items. So if you have a dropdown with the key `about` and a page with the key `about`, the dropdown will be created, and the page won't be in the menu.
+  - For example: With this file structure: `_pages/foo.md`, `_pages/foo/bar.md`, `_pages/foo/baz.md`, the link to `foo` will be lost.
 
 ## Digging Deeper into the internals
 
-While not required to know, you may find it interesting to learn more about how the navigation is handled internally.
-The best way to learn about this is to look at the source code, so here is a high-level overview with details on where to look in the source code.
+While not required to know, you may find it interesting to learn more about how the navigation is handled internally. Here is a high level overview,
+but you can find more detailed information in the [Navigation API](navigation-api) documentation.
 
-The main navigation menu is the `NavigationMenu` class, and the documentation sidebar is the `DocumentationSidebar` class.
-Both extend the same `BaseNavigationMenu` class:
+The main navigation menu is the `MainNavigationMenu` class, and the documentation sidebar is the `DocumentationSidebar` class. Both extend the same base `NavigationMenu` class.
 
 ```php
-use Hyde\Framework\Features\Navigation\NavigationMenu;
+use Hyde\Framework\Features\Navigation\MainNavigationMenu;
 use Hyde\Framework\Features\Navigation\DocumentationSidebar;
-use Hyde\Framework\Features\Navigation\BaseNavigationMenu;
+use Hyde\Framework\Features\Navigation\NavigationMenu;
 ```
 
-Within the `BaseNavigationMenu` class, you will find the main logic for how the menus are generated,
+Within the base `NavigationMenu` class, you will find the main logic for how the menus are generated,
 while the child implementations contain the extra logic tailored for their specific use cases.
 
-All the navigation menus store the menu items in their `$items` array containing instances of the `NavItem` class.
+All the navigation menus store the menu items in their `$items` collection containing instances of the `NavigationItem` class.
 
-The `NavItem` class is a simple class that contains the label and URL of the menu item and is used to represent each item in the menu.
-Dropdowns are represented by `DropdownNavItem` instances, which extend the `NavItem` class and contain an array of additional `NavItem` instances.
+The `NavigationItem` class is a simple class that contains the label and URL of the menu item and is used to represent each item in the menu.
+Dropdowns are represented by `NavigationGroup` instances, which extend the `NavigationMenu` class and contain a collection of additional `NavigationItem` instances.
 
 ```php
-use Hyde\Framework\Features\Navigation\NavItem;
-use Hyde\Framework\Features\Navigation\DropdownNavItem;
+use Hyde\Framework\Features\Navigation\NavigationItem;
+use Hyde\Framework\Features\Navigation\NavigationGroup;
 ```
+
+## The Navigation API
+
+If you want to interact with the site navigation programmatically, or if you want to create complex custom menus, you can do so through the new Navigation API.
+For most cases you don't need this, as Hyde creates the navigation for you. But it can be useful for advanced users and package developers.
+
+The Navigation API consists of a set of PHP classes, allowing you to fluently interact with the navigation menus. You can learn more about the API in the [Navigation API](navigation-api) documentation.
diff --git a/packages/framework/config/docs.php b/packages/framework/config/docs.php
index fab400e973d..93bbc751dc2 100644
--- a/packages/framework/config/docs.php
+++ b/packages/framework/config/docs.php
@@ -33,46 +33,47 @@
         // Should the sidebar footer be shown? You can also set this to a string
         // of Markdown to show in the footer. Set to `false` to disable.
         'footer' => true,
-    ],
-
-    /*
-    |--------------------------------------------------------------------------
-    | Sidebar Page Order
-    |--------------------------------------------------------------------------
-    |
-    | In the generated Documentation pages the navigation links in the sidebar
-    | default to sort alphabetically. You can reorder the page identifiers
-    | in the list below, and the links will get sorted in that order.
-    |
-    | The items will get a priority of 500 plus the order its found in the list.
-    | Pages without a priority will fall back to the default priority of 999.
-    |
-    | You can also set explicit priorities in front matter or by specifying
-    | a value to the array key in the list to override the inferred value.
-    |
-    */
-
-    'sidebar_order' => [
-        'readme',
-        'installation',
-        'getting-started',
-    ],
 
-    /*
-    |--------------------------------------------------------------------------
-    | Table of Contents Settings
-    |--------------------------------------------------------------------------
-    |
-    | The Hyde Documentation Module comes with a fancy Sidebar that, by default,
-    | has a Table of Contents included. Here, you can configure its behavior,
-    | content, look and feel. You can also disable the feature completely.
-    |
-    */
+        /*
+        |--------------------------------------------------------------------------
+        | Sidebar Page Order
+        |--------------------------------------------------------------------------
+        |
+        | In the generated Documentation pages the navigation links in the sidebar
+        | default to sort alphabetically. You can reorder the page identifiers
+        | in the list below, and the links will get sorted in that order.
+        |
+        | The items will get a priority of 500 plus the order its found in the list.
+        | Pages without a priority will fall back to the default priority of 999.
+        |
+        | You can also set explicit priorities in front matter or by specifying
+        | a value to the array key in the list to override the inferred value.
+        |
+        */
+
+        'order' => [
+            'readme',
+            'installation',
+            'getting-started',
+        ],
+
+        /*
+        |--------------------------------------------------------------------------
+        | Table of Contents Settings
+        |--------------------------------------------------------------------------
+        |
+        | The Hyde Documentation Module comes with a fancy Sidebar that, by default,
+        | has a Table of Contents included. Here, you can configure its behavior,
+        | content, look and feel. You can also disable the feature completely.
+        |
+        */
+
+        'table_of_contents' => [
+            'enabled' => true,
+            'min_heading_level' => 2,
+            'max_heading_level' => 4,
+        ],
 
-    'table_of_contents' => [
-        'enabled' => true,
-        'min_heading_level' => 2,
-        'max_heading_level' => 4,
     ],
 
     /*
diff --git a/packages/framework/config/hyde.php b/packages/framework/config/hyde.php
index 9cbbe1cceb3..c91370adce7 100644
--- a/packages/framework/config/hyde.php
+++ b/packages/framework/config/hyde.php
@@ -350,7 +350,7 @@
         // To get started quickly, you can uncomment the defaults here.
         // See the documentation link above for more information.
         'custom' => [
-            // NavItem::forLink('https://github.com/hydephp/hyde', 'GitHub', 200),
+            // NavigationItem::create('https://github.com/hydephp/hyde', 'GitHub', 200),
         ],
 
         // How should pages in subdirectories be displayed in the menu?
diff --git a/packages/framework/resources/views/components/docs/search-widget.blade.php b/packages/framework/resources/views/components/docs/search-widget.blade.php
index b44d81327c0..43f3ee46928 100644
--- a/packages/framework/resources/views/components/docs/search-widget.blade.php
+++ b/packages/framework/resources/views/components/docs/search-widget.blade.php
@@ -1,4 +1,4 @@
-<button id="searchMenuButton" x-on:click="searchWindowOpen = ! searchWindowOpen"
+<button id="search-menu-button" x-on:click="searchWindowOpen = ! searchWindowOpen"
         :title="searchWindowOpen ? 'Close search window' : 'Open search window'; $nextTick(() => { setTimeout(() => { document.getElementById('search-input').focus(); }); });"
         class="absolute right-4 top-4 mr-4 z-10 opacity-75 hover:opacity-100 hidden md:block"
         aria-label="Toggle search window">
@@ -14,7 +14,7 @@ class="absolute right-4 top-4 mr-4 z-10 opacity-75 hover:opacity-100 hidden md:b
         </svg>
     </span>
 </button>
-<button id="searchMenuButtonMobile" x-on:click="searchWindowOpen = ! searchWindowOpen"
+<button id="search-menu-button-mobile" x-on:click="searchWindowOpen = ! searchWindowOpen"
         :title="searchWindowOpen ? 'Close search window' : 'Open search window'; $nextTick(() => { setTimeout(() => { document.getElementById('search-input').focus(); }); });"
         class="block md:hidden fixed bottom-4 right-4 z-10 rounded-full p-2 opacity-75 hover:opacity-100 fill-black bg-gray-200 dark:fill-gray-200 dark:bg-gray-700"
         aria-label="Toggle search menu">
@@ -26,7 +26,7 @@ class="block md:hidden fixed bottom-4 right-4 z-10 rounded-full p-2 opacity-75 h
 
 <div id="search-window-container" x-show="searchWindowOpen" x-cloak role="dialog"
      class="z-30 fixed top-0 left-0 w-screen h-screen flex flex-col items-center px-8 py-24 md:py-16">
-    <aside x-on:click.away="searchWindowOpen = false" id="searchMenu"
+    <aside x-on:click.away="searchWindowOpen = false" id="search-menu"
            class="prose dark:prose-invert bg-white dark:bg-gray-800  z-50 p-4 rounded-lg overflow-y-hidden min-h-[300px] max-h-[75vh] w-[70ch] max-w-full cursor-auto ">
         <header class="flex justify-between pb-3 mb-3 border-b dark:border-gray-700 md:hidden">
             <strong>Search the documentation site</strong>
diff --git a/packages/framework/resources/views/components/docs/sidebar-brand.blade.php b/packages/framework/resources/views/components/docs/sidebar-brand.blade.php
index ad693a85c96..e56ce6b88b7 100644
--- a/packages/framework/resources/views/components/docs/sidebar-brand.blade.php
+++ b/packages/framework/resources/views/components/docs/sidebar-brand.blade.php
@@ -2,10 +2,10 @@
     <strong class="px-2">
         @if(DocumentationPage::home())
             <a href="{{ DocumentationPage::home() }}">
-                {{ config('docs.sidebar.header', 'Documentation') }}
+                {{ $sidebar->getHeader() }}
             </a>
         @else
-            {{ config('docs.sidebar.header', 'Documentation') }}
+            {{ $sidebar->getHeader() }}
         @endif
     </strong>
     <x-hyde::navigation.theme-toggle-button class="opacity-75 hover:opacity-100"/>
diff --git a/packages/framework/resources/views/components/docs/sidebar-footer-text.blade.php b/packages/framework/resources/views/components/docs/sidebar-footer-text.blade.php
index 6b49ca39bb1..ddc7e711303 100644
--- a/packages/framework/resources/views/components/docs/sidebar-footer-text.blade.php
+++ b/packages/framework/resources/views/components/docs/sidebar-footer-text.blade.php
@@ -1,7 +1 @@
-<p>
-    @if(is_bool(config('docs.sidebar.footer', true)))
-        <a href="{{ Hyde::relativeLink('index.html') }}">Back to home page</a>
-    @else
-        {{ Hyde::markdown(config('docs.sidebar.footer')) }}
-    @endif
-</p>
\ No newline at end of file
+{{ Hyde::markdown($sidebar->getFooter()) }}
diff --git a/packages/framework/resources/views/components/docs/sidebar-item.blade.php b/packages/framework/resources/views/components/docs/sidebar-item.blade.php
index a6da983c180..fe320513408 100644
--- a/packages/framework/resources/views/components/docs/sidebar-item.blade.php
+++ b/packages/framework/resources/views/components/docs/sidebar-item.blade.php
@@ -1,27 +1,27 @@
-@php /** @var \Hyde\Framework\Features\Navigation\NavItem $item */ @endphp
 @props(['grouped' => false])
+@php /** @var \Hyde\Framework\Features\Navigation\NavigationItem $item */ @endphp
 <li @class(['sidebar-item -ml-4 pl-4', $grouped
         ? 'active -ml-8 pl-8 bg-black/5 dark:bg-black/10'
-        : 'active bg-black/5 dark:bg-black/10' => $item->isCurrent()
+        : 'active bg-black/5 dark:bg-black/10' => $item->isActive()
     ]) role="listitem">
-    @if($item->isCurrent())
-        <a href="{{ $item->destination }}" aria-current="true" @class([$grouped
+    @if($item->isActive())
+        <a href="{{ $item->getLink() }}" aria-current="true" @class([$grouped
             ? '-ml-8 pl-4 py-1 px-2 block text-indigo-600 dark:text-indigo-400 dark:font-medium border-l-[0.325rem] border-indigo-500 transition-colors duration-300 ease-in-out hover:bg-black/10'
             : '-ml-4 p-2 block hover:bg-black/5 dark:hover:bg-black/10 text-indigo-600 dark:text-indigo-400 dark:font-medium border-l-[0.325rem] border-indigo-500 transition-colors duration-300 ease-in-out'
         ])>
-            {{ $item->label }}
+            {{ $item->getLabel() }}
         </a>
 
-        @if(config('docs.table_of_contents.enabled', true))
+        @if(config('docs.sidebar.table_of_contents.enabled', true))
             <span class="sr-only">Table of contents</span>
-            {!! ($page->getTableOfContents()) !!}
+            {!! $page->getTableOfContents() !!}
         @endif
     @else
-        <a href="{{ $item->destination }}" @class([$grouped
+        <a href="{{ $item->getLink() }}" @class([$grouped
             ? '-ml-8 pl-4 py-1 px-2 block border-l-[0.325rem] border-transparent transition-colors duration-300 ease-in-out hover:bg-black/10'
             : 'block -ml-4 p-2 border-l-[0.325rem] border-transparent hover:bg-black/5 dark:hover:bg-black/10'
         ])>
-            {{ $item->label }}
+            {{ $item->getLabel() }}
         </a>
     @endif
 </li>
\ No newline at end of file
diff --git a/packages/framework/resources/views/components/docs/sidebar-items.blade.php b/packages/framework/resources/views/components/docs/sidebar-items.blade.php
index 4c26062cf9f..6efff702add 100644
--- a/packages/framework/resources/views/components/docs/sidebar-items.blade.php
+++ b/packages/framework/resources/views/components/docs/sidebar-items.blade.php
@@ -1,23 +1,22 @@
-@php /** @var \Hyde\Framework\Features\Navigation\DocumentationSidebar $sidebar */ @endphp
 @if(! $sidebar->hasGroups())
     <ul id="sidebar-items" role="list" class="pl-2">
-        @foreach ($sidebar->items as $item)
+        @foreach ($sidebar->getItems() as $item)
             @include('hyde::components.docs.sidebar-item')
         @endforeach
     </ul>
 @else
     <ul id="sidebar-items" role="list">
-        @php ($collapsible = config('docs.sidebar.collapsible', true))
-        @foreach ($sidebar->getGroups() as $group)
-            <li class="sidebar-group" role="listitem" @if($collapsible) x-data="{ groupOpen: {{ $sidebar->isGroupActive($group) ? 'true' : 'false' }} }" @endif>
-                <header class="sidebar-group-header p-2 px-4 -ml-2 flex justify-between items-center @if($collapsible) group hover:bg-black/10 @endif" @if($collapsible) @click="groupOpen = ! groupOpen" @endif>
-                    <h4 class="sidebar-group-heading text-base font-semibold @if($collapsible) cursor-pointer dark:group-hover:text-white @endif">{{ $sidebar->makeGroupTitle($group) }}</h4>
-                    @if($collapsible)
+        @php /** @var \Hyde\Framework\Features\Navigation\NavigationGroup $group */ @endphp
+        @foreach ($sidebar->getItems() as $group)
+            <li class="sidebar-group" role="listitem" @if($sidebar->isCollapsible()) x-data="{ groupOpen: {{ ($sidebar->getActiveGroup() === $group) ? 'true' : 'false' }} }" @endif>
+                <header @class(['sidebar-group-header p-2 px-4 -ml-2 flex justify-between items-center', 'group hover:bg-black/10' => $sidebar->isCollapsible()]) @if($sidebar->isCollapsible()) @click="groupOpen = ! groupOpen" @endif>
+                    <h4 @class(['sidebar-group-heading text-base font-semibold', 'cursor-pointer dark:group-hover:text-white' => $sidebar->isCollapsible()])>{{ $group->getLabel() }}</h4>
+                    @if($sidebar->isCollapsible())
                         @include('hyde::components.docs.sidebar-group-toggle-button')
                     @endif
                 </header>
-                <ul class="sidebar-group-items ml-4 px-2 mb-2" role="list" @if($collapsible) x-show="groupOpen" @endif>
-                    @foreach ($sidebar->getItemsInGroup($group) as $item)
+                <ul class="sidebar-group-items ml-4 px-2 mb-2" role="list" @if($sidebar->isCollapsible()) x-show="groupOpen" @endif>
+                    @foreach ($group->getItems() as $item)
                         @include('hyde::components.docs.sidebar-item', ['grouped' => true])
                     @endforeach
                 </ul>
diff --git a/packages/framework/resources/views/components/docs/sidebar.blade.php b/packages/framework/resources/views/components/docs/sidebar.blade.php
index 04b9857a1d5..e6698715522 100644
--- a/packages/framework/resources/views/components/docs/sidebar.blade.php
+++ b/packages/framework/resources/views/components/docs/sidebar.blade.php
@@ -1,13 +1,15 @@
+@php
+    $sidebar = app('navigation.sidebar');
+@endphp
+
 <aside id="sidebar" x-cloak :class="sidebarOpen ? 'visible left-0' : 'invisible -left-64 md:visible md:left-0'" class="bg-gray-100 dark:bg-gray-800 dark:text-gray-200 h-screen w-64 fixed z-30 md:flex flex-col shadow-lg md:shadow-none transition-all duration-300">
     <header id="sidebar-header" class="h-16">
         @include('hyde::components.docs.sidebar-brand')
     </header>
     <nav id="sidebar-navigation" class="p-2 overflow-y-auto border-y border-gray-300 dark:border-[#1b2533] h-full">
-        @include('hyde::components.docs.sidebar-items', [
-            'sidebar' => \Hyde\Framework\Features\Navigation\DocumentationSidebar::create(),
-        ])
+        @include('hyde::components.docs.sidebar-items')
     </nav>
-    @if(config('docs.sidebar.footer', true) !== false)
+    @if($sidebar->hasFooter())
         <footer id="sidebar-footer" class="h-16 p-4 w-full bottom-0 left-0 text-center leading-8">
             @include('hyde::components.docs.sidebar-footer-text')
         </footer>
diff --git a/packages/framework/resources/views/components/navigation/dropdown.blade.php b/packages/framework/resources/views/components/navigation/dropdown.blade.php
index 52d03fcc9c0..b0c8de89a0d 100644
--- a/packages/framework/resources/views/components/navigation/dropdown.blade.php
+++ b/packages/framework/resources/views/components/navigation/dropdown.blade.php
@@ -9,7 +9,7 @@
             @isset($items)
                 @foreach ($items as $item)
                     <li class="whitespace-nowrap">
-                        @include('hyde::components.navigation.navigation-link')
+                        <x-hyde::navigation.navigation-link :item="$item"/>
                     </li>
                 @endforeach
             @else
diff --git a/packages/framework/resources/views/components/navigation/navigation-link.blade.php b/packages/framework/resources/views/components/navigation/navigation-link.blade.php
index cfad8bdb1e2..60ce617081d 100644
--- a/packages/framework/resources/views/components/navigation/navigation-link.blade.php
+++ b/packages/framework/resources/views/components/navigation/navigation-link.blade.php
@@ -1,4 +1,6 @@
-<a href="{{ $item }}" {!! $item->isCurrent() ? 'aria-current="page"' : '' !!} @class([
-    'block my-2 md:my-0 md:inline-block py-1 text-gray-700 hover:text-gray-900 dark:text-gray-100',
-    'border-l-4 border-indigo-500 md:border-none font-medium -ml-6 pl-5 md:ml-0 md:pl-0 bg-gray-100 dark:bg-gray-800 md:bg-transparent dark:md:bg-transparent' => $item->isCurrent()
-])>{{ $item->label }}</a>
\ No newline at end of file
+<a href="{{ $item }}" {{ $attributes->except('item')->class([
+    'navigation-link block my-2 md:my-0 md:inline-block py-1 text-gray-700 hover:text-gray-900 dark:text-gray-100',
+    'navigation-link-active border-l-4 border-indigo-500 md:border-none font-medium -ml-6 pl-5 md:ml-0 md:pl-0 bg-gray-100 dark:bg-gray-800 md:bg-transparent dark:md:bg-transparent' => $item->isActive()
+])->merge([
+    'aria-current' => $item->isActive() ? 'page' : false,
+]) }}>{{ $item->getLabel() }}</a>
\ No newline at end of file
diff --git a/packages/framework/resources/views/layouts/navigation.blade.php b/packages/framework/resources/views/layouts/navigation.blade.php
index 17707d5e10a..452e53d62fb 100644
--- a/packages/framework/resources/views/layouts/navigation.blade.php
+++ b/packages/framework/resources/views/layouts/navigation.blade.php
@@ -1,9 +1,9 @@
 @php
-    $navigation = \Hyde\Framework\Features\Navigation\NavigationMenu::create();
+    $navigation = app('navigation.main');
 @endphp
 
 <nav aria-label="Main navigation" id="main-navigation" class="flex flex-wrap items-center justify-between p-4 shadow-lg sm:shadow-xl md:shadow-none dark:bg-gray-800">
-    <div class="flex flex-grow items-center flex-shrink-0 text-gray-700 dark:text-gray-200">
+    <div id="main-navigation-brand" class="flex flex-grow items-center flex-shrink-0 text-gray-700 dark:text-gray-200">
         @include('hyde::components.navigation.navigation-brand')
 
         <div class="ml-auto">
@@ -17,13 +17,15 @@
             <svg x-show="! navigationOpen" title="Open Navigation Menu" class="dark:fill-gray-200"
                  style="display: block;"
                  id="open-main-navigation-menu-icon" xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24"
-                 width="24"><title>Open Menu</title>
+                 width="24">
+                <title>Open Menu</title>
                 <path d="M0 0h24v24H0z" fill="none"/>
                 <path d="M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z"/>
             </svg>
             <svg x-show="navigationOpen" title="Close Navigation Menu" class="dark:fill-gray-200" style="display: none;"
                  id="close-main-navigation-menu-icon" xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24"
-                 width="24"><title>Close Menu</title>
+                 width="24">
+                <title>Close Menu</title>
                 <path d="M0 0h24v24H0z" fill="none"></path>
                 <path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"></path>
             </svg>
@@ -33,12 +35,12 @@
     <div id="main-navigation-links" class="w-full x-uncloak-md md:flex flex-grow md:flex-grow-0 md:items-center md:w-auto px-6 -mx-4 border-t mt-3 pt-3 md:border-none md:mt-0 md:py-0 border-gray-200 dark:border-gray-700"
          :class="navigationOpen ? '' : 'hidden'" x-cloak>
         <ul aria-label="Navigation links" class="md:flex-grow md:flex justify-end">
-            @foreach ($navigation->items as $item)
+            @foreach ($navigation->getItems() as $item)
                 <li class="md:mx-2">
-                    @if($item instanceof \Hyde\Framework\Features\Navigation\DropdownNavItem)
-                        <x-hyde::navigation.dropdown :label="\Hyde\Hyde::makeTitle($item->label)" :items="$item->items"/>
+                    @if($item instanceof \Hyde\Framework\Features\Navigation\NavigationGroup)
+                        <x-hyde::navigation.dropdown :label="$item->getLabel()" :items="$item->getItems()"/>
                     @else
-                        @include('hyde::components.navigation.navigation-link')
+                        <x-hyde::navigation.navigation-link :item="$item"/>
                     @endif
                 </li>
             @endforeach
diff --git a/packages/framework/resources/views/pages/documentation-search.blade.php b/packages/framework/resources/views/pages/documentation-search.blade.php
index d30b4b7da16..c50683276d6 100644
--- a/packages/framework/resources/views/pages/documentation-search.blade.php
+++ b/packages/framework/resources/views/pages/documentation-search.blade.php
@@ -1,7 +1,7 @@
 @extends('hyde::layouts.docs')
 @section('content')
     <h1>Search the documentation site</h1>
-    <style>#searchMenuButton, .edit-page-link {
+    <style>#search-menu-button, .edit-page-link {
             display: none !important;
         }
 
diff --git a/packages/framework/src/Foundation/Providers/NavigationServiceProvider.php b/packages/framework/src/Foundation/Providers/NavigationServiceProvider.php
new file mode 100644
index 00000000000..02af9f13ec1
--- /dev/null
+++ b/packages/framework/src/Foundation/Providers/NavigationServiceProvider.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Foundation\Providers;
+
+use Hyde\Foundation\HydeKernel;
+use Illuminate\Support\ServiceProvider;
+use Hyde\Framework\Features\Navigation\MainNavigationMenu;
+use Hyde\Framework\Features\Navigation\DocumentationSidebar;
+use Hyde\Framework\Features\Navigation\NavigationMenuGenerator;
+
+class NavigationServiceProvider extends ServiceProvider
+{
+    public function register(): void
+    {
+        $this->app->make(HydeKernel::class)->booted(function (): void {
+            $this->app->singleton('navigation.main', function (): MainNavigationMenu {
+                return NavigationMenuGenerator::handle(MainNavigationMenu::class);
+            });
+
+            $this->app->singleton('navigation.sidebar', function (): DocumentationSidebar {
+                return NavigationMenuGenerator::handle(DocumentationSidebar::class);
+            });
+        });
+    }
+}
diff --git a/packages/framework/src/Framework/Actions/GeneratesTableOfContents.php b/packages/framework/src/Framework/Actions/GeneratesTableOfContents.php
index 0a68d1b032b..2889b0fe419 100644
--- a/packages/framework/src/Framework/Actions/GeneratesTableOfContents.php
+++ b/packages/framework/src/Framework/Actions/GeneratesTableOfContents.php
@@ -35,8 +35,8 @@ public function execute(): string
                 'position' => 'placeholder',
                 'placeholder' => '[[START_TOC]]',
                 'style' => 'bullet',
-                'min_heading_level' => Config::getInt('docs.table_of_contents.min_heading_level', 2),
-                'max_heading_level' => Config::getInt('docs.table_of_contents.max_heading_level', 4),
+                'min_heading_level' => Config::getInt('docs.sidebar.table_of_contents.min_heading_level', 2),
+                'max_heading_level' => Config::getInt('docs.sidebar.table_of_contents.max_heading_level', 4),
                 'normalize' => 'relative',
             ],
             'heading_permalink' => [
diff --git a/packages/framework/src/Framework/Factories/NavigationDataFactory.php b/packages/framework/src/Framework/Factories/NavigationDataFactory.php
index d9406d6f2ca..adf2eacbb78 100644
--- a/packages/framework/src/Framework/Factories/NavigationDataFactory.php
+++ b/packages/framework/src/Framework/Factories/NavigationDataFactory.php
@@ -10,6 +10,7 @@
 use Hyde\Pages\DocumentationPage;
 use Hyde\Markdown\Models\FrontMatter;
 use Hyde\Framework\Factories\Concerns\CoreDataObject;
+use Hyde\Framework\Features\Navigation\NavigationMenu;
 use Hyde\Markdown\Contracts\FrontMatter\SubSchemas\NavigationSchema;
 
 use function basename;
@@ -30,9 +31,6 @@ class NavigationDataFactory extends Concerns\PageDataFactory implements Navigati
      */
     final public const SCHEMA = NavigationSchema::NAVIGATION_SCHEMA;
 
-    protected const FALLBACK_PRIORITY = 999;
-    protected const CONFIG_OFFSET = 500;
-
     protected readonly ?string $label;
     protected readonly ?string $group;
     protected readonly ?bool $hidden;
@@ -73,7 +71,7 @@ public function toArray(): array
     protected function makeLabel(): ?string
     {
         return $this->searchForLabelInFrontMatter()
-            ?? $this->searchForLabelInConfig()
+            ?? $this->searchForLabelInConfigs()
             ?? $this->getMatter('title')
             ?? $this->title;
     }
@@ -84,14 +82,14 @@ protected function makeGroup(): ?string
             return $this->getSubdirectoryName();
         }
 
-        return $this->searchForGroupInFrontMatter() ?? $this->defaultGroup();
+        return $this->searchForGroupInFrontMatter();
     }
 
     protected function makeHidden(): bool
     {
         return $this->isInstanceOf(MarkdownPost::class)
             || $this->searchForHiddenInFrontMatter()
-            || $this->isPageHiddenInNavigationConfiguration()
+            || $this->searchForHiddenInConfigs()
             || $this->isNonDocumentationPageInHiddenSubdirectory();
     }
 
@@ -99,7 +97,7 @@ protected function makePriority(): int
     {
         return $this->searchForPriorityInFrontMatter()
             ?? $this->searchForPriorityInConfigs()
-            ?? self::FALLBACK_PRIORITY;
+            ?? NavigationMenu::LAST;
     }
 
     private function searchForLabelInFrontMatter(): ?string
@@ -120,11 +118,29 @@ private function searchForHiddenInFrontMatter(): ?bool
             ?? $this->invert($this->getMatter('navigation.visible'));
     }
 
+    private function searchForHiddenInConfigs(): ?bool
+    {
+        return $this->isInstanceOf(DocumentationPage::class)
+            ? $this->isPageHiddenInSidebarConfiguration()
+            : $this->isPageHiddenInNavigationConfiguration();
+    }
+
     private function isPageHiddenInNavigationConfiguration(): ?bool
     {
         return in_array($this->routeKey, Config::getArray('hyde.navigation.exclude', ['404']));
     }
 
+    private function isPageHiddenInSidebarConfiguration(): ?bool
+    {
+        $config = Config::getArray('docs.sidebar.exclude', ['404']);
+
+        return
+            // Check if the page is hidden from the sidebar by route key or identifier.
+            (in_array($this->routeKey, $config) || in_array($this->identifier, $config))
+            // Check if the page is hidden from the main navigation by its route key.
+            || $this->isPageHiddenInNavigationConfiguration();
+    }
+
     private function isNonDocumentationPageInHiddenSubdirectory(): bool
     {
         return ! $this->isInstanceOf(DocumentationPage::class)
@@ -139,7 +155,14 @@ private function searchForPriorityInFrontMatter(): ?int
             ?? $this->getMatter('navigation.order');
     }
 
-    private function searchForLabelInConfig(): ?string
+    private function searchForLabelInConfigs(): ?string
+    {
+        return $this->isInstanceOf(DocumentationPage::class)
+            ? $this->searchForLabelInSidebarConfig()
+            : $this->searchForLabelInNavigationConfig();
+    }
+
+    private function searchForLabelInNavigationConfig(): ?string
     {
         /** @var array<string, string> $config */
         $config = Config::getArray('hyde.navigation.labels', [
@@ -150,6 +173,16 @@ private function searchForLabelInConfig(): ?string
         return $config[$this->routeKey] ?? null;
     }
 
+    private function searchForLabelInSidebarConfig(): ?string
+    {
+        /** @var array<string>|array<string, string> $config */
+        $config = Config::getArray('docs.sidebar.labels', [
+            DocumentationPage::homeRouteName() => 'Docs',
+        ]);
+
+        return $config[$this->routeKey] ?? $config[$this->identifier] ?? null;
+    }
+
     private function searchForPriorityInConfigs(): ?int
     {
         return $this->isInstanceOf(DocumentationPage::class)
@@ -160,7 +193,7 @@ private function searchForPriorityInConfigs(): ?int
     private function searchForPriorityInSidebarConfig(): ?int
     {
         /** @var array<string>|array<string, int> $config */
-        $config = Config::getArray('docs.sidebar_order', []);
+        $config = Config::getArray('docs.sidebar.order', []);
 
         return
             // For consistency with the navigation config.
@@ -195,7 +228,7 @@ private function parseNavigationPriorityConfig(array $config, string $pageKeyNam
 
             return $this->offset(
                 array_flip($config)[$pageKey] ?? null,
-                self::CONFIG_OFFSET
+                NavigationMenu::DEFAULT
             );
         }
 
@@ -208,11 +241,6 @@ private function canUseSubdirectoryForGroups(): bool
             || $this->isInstanceOf(DocumentationPage::class);
     }
 
-    private function defaultGroup(): ?string
-    {
-        return $this->isInstanceOf(DocumentationPage::class) ? 'other' : null;
-    }
-
     private function pageIsInSubdirectory(): bool
     {
         return Str::contains($this->identifier, '/');
diff --git a/packages/framework/src/Framework/Features/Navigation/BaseNavigationMenu.php b/packages/framework/src/Framework/Features/Navigation/BaseNavigationMenu.php
deleted file mode 100644
index d802662c974..00000000000
--- a/packages/framework/src/Framework/Features/Navigation/BaseNavigationMenu.php
+++ /dev/null
@@ -1,72 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Hyde\Framework\Features\Navigation;
-
-use Hyde\Facades\Config;
-use Hyde\Support\Models\Route;
-use Hyde\Foundation\Facades\Routes;
-use Illuminate\Support\Collection;
-
-use function collect;
-
-abstract class BaseNavigationMenu
-{
-    /** @var \Illuminate\Support\Collection<string, \Hyde\Framework\Features\Navigation\NavItem> */
-    public Collection $items;
-
-    final protected function __construct()
-    {
-        $this->items = new Collection();
-    }
-
-    public static function create(): static
-    {
-        $menu = new static();
-
-        $menu->generate();
-        $menu->sortByPriority();
-        $menu->removeDuplicateItems();
-
-        return $menu;
-    }
-
-    protected function generate(): void
-    {
-        Routes::each(function (Route $route): void {
-            if ($this->canAddRoute($route)) {
-                $this->items->put($route->getRouteKey(), NavItem::fromRoute($route));
-            }
-        });
-
-        collect(Config::getArray('hyde.navigation.custom', []))->each(function (NavItem $item): void {
-            // Since these were added explicitly by the user, we can assume they should always be shown
-            $this->items->push($item);
-        });
-    }
-
-    protected function canAddRoute(Route $route): bool
-    {
-        return $route->getPage()->showInNavigation();
-    }
-
-    protected function removeDuplicateItems(): void
-    {
-        $this->items = $this->items->unique(function (NavItem $item): string {
-            // Filter using a combination of the group and label to allow duplicate labels in different groups
-            return $item->getGroup().$item->label;
-        });
-    }
-
-    protected function sortByPriority(): void
-    {
-        $this->items = $this->items->sortBy('priority')->values();
-    }
-
-    /** @return \Illuminate\Support\Collection<\Hyde\Framework\Features\Navigation\NavItem> */
-    public function getItems(): Collection
-    {
-        return $this->items;
-    }
-}
diff --git a/packages/framework/src/Framework/Features/Navigation/DocumentationSidebar.php b/packages/framework/src/Framework/Features/Navigation/DocumentationSidebar.php
index 919b93434a6..6e8332b8ad2 100644
--- a/packages/framework/src/Framework/Features/Navigation/DocumentationSidebar.php
+++ b/packages/framework/src/Framework/Features/Navigation/DocumentationSidebar.php
@@ -4,77 +4,81 @@
 
 namespace Hyde\Framework\Features\Navigation;
 
-use Hyde\Hyde;
 use Hyde\Facades\Config;
-use Hyde\Foundation\Facades\Routes;
 use Hyde\Pages\DocumentationPage;
 use Hyde\Support\Facades\Render;
-use Hyde\Support\Models\Route;
-use Illuminate\Support\Collection;
-use Illuminate\Support\Str;
+use Illuminate\Contracts\Support\Arrayable;
 
-use function collect;
+use function app;
+use function is_string;
 
-class DocumentationSidebar extends BaseNavigationMenu
+class DocumentationSidebar extends NavigationMenu
 {
-    protected function generate(): void
+    /**
+     * Get the navigation menu instance from the service container.
+     */
+    public static function get(): static
     {
-        Routes::getRoutes(DocumentationPage::class)->each(function (Route $route): void {
-            if ($this->canAddRoute($route)) {
-                $this->items->put($route->getRouteKey(), NavItem::fromRoute($route));
-            }
-        });
-
-        // If there are no pages other than the index page, we add it to the sidebar so that it's not empty
-        if ($this->items->count() === 0 && DocumentationPage::home() !== null) {
-            $this->items->push(NavItem::fromRoute(DocumentationPage::home(), group: 'other'));
-        }
+        return app('navigation.sidebar');
     }
 
-    public function hasGroups(): bool
+    public function __construct(Arrayable|array $items = [])
     {
-        return (count($this->getGroups()) >= 1) && ($this->getGroups() !== ['other']);
+        parent::__construct($items);
     }
 
-    /** @return array<string> */
-    public function getGroups(): array
+    public function getHeader(): string
     {
-        return $this->items->map(function (NavItem $item): string {
-            return $item->getGroup();
-        })->unique()->toArray();
+        return Config::get('docs.sidebar.header', 'Documentation');
     }
 
-    /** @return Collection<\Hyde\Framework\Features\Navigation\NavItem> */
-    public function getItemsInGroup(?string $group): Collection
+    public function getFooter(): ?string
     {
-        return $this->items->filter(function (NavItem $item) use ($group): bool {
-            return ($item->getGroup() === $group) || ($item->getGroup() === Str::slug($group));
-        })->sortBy('navigation.priority')->values();
-    }
+        $option = Config::get('docs.sidebar.footer', '[Back to home page](../)');
 
-    public function isGroupActive(string $group): bool
-    {
-        return Str::slug(Render::getPage()->navigationMenuGroup()) === $group
-            || $this->isPageIndexPage() && $this->shouldIndexPageBeActive($group);
+        if (is_string($option)) {
+            return $option;
+        }
+
+        return null;
     }
 
-    public function makeGroupTitle(string $group): string
+    public function hasFooter(): bool
     {
-        return Config::getNullableString("docs.sidebar_group_labels.$group") ?? Hyde::makeTitle($group);
+        return $this->getFooter() !== null;
     }
 
-    protected function canAddRoute(Route $route): bool
+    public function isCollapsible(): bool
     {
-        return parent::canAddRoute($route) && ! $route->is(DocumentationPage::homeRouteName());
+        return Config::getBool('docs.sidebar.collapsible', true);
     }
 
-    private function isPageIndexPage(): bool
+    public function hasGroups(): bool
     {
-        return Render::getPage()->getRoute()->is(DocumentationPage::homeRouteName());
+        return $this->getItems()->contains(fn (NavigationItem|NavigationGroup $item): bool => $item instanceof NavigationGroup);
     }
 
-    private function shouldIndexPageBeActive(string $group): bool
+    /**
+     * Get the group that should be open when the sidebar is loaded.
+     *
+     * @internal This method offloads logic for the sidebar view, and is not intended to be used in other contexts.
+     */
+    public function getActiveGroup(): ?NavigationGroup
     {
-        return Render::getPage()->navigationMenuGroup() === 'other' && $group === collect($this->getGroups())->first();
+        if ($this->items->isEmpty() || (! $this->hasGroups()) || (! $this->isCollapsible()) || Render::getPage() === null) {
+            return null;
+        }
+
+        $currentPage = Render::getPage();
+
+        if ($currentPage->getRoute()->is(DocumentationPage::homeRouteName()) && blank($currentPage->navigationMenuGroup())) {
+            // Unless the index page has a specific group set, the first group in the sidebar should be open when visiting the index page.
+            return $this->items->sortBy(fn (NavigationGroup $item): int => $item->getPriority())->first();
+        }
+
+        return $this->items->first(function (NavigationGroup $group) use ($currentPage): bool {
+            // A group is active when it contains the current page being rendered.
+            return $currentPage->navigationMenuGroup() && $group->getGroupKey() === NavigationGroup::normalizeGroupKey($currentPage->navigationMenuGroup());
+        });
     }
 }
diff --git a/packages/framework/src/Framework/Features/Navigation/DropdownNavItem.php b/packages/framework/src/Framework/Features/Navigation/DropdownNavItem.php
deleted file mode 100644
index aef24a99973..00000000000
--- a/packages/framework/src/Framework/Features/Navigation/DropdownNavItem.php
+++ /dev/null
@@ -1,52 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Hyde\Framework\Features\Navigation;
-
-use Hyde\Facades\Config;
-use Illuminate\Support\Collection;
-
-use function collect;
-
-/**
- * A navigation item that contains other navigation items.
- *
- * Unlike a regular navigation items, a dropdown item does not have a route or URL destination.
- */
-class DropdownNavItem extends NavItem
-{
-    /** @var array<NavItem> */
-    public array $items;
-
-    /** @param array<NavItem> $items */
-    public function __construct(string $label, array $items, ?int $priority = null)
-    {
-        parent::__construct('', $label, $priority ?? $this->searchForDropdownPriorityInNavigationConfig($label) ?? 999);
-        $this->items = $items;
-    }
-
-    /** @param array<NavItem> $items */
-    public static function fromArray(string $name, array $items): static
-    {
-        return new static($name, $items);
-    }
-
-    /** @return Collection<NavItem> */
-    public function getItems(): Collection
-    {
-        return collect($this->items);
-    }
-
-    private function searchForDropdownPriorityInNavigationConfig(string $groupKey): ?int
-    {
-        /** @var array<string, int> $config */
-        $config = Config::getArray('hyde.navigation.order', [
-            'index' => 0,
-            'posts' => 10,
-            'docs/index' => 100,
-        ]);
-
-        return $config[$groupKey] ?? null;
-    }
-}
diff --git a/packages/framework/src/Framework/Features/Navigation/MainNavigationMenu.php b/packages/framework/src/Framework/Features/Navigation/MainNavigationMenu.php
new file mode 100644
index 00000000000..e6681c42ffd
--- /dev/null
+++ b/packages/framework/src/Framework/Features/Navigation/MainNavigationMenu.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Features\Navigation;
+
+use function app;
+
+class MainNavigationMenu extends NavigationMenu
+{
+    public static function get(): static
+    {
+        return app('navigation.main');
+    }
+}
diff --git a/packages/framework/src/Framework/Features/Navigation/NavItem.php b/packages/framework/src/Framework/Features/Navigation/NavItem.php
deleted file mode 100644
index 7a57b554282..00000000000
--- a/packages/framework/src/Framework/Features/Navigation/NavItem.php
+++ /dev/null
@@ -1,138 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Hyde\Framework\Features\Navigation;
-
-use Hyde\Foundation\Facades\Routes;
-use Hyde\Hyde;
-use Hyde\Support\Models\Route;
-use Illuminate\Support\Str;
-use Stringable;
-
-/**
- * Abstraction for a navigation menu item. Used by the NavigationMenu and DocumentationSidebar classes.
- *
- * You have a few options to construct a navigation menu item:
- *   1. You can supply a Route directly and explicit properties to the constructor
- *   2. You can use NavItem::fromRoute() to use data from the route
- *   3. You can use NavItem::forLink() for an external or un-routed link
- */
-class NavItem implements Stringable
-{
-    public readonly string $destination;
-    public readonly string $label;
-    public readonly int $priority;
-    public readonly ?string $group;
-
-    /**
-     * Create a new navigation menu item.
-     */
-    public function __construct(Route|string $destination, string $label, int $priority = 500, ?string $group = null)
-    {
-        $this->destination = (string) $destination;
-        $this->label = $label;
-        $this->priority = $priority;
-        $this->group = $group;
-    }
-
-    /**
-     * Create a new navigation menu item from a route.
-     */
-    public static function fromRoute(Route $route, ?string $label = null, ?int $priority = null, ?string $group = null): static
-    {
-        return new static(
-            $route->getLink(),
-            $label ?? $route->getPage()->navigationMenuLabel(),
-            $priority ?? $route->getPage()->navigationMenuPriority(),
-            $group ?? static::getRouteGroup($route),
-        );
-    }
-
-    /**
-     * Create a new navigation menu item leading to an external URI.
-     */
-    public static function forLink(string $href, string $label, int $priority = 500): static
-    {
-        return new static($href, $label, $priority);
-    }
-
-    /**
-     * Create a new navigation menu item leading to a Route model.
-     *
-     * @param  \Hyde\Support\Models\Route|string<\Hyde\Support\Models\RouteKey>  $route  Route model or route key
-     * @param  int|null  $priority  Leave blank to use the priority of the route's corresponding page.
-     * @param  string|null  $label  Leave blank to use the label of the route's corresponding page.
-     * @param  string|null  $group  Leave blank to use the group of the route's corresponding page.
-     */
-    public static function forRoute(Route|string $route, ?string $label = null, ?int $priority = null, ?string $group = null): static
-    {
-        return static::fromRoute($route instanceof Route ? $route : Routes::getOrFail($route), $label, $priority, $group);
-    }
-
-    /**
-     * Resolve a link to the navigation item.
-     */
-    public function __toString(): string
-    {
-        return $this->destination;
-    }
-
-    /**
-     * Get the destination link of the navigation item.
-     *
-     * If the navigation item is an external link, this will return the link as is,
-     * if it's for a route, a resolved relative link will be returned.
-     */
-    public function getDestination(): string
-    {
-        return $this->destination;
-    }
-
-    /**
-     * Get the label of the navigation item.
-     */
-    public function getLabel(): string
-    {
-        return $this->label;
-    }
-
-    /**
-     * Get the priority to determine the order of the navigation item.
-     */
-    public function getPriority(): int
-    {
-        return $this->priority;
-    }
-
-    /**
-     * Get the group identifier of the navigation item, if any.
-     *
-     * For sidebars this is the category key, for navigation menus this is the dropdown key.
-     */
-    public function getGroup(): ?string
-    {
-        return $this->group;
-    }
-
-    /**
-     * Check if the NavItem instance is the current page.
-     */
-    public function isCurrent(): bool
-    {
-        return Hyde::currentRoute()->getLink() === $this->destination;
-    }
-
-    protected static function getRouteGroup(Route $route): ?string
-    {
-        /** @var string|null $group */
-        $group = $route->getPage()->data('navigation.group');
-
-        return static::normalizeGroupKey($group);
-    }
-
-    protected static function normalizeGroupKey(?string $group): ?string
-    {
-        return $group ? Str::slug($group) : null;
-    }
-}
diff --git a/packages/framework/src/Framework/Features/Navigation/NavigationGroup.php b/packages/framework/src/Framework/Features/Navigation/NavigationGroup.php
new file mode 100644
index 00000000000..9c472b9366a
--- /dev/null
+++ b/packages/framework/src/Framework/Features/Navigation/NavigationGroup.php
@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Features\Navigation;
+
+use Illuminate\Support\Str;
+use Hyde\Pages\DocumentationPage;
+
+use function min;
+
+/**
+ * Abstraction for a grouped navigation menu item, like a dropdown or a sidebar group.
+ */
+class NavigationGroup extends NavigationMenu
+{
+    protected string $label;
+    protected int $priority;
+
+    public function __construct(string $label, array $items = [], int $priority = NavigationMenu::LAST)
+    {
+        parent::__construct($items);
+
+        $this->label = $label;
+        $this->priority = $priority;
+    }
+
+    public static function create(string $label, array $items = [], int $priority = NavigationMenu::LAST): static
+    {
+        return new static($label, $items, $priority);
+    }
+
+    public function getLabel(): string
+    {
+        return $this->label;
+    }
+
+    public function getGroupKey(): string
+    {
+        return Str::slug($this->label);
+    }
+
+    public function getPriority(): int
+    {
+        if ($this->containsOnlyDocumentationPages()) {
+            // For sidebar groups, we use the priority of the lowest priority child, unless the dropdown instance itself has a lower priority.
+            return min($this->priority, $this->getItems()->min(fn (NavigationItem $item): int => $item->getPriority()));
+        }
+
+        return $this->priority;
+    }
+
+    protected function containsOnlyDocumentationPages(): bool
+    {
+        return count($this->getItems()) && $this->getItems()->every(function (NavigationItem $item): bool {
+            return $item->getPage() instanceof DocumentationPage;
+        });
+    }
+
+    /** @experimental This method is subject to change before its release. */
+    public static function normalizeGroupKey(string $group): string
+    {
+        return Str::slug($group);
+    }
+}
diff --git a/packages/framework/src/Framework/Features/Navigation/NavigationItem.php b/packages/framework/src/Framework/Features/Navigation/NavigationItem.php
new file mode 100644
index 00000000000..43d2cf5312b
--- /dev/null
+++ b/packages/framework/src/Framework/Features/Navigation/NavigationItem.php
@@ -0,0 +1,119 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Features\Navigation;
+
+use Hyde\Pages\Concerns\HydePage;
+use Hyde\Foundation\Facades\Routes;
+use Hyde\Hyde;
+use Hyde\Support\Models\Route;
+use Stringable;
+
+use function is_string;
+
+/**
+ * Abstraction for a navigation menu item containing useful information like the destination, label, and priority.
+ *
+ * It is used by the MainNavigationMenu and DocumentationSidebar classes.
+ */
+class NavigationItem implements Stringable
+{
+    protected string|Route $destination;
+    protected string $label;
+    protected int $priority;
+
+    /**
+     * Create a new navigation menu item, automatically filling in the properties from a Route instance if provided.
+     *
+     * @param  \Hyde\Support\Models\Route|string<\Hyde\Support\Models\RouteKey>|string  $destination  Route instance or route key, or an external URI.
+     * @param  string|null  $label  If not provided, Hyde will try to get it from the route's connected page, or from the URL.
+     * @param  int|null  $priority  If not provided, Hyde will try to get it from the route or the default priority of 500.
+     */
+    public function __construct(Route|string $destination, ?string $label = null, ?int $priority = null)
+    {
+        [$this->destination, $this->label, $this->priority] = self::make($destination, $label, $priority);
+    }
+
+    /**
+     * Create a new navigation menu item, automatically filling in the properties from a Route instance if provided.
+     *
+     * @param  \Hyde\Support\Models\Route|string<\Hyde\Support\Models\RouteKey>|string  $destination  Route instance or route key, or an external URI.
+     * @param  string|null  $label  If not provided, Hyde will try to get it from the route's connected page, or from the URL.
+     * @param  int|null  $priority  If not provided, Hyde will try to get it from the route or the default priority of 500.
+     */
+    public static function create(Route|string $destination, ?string $label = null, ?int $priority = null): static
+    {
+        return new static(...self::make($destination, $label, $priority));
+    }
+
+    /**
+     * Resolve a link to the navigation item. See `getLink()` for more information.
+     */
+    public function __toString(): string
+    {
+        return $this->getLink();
+    }
+
+    /**
+     * Resolve the destination link of the navigation item.
+     *
+     * This can then be used in the `href` attribute of an anchor tag.
+     *
+     * If the destination is a Route, it will be resolved using the Route's link.
+     * Otherwise, it will be returned as is for external links using URLs.
+     */
+    public function getLink(): string
+    {
+        return (string) $this->destination;
+    }
+
+    /**
+     * Get the label of the navigation item.
+     */
+    public function getLabel(): string
+    {
+        return $this->label;
+    }
+
+    /**
+     * Get the priority to determine the order of the navigation item.
+     */
+    public function getPriority(): int
+    {
+        return $this->priority;
+    }
+
+    /**
+     * If the navigation item is a link to a routed page, get the corresponding page instance.
+     */
+    public function getPage(): ?HydePage
+    {
+        return $this->destination instanceof Route ? $this->destination->getPage() : null;
+    }
+
+    /**
+     * Check if the NavigationItem instance is the current page being rendered.
+     */
+    public function isActive(): bool
+    {
+        return Hyde::currentRoute()?->getLink() === $this->getLink();
+    }
+
+    /** @return array{\Hyde\Support\Models\Route|string, string, int} */
+    protected static function make(Route|string $destination, ?string $label = null, ?int $priority = null): array
+    {
+        // Automatically resolve the destination if it's a route key.
+        if (is_string($destination) && Routes::has($destination)) {
+            $destination = Routes::get($destination);
+        }
+
+        if ($destination instanceof Route) {
+            // Try to fill in missing properties from the route's connected page.
+            $label ??= $destination->getPage()->navigationMenuLabel();
+            $priority ??= $destination->getPage()->navigationMenuPriority();
+        }
+
+        return [$destination, $label ?? $destination, $priority ?? NavigationMenu::DEFAULT];
+    }
+}
diff --git a/packages/framework/src/Framework/Features/Navigation/NavigationMenu.php b/packages/framework/src/Framework/Features/Navigation/NavigationMenu.php
index bcc844dca75..7329b6bfbe9 100644
--- a/packages/framework/src/Framework/Features/Navigation/NavigationMenu.php
+++ b/packages/framework/src/Framework/Features/Navigation/NavigationMenu.php
@@ -4,71 +4,67 @@
 
 namespace Hyde\Framework\Features\Navigation;
 
-use Hyde\Facades\Config;
-use Hyde\Support\Models\Route;
-use Hyde\Pages\DocumentationPage;
-use BadMethodCallException;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Collection;
+use Illuminate\Contracts\Support\Arrayable;
 
-class NavigationMenu extends BaseNavigationMenu
-{
-    protected function generate(): void
-    {
-        parent::generate();
+use function Hyde\evaluate_arrayable;
 
-        if ($this->dropdownsEnabled()) {
-            $this->moveGroupedItemsIntoDropdowns();
-        }
-    }
+/**
+ * Represents a site navigation menu, and contains all of its navigation items.
+ *
+ * The automatic navigation menus are stored within the service container and can be resolved by their identifiers.
+ *
+ * @example `$menu = app('navigation.main');` for the main navigation menu.
+ * @example `$menu = app('navigation.sidebar');` for the documentation sidebar.
+ */
+class NavigationMenu
+{
+    public const DEFAULT = 500;
+    public const LAST = 999;
 
-    public function hasDropdowns(): bool
-    {
-        return $this->dropdownsEnabled() && count($this->getDropdowns()) >= 1;
-    }
+    /** @var \Illuminate\Support\Collection<\Hyde\Framework\Features\Navigation\NavigationItem|\Hyde\Framework\Features\Navigation\NavigationGroup> */
+    protected Collection $items;
 
-    /** @return array<string, DropdownNavItem> */
-    public function getDropdowns(): array
+    public function __construct(Arrayable|array $items = [])
     {
-        if (! $this->dropdownsEnabled()) {
-            throw new BadMethodCallException('Dropdowns are not enabled. Enable it by setting `hyde.navigation.subdirectories` to `dropdown`.');
-        }
+        $this->items = new Collection();
 
-        return $this->items->filter(function (NavItem $item): bool {
-            return $item instanceof DropdownNavItem;
-        })->values()->all();
+        $this->add(evaluate_arrayable($items));
     }
 
-    protected function moveGroupedItemsIntoDropdowns(): void
+    /**
+     * Get the navigation items in the menu.
+     *
+     * Items are automatically sorted by their priority, falling back to the order they were added.
+     *
+     * @return \Illuminate\Support\Collection<\Hyde\Framework\Features\Navigation\NavigationItem|\Hyde\Framework\Features\Navigation\NavigationGroup>
+     */
+    public function getItems(): Collection
     {
-        $dropdowns = [];
+        // The reason we sort them here is that navigation items can be added from different sources,
+        // so any sorting we do in generator actions will only be partial. This way, we can ensure
+        // that the items are always freshly sorted by their priorities when they are retrieved.
 
-        foreach ($this->items as $key => $item) {
-            if ($this->canAddItemToDropdown($item)) {
-                // Buffer the item in the dropdowns array
-                $dropdowns[$item->getGroup()][] = $item;
-
-                // Remove the item from the main items collection
-                $this->items->forget($key);
-            }
-        }
-
-        foreach ($dropdowns as $group => $items) {
-            // Create a new dropdown item containing the buffered items
-            $this->items->add(new DropdownNavItem($group, $items));
-        }
+        return $this->items->sortBy(fn (NavigationItem|NavigationGroup $item) => $item->getPriority())->values();
     }
 
-    protected function canAddRoute(Route $route): bool
+    /**
+     * Add one or more navigation items to the navigation menu.
+     *
+     * @param  \Hyde\Framework\Features\Navigation\NavigationItem|\Hyde\Framework\Features\Navigation\NavigationGroup|array<\Hyde\Framework\Features\Navigation\NavigationItem|\Hyde\Framework\Features\Navigation\NavigationGroup>  $items
+     */
+    public function add(NavigationItem|NavigationGroup|array $items): static
     {
-        return parent::canAddRoute($route) && (! $route->getPage() instanceof DocumentationPage || $route->is(DocumentationPage::homeRouteName()));
-    }
+        foreach (Arr::wrap($items) as $item) {
+            $this->addItem($item);
+        }
 
-    protected function canAddItemToDropdown(NavItem $item): bool
-    {
-        return $item->getGroup() !== null;
+        return $this;
     }
 
-    protected function dropdownsEnabled(): bool
+    protected function addItem(NavigationItem|NavigationGroup $item): void
     {
-        return Config::getString('hyde.navigation.subdirectories', 'hidden') === 'dropdown';
+        $this->items->push($item);
     }
 }
diff --git a/packages/framework/src/Framework/Features/Navigation/NavigationMenuGenerator.php b/packages/framework/src/Framework/Features/Navigation/NavigationMenuGenerator.php
new file mode 100644
index 00000000000..d1476b87ac3
--- /dev/null
+++ b/packages/framework/src/Framework/Features/Navigation/NavigationMenuGenerator.php
@@ -0,0 +1,203 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Features\Navigation;
+
+use Hyde\Hyde;
+use Hyde\Facades\Config;
+use Hyde\Support\Models\Route;
+use Hyde\Pages\DocumentationPage;
+use Illuminate\Support\Collection;
+use Hyde\Foundation\Facades\Routes;
+use Hyde\Foundation\Kernel\RouteCollection;
+
+use function filled;
+use function assert;
+use function collect;
+use function in_array;
+use function strtolower;
+
+/**
+ * @experimental This class may change significantly before its release.
+ */
+class NavigationMenuGenerator
+{
+    /** @var \Illuminate\Support\Collection<string, \Hyde\Framework\Features\Navigation\NavigationItem> */
+    protected Collection $items;
+
+    /** @var \Hyde\Foundation\Kernel\RouteCollection<string, \Hyde\Support\Models\Route> */
+    protected RouteCollection $routes;
+
+    /** @var class-string<\Hyde\Framework\Features\Navigation\NavigationMenu> */
+    protected string $menuType;
+
+    protected bool $generatesSidebar;
+    protected bool $usesGroups;
+
+    /** @param class-string<\Hyde\Framework\Features\Navigation\NavigationMenu> $menuType */
+    protected function __construct(string $menuType)
+    {
+        assert(in_array($menuType, [MainNavigationMenu::class, DocumentationSidebar::class]));
+
+        $this->menuType = $menuType;
+
+        $this->items = new Collection();
+
+        $this->generatesSidebar = $menuType === DocumentationSidebar::class;
+
+        $this->routes = $this->generatesSidebar
+            ? Routes::getRoutes(DocumentationPage::class)
+            : Routes::all();
+
+        $this->usesGroups = $this->usesGroups();
+    }
+
+    /** @param class-string<\Hyde\Framework\Features\Navigation\NavigationMenu> $menuType */
+    public static function handle(string $menuType): MainNavigationMenu|DocumentationSidebar
+    {
+        $menu = new static($menuType);
+
+        $menu->generate();
+
+        return new $menuType($menu->items);
+    }
+
+    protected function generate(): void
+    {
+        $this->routes->each(function (Route $route): void {
+            if ($this->canAddRoute($route)) {
+                if ($this->canGroupRoute($route)) {
+                    $this->addRouteToGroup($route);
+                } else {
+                    $this->items->put($route->getRouteKey(), NavigationItem::create($route));
+                }
+            }
+        });
+
+        if ($this->generatesSidebar) {
+            // If there are no pages other than the index page, we add it to the sidebar so that it's not empty
+            if ($this->items->count() === 0 && DocumentationPage::home() !== null) {
+                $this->items->push(NavigationItem::create(DocumentationPage::home()));
+            }
+        } else {
+            collect(Config::getArray('hyde.navigation.custom', []))->each(function (NavigationItem $item): void {
+                // Since these were added explicitly by the user, we can assume they should always be shown
+                $this->items->push($item);
+            });
+        }
+    }
+
+    protected function usesGroups(): bool
+    {
+        if ($this->generatesSidebar) {
+            // In order to know if we should use groups in the sidebar, we need to loop through the pages and see if they have a group set.
+            // This automatically enables the sidebar grouping for all pages if at least one group is set.
+
+            return $this->routes->first(fn (Route $route): bool => filled($route->getPage()->navigationMenuGroup())) !== null;
+        } else {
+            return Config::getString('hyde.navigation.subdirectories', 'hidden') === 'dropdown';
+        }
+    }
+
+    protected function canAddRoute(Route $route): bool
+    {
+        if (! $route->getPage()->showInNavigation()) {
+            return false;
+        }
+
+        if ($this->generatesSidebar) {
+            // Since the index page is linked in the header, we don't want it in the sidebar
+            return ! $route->is(DocumentationPage::homeRouteName());
+        } else {
+            // While we for the most part can rely on the navigation visibility state provided by the navigation data factory,
+            // we need to make an exception for documentation pages, which generally have a visible state, as the data is
+            // also used in the sidebar. But we only want the documentation index page to be in the main navigation.
+            return ! $route->getPage() instanceof DocumentationPage || $route->is(DocumentationPage::homeRouteName());
+        }
+    }
+
+    protected function canGroupRoute(Route $route): bool
+    {
+        if (! $this->generatesSidebar) {
+            return $route->getPage()->navigationMenuGroup() !== null;
+        }
+
+        if (! $this->usesGroups) {
+            return false;
+        }
+
+        return true;
+    }
+
+    protected function addRouteToGroup(Route $route): void
+    {
+        $item = NavigationItem::create($route);
+
+        $groupKey = $item->getPage()->navigationMenuGroup();
+        $groupName = $this->generatesSidebar ? ($groupKey ?? 'Other') : $groupKey;
+
+        $groupItem = $this->getOrCreateGroupItem($groupName);
+
+        $groupItem->add($item);
+
+        if (! $this->items->has($groupItem->getGroupKey())) {
+            $this->items->put($groupItem->getGroupKey(), $groupItem);
+        }
+    }
+
+    protected function getOrCreateGroupItem(string $groupName): NavigationGroup
+    {
+        $groupKey = NavigationGroup::normalizeGroupKey($groupName);
+        $group = $this->items->get($groupKey);
+
+        if ($group instanceof NavigationGroup) {
+            return $group;
+        } elseif ($group instanceof NavigationItem) {
+            // We are trying to add children to an existing navigation menu item,
+            // so here we create a new instance to replace the base one, this
+            // does mean we lose the destination as we can't link to them.
+
+            $item = new NavigationGroup($group->getLabel(), [], $group->getPriority());
+
+            $this->items->put($groupKey, $item);
+
+            return $item;
+        }
+
+        return $this->createGroupItem($groupKey, $groupName);
+    }
+
+    protected function createGroupItem(string $groupKey, string $groupName): NavigationGroup
+    {
+        $label = $this->searchForGroupLabelInConfig($groupKey) ?? $groupName;
+
+        $priority = $this->searchForGroupPriorityInConfig($groupKey);
+
+        return NavigationGroup::create($this->normalizeGroupLabel($label), [], $priority ?? NavigationMenu::LAST);
+    }
+
+    protected function normalizeGroupLabel(string $label): string
+    {
+        // If there is no label, and the group is a slug, we can make a title from it
+        if ($label === strtolower($label)) {
+            return Hyde::makeTitle($label);
+        }
+
+        return $label;
+    }
+
+    protected function searchForGroupLabelInConfig(string $groupKey): ?string
+    {
+        $key = $this->generatesSidebar ? 'docs.sidebar_group_labels' : 'hyde.navigation.labels';
+
+        return Config::getArray($key, [])[$groupKey] ?? null;
+    }
+
+    protected function searchForGroupPriorityInConfig(string $groupKey): ?int
+    {
+        $key = $this->generatesSidebar ? 'docs.sidebar.order' : 'hyde.navigation.order';
+
+        return Config::getArray($key, [])[$groupKey] ?? null;
+    }
+}
diff --git a/packages/framework/src/Pages/DocumentationPage.php b/packages/framework/src/Pages/DocumentationPage.php
index c9df40fe15c..6ca14b5b9b8 100644
--- a/packages/framework/src/Pages/DocumentationPage.php
+++ b/packages/framework/src/Pages/DocumentationPage.php
@@ -51,7 +51,7 @@ public function getOnlineSourcePath(): string|false
 
     public static function hasTableOfContents(): bool
     {
-        return Config::getBool('docs.table_of_contents.enabled', true);
+        return Config::getBool('docs.sidebar.table_of_contents.enabled', true);
     }
 
     /**
diff --git a/packages/framework/tests/Feature/AutomaticNavigationConfigurationsTest.php b/packages/framework/tests/Feature/AutomaticNavigationConfigurationsTest.php
new file mode 100644
index 00000000000..5ae702cfad8
--- /dev/null
+++ b/packages/framework/tests/Feature/AutomaticNavigationConfigurationsTest.php
@@ -0,0 +1,1389 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Testing\Feature;
+
+use Hyde\Pages\HtmlPage;
+use Hyde\Pages\BladePage;
+use Hyde\Testing\TestCase;
+use Hyde\Pages\MarkdownPage;
+use Hyde\Pages\MarkdownPost;
+use Hyde\Pages\InMemoryPage;
+use Hyde\Foundation\HydeKernel;
+use JetBrains\PhpStorm\NoReturn;
+use Hyde\Pages\Concerns\HydePage;
+use Hyde\Pages\DocumentationPage;
+use Hyde\Support\Models\Redirect;
+use Illuminate\Support\Collection;
+use Hyde\Foundation\Kernel\RouteCollection;
+use Hyde\Framework\Features\Navigation\NavigationItem;
+use Hyde\Framework\Features\Navigation\NavigationGroup;
+use Hyde\Framework\Features\Navigation\MainNavigationMenu;
+use Hyde\Framework\Features\Navigation\DocumentationSidebar;
+use Hyde\Framework\Features\Navigation\NavigationMenuGenerator;
+
+/**
+ * High-level broad-spectrum tests for the automatic navigation configurations, testing various setups.
+ *
+ * @see \Hyde\Framework\Testing\Unit\Views\NavigationHtmlLayoutsTest
+ *
+ * @covers \Hyde\Framework\Factories\NavigationDataFactory
+ * @covers \Hyde\Framework\Features\Navigation\NavigationMenuGenerator
+ * @covers \Hyde\Framework\Features\Navigation\DocumentationSidebar
+ * @covers \Hyde\Framework\Features\Navigation\MainNavigationMenu
+ * @covers \Hyde\Framework\Features\Navigation\NavigationMenu
+ * @covers \Hyde\Framework\Features\Navigation\NavigationItem
+ */
+class AutomaticNavigationConfigurationsTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->kernel = new TestKernel();
+        HydeKernel::setInstance($this->kernel);
+    }
+
+    // Base tests
+
+    public function testMainNavigationMenu()
+    {
+        $this->menu()->assertEquals(['Home']);
+    }
+
+    public function testDocumentationSidebarMenu()
+    {
+        $this->sidebar()->assertEquals([]);
+    }
+
+    // Main navigation menu tests
+
+    public function testMainNavigationMenuWithPages()
+    {
+        $this->withPages([
+            new MarkdownPage('about'),
+            new MarkdownPage('contact'),
+        ])->menu()->assertEquals([
+            'About',
+            'Contact',
+        ]);
+    }
+
+    public function testOnlyRootTypePagesAreAddedToNavigationMenu()
+    {
+        $this->assertMenuEquals(['Html Page', 'Blade Page', 'Markdown Page'], [
+            new HtmlPage('html-page'),
+            new BladePage('blade-page'),
+            new MarkdownPage('markdown-page'),
+            new MarkdownPost('markdown-post'),
+            new DocumentationPage('documentation-page'),
+        ]);
+    }
+
+    public function testDocumentationIndexPagesAreAddedToNavigationMenu()
+    {
+        $this->assertMenuEquals(['Docs'], [
+            new DocumentationPage('index'),
+            new DocumentationPage('foo'),
+        ]);
+    }
+
+    public function testInMemoryPagesAreAddedToNavigationMenu()
+    {
+        $this->assertMenuEquals(['In Memory Page'], [
+            new InMemoryPage('in-memory-page'),
+        ]);
+    }
+
+    public function testMainNavigationDoesNotInclude404Page()
+    {
+        $this->assertMenuEquals([], [new MarkdownPage('404')]);
+    }
+
+    public function testRedirectPagesAreAddedToNavigationMenu()
+    {
+        $this->assertMenuEquals(['Redirect'], [
+            new Redirect('redirect', 'destination'),
+        ]);
+    }
+
+    // Main navigation front matter tests
+
+    public function testDefaultNavigationPriorities()
+    {
+        $this->assertMenuEquals([
+            ['priority' => 0],
+            ['priority' => 10],
+            ['priority' => 100],
+        ], [
+            new MarkdownPage('index'),
+            new MarkdownPage('posts'),
+            new MarkdownPage('docs/index'),
+        ]);
+    }
+
+    public function testDefaultNavigationLabels()
+    {
+        $this->assertMenuEquals([
+            ['label' => 'Home'],
+            ['label' => 'Docs'],
+        ], [
+            new MarkdownPage('index'),
+            new MarkdownPage('docs/index'),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithFrontMatterPriority()
+    {
+        $this->assertMenuEquals(['First', 'Second', 'Third'], [
+            new MarkdownPage('first', ['navigation.priority' => 1]),
+            new MarkdownPage('second', ['navigation.priority' => 2]),
+            new MarkdownPage('third', ['navigation.priority' => 3]),
+        ]);
+
+        $this->assertMenuEquals(['Third', 'Second', 'First'], [
+            new MarkdownPage('first', ['navigation.priority' => 3]),
+            new MarkdownPage('second', ['navigation.priority' => 2]),
+            new MarkdownPage('third', ['navigation.priority' => 1]),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithFrontMatterOrder()
+    {
+        $this->assertMenuEquals(['First', 'Second', 'Third'], [
+            new MarkdownPage('first', ['navigation.order' => 1]),
+            new MarkdownPage('second', ['navigation.order' => 2]),
+            new MarkdownPage('third', ['navigation.order' => 3]),
+        ]);
+
+        $this->assertMenuEquals(['Third', 'Second', 'First'], [
+            new MarkdownPage('first', ['navigation.order' => 3]),
+            new MarkdownPage('second', ['navigation.order' => 2]),
+            new MarkdownPage('third', ['navigation.order' => 1]),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithFrontMatterLabel()
+    {
+        $this->assertMenuEquals(['First', 'Second', 'Third'], [
+            new MarkdownPage('foo', ['navigation.label' => 'First']),
+            new MarkdownPage('bar', ['navigation.label' => 'Second']),
+            new MarkdownPage('baz', ['navigation.label' => 'Third']),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithFrontMatterHidden()
+    {
+        $this->assertMenuEquals(['Foo', 'Bar', 'Baz'], [
+            new MarkdownPage('foo', ['navigation.hidden' => false]),
+            new MarkdownPage('bar', ['navigation.hidden' => false]),
+            new MarkdownPage('baz', ['navigation.hidden' => false]),
+        ]);
+
+        $this->assertMenuEquals([], [
+            new MarkdownPage('foo', ['navigation.hidden' => true]),
+            new MarkdownPage('bar', ['navigation.hidden' => true]),
+            new MarkdownPage('baz', ['navigation.hidden' => true]),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithFrontMatterVisible()
+    {
+        $this->assertMenuEquals(['Foo', 'Bar', 'Baz'], [
+            new MarkdownPage('foo', ['navigation.visible' => true]),
+            new MarkdownPage('bar', ['navigation.visible' => true]),
+            new MarkdownPage('baz', ['navigation.visible' => true]),
+        ]);
+
+        $this->assertMenuEquals([], [
+            new MarkdownPage('foo', ['navigation.visible' => false]),
+            new MarkdownPage('bar', ['navigation.visible' => false]),
+            new MarkdownPage('baz', ['navigation.visible' => false]),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithExplicitFrontMatterGroupUsesDropdownsRegardlessOfConfigSetting()
+    {
+        $this->assertMenuEquals([
+            ['label' => 'Group 1', 'children' => ['Foo', 'Bar', 'Baz']],
+        ], [
+            new MarkdownPage('foo', ['navigation.group' => 'Group 1']),
+            new MarkdownPage('bar', ['navigation.group' => 'Group 1']),
+            new MarkdownPage('baz', ['navigation.group' => 'Group 1']),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithExplicitFrontMatterCategoryUsesDropdownsRegardlessOfConfigSetting()
+    {
+        $this->assertMenuEquals([
+            ['label' => 'Group 1', 'children' => ['Foo', 'Bar', 'Baz']],
+        ], [
+            new MarkdownPage('foo', ['navigation.category' => 'Group 1']),
+            new MarkdownPage('bar', ['navigation.category' => 'Group 1']),
+            new MarkdownPage('baz', ['navigation.category' => 'Group 1']),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithFrontMatterPriorityAndOrder()
+    {
+        // Since the main key in the navigation schema is 'priority', that takes precedence over its 'order' alias
+
+        $expected = [
+            ['label' => 'Foo', 'priority' => 1],
+            ['label' => 'Bar', 'priority' => 2],
+            ['label' => 'Baz', 'priority' => 3],
+        ];
+
+        $this->assertMenuEquals($expected, [
+            new MarkdownPage('foo', ['navigation.priority' => 1, 'navigation.order' => 10]),
+            new MarkdownPage('bar', ['navigation.priority' => 2, 'navigation.order' => 20]),
+            new MarkdownPage('baz', ['navigation.priority' => 3, 'navigation.order' => 30]),
+        ]);
+
+        $this->assertMenuEquals($expected, [
+            new MarkdownPage('foo', ['navigation.order' => 10, 'navigation.priority' => 1]),
+            new MarkdownPage('bar', ['navigation.order' => 20, 'navigation.priority' => 2]),
+            new MarkdownPage('baz', ['navigation.order' => 30, 'navigation.priority' => 3]),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithFrontMatterHiddenAndVisible()
+    {
+        // Since the main key in the navigation schema is 'hidden', that takes precedence over its 'visible' alias
+
+        $this->assertMenuEquals(['Foo', 'Bar', 'Baz'], [
+            new MarkdownPage('foo', ['navigation.hidden' => false, 'navigation.visible' => true]),
+            new MarkdownPage('bar', ['navigation.hidden' => false, 'navigation.visible' => true]),
+            new MarkdownPage('baz', ['navigation.hidden' => false, 'navigation.visible' => true]),
+        ]);
+
+        $this->assertMenuEquals([], [
+            new MarkdownPage('foo', ['navigation.hidden' => true, 'navigation.visible' => false]),
+            new MarkdownPage('bar', ['navigation.hidden' => true, 'navigation.visible' => false]),
+            new MarkdownPage('baz', ['navigation.hidden' => true, 'navigation.visible' => false]),
+        ]);
+
+        $this->assertMenuEquals([], [
+            new MarkdownPage('foo', ['navigation.hidden' => true, 'navigation.visible' => true]),
+            new MarkdownPage('bar', ['navigation.hidden' => true, 'navigation.visible' => true]),
+            new MarkdownPage('baz', ['navigation.hidden' => true, 'navigation.visible' => true]),
+        ]);
+
+        $this->assertMenuEquals(['Foo', 'Bar', 'Baz'], [
+            new MarkdownPage('foo', ['navigation.hidden' => false, 'navigation.visible' => false]),
+            new MarkdownPage('bar', ['navigation.hidden' => false, 'navigation.visible' => false]),
+            new MarkdownPage('baz', ['navigation.hidden' => false, 'navigation.visible' => false]),
+        ]);
+
+        $this->assertMenuEquals(['Bar'], [
+            new MarkdownPage('foo', ['navigation.hidden' => true, 'navigation.visible' => false]),
+            new MarkdownPage('bar', ['navigation.hidden' => false, 'navigation.visible' => true]),
+            new MarkdownPage('baz', ['navigation.hidden' => true, 'navigation.visible' => false]),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithFrontMatterGroupAndCategory()
+    {
+        // Since the main key in the navigation schema is 'group', that takes precedence over its 'category' alias
+
+        $this->assertMenuEquals([[
+            'label' => 'Group 1',
+            'children' => ['Foo', 'Bar', 'Baz'],
+        ]], [
+            new MarkdownPage('foo', ['navigation.group' => 'Group 1', 'navigation.category' => 'Group 2']),
+            new MarkdownPage('bar', ['navigation.group' => 'Group 1', 'navigation.category' => 'Group 2']),
+            new MarkdownPage('baz', ['navigation.group' => 'Group 1', 'navigation.category' => 'Group 2']),
+        ]);
+    }
+
+    // Main navigation configuration tests
+
+    public function testMainNavigationMenuWithConfigOrder()
+    {
+        config(['hyde.navigation.order' => ['first', 'second', 'third']]);
+
+        $this->assertMenuEquals(['First', 'Second', 'Third'], [
+            new MarkdownPage('first'),
+            new MarkdownPage('second'),
+            new MarkdownPage('third'),
+        ]);
+
+        config(['hyde.navigation.order' => ['third', 'second', 'first']]);
+
+        $this->assertMenuEquals(['Third', 'Second', 'First'], [
+            new MarkdownPage('first'),
+            new MarkdownPage('second'),
+            new MarkdownPage('third'),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithConfigOrderHasInferredPriorities()
+    {
+        $this->assertMenuEquals([
+            ['priority' => 999],
+            ['priority' => 999],
+            ['priority' => 999],
+        ], [
+            new MarkdownPage('first'),
+            new MarkdownPage('second'),
+            new MarkdownPage('third'),
+        ]);
+
+        config(['hyde.navigation.order' => ['first', 'second', 'third']]);
+
+        $this->assertMenuEquals([
+            ['priority' => 500],
+            ['priority' => 501],
+            ['priority' => 502],
+        ], [
+            new MarkdownPage('first'),
+            new MarkdownPage('second'),
+            new MarkdownPage('third'),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithExplicitConfigOrder()
+    {
+        config(['hyde.navigation.order' => ['first' => 1, 'second' => 2, 'third' => 3]]);
+
+        $this->assertMenuEquals(['First', 'Second', 'Third'], [
+            new MarkdownPage('first'),
+            new MarkdownPage('second'),
+            new MarkdownPage('third'),
+        ]);
+
+        config(['hyde.navigation.order' => ['first' => 3, 'second' => 2, 'third' => 1]]);
+
+        $this->assertMenuEquals(['Third', 'Second', 'First'], [
+            new MarkdownPage('first'),
+            new MarkdownPage('second'),
+            new MarkdownPage('third'),
+        ]);
+
+        config(['hyde.navigation.order' => ['first' => 1, 'second' => 2, 'third' => 3]]);
+
+        $this->assertMenuEquals([
+            ['label' => 'First', 'priority' => 1],
+            ['label' => 'Second', 'priority' => 2],
+            ['label' => 'Third', 'priority' => 3],
+        ], [
+            new MarkdownPage('first'),
+            new MarkdownPage('second'),
+            new MarkdownPage('third'),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithMixedConfigOrders()
+    {
+        config(['hyde.navigation.order' => ['foo', 'bar' => 650]]);
+
+        $this->assertMenuEquals([
+            ['label' => 'Foo', 'priority' => 500],
+            ['label' => 'Bar', 'priority' => 650],
+            ['label' => 'Baz', 'priority' => 999],
+        ], [
+            new MarkdownPage('foo'),
+            new MarkdownPage('bar'),
+            new MarkdownPage('baz'),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithConfigLabels()
+    {
+        config(['hyde.navigation.labels' => ['foo' => 'First', 'bar' => 'Second', 'baz' => 'Third']]);
+
+        $this->assertMenuEquals(['First', 'Second', 'Third'], [
+            new MarkdownPage('foo'),
+            new MarkdownPage('bar'),
+            new MarkdownPage('baz'),
+        ]);
+    }
+
+    public function testMainNavigationDropdownLabelsCanBeSetInConfig()
+    {
+        config(['hyde.navigation.labels' => ['hello' => 'World']]);
+
+        $this->assertMenuEquals(['World'], [
+            new MarkdownPage('foo', ['navigation.group' => 'Hello']),
+        ]);
+    }
+
+    public function testMainNavigationAutomaticSubdirectoryDropdownLabelsCanBeSetInConfig()
+    {
+        config(['hyde.navigation.subdirectories' => 'dropdown']);
+        config(['hyde.navigation.labels' => ['hello' => 'World']]);
+
+        $this->assertMenuEquals(['World'], [
+            new MarkdownPage('hello/world'),
+        ]);
+    }
+
+    public function testMainNavigationMenuWithConfigHidden()
+    {
+        config(['hyde.navigation.exclude' => ['foo', 'bar', 'baz']]);
+
+        $this->assertMenuEquals([], [
+            new MarkdownPage('foo'),
+            new MarkdownPage('bar'),
+            new MarkdownPage('baz'),
+        ]);
+    }
+
+    // Main navigation subdirectory handling tests
+
+    public function testPagesInSubdirectoriesAreNotAddedToNavigation()
+    {
+        $this->assertMenuEquals([], [
+            new MarkdownPage('about/foo'),
+            new MarkdownPage('about/bar'),
+            new MarkdownPage('about/baz'),
+        ]);
+    }
+
+    public function testPagesInSubdirectoriesAreAddedToNavigationWhenNavigationSubdirectoriesIsSetToFlat()
+    {
+        config(['hyde.navigation.subdirectories' => 'flat']);
+
+        $this->assertMenuEquals(['Foo', 'Bar', 'Baz'], [
+            new MarkdownPage('about/foo'),
+            new MarkdownPage('about/bar'),
+            new MarkdownPage('about/baz'),
+        ]);
+    }
+
+    public function testPagesInSubdirectoriesAreAddedAsDropdownsWhenNavigationSubdirectoriesIsSetToDropdown()
+    {
+        config(['hyde.navigation.subdirectories' => 'dropdown']);
+
+        $this->assertMenuEquals([
+            ['label' => 'About', 'children' => ['Foo', 'Bar', 'Baz']],
+        ], [
+            new MarkdownPage('about/foo'),
+            new MarkdownPage('about/bar'),
+            new MarkdownPage('about/baz'),
+        ]);
+    }
+
+    public function testMainNavigationMenuItemsWithTheSameLabelAreNotFilteredForDuplicates()
+    {
+        $this->assertMenuEquals(['Foo', 'Foo'], [
+            new MarkdownPage('foo', ['navigation.label' => 'Foo']),
+            new MarkdownPage('bar', ['navigation.label' => 'Foo']),
+        ]);
+    }
+
+    public function testMainNavigationMenuItemsWithTheSameLabelAreNotFilteredForDuplicatesRegardlessOfCase()
+    {
+        $this->assertMenuEquals(['Foo', 'Foo', 'FOO'], [
+            new MarkdownPage('foo'),
+            new MarkdownPage('Foo'),
+            new MarkdownPage('FOO'),
+        ]);
+
+        $this->assertMenuEquals(['foo', 'Foo', 'FOO'], [
+            new MarkdownPage('foo', ['navigation.label' => 'foo']),
+            new MarkdownPage('bar', ['navigation.label' => 'Foo']),
+            new MarkdownPage('baz', ['navigation.label' => 'FOO']),
+        ]);
+    }
+
+    public function testMainNavigationMenuItemsWithSameLabelButDifferentGroupsAreNotFiltered()
+    {
+        $this->assertMenuEquals([
+            ['label' => 'Group 1', 'children' => ['Foo']],
+            ['label' => 'Group 2', 'children' => ['Foo']],
+        ], [
+            new MarkdownPage('foo', ['navigation.label' => 'Foo', 'navigation.group' => 'Group 1']),
+            new MarkdownPage('bar', ['navigation.label' => 'Foo', 'navigation.group' => 'Group 2']),
+        ]);
+    }
+
+    public function testMainNavigationMenuDropdownItemsWithSameLabelButDifferentGroupsAreNotFiltered()
+    {
+        config(['hyde.navigation.subdirectories' => 'dropdown']);
+
+        $this->assertMenuEquals([
+            ['label' => 'One', 'children' => ['Foo']],
+            ['label' => 'Two', 'children' => ['Foo']],
+        ], [
+            new MarkdownPage('one/foo'),
+            new MarkdownPage('two/foo'),
+        ]);
+    }
+
+    public function testMainNavigationMenuAutomaticDropdownItemsWithSameLabelButDifferentGroupsAreNotFiltered()
+    {
+        config(['hyde.navigation.subdirectories' => 'dropdown']);
+
+        $this->assertMenuEquals([
+            ['label' => 'One', 'children' => ['Foo']],
+            ['label' => 'Two', 'children' => ['Foo']],
+        ], [
+            new MarkdownPage('one/foo'),
+            new MarkdownPage('two/foo'),
+        ]);
+    }
+
+    public function testConflictingSubdirectoryAndFrontMatterDropdownConfigurationGivesPrecedenceToSubdirectory()
+    {
+        // In case subdirectories are set to be used as dropdowns, but a page has a group set in its front matter,
+        // we run into a conflicting state where we don't know what the user intended. We solve this by giving
+        // precedence to the subdirectory configuration. This is opinionated, but allows for good grouping.
+
+        config(['hyde.navigation.subdirectories' => 'dropdown']);
+
+        $this->assertMenuEquals([
+            ['label' => 'Foo', 'children' => ['Child']],
+        ], [
+            new MarkdownPage('foo/child', ['navigation.group' => 'bar']),
+        ]);
+    }
+
+    public function testCanMixSubdirectoryDropdownsWithFrontMatterDropdowns()
+    {
+        config(['hyde.navigation.subdirectories' => 'dropdown']);
+
+        $this->assertMenuEquals([
+            ['label' => 'Foo', 'children' => ['Bar', 'Baz']],
+        ], [
+            new MarkdownPage('foo/bar'),
+            new MarkdownPage('foo/baz', ['navigation.group' => 'foo']),
+        ]);
+    }
+
+    public function testMainMenuAutomaticDropdownLabelsCanBeSetInConfig()
+    {
+        config(['hyde.navigation.subdirectories' => 'dropdown']);
+        config(['hyde.navigation.labels' => ['foo' => 'Bar']]);
+
+        $this->assertMenuEquals([
+            ['label' => 'Bar', 'children' => ['Bar']],
+        ], [
+            new MarkdownPage('foo/bar'),
+        ]);
+    }
+
+    // Documentation sidebar menu tests
+
+    public function testSidebarWithPages()
+    {
+        $this->assertSidebarEquals(['Foo', 'Bar', 'Baz'], [
+            new DocumentationPage('foo'),
+            new DocumentationPage('bar'),
+            new DocumentationPage('baz'),
+        ]);
+    }
+
+    public function testOnlyDocumentationPagesAreAddedToSidebar()
+    {
+        $this->assertSidebarEquals(['Documentation Page'], [
+            new HtmlPage('html-page'),
+            new BladePage('blade-page'),
+            new MarkdownPage('markdown-page'),
+            new MarkdownPost('markdown-post'),
+            new DocumentationPage('documentation-page'),
+            new InMemoryPage('in-memory-page'),
+            new Redirect('redirect', 'destination'),
+        ]);
+    }
+
+    public function testDocumentationIndexPageIsNotAddedToSidebar()
+    {
+        $this->assertSidebarEquals([], [new DocumentationPage('index')]);
+    }
+
+    // Documentation sidebar front matter tests
+
+    public function testSidebarWithFrontMatterPriority()
+    {
+        $this->assertSidebarEquals(['First', 'Second', 'Third'], [
+            new DocumentationPage('first', ['navigation.priority' => 1]),
+            new DocumentationPage('second', ['navigation.priority' => 2]),
+            new DocumentationPage('third', ['navigation.priority' => 3]),
+        ]);
+
+        $this->assertSidebarEquals(['Third', 'Second', 'First'], [
+            new DocumentationPage('first', ['navigation.priority' => 3]),
+            new DocumentationPage('second', ['navigation.priority' => 2]),
+            new DocumentationPage('third', ['navigation.priority' => 1]),
+        ]);
+    }
+
+    public function testSidebarWithFrontMatterOrder()
+    {
+        $this->assertSidebarEquals(['First', 'Second', 'Third'], [
+            new DocumentationPage('first', ['navigation.order' => 1]),
+            new DocumentationPage('second', ['navigation.order' => 2]),
+            new DocumentationPage('third', ['navigation.order' => 3]),
+        ]);
+
+        $this->assertSidebarEquals(['Third', 'Second', 'First'], [
+            new DocumentationPage('first', ['navigation.order' => 3]),
+            new DocumentationPage('second', ['navigation.order' => 2]),
+            new DocumentationPage('third', ['navigation.order' => 1]),
+        ]);
+    }
+
+    public function testSidebarWithFrontMatterLabel()
+    {
+        $this->assertSidebarEquals(['First', 'Second', 'Third'], [
+            new DocumentationPage('foo', ['navigation.label' => 'First']),
+            new DocumentationPage('bar', ['navigation.label' => 'Second']),
+            new DocumentationPage('baz', ['navigation.label' => 'Third']),
+        ]);
+    }
+
+    public function testSidebarWithFrontMatterHidden()
+    {
+        $this->assertSidebarEquals(['Foo', 'Bar', 'Baz'], [
+            new DocumentationPage('foo', ['navigation.hidden' => false]),
+            new DocumentationPage('bar', ['navigation.hidden' => false]),
+            new DocumentationPage('baz', ['navigation.hidden' => false]),
+        ]);
+
+        $this->assertSidebarEquals([], [
+            new DocumentationPage('foo', ['navigation.hidden' => true]),
+            new DocumentationPage('bar', ['navigation.hidden' => true]),
+            new DocumentationPage('baz', ['navigation.hidden' => true]),
+        ]);
+    }
+
+    public function testSidebarWithFrontMatterVisible()
+    {
+        $this->assertSidebarEquals(['Foo', 'Bar', 'Baz'], [
+            new DocumentationPage('foo', ['navigation.visible' => true]),
+            new DocumentationPage('bar', ['navigation.visible' => true]),
+            new DocumentationPage('baz', ['navigation.visible' => true]),
+        ]);
+
+        $this->assertSidebarEquals([], [
+            new DocumentationPage('foo', ['navigation.visible' => false]),
+            new DocumentationPage('bar', ['navigation.visible' => false]),
+            new DocumentationPage('baz', ['navigation.visible' => false]),
+        ]);
+    }
+
+    public function testSidebarWithFrontMatterGroup()
+    {
+        $this->assertSidebarEquals([[
+            'label' => 'Group 1',
+            'children' => ['Foo', 'Bar', 'Baz']],
+        ], [
+            new DocumentationPage('foo', ['navigation.group' => 'Group 1']),
+            new DocumentationPage('bar', ['navigation.group' => 'Group 1']),
+            new DocumentationPage('baz', ['navigation.group' => 'Group 1']),
+        ]);
+    }
+
+    public function testSidebarWithFrontMatterCategory()
+    {
+        $this->assertSidebarEquals([[
+            'label' => 'Group 1',
+            'children' => ['Foo', 'Bar', 'Baz']],
+        ], [
+            new DocumentationPage('foo', ['navigation.category' => 'Group 1']),
+            new DocumentationPage('bar', ['navigation.category' => 'Group 1']),
+            new DocumentationPage('baz', ['navigation.category' => 'Group 1']),
+        ]);
+    }
+
+    public function testSidebarWithFrontMatterPriorityAndOrder()
+    {
+        // Since the main key in the navigation schema is 'priority', that takes precedence over its 'order' alias
+
+        $expected = [
+            ['label' => 'Foo', 'priority' => 1],
+            ['label' => 'Bar', 'priority' => 2],
+            ['label' => 'Baz', 'priority' => 3],
+        ];
+
+        $this->assertSidebarEquals($expected, [
+            new DocumentationPage('foo', ['navigation.priority' => 1, 'navigation.order' => 10]),
+            new DocumentationPage('bar', ['navigation.priority' => 2, 'navigation.order' => 20]),
+            new DocumentationPage('baz', ['navigation.priority' => 3, 'navigation.order' => 30]),
+        ]);
+
+        $this->assertSidebarEquals($expected, [
+            new DocumentationPage('foo', ['navigation.order' => 10, 'navigation.priority' => 1]),
+            new DocumentationPage('bar', ['navigation.order' => 20, 'navigation.priority' => 2]),
+            new DocumentationPage('baz', ['navigation.order' => 30, 'navigation.priority' => 3]),
+        ]);
+    }
+
+    public function testSidebarWithFrontMatterHiddenAndVisible()
+    {
+        // Since the main key in the navigation schema is 'hidden', that takes precedence over its 'visible' alias
+
+        $this->assertSidebarEquals(['Foo', 'Bar', 'Baz'], [
+            new DocumentationPage('foo', ['navigation.hidden' => false, 'navigation.visible' => true]),
+            new DocumentationPage('bar', ['navigation.hidden' => false, 'navigation.visible' => true]),
+            new DocumentationPage('baz', ['navigation.hidden' => false, 'navigation.visible' => true]),
+        ]);
+
+        $this->assertSidebarEquals([], [
+            new DocumentationPage('foo', ['navigation.hidden' => true, 'navigation.visible' => false]),
+            new DocumentationPage('bar', ['navigation.hidden' => true, 'navigation.visible' => false]),
+            new DocumentationPage('baz', ['navigation.hidden' => true, 'navigation.visible' => false]),
+        ]);
+
+        $this->assertSidebarEquals([], [
+            new DocumentationPage('foo', ['navigation.hidden' => true, 'navigation.visible' => true]),
+            new DocumentationPage('bar', ['navigation.hidden' => true, 'navigation.visible' => true]),
+            new DocumentationPage('baz', ['navigation.hidden' => true, 'navigation.visible' => true]),
+        ]);
+
+        $this->assertSidebarEquals(['Foo', 'Bar', 'Baz'], [
+            new DocumentationPage('foo', ['navigation.hidden' => false, 'navigation.visible' => false]),
+            new DocumentationPage('bar', ['navigation.hidden' => false, 'navigation.visible' => false]),
+            new DocumentationPage('baz', ['navigation.hidden' => false, 'navigation.visible' => false]),
+        ]);
+
+        $this->assertSidebarEquals(['Bar'], [
+            new DocumentationPage('foo', ['navigation.hidden' => true, 'navigation.visible' => false]),
+            new DocumentationPage('bar', ['navigation.hidden' => false, 'navigation.visible' => true]),
+            new DocumentationPage('baz', ['navigation.hidden' => true, 'navigation.visible' => false]),
+        ]);
+    }
+
+    public function testSidebarWithFrontMatterGroupAndCategory()
+    {
+        // Since the main key in the navigation schema is 'group', that takes precedence over its 'category' alias
+
+        $this->assertSidebarEquals([[
+            'label' => 'Group 1',
+            'children' => ['Foo', 'Bar', 'Baz'],
+        ]], [
+            new DocumentationPage('foo', ['navigation.group' => 'Group 1', 'navigation.category' => 'Group 2']),
+            new DocumentationPage('bar', ['navigation.group' => 'Group 1', 'navigation.category' => 'Group 2']),
+            new DocumentationPage('baz', ['navigation.group' => 'Group 1', 'navigation.category' => 'Group 2']),
+        ]);
+    }
+
+    // Sidebar configuration tests
+
+    public function testSidebarWithConfigOrder()
+    {
+        config(['docs.sidebar.order' => ['first', 'second', 'third']]);
+
+        $this->assertSidebarEquals(['First', 'Second', 'Third'], [
+            new DocumentationPage('first'),
+            new DocumentationPage('second'),
+            new DocumentationPage('third'),
+        ]);
+
+        config(['docs.sidebar.order' => ['third', 'second', 'first']]);
+
+        $this->assertSidebarEquals(['Third', 'Second', 'First'], [
+            new DocumentationPage('first'),
+            new DocumentationPage('second'),
+            new DocumentationPage('third'),
+        ]);
+    }
+
+    public function testSidebarWithConfigOrderHasInferredPriorities()
+    {
+        $this->assertSidebarEquals([
+            ['priority' => 999],
+            ['priority' => 999],
+            ['priority' => 999],
+        ], [
+            new DocumentationPage('first'),
+            new DocumentationPage('second'),
+            new DocumentationPage('third'),
+        ]);
+
+        config(['docs.sidebar.order' => ['first', 'second', 'third']]);
+
+        $this->assertSidebarEquals([
+            ['priority' => 500],
+            ['priority' => 501],
+            ['priority' => 502],
+        ], [
+            new DocumentationPage('first'),
+            new DocumentationPage('second'),
+            new DocumentationPage('third'),
+        ]);
+    }
+
+    public function testSidebarWithExplicitConfigOrder()
+    {
+        config(['docs.sidebar.order' => ['first' => 1, 'second' => 2, 'third' => 3]]);
+
+        $this->assertSidebarEquals(['First', 'Second', 'Third'], [
+            new DocumentationPage('first'),
+            new DocumentationPage('second'),
+            new DocumentationPage('third'),
+        ]);
+
+        config(['docs.sidebar.order' => ['first' => 3, 'second' => 2, 'third' => 1]]);
+
+        $this->assertSidebarEquals(['Third', 'Second', 'First'], [
+            new DocumentationPage('first'),
+            new DocumentationPage('second'),
+            new DocumentationPage('third'),
+        ]);
+
+        config(['docs.sidebar.order' => ['first' => 1, 'second' => 2, 'third' => 3]]);
+
+        $this->assertSidebarEquals([
+            ['label' => 'First', 'priority' => 1],
+            ['label' => 'Second', 'priority' => 2],
+            ['label' => 'Third', 'priority' => 3],
+        ], [
+            new DocumentationPage('first'),
+            new DocumentationPage('second'),
+            new DocumentationPage('third'),
+        ]);
+    }
+
+    public function testSidebarWithMixedConfigOrders()
+    {
+        config(['docs.sidebar.order' => ['foo', 'bar' => 650]]);
+
+        $this->assertSidebarEquals([
+            ['label' => 'Foo', 'priority' => 500],
+            ['label' => 'Bar', 'priority' => 650],
+            ['label' => 'Baz', 'priority' => 999],
+        ], [
+            new DocumentationPage('foo'),
+            new DocumentationPage('bar'),
+            new DocumentationPage('baz'),
+        ]);
+    }
+
+    public function testSidebarWithConfigLabels()
+    {
+        config(['docs.sidebar.labels' => ['foo' => 'First', 'bar' => 'Second', 'baz' => 'Third']]);
+
+        $this->assertSidebarEquals(['First', 'Second', 'Third'], [
+            new DocumentationPage('foo'),
+            new DocumentationPage('bar'),
+            new DocumentationPage('baz'),
+        ]);
+    }
+
+    public function testSidebarGroupLabelsCanBeSetInConfig()
+    {
+        config(['docs.sidebar_group_labels' => ['foo' => 'Bar']]);
+
+        $this->assertSidebarEquals([
+            ['label' => 'Bar', 'children' => ['Bar']],
+        ], [
+            new DocumentationPage('foo/bar'),
+        ]);
+    }
+
+    public function testSidebarWithConfigHidden()
+    {
+        config(['docs.sidebar.exclude' => ['foo', 'bar', 'baz']]);
+
+        $this->assertSidebarEquals([], [
+            new DocumentationPage('foo'),
+            new DocumentationPage('bar'),
+            new DocumentationPage('baz'),
+        ]);
+    }
+
+    // Sidebar subdirectory handling tests
+
+    public function testDocumentationPagesInSubdirectoriesAreAddedToSidebar()
+    {
+        $this->assertSidebarEquals([[
+            'label' => 'About',
+            'children' => ['Foo', 'Bar', 'Baz'],
+        ]], [
+            new DocumentationPage('about/foo'),
+            new DocumentationPage('about/bar'),
+            new DocumentationPage('about/baz'),
+        ]);
+    }
+
+    public function testPagesInSubdirectoriesAreAddedToSidebarRegardlessOfConfiguration()
+    {
+        $options = ['dropdown', 'flat', 'hidden'];
+
+        foreach ($options as $option) {
+            config(['docs.sidebar.subdirectories' => $option]);
+
+            $this->assertSidebarEquals([[
+                'label' => 'About',
+                'children' => ['Foo', 'Bar', 'Baz'],
+            ]], [
+                new DocumentationPage('about/foo'),
+                new DocumentationPage('about/bar'),
+                new DocumentationPage('about/baz'),
+            ]);
+        }
+    }
+
+    public function testSidebarItemsWithTheSameLabelAreNotFiltered()
+    {
+        $this->assertSidebarEquals(['Foo', 'Foo'], [
+            new DocumentationPage('foo', ['navigation.label' => 'Foo']),
+            new DocumentationPage('bar', ['navigation.label' => 'Foo']),
+        ]);
+    }
+
+    public function testSidebarItemsWithTheSameLabelAreNotFilteredForDuplicatesRegardlessOfCase()
+    {
+        $this->assertSidebarEquals(['Foo', 'Foo', 'FOO'], [
+            new DocumentationPage('foo'),
+            new DocumentationPage('Foo'),
+            new DocumentationPage('FOO'),
+        ]);
+
+        $this->assertSidebarEquals(['foo', 'Foo', 'FOO'], [
+            new DocumentationPage('foo', ['navigation.label' => 'foo']),
+            new DocumentationPage('bar', ['navigation.label' => 'Foo']),
+            new DocumentationPage('baz', ['navigation.label' => 'FOO']),
+        ]);
+    }
+
+    public function testSidebarItemsWithSameLabelButDifferentGroupsAreNotFiltered()
+    {
+        $this->assertSidebarEquals([
+            ['label' => 'Group 1', 'children' => ['Foo']],
+            ['label' => 'Group 2', 'children' => ['Foo']],
+        ], [
+            new DocumentationPage('foo', ['navigation.label' => 'Foo', 'navigation.group' => 'Group 1']),
+            new DocumentationPage('bar', ['navigation.label' => 'Foo', 'navigation.group' => 'Group 2']),
+        ]);
+    }
+
+    public function testSidebarDropdownItemsWithSameLabelButDifferentGroupsAreFiltered()
+    {
+        $this->assertSidebarEquals([
+            ['label' => 'One', 'children' => ['Foo']],
+            ['label' => 'Two', 'children' => ['Foo']],
+        ], [
+            new DocumentationPage('one/foo'),
+            new DocumentationPage('two/foo'),
+        ]);
+    }
+
+    public function testSidebarAutomaticDropdownItemsWithSameLabelButDifferentGroupsAreFiltered()
+    {
+        $this->assertSidebarEquals([
+            ['label' => 'One', 'children' => ['Foo']],
+            ['label' => 'Two', 'children' => ['Foo']],
+        ], [
+            new DocumentationPage('one/foo'),
+            new DocumentationPage('two/foo'),
+        ]);
+    }
+
+    public function testSidebarDropdownItemsWithSameLabelButDifferentGroupsAreNotFilteredWithFlattenedOutputPaths()
+    {
+        config(['docs.flattened_output_paths' => false]);
+
+        $this->assertSidebarEquals([
+            ['label' => 'One', 'children' => ['Foo']],
+            ['label' => 'Two', 'children' => ['Foo']],
+        ], [
+            new DocumentationPage('one/foo'),
+            new DocumentationPage('two/foo'),
+        ]);
+    }
+
+    public function testSidebarAutomaticDropdownItemsWithSameLabelButDifferentGroupsAreNotFilteredWithFlattenedOutputPaths()
+    {
+        config(['docs.flattened_output_paths' => false]);
+
+        $this->assertSidebarEquals([
+            ['label' => 'One', 'children' => ['Foo']],
+            ['label' => 'Two', 'children' => ['Foo']],
+        ], [
+            new DocumentationPage('one/foo'),
+            new DocumentationPage('two/foo'),
+        ]);
+    }
+
+    public function testSidebarItemGroupingIsCaseInsensitive()
+    {
+        $this->assertSidebarEquals(['Foo'], [
+            new DocumentationPage('foo', ['navigation.group' => 'foo']),
+            new DocumentationPage('bar', ['navigation.group' => 'Foo']),
+            new DocumentationPage('baz', ['navigation.group' => 'FOO']),
+        ]);
+    }
+
+    public function testSidebarItemGroupingIsNormalized()
+    {
+        $this->assertSidebarEquals(['Hello World'], [
+            new DocumentationPage('foo', ['navigation.group' => 'hello world']),
+            new DocumentationPage('bar', ['navigation.group' => 'hello-world']),
+            new DocumentationPage('baz', ['navigation.group' => 'hello_world']),
+            new DocumentationPage('qux', ['navigation.group' => 'Hello World']),
+        ]);
+    }
+
+    public function testSidebarLabelsCanBeSetInConfig()
+    {
+        config(['docs.sidebar_group_labels' => ['foo' => 'Hello world!']]);
+
+        $this->assertSidebarEquals(['Hello world!'], [
+            new DocumentationPage('foo', ['navigation.group' => 'foo']),
+        ]);
+    }
+
+    public function testSidebarGroupsAreSortedByLowestFoundPriorityInEachGroup()
+    {
+        $this->assertSidebarEquals([
+            'A', 'B', 'C',
+        ], [
+            new DocumentationPage('foo', ['navigation.group' => 'a', 'navigation.priority' => 1]),
+            new DocumentationPage('bar', ['navigation.group' => 'b', 'navigation.priority' => 2]),
+            new DocumentationPage('baz', ['navigation.group' => 'c', 'navigation.priority' => 3]),
+        ]);
+
+        $this->assertSidebarEquals([
+            'C', 'B', 'A',
+        ], [
+            new DocumentationPage('foo', ['navigation.group' => 'a', 'navigation.priority' => 3]),
+            new DocumentationPage('bar', ['navigation.group' => 'b', 'navigation.priority' => 2]),
+            new DocumentationPage('baz', ['navigation.group' => 'c', 'navigation.priority' => 1]),
+        ]);
+
+        $this->assertSidebarEquals([
+            'C', 'A', 'B',
+        ], [
+            new DocumentationPage('a', ['navigation.group' => 'a', 'navigation.priority' => 100]),
+            new DocumentationPage('b', ['navigation.group' => 'b', 'navigation.priority' => 200]),
+            new DocumentationPage('c', ['navigation.group' => 'c', 'navigation.priority' => 300]),
+            new DocumentationPage('d', ['navigation.group' => 'c', 'navigation.priority' => 10]),
+        ]);
+    }
+
+    public function testSidebarGroupsAreSortedByLowestFoundPriorityInEachGroupUnlessGroupPriorityIsLower()
+    {
+        $this->assertSidebarEquals([
+            'A', 'B', 'C',
+        ], [
+            new DocumentationPage('foo', ['navigation.group' => 'a', 'navigation.priority' => 10]),
+            new DocumentationPage('bar', ['navigation.group' => 'b', 'navigation.priority' => 20]),
+            new DocumentationPage('baz', ['navigation.group' => 'c', 'navigation.priority' => 30]),
+        ]);
+
+        $this->assertSidebarEquals([
+            'C', 'B', 'A',
+        ], [
+            new DocumentationPage('foo', ['navigation.group' => 'a', 'navigation.priority' => 30]),
+            new DocumentationPage('bar', ['navigation.group' => 'b', 'navigation.priority' => 20]),
+            new DocumentationPage('baz', ['navigation.group' => 'c', 'navigation.priority' => 10]),
+        ]);
+
+        config(['docs.sidebar.order' => ['a' => 5]]);
+
+        $this->assertSidebarEquals([
+            'A', 'C', 'B',
+        ], [
+            new DocumentationPage('foo', ['navigation.group' => 'a', 'navigation.priority' => 30]),
+            new DocumentationPage('bar', ['navigation.group' => 'b', 'navigation.priority' => 20]),
+            new DocumentationPage('baz', ['navigation.group' => 'c', 'navigation.priority' => 10]),
+        ]);
+    }
+
+    public function testAllSidebarItemsArePlacedInGroupsWhenAtLeastOneItemIsGrouped()
+    {
+        $this->assertSidebarEquals([
+            ['label' => 'Foo', 'children' => ['Grouped']],
+            ['label' => 'Other', 'children' => ['Ungrouped']],
+        ], [
+            new DocumentationPage('grouped', ['navigation.group' => 'foo']),
+            new DocumentationPage('ungrouped'),
+        ]);
+    }
+
+    public function testSidebarCanMixSubdirectoryGroupsWithFrontMatterGroups()
+    {
+        $this->assertSidebarEquals([
+            ['label' => 'Foo', 'children' => ['Bar', 'Baz']],
+        ], [
+            new DocumentationPage('foo/bar'),
+            new DocumentationPage('foo/baz', ['navigation.group' => 'foo']),
+        ]);
+    }
+
+    // Priority tests
+
+    public function testMainNavigationDropdownPriorityCanBeSetInConfig()
+    {
+        config(['hyde.navigation.subdirectories' => 'dropdown']);
+        config(['hyde.navigation.order' => ['foo' => 500]]);
+
+        $this->assertMenuEquals(
+            [['label' => 'Foo', 'priority' => 500]],
+            [new MarkdownPage('foo/bar')]
+        );
+    }
+
+    public function testMainNavigationDropdownPriorityCanBeSetInConfigUsingDifferingCases()
+    {
+        config(['hyde.navigation.subdirectories' => 'dropdown']);
+        config(['hyde.navigation.order' => ['hello-world' => 500]]);
+
+        $expected = [['label' => 'Hello World', 'priority' => 500]];
+        $this->assertMenuEquals($expected, [new MarkdownPage('Hello World/bar')]);
+        $this->assertMenuEquals($expected, [new MarkdownPage('hello-world/bar')]);
+        $this->assertMenuEquals($expected, [new MarkdownPage('hello world/bar')]);
+    }
+
+    public function testSidebarGroupPriorityCanBeSetInConfig()
+    {
+        config(['docs.sidebar.order' => ['foo' => 500]]);
+
+        $this->assertSidebarEquals(
+            [['label' => 'Foo', 'priority' => 500]],
+            [new DocumentationPage('foo/bar')]
+        );
+    }
+
+    public function testSidebarGroupPriorityCanBeSetInConfigUsingDifferingCases()
+    {
+        config(['docs.sidebar.order' => ['hello-world' => 500]]);
+
+        $expected = [['label' => 'Hello World', 'priority' => 500]];
+        $this->assertSidebarEquals($expected, [new DocumentationPage('Hello World/bar')]);
+        $this->assertSidebarEquals($expected, [new DocumentationPage('hello-world/bar')]);
+        $this->assertSidebarEquals($expected, [new DocumentationPage('hello world/bar')]);
+    }
+
+    // Label casing tests
+
+    public function testMainMenuNavigationItemCasing()
+    {
+        // These labels are based on the page titles, which are made from the file names, so we try to format them
+
+        $this->assertMenuEquals(['Hello World'], [new MarkdownPage('Hello World')]);
+        $this->assertMenuEquals(['Hello World'], [new MarkdownPage('hello-world')]);
+        $this->assertMenuEquals(['Hello World'], [new MarkdownPage('hello world')]);
+    }
+
+    public function testMainMenuNavigationItemCasingUsingFrontMatter()
+    {
+        // If the user explicitly sets the label, we should respect that and assume it's already formatted correctly
+
+        $this->assertMenuEquals(['Hello World'], [new MarkdownPage('foo', ['title' => 'Hello World'])]);
+        $this->assertMenuEquals(['hello-world'], [new MarkdownPage('foo', ['title' => 'hello-world'])]);
+        $this->assertMenuEquals(['hello world'], [new MarkdownPage('foo', ['title' => 'hello world'])]);
+
+        $this->assertMenuEquals(['Hello World'], [new MarkdownPage('foo', ['navigation.label' => 'Hello World'])]);
+        $this->assertMenuEquals(['hello-world'], [new MarkdownPage('foo', ['navigation.label' => 'hello-world'])]);
+        $this->assertMenuEquals(['hello world'], [new MarkdownPage('foo', ['navigation.label' => 'hello world'])]);
+    }
+
+    public function testMainMenuNavigationGroupCasing()
+    {
+        config(['hyde.navigation.subdirectories' => 'dropdown']);
+
+        // When using subdirectory groupings, we try to format them the same way as the page titles
+
+        $this->assertMenuEquals(['Hello World'], [new MarkdownPage('Hello World/foo')]);
+        $this->assertMenuEquals(['Hello World'], [new MarkdownPage('hello-world/foo')]);
+        $this->assertMenuEquals(['Hello World'], [new MarkdownPage('hello world/foo')]);
+    }
+
+    public function testMainMenuNavigationGroupCasingUsingFrontMatter()
+    {
+        // If the user explicitly sets the group, we should respect that and assume it's already formatted correctly
+
+        $this->assertMenuEquals(['Hello World'], [new MarkdownPage('foo', ['navigation.group' => 'Hello World'])]);
+        $this->assertMenuEquals(['Hello World'], [new MarkdownPage('foo', ['navigation.group' => 'hello-world'])]);
+        $this->assertMenuEquals(['Hello World'], [new MarkdownPage('foo', ['navigation.group' => 'hello world'])]);
+    }
+
+    public function testSidebarItemCasing()
+    {
+        // These labels are based on the page titles, which are made from the file names, so we try to format them
+
+        $this->assertSidebarEquals(['Hello World'], [new DocumentationPage('Hello World')]);
+        $this->assertSidebarEquals(['Hello World'], [new DocumentationPage('hello-world')]);
+        $this->assertSidebarEquals(['Hello World'], [new DocumentationPage('hello world')]);
+    }
+
+    public function testSidebarItemCasingUsingFrontMatter()
+    {
+        // If the user explicitly sets the label, we should respect that and assume it's already formatted correctly
+
+        $this->assertSidebarEquals(['Hello World'], [new DocumentationPage('foo', ['title' => 'Hello World'])]);
+        $this->assertSidebarEquals(['hello-world'], [new DocumentationPage('foo', ['title' => 'hello-world'])]);
+        $this->assertSidebarEquals(['hello world'], [new DocumentationPage('foo', ['title' => 'hello world'])]);
+
+        $this->assertSidebarEquals(['Hello World'], [new DocumentationPage('foo', ['navigation.label' => 'Hello World'])]);
+        $this->assertSidebarEquals(['hello-world'], [new DocumentationPage('foo', ['navigation.label' => 'hello-world'])]);
+        $this->assertSidebarEquals(['hello world'], [new DocumentationPage('foo', ['navigation.label' => 'hello world'])]);
+    }
+
+    public function testSidebarGroupCasing()
+    {
+        // When using subdirectory groupings, we try to format them the same way as the page titles
+
+        $this->assertSidebarEquals(['Hello World'], [new DocumentationPage('Hello World/foo')]);
+        $this->assertSidebarEquals(['Hello World'], [new DocumentationPage('hello-world/foo')]);
+        $this->assertSidebarEquals(['Hello World'], [new DocumentationPage('hello world/foo')]);
+    }
+
+    public function testSidebarGroupCasingUsingFrontMatter()
+    {
+        // If the user explicitly sets the group, we should respect that and assume it's already formatted correctly
+
+        $this->assertSidebarEquals(['Hello World'], [new DocumentationPage('foo', ['navigation.group' => 'Hello World'])]);
+        $this->assertSidebarEquals(['Hello World'], [new DocumentationPage('foo', ['navigation.group' => 'hello-world'])]);
+        $this->assertSidebarEquals(['Hello World'], [new DocumentationPage('foo', ['navigation.group' => 'hello world'])]);
+    }
+
+    // Testing helpers
+
+    protected function assertSidebarEquals(array $expected, array $menuPages): AssertableNavigationMenu
+    {
+        return $this->sidebar($menuPages)->assertEquals($expected);
+    }
+
+    protected function assertMenuEquals(array $expected, array $menuPages): AssertableNavigationMenu
+    {
+        return $this->menu($menuPages)->assertEquals($expected);
+    }
+
+    #[NoReturn]
+    protected function ddMenu(?array $menuPages = null, ?string $menu = 'menu'): void
+    {
+        if ($menu === 'sidebar') {
+            dd($this->sidebar($menuPages)->state());
+        }
+
+        dd($this->menu($menuPages)->state());
+    }
+
+    protected function menu(?array $withPages = null): AssertableNavigationMenu
+    {
+        if ($withPages) {
+            $this->withPages($withPages);
+        }
+
+        return new AssertableNavigationMenu($this);
+    }
+
+    protected function withPages(array $pages): static
+    {
+        $this->kernel->setRoutes(collect($pages)->map(fn (HydePage $page) => $page->getRoute()));
+
+        return $this;
+    }
+
+    protected function sidebar(?array $withPages = null): AssertableNavigationMenu
+    {
+        if ($withPages) {
+            $this->withPages($withPages);
+        }
+
+        return new AssertableNavigationMenu($this, true);
+    }
+}
+
+class TestNavigationItem
+{
+    public readonly string $label;
+    public readonly int $priority;
+    public readonly array $children;
+
+    public function __construct(string $label, int $priority, array $children)
+    {
+        $this->label = $label;
+        $this->priority = $priority;
+        $this->children = collect($children)->map(fn (NavigationItem|NavigationGroup $child) => $child->getLabel())->toArray();
+    }
+
+    public static function properties(): array
+    {
+        return ['label', 'priority', 'children'];
+    }
+}
+
+class AssertableNavigationMenu
+{
+    protected TestCase $test;
+    protected Collection $items;
+
+    public function __construct(TestCase $test, $sidebar = false)
+    {
+        $this->items = $sidebar
+            ? NavigationMenuGenerator::handle(DocumentationSidebar::class)->getItems()
+            : NavigationMenuGenerator::handle(MainNavigationMenu::class)->getItems();
+
+        $this->test = $test;
+    }
+
+    /** A simplified serialized format for comparisons */
+    public function state(): array
+    {
+        return $this->items->map(function (NavigationItem|NavigationGroup $item): TestNavigationItem {
+            return new TestNavigationItem($item->getLabel(), $item->getPriority(), $item instanceof NavigationGroup ? $item->getItems()->all() : []);
+        })->toArray();
+    }
+
+    public function getState(int $index): ?TestNavigationItem
+    {
+        return $this->state()[$index] ?? null;
+    }
+
+    public function ddState(): void
+    {
+        dd($this->state());
+    }
+
+    /**
+     * @param  array  $expected  The expected state format
+     * @param  bool  $strict  If false, missing array keys are ignored
+     */
+    public function assertEquals(array $expected, bool $strict = false): static
+    {
+        foreach ($expected as $index => $item) {
+            if (! is_array($item)) {
+                $item = ['label' => $item];
+            }
+
+            foreach (TestNavigationItem::properties() as $property) {
+                if ($this->getState($index) !== null) {
+                    if (isset($item[$property])) {
+                        $a = $item[$property];
+                        $b = $this->getState($index)->$property;
+
+                        if ($a !== $b) {
+                            dump([
+                                'error' => "Failed to match the expected value for '$property'",
+                                'expected' => $a,
+                                'actual' => $b,
+                                'menu' => $this->state(),
+                            ]);
+                        }
+
+                        $this->test->assertSame($a, $b, "Failed to match the expected value for '$property'");
+                    } elseif ($strict) {
+                        $this->test->fail("Missing array key '$property' in the expected state");
+                    }
+                }
+            }
+        }
+
+        $this->test->assertCount(count($expected), $this->state(), 'The expected state has a different count than the actual state'."\n".json_encode($this->state(), JSON_PRETTY_PRINT));
+
+        return $this;
+    }
+}
+
+class TestKernel extends HydeKernel
+{
+    protected ?RouteCollection $mockRoutes = null;
+
+    public function setRoutes(Collection $routes): void
+    {
+        $this->mockRoutes = RouteCollection::make($routes);
+    }
+
+    /** @return \Hyde\Foundation\Kernel\RouteCollection<string, \Hyde\Support\Models\Route> */
+    public function routes(): RouteCollection
+    {
+        return $this->mockRoutes ?? parent::routes();
+    }
+}
diff --git a/packages/framework/tests/Feature/DarkmodeFeatureTest.php b/packages/framework/tests/Feature/DarkmodeFeatureTest.php
index a1d710d25bd..bd5168d390e 100644
--- a/packages/framework/tests/Feature/DarkmodeFeatureTest.php
+++ b/packages/framework/tests/Feature/DarkmodeFeatureTest.php
@@ -4,6 +4,7 @@
 
 namespace Hyde\Framework\Testing\Feature;
 
+use Hyde\Hyde;
 use Hyde\Facades\Features;
 use Hyde\Pages\DocumentationPage;
 use Hyde\Testing\TestCase;
@@ -38,6 +39,8 @@ public function testHasDarkmode()
 
     public function testLayoutHasToggleButtonAndScriptWhenEnabled()
     {
+        Hyde::boot();
+
         Config::set('hyde.features', [
             Features::markdownPages(),
             Features::bladePages(),
@@ -75,6 +78,8 @@ public function testDocumentationPageHasToggleButtonAndScriptWhenEnabled()
 
     public function testDarkModeThemeButtonIsHiddenInLayoutsWhenDisabled()
     {
+        Hyde::boot();
+
         Config::set('hyde.features', [
             Features::markdownPages(),
             Features::bladePages(),
diff --git a/packages/framework/tests/Feature/HydePageTest.php b/packages/framework/tests/Feature/HydePageTest.php
index dde95fffb96..158e06e56c6 100644
--- a/packages/framework/tests/Feature/HydePageTest.php
+++ b/packages/framework/tests/Feature/HydePageTest.php
@@ -239,7 +239,7 @@ public function testNavigationMenuGroup()
         $this->assertNull((new MarkdownPage())->navigationMenuGroup());
         $this->assertNull((new MarkdownPost())->navigationMenuGroup());
         $this->assertNull((new HtmlPage())->navigationMenuGroup());
-        $this->assertSame('other', (new DocumentationPage())->navigationMenuGroup());
+        $this->assertNull((new DocumentationPage())->navigationMenuGroup());
         $this->assertSame('foo', DocumentationPage::make(matter: ['navigation' => ['group' => 'foo']])->navigationMenuGroup());
     }
 
diff --git a/packages/framework/tests/Feature/HydeServiceProviderTest.php b/packages/framework/tests/Feature/HydeServiceProviderTest.php
index d48d22933cb..c3b59226ee5 100644
--- a/packages/framework/tests/Feature/HydeServiceProviderTest.php
+++ b/packages/framework/tests/Feature/HydeServiceProviderTest.php
@@ -4,6 +4,9 @@
 
 namespace Hyde\Framework\Testing\Feature;
 
+use Hyde\Framework\Features\Navigation\MainNavigationMenu;
+use Hyde\Framework\Features\Navigation\DocumentationSidebar;
+use Illuminate\Contracts\Container\BindingResolutionException;
 use Hyde\Console\ConsoleServiceProvider;
 use Hyde\Framework\HydeServiceProvider;
 use Hyde\Framework\Services\AssetService;
@@ -22,6 +25,7 @@
  * @covers \Hyde\Framework\HydeServiceProvider
  * @covers \Hyde\Framework\Concerns\RegistersFileLocations
  * @covers \Hyde\Foundation\Providers\ConfigurationServiceProvider
+ * @covers \Hyde\Foundation\Providers\NavigationServiceProvider
  * @covers \Hyde\Foundation\Providers\ViewServiceProvider
  */
 class HydeServiceProviderTest extends TestCase
@@ -317,4 +321,46 @@ public function testOutputDirectoriesCanBeSetUsingKebabCaseClassNames()
         $this->assertEquals('foo', MarkdownPost::outputDirectory());
         $this->assertEquals('foo', DocumentationPage::outputDirectory());
     }
+
+    public function testCannotGetMainNavigationMenuFromContainerBeforeKernelIsBooted()
+    {
+        $this->expectException(BindingResolutionException::class);
+
+        app('navigation.main');
+    }
+
+    public function testCannotGetDocumentationSidebarFromContainerBeforeKernelIsBooted()
+    {
+        $this->expectException(BindingResolutionException::class);
+
+        app('navigation.sidebar');
+    }
+
+    public function testCanGetMainNavigationMenuFromContainer()
+    {
+        Hyde::boot();
+
+        $this->assertInstanceOf(MainNavigationMenu::class, app('navigation.main'));
+    }
+
+    public function testCanGetDocumentationSidebarFromContainer()
+    {
+        Hyde::boot();
+
+        $this->assertInstanceOf(DocumentationSidebar::class, app('navigation.sidebar'));
+    }
+
+    public function testCanGetMainNavigationMenuFromContainerUsingShorthand()
+    {
+        Hyde::boot();
+
+        $this->assertSame(app('navigation.main'), MainNavigationMenu::get());
+    }
+
+    public function testCanGetDocumentationSidebarFromContainerUsingShorthand()
+    {
+        Hyde::boot();
+
+        $this->assertSame(app('navigation.sidebar'), DocumentationSidebar::get());
+    }
 }
diff --git a/packages/framework/tests/Feature/MarkdownServiceTest.php b/packages/framework/tests/Feature/MarkdownServiceTest.php
index d3c68a835ef..aac0df233e0 100644
--- a/packages/framework/tests/Feature/MarkdownServiceTest.php
+++ b/packages/framework/tests/Feature/MarkdownServiceTest.php
@@ -192,7 +192,7 @@ public function testMethodCanEnablePermalinksIsAutomaticallyForDocumentationPage
     {
         $service = new MarkdownServiceTestClass(pageClass: DocumentationPage::class);
 
-        Config::set('docs.table_of_contents.enabled', true);
+        Config::set('docs.sidebar.table_of_contents.enabled', true);
 
         $this->assertTrue($service->canEnablePermalinks());
     }
diff --git a/packages/framework/tests/Feature/NavigationAPITest.php b/packages/framework/tests/Feature/NavigationAPITest.php
new file mode 100644
index 00000000000..f396837b0e9
--- /dev/null
+++ b/packages/framework/tests/Feature/NavigationAPITest.php
@@ -0,0 +1,267 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Testing\Feature;
+
+use Hyde\Hyde;
+use Hyde\Pages\BladePage;
+use Hyde\Testing\TestCase;
+use Illuminate\Support\Arr;
+use Hyde\Foundation\Facades\Routes;
+use Hyde\Testing\MocksKernelFeatures;
+use Illuminate\Support\Facades\Blade;
+use Hyde\Framework\Features\Navigation\NavigationMenu;
+use Hyde\Framework\Features\Navigation\NavigationItem;
+use Hyde\Framework\Features\Navigation\NavigationGroup;
+use Hyde\Framework\Features\Navigation\MainNavigationMenu;
+use Hyde\Framework\Features\Navigation\DocumentationSidebar;
+
+/**
+ * High level tests for the Navigation API to go along with the code-driven documentation.
+ *
+ * @see \Hyde\Framework\Features\Navigation\
+ *
+ * @covers \Hyde\Framework\Features\Navigation\NavigationMenu
+ * @covers \Hyde\Framework\Features\Navigation\NavigationItem
+ * @covers \Hyde\Framework\Features\Navigation\NavigationGroup
+ * @covers \Hyde\Framework\Features\Navigation\MainNavigationMenu
+ * @covers \Hyde\Framework\Features\Navigation\DocumentationSidebar
+ */
+class NavigationAPITest extends TestCase
+{
+    use MocksKernelFeatures;
+
+    public function testServiceContainerMenus()
+    {
+        // The NavigationServiceProvider binds the main and sidebar navigation menus into the service container.
+
+        Hyde::boot();
+
+        // You can access the menus from the service container.
+
+        $this->assertInstanceOf(MainNavigationMenu::class, app('navigation.main'));
+        $this->assertInstanceOf(DocumentationSidebar::class, app('navigation.sidebar'));
+
+        // You can also use the facade to access the menus.
+
+        $this->assertSame(app('navigation.main'), MainNavigationMenu::get());
+        $this->assertSame(app('navigation.sidebar'), DocumentationSidebar::get());
+    }
+
+    public function testNavigationItems()
+    {
+        // The NavigationItem class is an abstraction for a navigation menu item containing useful information like the destination, label, and priority.
+
+        // ## Creating Navigation Items
+
+        // There are two syntaxes for creating NavigationItem instances, you can use a standard constructor or the static create method.
+        // Both options provide the exact same signature and functionality, so it's just a matter of preference which one you use.
+
+        // The constructors take three parameters: the destination, the label, and the optional priority.
+        // The destination can be a Route instance, a route key string, or an external URL.
+
+        // Using a Route instance will automatically fill in the label and priority from the route's connected page.
+        $item = new NavigationItem(Routes::get('index'));
+        $this->assertData(['destination' => 'index.html', 'label' => 'Home', 'priority' => 0], $item);
+
+        // Using a route key provides the same functionality as using a Route instance.
+        // Make sure the route exists otherwise it will be treated as a link.
+        $item = new NavigationItem('index');
+        $this->assertEquals(new NavigationItem(Routes::get('index')), $item);
+
+        // Setting the label and/or priorities will override the page's data.
+        $item = new NavigationItem(Routes::get('index'), 'Custom Label', 10);
+        $this->assertData(['destination' => 'index.html', 'label' => 'Custom Label', 'priority' => 10], $item);
+
+        // You can also pass an external URL as the destination.
+        $item = new NavigationItem('https://example.com', 'External Link', 10);
+        $this->assertData(['destination' => 'https://example.com', 'label' => 'External Link', 'priority' => 10], $item);
+
+        // If you do not set a label for links, the label will default to the URL.
+        // And if you do not set a priority, it will default to 500.
+        $item = new NavigationItem('https://example.com');
+        $this->assertData(['destination' => 'https://example.com', 'label' => 'https://example.com', 'priority' => 500], $item);
+
+        // ## Navigation Item Methods
+
+        // There are a few helper methods available on NavigationItem instances.
+        $item = NavigationItem::create('index'); // Documentation ignores this line.
+
+        // Get the label of the item.
+        $this->assertSame('Home', $item->getLabel());
+
+        // Get the link of the item.
+        $this->assertSame('index.html', $item->getLink());
+
+        // You can also get the link by casting the item to a string.
+        $this->assertSame('index.html', (string) $item);
+
+        // Get the priority of the item.
+        $this->assertSame(0, $item->getPriority());
+
+        // Get the underlying Page instance of the item, if it exists. If the item is not a routed page (like direct URLs), this will return null.
+        $this->assertInstanceOf(BladePage::class, $item->getPage());
+
+        // Check if the item is active (the current page being rendered).
+        $this->assertFalse($item->isActive());
+    }
+
+    public function testNavigationMenus()
+    {
+        $this->withPages(['index', 'about', 'contact']);
+
+        // Navigation menus are created with an array of NavigationItem instances.
+        $menu = new NavigationMenu([
+            new NavigationItem(Routes::get('index'), 'Home'),
+            new NavigationItem(Routes::get('about'), 'About'),
+            new NavigationItem(Routes::get('contact'), 'Contact'),
+        ]);
+
+        $this->assertSame([
+            'Home' => 'index.html',
+            'About' => 'about.html',
+            'Contact' => 'contact.html',
+        ], $this->toArray($menu));
+
+        // You can get the items in the menu, which are automatically sorted by their priority.
+        foreach ($menu->getItems() as $item) {
+            $this->assertInstanceOf(NavigationItem::class, $item);
+
+            $this->assertIsString($item->getLabel());
+            $this->assertIsString($item->getLink());
+        }
+    }
+
+    public function testNavigationMenusWithGroups()
+    {
+        $this->withPages(['index', 'about', 'contact']);
+
+        // You can also add navigation groups to the menu, which can contain more items.
+        $menu = new NavigationMenu([
+            new NavigationItem(Routes::get('index'), 'Home'),
+            new NavigationGroup('About', [
+                new NavigationItem(Routes::get('about'), 'About Us'),
+                new NavigationItem(Routes::get('contact'), 'Contact Us'),
+            ]),
+        ]);
+
+        $this->assertSame([
+            'Home' => 'index.html',
+            'About' => [
+                'items' => [
+                    'About Us' => 'about.html',
+                    'Contact Us' => 'contact.html',
+                ],
+            ],
+        ], $this->toArray($menu));
+    }
+
+    public function testItemSorting()
+    {
+        // Test items without priorities are returned in the order they were added.
+
+        $menu = new NavigationMenu([
+            new NavigationItem('foo', 'foo'),
+            new NavigationItem('bar', 'bar'),
+            new NavigationItem('baz', 'baz'),
+        ]);
+
+        $this->assertSame([
+            'foo' => 'foo',
+            'bar' => 'bar',
+            'baz' => 'baz',
+        ], $this->toArray($menu));
+
+        // Test items with priorities are sorted by priority.
+
+        $menu = new NavigationMenu([
+            new NavigationItem('foo', 'foo', 10),
+            new NavigationItem('baz', 'baz', 15),
+            new NavigationItem('bar', 'bar', 5),
+        ]);
+
+        $this->assertSame([
+            'bar' => 'bar',
+            'foo' => 'foo',
+            'baz' => 'baz',
+        ], $this->toArray($menu));
+    }
+
+    public function testSocialMediaFooterLinkExample()
+    {
+        // To create our menu, we start by constructing a new NavigationMenu instance
+        $menu = new NavigationMenu();
+
+        // We can then add our social media links to the menu.
+        // We do this by adding NavigationItem instances to the menu.
+        $menu->add([
+            // The first parameter is the URL, and the second is the label.
+            NavigationItem::create('https://twitter.com/hydephp', 'Twitter'),
+            NavigationItem::create('https://github.com/hydephp', 'GitHub'),
+            NavigationItem::create('https://hydephp.com', 'Website'),
+        ]);
+
+        $rendered = Blade::render(/** @lang Blade */ <<<'BLADE'
+        {{-- We can now iterate over the menu items to render them in our footer. --}}
+        <footer>
+            <ul>
+                @foreach ($menu->getItems() as $item)
+                    <li><a href="{{ $item->getLink() }}">{{ $item->getLabel() }}</a></li>
+                @endforeach
+            </ul>
+        </footer>
+        BLADE, ['menu' => $menu]);
+
+        $this->assertSameIgnoringIndentation(<<<'HTML'
+        <footer>
+            <ul>
+                <li><a href="https://twitter.com/hydephp">Twitter</a></li>
+                <li><a href="https://github.com/hydephp">GitHub</a></li>
+                <li><a href="https://hydephp.com">Website</a></li>
+            </ul>
+        </footer>
+        HTML, $rendered);
+    }
+
+    protected function toArray(NavigationMenu $menu): array
+    {
+        return $menu->getItems()->mapWithKeys(function (NavigationItem|NavigationGroup $item): array {
+            if ($item instanceof NavigationGroup) {
+                return [
+                    $item->getLabel() => [
+                        'items' => Arr::mapWithKeys($item->getItems()->all(), function (NavigationItem $item): array {
+                            return [$item->getLabel() => $item->getLink()];
+                        }),
+                    ],
+                ];
+            }
+
+            return [$item->getLabel() => $item->getLink()];
+        })->all();
+    }
+
+    protected function assertSameIgnoringIndentation(string $expected, string $actual): void
+    {
+        $this->assertSame(
+            $this->removeIndentation(trim($expected)),
+            $this->removeIndentation(trim($actual))
+        );
+    }
+
+    protected function removeIndentation(string $actual): string
+    {
+        return implode("\n", array_map('trim', explode("\n", $actual)));
+    }
+
+    protected function assertData(array $expected, NavigationItem $item): void
+    {
+        $actual = [
+            'destination' => $item->getLink(),
+            'label' => $item->getLabel(),
+            'priority' => $item->getPriority(),
+        ];
+
+        $this->assertSame($expected, $actual);
+    }
+}
diff --git a/packages/framework/tests/Feature/NavigationMenuTest.php b/packages/framework/tests/Feature/NavigationMenuTest.php
index a36346e4d53..a98931a6e41 100644
--- a/packages/framework/tests/Feature/NavigationMenuTest.php
+++ b/packages/framework/tests/Feature/NavigationMenuTest.php
@@ -4,37 +4,42 @@
 
 namespace Hyde\Framework\Testing\Feature;
 
-use BadMethodCallException;
+use Hyde\Hyde;
 use Hyde\Support\Models\Route;
 use Hyde\Foundation\Facades\Routes;
-use Hyde\Framework\Features\Navigation\DropdownNavItem;
-use Hyde\Framework\Features\Navigation\NavigationMenu;
-use Hyde\Framework\Features\Navigation\NavItem;
-use Hyde\Pages\DocumentationPage;
+use Hyde\Framework\Features\Navigation\NavigationGroup;
+use Hyde\Framework\Features\Navigation\MainNavigationMenu;
+use Hyde\Framework\Features\Navigation\NavigationItem;
 use Hyde\Pages\MarkdownPage;
-use Hyde\Pages\MarkdownPost;
 use Hyde\Testing\TestCase;
 use Illuminate\Support\Collection;
+use Hyde\Framework\Features\Navigation\NavigationMenuGenerator;
 
 /**
  * @covers \Hyde\Framework\Features\Navigation\NavigationMenu
- * @covers \Hyde\Framework\Features\Navigation\BaseNavigationMenu
+ * @covers \Hyde\Framework\Features\Navigation\MainNavigationMenu
+ * @covers \Hyde\Framework\Features\Navigation\NavigationMenuGenerator
+ *
+ * @see \Hyde\Framework\Testing\Unit\NavigationMenuUnitTest
  */
 class NavigationMenuTest extends TestCase
 {
     public function testConstructor()
     {
-        $this->assertInstanceOf(NavigationMenu::class, NavigationMenu::create());
+        $this->assertInstanceOf(MainNavigationMenu::class, $this->createNavigationMenu());
     }
 
-    public function testGenerateMethodCreatesCollectionOfNavItems()
+    public function testGenerateMethodCreatesCollectionOfNavigationItems()
     {
-        $this->assertInstanceOf(Collection::class, NavigationMenu::create()->items);
+        $this->assertInstanceOf(Collection::class, $this->createNavigationMenu()->getItems());
+        $this->assertContainsOnlyInstancesOf(NavigationItem::class, $this->createNavigationMenu()->getItems());
     }
 
     public function testGetItemsReturnsItems()
     {
-        $this->assertEquals(NavigationMenu::create()->items, NavigationMenu::create()->getItems());
+        $this->assertEquals(collect([
+            NavigationItem::create(Routes::get('index')),
+        ]), $this->createNavigationMenu()->getItems());
     }
 
     public function testItemsAreSortedByPriority()
@@ -43,7 +48,7 @@ public function testItemsAreSortedByPriority()
         Routes::addRoute(new Route(new MarkdownPage('bar', ['navigation.priority' => 2])));
         Routes::addRoute(new Route(new MarkdownPage('baz', ['navigation.priority' => 3])));
 
-        $this->assertSame(['Home', 'Foo', 'Bar', 'Baz'], NavigationMenu::create()->items->pluck('label')->toArray());
+        $this->assertSame(['Home', 'Foo', 'Bar', 'Baz'], $this->createNavigationMenu()->getItems()->map(fn ($item) => $item->getLabel())->toArray());
     }
 
     public function testItemsWithHiddenPropertySetToTrueAreNotAdded()
@@ -51,7 +56,7 @@ public function testItemsWithHiddenPropertySetToTrueAreNotAdded()
         Routes::addRoute(new Route(new MarkdownPage('foo', ['navigation.hidden' => true])));
         Routes::addRoute(new Route(new MarkdownPage('bar', ['navigation.hidden' => false])));
 
-        $this->assertSame(['Home', 'Bar'], NavigationMenu::create()->items->pluck('label')->toArray());
+        $this->assertSame(['Home', 'Bar'], $this->createNavigationMenu()->getItems()->map(fn ($item) => $item->getLabel())->toArray());
     }
 
     public function testCreatedCollectionIsSortedByNavigationMenuPriority()
@@ -59,119 +64,117 @@ public function testCreatedCollectionIsSortedByNavigationMenuPriority()
         $this->file('_pages/foo.md');
         $this->file('_docs/index.md');
 
-        $menu = NavigationMenu::create();
+        $menu = $this->createNavigationMenu();
 
         $expected = collect([
-            NavItem::fromRoute(Routes::get('index')),
-            NavItem::fromRoute(Routes::get('foo')),
-            NavItem::fromRoute(Routes::get('docs/index')),
+            NavigationItem::create(Routes::get('index')),
+            NavigationItem::create(Routes::get('foo')),
+            NavigationItem::create(Routes::get('docs/index')),
         ]);
 
-        $this->assertCount(count($expected), $menu->items);
-        $this->assertEquals($expected, $menu->items);
+        $this->assertCount(count($expected), $menu->getItems());
+        $this->assertEquals($expected, $menu->getItems());
     }
 
     public function testIsSortedAutomaticallyWhenUsingNavigationMenuCreate()
     {
         $this->file('_pages/foo.md');
 
-        $menu = NavigationMenu::create();
+        $menu = $this->createNavigationMenu();
 
         $expected = collect([
-            NavItem::fromRoute(Routes::get('index')),
-            NavItem::fromRoute(Routes::get('foo')),
+            NavigationItem::create(Routes::get('index')),
+            NavigationItem::create(Routes::get('foo')),
         ]);
 
-        $this->assertCount(count($expected), $menu->items);
-        $this->assertEquals($expected, $menu->items);
-    }
-
-    public function testCollectionOnlyContainsNavItems()
-    {
-        $this->assertContainsOnlyInstancesOf(NavItem::class, NavigationMenu::create()->items);
+        $this->assertCount(count($expected), $menu->getItems());
+        $this->assertEquals($expected, $menu->getItems());
     }
 
     public function testExternalLinkCanBeAddedInConfig()
     {
-        config(['hyde.navigation.custom' => [NavItem::forLink('https://example.com', 'foo')]]);
+        config(['hyde.navigation.custom' => [NavigationItem::create('https://example.com', 'foo')]]);
 
-        $menu = NavigationMenu::create();
+        $menu = $this->createNavigationMenu();
 
         $expected = collect([
-            NavItem::fromRoute(Routes::get('index')),
-            NavItem::forLink('https://example.com', 'foo'),
+            NavigationItem::create(Routes::get('index')),
+            NavigationItem::create('https://example.com', 'foo'),
         ]);
 
-        $this->assertCount(count($expected), $menu->items);
-        $this->assertEquals($expected, $menu->items);
+        $this->assertCount(count($expected), $menu->getItems());
+        $this->assertEquals($expected, $menu->getItems());
     }
 
     public function testPathLinkCanBeAddedInConfig()
     {
-        config(['hyde.navigation.custom' => [NavItem::forLink('foo', 'foo')]]);
+        config(['hyde.navigation.custom' => [NavigationItem::create('foo', 'foo')]]);
 
-        $menu = NavigationMenu::create();
+        $menu = $this->createNavigationMenu();
 
         $expected = collect([
-            NavItem::fromRoute(Routes::get('index')),
-            NavItem::forLink('foo', 'foo'),
+            NavigationItem::create(Routes::get('index')),
+            NavigationItem::create('foo', 'foo'),
         ]);
 
-        $this->assertCount(count($expected), $menu->items);
-        $this->assertEquals($expected, $menu->items);
+        $this->assertCount(count($expected), $menu->getItems());
+        $this->assertEquals($expected, $menu->getItems());
     }
 
-    public function testDuplicatesAreRemovedWhenAddingInConfig()
+    public function testDuplicatesAreNotRemovedWhenAddingInConfig()
     {
         config(['hyde.navigation.custom' => [
-            NavItem::forLink('foo', 'foo'),
-            NavItem::forLink('foo', 'foo'),
+            NavigationItem::create('foo', 'foo'),
+            NavigationItem::create('foo', 'foo'),
         ]]);
 
-        $menu = NavigationMenu::create();
+        $menu = $this->createNavigationMenu();
 
         $expected = collect([
-            NavItem::fromRoute(Routes::get('index')),
-            NavItem::forLink('foo', 'foo'),
+            NavigationItem::create(Routes::get('index')),
+            NavigationItem::create('foo', 'foo'),
+            NavigationItem::create('foo', 'foo'),
         ]);
 
-        $this->assertCount(count($expected), $menu->items);
-        $this->assertEquals($expected, $menu->items);
+        $this->assertCount(count($expected), $menu->getItems());
+        $this->assertEquals($expected, $menu->getItems());
     }
 
-    public function testDuplicatesAreRemovedWhenAddingInConfigRegardlessOfDestination()
+    public function testDuplicatesAreNotRemovedWhenAddingInConfigRegardlessOfDestination()
     {
         config(['hyde.navigation.custom' => [
-            NavItem::forLink('foo', 'foo'),
-            NavItem::forLink('bar', 'foo'),
+            NavigationItem::create('foo', 'foo'),
+            NavigationItem::create('bar', 'foo'),
         ]]);
 
-        $menu = NavigationMenu::create();
+        $menu = $this->createNavigationMenu();
 
         $expected = collect([
-            NavItem::fromRoute(Routes::get('index')),
-            NavItem::forLink('foo', 'foo'),
+            NavigationItem::create(Routes::get('index')),
+            NavigationItem::create('foo', 'foo'),
+            NavigationItem::create('bar', 'foo'),
         ]);
 
-        $this->assertCount(count($expected), $menu->items);
-        $this->assertEquals($expected, $menu->items);
+        $this->assertCount(count($expected), $menu->getItems());
+        $this->assertEquals($expected, $menu->getItems());
     }
 
     public function testConfigItemsTakePrecedenceOverGeneratedItems()
     {
         $this->file('_pages/foo.md');
 
-        config(['hyde.navigation.custom' => [NavItem::forLink('bar', 'Foo')]]);
+        config(['hyde.navigation.custom' => [NavigationItem::create('bar', 'Foo')]]);
 
-        $menu = NavigationMenu::create();
+        $menu = $this->createNavigationMenu();
 
         $expected = collect([
-            NavItem::fromRoute(Routes::get('index')),
-            NavItem::forLink('bar', 'Foo'),
+            NavigationItem::create(Routes::get('index')),
+            NavigationItem::create('bar', 'Foo'),
+            NavigationItem::create(Routes::get('foo')),
         ]);
 
-        $this->assertCount(count($expected), $menu->items);
-        $this->assertEquals($expected, $menu->items);
+        $this->assertCount(count($expected), $menu->getItems());
+        $this->assertEquals($expected, $menu->getItems());
     }
 
     public function testDocumentationPagesThatAreNotIndexAreNotAddedToTheMenu()
@@ -179,15 +182,15 @@ public function testDocumentationPagesThatAreNotIndexAreNotAddedToTheMenu()
         $this->file('_docs/foo.md');
         $this->file('_docs/index.md');
 
-        $menu = NavigationMenu::create();
+        $menu = $this->createNavigationMenu();
 
         $expected = collect([
-            NavItem::fromRoute(Routes::get('index')),
-            NavItem::fromRoute(Routes::get('docs/index')),
+            NavigationItem::create(Routes::get('index')),
+            NavigationItem::create(Routes::get('docs/index')),
         ]);
 
-        $this->assertCount(count($expected), $menu->items);
-        $this->assertEquals($expected, $menu->items);
+        $this->assertCount(count($expected), $menu->getItems());
+        $this->assertEquals($expected, $menu->getItems());
     }
 
     public function testPagesInSubdirectoriesAreNotAddedToTheNavigationMenu()
@@ -195,11 +198,11 @@ public function testPagesInSubdirectoriesAreNotAddedToTheNavigationMenu()
         $this->directory('_pages/foo');
         $this->file('_pages/foo/bar.md');
 
-        $menu = NavigationMenu::create();
-        $expected = collect([NavItem::fromRoute(Routes::get('index'))]);
+        $menu = $this->createNavigationMenu();
+        $expected = collect([NavigationItem::create(Routes::get('index'))]);
 
-        $this->assertCount(count($expected), $menu->items);
-        $this->assertEquals($expected, $menu->items);
+        $this->assertCount(count($expected), $menu->getItems());
+        $this->assertEquals($expected, $menu->getItems());
     }
 
     public function testPagesInSubdirectoriesCanBeAddedToTheNavigationMenuWithConfigFlatSetting()
@@ -208,14 +211,14 @@ public function testPagesInSubdirectoriesCanBeAddedToTheNavigationMenuWithConfig
         $this->directory('_pages/foo');
         $this->file('_pages/foo/bar.md');
 
-        $menu = NavigationMenu::create();
+        $menu = $this->createNavigationMenu();
         $expected = collect([
-            NavItem::fromRoute(Routes::get('index')),
-            NavItem::fromRoute(Routes::get('foo/bar')),
+            NavigationItem::create(Routes::get('index')),
+            NavigationItem::create(Routes::get('foo/bar')),
         ]);
 
-        $this->assertCount(count($expected), $menu->items);
-        $this->assertEquals($expected, $menu->items);
+        $this->assertCount(count($expected), $menu->getItems());
+        $this->assertEquals($expected, $menu->getItems());
     }
 
     public function testPagesInSubdirectoriesAreNotAddedToTheNavigationMenuWithConfigDropdownSetting()
@@ -224,163 +227,54 @@ public function testPagesInSubdirectoriesAreNotAddedToTheNavigationMenuWithConfi
         $this->directory('_pages/foo');
         $this->file('_pages/foo/bar.md');
 
-        $menu = NavigationMenu::create();
+        $menu = $this->createNavigationMenu();
         $expected = collect([
-            NavItem::fromRoute(Routes::get('index')),
-            DropdownNavItem::fromArray('foo', [
-                NavItem::fromRoute(Routes::get('foo/bar')),
+            NavigationItem::create(Routes::get('index')),
+            NavigationGroup::create('Foo', [
+                NavigationItem::create(Routes::get('foo/bar')),
             ]),
         ]);
 
-        $this->assertCount(count($expected), $menu->items);
-        $this->assertEquals($expected, $menu->items);
-    }
-
-    public function testHasDropdownsReturnsFalseWhenThereAreNoDropdowns()
-    {
-        config(['hyde.navigation.subdirectories' => 'dropdown']);
-        $menu = NavigationMenu::create();
-        $this->assertFalse($menu->hasDropdowns());
-    }
-
-    public function testHasDropdownsReturnsTrueWhenThereAreDropdowns()
-    {
-        config(['hyde.navigation.subdirectories' => 'dropdown']);
-        Routes::addRoute((new MarkdownPage('foo/bar'))->getRoute());
-        $menu = NavigationMenu::create();
-        $this->assertTrue($menu->hasDropdowns());
-    }
-
-    public function testHasDropdownsAlwaysReturnsFalseWhenDropdownsAreDisabled()
-    {
-        Routes::addRoute((new MarkdownPage('foo/bar'))->getRoute());
-        $this->assertFalse(NavigationMenu::create()->hasDropdowns());
-    }
-
-    public function testGetDropdownsReturnsEmptyArrayThereAreNoDropdowns()
-    {
-        config(['hyde.navigation.subdirectories' => 'dropdown']);
-        $menu = NavigationMenu::create();
-        $this->assertCount(0, $menu->getDropdowns());
-        $this->assertSame([], $menu->getDropdowns());
-    }
-
-    public function testGetDropdownsReturnsCorrectArrayWhenThereAreDropdowns()
-    {
-        config(['hyde.navigation.subdirectories' => 'dropdown']);
-        Routes::addRoute((new MarkdownPage('foo/bar'))->getRoute());
-        $menu = NavigationMenu::create();
-        $this->assertCount(1, $menu->getDropdowns());
-
-        $this->assertEquals([
-            DropdownNavItem::fromArray('foo', [
-                NavItem::fromRoute((new MarkdownPage('foo/bar'))->getRoute()),
-            ]), ], $menu->getDropdowns());
-    }
-
-    public function testGetDropdownsWithMultipleItems()
-    {
-        config(['hyde.navigation.subdirectories' => 'dropdown']);
-
-        Routes::addRoute((new MarkdownPage('foo/bar'))->getRoute());
-        Routes::addRoute((new MarkdownPage('foo/baz'))->getRoute());
-        $menu = NavigationMenu::create();
-
-        $this->assertCount(1, $menu->getDropdowns());
-
-        $this->assertEquals([
-            DropdownNavItem::fromArray('foo', [
-                NavItem::fromRoute((new MarkdownPage('foo/bar'))->getRoute()),
-                NavItem::fromRoute((new MarkdownPage('foo/baz'))->getRoute()),
-            ]),
-        ], $menu->getDropdowns());
+        $this->assertCount(count($expected), $menu->getItems());
+        $this->assertEquals($expected, $menu->getItems());
     }
 
-    public function testGetDropdownsWithMultipleDropdowns()
+    public function testPagesInDropdownsDoNotGetAddedToTheMainNavigation()
     {
         config(['hyde.navigation.subdirectories' => 'dropdown']);
 
-        Routes::addRoute((new MarkdownPage('foo/bar'))->getRoute());
-        Routes::addRoute((new MarkdownPage('foo/baz'))->getRoute());
-        Routes::addRoute((new MarkdownPage('cat/hat'))->getRoute());
-
-        $menu = NavigationMenu::create();
-
-        $this->assertCount(2, $menu->getDropdowns());
+        Routes::push((new MarkdownPage('foo'))->getRoute());
+        Routes::push((new MarkdownPage('bar/baz'))->getRoute());
+        $menu = $this->createNavigationMenu();
 
+        $this->assertCount(3, $menu->getItems());
         $this->assertEquals([
-            DropdownNavItem::fromArray('foo', [
-                NavItem::fromRoute((new MarkdownPage('foo/bar'))->getRoute()),
-                NavItem::fromRoute((new MarkdownPage('foo/baz'))->getRoute()),
-            ]),
-            DropdownNavItem::fromArray('cat', [
-                NavItem::fromRoute((new MarkdownPage('cat/hat'))->getRoute()),
+            NavigationItem::create(Routes::get('index')),
+            NavigationItem::create((new MarkdownPage('foo'))->getRoute()),
+            NavigationGroup::create('Bar', [
+                NavigationItem::create((new MarkdownPage('bar/baz'))->getRoute()),
             ]),
-        ], $menu->getDropdowns());
+        ], $menu->getItems()->all());
     }
 
-    public function testGetDropdownsThrowsExceptionWhenDisabled()
+    public function testCanGetMenuFromServiceContainer()
     {
-        $this->expectException(BadMethodCallException::class);
-        $this->expectExceptionMessage('Dropdowns are not enabled. Enable it by setting `hyde.navigation.subdirectories` to `dropdown`.');
-
-        $menu = NavigationMenu::create();
-        $menu->getDropdowns();
+        $this->assertEquals($this->createNavigationMenu(), app('navigation.main'));
     }
 
-    public function testDocumentationPagesDoNotGetAddedToDropdowns()
+    public function testCanAddItemsToMainNavigationMenuResolvedFromContainer()
     {
-        config(['hyde.navigation.subdirectories' => 'dropdown']);
+        Hyde::boot();
 
-        Routes::addRoute((new DocumentationPage('foo'))->getRoute());
-        Routes::addRoute((new DocumentationPage('bar/baz'))->getRoute());
-        $menu = NavigationMenu::create();
+        $navigation = app('navigation.main');
+        $navigation->add(new NavigationItem('/foo', 'Foo'));
 
-        $this->assertFalse($menu->hasDropdowns());
-        $this->assertCount(0, $menu->getDropdowns());
+        $this->assertCount(2, $navigation->getItems());
+        $this->assertSame('Foo', $navigation->getItems()->last()->getLabel());
     }
 
-    public function testBlogPostsDoNotGetAddedToDropdowns()
+    protected function createNavigationMenu(): MainNavigationMenu
     {
-        config(['hyde.navigation.subdirectories' => 'dropdown']);
-
-        Routes::addRoute((new MarkdownPost('foo'))->getRoute());
-        Routes::addRoute((new MarkdownPost('bar/baz'))->getRoute());
-
-        $menu = NavigationMenu::create();
-        $this->assertFalse($menu->hasDropdowns());
-        $this->assertCount(0, $menu->getDropdowns());
-    }
-
-    public function testPagesInDropdownsDoNotGetAddedToTheMainNavigation()
-    {
-        config(['hyde.navigation.subdirectories' => 'dropdown']);
-
-        Routes::push((new MarkdownPage('foo'))->getRoute());
-        Routes::push((new MarkdownPage('bar/baz'))->getRoute());
-        $menu = NavigationMenu::create();
-
-        $this->assertCount(3, $menu->items);
-        $this->assertEquals([
-            NavItem::fromRoute(Routes::get('index')),
-            NavItem::fromRoute((new MarkdownPage('foo'))->getRoute()),
-            DropdownNavItem::fromArray('bar', [
-                NavItem::fromRoute((new MarkdownPage('bar/baz'))->getRoute()),
-            ]),
-        ], $menu->items->all());
-    }
-
-    public function testDropdownMenuItemsAreSortedByPriority()
-    {
-        config(['hyde.navigation.subdirectories' => 'dropdown']);
-
-        Routes::addRoute(new Route(new MarkdownPage('foo/foo', ['navigation.priority' => 1])));
-        Routes::addRoute(new Route(new MarkdownPage('foo/bar', ['navigation.priority' => 2])));
-        Routes::addRoute(new Route(new MarkdownPage('foo/baz', ['navigation.priority' => 3])));
-
-        $menu = NavigationMenu::create();
-        $dropdowns = $menu->getDropdowns();
-
-        $this->assertSame(['Foo', 'Bar', 'Baz'], $dropdowns[0]->getItems()->pluck('label')->toArray());
+        return NavigationMenuGenerator::handle(MainNavigationMenu::class);
     }
 }
diff --git a/packages/framework/tests/Feature/Services/DocumentationSidebarTest.php b/packages/framework/tests/Feature/Services/DocumentationSidebarTest.php
index 54290a8e34d..a1971486787 100644
--- a/packages/framework/tests/Feature/Services/DocumentationSidebarTest.php
+++ b/packages/framework/tests/Feature/Services/DocumentationSidebarTest.php
@@ -7,20 +7,27 @@
 use Hyde\Facades\Filesystem;
 use Hyde\Foundation\Facades\Routes;
 use Hyde\Framework\Actions\ConvertsArrayToFrontMatter;
+use Hyde\Framework\Features\Navigation\NavigationGroup;
 use Hyde\Framework\Features\Navigation\DocumentationSidebar;
-use Hyde\Framework\Features\Navigation\NavItem;
+use Hyde\Framework\Features\Navigation\NavigationItem;
 use Hyde\Hyde;
 use Hyde\Pages\DocumentationPage;
 use Hyde\Support\Facades\Render;
 use Hyde\Testing\TestCase;
 use Illuminate\Support\Facades\Config;
 use Illuminate\Support\Facades\File;
+use Hyde\Framework\Features\Navigation\NavigationMenuGenerator;
 
 /**
  * @covers \Hyde\Framework\Features\Navigation\DocumentationSidebar
+ * @covers \Hyde\Framework\Features\Navigation\NavigationMenuGenerator
+ * @covers \Hyde\Framework\Features\Navigation\NavigationMenu
  * @covers \Hyde\Framework\Factories\Concerns\HasFactory
  * @covers \Hyde\Framework\Factories\NavigationDataFactory
- * @covers \Hyde\Framework\Features\Navigation\NavItem
+ * @covers \Hyde\Framework\Features\Navigation\NavigationItem
+ *
+ * @see \Hyde\Framework\Testing\Unit\DocumentationSidebarUnitTest
+ * @see \Hyde\Framework\Testing\Unit\DocumentationSidebarGetActiveGroupUnitTest
  */
 class DocumentationSidebarTest extends TestCase
 {
@@ -40,7 +47,7 @@ protected function tearDown(): void
 
     public function testSidebarCanBeCreated()
     {
-        $sidebar = DocumentationSidebar::create();
+        $sidebar = NavigationMenuGenerator::handle(DocumentationSidebar::class);
 
         $this->assertInstanceOf(DocumentationSidebar::class, $sidebar);
     }
@@ -49,9 +56,9 @@ public function testSidebarItemsAreAddedAutomatically()
     {
         $this->createTestFiles();
 
-        $sidebar = DocumentationSidebar::create();
+        $sidebar = NavigationMenuGenerator::handle(DocumentationSidebar::class);
 
-        $this->assertCount(5, $sidebar->items);
+        $this->assertCount(5, $sidebar->getItems());
     }
 
     public function testIndexPageIsRemovedFromSidebar()
@@ -59,8 +66,8 @@ public function testIndexPageIsRemovedFromSidebar()
         $this->createTestFiles();
         Filesystem::touch('_docs/index.md');
 
-        $sidebar = DocumentationSidebar::create();
-        $this->assertCount(5, $sidebar->items);
+        $sidebar = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertCount(5, $sidebar->getItems());
     }
 
     public function testFilesWithFrontMatterHiddenSetToTrueAreRemovedFromSidebar()
@@ -68,30 +75,30 @@ public function testFilesWithFrontMatterHiddenSetToTrueAreRemovedFromSidebar()
         $this->createTestFiles();
         File::put(Hyde::path('_docs/test.md'), "---\nnavigation:\n    hidden: true\n---\n\n# Foo");
 
-        $sidebar = DocumentationSidebar::create();
-        $this->assertCount(5, $sidebar->items);
+        $sidebar = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertCount(5, $sidebar->getItems());
     }
 
     public function testSidebarIsOrderedAlphabeticallyWhenNoOrderIsSetInConfig()
     {
-        Config::set('docs.sidebar_order', []);
+        Config::set('docs.sidebar.order', []);
         Filesystem::touch('_docs/a.md');
         Filesystem::touch('_docs/b.md');
         Filesystem::touch('_docs/c.md');
 
         $this->assertEquals(
             collect([
-                NavItem::fromRoute(Routes::get('docs/a'), priority: 999),
-                NavItem::fromRoute(Routes::get('docs/b'), priority: 999),
-                NavItem::fromRoute(Routes::get('docs/c'), priority: 999),
+                NavigationItem::create(Routes::get('docs/a'), priority: 999),
+                NavigationItem::create(Routes::get('docs/b'), priority: 999),
+                NavigationItem::create(Routes::get('docs/c'), priority: 999),
             ]),
-            DocumentationSidebar::create()->items
+            NavigationMenuGenerator::handle(DocumentationSidebar::class)->getItems()
         );
     }
 
     public function testSidebarIsOrderedByPriorityWhenPriorityIsSetInConfig()
     {
-        Config::set('docs.sidebar_order', [
+        Config::set('docs.sidebar.order', [
             'c',
             'b',
             'a',
@@ -102,11 +109,11 @@ public function testSidebarIsOrderedByPriorityWhenPriorityIsSetInConfig()
 
         $this->assertEquals(
             collect([
-                NavItem::fromRoute(Routes::get('docs/c'), priority: 250 + 250),
-                NavItem::fromRoute(Routes::get('docs/b'), priority: 250 + 251),
-                NavItem::fromRoute(Routes::get('docs/a'), priority: 250 + 252),
+                NavigationItem::create(Routes::get('docs/c'), priority: 250 + 250),
+                NavigationItem::create(Routes::get('docs/b'), priority: 250 + 251),
+                NavigationItem::create(Routes::get('docs/a'), priority: 250 + 252),
             ]),
-            DocumentationSidebar::create()->items
+            NavigationMenuGenerator::handle(DocumentationSidebar::class)->getItems()
         );
     }
 
@@ -114,21 +121,21 @@ public function testSidebarItemPriorityCanBeSetInFrontMatter()
     {
         $this->makePage('foo', ['navigation.priority' => 25]);
 
-        $this->assertEquals(25, DocumentationSidebar::create()->items->first()->priority);
+        $this->assertEquals(25, NavigationMenuGenerator::handle(DocumentationSidebar::class)->getItems()->first()->getPriority());
     }
 
     public function testSidebarItemPrioritySetInConfigOverridesFrontMatter()
     {
         $this->makePage('foo', ['navigation.priority' => 25]);
 
-        Config::set('docs.sidebar_order', ['foo']);
+        Config::set('docs.sidebar.order', ['foo']);
 
-        $this->assertEquals(25, DocumentationSidebar::create()->items->first()->priority);
+        $this->assertEquals(25, NavigationMenuGenerator::handle(DocumentationSidebar::class)->getItems()->first()->getPriority());
     }
 
     public function testSidebarPrioritiesCanBeSetInBothFrontMatterAndConfig()
     {
-        Config::set('docs.sidebar_order', [
+        Config::set('docs.sidebar.order', [
             'first',
             'third',
             'second',
@@ -141,11 +148,11 @@ public function testSidebarPrioritiesCanBeSetInBothFrontMatterAndConfig()
 
         $this->assertEquals(
             collect([
-                NavItem::fromRoute(Routes::get('docs/first'), priority: 250 + 250),
-                NavItem::fromRoute(Routes::get('docs/second'), priority: 250 + 252),
-                NavItem::fromRoute(Routes::get('docs/third'), priority: 250 + 300),
+                NavigationItem::create(Routes::get('docs/first'), priority: 250 + 250),
+                NavigationItem::create(Routes::get('docs/second'), priority: 250 + 252),
+                NavigationItem::create(Routes::get('docs/third'), priority: 250 + 300),
             ]),
-            DocumentationSidebar::create()->items
+            NavigationMenuGenerator::handle(DocumentationSidebar::class)->getItems()
         );
     }
 
@@ -153,19 +160,21 @@ public function testGroupCanBeSetInFrontMatter()
     {
         $this->makePage('foo', ['navigation.group' => 'bar']);
 
-        $this->assertEquals('bar', DocumentationSidebar::create()->items->first()->getGroup());
+        /** @var NavigationItem $item */
+        $item = collect(NavigationMenuGenerator::handle(DocumentationSidebar::class)->getItems()->first()->getItems())->first();
+        $this->assertSame('bar', $item->getPage()->navigationMenuGroup());
     }
 
     public function testHasGroupsReturnsFalseWhenThereAreNoGroups()
     {
-        $this->assertFalse(DocumentationSidebar::create()->hasGroups());
+        $this->assertFalse(NavigationMenuGenerator::handle(DocumentationSidebar::class)->hasGroups());
     }
 
     public function testHasGroupsReturnsTrueWhenThereAreGroups()
     {
         $this->makePage('foo', ['navigation.group' => 'bar']);
 
-        $this->assertTrue(DocumentationSidebar::create()->hasGroups());
+        $this->assertTrue(NavigationMenuGenerator::handle(DocumentationSidebar::class)->hasGroups());
     }
 
     public function testHasGroupsReturnsTrueWhenThereAreMultipleGroups()
@@ -173,7 +182,7 @@ public function testHasGroupsReturnsTrueWhenThereAreMultipleGroups()
         $this->makePage('foo', ['navigation.group' => 'bar']);
         $this->makePage('bar', ['navigation.group' => 'baz']);
 
-        $this->assertTrue(DocumentationSidebar::create()->hasGroups());
+        $this->assertTrue(NavigationMenuGenerator::handle(DocumentationSidebar::class)->hasGroups());
     }
 
     public function testHasGroupsReturnsTrueWhenThereAreMultipleGroupsMixedWithDefaults()
@@ -182,120 +191,57 @@ public function testHasGroupsReturnsTrueWhenThereAreMultipleGroupsMixedWithDefau
         $this->makePage('bar', ['navigation.group' => 'baz']);
         $this->makePage('baz');
 
-        $this->assertTrue(DocumentationSidebar::create()->hasGroups());
+        $this->assertTrue(NavigationMenuGenerator::handle(DocumentationSidebar::class)->hasGroups());
     }
 
-    public function testGetGroupsReturnsEmptyArrayWhenThereAreNoGroups()
-    {
-        $this->assertEquals([], DocumentationSidebar::create()->getGroups());
-    }
-
-    public function testGetGroupsReturnsArrayOfGroupsWhenThereAreGroups()
-    {
-        $this->makePage('foo', ['navigation.group' => 'bar']);
-
-        $this->assertEquals(['bar'], DocumentationSidebar::create()->getGroups());
-    }
-
-    public function testGetGroupsReturnsArrayWithNoDuplicates()
-    {
-        $this->makePage('foo', ['navigation.group' => 'bar']);
-        $this->makePage('bar', ['navigation.group' => 'bar']);
-        $this->makePage('baz', ['navigation.group' => 'baz']);
-
-        $this->assertEquals(['bar', 'baz'], DocumentationSidebar::create()->getGroups());
-    }
-
-    public function testGroupsAreSortedByLowestFoundPriorityInEachGroup()
-    {
-        $this->makePage('foo', ['navigation.group' => 'bar', 'navigation.priority' => 100]);
-        $this->makePage('bar', ['navigation.group' => 'bar', 'navigation.priority' => 200]);
-        $this->makePage('baz', ['navigation.group' => 'baz', 'navigation.priority' => 10]);
-
-        $this->assertEquals(['baz', 'bar'], DocumentationSidebar::create()->getGroups());
-    }
-
-    public function testGetItemsInGroupReturnsEmptyCollectionWhenThereAreNoItems()
-    {
-        $this->assertEquals(collect(), DocumentationSidebar::create()->getItemsInGroup('foo'));
-    }
-
-    public function testGetItemsInGroupReturnsCollectionOfItemsInGroup()
-    {
-        $this->makePage('foo', ['navigation.group' => 'bar']);
-        $this->makePage('bar', ['navigation.group' => 'bar']);
-        $this->makePage('baz', ['navigation.group' => 'baz']);
-
-        $this->assertEquals(
-            collect([
-                NavItem::fromRoute(Routes::get('docs/bar'), priority: 999),
-                NavItem::fromRoute(Routes::get('docs/foo'), priority: 999),
-            ]),
-            DocumentationSidebar::create()->getItemsInGroup('bar')
-        );
-
-        $this->assertEquals(
-            collect([
-                NavItem::fromRoute(Routes::get('docs/baz'), priority: 999),
-            ]),
-            DocumentationSidebar::create()->getItemsInGroup('baz')
-        );
-    }
-
-    public function testGetItemsInGroupNormalizesGroupNameToSlugFormat()
+    public function testGetItemsInGroupDoesNotIncludeDocsIndex()
     {
-        $this->makePage('a', ['navigation.group' => 'foo bar']);
-        $this->makePage('b', ['navigation.group' => 'Foo Bar']);
-        $this->makePage('c', ['navigation.group' => 'foo-bar']);
+        Filesystem::touch('_docs/foo.md');
+        Filesystem::touch('_docs/index.md');
 
         $this->assertEquals(
-            collect([
-                NavItem::fromRoute(Routes::get('docs/a'), priority: 999),
-                NavItem::fromRoute(Routes::get('docs/b'), priority: 999),
-                NavItem::fromRoute(Routes::get('docs/c'), priority: 999),
-            ]),
-            DocumentationSidebar::create()->getItemsInGroup('Foo bar')
+            collect([NavigationItem::create(Routes::get('docs/foo'), priority: 999)]),
+            NavigationMenuGenerator::handle(DocumentationSidebar::class)->getItems()
         );
     }
 
-    public function testGetItemsInGroupDoesNotIncludeItemsWithHiddenFrontMatter()
+    public function testGetActiveGroup()
     {
-        $this->makePage('a', ['navigation.hidden' => true, 'navigation.group' => 'foo']);
-        $this->makePage('b', ['navigation.group' => 'foo']);
-
-        $this->assertEquals(
-            collect([NavItem::fromRoute(Routes::get('docs/b'), priority: 999)]),
-            DocumentationSidebar::create()->getItemsInGroup('foo')
-        );
-    }
+        $this->makePage('foo', ['navigation.group' => 'foo']);
+        $this->makePage('bar', ['navigation.group' => 'bar']);
+        $this->makePage('baz');
 
-    public function testGetItemsInGroupDoesNotIncludeDocsIndex()
-    {
-        Filesystem::touch('_docs/foo.md');
-        Filesystem::touch('_docs/index.md');
+        Render::setPage(new DocumentationPage(matter: ['navigation.group' => 'foo']));
 
         $this->assertEquals(
-            collect([NavItem::fromRoute(Routes::get('docs/foo'), priority: 999)]),
-            DocumentationSidebar::create()->items
+            NavigationGroup::create('Foo', [
+                NavigationItem::create(Routes::get('docs/foo'), priority: 999),
+            ]),
+            NavigationMenuGenerator::handle(DocumentationSidebar::class)->getActiveGroup()
         );
     }
 
     public function testIsGroupActiveReturnsFalseWhenSuppliedGroupIsNotActive()
     {
         Render::setPage(new DocumentationPage(matter: ['navigation.group' => 'foo']));
-        $this->assertFalse(DocumentationSidebar::create()->isGroupActive('bar'));
+        $mainNavigationMenu = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertFalse('bar' === $this->getGroupKey($mainNavigationMenu));
     }
 
     public function testIsGroupActiveReturnsTrueWhenSuppliedGroupIsActive()
     {
+        $this->makePage('foo', ['navigation.group' => 'foo']);
         Render::setPage(new DocumentationPage(matter: ['navigation.group' => 'foo']));
-        $this->assertTrue(DocumentationSidebar::create()->isGroupActive('foo'));
+        $mainNavigationMenu = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertTrue('foo' === $this->getGroupKey($mainNavigationMenu));
     }
 
     public function testIsGroupActiveReturnsTrueForDifferingCasing()
     {
+        $this->makePage('foo', ['navigation.group' => 'Foo Bar']);
         Render::setPage(new DocumentationPage(matter: ['navigation.group' => 'Foo Bar']));
-        $this->assertTrue(DocumentationSidebar::create()->isGroupActive('foo-bar'));
+        $mainNavigationMenu = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertTrue('foo-bar' === $this->getGroupKey($mainNavigationMenu));
     }
 
     public function testIsGroupActiveReturnsTrueFirstGroupOfIndexPage()
@@ -306,9 +252,12 @@ public function testIsGroupActiveReturnsTrueFirstGroupOfIndexPage()
         $this->makePage('baz', ['navigation.group' => 'baz']);
 
         Render::setPage(DocumentationPage::get('index'));
-        $this->assertTrue(DocumentationSidebar::create()->isGroupActive('bar'));
-        $this->assertFalse(DocumentationSidebar::create()->isGroupActive('foo'));
-        $this->assertFalse(DocumentationSidebar::create()->isGroupActive('baz'));
+        $mainNavigationMenu2 = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertTrue('bar' === $this->getGroupKey($mainNavigationMenu2));
+        $mainNavigationMenu1 = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertFalse('foo' === $this->getGroupKey($mainNavigationMenu1));
+        $mainNavigationMenu = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertFalse('baz' === $this->getGroupKey($mainNavigationMenu));
     }
 
     public function testIsGroupActiveReturnsTrueFirstSortedGroupOfIndexPage()
@@ -319,9 +268,12 @@ public function testIsGroupActiveReturnsTrueFirstSortedGroupOfIndexPage()
         $this->makePage('baz', ['navigation.group' => 'baz', 'navigation.priority' => 3]);
 
         Render::setPage(DocumentationPage::get('index'));
-        $this->assertTrue(DocumentationSidebar::create()->isGroupActive('foo'));
-        $this->assertFalse(DocumentationSidebar::create()->isGroupActive('bar'));
-        $this->assertFalse(DocumentationSidebar::create()->isGroupActive('baz'));
+        $mainNavigationMenu2 = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertTrue('foo' === $this->getGroupKey($mainNavigationMenu2));
+        $mainNavigationMenu1 = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertFalse('bar' === $this->getGroupKey($mainNavigationMenu1));
+        $mainNavigationMenu = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertFalse('baz' === $this->getGroupKey($mainNavigationMenu));
     }
 
     public function testAutomaticIndexPageGroupExpansionRespectsCustomNavigationMenuSettings()
@@ -332,27 +284,12 @@ public function testAutomaticIndexPageGroupExpansionRespectsCustomNavigationMenu
         $this->makePage('baz', ['navigation.group' => 'baz', 'navigation.priority' => 3]);
 
         Render::setPage(DocumentationPage::get('index'));
-        $this->assertFalse(DocumentationSidebar::create()->isGroupActive('foo'));
-        $this->assertFalse(DocumentationSidebar::create()->isGroupActive('bar'));
-        $this->assertTrue(DocumentationSidebar::create()->isGroupActive('baz'));
-    }
-
-    public function testMakeGroupTitleTurnsGroupKeyIntoTitle()
-    {
-        $this->assertSame('Hello World', DocumentationSidebar::create()->makeGroupTitle('hello world'));
-        $this->assertSame('Hello World', DocumentationSidebar::create()->makeGroupTitle('hello-world'));
-        $this->assertSame('Hello World', DocumentationSidebar::create()->makeGroupTitle('hello_world'));
-        $this->assertSame('Hello World', DocumentationSidebar::create()->makeGroupTitle('helloWorld'));
-    }
-
-    public function testMakeGroupTitleUsesConfiguredSidebarGroupLabelsWhenAvailable()
-    {
-        Config::set('docs.sidebar_group_labels', [
-            'example' => 'Hello world!',
-        ]);
-
-        $this->assertSame('Hello world!', DocumentationSidebar::create()->makeGroupTitle('example'));
-        $this->assertSame('Default', DocumentationSidebar::create()->makeGroupTitle('default'));
+        $mainNavigationMenu2 = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertFalse('foo' === $this->getGroupKey($mainNavigationMenu2));
+        $mainNavigationMenu1 = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertFalse('bar' === $this->getGroupKey($mainNavigationMenu1));
+        $mainNavigationMenu = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertTrue('baz' === $this->getGroupKey($mainNavigationMenu));
     }
 
     public function testCanHaveMultipleGroupedPagesWithTheSameNameLabels()
@@ -360,29 +297,38 @@ public function testCanHaveMultipleGroupedPagesWithTheSameNameLabels()
         $this->makePage('foo', ['navigation.group' => 'foo', 'navigation.label' => 'Foo']);
         $this->makePage('bar', ['navigation.group' => 'bar', 'navigation.label' => 'Foo']);
 
-        $sidebar = DocumentationSidebar::create();
-        $this->assertCount(2, $sidebar->items);
+        $sidebar = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertCount(2, $sidebar->getItems());
 
         $this->assertEquals(
             collect([
-                NavItem::fromRoute(Routes::get('docs/bar'), priority: 999),
-                NavItem::fromRoute(Routes::get('docs/foo'), priority: 999),
+                NavigationGroup::create('Bar', [
+                    NavigationItem::create(Routes::get('docs/bar'), priority: 999),
+                ]),
+                NavigationGroup::create('Foo', [
+                    NavigationItem::create(Routes::get('docs/foo'), priority: 999),
+                ]),
             ]),
-            $sidebar->items
+            $sidebar->getItems()
         );
     }
 
-    public function testDuplicateLabelsWithinTheSameGroupIsRemoved()
+    public function testDuplicateLabelsWithinTheSameGroupAreNotRemoved()
     {
         $this->makePage('foo', ['navigation.group' => 'foo', 'navigation.label' => 'Foo']);
         $this->makePage('bar', ['navigation.group' => 'foo', 'navigation.label' => 'Foo']);
 
-        $sidebar = DocumentationSidebar::create();
-        $this->assertCount(1, $sidebar->items);
+        $sidebar = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertCount(1, $sidebar->getItems());
 
         $this->assertEquals(
-            collect([NavItem::fromRoute(Routes::get('docs/bar'), priority: 999)]),
-            $sidebar->items
+            collect([
+                NavigationGroup::create('Foo', [
+                    NavigationItem::create(Routes::get('docs/bar'), priority: 999),
+                    NavigationItem::create(Routes::get('docs/foo'), priority: 999),
+                ]),
+            ]),
+            $sidebar->getItems()
         );
     }
 
@@ -391,18 +337,19 @@ public function testIsGroupActiveForIndexPageWithNoGroups()
         $this->makePage('index');
 
         Render::setPage(DocumentationPage::get('index'));
-        $this->assertFalse(DocumentationSidebar::create()->isGroupActive('foo'));
+        $mainNavigationMenu = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        $this->assertFalse('foo' === $this->getGroupKey($mainNavigationMenu));
     }
 
     public function testIndexPageAddedToSidebarWhenItIsTheOnlyPage()
     {
         Filesystem::touch('_docs/index.md');
-        $sidebar = DocumentationSidebar::create();
+        $sidebar = NavigationMenuGenerator::handle(DocumentationSidebar::class);
 
-        $this->assertCount(1, $sidebar->items);
+        $this->assertCount(1, $sidebar->getItems());
         $this->assertEquals(
-            collect([NavItem::fromRoute(Routes::get('docs/index'))]),
-            $sidebar->items
+            collect([NavigationItem::create(Routes::get('docs/index'))]),
+            $sidebar->getItems()
         );
     }
 
@@ -410,12 +357,12 @@ public function testIndexPageNotAddedToSidebarWhenOtherPagesExist()
     {
         $this->createTestFiles(1);
         Filesystem::touch('_docs/index.md');
-        $sidebar = DocumentationSidebar::create();
+        $sidebar = NavigationMenuGenerator::handle(DocumentationSidebar::class);
 
-        $this->assertCount(1, $sidebar->items);
+        $this->assertCount(1, $sidebar->getItems());
         $this->assertEquals(
-            collect([NavItem::fromRoute(Routes::get('docs/test-0'))]),
-            $sidebar->items
+            collect([NavigationItem::create(Routes::get('docs/test-0'))]),
+            $sidebar->getItems()
         );
     }
 
@@ -433,4 +380,9 @@ protected function makePage(string $name, ?array $matter = null): void
             (new ConvertsArrayToFrontMatter)->execute($matter ?? [])
         );
     }
+
+    protected function getGroupKey(DocumentationSidebar $menu): ?string
+    {
+        return $menu->getActiveGroup()?->getGroupKey();
+    }
 }
diff --git a/packages/framework/tests/Feature/SidebarViewTest.php b/packages/framework/tests/Feature/SidebarViewTest.php
index 005b2421062..1f76307068b 100644
--- a/packages/framework/tests/Feature/SidebarViewTest.php
+++ b/packages/framework/tests/Feature/SidebarViewTest.php
@@ -7,10 +7,9 @@
 namespace Hyde\Framework\Testing\Feature;
 
 use Hyde\Framework\Features\Navigation\DocumentationSidebar;
-use Hyde\Hyde;
 use Hyde\Testing\TestCase;
 use Illuminate\Contracts\View\View;
-use Throwable;
+use Hyde\Framework\Features\Navigation\NavigationMenuGenerator;
 
 /**
  * Very high level test of the sidebar views and their combinations of layouts.
@@ -36,15 +35,12 @@ public function testBaseSidebar()
             ->assertSeeHtml('<ul id="sidebar-items" role="list"')
             ->assertSeeHtml('<nav id="sidebar-navigation"')
             ->assertSeeHtml('<footer id="sidebar-footer"')
-            ->assertSeeHtml('<a href="index.html">Back to home page</a>')
+            ->assertSeeHtml('<a href="../">Back to home page</a>')
             ->assertSeeHtml('<span class="sr-only">Toggle dark theme</span>')
             ->assertDontSee('<a href="docs/index.html">')
-            ->assertDontSee('<li class="sidebar-item')
-            ->allGood();
+            ->assertDontSee('<li class="sidebar-item');
 
-        $this->assertViewWasRendered(view('hyde::components.docs.sidebar-items', [
-            'sidebar' => DocumentationSidebar::create(),
-        ]));
+        $this->assertViewWasRendered(view('hyde::components.docs.sidebar-items'));
 
         $this->assertViewWasRendered(view('hyde::components.docs.sidebar-brand'));
         $this->assertViewWasRendered(view('hyde::components.docs.sidebar-footer-text'));
@@ -54,9 +50,9 @@ public function testBaseSidebarWithoutFooter()
     {
         config(['docs.sidebar.footer' => false]);
 
-        $this->renderComponent(view('hyde::components.docs.sidebar'));
-
-        $this->assertViewWasNotRendered(view('hyde::components.docs.sidebar-footer-text'));
+        $this->renderComponent(view('hyde::components.docs.sidebar'))
+            ->assertDontSee('<footer id="sidebar-footer"')
+            ->assertDontSee('Back to home page');
     }
 
     public function testBaseSidebarWithCustomFooterText()
@@ -66,8 +62,7 @@ public function testBaseSidebarWithCustomFooterText()
         $this->renderComponent(view('hyde::components.docs.sidebar'))
             ->assertSeeHtml('<footer id="sidebar-footer"')
             ->assertSeeHtml('<p>My <strong>Markdown</strong> Footer Text</p>')
-            ->assertDontSee('Back to home page')
-            ->allGood();
+            ->assertDontSee('Back to home page');
     }
 
     public function testBaseSidebarCustomHeaderBrand()
@@ -76,8 +71,7 @@ public function testBaseSidebarCustomHeaderBrand()
 
         $this->renderComponent(view('hyde::components.docs.sidebar'))
             ->assertSeeText('My Custom Header')
-            ->assertDontSee('HydePHP Docs')
-            ->allGood();
+            ->assertDontSee('HydePHP Docs');
 
         $this->assertViewWasRendered(view('hyde::components.docs.sidebar-brand'));
     }
@@ -92,12 +86,9 @@ public function testBaseSidebarWithItems()
             ->assertSeeHtml('<a href="docs/index.html">')
             ->assertSeeHtml('<nav id="sidebar-navigation"')
             ->assertSeeHtml('<ul id="sidebar-items" role="list" class="pl-2">')
-            ->assertSeeHtml('<li class="sidebar-item')
-            ->allGood();
+            ->assertSeeHtml('<li class="sidebar-item');
 
-        $this->assertViewWasRendered(view('hyde::components.docs.sidebar-items', [
-            'sidebar' => DocumentationSidebar::create(),
-        ]));
+        $this->assertViewWasRendered(view('hyde::components.docs.sidebar-items'));
     }
 
     public function testSidebarWithGroupedItems()
@@ -120,11 +111,9 @@ public function testSidebarWithGroupedItems()
             ->assertSeeHtml('class="sidebar-group-toggle')
             ->assertSeeHtml('class="sidebar-group-toggle-icon')
             ->assertSeeHtml('class="sidebar-group-items')
-            ->assertSee('groupOpen')
-            ->allGood();
+            ->assertSee('groupOpen');
 
         $this->assertViewWasRendered(view('hyde::components.docs.sidebar-items', [
-            'sidebar' => DocumentationSidebar::create(),
             'grouped' => true,
         ]));
 
@@ -152,34 +141,45 @@ public function testSidebarWithNonCollapsibleGroupedItems()
             ->assertSeeHtml('class="sidebar-group-items')
             ->assertDontSee('sidebar-group-toggle')
             ->assertDontSee('sidebar-group-toggle-icon')
-            ->assertDontSee('groupOpen')
-            ->allGood();
+            ->assertDontSee('groupOpen');
 
         $this->assertViewWasRendered(view('hyde::components.docs.sidebar-items', [
-            'sidebar' => DocumentationSidebar::create(),
             'grouped' => true,
         ]));
 
         $this->assertViewWasNotRendered(view('hyde::components.docs.sidebar-group-toggle-button'));
     }
 
+    public function testSidebarWithMixedGroupedAndUngroupedItems()
+    {
+        $this->mockRoute();
+        $this->mockPage();
+        $this->file('_docs/index.md');
+        $this->markdown('_docs/first.md', matter: ['navigation.group' => 'Group 1']);
+        $this->markdown('_docs/second.md');
+
+        $this->renderComponent(view('hyde::components.docs.sidebar'))
+            ->assertSeeText('Group 1')
+            ->assertSeeText('First')
+            ->assertSeeText('Other')
+            ->assertSeeText('Second')
+            ->assertSeeHtml('href="docs/first.html"')
+            ->assertSeeHtml('href="docs/second.html"');
+
+        $this->assertViewWasRendered(view('hyde::components.docs.sidebar-items', [
+            'grouped' => true,
+        ]));
+
+        $this->assertViewWasRendered(view('hyde::components.docs.sidebar-group-toggle-button'));
+    }
+
     protected function renderComponent(View $view): self
     {
-        try {
-            $this->html = $view->render();
-            /** @noinspection LaravelFunctionsInspection */
-            if (env('TEST_HTML_DEBUG', false)) {
-                file_put_contents(Hyde::path('_site/test.html'), $this->html);
-                echo "\e[0;32mCreated file: \e[0m".realpath(Hyde::path('_site/test.html'));
-            }
-        } catch (Throwable $exception) {
-            /** @noinspection LaravelFunctionsInspection */
-            if (env('TEST_HTML_DEBUG', false)) {
-                throw $exception;
-            }
-            $this->fail($exception->getMessage());
-        }
+        $sidebar = NavigationMenuGenerator::handle(DocumentationSidebar::class);
+        app()->instance('navigation.sidebar', $sidebar);
+        view()->share('sidebar', $sidebar);
 
+        $this->html = $view->render();
         $this->assertIsString($this->html);
 
         return $this;
@@ -226,11 +226,4 @@ protected function assertDontSee(string $text): self
 
         return $this;
     }
-
-    protected function allGood(): self
-    {
-        // Just an empty helper so we get easier Git diffs when adding new assertions.
-
-        return $this;
-    }
 }
diff --git a/packages/framework/tests/Feature/Views/SidebarBrandViewTest.php b/packages/framework/tests/Feature/Views/SidebarBrandViewTest.php
index 03670822588..bc4e8de71fb 100644
--- a/packages/framework/tests/Feature/Views/SidebarBrandViewTest.php
+++ b/packages/framework/tests/Feature/Views/SidebarBrandViewTest.php
@@ -9,6 +9,7 @@
 use Hyde\Foundation\HydeKernel;
 use Hyde\Testing\TestsBladeViews;
 use Hyde\Pages\DocumentationPage;
+use Hyde\Framework\Features\Navigation\DocumentationSidebar;
 
 class SidebarBrandViewTest extends TestCase
 {
@@ -68,4 +69,11 @@ public function testSidebarBrandViewWithoutDarkmodeFeature()
         $view->assertSee('HydePHP Docs');
         $view->assertDontSee('theme-toggle-button');
     }
+
+    protected function testViewData(): array
+    {
+        return [
+            'sidebar' => new DocumentationSidebar(),
+        ];
+    }
 }
diff --git a/packages/framework/tests/Feature/Views/SidebarFooterTextViewTest.php b/packages/framework/tests/Feature/Views/SidebarFooterTextViewTest.php
index 0b27fa6f467..a2347c3ad66 100644
--- a/packages/framework/tests/Feature/Views/SidebarFooterTextViewTest.php
+++ b/packages/framework/tests/Feature/Views/SidebarFooterTextViewTest.php
@@ -7,6 +7,7 @@
 use Hyde\Facades\Config;
 use Hyde\Testing\TestCase;
 use Hyde\Testing\TestsBladeViews;
+use Hyde\Framework\Features\Navigation\DocumentationSidebar;
 
 class SidebarFooterTextViewTest extends TestCase
 {
@@ -14,33 +15,22 @@ class SidebarFooterTextViewTest extends TestCase
 
     public function testSidebarFooterTextViewWithDefaultConfig()
     {
-        $view = $this->view(view('hyde::components.docs.sidebar-footer-text'));
+        $view = $this->view(view('hyde::components.docs.sidebar-footer-text', $this->withSidebar()));
 
-        $view->assertSeeHtml('<a href="index.html">Back to home page</a>');
-    }
-
-    public function testSidebarFooterTextViewWhenConfigOptionIsTrue()
-    {
-        Config::set('docs.sidebar.footer', true);
-
-        $view = $this->view(view('hyde::components.docs.sidebar-footer-text'));
-
-        $view->assertSeeHtml('<a href="index.html">Back to home page</a>');
+        $view->assertSeeHtml('<a href="../">Back to home page</a>');
     }
 
     public function testSidebarFooterTextViewWhenConfigOptionIsMarkdownString()
     {
         Config::set('docs.sidebar.footer', 'Your Markdown String Here');
 
-        $view = $this->view(view('hyde::components.docs.sidebar-footer-text'));
+        $view = $this->view(view('hyde::components.docs.sidebar-footer-text', $this->withSidebar()));
 
         $view->assertSeeText('Your Markdown String Here');
     }
 
-    public function testSidebarFooterTextViewWhenConfigOptionIsFalse()
+    protected function withSidebar(): array
     {
-        // This state is handled earlier in the component by the sidebar component so we don't need to test it here.
-
-        $this->assertTrue(true);
+        return ['sidebar' => new DocumentationSidebar()];
     }
 }
diff --git a/packages/framework/tests/Unit/DocumentationPageTest.php b/packages/framework/tests/Unit/DocumentationPageTest.php
index b725e59477a..9304a4955c1 100644
--- a/packages/framework/tests/Unit/DocumentationPageTest.php
+++ b/packages/framework/tests/Unit/DocumentationPageTest.php
@@ -195,10 +195,10 @@ public function testHasTableOfContents()
     {
         $this->assertIsBool(DocumentationPage::hasTableOfContents());
 
-        Config::set('docs.table_of_contents.enabled', true);
+        Config::set('docs.sidebar.table_of_contents.enabled', true);
         $this->assertTrue(DocumentationPage::hasTableOfContents());
 
-        Config::set('docs.table_of_contents.enabled', false);
+        Config::set('docs.sidebar.table_of_contents.enabled', false);
         $this->assertFalse(DocumentationPage::hasTableOfContents());
     }
 
diff --git a/packages/framework/tests/Unit/DocumentationSidebarGetActiveGroupUnitTest.php b/packages/framework/tests/Unit/DocumentationSidebarGetActiveGroupUnitTest.php
new file mode 100644
index 00000000000..85cfca99569
--- /dev/null
+++ b/packages/framework/tests/Unit/DocumentationSidebarGetActiveGroupUnitTest.php
@@ -0,0 +1,198 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Testing\Unit;
+
+use Mockery;
+use Illuminate\View\Factory;
+use Hyde\Testing\UnitTestCase;
+use Hyde\Support\Facades\Render;
+use Hyde\Pages\DocumentationPage;
+use Hyde\Support\Models\RenderData;
+use Illuminate\Support\Facades\View;
+use Hyde\Framework\Features\Navigation\NavigationItem;
+use Hyde\Framework\Features\Navigation\NavigationGroup;
+use Hyde\Framework\Features\Navigation\DocumentationSidebar;
+
+/**
+ * @covers \Hyde\Framework\Features\Navigation\DocumentationSidebar
+ *
+ * @see \Hyde\Framework\Testing\Feature\Services\DocumentationSidebarTest
+ * @see \Hyde\Framework\Testing\Unit\DocumentationSidebarGetActiveGroupUnitTest
+ */
+class DocumentationSidebarGetActiveGroupUnitTest extends UnitTestCase
+{
+    protected static bool $needsKernel = true;
+
+    protected RenderData $renderData;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        View::swap(Mockery::mock(Factory::class)->makePartial());
+        $this->renderData = new RenderData();
+        Render::swap($this->renderData);
+
+        self::mockConfig();
+    }
+
+    protected function createSidebar(): DocumentationSidebar
+    {
+        // The sidebar structure
+        $items = [
+            // Group keys
+            'getting-started' => [
+                // Group items
+                'Introduction',
+                'Installation',
+            ],
+            'configuration' => [
+                'Configuration',
+                'Environment Variables',
+            ],
+            'usage' => [
+                'Routing',
+                'Middleware',
+            ],
+        ];
+
+        // Create the sidebar items
+        foreach ($items as $groupKey => $groupItems) {
+            $items[$groupKey] = new NavigationGroup($groupKey, array_map(fn (string $item): NavigationItem => new NavigationItem($item, $item), $groupItems));
+        }
+
+        // Create the sidebar
+        return new DocumentationSidebar($items);
+    }
+
+    public function testNoActiveGroupWhenNoneExists()
+    {
+        $this->assertNull($this->createSidebar()->getActiveGroup());
+    }
+
+    public function testNoActiveGroupWhenOutsideSidebar()
+    {
+        $this->mockCurrentPageForActiveGroup('foo');
+        $this->assertNull($this->createSidebar()->getActiveGroup());
+    }
+
+    public function testNoActiveGroupWhenSidebarNotCollapsible()
+    {
+        self::mockConfig(['docs.sidebar.collapsible' => false]);
+        $this->mockCurrentPageForActiveGroup('getting-started');
+        $this->assertNull($this->createSidebar()->getActiveGroup());
+        self::mockConfig(['docs.sidebar.collapsible' => true]);
+    }
+
+    public function testActiveGroupGettingStarted()
+    {
+        $this->mockCurrentPageForActiveGroup('getting-started');
+        $this->assertSame('getting-started', $this->getActiveGroupKey());
+    }
+
+    public function testActiveGroupConfiguration()
+    {
+        $this->mockCurrentPageForActiveGroup('configuration');
+        $this->assertSame('configuration', $this->getActiveGroupKey());
+    }
+
+    public function testActiveGroupUsage()
+    {
+        $this->mockCurrentPageForActiveGroup('usage');
+        $this->assertSame('usage', $this->getActiveGroupKey());
+    }
+
+    public function testActiveGroupWithIdentifierGettingStarted()
+    {
+        $this->mockCurrentPageForActiveGroup('getting-started', 'Introduction');
+        $this->assertSame('getting-started', $this->getActiveGroupKey());
+    }
+
+    public function testActiveGroupWithIdentifierConfiguration()
+    {
+        $this->mockCurrentPageForActiveGroup('configuration', 'Configuration');
+        $this->assertSame('configuration', $this->getActiveGroupKey());
+    }
+
+    public function testActiveGroupWithIdentifierUsage()
+    {
+        $this->mockCurrentPageForActiveGroup('usage', 'Routing');
+        $this->assertSame('usage', $this->getActiveGroupKey());
+    }
+
+    public function testActiveGroupDifferentCasingGettingStarted()
+    {
+        $this->mockCurrentPageForActiveGroup('GETTING-STARTED');
+        $this->assertSame('getting-started', $this->getActiveGroupKey());
+    }
+
+    public function testActiveGroupDifferentCasingGettingStarted2()
+    {
+        $this->mockCurrentPageForActiveGroup('Getting-Started');
+        $this->assertSame('getting-started', $this->getActiveGroupKey());
+    }
+
+    public function testActiveGroupDifferentCasingGettingStarted3()
+    {
+        $this->mockCurrentPageForActiveGroup('getting-started');
+        $this->assertSame('getting-started', $this->getActiveGroupKey());
+    }
+
+    public function testGetActiveGroupIsNullWhenNoItemsExist()
+    {
+        $this->assertNull((new DocumentationSidebar())->getActiveGroup());
+    }
+
+    public function testGetActiveGroupIsNullWhenNoGroupsExist()
+    {
+        $this->assertNull((new DocumentationSidebar([new NavigationItem('foo', 'Foo')]))->getActiveGroup());
+    }
+
+    public function testGetActiveGroupIsNullIfTheSetGroupIsNotPresentInTheSidebarItems()
+    {
+        $this->renderData->setPage(new DocumentationPage('foo', ['navigation.group' => 'foo']));
+        $this->assertNull($this->createSidebar()->getActiveGroup());
+    }
+
+    public function testGetActiveGroupReturnsFirstGroupWhenRenderingIndexPage()
+    {
+        $this->renderData->setPage(new DocumentationPage('index'));
+        $this->assertSame('getting-started', $this->getActiveGroupKey());
+    }
+
+    public function testGetActiveGroupReturnsExplicitlySetIndexPageGroupWhenRenderingIndexPage()
+    {
+        $this->renderData->setPage(new DocumentationPage('index', ['navigation.group' => 'usage']));
+        $this->assertSame('usage', $this->getActiveGroupKey($this->createSidebar()));
+    }
+
+    public function testGetActiveGroupReturnsFirstGroupByLowestPriorityWhenRenderingIndexPage()
+    {
+        $sidebar = $this->createSidebar()->add(new NavigationGroup('other', [new NavigationItem('Other', 'Other')], 0));
+
+        $this->renderData->setPage(new DocumentationPage('index'));
+        $this->assertSame('other', $this->getActiveGroupKey($sidebar));
+    }
+
+    public function testGetActiveGroupReturnsExplicitlySetIndexPageGroupWhenRenderingIndexPageRegardlessOfPriorities()
+    {
+        $sidebar = $this->createSidebar()->add(new NavigationGroup('other', [new NavigationItem('Other', 'Other')], 0));
+
+        $this->renderData->setPage(new DocumentationPage('index', ['navigation.group' => 'usage']));
+        $this->assertSame('usage', $this->getActiveGroupKey($sidebar));
+    }
+
+    protected function mockCurrentPageForActiveGroup(string $group, string $identifier = 'foo'): void
+    {
+        $this->renderData->setPage(new DocumentationPage($identifier, ['navigation.group' => $group]));
+    }
+
+    protected function getActiveGroupKey(?DocumentationSidebar $sidebar = null): string
+    {
+        $sidebar ??= $this->createSidebar();
+
+        return $sidebar->getActiveGroup()->getGroupKey();
+    }
+}
diff --git a/packages/framework/tests/Unit/DocumentationSidebarUnitTest.php b/packages/framework/tests/Unit/DocumentationSidebarUnitTest.php
new file mode 100644
index 00000000000..27e1e3826e3
--- /dev/null
+++ b/packages/framework/tests/Unit/DocumentationSidebarUnitTest.php
@@ -0,0 +1,232 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Testing\Unit;
+
+use Hyde\Testing\UnitTestCase;
+use Illuminate\Support\Collection;
+use Hyde\Framework\Features\Navigation\NavigationItem;
+use Hyde\Framework\Features\Navigation\NavigationGroup;
+use Hyde\Framework\Features\Navigation\DocumentationSidebar;
+
+/**
+ * @covers \Hyde\Framework\Features\Navigation\DocumentationSidebar
+ * @covers \Hyde\Framework\Features\Navigation\NavigationMenu
+ *
+ * @see \Hyde\Framework\Testing\Feature\Services\DocumentationSidebarTest
+ * @see \Hyde\Framework\Testing\Unit\DocumentationSidebarGetActiveGroupUnitTest
+ * @see \Hyde\Framework\Testing\Unit\NavigationMenuUnitTest
+ */
+class DocumentationSidebarUnitTest extends UnitTestCase
+{
+    protected static bool $needsKernel = true;
+    protected static bool $needsConfig = true;
+
+    // Base menu tests
+
+    public function testCanConstruct()
+    {
+        $this->assertInstanceOf(DocumentationSidebar::class, new DocumentationSidebar());
+    }
+
+    public function testCanConstructWithItemsArray()
+    {
+        $this->assertInstanceOf(DocumentationSidebar::class, new DocumentationSidebar($this->getItems()));
+    }
+
+    public function testCanConstructWithItemsArrayable()
+    {
+        $this->assertInstanceOf(DocumentationSidebar::class, new DocumentationSidebar(collect($this->getItems())));
+    }
+
+    public function testGetItemsReturnsCollection()
+    {
+        $this->assertInstanceOf(Collection::class, (new DocumentationSidebar())->getItems());
+    }
+
+    public function testGetItemsReturnsCollectionWhenSuppliedArray()
+    {
+        $this->assertInstanceOf(Collection::class, (new DocumentationSidebar($this->getItems()))->getItems());
+    }
+
+    public function testGetItemsReturnsCollectionWhenSuppliedArrayable()
+    {
+        $this->assertInstanceOf(Collection::class, (new DocumentationSidebar(collect($this->getItems())))->getItems());
+    }
+
+    public function testGetItemsReturnsItems()
+    {
+        $items = $this->getItems();
+
+        $this->assertSame($items, (new DocumentationSidebar($items))->getItems()->all());
+    }
+
+    public function testGetItemsReturnsItemsWhenSuppliedArrayable()
+    {
+        $items = $this->getItems();
+
+        $this->assertSame($items, (new DocumentationSidebar(collect($items)))->getItems()->all());
+    }
+
+    public function testGetItemsReturnsEmptyArrayWhenNoItems()
+    {
+        $this->assertSame([], (new DocumentationSidebar())->getItems()->all());
+    }
+
+    public function testCanAddItems()
+    {
+        $menu = new DocumentationSidebar();
+
+        $item = $this->item('/', 'Docs');
+
+        $menu->add($item);
+
+        $this->assertCount(1, $menu->getItems());
+        $this->assertSame($item, $menu->getItems()->first());
+    }
+
+    public function testItemsAreInTheOrderTheyWereAddedWhenThereAreNoCustomPriorities()
+    {
+        $menu = new DocumentationSidebar();
+
+        $item1 = $this->item('/', 'Docs');
+        $item2 = $this->item('/installation', 'Installation');
+        $item3 = $this->item('/getting-started', 'Getting Started');
+
+        $menu->add($item1);
+        $menu->add($item2);
+        $menu->add($item3);
+
+        $this->assertSame([$item1, $item2, $item3], $menu->getItems()->all());
+    }
+
+    public function testItemsAreSortedByPriority()
+    {
+        $menu = new DocumentationSidebar();
+
+        $item1 = $this->item('/', 'Docs', 100);
+        $item2 = $this->item('/installation', 'Installation', 200);
+        $item3 = $this->item('/getting-started', 'Getting Started', 300);
+
+        $menu->add($item3);
+        $menu->add($item1);
+        $menu->add($item2);
+
+        $this->assertSame([$item1, $item2, $item3], $menu->getItems()->all());
+    }
+
+    // Sidebar specific tests
+
+    public function testGetMethodResolvesInstanceFromServiceContainer()
+    {
+        app()->instance('navigation.sidebar', $instance = new DocumentationSidebar());
+
+        $this->assertSame($instance, DocumentationSidebar::get());
+    }
+
+    public function testGetHeaderReturnsDefaultWhenNotConfigured()
+    {
+        self::mockConfig();
+
+        $this->assertSame('Documentation', (new DocumentationSidebar())->getHeader());
+    }
+
+    public function testGetHeaderReturnsConfiguredValue()
+    {
+        self::mockConfig(['docs.sidebar.header' => 'Some header']);
+
+        $this->assertSame('Some header', (new DocumentationSidebar())->getHeader());
+    }
+
+    public function testGetFooterReturnsBackLinkByDefault()
+    {
+        self::mockConfig();
+
+        $this->assertSame('[Back to home page](../)', (new DocumentationSidebar())->getFooter());
+    }
+
+    public function testGetFooterReturnsStringWhenConfigIsString()
+    {
+        self::mockConfig(['docs.sidebar.footer' => 'Some footer content']);
+
+        $this->assertSame('Some footer content', (new DocumentationSidebar())->getFooter());
+    }
+
+    public function testGetFooterReturnsNullWhenConfigIsFalse()
+    {
+        self::mockConfig(['docs.sidebar.footer' => false]);
+
+        $this->assertNull((new DocumentationSidebar())->getFooter());
+    }
+
+    public function testIsCollapsibleReturnsTrueByDefault()
+    {
+        self::mockConfig();
+
+        $this->assertTrue((new DocumentationSidebar())->isCollapsible());
+    }
+
+    public function testIsCollapsibleReturnsTrueWhenConfigIsTrue()
+    {
+        self::mockConfig(['docs.sidebar.collapsible' => true]);
+
+        $this->assertTrue((new DocumentationSidebar())->isCollapsible());
+    }
+
+    public function testIsCollapsibleReturnsFalseWhenConfigIsFalse()
+    {
+        self::mockConfig(['docs.sidebar.collapsible' => false]);
+
+        $this->assertFalse((new DocumentationSidebar())->isCollapsible());
+    }
+
+    public function testHasFooterReturnsTrueByDefault()
+    {
+        self::mockConfig();
+
+        $this->assertTrue((new DocumentationSidebar())->hasFooter());
+    }
+
+    public function testHasFooterReturnsTrueWhenConfigIsString()
+    {
+        self::mockConfig(['docs.sidebar.footer' => 'Some footer content']);
+
+        $this->assertTrue((new DocumentationSidebar())->hasFooter());
+    }
+
+    public function testHasFooterReturnsFalseWhenConfigIsFalse()
+    {
+        self::mockConfig(['docs.sidebar.footer' => false]);
+
+        $this->assertFalse((new DocumentationSidebar())->hasFooter());
+    }
+
+    public function testHasGroupsReturnsFalseWhenNoItemsHaveChildren()
+    {
+        $this->assertFalse((new DocumentationSidebar())->hasGroups());
+    }
+
+    public function testHasGroupsReturnsTrueWhenAtLeastOneItemIsNavigationGroupInstance()
+    {
+        $menu = new DocumentationSidebar([
+            new NavigationGroup('foo', []),
+        ]);
+
+        $this->assertTrue($menu->hasGroups());
+    }
+
+    protected function getItems(): array
+    {
+        return [
+            $this->item('/', 'Docs'),
+            $this->item('/installation', 'Installation'),
+            $this->item('/getting-started', 'Getting Started'),
+        ];
+    }
+
+    protected function item(string $destination, string $label, int $priority = 500): NavigationItem
+    {
+        return new NavigationItem($destination, $label, $priority);
+    }
+}
diff --git a/packages/framework/tests/Unit/DropdownNavItemTest.php b/packages/framework/tests/Unit/DropdownNavItemTest.php
deleted file mode 100644
index 884045acb46..00000000000
--- a/packages/framework/tests/Unit/DropdownNavItemTest.php
+++ /dev/null
@@ -1,105 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Hyde\Framework\Testing\Unit;
-
-use Hyde\Facades\Config;
-use Hyde\Framework\Features\Navigation\DropdownNavItem;
-use Hyde\Framework\Features\Navigation\NavItem;
-use Hyde\Pages\MarkdownPage;
-use Hyde\Support\Facades\Render;
-use Hyde\Support\Models\RenderData;
-use Hyde\Support\Models\Route;
-use Hyde\Testing\UnitTestCase;
-
-/**
- * @covers \Hyde\Framework\Features\Navigation\DropdownNavItem
- */
-class DropdownNavItemTest extends UnitTestCase
-{
-    protected static bool $needsKernel = true;
-    protected static bool $needsConfig = true;
-
-    public static function setUpBeforeClass(): void
-    {
-        parent::setUpBeforeClass();
-        Render::swap(new RenderData());
-    }
-
-    public static function tearDownAfterClass(): void
-    {
-        Render::swap(new RenderData());
-    }
-
-    public function testConstruct()
-    {
-        $item = new DropdownNavItem('foo', []);
-
-        $this->assertSame('foo', $item->label);
-        $this->assertSame([], $item->items);
-        $this->assertSame(999, $item->priority);
-    }
-
-    public function testConstructWithCustomPriority()
-    {
-        $item = new DropdownNavItem('foo', [], 500);
-
-        $this->assertSame(500, $item->priority);
-    }
-
-    public function testConstructWithNullPriority()
-    {
-        $item = new DropdownNavItem('foo', [], null);
-
-        $this->assertSame(999, $item->priority);
-    }
-
-    public function testFromArray()
-    {
-        $item = DropdownNavItem::fromArray('foo', []);
-
-        $this->assertSame('foo', $item->label);
-        $this->assertSame([], $item->items);
-    }
-
-    public function testWithChildren()
-    {
-        $children = [
-            new NavItem(new Route(new MarkdownPage()), 'bar'),
-        ];
-
-        $item = new DropdownNavItem('foo', $children);
-        $this->assertSame($children, $item->items);
-
-        $item = DropdownNavItem::fromArray('foo', $children);
-        $this->assertSame($children, $item->items);
-    }
-
-    public function testGetItems()
-    {
-        $children = [
-            new NavItem(new Route(new MarkdownPage()), 'bar'),
-        ];
-
-        $item = new DropdownNavItem('foo', $children);
-        $this->assertSame($children, $item->getItems()->all());
-
-        $item = DropdownNavItem::fromArray('foo', $children);
-        $this->assertSame($children, $item->getItems()->all());
-    }
-
-    public function testCanSetPriorityInConfig()
-    {
-        $root = Config::getFacadeRoot();
-        $mock = clone $root;
-        Config::swap($mock);
-
-        Config::set('hyde.navigation.order.foo', 500);
-        $item = new DropdownNavItem('foo', []);
-
-        $this->assertSame(500, $item->priority);
-
-        Config::swap($root);
-    }
-}
diff --git a/packages/framework/tests/Unit/HydePageSerializableUnitTest.php b/packages/framework/tests/Unit/HydePageSerializableUnitTest.php
index 9462f29728c..149e184dee6 100644
--- a/packages/framework/tests/Unit/HydePageSerializableUnitTest.php
+++ b/packages/framework/tests/Unit/HydePageSerializableUnitTest.php
@@ -347,7 +347,7 @@ public function testJsonSerializedDocumentationPageContents()
                     "label": "",
                     "priority": 999,
                     "hidden": false,
-                    "group": "other"
+                    "group": null
                 },
                 "title": ""
             }
diff --git a/packages/framework/tests/Unit/NavItemTest.php b/packages/framework/tests/Unit/NavItemTest.php
deleted file mode 100644
index 379fbf581eb..00000000000
--- a/packages/framework/tests/Unit/NavItemTest.php
+++ /dev/null
@@ -1,197 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Hyde\Framework\Testing\Unit;
-
-use Hyde\Foundation\Facades\Routes;
-use Hyde\Framework\Exceptions\RouteNotFoundException;
-use Hyde\Framework\Features\Navigation\NavItem;
-use Hyde\Pages\InMemoryPage;
-use Hyde\Pages\MarkdownPage;
-use Hyde\Support\Facades\Render;
-use Hyde\Support\Models\RenderData;
-use Hyde\Support\Models\Route;
-use Hyde\Testing\UnitTestCase;
-use Mockery;
-
-/**
- * This unit test covers the basics of the NavItem class.
- * For the full feature test, see the NavigationMenuTest class.
- *
- * @covers \Hyde\Framework\Features\Navigation\NavItem
- *
- * @see \Hyde\Framework\Testing\Unit\NavItemIsCurrentHelperTest
- */
-class NavItemTest extends UnitTestCase
-{
-    public static function setUpBeforeClass(): void
-    {
-        self::$hasSetUpKernel = false;
-
-        self::needsKernel();
-        self::mockConfig();
-    }
-
-    protected function setUp(): void
-    {
-        Render::swap(new RenderData());
-    }
-
-    public function testConstruct()
-    {
-        $route = new Route(new MarkdownPage());
-        $item = new NavItem($route, 'Test', 500);
-
-        $this->assertSame($route->getLink(), $item->destination);
-    }
-
-    public function testGetDestination()
-    {
-        $navItem = new NavItem(new Route(new InMemoryPage('foo')), 'Page', 500);
-        $this->assertSame('foo.html', $navItem->getDestination());
-    }
-
-    public function testGetLabel()
-    {
-        $navItem = new NavItem(new Route(new InMemoryPage('foo')), 'Page', 500);
-        $this->assertSame('Page', $navItem->getLabel());
-    }
-
-    public function testGetPriority()
-    {
-        $navItem = new NavItem(new Route(new InMemoryPage('foo')), 'Page', 500);
-        $this->assertSame(500, $navItem->getPriority());
-    }
-
-    public function testGetGroup()
-    {
-        $navItem = new NavItem(new Route(new InMemoryPage('foo')), 'Page', 500);
-        $this->assertNull($navItem->getGroup());
-    }
-
-    public function testFromRoute()
-    {
-        $route = new Route(new MarkdownPage());
-        $item = NavItem::fromRoute($route);
-
-        $this->assertSame($route->getLink(), $item->destination);
-    }
-
-    public function testToString()
-    {
-        Render::shouldReceive('getRouteKey')->once()->andReturn('index');
-
-        $this->assertSame('index.html', (string) NavItem::fromRoute(Routes::get('index')));
-    }
-
-    public function testForLink()
-    {
-        $item = NavItem::forLink('foo', 'bar');
-
-        $this->assertSame('foo', $item->destination);
-        $this->assertSame('bar', $item->label);
-        $this->assertSame(500, $item->priority);
-    }
-
-    public function testForLinkWithCustomPriority()
-    {
-        $this->assertSame(100, NavItem::forLink('foo', 'bar', 100)->priority);
-    }
-
-    public function testForRoute()
-    {
-        $route = Routes::get('404');
-        $item = NavItem::forRoute($route, 'foo');
-
-        $this->assertSame($route->getLink(), $item->destination);
-        $this->assertSame('foo', $item->label);
-        $this->assertSame(999, $item->priority);
-    }
-
-    public function testForIndexRoute()
-    {
-        $route = Routes::get('index');
-        $item = NavItem::forRoute($route, 'foo');
-
-        $this->assertSame($route->getLink(), $item->destination);
-        $this->assertSame('foo', $item->label);
-        $this->assertSame(0, $item->priority);
-    }
-
-    public function testForRouteWithRouteKey()
-    {
-        $this->assertEquals(
-            NavItem::forRoute(Routes::get('index'), 'foo'),
-            NavItem::forRoute('index', 'foo')
-        );
-    }
-
-    public function testForRouteWithMissingRouteKey()
-    {
-        $this->expectException(RouteNotFoundException::class);
-        NavItem::forRoute('foo', 'foo');
-    }
-
-    public function testForRouteWithCustomPriority()
-    {
-        $this->assertSame(100, NavItem::forRoute(Routes::get('index'), 'foo', 100)->priority);
-    }
-
-    public function testRouteBasedNavItemDestinationsAreResolvedRelatively()
-    {
-        Render::swap(Mockery::mock(RenderData::class, [
-            'getRoute' => (new Route(new InMemoryPage('foo'))),
-            'getRouteKey' => 'foo',
-        ]));
-
-        $this->assertSame('foo.html', (string) NavItem::fromRoute(new Route(new InMemoryPage('foo'))));
-        $this->assertSame('foo/bar.html', (string) NavItem::fromRoute(new Route(new InMemoryPage('foo/bar'))));
-
-        Render::swap(Mockery::mock(RenderData::class, [
-            'getRoute' => (new Route(new InMemoryPage('foo/bar'))),
-            'getRouteKey' => 'foo/bar',
-        ]));
-
-        $this->assertSame('../foo.html', (string) NavItem::fromRoute(new Route(new InMemoryPage('foo'))));
-        $this->assertSame('../foo/bar.html', (string) NavItem::fromRoute(new Route(new InMemoryPage('foo/bar'))));
-
-        Render::swap(Mockery::mock(RenderData::class, [
-            'getRoute' => (new Route(new InMemoryPage('foo/bar/baz'))),
-            'getRouteKey' => 'foo/bar/baz',
-        ]));
-
-        $this->assertSame('../../foo.html', (string) NavItem::fromRoute(new Route(new InMemoryPage('foo'))));
-        $this->assertSame('../../foo/bar.html', (string) NavItem::fromRoute(new Route(new InMemoryPage('foo/bar'))));
-    }
-
-    public function testIsCurrent()
-    {
-        Render::swap(Mockery::mock(RenderData::class, [
-            'getRoute' => (new Route(new InMemoryPage('foo'))),
-            'getRouteKey' => 'foo',
-        ]));
-        $this->assertTrue(NavItem::fromRoute(new Route(new InMemoryPage('foo')))->isCurrent());
-        $this->assertFalse(NavItem::fromRoute(new Route(new InMemoryPage('bar')))->isCurrent());
-    }
-
-    public function testGetGroupWithNoGroup()
-    {
-        $this->assertNull((new NavItem(new Route(new MarkdownPage()), 'Test', 500))->getGroup());
-    }
-
-    public function testGetGroupWithGroup()
-    {
-        $this->assertSame('foo', (new NavItem(new Route(new MarkdownPage()), 'Test', 500, 'foo'))->getGroup());
-    }
-
-    public function testGetGroupFromRouteWithGroup()
-    {
-        $this->assertSame('foo', NavItem::fromRoute(new Route(new MarkdownPage(matter: ['navigation.group' => 'foo'])))->getGroup());
-    }
-
-    public function testGetGroupForRouteWithGroup()
-    {
-        $this->assertSame('foo', NavItem::forRoute(new Route(new MarkdownPage(matter: ['navigation.group' => 'foo'])), 'foo')->getGroup());
-    }
-}
diff --git a/packages/framework/tests/Unit/NavigationDataFactoryUnitTest.php b/packages/framework/tests/Unit/NavigationDataFactoryUnitTest.php
index a118c695723..85719ae6611 100644
--- a/packages/framework/tests/Unit/NavigationDataFactoryUnitTest.php
+++ b/packages/framework/tests/Unit/NavigationDataFactoryUnitTest.php
@@ -74,7 +74,7 @@ public function testSearchForPriorityInNavigationConfigForMarkdownPageSupportsMi
 
     public function testSearchForPriorityInNavigationConfigForDocumentationPageWithListConfig()
     {
-        self::mockConfig(['docs.sidebar_order' => [
+        self::mockConfig(['docs.sidebar.order' => [
             'foo' => 15,
             'bar' => 10,
         ]]);
@@ -88,7 +88,7 @@ public function testSearchForPriorityInNavigationConfigForDocumentationPageWithL
 
     public function testSearchForPriorityInNavigationConfigForDocumentationPageWithKeyedConfig()
     {
-        self::mockConfig(['docs.sidebar_order' => [
+        self::mockConfig(['docs.sidebar.order' => [
             'foo',
             'bar' => 10,
             'baz',
@@ -109,7 +109,7 @@ public function testSearchForPriorityInNavigationConfigForDocumentationPageWithK
 
     public function testSearchForPriorityInNavigationConfigForDocumentationPageSupportsMixingKeyedAndListConfig()
     {
-        self::mockConfig(['docs.sidebar_order' => [
+        self::mockConfig(['docs.sidebar.order' => [
             'foo',
             'bar' => 10,
             'baz',
@@ -130,7 +130,7 @@ public function testSearchForPriorityInNavigationConfigForDocumentationPageSuppo
 
     public function testRouteKeysCanBeUsedForDocumentationSidebarPriorities()
     {
-        self::mockConfig(['docs.sidebar_order' => [
+        self::mockConfig(['docs.sidebar.order' => [
             'key/foo',
             'key/bar',
             'baz',
@@ -146,6 +146,97 @@ public function testRouteKeysCanBeUsedForDocumentationSidebarPriorities()
         $this->assertSame(502, $factory->makePriority());
     }
 
+    public function testSearchForLabelInNavigationConfigForMarkdownPage()
+    {
+        self::mockConfig([
+            'hyde.navigation.labels' => [
+                'foo' => 'Foo Label',
+                'bar' => 'Bar Label',
+            ],
+        ]);
+
+        $factory = new NavigationConfigTestClass($this->makeCoreDataObject(routeKey: 'foo'));
+        $this->assertSame('Foo Label', $factory->makeLabel());
+
+        $factory = new NavigationConfigTestClass($this->makeCoreDataObject(routeKey: 'bar'));
+        $this->assertSame('Bar Label', $factory->makeLabel());
+    }
+
+    public function testSearchForLabelInSidebarConfigForDocumentationPage()
+    {
+        self::mockConfig([
+            'docs.sidebar.labels' => [
+                'foo' => 'Documentation Foo Label',
+                'bar' => 'Documentation Bar Label',
+            ],
+        ]);
+
+        $factory = new NavigationConfigTestClass($this->makeCoreDataObject(routeKey: 'foo', pageClass: DocumentationPage::class));
+        $this->assertSame('Documentation Foo Label', $factory->makeLabel());
+
+        $factory = new NavigationConfigTestClass($this->makeCoreDataObject(routeKey: 'bar', pageClass: DocumentationPage::class));
+        $this->assertSame('Documentation Bar Label', $factory->makeLabel());
+    }
+
+    public function testLabelFallbackToTitleIfNotDefinedInConfig()
+    {
+        self::mockConfig([
+            'hyde.navigation.labels' => [],
+            'docs.sidebar.labels' => [],
+        ]);
+
+        // Assuming the title fallback is correctly set in front matter or title property
+        $frontMatter = new FrontMatter(['title' => 'Fallback Title']);
+        $coreDataObject = new CoreDataObject($frontMatter, new Markdown(), MarkdownPage::class, '', '', '', 'undefinedKey');
+
+        $factory = new NavigationConfigTestClass($coreDataObject);
+        $this->assertSame('Fallback Title', $factory->makeLabel());
+    }
+
+    public function testPageIsHiddenBasedOnNavigationConfiguration()
+    {
+        self::mockConfig(['hyde.navigation.exclude' => ['hiddenPage']]);
+
+        $factory = new NavigationConfigTestClass($this->makeCoreDataObject(routeKey: 'hiddenPage'));
+        $this->assertTrue($factory->makeHidden());
+
+        $factory = new NavigationConfigTestClass($this->makeCoreDataObject(routeKey: 'visiblePage'));
+        $this->assertFalse($factory->makeHidden());
+    }
+
+    public function testPageIsHiddenBasedOnSidebarConfigurationForDocumentationPage()
+    {
+        self::mockConfig(['docs.sidebar.exclude' => ['hiddenDocPage']]);
+
+        $factory = new NavigationConfigTestClass($this->makeCoreDataObject('hiddenDocPage', pageClass: DocumentationPage::class));
+        $this->assertTrue($factory->makeHidden());
+
+        $factory = new NavigationConfigTestClass($this->makeCoreDataObject('visibleDocPage', pageClass: DocumentationPage::class));
+        $this->assertFalse($factory->makeHidden());
+    }
+
+    public function testSearchForHiddenInConfigsSelectsCorrectConfigurationBasedOnPageType()
+    {
+        self::mockConfig([
+            'hyde.navigation.exclude' => ['hiddenPage'],
+            'docs.sidebar.exclude' => ['hiddenDocPage'],
+        ]);
+
+        // Test for a Markdown page, should use navigation.exclude config
+        $factory = new NavigationConfigTestClass($this->makeCoreDataObject(routeKey: 'hiddenPage'));
+        $this->assertTrue($factory->makeHidden());
+
+        $factory = new NavigationConfigTestClass($this->makeCoreDataObject(routeKey: 'visiblePage'));
+        $this->assertFalse($factory->makeHidden());
+
+        // Test for a Documentation page, should use docs.sidebar.exclude config
+        $factory = new NavigationConfigTestClass($this->makeCoreDataObject('hiddenDocPage', pageClass: DocumentationPage::class));
+        $this->assertTrue($factory->makeHidden());
+
+        $factory = new NavigationConfigTestClass($this->makeCoreDataObject('visibleDocPage', pageClass: DocumentationPage::class));
+        $this->assertFalse($factory->makeHidden());
+    }
+
     protected function makeCoreDataObject(string $identifier = '', string $routeKey = '', string $pageClass = MarkdownPage::class): CoreDataObject
     {
         return new CoreDataObject(new FrontMatter(), new Markdown(), $pageClass, $identifier, '', '', $routeKey);
@@ -163,4 +254,14 @@ public function makePriority(): int
     {
         return parent::makePriority();
     }
+
+    public function makeLabel(): ?string
+    {
+        return parent::makeLabel();
+    }
+
+    public function makeHidden(): bool
+    {
+        return parent::makeHidden();
+    }
 }
diff --git a/packages/framework/tests/Unit/NavigationGroupTest.php b/packages/framework/tests/Unit/NavigationGroupTest.php
new file mode 100644
index 00000000000..a9ad9646633
--- /dev/null
+++ b/packages/framework/tests/Unit/NavigationGroupTest.php
@@ -0,0 +1,219 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Testing\Unit;
+
+use Hyde\Pages\MarkdownPage;
+use Hyde\Pages\InMemoryPage;
+use Hyde\Testing\UnitTestCase;
+use Hyde\Support\Models\Route;
+use Hyde\Pages\DocumentationPage;
+use Hyde\Foundation\HydeCoreExtension;
+use Hyde\Framework\Features\Navigation\NavigationItem;
+use Hyde\Framework\Features\Navigation\NavigationGroup;
+
+/**
+ * @covers \Hyde\Framework\Features\Navigation\NavigationGroup
+ */
+class NavigationGroupTest extends UnitTestCase
+{
+    public static function setUpBeforeClass(): void
+    {
+        self::needsKernel();
+        self::mockConfig();
+    }
+
+    public function testCanConstruct()
+    {
+        $this->assertInstanceOf(NavigationGroup::class, new NavigationGroup('Foo'));
+        $this->assertSame('Foo', (new NavigationGroup('Foo'))->getLabel());
+    }
+
+    public function testCanConstructWithPriority()
+    {
+        $this->assertSame(500, (new NavigationGroup('Foo', priority: 500))->getPriority());
+    }
+
+    public function testDefaultPriorityValueIsLast()
+    {
+        $this->assertSame(999, (new NavigationGroup('Foo'))->getPriority());
+    }
+
+    public function testCanConstructWithChildren()
+    {
+        $children = $this->createNavigationItems();
+        $item = new NavigationGroup('Foo', $children);
+
+        $this->assertCount(2, $item->getItems()->all());
+        $this->assertSame($children, $item->getItems()->all());
+    }
+
+    public function testCanConstructWithChildrenWithoutRoute()
+    {
+        $children = $this->createNavigationItems();
+        $item = new NavigationGroup('Foo', $children);
+
+        $this->assertCount(2, $item->getItems()->all());
+        $this->assertSame($children, $item->getItems()->all());
+    }
+
+    public function testCreate()
+    {
+        $this->assertEquals(
+            new NavigationGroup('Foo', [new NavigationItem(new Route(new InMemoryPage('foo')), 'Foo')], 100),
+            NavigationGroup::create('Foo', [new NavigationItem(new Route(new InMemoryPage('foo')), 'Foo')], 100)
+        );
+    }
+
+    public function testGetItems()
+    {
+        $children = $this->createNavigationItems();
+        $item = new NavigationGroup('Foo', $children);
+
+        $this->assertSame($children, $item->getItems()->all());
+        $this->assertEquals(collect($children), $item->getItems());
+    }
+
+    public function testGetItemsWithNoItems()
+    {
+        $this->assertEmpty((new NavigationGroup('Foo'))->getItems()->all());
+    }
+
+    public function testCanAddItemToDropdown()
+    {
+        $group = new NavigationGroup('Foo');
+        $child = new NavigationItem(new Route(new MarkdownPage()), 'Bar');
+
+        $this->assertSame([$child], $group->add($child)->getItems()->all());
+    }
+
+    public function testAddChildMethodReturnsSelf()
+    {
+        $group = new NavigationGroup('Foo');
+        $child = new NavigationItem(new Route(new MarkdownPage()), 'Bar');
+
+        $this->assertSame($group, $group->add($child));
+    }
+
+    public function testCanAddMultipleItemsToDropdown()
+    {
+        $group = new NavigationGroup('Foo');
+        $items = $this->createNavigationItems();
+
+        $this->assertSame($items, $group->add($items)->getItems()->all());
+    }
+
+    public function testCanAddGroupsToDropdown()
+    {
+        $group = new NavigationGroup('Foo');
+        $child = new NavigationGroup('Bar');
+
+        $this->assertSame([$child], $group->add($child)->getItems()->all());
+    }
+
+    public function testAddChildrenMethodReturnsSelf()
+    {
+        $group = new NavigationGroup('Foo');
+
+        $this->assertSame($group, $group->add([]));
+    }
+
+    public function testItemsOrderingDefaultsToAddOrder()
+    {
+        $group = new NavigationGroup('Group', [
+            new NavigationItem(new Route(new MarkdownPage()), 'Foo'),
+            new NavigationItem(new Route(new MarkdownPage()), 'Bar'),
+            new NavigationItem(new Route(new MarkdownPage()), 'Baz'),
+        ]);
+
+        $this->assertSame(['Foo', 'Bar', 'Baz'], $group->getItems()->map(fn (NavigationItem $item) => $item->getLabel())->all());
+    }
+
+    public function testItemsAreSortedByPriority()
+    {
+        $group = new NavigationGroup('Group', [
+            new NavigationItem(new Route(new MarkdownPage()), 'Foo', 3),
+            new NavigationItem(new Route(new MarkdownPage()), 'Bar', 2),
+            new NavigationItem(new Route(new MarkdownPage()), 'Baz', 1),
+        ]);
+
+        $this->assertSame(['Baz', 'Bar', 'Foo'], $group->getItems()->map(fn (NavigationItem $item) => $item->getLabel())->all());
+    }
+
+    public function testGetPriorityUsesDefaultPriority()
+    {
+        $this->assertSame(999, (new NavigationGroup('Foo'))->getPriority());
+    }
+
+    public function testGetPriorityWithNoChildrenUsesGroupPriority()
+    {
+        $this->assertSame(999, (new NavigationGroup('Foo'))->getPriority());
+    }
+
+    public function testGetPriorityWithChildrenUsesGroupPriority()
+    {
+        $group = new NavigationGroup('Foo', [new NavigationItem(new Route(new MarkdownPage()), 'Bar', 100)]);
+
+        $this->assertSame(999, $group->getPriority());
+    }
+
+    public function testGetPriorityWithDocumentationPageChildrenUsesLowestPriority()
+    {
+        $items = [
+            new NavigationItem(new Route(new DocumentationPage()), 'Foo', 100),
+            new NavigationItem(new Route(new DocumentationPage()), 'Bar', 200),
+            new NavigationItem(new Route(new DocumentationPage()), 'Baz', 300),
+        ];
+
+        $this->assertSame(100, (new NavigationGroup('Foo', $items))->getPriority());
+        $this->assertSame(100, (new NavigationGroup('Foo', array_reverse($items)))->getPriority());
+    }
+
+    public function testGetPriorityUsesGroupPriorityForMixedChildTypes()
+    {
+        $group = new NavigationGroup('Foo');
+
+        foreach (HydeCoreExtension::getPageClasses() as $type) {
+            $child = new NavigationItem(new Route(new $type()), 'Bar', 100);
+            $group->add($child);
+        }
+
+        $this->assertSame(999, $group->getPriority());
+    }
+
+    public function testGetPriorityHandlesStringUrlChildGracefully()
+    {
+        $this->assertSame(999, (new NavigationGroup('Foo', [new NavigationItem('foo', 'Bar', 100)]))->getPriority());
+    }
+
+    public function testGetPriorityHandlesExternalUrlChildGracefully()
+    {
+        $this->assertSame(999, (new NavigationGroup('Foo', [new NavigationItem('https://example.com', 'Bar', 100)]))->getPriority());
+    }
+
+    public function testModifierMethodsAreFluentlyChainable()
+    {
+        $group = new NavigationGroup('Foo');
+
+        $this->assertSame($group, $group->add(new NavigationItem(new Route(new MarkdownPage()), 'Bar')));
+        $this->assertSame($group, $group->add([new NavigationItem(new Route(new MarkdownPage()), 'Bar')]));
+    }
+
+    public function testNormalizeGroupKeyCreatesSlugs()
+    {
+        $this->assertSame('foo-bar', NavigationGroup::normalizeGroupKey('Foo Bar'));
+        $this->assertSame('foo-bar', NavigationGroup::normalizeGroupKey('foo bar'));
+        $this->assertSame('foo-bar', NavigationGroup::normalizeGroupKey('foo_bar'));
+        $this->assertSame('foo-bar', NavigationGroup::normalizeGroupKey('foo-bar'));
+        $this->assertSame('foo-bar', NavigationGroup::normalizeGroupKey(' foo bar '));
+    }
+
+    protected function createNavigationItems(): array
+    {
+        return [
+            new NavigationItem(new Route(new InMemoryPage('foo')), 'Foo'),
+            new NavigationItem(new Route(new InMemoryPage('bar')), 'Bar'),
+        ];
+    }
+}
diff --git a/packages/framework/tests/Unit/NavItemIsCurrentHelperTest.php b/packages/framework/tests/Unit/NavigationItemIsActiveHelperTest.php
similarity index 65%
rename from packages/framework/tests/Unit/NavItemIsCurrentHelperTest.php
rename to packages/framework/tests/Unit/NavigationItemIsActiveHelperTest.php
index d9500006247..e747d0b9f0f 100644
--- a/packages/framework/tests/Unit/NavItemIsCurrentHelperTest.php
+++ b/packages/framework/tests/Unit/NavigationItemIsActiveHelperTest.php
@@ -5,7 +5,7 @@
 namespace Hyde\Framework\Testing\Unit;
 
 use Hyde\Foundation\Facades\Routes;
-use Hyde\Framework\Features\Navigation\NavItem;
+use Hyde\Framework\Features\Navigation\NavigationItem;
 use Hyde\Pages\InMemoryPage;
 use Hyde\Support\Facades\Render;
 use Hyde\Support\Models\RenderData;
@@ -14,11 +14,11 @@
 use Mockery;
 
 /**
- * @covers \Hyde\Framework\Features\Navigation\NavItem
+ * @covers \Hyde\Framework\Features\Navigation\NavigationItem
  *
- * @see \Hyde\Framework\Testing\Unit\NavItemTest
+ * @see \Hyde\Framework\Testing\Unit\NavigationItemTest
  */
-class NavItemIsCurrentHelperTest extends UnitTestCase
+class NavigationItemIsActiveHelperTest extends UnitTestCase
 {
     public static function setUpBeforeClass(): void
     {
@@ -34,205 +34,205 @@ protected function tearDown(): void
     public function testIsCurrent()
     {
         $this->mockRenderData($this->makeRoute('foo'));
-        $this->assertFalse(NavItem::fromRoute($this->makeRoute('bar'))->isCurrent());
+        $this->assertFalse(NavigationItem::create($this->makeRoute('bar'))->isActive());
     }
 
     public function testIsCurrentWhenCurrent()
     {
         $this->mockRenderData($this->makeRoute('foo'));
-        $this->assertTrue(NavItem::fromRoute($this->makeRoute('foo'))->isCurrent());
+        $this->assertTrue(NavigationItem::create($this->makeRoute('foo'))->isActive());
     }
 
     public function testIsCurrentUsingCurrentRoute()
     {
         $this->mockRenderData($this->makeRoute('index'));
-        $this->assertTrue(NavItem::fromRoute(Routes::get('index'))->isCurrent());
+        $this->assertTrue(NavigationItem::create(Routes::get('index'))->isActive());
     }
 
     public function testIsCurrentUsingCurrentLink()
     {
         $this->mockRenderData($this->makeRoute('index'));
-        $this->assertTrue(NavItem::forLink('index.html', 'Home')->isCurrent());
+        $this->assertTrue(NavigationItem::create('index.html', 'Home')->isActive());
     }
 
     public function testIsCurrentWhenNotCurrent()
     {
         $this->mockRenderData($this->makeRoute('foo'));
-        $this->assertFalse(NavItem::fromRoute($this->makeRoute('bar'))->isCurrent());
+        $this->assertFalse(NavigationItem::create($this->makeRoute('bar'))->isActive());
     }
 
     public function testIsCurrentUsingNotCurrentRoute()
     {
         $this->mockRenderData($this->makeRoute('foo'));
-        $this->assertFalse(NavItem::fromRoute(Routes::get('index'))->isCurrent());
+        $this->assertFalse(NavigationItem::create(Routes::get('index'))->isActive());
     }
 
     public function testIsCurrentUsingNotCurrentLink()
     {
         $this->mockRenderData($this->makeRoute('foo'));
-        $this->assertFalse(NavItem::forLink('index.html', 'Home')->isCurrent());
+        $this->assertFalse(NavigationItem::create('index.html', 'Home')->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPage()
     {
         $this->mockRenderData($this->makeRoute('foo/bar'));
-        $this->assertFalse(NavItem::fromRoute($this->makeRoute('bar'))->isCurrent());
+        $this->assertFalse(NavigationItem::create($this->makeRoute('bar'))->isActive());
     }
 
     public function testIsCurrentWhenCurrentWithNestedCurrentPage()
     {
         $this->mockRenderData($this->makeRoute('foo/bar'));
-        $this->assertTrue(NavItem::fromRoute($this->makeRoute('foo/bar'))->isCurrent());
+        $this->assertTrue(NavigationItem::create($this->makeRoute('foo/bar'))->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPageWhenNested()
     {
         $this->mockRenderData($this->makeRoute('foo/bar'));
-        $this->assertTrue(NavItem::fromRoute($this->makeRoute('foo/bar'))->isCurrent());
+        $this->assertTrue(NavigationItem::create($this->makeRoute('foo/bar'))->isActive());
     }
 
     public function testIsCurrentWhenCurrentWithNestedCurrentPageWhenNested()
     {
         $this->mockRenderData($this->makeRoute('foo/bar'));
-        $this->assertFalse(NavItem::fromRoute($this->makeRoute('foo/baz'))->isCurrent());
+        $this->assertFalse(NavigationItem::create($this->makeRoute('foo/baz'))->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPageWhenVeryNested()
     {
         $this->mockRenderData($this->makeRoute('foo/bar/baz'));
-        $this->assertTrue(NavItem::fromRoute($this->makeRoute('foo/bar/baz'))->isCurrent());
+        $this->assertTrue(NavigationItem::create($this->makeRoute('foo/bar/baz'))->isActive());
     }
 
     public function testIsCurrentWhenCurrentWithNestedCurrentPageWhenVeryNested()
     {
         $this->mockRenderData($this->makeRoute('foo/bar/baz'));
-        $this->assertFalse(NavItem::fromRoute($this->makeRoute('foo/baz/bar'))->isCurrent());
+        $this->assertFalse(NavigationItem::create($this->makeRoute('foo/baz/bar'))->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPageWhenVeryDifferingNested()
     {
         $this->mockRenderData($this->makeRoute('foo'));
-        $this->assertFalse(NavItem::fromRoute($this->makeRoute('foo/bar/baz'))->isCurrent());
+        $this->assertFalse(NavigationItem::create($this->makeRoute('foo/bar/baz'))->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPageWhenVeryDifferingNestedInverse()
     {
         $this->mockRenderData($this->makeRoute('foo/bar/baz'));
-        $this->assertFalse(NavItem::fromRoute($this->makeRoute('foo'))->isCurrent());
+        $this->assertFalse(NavigationItem::create($this->makeRoute('foo'))->isActive());
     }
 
     public function testIsCurrentUsingCurrentLinkWithNestedCurrentPage()
     {
         $this->mockRenderData($this->makeRoute('foo/bar'));
-        $this->assertFalse(NavItem::forLink('foo/bar.html', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo/bar.html', 'foo')->isActive());
     }
 
     public function testIsCurrentUsingNotCurrentLinkWithNestedCurrentPage()
     {
         $this->mockRenderData($this->makeRoute('foo/bar'));
-        $this->assertFalse(NavItem::forLink('foo.html', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo.html', 'foo')->isActive());
     }
 
     public function testIsCurrentWhenCurrentWithNestedCurrentPageAndSubjectPage()
     {
         $this->mockRenderData($this->makeRoute('foo/bar'));
-        $this->assertFalse(NavItem::forLink('foo/bar.html', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo/bar.html', 'foo')->isActive());
     }
 
     public function testIsCurrentWhenNotCurrentWithNestedCurrentPageAndSubjectPage()
     {
         $this->mockRenderData($this->makeRoute('foo/bar'));
-        $this->assertFalse(NavItem::forLink('foo/baz.html', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo/baz.html', 'foo')->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPageWhenNestedUsingLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo/bar'));
-        $this->assertFalse(NavItem::forLink('foo/bar.html', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo/bar.html', 'foo')->isActive());
     }
 
     public function testIsCurrentWhenCurrentWithNestedCurrentPageWhenNestedUsingLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo/bar'));
-        $this->assertFalse(NavItem::forLink('foo/baz.html', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo/baz.html', 'foo')->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPageWhenVeryNestedUsingLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo/bar/baz'));
-        $this->assertFalse(NavItem::forLink('foo/bar/baz.html', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo/bar/baz.html', 'foo')->isActive());
     }
 
     public function testIsCurrentWhenCurrentWithNestedCurrentPageWhenVeryNestedUsingLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo/bar/baz'));
-        $this->assertFalse(NavItem::forLink('foo/baz/bar.html', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo/baz/bar.html', 'foo')->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPageWhenVeryDifferingNestedUsingLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo'));
-        $this->assertFalse(NavItem::forLink('foo/bar/baz.html', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo/bar/baz.html', 'foo')->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPageWhenVeryDifferingNestedInverseUsingLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo/bar/baz'));
-        $this->assertFalse(NavItem::forLink('foo.html', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo.html', 'foo')->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPageWhenNestedUsingPrettyLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo/bar'));
-        $this->assertFalse(NavItem::forLink('foo/bar', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo/bar', 'foo')->isActive());
     }
 
     public function testIsCurrentWhenCurrentWithNestedCurrentPageWhenNestedUsingPrettyLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo/bar'));
-        $this->assertFalse(NavItem::forLink('foo/baz', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo/baz', 'foo')->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPageWhenVeryNestedUsingPrettyLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo/bar/baz'));
-        $this->assertFalse(NavItem::forLink('foo/bar/baz', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo/bar/baz', 'foo')->isActive());
     }
 
     public function testIsCurrentWhenCurrentWithNestedCurrentPageWhenVeryNestedUsingPrettyLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo/bar/baz'));
-        $this->assertFalse(NavItem::forLink('foo/baz/bar', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo/baz/bar', 'foo')->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPageWhenVeryDifferingNestedUsingPrettyLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo'));
-        $this->assertFalse(NavItem::forLink('foo/bar/baz', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo/bar/baz', 'foo')->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPageWhenVeryDifferingNestedInverseUsingPrettyLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo/bar/baz'));
-        $this->assertFalse(NavItem::forLink('foo', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('foo', 'foo')->isActive());
     }
 
     public function testIsCurrentWithAbsoluteLink()
     {
         $this->mockRenderData($this->makeRoute('foo'));
-        $this->assertFalse(NavItem::forLink('/foo', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('/foo', 'foo')->isActive());
     }
 
     public function testIsCurrentWithNestedCurrentPageWhenNestedUsingAbsoluteLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo/bar'));
-        $this->assertFalse(NavItem::forLink('/foo/bar', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('/foo/bar', 'foo')->isActive());
     }
 
     public function testIsCurrentWhenCurrentWithNestedCurrentPageWhenNestedUsingAbsoluteLinkItem()
     {
         $this->mockRenderData($this->makeRoute('foo/bar/baz'));
-        $this->assertFalse(NavItem::forLink('/foo/bar/baz', 'foo')->isCurrent());
+        $this->assertFalse(NavigationItem::create('/foo/bar/baz', 'foo')->isActive());
     }
 
     protected function mockRenderData(Route $route): void
diff --git a/packages/framework/tests/Unit/NavigationItemTest.php b/packages/framework/tests/Unit/NavigationItemTest.php
new file mode 100644
index 00000000000..e0a669adf9a
--- /dev/null
+++ b/packages/framework/tests/Unit/NavigationItemTest.php
@@ -0,0 +1,328 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Testing\Unit;
+
+use Hyde\Foundation\Facades\Routes;
+use Hyde\Framework\Features\Navigation\NavigationItem;
+use Hyde\Pages\InMemoryPage;
+use Hyde\Pages\MarkdownPage;
+use Hyde\Support\Facades\Render;
+use Hyde\Support\Models\RenderData;
+use Hyde\Support\Models\Route;
+use Hyde\Testing\UnitTestCase;
+use Mockery;
+use Hyde\Framework\Features\Navigation\NavigationGroup;
+
+/**
+ * This unit test covers the basics of the NavigationItem class.
+ * For the full feature test, see the MainNavigationMenuTest class.
+ *
+ * @covers \Hyde\Framework\Features\Navigation\NavigationItem
+ *
+ * @see \Hyde\Framework\Testing\Unit\NavigationItemIsActiveHelperTest
+ */
+class NavigationItemTest extends UnitTestCase
+{
+    public static function setUpBeforeClass(): void
+    {
+        self::$hasSetUpKernel = false;
+
+        self::needsKernel();
+        self::mockConfig();
+    }
+
+    protected function setUp(): void
+    {
+        Render::swap(new RenderData());
+    }
+
+    public function testConstruct()
+    {
+        $this->assertInstanceOf(NavigationItem::class, new NavigationItem('foo', 'Test'));
+        $this->assertInstanceOf(NavigationItem::class, new NavigationItem(new Route(new MarkdownPage()), 'Test'));
+        $this->assertInstanceOf(NavigationItem::class, new NavigationItem(new Route(new MarkdownPage()), 'Test', 500));
+    }
+
+    public function testPassingRouteInstanceToConstructorUsesRouteInstance()
+    {
+        $route = new Route(new MarkdownPage());
+        $this->assertEquals($route, (new NavigationItem($route, 'Home'))->getPage()->getRoute());
+    }
+
+    public function testPassingRouteKeyToConstructorUsesDestinationAsRoute()
+    {
+        $item = new NavigationItem('index', 'Home');
+        $this->assertSame(Routes::get('index')->getPage(), $item->getPage());
+        $this->assertSame('index', $item->getPage()->getRouteKey());
+        $this->assertSame('index.html', $item->getLink());
+    }
+
+    public function testPassingUrlToConstructorSetsRouteToNull()
+    {
+        $item = new NavigationItem('https://example.com', 'Home');
+        $this->assertNull($item->getPage());
+        $this->assertSame('https://example.com', $item->getLink());
+    }
+
+    public function testPassingUnknownRouteKeyToConstructorSetsRouteToNull()
+    {
+        $item = new NavigationItem('foo', 'Home');
+        $this->assertNull($item->getPage());
+        $this->assertSame('foo', $item->getLink());
+    }
+
+    public function testCanGetPage()
+    {
+        $page = new MarkdownPage();
+        $item = new NavigationItem(new Route($page), 'Test', 500);
+
+        $this->assertSame($page, $item->getPage());
+    }
+
+    public function testGetPageRoute()
+    {
+        $route = new Route(new InMemoryPage('foo'));
+        $NavigationItem = new NavigationItem($route, 'Page', 500);
+
+        $this->assertEquals($route, $NavigationItem->getPage()->getRoute());
+    }
+
+    public function testGetLink()
+    {
+        $NavigationItem = new NavigationItem(new Route(new InMemoryPage('foo')), 'Page', 500);
+        $this->assertSame('foo.html', $NavigationItem->getLink());
+    }
+
+    public function testGetLabel()
+    {
+        $NavigationItem = new NavigationItem(new Route(new InMemoryPage('foo')), 'Page', 500);
+        $this->assertSame('Page', $NavigationItem->getLabel());
+    }
+
+    public function testGetPriority()
+    {
+        $NavigationItem = new NavigationItem(new Route(new InMemoryPage('foo')), 'Page', 500);
+        $this->assertSame(500, $NavigationItem->getPriority());
+    }
+
+    public function testFromRoute()
+    {
+        $page = new MarkdownPage();
+        $route = new Route($page);
+        $item = NavigationItem::create($route);
+
+        $this->assertSame($page, $item->getPage());
+        $this->assertEquals($route, $item->getPage()->getRoute());
+    }
+
+    public function testToString()
+    {
+        Render::shouldReceive('getRouteKey')->once()->andReturn('index');
+
+        $this->assertSame('index.html', (string) NavigationItem::create(Routes::get('index')));
+    }
+
+    public function testCreateWithLink()
+    {
+        $item = NavigationItem::create('foo', 'bar');
+
+        $this->assertNull($item->getPage());
+        $this->assertSame('foo', $item->getLink());
+        $this->assertSame('bar', $item->getLabel());
+        $this->assertSame(500, $item->getPriority());
+    }
+
+    public function testCreateWithLinkWithCustomPriority()
+    {
+        $this->assertSame(100, NavigationItem::create('foo', 'bar', 100)->getPriority());
+    }
+
+    public function testCreate()
+    {
+        $route = Routes::get('404');
+        $item = NavigationItem::create($route, 'foo');
+
+        $this->assertSame($route->getPage(), $item->getPage());
+        $this->assertSame('foo', $item->getLabel());
+        $this->assertSame(999, $item->getPriority());
+        $this->assertEquals($route, $item->getPage()->getRoute());
+        $this->assertSame('404.html', $item->getLink());
+        $this->assertSame('404.html', (string) $item);
+    }
+
+    public function testForIndexRoute()
+    {
+        $route = Routes::get('index');
+        $item = NavigationItem::create($route);
+
+        $this->assertSame($route->getPage(), $item->getPage());
+        $this->assertSame('Home', $item->getLabel());
+        $this->assertSame(0, $item->getPriority());
+        $this->assertEquals($route, $item->getPage()->getRoute());
+        $this->assertSame('index.html', $item->getLink());
+        $this->assertSame('index.html', (string) $item);
+    }
+
+    public function testCreateWithLabels()
+    {
+        $route = Routes::get('404');
+        $item = NavigationItem::create($route, 'foo');
+        $this->assertSame('foo', $item->getLabel());
+
+        $route = Routes::get('index');
+        $item = NavigationItem::create($route);
+        $this->assertSame('Home', $item->getLabel());
+    }
+
+    public function testCreateWithRouteKey()
+    {
+        $this->assertEquals(
+            NavigationItem::create(Routes::get('index'), 'foo'),
+            NavigationItem::create('index', 'foo')
+        );
+    }
+
+    public function testCreateWithMissingRouteKey()
+    {
+        $this->assertNull(NavigationItem::create('foo', 'foo')->getPage());
+    }
+
+    public function testCreateWithCustomPriority()
+    {
+        $this->assertSame(100, NavigationItem::create(Routes::get('index'), 'foo', 100)->getPriority());
+    }
+
+    public function testCreateWithNullLabelForRoute()
+    {
+        $this->assertSame('Home', NavigationItem::create('index')->getLabel());
+    }
+
+    public function testCreateWithNullLabel()
+    {
+        $this->assertSame('foo', NavigationItem::create('foo')->getLabel());
+
+        $links = [
+            'www.example.com',
+            'https://example.com',
+            'https://example.com/',
+            'https://example.com/foo',
+            'https://example.com/foo/',
+            'https://example.com/foo/bar',
+            'https://example.com/foo/bar.html',
+            'https://example.com/foo/bar.png',
+        ];
+
+        foreach ($links as $link) {
+            $this->assertSame($link, NavigationItem::create($link)->getLabel());
+        }
+    }
+
+    public function testConstructWithNullLabel()
+    {
+        $this->assertSame('foo', (new NavigationItem('foo'))->getLabel());
+
+        $links = [
+            'www.example.com',
+            'https://example.com',
+            'https://example.com/',
+            'https://example.com/foo',
+            'https://example.com/foo/',
+            'https://example.com/foo/bar',
+            'https://example.com/foo/bar.html',
+            'https://example.com/foo/bar.png',
+        ];
+
+        foreach ($links as $link) {
+            $this->assertSame($link, (new NavigationItem($link))->getLabel());
+        }
+    }
+
+    public function testPassingRouteKeyToStaticConstructorUsesRouteInstance()
+    {
+        $route = Routes::get('index');
+        $item = NavigationItem::create('index', 'Home');
+        $this->assertNotNull($item->getPage());
+        $this->assertSame($route->getPage(), $item->getPage());
+    }
+
+    public function testRouteBasedNavigationItemDestinationsAreResolvedRelatively()
+    {
+        Render::swap(Mockery::mock(RenderData::class, [
+            'getRoute' => new Route(new InMemoryPage('foo')),
+            'getRouteKey' => 'foo',
+        ]));
+
+        $this->assertSame('foo.html', (string) NavigationItem::create(new Route(new InMemoryPage('foo'))));
+        $this->assertSame('foo/bar.html', (string) NavigationItem::create(new Route(new InMemoryPage('foo/bar'))));
+
+        Render::swap(Mockery::mock(RenderData::class, [
+            'getRoute' => new Route(new InMemoryPage('foo/bar')),
+            'getRouteKey' => 'foo/bar',
+        ]));
+
+        $this->assertSame('../foo.html', (string) NavigationItem::create(new Route(new InMemoryPage('foo'))));
+        $this->assertSame('../foo/bar.html', (string) NavigationItem::create(new Route(new InMemoryPage('foo/bar'))));
+
+        Render::swap(Mockery::mock(RenderData::class, [
+            'getRoute' => new Route(new InMemoryPage('foo/bar/baz')),
+            'getRouteKey' => 'foo/bar/baz',
+        ]));
+
+        $this->assertSame('../../foo.html', (string) NavigationItem::create(new Route(new InMemoryPage('foo'))));
+        $this->assertSame('../../foo/bar.html', (string) NavigationItem::create(new Route(new InMemoryPage('foo/bar'))));
+    }
+
+    public function testDropdownFacade()
+    {
+        $item = NavigationGroup::create('foo');
+
+        $this->assertSame('foo', $item->getLabel());
+        $this->assertSame([], $item->getItems()->all());
+        $this->assertSame(999, $item->getPriority());
+    }
+
+    public function testDropdownFacadeWithChildren()
+    {
+        $children = [
+            new NavigationItem(new Route(new MarkdownPage()), 'bar'),
+        ];
+
+        $item = NavigationGroup::create('foo', $children);
+        $this->assertSame($children, $item->getItems()->all());
+        $this->assertSame(999, $item->getPriority());
+    }
+
+    public function testDropdownFacadeWithCustomPriority()
+    {
+        $item = NavigationGroup::create('foo', [], 500);
+
+        $this->assertSame(500, $item->getPriority());
+    }
+
+    public function testIsCurrent()
+    {
+        Render::swap(Mockery::mock(RenderData::class, [
+            'getRoute' => new Route(new InMemoryPage('foo')),
+            'getRouteKey' => 'foo',
+        ]));
+        $this->assertTrue(NavigationItem::create(new Route(new InMemoryPage('foo')))->isActive());
+        $this->assertFalse(NavigationItem::create(new Route(new InMemoryPage('bar')))->isActive());
+    }
+
+    public function testIsCurrentWithLink()
+    {
+        Render::swap(Mockery::mock(RenderData::class, [
+            'getRoute' => new Route(new InMemoryPage('foo')),
+            'getRouteKey' => 'foo',
+        ]));
+        $this->assertFalse(NavigationItem::create('foo', 'bar')->isActive());
+        $this->assertFalse(NavigationItem::create('https://example.com', 'bar')->isActive());
+    }
+
+    public function testIsCurrentIsNullSafe()
+    {
+        $this->assertFalse(NavigationItem::create('foo', 'bar')->isActive());
+    }
+}
diff --git a/packages/framework/tests/Unit/NavigationMenuUnitTest.php b/packages/framework/tests/Unit/NavigationMenuUnitTest.php
new file mode 100644
index 00000000000..8de2aba9229
--- /dev/null
+++ b/packages/framework/tests/Unit/NavigationMenuUnitTest.php
@@ -0,0 +1,166 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Testing\Unit;
+
+use Hyde\Testing\UnitTestCase;
+use Illuminate\Support\Collection;
+use Hyde\Framework\Features\Navigation\NavigationItem;
+use Hyde\Framework\Features\Navigation\MainNavigationMenu;
+
+/**
+ * @covers \Hyde\Framework\Features\Navigation\NavigationMenu
+ * @covers \Hyde\Framework\Features\Navigation\MainNavigationMenu
+ *
+ * @see \Hyde\Framework\Testing\Feature\NavigationMenuTest
+ * @see \Hyde\Framework\Testing\Unit\DocumentationSidebarUnitTest
+ */
+class NavigationMenuUnitTest extends UnitTestCase
+{
+    protected static bool $needsKernel = true;
+    protected static bool $needsConfig = true;
+
+    // Base menu tests
+
+    public function testCanConstruct()
+    {
+        $this->assertInstanceOf(MainNavigationMenu::class, new MainNavigationMenu());
+    }
+
+    public function testCanConstructWithItemsArray()
+    {
+        $this->assertInstanceOf(MainNavigationMenu::class, new MainNavigationMenu($this->getItems()));
+    }
+
+    public function testCanConstructWithItemsArrayable()
+    {
+        $this->assertInstanceOf(MainNavigationMenu::class, new MainNavigationMenu(collect($this->getItems())));
+    }
+
+    public function testGetItemsReturnsCollection()
+    {
+        $this->assertInstanceOf(Collection::class, (new MainNavigationMenu())->getItems());
+    }
+
+    public function testGetItemsReturnsCollectionWhenSuppliedArray()
+    {
+        $this->assertInstanceOf(Collection::class, (new MainNavigationMenu($this->getItems()))->getItems());
+    }
+
+    public function testGetItemsReturnsCollectionWhenSuppliedArrayable()
+    {
+        $this->assertInstanceOf(Collection::class, (new MainNavigationMenu(collect($this->getItems())))->getItems());
+    }
+
+    public function testGetItemsReturnsItems()
+    {
+        $items = $this->getItems();
+
+        $this->assertSame($items, (new MainNavigationMenu($items))->getItems()->all());
+    }
+
+    public function testGetItemsReturnsItemsWhenSuppliedArrayable()
+    {
+        $items = $this->getItems();
+
+        $this->assertSame($items, (new MainNavigationMenu(collect($items)))->getItems()->all());
+    }
+
+    public function testGetItemsReturnsEmptyArrayWhenNoItems()
+    {
+        $this->assertSame([], (new MainNavigationMenu())->getItems()->all());
+    }
+
+    public function testCanAddItems()
+    {
+        $menu = new MainNavigationMenu();
+
+        $item = $this->item('/', 'Home');
+
+        $menu->add($item);
+
+        $this->assertCount(1, $menu->getItems());
+        $this->assertSame($item, $menu->getItems()->first());
+    }
+
+    public function testCanAddMultipleItems()
+    {
+        $menu = new MainNavigationMenu();
+
+        $item1 = $this->item('/', 'Home');
+        $item2 = $this->item('/about', 'About');
+
+        $menu->add($item1);
+        $menu->add($item2);
+
+        $this->assertCount(2, $menu->getItems());
+        $this->assertSame([$item1, $item2], $menu->getItems()->all());
+    }
+
+    public function testCanAddMultipleItemsAtOnce()
+    {
+        $menu = new MainNavigationMenu();
+
+        $item1 = $this->item('/', 'Home');
+        $item2 = $this->item('/about', 'About');
+
+        $menu->add([$item1, $item2]);
+
+        $this->assertCount(2, $menu->getItems());
+        $this->assertSame([$item1, $item2], $menu->getItems()->all());
+    }
+
+    public function testItemsAreInTheOrderTheyWereAddedWhenThereAreNoCustomPriorities()
+    {
+        $menu = new MainNavigationMenu();
+
+        $item1 = $this->item('/', 'Home');
+        $item2 = $this->item('/about', 'About');
+        $item3 = $this->item('/contact', 'Contact');
+
+        $menu->add($item1);
+        $menu->add($item2);
+        $menu->add($item3);
+
+        $this->assertSame([$item1, $item2, $item3], $menu->getItems()->all());
+    }
+
+    public function testItemsAreSortedByPriority()
+    {
+        $menu = new MainNavigationMenu();
+
+        $item1 = $this->item('/', 'Home', 100);
+        $item2 = $this->item('/about', 'About', 200);
+        $item3 = $this->item('/contact', 'Contact', 300);
+
+        $menu->add($item3);
+        $menu->add($item1);
+        $menu->add($item2);
+
+        $this->assertSame([$item1, $item2, $item3], $menu->getItems()->all());
+    }
+
+    public function testModifierMethodsAreFluentlyChainable()
+    {
+        $menu = new MainNavigationMenu();
+
+        $item = $this->item('/', 'Home');
+
+        $this->assertSame($menu, $menu->add($item));
+    }
+
+    protected function getItems(): array
+    {
+        return [
+            $this->item('/', 'Home'),
+            $this->item('/about', 'About'),
+            $this->item('/contact', 'Contact'),
+        ];
+    }
+
+    protected function item(string $destination, string $label, int $priority = 500): NavigationItem
+    {
+        return new NavigationItem($destination, $label, $priority);
+    }
+}
diff --git a/packages/framework/tests/Unit/Pages/DocumentationPageUnitTest.php b/packages/framework/tests/Unit/Pages/DocumentationPageUnitTest.php
index 4017fcf60e7..b00c3df4aaa 100644
--- a/packages/framework/tests/Unit/Pages/DocumentationPageUnitTest.php
+++ b/packages/framework/tests/Unit/Pages/DocumentationPageUnitTest.php
@@ -97,7 +97,7 @@ public function testNavigationMenuLabel()
 
     public function testNavigationMenuGroup()
     {
-        $this->assertSame('other', (new DocumentationPage('foo'))->navigationMenuGroup());
+        $this->assertSame(null, (new DocumentationPage('foo'))->navigationMenuGroup());
     }
 
     public function testNavigationMenuGroupWithData()
diff --git a/packages/framework/tests/Unit/RelativeLinksAcrossPagesRetainsIntegrityTest.php b/packages/framework/tests/Unit/RelativeLinksAcrossPagesRetainsIntegrityTest.php
index c263016b94f..facec7a3cc6 100644
--- a/packages/framework/tests/Unit/RelativeLinksAcrossPagesRetainsIntegrityTest.php
+++ b/packages/framework/tests/Unit/RelativeLinksAcrossPagesRetainsIntegrityTest.php
@@ -93,7 +93,7 @@ public function testRelativeLinksAcrossPagesRetainsIntegrity()
             '<link rel="stylesheet" href="../media/app.css">',
             '<a href="../docs/index.html">',
             '<a href="../docs/docs.html"',
-            '<a href="../index.html">Back to home page</a>',
+            '<a href="../">Back to home page</a>',
         ]);
     }
 }
diff --git a/packages/framework/tests/Unit/Views/NavigationBrandViewTest.php b/packages/framework/tests/Unit/Views/NavigationBrandViewTest.php
index 577295f5cf0..a12a053b608 100644
--- a/packages/framework/tests/Unit/Views/NavigationBrandViewTest.php
+++ b/packages/framework/tests/Unit/Views/NavigationBrandViewTest.php
@@ -4,7 +4,7 @@
 
 namespace Hyde\Framework\Testing\Unit\Views;
 
-use Hyde\Framework\Features\Navigation\NavigationMenu;
+use Hyde\Framework\Features\Navigation\MainNavigationMenu;
 use Hyde\Testing\TestCase;
 
 /**
@@ -22,7 +22,7 @@ protected function setUp(): void
     protected function render(): string
     {
         return view('hyde::components.navigation.navigation-brand', [
-            'navigation' => NavigationMenu::create(),
+            'navigation' => new MainNavigationMenu(),
         ])->render();
     }
 
diff --git a/packages/framework/tests/Unit/Views/NavigationHtmlLayoutsTest.php b/packages/framework/tests/Unit/Views/NavigationHtmlLayoutsTest.php
new file mode 100644
index 00000000000..b34f0d78af2
--- /dev/null
+++ b/packages/framework/tests/Unit/Views/NavigationHtmlLayoutsTest.php
@@ -0,0 +1,960 @@
+<?php
+
+/** @noinspection PhpComposerExtensionStubsInspection */
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Testing\Unit\Views;
+
+use DOMXPath;
+use Hyde\Hyde;
+use DOMElement;
+use DOMDocument;
+use Hyde\Pages\HtmlPage;
+use Hyde\Facades\Config;
+use Hyde\Pages\BladePage;
+use Hyde\Testing\TestCase;
+use Hyde\Facades\Features;
+use Illuminate\Support\Str;
+use Hyde\Pages\MarkdownPage;
+use Hyde\Pages\InMemoryPage;
+use Hyde\Foundation\HydeKernel;
+use JetBrains\PhpStorm\NoReturn;
+use Hyde\Pages\Concerns\HydePage;
+use Hyde\Pages\DocumentationPage;
+use Illuminate\Support\Collection;
+use Hyde\Foundation\Kernel\RouteCollection;
+use Hyde\Framework\Features\Navigation\MainNavigationMenu;
+use Hyde\Framework\Features\Navigation\DocumentationSidebar;
+use Hyde\Framework\Features\Navigation\NavigationMenuGenerator;
+
+use function app;
+use function md5;
+use function view;
+use function trim;
+use function range;
+use function rtrim;
+use function config;
+use function collect;
+use function sprintf;
+use function explode;
+use function implode;
+use function array_map;
+use function is_string;
+use function strip_tags;
+use function array_keys;
+use function json_encode;
+use function str_replace;
+use function preg_replace;
+use function substr_count;
+use function array_filter;
+use function array_values;
+use function class_basename;
+use function file_put_contents;
+
+/**
+ * Very high level tests for navigation menu and sidebar view layouts.
+ *
+ * These tests provide a sort of structural visual testing that can signal smoke
+ * before end-to-end testing kicks in, as they take a long time to set up and run.
+ *
+ * @see \Hyde\Framework\Testing\Feature\AutomaticNavigationConfigurationsTest
+ */
+class NavigationHtmlLayoutsTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->kernel = new TestKernel();
+        HydeKernel::setInstance($this->kernel);
+
+        app()->instance('navigation.main', null);
+        app()->instance('navigation.sidebar', null);
+
+        $this->mockPage();
+        $this->mockRoute();
+    }
+
+    public function testMainNavigationMenu()
+    {
+        $this->menu()
+            ->assertHasId('main-navigation')
+            ->assertHasElement('theme-toggle-button')
+            ->assertHasElement('navigation-toggle-button')
+            ->assertHasElement('main-navigation-links')
+            ->assertDoesNotHaveElement('dropdown')
+            ->assertDoesNotHaveElement('dropdown-items')
+            ->assertDoesNotHaveElement('dropdown-button')
+            ->assertHasNoPages();
+    }
+
+    public function testDocumentationSidebarMenu()
+    {
+        $this->sidebar()
+            ->assertHasId('sidebar')
+            ->assertHasElement('sidebar-header')
+            ->assertHasElement('sidebar-brand')
+            ->assertHasElement('sidebar-navigation')
+            ->assertHasElement('sidebar-footer')
+            ->assertHasElement('theme-toggle-button')
+            ->assertHasElement('sidebar-items')
+            ->assertHasNoPages();
+    }
+
+    public function testNavigationMenuWithPages()
+    {
+        $this->menu($this->withExamplePages())
+            ->assertHasPages([
+                'index.html' => 'Home',
+                'first.html' => 'First',
+                'about.html' => 'About',
+                'custom.html' => 'Label',
+            ])
+            ->assertLooksLike(<<<'HTML'
+                HydePHP Toggle theme Toggle menu
+                - Home
+                - First
+                - About
+                - Label
+                HTML
+            );
+    }
+
+    public function testSidebarWithPages()
+    {
+        $this->sidebar($this->withSidebarPages())
+            ->assertHasPages([
+                'docs/foo.html' => 'Foo',
+                'docs/bar.html' => 'Bar',
+                'docs/baz.html' => 'Baz',
+            ])
+            ->assertLooksLike(<<<'HTML'
+                HydePHP Docs Toggle theme
+                Foo
+                Bar
+                Baz
+                Back to home page
+                HTML
+            );
+    }
+
+    public function testMenuHeader()
+    {
+        $this->menu()->assertHeaderIs('HydePHP');
+    }
+
+    public function testSidebarHeader()
+    {
+        $this->sidebar()->assertHeaderIs('HydePHP Docs');
+    }
+
+    public function testCustomMenuHeader()
+    {
+        Config::set('hyde.name', 'Example');
+
+        $this->menu()->assertHeaderIs('Example');
+    }
+
+    public function testCustomSidebarHeader()
+    {
+        Config::set('docs.sidebar.header', 'Documentation');
+
+        $this->sidebar()->assertHeaderIs('Documentation');
+    }
+
+    public function testSidebarHeaderHasThemeToggleButton()
+    {
+        $this->sidebar()->header()->assertHasThemeToggleButton();
+    }
+
+    public function testSidebarHeaderDoesNotHaveThemeToggleButtonWhenDarkmodeIsDisabled()
+    {
+        Features::mock('darkmode', false);
+
+        $this->sidebar()->header()->assertDoesNotHaveThemeToggleButton();
+    }
+
+    public function testNavigationMenuFromNestedRoute()
+    {
+        $this->fromPage('nested/page')
+            ->menu($this->withExamplePages())
+            ->assertHasPages([
+                '../index.html' => 'Home',
+                '../first.html' => 'First',
+                '../about.html' => 'About',
+                '../custom.html' => 'Label',
+            ])
+            ->assertItemsLookLike(<<<'HTML'
+                - Home
+                - First
+                - About
+                - Label
+                HTML
+            );
+    }
+
+    public function testNavigationMenuWithDropdownPages()
+    {
+        $this->useSubdirectoryConfig('dropdown')
+            ->menu([
+                new MarkdownPage('index'),
+                new MarkdownPage('foo/bar'),
+                new MarkdownPage('foo/baz'),
+            ])
+            ->assertHasDropdowns(['Foo' => ['Bar', 'Baz']])
+            ->assertHasPages([
+                'index.html' => 'Home',
+                'foo/bar.html' => 'Bar',
+                'foo/baz.html' => 'Baz',
+            ])
+            ->assertItemsLookLike(<<<'HTML'
+                - Home
+                - Foo
+                    - Bar
+                    - Baz
+                HTML
+            );
+    }
+
+    public function testNavigationMenuWithFlatSubdirectoryPages()
+    {
+        $this->useSubdirectoryConfig('flat')
+            ->menu([
+                new MarkdownPage('index'),
+                new MarkdownPage('foo/bar'),
+                new MarkdownPage('foo/baz'),
+            ])
+            ->assertDoesNotHaveDropdowns()
+            ->assertHasPages([
+                'index.html' => 'Home',
+                'foo/bar.html' => 'Bar',
+                'foo/baz.html' => 'Baz',
+            ])
+            ->assertItemsLookLike(<<<'HTML'
+                - Home
+                - Bar
+                - Baz
+                HTML
+            );
+    }
+
+    public function testNavigationMenuWithHiddenSubdirectoryPages()
+    {
+        $this->useSubdirectoryConfig('hidden')
+            ->menu([
+                new MarkdownPage('index'),
+                new MarkdownPage('foo/bar'),
+                new MarkdownPage('foo/baz'),
+            ])
+            ->assertDoesNotHaveDropdowns()
+            ->assertHasPages([
+                'index.html' => 'Home',
+            ])
+            ->assertItemsLookLike('- Home');
+    }
+
+    protected function withPages(array $pages): static
+    {
+        $this->kernel->setRoutes(collect($pages)->map(fn (HydePage $page) => $page->getRoute()));
+
+        return $this;
+    }
+
+    public function testNavigationMenuWithFlatSubdirectoryPagesAndMatchingSubdirectoryPage()
+    {
+        $this->useSubdirectoryConfig('flat')
+            ->menu([
+                new MarkdownPage('index'),
+                new MarkdownPage('foo'),
+                new MarkdownPage('foo/bar'),
+                new MarkdownPage('foo/baz'),
+            ])
+            ->assertDoesNotHaveDropdowns()
+            ->assertHasPages([
+                'index.html' => 'Home',
+                'foo.html' => 'Foo',
+                'foo/bar.html' => 'Bar',
+                'foo/baz.html' => 'Baz',
+            ])
+            ->assertItemsLookLike(<<<'HTML'
+                - Home
+                - Foo
+                - Bar
+                - Baz
+                HTML
+            );
+    }
+
+    public function testNavigationMenuWithFlatSubdirectoryPagesAndMatchingSubdirectoryIndexPage()
+    {
+        $this->useSubdirectoryConfig('flat')
+            ->menu([
+                new MarkdownPage('index'),
+                new MarkdownPage('foo/index'),
+                new MarkdownPage('foo/bar'),
+                new MarkdownPage('foo/baz'),
+            ])
+            ->assertDoesNotHaveDropdowns()
+            ->assertHasPages([
+                'index.html' => 'Home',
+                'foo/index.html' => 'Foo',
+                'foo/bar.html' => 'Bar',
+                'foo/baz.html' => 'Baz',
+            ])
+            ->assertItemsLookLike(<<<'HTML'
+                - Home
+                - Foo
+                - Bar
+                - Baz
+                HTML
+            );
+    }
+
+    public function testNavigationMenuWithFlatSubdirectoryPagesAndMatchingSubdirectoryAndIndexPage()
+    {
+        $this->useSubdirectoryConfig('flat')
+            ->menu([
+                new MarkdownPage('index'),
+                new MarkdownPage('foo'),
+                new MarkdownPage('foo/index'),
+                new MarkdownPage('foo/bar'),
+                new MarkdownPage('foo/baz'),
+            ])
+            ->assertDoesNotHaveDropdowns()
+            ->assertHasPages([
+                'index.html' => 'Home',
+                'foo.html' => 'Foo',
+                'foo/index.html' => 'Foo',
+                'foo/bar.html' => 'Bar',
+                'foo/baz.html' => 'Baz',
+            ])
+            ->assertItemsLookLike(<<<'HTML'
+                - Home
+                - Foo
+                - Foo
+                - Bar
+                - Baz
+                HTML
+            );
+    }
+
+    public function testNavigationMenuWithDropdownSubdirectoryPagesAndMatchingSubdirectoryPage()
+    {
+        $this->useSubdirectoryConfig('dropdown')
+            ->menu([
+                new MarkdownPage('index'),
+                new MarkdownPage('foo'),
+                new MarkdownPage('foo/bar'),
+                new MarkdownPage('foo/baz'),
+            ])
+            ->assertHasDropdowns()
+            ->assertHasPages([
+                'index.html' => 'Home',
+                'foo/bar.html' => 'Bar',
+                'foo/baz.html' => 'Baz',
+            ])
+            ->assertItemsLookLike(<<<'HTML'
+                - Home
+                - Foo
+                    - Bar
+                    - Baz
+                HTML
+            );
+    }
+
+    public function testNavigationMenuWithDropdownSubdirectoryPagesAndMatchingSubdirectoryIndexPage()
+    {
+        $this->useSubdirectoryConfig('dropdown')
+            ->menu([
+                new MarkdownPage('index'),
+                new MarkdownPage('foo/index'),
+                new MarkdownPage('foo/bar'),
+                new MarkdownPage('foo/baz'),
+            ])
+            ->assertHasDropdowns()
+            ->assertHasPages([
+                'index.html' => 'Home',
+                'foo/index.html' => 'Foo',
+                'foo/bar.html' => 'Bar',
+                'foo/baz.html' => 'Baz',
+            ])
+            ->assertItemsLookLike(<<<'HTML'
+                - Home
+                - Foo
+                    - Foo
+                    - Bar
+                    - Baz
+                HTML
+            );
+    }
+
+    public function testNavigationMenuWithDropdownSubdirectoryPagesAndMatchingSubdirectoryAndIndexPage()
+    {
+        $this->useSubdirectoryConfig('dropdown')
+            ->menu([
+                new MarkdownPage('index'),
+                new MarkdownPage('foo'),
+                new MarkdownPage('foo/index'),
+                new MarkdownPage('foo/bar'),
+                new MarkdownPage('foo/baz'),
+            ])
+            ->assertHasDropdowns()
+            ->assertHasPages([
+                'index.html' => 'Home',
+                'foo/index.html' => 'Foo',
+                'foo/bar.html' => 'Bar',
+                'foo/baz.html' => 'Baz',
+            ])
+            ->assertItemsLookLike(<<<'HTML'
+                - Home
+                - Foo
+                    - Foo
+                    - Bar
+                    - Baz
+                HTML
+            );
+    }
+
+    public function testSidebarFromNestedRoute()
+    {
+        $this->fromPage('nested/page')
+            ->sidebar([
+                new DocumentationPage('index'),
+                new DocumentationPage('foo'),
+                new DocumentationPage('bar'),
+                new DocumentationPage('baz'),
+            ])
+            ->assertHasPages([
+                '../docs/foo.html' => 'Foo',
+                '../docs/bar.html' => 'Bar',
+                '../docs/baz.html' => 'Baz',
+            ])
+            ->assertItemsLookLike(<<<'HTML'
+                - Foo
+                - Bar
+                - Baz
+                HTML
+            );
+    }
+
+    public function testSidebarWithoutGroupedPages()
+    {
+        $this->sidebar($this->withSidebarPages())
+            ->assertHasNoGroups()
+            ->assertHasPages([
+                'docs/foo.html' => 'Foo',
+                'docs/bar.html' => 'Bar',
+                'docs/baz.html' => 'Baz',
+            ])
+            ->assertItemsLookLike(<<<'HTML'
+                - Foo
+                - Bar
+                - Baz
+                HTML
+            );
+    }
+
+    public function testSidebarWithGroupedPages()
+    {
+        $this->sidebar($this->withGroupedSidebarPages())
+            ->assertHasGroups()
+            ->assertHasPages([
+                'docs/bar.html' => 'Bar',
+                'docs/baz.html' => 'Baz',
+            ])
+            ->assertItemsLookLike(<<<'HTML'
+            - Foo
+                - Bar
+                - Baz
+            HTML
+            );
+    }
+
+    public function testSidebarWithGroupedPagesWithoutFlattenedOutputPaths()
+    {
+        $this->withoutFlattenedOutputPaths()
+            ->sidebar($this->withGroupedSidebarPages())
+            ->assertHasGroups()
+            ->assertHasPages([
+                'docs/foo/bar.html' => 'Bar',
+                'docs/foo/baz.html' => 'Baz',
+            ])
+            ->assertItemsLookLike(<<<'HTML'
+            - Foo
+                - Bar
+                - Baz
+            HTML
+            );
+    }
+
+    protected function fromPage(string $mockedRoute): static
+    {
+        $this->mockCurrentPage($mockedRoute);
+
+        return $this;
+    }
+
+    protected function menu(array $withPages = []): RenderedMainNavigationMenu
+    {
+        $this->withPages($withPages);
+
+        app()->instance('navigation.main', NavigationMenuGenerator::handle(MainNavigationMenu::class));
+
+        return new RenderedMainNavigationMenu($this, $this->render('hyde::layouts.navigation'));
+    }
+
+    protected function sidebar(array $withPages = []): RenderedDocumentationSidebarMenu
+    {
+        $this->withPages($withPages);
+
+        app()->instance('navigation.sidebar', NavigationMenuGenerator::handle(DocumentationSidebar::class));
+
+        return new RenderedDocumentationSidebarMenu($this, $this->render('hyde::components.docs.sidebar'));
+    }
+
+    protected function useSubdirectoryConfig(string $option): static
+    {
+        config(['hyde.navigation.subdirectories' => $option]);
+
+        return $this;
+    }
+
+    protected function withoutFlattenedOutputPaths(): static
+    {
+        config(['docs.flattened_output_paths' => false]);
+
+        return $this;
+    }
+
+    protected function render(string $view): string
+    {
+        return view($view)->render();
+    }
+
+    protected function withExamplePages(): array
+    {
+        return [
+            new MarkdownPage('index'),
+            new MarkdownPage('404'),
+            new BladePage('about'),
+            new BladePage('hidden', ['navigation.hidden' => true]),
+            new InMemoryPage('custom', ['navigation.label' => 'Label']),
+            new HtmlPage('first', ['navigation.priority' => 1]),
+        ];
+    }
+
+    protected function withSidebarPages(): array
+    {
+        return [
+            new DocumentationPage('index'),
+            new DocumentationPage('foo'),
+            new DocumentationPage('bar'),
+            new DocumentationPage('baz'),
+        ];
+    }
+
+    protected function withGroupedSidebarPages(): array
+    {
+        return [
+            new DocumentationPage('index'),
+            new DocumentationPage('foo/bar'),
+            new DocumentationPage('foo/baz'),
+        ];
+    }
+}
+
+abstract class RenderedNavigationMenu
+{
+    protected readonly NavigationHtmlLayoutsTest $test;
+    protected readonly string $html;
+    protected readonly DOMDocument $ast;
+
+    protected const TYPE = null;
+
+    public function __construct(NavigationHtmlLayoutsTest $test, string $html)
+    {
+        $this->test = $test;
+        $this->html = $html;
+
+        $this->ast = $this->parseHtml();
+
+        $this->test->assertNotEmpty($this->html);
+    }
+
+    public function finish(): void
+    {
+        // Empty method to provide cleaner diffs when using method chaining.
+    }
+
+    public function assertHasId(string $id): static
+    {
+        $node = $this->ast->documentElement;
+
+        $this->test->assertTrue($node->hasAttribute('id'));
+        $this->test->assertSame($id, $node->getAttribute('id'));
+
+        return $this;
+    }
+
+    public function assertHasElement(string $id): static
+    {
+        $element = $this->ast->getElementById($id);
+
+        if ($element === null) {
+            // Search for the element in the entire HTML.
+            $xpath = new DOMXPath($this->ast);
+            $element = $xpath->query("//*[@id='$id']")->item(0);
+
+            if ($element === null) {
+                // See if there is an element containing the ID as a class.
+                $element = $xpath->query("//*[contains(concat(' ', normalize-space(@class), ' '), ' $id ')]")->item(0);
+            }
+        }
+
+        $this->test->assertNotNull($element, "Element with '$id' not found in the HTML.");
+
+        return $this;
+    }
+
+    public function assertDoesNotHaveElement(string $id): static
+    {
+        $element = $this->ast->getElementById($id);
+
+        if ($element === null) {
+            // Search for the element in the entire HTML.
+            $xpath = new DOMXPath($this->ast);
+            $element = $xpath->query("//*[@id='$id']")->item(0);
+
+            if ($element === null) {
+                // See if there is an element containing the ID as a class.
+                $element = $xpath->query("//*[contains(concat(' ', normalize-space(@class), ' '), ' $id ')]")->item(0);
+            }
+        }
+
+        $this->test->assertNull($element, "Element with '$id' found in the HTML.");
+
+        return $this;
+    }
+
+    public function assertElementTextIs(DOMElement|string $element, string $expected): static
+    {
+        if (is_string($element)) {
+            $this->assertHasElement($element);
+
+            $element = $this->ast->getElementById($element);
+        }
+
+        $this->test->assertSame($expected, trim($element->textContent));
+
+        return $this;
+    }
+
+    public function assertHasPages(array $pages): static
+    {
+        $renderedPages = $this->getRenderedPages();
+
+        $this->test->assertSame($pages, $renderedPages, sprintf('Rendered pages do not match expected pages: %s', $this->printSerializedArray([
+            'expected' => $pages,
+            'rendered' => $renderedPages,
+        ])));
+
+        return $this;
+    }
+
+    public function assertHasNoPages(): static
+    {
+        $this->test->assertEmpty($this->getRenderedPages());
+
+        return $this;
+    }
+
+    public function assertLooksLike(string $expected, bool $skipHeaderRow = false): static
+    {
+        $actual = $this->makeTextRepresentation();
+
+        if ($skipHeaderRow) {
+            $actual = trim(Str::after($actual, "\n"));
+            if (str_contains($actual, 'Back to home page')) {
+                $actual = trim(str_replace('Back to home page', '', $actual));
+            }
+        }
+        // If expected omitted dashes, remove them from actual
+        if (! str_contains($expected, '- ')) {
+            $actual = str_replace('- ', '', $actual);
+        }
+        // If expected uses 4 spaces, replace with 2 spaces
+        $expected = str_replace('    ', '  ', $expected);
+
+        $this->test->assertSame($expected, $actual, sprintf("Actual HTML does not match expected text:\nExpected:\n%s\nActual:\n%s", $expected, $actual));
+
+        return $this;
+    }
+
+    public function assertItemsLookLike(string $expected): static
+    {
+        return $this->assertLooksLike($expected, true);
+    }
+
+    public function assertHeaderIs(string $expected): static
+    {
+        if (static::TYPE === DocumentationSidebar::class) {
+            $elementId = 'sidebar-brand';
+            $nodeName = 'strong';
+        } else {
+            $elementId = 'main-navigation-brand';
+            $nodeName = 'a';
+        }
+
+        $this->assertHasElement($elementId);
+
+        $element = $this->ast->getElementById($elementId)->getElementsByTagName($nodeName)->item(0);
+
+        $this->test->assertNotNull($element, "No <$nodeName> element found in menu header");
+
+        $this->assertElementTextIs($element, $expected);
+
+        return $this;
+    }
+
+    #[NoReturn]
+    public function dd(bool $writeHtml = true): void
+    {
+        if ($writeHtml) {
+            file_put_contents(Hyde::path(Str::kebab(class_basename(static::TYPE)).'.html'), $this->html);
+        }
+
+        exit(trim($this->html)."\n\n");
+    }
+
+    /** Get an element node and assert it is not null */
+    protected function getAssertedElement(string $id): DOMElement
+    {
+        $this->assertHasElement($id);
+
+        return $this->ast->getElementById($id);
+    }
+
+    protected function parseHtml(): DOMDocument
+    {
+        $dom = new DOMDocument();
+
+        $dom->loadHTML($this->html, LIBXML_HTML_NOIMPLIED | LIBXML_HTML_NODEFDTD | LIBXML_NOWARNING | LIBXML_NOERROR | LIBXML_PARSEHUGE);
+
+        return $dom;
+    }
+
+    /** @return array<string, string> */
+    protected function getRenderedPages(): array
+    {
+        $containerNodeId = static::TYPE === MainNavigationMenu::class ? 'main-navigation-links' : 'sidebar-items';
+
+        $this->assertHasElement($containerNodeId);
+
+        $containerNode = $this->ast->getElementById($containerNodeId);
+
+        $links = $containerNode->getElementsByTagName('a');
+
+        $pages = [];
+
+        foreach ($links as $link) {
+            $pages[$link->getAttribute('href')] = trim($link->textContent);
+        }
+
+        return $pages;
+    }
+
+    protected function makeTextRepresentation(): string
+    {
+        $html = str_replace(['<title>Open Menu</title>', '<title>Close Menu</title>'], ['Toggle menu', ''], $this->html);
+        $html = str_replace(['<li', '</li>'], ['<li-keep', '</li-keep>'], $html);
+        $html = str_replace(['<ul', '</ul>'], ['<ul-keep', '</ul-keep>'], $html);
+        $html = strip_tags($html, '<li-keep><ul-keep>');
+        $html = str_replace(['<li-keep', '</li-keep>'], ['<li', '</li>'], $html);
+        $html = str_replace(['<ul-keep', '</ul-keep>'], ['<ul', '</ul>'], $html);
+        $html = preg_replace('/<li[^>]*>/', '<li>', $html);
+        $html = preg_replace('/<ul[^>]*>/', '<ul>', $html);
+        $html = str_replace(['</li>'], '<br>', $html);
+        $html = preg_replace('/\s+/', '', $html);
+        $html = str_replace('<br>', "\n", $html);
+        $html = str_replace('<li>', '- ', $html);
+        $html = Str::replaceFirst('<ul>', "\n", $html);
+
+        $innerUlCount = substr_count($html, '<ul>');
+        if ($innerUlCount >= 1) {
+            // Indent each line within the remaining UL elements
+            foreach (range(1, $innerUlCount) as $item) {
+                $html = Str::replaceFirst('</ul>', '</ul-first>', $html);
+                $innerUlContent = Str::between($html, '<ul>', '</ul-first>');
+                $id = md5("$innerUlContent-$item");
+                $html = Str::replaceFirst($innerUlContent, $id, $html);
+                $innerUlContent = trim(str_replace("\n", "\n  ", $innerUlContent));
+
+                $html = str_replace("<ul>$id</ul-first>", "\n  $innerUlContent", $html);
+            }
+        }
+
+        $html = Str::replaceLast('</ul>', '', $html);
+
+        /** @noinspection SpellCheckingInspection */
+        $html = str_replace(
+            ['HydePHPDocs', 'themeToggle', 'Toggledarktheme', 'Togglemenu', 'Backtohomepage'],
+            ['HydePHP Docs', 'theme Toggle', ' Toggle theme', 'Toggle menu', 'Back to home page'],
+            $html
+        );
+
+        return trim(implode("\n", array_map('rtrim', explode("\n", $html))));
+    }
+
+    protected function printSerializedArray(array $data): string
+    {
+        $string = json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
+
+        // Convert JSON to PHP array syntax
+        $string = str_replace(['{', '}'], ['[', ']'], $string);
+        $string = str_replace('": "', "' => '", $string);
+        $string = str_replace('": [', "' => [", $string);
+        $string = str_replace('"', "'", $string);
+        $string = str_replace("'\n", "',\n", $string);
+        $string = str_replace(']', '],', $string);
+        $string = str_replace(',,', ',', $string);
+
+        return rtrim($string, ',');
+    }
+}
+
+class RenderedMainNavigationMenu extends RenderedNavigationMenu
+{
+    protected const TYPE = MainNavigationMenu::class;
+
+    public function assertHasDropdowns(?array $expected = null): static
+    {
+        $this->assertHasElement('dropdown');
+        $this->assertHasElement('dropdown-items');
+        $this->assertHasElement('dropdown-button');
+
+        if ($expected) {
+            $xpath = new DOMXPath($this->ast);
+            $dropdownItems = $xpath->query('//ul[contains(concat(" ", normalize-space(@class), " "), " dropdown-items ")]');
+
+            /** @var array<string, array<string> $actual */
+            $actual = [];
+
+            foreach ($dropdownItems as $dropdownItem) {
+                $button = $xpath->query('../preceding-sibling::button', $dropdownItem)->item(0);
+
+                $label = trim($button->textContent);
+
+                $children = array_values(array_filter(array_map('trim', explode("\n", $dropdownItem->textContent))));
+
+                $actual[$label] = $children;
+            }
+
+            // If expected is a list array, then remove values from actual
+            if (array_values($expected) === $expected) {
+                $actual = array_keys($actual);
+            }
+
+            $this->test->assertSame($expected, $actual, sprintf('Rendered dropdown does not match expected format: %s', $this->printSerializedArray([
+                'expected' => $expected,
+                'rendered' => $actual,
+            ])));
+        }
+
+        return $this;
+    }
+
+    public function assertDoesNotHaveDropdowns(): static
+    {
+        $this->assertDoesNotHaveElement('dropdown');
+        $this->assertDoesNotHaveElement('dropdown-items');
+        $this->assertDoesNotHaveElement('dropdown-button');
+
+        return $this;
+    }
+}
+
+class RenderedDocumentationSidebarMenu extends RenderedNavigationMenu
+{
+    protected const TYPE = DocumentationSidebar::class;
+
+    protected bool $scopeToHeader = false;
+
+    public function assertHasGroups(): static
+    {
+        $this->assertHasElement('sidebar-group');
+        $this->assertHasElement('sidebar-group-items');
+        $this->assertHasElement('sidebar-group-heading');
+        $this->assertHasElement('sidebar-group-header');
+        $this->assertHasElement('sidebar-group-toggle');
+
+        return $this;
+    }
+
+    public function assertHasNoGroups(): static
+    {
+        $this->assertDoesNotHaveElement('sidebar-group');
+        $this->assertDoesNotHaveElement('sidebar-group-items');
+        $this->assertDoesNotHaveElement('sidebar-group-heading');
+        $this->assertDoesNotHaveElement('sidebar-group-header');
+        $this->assertDoesNotHaveElement('sidebar-group-toggle');
+
+        return $this;
+    }
+
+    public function assertHasThemeToggleButton(): static
+    {
+        if (! $this->scopeToHeader) {
+            $this->assertHasElement('theme-toggle-button');
+        } else {
+            $header = $this->getAssertedElement('sidebar-header');
+
+            $xpath = new DOMXPath($this->ast);
+            $header = $xpath->query('.//button[contains(concat(" ", normalize-space(@class), " "), " theme-toggle-button ")]', $header)->item(0);
+
+            $this->test->assertNotNull($header, 'No theme toggle button found in sidebar header');
+            $this->test->assertSame('Toggle dark theme', trim($header->textContent));
+        }
+
+        return $this;
+    }
+
+    public function assertDoesNotHaveThemeToggleButton(): static
+    {
+        if (! $this->scopeToHeader) {
+            $this->assertDoesNotHaveElement('theme-toggle-button');
+        } else {
+            $header = $this->getAssertedElement('sidebar-header');
+
+            $xpath = new DOMXPath($this->ast);
+            $header = $xpath->query('.//button[contains(concat(" ", normalize-space(@class), " "), " theme-toggle-button ")]', $header)->item(0);
+
+            $this->test->assertNull($header, 'Theme toggle button found in sidebar header');
+        }
+
+        return $this;
+    }
+
+    public function header(): static
+    {
+        $this->scopeToHeader = true;
+
+        return $this;
+    }
+}
+
+class TestKernel extends HydeKernel
+{
+    protected ?RouteCollection $mockRoutes = null;
+
+    public function setRoutes(Collection $routes): void
+    {
+        $this->mockRoutes = RouteCollection::make($routes);
+    }
+
+    /** @return \Hyde\Foundation\Kernel\RouteCollection<string, \Hyde\Support\Models\Route> */
+    public function routes(): RouteCollection
+    {
+        return $this->mockRoutes ?? parent::routes();
+    }
+}
diff --git a/packages/framework/tests/Unit/Views/NavigationLinkViewTest.php b/packages/framework/tests/Unit/Views/NavigationLinkViewTest.php
index 1018d2ae3c0..de571ed18df 100644
--- a/packages/framework/tests/Unit/Views/NavigationLinkViewTest.php
+++ b/packages/framework/tests/Unit/Views/NavigationLinkViewTest.php
@@ -4,8 +4,12 @@
 
 namespace Hyde\Framework\Testing\Unit\Views;
 
-use Hyde\Foundation\Facades\Routes;
-use Hyde\Framework\Features\Navigation\NavItem;
+use Hyde\Pages\InMemoryPage;
+use Hyde\Support\Models\Route;
+use Hyde\Testing\TestsBladeViews;
+use Hyde\Testing\Support\TestView;
+use Illuminate\View\ComponentAttributeBag;
+use Hyde\Framework\Features\Navigation\NavigationItem;
 use Hyde\Testing\TestCase;
 
 /**
@@ -13,6 +17,8 @@
  */
 class NavigationLinkViewTest extends TestCase
 {
+    use TestsBladeViews;
+
     protected function setUp(): void
     {
         parent::setUp();
@@ -20,32 +26,66 @@ protected function setUp(): void
         $this->mockPage();
     }
 
-    protected function render(?NavItem $item = null): string
+    protected function testView(): TestView
+    {
+        return $this->view(view('hyde::components.navigation.navigation-link', [
+            'item' => NavigationItem::create(new Route(new InMemoryPage('foo')), 'Foo'),
+            'attributes' => new ComponentAttributeBag(),
+        ]));
+    }
+
+    public function testComponentRenders()
     {
-        return view('hyde::components.navigation.navigation-link', [
-            'item' => $item ?? NavItem::forLink('foo.html', 'Foo'),
-        ])->render();
+        $this->testView()->assertHasElement('<a>');
     }
 
     public function testComponentLinksToRouteDestination()
     {
-        $this->assertStringContainsString('href="foo.html"', $this->render());
+        $this->testView()->assertAttributeIs('href="foo.html"');
+    }
+
+    public function testComponentResolvesRelativeLinksForRoutes()
+    {
+        $this->mockCurrentPage('foo/bar');
+
+        $this->testView()->assertAttributeIs('href="../foo.html"');
     }
 
     public function testComponentUsesTitle()
     {
-        $this->assertStringContainsString('Foo', $this->render());
+        $this->testView()->assertTextIs('Foo');
+    }
+
+    public function testComponentDoesNotHaveCurrentAttributesWhenCurrentRouteDoesNotMatch()
+    {
+        $this->testView()
+            ->assertDontSee('current')
+            ->assertDoesNotHaveAttribute('aria-current');
     }
 
     public function testComponentIsCurrentWhenCurrentRouteMatches()
     {
-        $this->mockRoute(Routes::get('index'));
-        $this->assertStringContainsString('current', $this->render(NavItem::forRoute(Routes::get('index'), 'Home')));
+        $this->mockCurrentPage('foo');
+
+        $this->testView()
+            ->assertSee('current')
+            ->assertHasAttribute('aria-current')
+            ->assertAttributeIs('aria-current="page"');
+    }
+
+    public function testComponentDoesNotHaveActiveClassWhenNotActive()
+    {
+        $this->testView()
+            ->assertHasClass('navigation-link')
+            ->assertDoesNotHaveClass('navigation-link-active');
     }
 
-    public function testComponentHasAriaCurrentWhenCurrentRouteMatches()
+    public function testComponentHasActiveClassWhenActive()
     {
-        $this->mockRoute(Routes::get('index'));
-        $this->assertStringContainsString('aria-current="page"', $this->render(NavItem::forRoute(Routes::get('index'), 'Home')));
+        $this->mockCurrentPage('foo');
+
+        $this->testView()
+            ->assertHasClass('navigation-link')
+            ->assertHasClass('navigation-link-active');
     }
 }
diff --git a/packages/framework/tests/Unit/Views/NavigationMenuViewTest.php b/packages/framework/tests/Unit/Views/NavigationMenuViewTest.php
index f9b4c76ed2c..18d9bfd7cbf 100644
--- a/packages/framework/tests/Unit/Views/NavigationMenuViewTest.php
+++ b/packages/framework/tests/Unit/Views/NavigationMenuViewTest.php
@@ -20,6 +20,8 @@ protected function setUp(): void
         parent::setUp();
         $this->mockRoute();
         $this->mockPage();
+
+        Hyde::boot();
     }
 
     protected function render(): string
@@ -71,7 +73,7 @@ public function testNavigationMenuWithRootPages()
         $contents = $foo->compile();
 
         $this->assertStringContainsString('<a href="foo.html" aria-current="page" class="', $contents);
-        $this->assertStringContainsString('<a href="bar.html"  class="', $contents);
+        $this->assertStringContainsString('<a href="bar.html" class="', $contents);
     }
 
     public function testNavigationMenuWithDropdownPages()
diff --git a/packages/framework/tests/Unit/Views/SidebarItemsViewTest.php b/packages/framework/tests/Unit/Views/SidebarItemsViewTest.php
new file mode 100644
index 00000000000..7d8a7b5065f
--- /dev/null
+++ b/packages/framework/tests/Unit/Views/SidebarItemsViewTest.php
@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Testing\Unit\Views;
+
+use Hyde\Hyde;
+use Hyde\Testing\TestCase;
+use Hyde\Support\Models\Route;
+use Hyde\Testing\TestsBladeViews;
+use Hyde\Pages\DocumentationPage;
+use Hyde\Testing\Support\TestView;
+use Hyde\Framework\Features\Navigation\DocumentationSidebar;
+use Hyde\Framework\Features\Navigation\NavigationMenuGenerator;
+
+/**
+ * @see resources/views/components/docs/sidebar-items.blade.php
+ */
+class SidebarItemsViewTest extends TestCase
+{
+    use TestsBladeViews;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->mockRoute();
+    }
+
+    protected function testView(): TestView
+    {
+        Hyde::routes()->addRoute(new Route(new DocumentationPage('foo')));
+        Hyde::routes()->addRoute(new Route(new DocumentationPage('bar')));
+        Hyde::routes()->addRoute(new Route(new DocumentationPage('baz')));
+
+        return $this->view(view('hyde::components.docs.sidebar-items', [
+            'sidebar' => NavigationMenuGenerator::handle(DocumentationSidebar::class),
+        ]));
+    }
+
+    public function testComponentRenders()
+    {
+        $this->testView()->assertHasElement('#sidebar-items')->assertSeeTimes('listitem', 3);
+    }
+
+    public function testViewDoesNotContainActiveStateWhenNoPageIsActive()
+    {
+        $this->testView()
+            ->assertDontSee('active')
+            ->assertDontSee('Table of contents')
+            ->assertDoesNotHaveAttribute('aria-current');
+    }
+
+    public function testViewContainsActiveStateWhenPageIsActive()
+    {
+        $this->mockCurrentPage('docs/foo');
+        $this->mockPage(new DocumentationPage('foo'));
+
+        $this->testView()
+            ->assertSeeOnce('active')
+            ->assertSeeOnce('Table of contents')
+            ->assertHasAttribute('aria-current')
+            ->assertAttributeIs('aria-current="true"');
+    }
+
+    public function testTypeAnnotationIsNotPresentInHtml()
+    {
+        $this->testView()->assertDontSee('@var')->assertDontSee('$group');
+    }
+}