diff --git a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-button/index.en-US.mdx b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-button/index.en-US.mdx
index 5a5c968..959449d 100644
--- a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-button/index.en-US.mdx
+++ b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-button/index.en-US.mdx
@@ -1,50 +1,123 @@
----
-description: "A button that's styled for use in a CommandBar."
----
-
-# AppBarButton
-
-We're still working on this, coming soon!
-
-{/* {
- "UniqueId": "AppBarButton",
- "Title": "AppBarButton",
- "Subtitle": "A button that's styled for use in a CommandBar.",
- "ImagePath": "ms-appx:///Assets/ControlImages/AppBarButton.png",
- "ImageIconPath": "ms-appx:///Assets/ControlIcons/AppBarButtonIcon.png",
- "Description": "App bar buttons differ from standard buttons in several ways:\n- Their default appearance is a transparent background with a smaller size.\n- You use the Label and Icon properties to set the content instead of the Content property. The Content property is ignored.\n- The button's IsCompact property controls its size.",
- "Content": "
You can open the app bar and toggle the IsCompact button to see how the app bar buttons on this page change.
Use the Label and Icon properties to define the content of the app bar buttons. Set the Label property to a string to specify the text label. The label is shown by default but is hidden when the button is in its compact state, so you also need to specify a meaningful icon. To do that, set the button's Icon property to an element derived from the IconElement class. Four kinds of icon elements are provided:
FontIcon - The icon is based on a glyph from the specified font family.
BitmapIcon - The icon is based on a bitmap image file with the specified Uri.
PathIcon - The icon is based on Path data.
SymbolIcon - The icon is based on a predefined list of glyphs from the Segoe UI Symbol font.
Look at the AppBarButtonPage.xaml file in Visual Studio to see the full code for this page.
",
- "IsNew": false,
- "IsUpdated": false,
- "Docs": [
- {
- "Title": "AppBarButton - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.ui.xaml.controls.appbarbutton"
- },
- {
- "Title": "SymbolIcon - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.ui.xaml.controls.symbolicon"
- },
- {
- "Title": "FontIcon - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.ui.xaml.controls.fonticon"
- },
- {
- "Title": "BitmapIcon - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.ui.xaml.controls.bitmapicon"
- },
- {
- "Title": "PathIcon - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.ui.xaml.controls.pathicon"
- },
- {
- "Title": "Guidelines",
- "Uri": "https://docs.microsoft.com/windows/apps/design/controls/command-bar"
- }
- ],
- "RelatedControls": [
- "AppBarToggleButton",
- "AppBarSeparator",
- "CommandBar"
- ]
-}, */}
\ No newline at end of file
+---
+description: "A button that's styled for use in a CommandBar."
+---
+
+# AppBarButton
+
+Use an AppBarButton for commands hosted in a [CommandBar](./command-bar), a [CommandBarFlyout](./command-bar-flyout), or anywhere else you want a button that follows the same icon-and-label styling. AppBarButton differs from a plain `Button` in a few ways:
+
+- Its default appearance is a transparent background at a smaller size than a standard button.
+
+- You set its content through the **Label** and **Icon** properties instead of `Content`.
+
+- Its **IsCompact** property controls whether the label is shown at all, or the button shrinks down to just its icon.
+
+- **Class**: [iNKORE.UI.WPF.Modern.Controls](..)[.AppBarButton](.)
+
+- **Inheritance**: [Object](https://learn.microsoft.com/en-us/dotnet/api/system.object) → (...) → [ButtonBase](https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls.primitives.buttonbase) → [Button](https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls.button) → [AppBarButton](.)
+
+## Examples
+
+### A basic AppBarButton with an icon
+
+Set **Label** to the button's text, and **Icon** to any `IconElement`, most commonly a **FontIcon**:
+
+```xml
+
+
+
+
+
+```
+
+**Icon** also accepts a **PathIcon** (or any other `IconElement`) if a font glyph doesn't cover what you need:
+
+```xml
+
+
+
+
+
+```
+
+### Binding a command
+
+AppBarButton works with the same `Command`/`CommandParameter`/`CommandBindings` you'd use on any `Button`:
+
+```xml
+
+
+
+
+
+
+
+
+```
+
+### Attaching a flyout
+
+Set **Flyout** to show a [MenuFlyout](./menu-flyout) (or any `FlyoutBase`) when the button is clicked, instead of raising `Click`:
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+## Remarks
+
+### IsCompact and label position
+
+**IsCompact** shrinks the button down so only the icon shows, which is what a [CommandBar](./command-bar) does automatically to primary commands when it runs out of horizontal room. **LabelPosition** lets an individual button opt out of the bar's **DefaultLabelPosition**, for example collapsing just one button's label while the rest keep theirs.
+
+### Icon types
+
+**Icon** accepts any `IconElement`. This library ports four of them from WinUI:
+
+- **FontIcon** — a glyph from an icon font, most commonly `SegoeFluentIcons`.
+
+- **PathIcon** — a vector icon described with `Path` mini-language geometry data.
+
+- **BitmapIcon** / **ImageIcon** — an icon based on a bitmap image.
+
+`SymbolIcon` also exists, ported from WinUI, but it's marked obsolete in favor of `FontIcon`.
+
+### InputGestureText vs. keyboard accelerators
+
+**InputGestureText** just displays a hint string (like "Ctrl+S") next to the button's label or in its overflow row, it does not by itself make that shortcut work. Wire up the actual shortcut the normal WPF way (an `InputBinding`/`KeyBinding`, or `AddKeyboardAccelerator` when the button lives in a [CommandBar](./command-bar)).
+
+## See also
+
+### Microsoft Learn
+
+- [AppBarButton Class (WinRT)](https://learn.microsoft.com/en-us/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.controls.appbarbutton)
+
+- [Command bar - Windows apps](https://learn.microsoft.com/en-us/windows/apps/design/controls/command-bar)
+
+### Related controls
+
+- [AppBarToggleButton](./appbar-toggle-button)
+
+- [AppBarRepeatButton](./appbar-repeat-button)
+
+- [AppBarSeparator](./appbar-separator)
+
+- [CommandBar](./command-bar)
+
+- [CommandBarFlyout](./command-bar-flyout)
+
+- [MenuFlyout](./menu-flyout)
diff --git a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-repeat-button/index.en-US.mdx b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-repeat-button/index.en-US.mdx
new file mode 100644
index 0000000..67f00de
--- /dev/null
+++ b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-repeat-button/index.en-US.mdx
@@ -0,0 +1,101 @@
+---
+description: "A button that's styled for use in a CommandBar, and raises Click repeatedly while pressed and held."
+---
+
+# AppBarRepeatButton
+
+AppBarRepeatButton is the same idea as [AppBarButton](./appbar-button), but built on WPF's native `RepeatButton` instead of `Button`: holding it down keeps raising **Click** on a timer, instead of only once. Use it in a [CommandBar](./command-bar) or [CommandBarFlyout](./command-bar-flyout) for commands that make sense to repeat while held, such as zoom in/out, volume up/down, or nudging a value.
+
+- **Class**: [iNKORE.UI.WPF.Modern.Controls](..)[.AppBarRepeatButton](.)
+
+- **Inheritance**: [Object](https://learn.microsoft.com/en-us/dotnet/api/system.object) → (...) → [ButtonBase](https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls.primitives.buttonbase) → [RepeatButton](https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls.primitives.repeatbutton) → [AppBarRepeatButton](.)
+
+## Examples
+
+### A basic AppBarRepeatButton
+
+It's used exactly like [AppBarButton](./appbar-button): set **Label** and **Icon** instead of `Content`, and handle **Click**.
+
+```xml
+
+
+
+
+
+```
+
+```csharp
+private void ZoomIn_Click(object sender, RoutedEventArgs e)
+{
+ CurrentZoom = Math.Min(CurrentZoom + 0.1, 4.0);
+}
+```
+
+While the button is held down, `Click` keeps firing, so `CurrentZoom` keeps increasing until the user releases the mouse or lifts their finger.
+
+### Controlling the repeat timing
+
+**Delay** and **Interval**, inherited from the native `RepeatButton`, control how long to wait before the first repeat and how often it repeats after that (both in milliseconds):
+
+```xml
+
+
+
+
+
+```
+
+### In a CommandBar
+
+AppBarRepeatButton participates in overflow and layout the same way [AppBarButton](./appbar-button) does, so it can go straight into a [CommandBar](./command-bar)'s primary or secondary commands:
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+## Remarks
+
+### There's no WinUI equivalent
+
+Unlike [AppBarButton](./appbar-button), [AppBarToggleButton](./appbar-toggle-button), and [AppBarSeparator](./appbar-separator), AppBarRepeatButton isn't a port of a WinUI type, WinUI's `CommandBar` doesn't have a repeat-button command. This library adds it because WPF's `RepeatButton` already exists natively and repeat-while-held is a common toolbar need, so if you're cross-referencing against WinUI's docs, you won't find a matching page there.
+
+### It's still an AppBar element
+
+AppBarRepeatButton implements the same `ICommandBarElement` interface as the other AppBar controls, so it gets the same **IsCompact**, **LabelPosition**, and overflow handling when it's a [CommandBar](./command-bar) command. See [AppBarButton](./appbar-button)'s remarks on those, everything there applies here too.
+
+### Command vs. Click for repeating actions
+
+If you bind **Command** instead of handling **Click**, that command's `Execute` is what runs repeatedly, make sure it's cheap enough to call many times a second, or debounce/throttle the actual work it does.
+
+## See also
+
+### Microsoft Learn
+
+- [RepeatButton Class (WPF)](https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls.primitives.repeatbutton)
+
+- [Command bar - Windows apps](https://learn.microsoft.com/en-us/windows/apps/design/controls/command-bar)
+
+### Related controls
+
+- [AppBarButton](./appbar-button)
+
+- [AppBarToggleButton](./appbar-toggle-button)
+
+- [AppBarSeparator](./appbar-separator)
+
+- [CommandBar](./command-bar)
diff --git a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-repeat-button/index.meta.yml b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-repeat-button/index.meta.yml
new file mode 100644
index 0000000..e69de29
diff --git a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-separator/index.en-US.mdx b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-separator/index.en-US.mdx
index ef7a412..d01988e 100644
--- a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-separator/index.en-US.mdx
+++ b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-separator/index.en-US.mdx
@@ -1,34 +1,88 @@
----
-description: "A vertical line that's used to visually separate groups of commands in an app bar."
----
-
-# AppBarSeparator
-
-We're still working on this, coming soon!
-
-{/* {
- "UniqueId": "AppBarSeparator",
- "Title": "AppBarSeparator",
- "Subtitle": "A vertical line that's used to visually separate groups of commands in an app bar.",
- "ImagePath": "ms-appx:///Assets/ControlImages/AppBarSeparator.png",
- "ImageIconPath": "ms-appx:///Assets/ControlIcons/AppBarSeparatorIcon.png",
- "Description": "An AppBarSeparator creates a vertical line to visually separate groups of commands in a app bar. It has a compact state with reduced padding to match the compact state of the AppBarButton and AppBarToggleButton controls.",
- "Content": "
You can open the app bar and toggle the IsCompact button to see how the app bar buttons and separators on this page change.
When the IsCompact property is true, the padding around the AppBarSeparator is reduced.
Look at the AppBarSeparatorPage.xaml file in Visual Studio to see the full code for this page.
",
- "IsNew": false,
- "IsUpdated": false,
- "Docs": [
- {
- "Title": "AppBarSeparator - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.ui.xaml.controls.appbarseparator"
- },
- {
- "Title": "Guidelines",
- "Uri": "https://docs.microsoft.com/windows/apps/design/controls/command-bar"
- }
- ],
- "RelatedControls": [
- "AppBarButton",
- "AppBarToggleButton",
- "CommandBar"
- ]
-}, */}
\ No newline at end of file
+---
+description: "A vertical line that's used to visually separate groups of commands in an app bar."
+---
+
+# AppBarSeparator
+
+Use an AppBarSeparator to visually split a [CommandBar](./command-bar) (or [CommandBarFlyout](./command-bar-flyout)) into groups of related commands, for example separating clipboard actions from formatting actions. It renders as a short vertical line, and, like [AppBarButton](./appbar-button), has a compact state that reduces its padding to match.
+
+- **Class**: [iNKORE.UI.WPF.Modern.Controls](..)[.AppBarSeparator](.)
+
+- **Inheritance**: [Object](https://learn.microsoft.com/en-us/dotnet/api/system.object) → (...) → [Control](https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls.control) → [AppBarSeparator](.)
+
+## Examples
+
+### Grouping commands in a CommandBar
+
+Place an AppBarSeparator between the buttons you want visually split apart:
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+### Adding a separator at runtime
+
+Since it's a lightweight `Control` with no content, an AppBarSeparator can just be constructed directly when building a [CommandBar](./command-bar) in code:
+
+```csharp
+PrimaryCommandBar.SecondaryCommands.Add(new AppBarButton { Label = "Button 2" });
+PrimaryCommandBar.SecondaryCommands.Add(new AppBarSeparator());
+PrimaryCommandBar.SecondaryCommands.Add(new AppBarButton { Label = "Button 3" });
+```
+
+## Remarks
+
+### It only makes sense inside a command surface
+
+AppBarSeparator implements the same `ICommandBarElement` interface as [AppBarButton](./appbar-button) and [AppBarToggleButton](./appbar-toggle-button), which is what lets a [CommandBar](./command-bar) or [CommandBarFlyout](./command-bar-flyout) participate in dynamic overflow with it. Using it outside one of those hosts has no real effect since there's nothing to lay it out.
+
+### IsCompact
+
+Like the other AppBar elements, **IsCompact** reduces the separator's padding to match a [CommandBar](./command-bar) whose primary commands have collapsed down to icon-only. You don't usually need to set this yourself, the owning CommandBar keeps it in sync automatically.
+
+## See also
+
+### Microsoft Learn
+
+- [AppBarSeparator Class (WinRT)](https://learn.microsoft.com/en-us/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.controls.appbarseparator)
+
+- [Command bar - Windows apps](https://learn.microsoft.com/en-us/windows/apps/design/controls/command-bar)
+
+### Related controls
+
+- [AppBarButton](./appbar-button)
+
+- [AppBarToggleButton](./appbar-toggle-button)
+
+- [AppBarRepeatButton](./appbar-repeat-button)
+
+- [CommandBar](./command-bar)
diff --git a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-toggle-button/index.en-US.mdx b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-toggle-button/index.en-US.mdx
index e5ea423..72bc489 100644
--- a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-toggle-button/index.en-US.mdx
+++ b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# appbar-toggle-button/index.en-US.mdx
@@ -1,50 +1,91 @@
----
-description: "A button that can be on, off, or indeterminate like a CheckBox, and is styled for use in an app bar or other specialized UI."
----
-
-# AppBarToggleButton
-
-We're still working on this, coming soon!
-
-{/* {
- "UniqueId": "AppBarToggleButton",
- "Title": "AppBarToggleButton",
- "Subtitle": "A button that can be on, off, or indeterminate like a CheckBox, and is styled for use in an app bar or other specialized UI.",
- "ImagePath": "ms-appx:///Assets/ControlImages/AppBarToggleButton.png",
- "ImageIconPath": "ms-appx:///Assets/ControlIcons/AppBarToggleButtonIcon.png",
- "Description": "An AppBarToggleButton looks like an AppBarButton, but works like a CheckBox. It typically has two states, checked (on) or unchecked (off), but can be indeterminate if the IsThreeState property is true. You can determine it's state by checking the IsChecked property.",
- "Content": "
You can open the app bar and toggle the IsCompact button to see how the app bar buttons on this page change.
Look at the AppBarToggleButtonPage.xaml file in Visual Studio to see the full code for this page.
",
- "IsNew": false,
- "IsUpdated": false,
- "Docs": [
- {
- "Title": "AppBarToggleButton - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.ui.xaml.controls.appbartogglebutton"
- },
- {
- "Title": "SymbolIcon - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.ui.xaml.controls.symbolicon"
- },
- {
- "Title": "FontIcon - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.ui.xaml.controls.fonticon"
- },
- {
- "Title": "BitmapIcon - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.ui.xaml.controls.bitmapicon"
- },
- {
- "Title": "PathIcon - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.ui.xaml.controls.pathicon"
- },
- {
- "Title": "Guidelines",
- "Uri": "https://docs.microsoft.com/windows/apps/design/controls/command-bar"
- }
- ],
- "RelatedControls": [
- "AppBarButton",
- "AppBarSeparator",
- "CommandBar"
- ]
-}, */}
\ No newline at end of file
+---
+description: "A button that can be on, off, or indeterminate like a CheckBox, and is styled for use in an app bar or other specialized UI."
+---
+
+# AppBarToggleButton
+
+AppBarToggleButton looks like an [AppBarButton](./appbar-button), but behaves like a `CheckBox`: it has an on/off (checked/unchecked) state you read through **IsChecked**, and can be indeterminate if **IsThreeState** is `True`. Use it in a [CommandBar](./command-bar) for commands that represent a toggled state, such as "Bold" or "Show grid", rather than a one-shot action.
+
+- **Class**: [iNKORE.UI.WPF.Modern.Controls](..)[.AppBarToggleButton](.)
+
+- **Inheritance**: [Object](https://learn.microsoft.com/en-us/dotnet/api/system.object) → (...) → [ButtonBase](https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls.primitives.buttonbase) → [ToggleButton](https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls.primitives.togglebutton) → [AppBarToggleButton](.)
+
+## Examples
+
+### A basic AppBarToggleButton
+
+Like AppBarButton, set **Label** and **Icon** instead of `Content`:
+
+```xml
+
+
+
+
+
+```
+
+Read the state the same way you would for a `ToggleButton` or `CheckBox`, through **IsChecked**:
+
+```csharp
+private void AppBarToggleButton_Click(object sender, RoutedEventArgs e)
+{
+ var button = (AppBarToggleButton)sender;
+ Control3Output.Text = button.IsChecked == true ? "On" : "Off";
+}
+```
+
+### A three-state toggle
+
+Set **IsThreeState** to `True` to allow an indeterminate (`null`) state in addition to on/off, exactly like `CheckBox`:
+
+```xml
+
+
+
+
+
+```
+
+### In a CommandBar
+
+AppBarToggleButton is most commonly used as a [CommandBar](./command-bar) command, and follows the bar's overflow and label rules the same way AppBarButton does:
+
+```xml
+
+
+
+
+
+
+
+```
+
+## Remarks
+
+### AppBarToggleButton vs. RadioMenuItem
+
+AppBarToggleButton is an independent on/off switch, checking one doesn't affect any other button. If you need mutually exclusive options instead (only one can be checked at a time), that's a grouping concern that this control doesn't provide, look at [RadioMenuItem](./menu-flyout) inside a [MenuFlyout](./menu-flyout) or [MenuBar](./menu-bar) instead.
+
+### IsCompact and label position
+
+Just like [AppBarButton](./appbar-button), **IsCompact** collapses the label down to an icon-only button, and **LabelPosition** overrides the owning [CommandBar](./command-bar)'s **DefaultLabelPosition** for this one button.
+
+## See also
+
+### Microsoft Learn
+
+- [AppBarToggleButton Class (WinRT)](https://learn.microsoft.com/en-us/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.controls.appbartogglebutton)
+
+- [Command bar - Windows apps](https://learn.microsoft.com/en-us/windows/apps/design/controls/command-bar)
+
+### Related controls
+
+- [AppBarButton](./appbar-button)
+
+- [AppBarRepeatButton](./appbar-repeat-button)
+
+- [AppBarSeparator](./appbar-separator)
+
+- [CommandBar](./command-bar)
diff --git a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# command-bar-flyout/index.en-US.mdx b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# command-bar-flyout/index.en-US.mdx
index d04dc20..4111778 100644
--- a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# command-bar-flyout/index.en-US.mdx
+++ b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# command-bar-flyout/index.en-US.mdx
@@ -1,37 +1,90 @@
----
-description: "A mini-toolbar displaying proactive commands, and an optional menu of commands."
----
-
-# CommandBarFlyout
-
-We're still working on this, coming soon!
-
-{/* {
- "UniqueId": "CommandBarFlyout",
- "Title": "CommandBarFlyout",
- "Subtitle": "A mini-toolbar displaying proactive commands, and an optional menu of commands.",
- "ImagePath": "ms-appx:///Assets/ControlImages/CommandBarFlyout.png",
- "ImageIconPath": "ms-appx:///Assets/ControlIcons/CommandBarFlyoutIcon.png",
- "Description": "A mini-toolbar which displays a set of proactive commands, as well as a secondary menu of commands if desired.",
- "Content": "",
- "IsNew": false,
- "IsUpdated": false,
- "Docs": [
- {
- "Title": "CommandBarFlyout - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.ui.xaml.controls.commandbarflyout"
- },
- {
- "Title": "Guidelines",
- "Uri": "https://docs.microsoft.com/windows/apps/design/controls/command-bar-flyout"
- }
- ],
- "RelatedControls": [
- "CommandBar",
- "MenuFlyout",
- "RichEditBox",
- "TextBox",
- "StandardUICommand",
- "XamlUICommand"
- ]
-}, */}
\ No newline at end of file
+---
+description: "A mini-toolbar displaying proactive commands, and an optional menu of commands."
+---
+
+# CommandBarFlyout
+
+Use a CommandBarFlyout to show a small, contextual toolbar of commands for a specific object, for example the selection toolbar that appears when you select text or right-click an image. It's essentially a [CommandBar](./command-bar) hosted inside a flyout: it has its own **PrimaryCommands** and **SecondaryCommands**, and closes itself automatically once a command is invoked.
+
+- **Class**: [iNKORE.UI.WPF.Modern.Controls](..)[.CommandBarFlyout](.)
+
+- **Inheritance**: [Object](https://learn.microsoft.com/en-us/dotnet/api/system.object) → (...) → [DependencyObject](https://learn.microsoft.com/en-us/dotnet/api/system.windows.dependencyobject) → FlyoutBase → [CommandBarFlyout](.)
+
+## Examples
+
+### A CommandBarFlyout for an in-app object
+
+Define the flyout once as a resource, and attach it wherever it's needed, here, on a button that wraps an image:
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+Show it explicitly through code, for example in response to a click or a context-menu request, using the `FlyoutBase.ShowAt` pattern:
+
+```csharp
+private void MyImageButton_Click(object sender, RoutedEventArgs e)
+{
+ var flyout = (CommandBarFlyout)Resources["ImageCommandBarFlyout"];
+ flyout.ShowAt((FrameworkElement)sender);
+}
+```
+
+## Remarks
+
+### It closes itself after a command runs
+
+CommandBarFlyout wires up its own `Click` (for buttons) and `Checked`/`Unchecked` (for toggle buttons) handling on every command you add, primary or secondary, and hides itself automatically once one of them fires. You don't need to call `Hide()` yourself after handling a command's `Click` event. The one exception is a button whose own **Flyout** is set, clicking it opens that flyout instead of closing the CommandBarFlyout.
+
+### CommandBarFlyout vs. CommandBar
+
+Reach for CommandBarFlyout instead of a plain [CommandBar](./command-bar) when the commands only make sense in the context of a specific object or selection, and should disappear once the user acts or clicks away, rather than being a permanent, always-visible part of your window's layout.
+
+### CommandBarFlyout vs. MenuFlyout
+
+CommandBarFlyout and [MenuFlyout](./menu-flyout) both pop up contextually, but they suit different content: CommandBarFlyout is for a row of icon buttons (proactive commands, plus an optional overflow menu), while MenuFlyout is for a vertical list of text commands, checkable items, and nested submenus, closer to a classic right-click context menu.
+
+## See also
+
+### Microsoft Learn
+
+- [CommandBarFlyout Class (WinRT)](https://learn.microsoft.com/en-us/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.controls.commandbarflyout)
+
+- [Command bar flyout - Windows apps](https://learn.microsoft.com/en-us/windows/apps/design/controls/command-bar-flyout)
+
+### Related controls
+
+- [CommandBar](./command-bar)
+
+- [MenuFlyout](./menu-flyout)
+
+- [AppBarButton](./appbar-button)
diff --git a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# command-bar/index.en-US.mdx b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# command-bar/index.en-US.mdx
index cadd039..982b90e 100644
--- a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# command-bar/index.en-US.mdx
+++ b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# command-bar/index.en-US.mdx
@@ -1,40 +1,139 @@
----
-description: "A toolbar for displaying application-specific commands that handles layout and resizing of its contents."
----
-
-# CommandBar
-
-We're still working on this, coming soon!
-
-The CommandBar simplifies the creation of basic app bars by providing:
-- Automatic layout of commands, with primary commands on the right and secondary commands on the left.
-- Automatic resizing of app bar commands when the app size changes.\nWhen you need an app bar that contains only AppBarButton,AppBarToggleButton, and AppBarSeparator controls, use a CommandBar.
-
-If you need more complex content, such as images, progress bars, or text blocks, use an AppBar control.
-
-{/* {
- "UniqueId": "CommandBar",
- "Title": "CommandBar",
- "Subtitle": "A toolbar for displaying application-specific commands that handles layout and resizing of its contents.",
- "ImagePath": "ms-appx:///Assets/ControlImages/CommandBar.png",
- "ImageIconPath": "ms-appx:///Assets/ControlIcons/CommandBarIcon.png",
- "Description": "The CommandBar simplifies the creation of basic app bars by providing:\n- Automatic layout of commands, with primary commands on the right and secondary commands on the left.\n- Automatic resizing of app bar commands when the app size changes.\nWhen you need an app bar that contains only AppBarButton,AppBarToggleButton , and AppBarSeparator controls, use a CommandBar. If you need more complex content, such as images, progress bars, or text blocks, use an AppBar control.",
- "Content": "
The bottom app bar on this page is a CommandBar control.
Add secondary commands and then resize the app to see how the CommandBar automatically adapts to different widths.
This CommandBar element is in the ItemPage so it can be shared across all control pages in the app. Look at the ItemPage.xaml file in Visual Studio to see the full code for this page.
",
- "IsNew": false,
- "IsUpdated": false,
- "Docs": [
- {
- "Title": "CommandBar - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.ui.xaml.controls.commandbar"
- },
- {
- "Title": "Guidelines",
- "Uri": "https://docs.microsoft.com/windows/apps/design/controls/command-bar"
- }
- ],
- "RelatedControls": [
- "AppBarButton",
- "AppBarToggleButton",
- "AppBarSeparator"
- ]
-}, */}
\ No newline at end of file
+---
+description: "A toolbar for displaying application-specific commands that handles layout and resizing of its contents."
+---
+
+# CommandBar
+
+Use a CommandBar to give users quick access to the most common actions in your app. A CommandBar automatically lays out its commands, with **PrimaryCommands** shown directly on the bar and **SecondaryCommands** collapsed into an overflow menu, and moves primary commands into overflow on its own as the available width shrinks.
+
+- **Class**: [iNKORE.UI.WPF.Modern.Controls](..)[.CommandBar](.)
+
+- **Inheritance**: [Object](https://learn.microsoft.com/en-us/dotnet/api/system.object) → (...) → [Control](https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls.control) → [CommandBar](.)
+
+A CommandBar is built almost entirely out of [AppBarButton](./appbar-button), [AppBarToggleButton](./appbar-toggle-button), and [AppBarSeparator](./appbar-separator) elements, this is what lets it automatically resize and reflow its content.
+
+## Examples
+
+### A basic CommandBar
+
+Add elements to **PrimaryCommands** for the actions you always want visible, and to **SecondaryCommands** for less common actions that can live in the overflow menu. **DefaultLabelPosition** controls where each primary command's label is drawn relative to its icon.
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+```csharp
+private void OnElementClicked(object sender, RoutedEventArgs e)
+{
+ var button = (AppBarButton)sender;
+ SelectedOptionText.Text = "You clicked: " + button.Label;
+}
+```
+
+### Opening and closing the overflow menu
+
+**IsOpen** controls whether the secondary-commands overflow menu is expanded, and is two-way bindable, so you can drive it from a toggle in your own UI as well as from user clicks:
+
+```csharp
+private void OpenButton_Click(object sender, RoutedEventArgs e) => PrimaryCommandBar.IsOpen = true;
+
+private void CloseButton_Click(object sender, RoutedEventArgs e) => PrimaryCommandBar.IsOpen = false;
+```
+
+### Adding commands at runtime
+
+**PrimaryCommands** and **SecondaryCommands** are `ObservableCollection`, so you can build a CommandBar entirely in code, or add to one that's already on screen:
+
+```csharp
+var newButton = new AppBarButton
+{
+ Icon = new FontIcon(SegoeFluentIcons.Delete),
+ Label = "Delete"
+};
+newButton.AddKeyboardAccelerator(Key.Delete);
+
+PrimaryCommandBar.SecondaryCommands.Add(newButton);
+PrimaryCommandBar.SecondaryCommands.Add(new AppBarSeparator());
+```
+
+## Remarks
+
+### Content beyond commands
+
+WinUI's older docs point people toward a separate `AppBar` control when a command bar needs more than buttons, toggles, and separators, images, progress bars, or arbitrary text. This library doesn't include that separate `AppBar` control. Instead, use CommandBar's own **Content** and **ContentTemplate** properties: whatever you set there is rendered as the bar's header, before the primary commands, so you can put arbitrary content directly on the bar without a different control:
+
+```xml
+
+
+
+
+
+
+```
+
+### Controlling overflow behavior
+
+- **IsDynamicOverflowEnabled** (default `True`) lets primary commands move into overflow automatically when the bar runs out of room. Set it to `False` if you'd rather primary commands stay put and just get clipped.
+
+- **OverflowButtonVisibility** controls whether the "more" (`...`) button is shown `Auto`matically only when there's something to overflow, always `Visible`, or always `Collapsed`.
+
+- Setting `ToolBar.OverflowMode` (inherited by every `AppBarButton`/`AppBarToggleButton`/`AppBarSeparator`) to `Always` is how an item ends up in **SecondaryCommands** in the first place; you normally don't need to set it directly since placing an element in `PrimaryCommands` or `SecondaryCommands` does it for you.
+
+### Keyboard accelerators
+
+CommandBar elements support keyboard accelerators through the `AddKeyboardAccelerator` extension method, letting users trigger a command without opening the bar at all:
+
+```csharp
+AddButton.AddKeyboardAccelerator(Key.A, ModifierKeys.Control);
+DeleteButton.AddKeyboardAccelerator(Key.Delete);
+```
+
+### Opened and Closed events
+
+**Opened** and **Closed** fire when the overflow menu itself opens or closes, not when the whole CommandBar becomes visible. Use them if you need to react specifically to the overflow flyout, for example to load its contents lazily.
+
+## See also
+
+### Microsoft Learn
+
+- [CommandBar Class (WinRT)](https://learn.microsoft.com/en-us/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.controls.commandbar)
+
+- [Command bar - Windows apps](https://learn.microsoft.com/en-us/windows/apps/design/controls/command-bar)
+
+### Related controls
+
+- [AppBarButton](./appbar-button)
+
+- [AppBarToggleButton](./appbar-toggle-button)
+
+- [AppBarRepeatButton](./appbar-repeat-button)
+
+- [AppBarSeparator](./appbar-separator)
+
+- [CommandBarFlyout](./command-bar-flyout)
+
+- [MenuBar](./menu-bar)
diff --git a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# menu-bar/index.en-US.mdx b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# menu-bar/index.en-US.mdx
index 841663f..1305768 100644
--- a/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# menu-bar/index.en-US.mdx
+++ b/data/docs/ui-wpf-modern/03. components/07. menu-and-toolbars/# menu-bar/index.en-US.mdx
@@ -1,35 +1,104 @@
----
-description: "A classic menu, allowing the display of MenuItems containing MenuFlyoutItems."
----
-
-# MenuBar
-
-We're still working on this, coming soon!
-
-{/* {
- "UniqueId": "MenuBar",
- "Title": "MenuBar",
- "Subtitle": "A classic menu, allowing the display of MenuItems containing MenuFlyoutItems.",
- "ImagePath": "ms-appx:///Assets/ControlImages/MenuBar.png",
- "ImageIconPath": "ms-appx:///Assets/ControlIcons/MenuBarIcon.png",
- "Description": "The Menubar simplifies the creation of basic applications by providing a set of menus at the top of the app or window.",
- "Content": "",
- "IsNew": false,
- "IsUpdated": false,
- "Docs": [
- {
- "Title": "MenuBar - API",
- "Uri": "https://docs.microsoft.com/windows/winui/api/microsoft.UI.Xaml.Controls.MenuBar"
- },
- {
- "Title": "Guidelines",
- "Uri": "https://docs.microsoft.com/windows/apps/design/controls/menus"
- }
- ],
- "RelatedControls": [
- "CommandBar",
- "MenuFlyout",
- "StandardUICommand",
- "XamlUICommand"
- ]
-}, */}
\ No newline at end of file
+---
+description: "A classic menu, allowing the display of MenuItems containing MenuFlyoutItems."
+---
+
+# MenuBar
+
+A MenuBar is the classic row of menus across the top of a window, File, Edit, View, and so on. Unlike the other controls on this page, there's no separate `MenuBar` class in this library: it's just this library's Fluent 2 restyling of the native WPF **Menu** control, used the way you'd normally use a `Menu` at the top of a window.
+
+- **Class**: [System.Windows.Controls](https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls)[.Menu](https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls.menu)
+
+- **Inheritance**: [Object](https://learn.microsoft.com/en-us/dotnet/api/system.object) → (...) → [ItemsControl](https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls.itemscontrol) → [Menu](https://learn.microsoft.com/en-us/dotnet/api/system.windows.controls.menu)
+
+Because it's the native `Menu`, no `xmlns:ui` prefix is needed on the `