From 49ee6546f172fa8cc0ebcc19d039d75f5e8c02f0 Mon Sep 17 00:00:00 2001
From: Jonathan Peppers <jonathan.peppers@microsoft.com>
Date: Mon, 15 Jun 2026 18:09:31 -0500
Subject: [PATCH 1/6] Wire RefreshColor on RefreshViewHandler

Maps Microsoft.Maui.Graphics.SolidPaint on IRefreshView.RefreshColor
to the Compose Material 3 PullToRefreshDefaults.Indicator spinner
color. Null (or non-solid) RefreshColor keeps the existing
ComposePullToRefreshBox facade path; a non-null solid color switches
to a hand-written ColoredIndicatorBox ComposableNode that calls
PullToRefreshKt.PullToRefreshBox directly with a custom indicator
IFunction3 invoking PullToRefreshDefaults.Instance.Indicator(...)
with the packed color.

Adds [InternalsVisibleTo("Microsoft.AndroidX.Compose.Maui")] to the
Compose facade assembly so the Maui project can reach the internal
ComposableLambdas/ComposableLambda0/BuildModifier helpers needed by
ColoredIndicatorBox.

RefreshViewHandler is now at 35 / 35 (100%) per docs/maui-coverage.md.

The sample's RefreshPage now ships RefreshColor="#FF6B35" so the
behaviour is exercised on-device.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 docs/maui-coverage.md                         |  19 +-
 .../Pages/RefreshPage.xaml                    |   7 +-
 .../Handlers/RefreshViewHandler.cs            | 183 ++++++++++++++++--
 .../AssemblyInfo.cs                           |  11 ++
 4 files changed, 192 insertions(+), 28 deletions(-)
 create mode 100644 src/Microsoft.AndroidX.Compose/AssemblyInfo.cs

diff --git a/docs/maui-coverage.md b/docs/maui-coverage.md
index 24d3799e..db337bc7 100644
--- a/docs/maui-coverage.md
+++ b/docs/maui-coverage.md
@@ -1,6 +1,6 @@
 # .NET MAUI ⇄ Microsoft.AndroidX.Compose.Maui backend coverage
 
-Generated by `scripts/maui-coverage.cs` on 2026-06-12 22:58 UTC.
+Generated by `scripts/maui-coverage.cs` on 2026-06-15 23:09 UTC.
 
 Pinned MAUI version: **10.0.20** (from `Directory.Build.targets`).
 
@@ -15,14 +15,14 @@ collected transitively across base mappers (`ViewHandler.ViewMapper`,
 
 - **Stock MAUI handlers in scope**: 43
 - **Handlers we override**: 24 (**55.8%**)
-- **Property-mapper keys covered**: 883 / 1224 (**72.1%**)
+- **Property-mapper keys covered**: 884 / 1224 (**72.2%**)
 
 ### Per-category coverage
 
 | Category | Handlers | Keys |
 | --- | --- | --- |
 | **Pages / Navigation** | 1/4 (25%) | 33/130 (25%) |
-| **Containers** | 5/5 (100%) | 166/174 (95%) |
+| **Containers** | 5/5 (100%) | 167/174 (96%) |
 | **Leaves** | 18/18 (100%) | 684/695 (98%) |
 | **Menus / Toolbar** | 0/7 (0%) | 0/1 (0%) |
 | **Shapes** | 0/1 (0%) | 0/41 (0%) |
@@ -42,7 +42,7 @@ Sorted by category. ✅ = fully covered (100%), 🟡 = partial, ❌ = not implem
 | 🟡 | `BorderHandler` | Containers | `Border` | `BorderHandler` | 35 / 40 (88%) |
 | ✅ | `ContentViewHandler` | Containers | `ContentView`, `IContentView` | `ContentViewHandler` | 32 / 32 (100%) |
 | ✅ | `LayoutHandler` | Containers | `Layout` | `LayoutHandler` | 32 / 32 (100%) |
-| 🟡 | `RefreshViewHandler` | Containers | `RefreshView` | `RefreshViewHandler` | 34 / 35 (97%) |
+| ✅ | `RefreshViewHandler` | Containers | `RefreshView` | `RefreshViewHandler` | 35 / 35 (100%) |
 | 🟡 | `ScrollViewHandler` | Containers | `ScrollView` | `ScrollViewHandler` | 33 / 35 (94%) |
 | ✅ | `ActivityIndicatorHandler` | Leaves | `ActivityIndicator` | `ActivityIndicatorHandler` | 33 / 33 (100%) |
 | ✅ | `ButtonHandler` | Leaves | `Button` | `ButtonHandler` | 40 / 40 (100%) |
@@ -116,7 +116,6 @@ dashed stroke patterns on `Border`).
 - **`RadioButtonHandler`** (92%) — missing: `CornerRadius`, `StrokeColor`, `StrokeThickness`
 - **`ScrollViewHandler`** (94%) — missing: `HorizontalScrollBarVisibility`, `VerticalScrollBarVisibility`
 - **`ImageHandler`** (97%) — missing: `IsAnimationPlaying`
-- **`RefreshViewHandler`** (97%) — missing: `RefreshColor`
 - **`ImageButtonHandler`** (97%) — missing: `IsAnimationPlaying`
 - **`SliderHandler`** (97%) — missing: `ThumbImageSource`
 - **`LabelHandler`** (98%) — missing: `VerticalTextAlignment`
@@ -454,13 +453,9 @@ Extra keys we map (no stock counterpart):
 
 </details>
 
-### 🟡 `RefreshViewHandler` — `RefreshView`
+### ✅ `RefreshViewHandler` — `RefreshView`
 
-Backed by `RefreshViewHandler`. **34 / 35 keys (97%)**.
-
-Missing keys:
-
-- [ ] `RefreshColor`
+Backed by `RefreshViewHandler`. **35 / 35 keys (100%)**.
 
 <details><summary>All stock keys</summary>
 
@@ -483,7 +478,7 @@ Missing keys:
 - [x] `MinimumHeight`
 - [x] `MinimumWidth`
 - [x] `Opacity`
-- [ ] `RefreshColor`
+- [x] `RefreshColor`
 - [x] `Rotation`
 - [x] `RotationX`
 - [x] `RotationY`
diff --git a/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/RefreshPage.xaml b/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/RefreshPage.xaml
index 1d033fca..3c0d6b70 100644
--- a/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/RefreshPage.xaml
+++ b/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/RefreshPage.xaml
@@ -18,6 +18,7 @@
               VerticalStackLayout folds into the parent Page composition.
     -->
     <RefreshView x:Name="Refresh"
+                 RefreshColor="#FF6B35"
                  Refreshing="OnRefreshing">
         <ScrollView>
             <VerticalStackLayout x:Name="ItemsHost"
@@ -44,10 +45,12 @@
                 <Label x:Name="Item4" Text="• Item 5" />
 
                 <!-- New mapper coverage: IsRefreshEnabled toggles whether
-                     the pull gesture even kicks off a refresh. -->
+                     the pull gesture even kicks off a refresh.
+                     RefreshColor (above on the RefreshView) tints the
+                     spinner glyph orange. -->
                 <Label Text="-- New mapper coverage --"
                        FontAttributes="Bold" />
-                <Label Text="Toggle below disables/enables IsRefreshEnabled. Pull-to-refresh ignores gestures while disabled." />
+                <Label Text="The spinner glyph is tinted via RefreshColor=&quot;#FF6B35&quot;. The toggle below disables/enables IsRefreshEnabled. Pull-to-refresh ignores gestures while disabled." />
                 <Switch x:Name="EnabledSwitch"
                         IsToggled="True"
                         Toggled="OnRefreshEnabledToggled"
diff --git a/src/Microsoft.AndroidX.Compose.Maui/Handlers/RefreshViewHandler.cs b/src/Microsoft.AndroidX.Compose.Maui/Handlers/RefreshViewHandler.cs
index d828aefe..272c8ff0 100644
--- a/src/Microsoft.AndroidX.Compose.Maui/Handlers/RefreshViewHandler.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui/Handlers/RefreshViewHandler.cs
@@ -1,6 +1,8 @@
 using AndroidX.Compose;
+using AndroidX.Compose.Material3.PullToRefresh;
 using AndroidX.Compose.Runtime;
 using AndroidX.Compose.UI.Platform;
+using Kotlin.Jvm.Functions;
 using Microsoft.AndroidX.Compose.Maui.Platform;
 using Microsoft.Maui.Handlers;
 using ComposePullToRefreshBox = AndroidX.Compose.PullToRefreshBox;
@@ -39,11 +41,15 @@ namespace Microsoft.AndroidX.Compose.Maui.Handlers;
 /// <see cref="LayoutHandler"/> / <see cref="ContentViewHandler"/>, so
 /// nested Compose-backed views fold into the parent composition.</para>
 ///
-/// <para><see cref="IRefreshView.RefreshColor"/> isn't wired yet: the
-/// current C# <c>PullToRefreshBox</c> facade doesn't expose
-/// <c>containerColor</c> / <c>contentColor</c> slots. Until it does,
-/// the spinner uses Material 3's default theme tint. Tracked as a
-/// follow-up for the next slice.</para>
+/// <para><see cref="IRefreshView.RefreshColor"/> maps to the spinner
+/// glyph color via <see cref="PullToRefreshDefaults"/>'s
+/// <c>Indicator(state, isRefreshing, modifier, containerColor, color,
+/// maxDistance, ...)</c> helper. When unset the spinner falls back to
+/// Material 3's default tint and we render the plain
+/// <see cref="ComposePullToRefreshBox"/> facade; when set we render
+/// directly through the bound <c>PullToRefreshKt.PullToRefreshBox</c>
+/// with a custom indicator <c>IFunction3</c> slot that supplies the
+/// packed color.</para>
 /// </remarks>
 public partial class RefreshViewHandler : ComposeElementHandler<IRefreshView>
 {
@@ -56,25 +62,21 @@ public partial class RefreshViewHandler : ComposeElementHandler<IRefreshView>
         {
             [nameof(IRefreshView.IsRefreshing)]      = MapIsRefreshing,
             [nameof(IRefreshView.IsRefreshEnabled)]  = MapIsRefreshEnabled,
+            [nameof(IRefreshView.RefreshColor)]      = MapRefreshColor,
             ["Content"]                              = MapContent,
-            // TODO: IRefreshView.RefreshColor — Compose Material 3's
-            // PullToRefreshBox doesn't currently expose containerColor /
-            // contentColor through our facade (the bound Kotlin overload
-            // takes a PullToRefreshState parameter we don't surface).
-            // Wiring this needs a PullToRefreshBox facade extension —
-            // larger surgery than fits this PR.
         };
 
     /// <summary>Command mapper (inherits view-level commands; no extras).</summary>
     public static CommandMapper<IRefreshView, RefreshViewHandler> CommandMapper =
         new(ViewCommandMapper);
 
-    readonly MutableState<bool> _isRefreshing  = new(false);
-    readonly MutableState<bool> _isEnabled     = new(true);
+    readonly MutableState<bool>  _isRefreshing   = new(false);
+    readonly MutableState<bool>  _isEnabled      = new(true);
+    readonly MutableState<long?> _refreshColor   = new((long?)null);
     // Bumped whenever Content swaps so BuildNode reads the live
     // PresentedContent reference (IView itself doesn't fit in
     // MutableState<T>; same trick as ContentViewHandler).
-    readonly MutableState<int>  _contentVersion = new(0);
+    readonly MutableState<int>   _contentVersion = new(0);
 
     /// <summary>Construct a handler with the default mappers.</summary>
     public RefreshViewHandler() : base(Mapper, CommandMapper) { }
@@ -96,6 +98,18 @@ public override ComposableNode BuildNode(IComposer composer)
             ?? throw new InvalidOperationException("MauiContext not set on RefreshViewHandler.");
 
         bool isEnabled = _isEnabled.Value;
+
+        // When RefreshColor is set we drop into the
+        // PullToRefreshBox-with-custom-indicator path so the spinner
+        // glyph picks up the caller-supplied tint. The default path
+        // keeps using the existing facade, which lets Material 3's
+        // theme drive the indicator colors.
+        if (_refreshColor.Value is long packedColor)
+        {
+            return new ColoredIndicatorBox(
+                this, view, context, isEnabled, packedColor);
+        }
+
         var box = new ComposePullToRefreshBox(
             isRefreshing: _isRefreshing.Value,
             onRefresh:    () =>
@@ -153,4 +167,145 @@ public static void MapContent(RefreshViewHandler handler, IRefreshView _) =>
     /// </summary>
     public static void MapIsRefreshEnabled(RefreshViewHandler handler, IRefreshView view) =>
         handler._isEnabled.Value = view.IsRefreshEnabled;
+
+    /// <summary>
+    /// Map <see cref="IRefreshView.RefreshColor"/> to the spinner
+    /// glyph color. <c>null</c> (or a non-<see cref="SolidPaint"/>
+    /// brush) falls back to Material 3's default theme tint and the
+    /// handler renders the plain <see cref="ComposePullToRefreshBox"/>
+    /// facade; a non-null solid color switches us to the
+    /// custom-indicator render path.
+    /// </summary>
+    /// <remarks>
+    /// <see cref="IRefreshView.RefreshColor"/> is a
+    /// <see cref="Paint"/> on the interface so consumers can in theory
+    /// bind a gradient brush — but MAUI's stock platform handlers all
+    /// flatten that to a single tint, so we do the same. Gradient
+    /// paints are silently treated as "no color set".
+    /// </remarks>
+    public static void MapRefreshColor(RefreshViewHandler handler, IRefreshView view) =>
+        handler._refreshColor.Value = ColorMapping.ToPackedLong((view.RefreshColor as SolidPaint)?.Color);
+
+    /// <summary>
+    /// Hand-written <see cref="ComposableNode"/> that drives the
+    /// <c>PullToRefreshKt.PullToRefreshBox</c> binding directly so the
+    /// indicator slot can pipe a caller-supplied
+    /// <see cref="IRefreshView.RefreshColor"/> through to
+    /// <see cref="PullToRefreshDefaults.Instance"/>'s
+    /// <c>Indicator(...)</c> helper. Lives here (not as a generated
+    /// facade) because no current <c>[ComposeFacade]</c> shape models
+    /// "rebuild PullToRefreshBox with a custom indicator slot whose
+    /// only deviation from Material 3's default is the spinner color".
+    /// </summary>
+    sealed class ColoredIndicatorBox : ComposableNode
+    {
+        // PullToRefreshBox $default mask bits — order mirrors
+        // PullToRefreshBoxDefault in ComposeDefaults.cs.
+        const int BitContentAlignment = 1 << 4;
+
+        // PullToRefreshDefaults.Indicator $default mask bits — order
+        // matches the bound JNI signature
+        // (state, isRefreshing, modifier, containerColor, color,
+        // maxDistance). Bits 0/1 are always supplied; bit 4 is
+        // cleared when we pass our own color.
+        const int IndicatorBitModifier       = 1 << 2;
+        const int IndicatorBitContainerColor = 1 << 3;
+        const int IndicatorBitMaxDistance    = 1 << 5;
+
+        readonly RefreshViewHandler _owner;
+        readonly IRefreshView       _view;
+        readonly IMauiContext       _context;
+        readonly bool               _isEnabled;
+        readonly long               _packedColor;
+
+        public ColoredIndicatorBox(
+            RefreshViewHandler owner,
+            IRefreshView       view,
+            IMauiContext       context,
+            bool               isEnabled,
+            long               packedColor)
+        {
+            _owner       = owner;
+            _view        = view;
+            _context     = context;
+            _isEnabled   = isEnabled;
+            _packedColor = packedColor;
+        }
+
+        public override void Render(IComposer composer)
+        {
+            // Mirror RefreshViewHandler.BuildNode's IsRefreshEnabled
+            // gesture-swallow guard (see comments there).
+            var onRefresh = new ComposableLambda0(() =>
+            {
+                if (!_isEnabled) return;
+                _owner._isRefreshing.Value = true;
+                _view.IsRefreshing         = true;
+            });
+
+            // Remember the JVM PullToRefreshState. RememberPullToRefreshState
+            // is itself a @Composable that internally uses `remember`,
+            // so calling it directly during Render returns the same
+            // instance across recompositions (Kotlin slot-table identity).
+            // No outer `composer.Remember(...)` wrapper needed.
+            var state = PullToRefreshKt.RememberPullToRefreshState(composer, 0);
+
+            bool isRefreshing = _owner._isRefreshing.Value;
+
+            // Custom indicator slot — calls the bound
+            // PullToRefreshDefaults.Indicator(...) with our packed
+            // color.
+            IFunction3 indicator = ComposableLambdas.Wrap3(
+                composer,
+                c =>
+                {
+                    int indicatorMask =
+                        IndicatorBitModifier |
+                        IndicatorBitContainerColor |
+                        IndicatorBitMaxDistance;
+                    PullToRefreshDefaults.Instance.Indicator(
+                        state:           state,
+                        isRefreshing:    isRefreshing,
+                        modifier:        null,
+                        containerColor:  0L,
+                        color:           _packedColor,
+                        maxDistance:     0f,
+                        _composer:       c,
+                        p7:              indicatorMask,
+                        _changed:        0);
+                });
+
+            // Content lambda — same walk as the default path.
+            IFunction3 content = ComposableLambdas.Wrap3(
+                composer,
+                c =>
+                {
+                    if (_view.Content is { } child)
+                        ComposeWalker.Render(child, c, _context);
+                });
+
+            var modifier = Modifier.FillMaxSize()
+                .ApplyViewProperties(_view)
+                .ApplySemantics(_view);
+
+            // PullToRefreshBox $default mask. Bits we always pass —
+            // isRefreshing(0), onRefresh(1), modifier(2), state(3),
+            // indicator(5), content(6) — stay cleared. Bit 4
+            // (contentAlignment) is set so Kotlin uses its default
+            // (Alignment.TopCenter for the indicator placement).
+            int boxMask = BitContentAlignment;
+
+            PullToRefreshKt.PullToRefreshBox(
+                isRefreshing:     isRefreshing,
+                onRefresh:        onRefresh,
+                modifier:         modifier.Build(),
+                state:            state,
+                contentAlignment: null,
+                indicator:        indicator,
+                content:          content,
+                _composer:        composer,
+                p8:               boxMask,
+                _changed:         0);
+        }
+    }
 }
diff --git a/src/Microsoft.AndroidX.Compose/AssemblyInfo.cs b/src/Microsoft.AndroidX.Compose/AssemblyInfo.cs
new file mode 100644
index 00000000..ea91fa37
--- /dev/null
+++ b/src/Microsoft.AndroidX.Compose/AssemblyInfo.cs
@@ -0,0 +1,11 @@
+using System.Runtime.CompilerServices;
+
+// The MAUI handler assembly hand-writes a small handful of
+// ComposableNode subclasses (e.g. RefreshViewHandler's
+// PullToRefreshBox-with-indicator-color renderer, SliderHandler's
+// thumb-bearing slider) that need to call the same internal
+// ComposableLambdas.Wrap2/Wrap3 helpers facades use, plus a few of
+// the [ComposeBridge]-decorated state-holder shims on the internal
+// ComposeBridges static class. Limited to the Maui assembly so the
+// surface stays "everything else is public C# facade or extension".
+[assembly: InternalsVisibleTo("Microsoft.AndroidX.Compose.Maui")]

From 387e4638bc89c9f21872d76a7beaa1efd345e827 Mon Sep 17 00:00:00 2001
From: Jonathan Peppers <jonathan.peppers@microsoft.com>
Date: Mon, 15 Jun 2026 18:16:29 -0500
Subject: [PATCH 2/6] Wire ThumbImageSource on SliderHandler

Maps ISlider.ThumbImageSource through the shared ImageSourceLoader
(same helper backing ImageHandler / ImageButtonHandler). A small
SliderThumbImageSourcePart adapter exposes the slider as an
IImageSourcePart so the loader's standard MAUI pipeline resolves the
source to either a drawable id (fast path) or a runtime-decoded
BitmapPainter (general path).

When the loader resolves a painter or drawable id, BuildNode swaps to
a hand-written ImageThumbSlider ComposableNode that calls the
lower-level SliderKt.Slider(value, onValueChange, ..., thumb=...)
overload directly with an Image of the resolved source in the thumb
slot. Material 3's stock Slider draws its thumb as a fixed circle and
has no public way to inject a custom drawable, so we have to go
through the bound overload rather than the existing Slider facade.

SliderHandler is now at 38 / 38 (100%) per docs/maui-coverage.md.

The sample's SlidersPage now ships a third slider with
ThumbImageSource="dotnet_bot.png" so the path is exercised on-device.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 docs/maui-coverage.md                         |  19 +-
 .../Pages/SlidersPage.xaml                    |  15 ++
 .../Pages/SlidersPage.xaml.cs                 |  11 +-
 .../Handlers/SliderHandler.cs                 | 222 +++++++++++++++++-
 4 files changed, 246 insertions(+), 21 deletions(-)

diff --git a/docs/maui-coverage.md b/docs/maui-coverage.md
index db337bc7..68563bf3 100644
--- a/docs/maui-coverage.md
+++ b/docs/maui-coverage.md
@@ -1,6 +1,6 @@
 # .NET MAUI ⇄ Microsoft.AndroidX.Compose.Maui backend coverage
 
-Generated by `scripts/maui-coverage.cs` on 2026-06-15 23:09 UTC.
+Generated by `scripts/maui-coverage.cs` on 2026-06-15 23:16 UTC.
 
 Pinned MAUI version: **10.0.20** (from `Directory.Build.targets`).
 
@@ -15,7 +15,7 @@ collected transitively across base mappers (`ViewHandler.ViewMapper`,
 
 - **Stock MAUI handlers in scope**: 43
 - **Handlers we override**: 24 (**55.8%**)
-- **Property-mapper keys covered**: 884 / 1224 (**72.2%**)
+- **Property-mapper keys covered**: 885 / 1224 (**72.3%**)
 
 ### Per-category coverage
 
@@ -23,7 +23,7 @@ collected transitively across base mappers (`ViewHandler.ViewMapper`,
 | --- | --- | --- |
 | **Pages / Navigation** | 1/4 (25%) | 33/130 (25%) |
 | **Containers** | 5/5 (100%) | 167/174 (96%) |
-| **Leaves** | 18/18 (100%) | 684/695 (98%) |
+| **Leaves** | 18/18 (100%) | 685/695 (99%) |
 | **Menus / Toolbar** | 0/7 (0%) | 0/1 (0%) |
 | **Shapes** | 0/1 (0%) | 0/41 (0%) |
 | **App / Window** | 0/2 (0%) | 0/8 (0%) |
@@ -58,7 +58,7 @@ Sorted by category. ✅ = fully covered (100%), 🟡 = partial, ❌ = not implem
 | ✅ | `ProgressBarHandler` | Leaves | `ProgressBar` | `ProgressBarHandler` | 33 / 33 (100%) |
 | 🟡 | `RadioButtonHandler` | Leaves | `RadioButton` | `RadioButtonHandler` | 36 / 39 (92%) |
 | 🟡 | `SearchBarHandler` | Leaves | `SearchBar` | `SearchBarHandler` | 46 / 47 (98%) |
-| 🟡 | `SliderHandler` | Leaves | `Slider` | `SliderHandler` | 37 / 38 (97%) |
+| ✅ | `SliderHandler` | Leaves | `Slider` | `SliderHandler` | 38 / 38 (100%) |
 | ✅ | `StepperHandler` | Leaves | `Stepper` | `StepperHandler` | 35 / 35 (100%) |
 | ✅ | `SwitchHandler` | Leaves | `Switch` | `SwitchHandler` | 34 / 34 (100%) |
 | ✅ | `TimePickerHandler` | Leaves | `TimePicker` | `TimePickerHandler` | 37 / 37 (100%) |
@@ -117,7 +117,6 @@ dashed stroke patterns on `Border`).
 - **`ScrollViewHandler`** (94%) — missing: `HorizontalScrollBarVisibility`, `VerticalScrollBarVisibility`
 - **`ImageHandler`** (97%) — missing: `IsAnimationPlaying`
 - **`ImageButtonHandler`** (97%) — missing: `IsAnimationPlaying`
-- **`SliderHandler`** (97%) — missing: `ThumbImageSource`
 - **`LabelHandler`** (98%) — missing: `VerticalTextAlignment`
 - **`PickerHandler`** (98%) — missing: `VerticalTextAlignment`
 - **`EditorHandler`** (98%) — missing: `VerticalTextAlignment`
@@ -1288,13 +1287,9 @@ Extra keys we map (no stock counterpart):
 
 </details>
 
-### 🟡 `SliderHandler` — `Slider`
+### ✅ `SliderHandler` — `Slider`
 
-Backed by `SliderHandler`. **37 / 38 keys (97%)**.
-
-Missing keys:
-
-- [ ] `ThumbImageSource`
+Backed by `SliderHandler`. **38 / 38 keys (100%)**.
 
 <details><summary>All stock keys</summary>
 
@@ -1328,7 +1323,7 @@ Missing keys:
 - [x] `Semantics`
 - [x] `Shadow`
 - [x] `ThumbColor`
-- [ ] `ThumbImageSource`
+- [x] `ThumbImageSource`
 - [x] `ToolTip`
 - [x] `Toolbar`
 - [x] `TranslationX`
diff --git a/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/SlidersPage.xaml b/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/SlidersPage.xaml
index d1a7bd71..91bd52de 100644
--- a/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/SlidersPage.xaml
+++ b/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/SlidersPage.xaml
@@ -59,6 +59,21 @@
                 x:Name="ColoredValueLabel"
                 Text="value = 0" />
 
+            <Label Text="-- Slider with ThumbImageSource --"
+                   FontAttributes="Bold" />
+
+            <Slider
+                x:Name="ThumbImageSlider"
+                Minimum="0"
+                Maximum="100"
+                Value="50"
+                ThumbImageSource="dotnet_bot.png"
+                ValueChanged="OnThumbImageSliderChanged" />
+
+            <Label
+                x:Name="ThumbImageValueLabel"
+                Text="value = 50" />
+
             <Label Text="-- Stepper bound to a label (Increment=2) --"
                    FontAttributes="Bold" />
 
diff --git a/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/SlidersPage.xaml.cs b/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/SlidersPage.xaml.cs
index 56789a3f..1eb44a93 100644
--- a/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/SlidersPage.xaml.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/SlidersPage.xaml.cs
@@ -30,14 +30,19 @@ void OnColoredSliderChanged(object? sender, ValueChangedEventArgs e) =>
         ColoredValueLabel.Text =
             $"value = {e.NewValue.ToString("0.0", CultureInfo.InvariantCulture)}";
 
+    void OnThumbImageSliderChanged(object? sender, ValueChangedEventArgs e) =>
+        ThumbImageValueLabel.Text =
+            $"value = {e.NewValue.ToString("0", CultureInfo.InvariantCulture)}";
+
     void OnStepperChanged(object? sender, ValueChangedEventArgs e) =>
         StepperValueLabel.Text =
             e.NewValue.ToString("0", CultureInfo.InvariantCulture);
 
     void OnResetClicked(object? sender, EventArgs e)
     {
-        DefaultSlider.Value = 0.25;
-        ColoredSlider.Value = 0;
-        DemoStepper.Value   = 6;
+        DefaultSlider.Value     = 0.25;
+        ColoredSlider.Value     = 0;
+        ThumbImageSlider.Value  = 50;
+        DemoStepper.Value       = 6;
     }
 }
diff --git a/src/Microsoft.AndroidX.Compose.Maui/Handlers/SliderHandler.cs b/src/Microsoft.AndroidX.Compose.Maui/Handlers/SliderHandler.cs
index ae24de4d..7982d5cf 100644
--- a/src/Microsoft.AndroidX.Compose.Maui/Handlers/SliderHandler.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui/Handlers/SliderHandler.cs
@@ -1,10 +1,15 @@
 using AndroidX.Compose;
 using AndroidX.Compose.Material3;
 using AndroidX.Compose.Runtime;
+using AndroidX.Compose.UI.Platform;
+using Kotlin.Jvm.Functions;
 using Kotlin.Ranges;
+using Microsoft.AndroidX.Compose.Maui.Loaders;
 using Microsoft.AndroidX.Compose.Maui.Platform;
 using Microsoft.Maui.Handlers;
-using ComposeSlider = AndroidX.Compose.Slider;
+using ComposeImage   = AndroidX.Compose.Image;
+using ComposePainter = AndroidX.Compose.UI.Graphics.Painter.Painter;
+using ComposeSlider  = AndroidX.Compose.Slider;
 
 namespace Microsoft.AndroidX.Compose.Maui.Handlers;
 
@@ -38,6 +43,16 @@ namespace Microsoft.AndroidX.Compose.Maui.Handlers;
 /// MAUI exposes (<c>thumbColor</c>, <c>activeTrackColor</c>,
 /// <c>inactiveTrackColor</c>) are wired — tick colours and the four
 /// disabled siblings stay at the Material default.</para>
+///
+/// <para><see cref="ISlider.ThumbImageSource"/> is resolved through
+/// the shared <see cref="ImageSourceLoader"/> (the same helper that
+/// backs <see cref="ImageHandler"/>). When a thumb image is supplied
+/// the handler swaps to a hand-written
+/// <see cref="ComposableNode"/> that calls the lower-level
+/// <c>SliderKt.Slider(..., thumb = { ... })</c> overload directly with
+/// an <see cref="ComposeImage"/> thumb slot — Material 3's stock
+/// <c>Slider</c> draws its thumb as a fixed circle and has no public
+/// way to inject a custom drawable.</para>
 /// </remarks>
 public partial class SliderHandler : ComposeElementHandler<ISlider>
 {
@@ -54,11 +69,7 @@ public partial class SliderHandler : ComposeElementHandler<ISlider>
             [nameof(ISlider.MinimumTrackColor)] = MapMinimumTrackColor,
             [nameof(ISlider.MaximumTrackColor)] = MapMaximumTrackColor,
             [nameof(ISlider.ThumbColor)]        = MapThumbColor,
-            // TODO: ISlider.ThumbImageSource — Material 3's Slider draws
-            // its thumb as a fixed circle; supplying a custom drawable
-            // requires the lower-level Slider(state, ..., thumb = { ... })
-            // overload plus piping the resolved Painter through our
-            // ImageSourceLoader. Larger surgery than fits this PR.
+            [nameof(ISlider.ThumbImageSource)]  = MapThumbImageSource,
         };
 
     /// <summary>Command mapper (inherits view-level commands; no extras).</summary>
@@ -71,6 +82,14 @@ public partial class SliderHandler : ComposeElementHandler<ISlider>
     readonly MutableState<long?> _thumbColor        = new((long?)null);
     readonly MutableState<long?> _minTrackColor     = new((long?)null);
     readonly MutableState<long?> _maxTrackColor     = new((long?)null);
+    ImageSourceLoader?           _thumbLoader;
+
+    // Lazy — sliders without ThumbImageSource set never allocate the
+    // loader or its IImageSourcePart adapter.
+    ImageSourceLoader ThumbLoader =>
+        _thumbLoader ??= new ImageSourceLoader(
+            this,
+            () => VirtualView is ISlider s ? new SliderThumbImageSourcePart(s) : null);
 
     /// <summary>Construct a handler with the default mappers.</summary>
     public SliderHandler() : base(Mapper, CommandMapper) { }
@@ -91,6 +110,18 @@ public override ComposableNode BuildNode(IComposer composer)
         var minTrack   = _minTrackColor.Value;
         var maxTrack   = _maxTrackColor.Value;
 
+        // When the consumer set a ThumbImageSource and it resolved to
+        // either a packaged drawable id or a runtime-decoded
+        // BitmapPainter, drop into the hand-written thumb-slot path
+        // so the image actually paints in the thumb slot.
+        if (_thumbLoader is { } loader &&
+            (loader.Painter.Value is not null || loader.DrawableResourceId.Value is not null))
+        {
+            return new ImageThumbSlider(
+                this, virtualView, _value.Value, min, max, thumb, minTrack, maxTrack,
+                loader.DrawableResourceId.Value, loader.Painter.Value);
+        }
+
         var slider = new ComposeSlider(_value.Value, OnValueChanged);
 
         // Only allocate a Kotlin ClosedFloatingPointRange when the
@@ -111,6 +142,13 @@ public override ComposableNode BuildNode(IComposer composer)
         return slider;
     }
 
+    /// <inheritdoc/>
+    protected override void DisconnectHandler(ComposeView platformView)
+    {
+        _thumbLoader?.Reset();
+        base.DisconnectHandler(platformView);
+    }
+
     void OnValueChanged(float newValue)
     {
         // Update Compose state synchronously so the rendered position
@@ -148,4 +186,176 @@ public static void MapMaximumTrackColor(SliderHandler handler, ISlider slider) =
     /// <summary>Map <see cref="ISlider.ThumbColor"/> to <c>SliderColors.thumbColor</c>.</summary>
     public static void MapThumbColor(SliderHandler handler, ISlider slider) =>
         handler._thumbColor.Value = ColorMapping.ToPackedLong(slider.ThumbColor);
+
+    /// <summary>
+    /// Map <see cref="ISlider.ThumbImageSource"/> through the shared
+    /// <see cref="ImageSourceLoader"/>. When the loader resolves a
+    /// painter or drawable id, <see cref="BuildNode"/> swaps to the
+    /// hand-written <see cref="ImageThumbSlider"/> render path; while
+    /// the load is in flight (or the source is null) the default
+    /// <see cref="ComposeSlider"/> facade keeps drawing the Material
+    /// stock thumb circle.
+    /// </summary>
+    /// <remarks>
+    /// Declared <c>async void</c> deliberately — mirrors
+    /// <see cref="ImageHandler.MapSource"/>; see that mapper's remarks
+    /// for the fire-and-forget rationale.
+    /// </remarks>
+    public static async void MapThumbImageSource(SliderHandler handler, ISlider slider) =>
+        await handler.ThumbLoader.LoadAsync(slider.ThumbImageSource).ConfigureAwait(false);
+
+    /// <summary>
+    /// Adapter exposing the slider's <see cref="ISlider.ThumbImageSource"/>
+    /// to <see cref="ImageSourceLoader"/> as an
+    /// <see cref="IImageSourcePart"/>. <see cref="ISlider"/> itself
+    /// doesn't implement <see cref="IImageSourcePart"/> (only the
+    /// stand-alone <see cref="Microsoft.Maui.IImage"/> /
+    /// <see cref="IImageButton"/> virtual views do), so we wrap it.
+    /// </summary>
+    sealed class SliderThumbImageSourcePart : IImageSourcePart
+    {
+        readonly ISlider _slider;
+        public SliderThumbImageSourcePart(ISlider slider) => _slider = slider;
+
+        public IImageSource? Source           => _slider.ThumbImageSource;
+        public bool          IsAnimationPlaying => false;
+        public bool          IsLoading          => false;
+
+        public void UpdateIsLoading(bool isLoading) { /* no-op */ }
+    }
+
+    /// <summary>
+    /// Hand-written <see cref="ComposableNode"/> that drives the
+    /// <c>SliderKt.Slider(value, onValueChange, ..., thumb)</c>
+    /// overload directly so the thumb slot can render a caller-supplied
+    /// <see cref="ISlider.ThumbImageSource"/>. Lives here (not as a
+    /// generated facade) because no current <c>[ComposeFacade]</c>
+    /// shape models "swap the thumb slot with an
+    /// <see cref="ComposeImage"/> built from a runtime-resolved
+    /// painter or drawable resource id".
+    /// </summary>
+    sealed class ImageThumbSlider : ComposableNode
+    {
+        // SliderKt.Slider(value, onValueChange, modifier, enabled,
+        //                 onValueChangeFinished, colors, interactionSource,
+        //                 steps, thumb, track, valueRange,
+        //                 _composer, $changed, $changed1, $default)
+        // — $default mask bits 0..10, one per user param above (skipping
+        // _composer and the two $changed slots).
+        const int BitEnabled               = 1 << 3;
+        const int BitOnValueChangeFinished = 1 << 4;
+        const int BitColors                = 1 << 5;
+        const int BitInteractionSource     = 1 << 6;
+        const int BitSteps                 = 1 << 7;
+        const int BitTrack                 = 1 << 9;
+        const int BitValueRange            = 1 << 10;
+
+        // Compose's stock thumb is a 20-dp filled circle; sizing the
+        // image slightly bigger keeps the source bitmap visible without
+        // overflowing the slider's intrinsic height.
+        static readonly Modifier s_thumbSize = Modifier.Size(40);
+
+        readonly SliderHandler   _owner;
+        readonly ISlider         _virtualView;
+        readonly float           _value;
+        readonly float           _min;
+        readonly float           _max;
+        readonly long?           _thumbColor;
+        readonly long?           _minTrack;
+        readonly long?           _maxTrack;
+        readonly int?            _drawableId;
+        readonly ComposePainter? _painter;
+
+        public ImageThumbSlider(
+            SliderHandler   owner,
+            ISlider         virtualView,
+            float           value,
+            float           min,
+            float           max,
+            long?           thumbColor,
+            long?           minTrack,
+            long?           maxTrack,
+            int?            drawableId,
+            ComposePainter? painter)
+        {
+            _owner       = owner;
+            _virtualView = virtualView;
+            _value       = value;
+            _min         = min;
+            _max         = max;
+            _thumbColor  = thumbColor;
+            _minTrack    = minTrack;
+            _maxTrack    = maxTrack;
+            _drawableId  = drawableId;
+            _painter     = painter;
+        }
+
+        public override void Render(IComposer composer)
+        {
+            var onValueChange = new ComposableLambda1(boxed =>
+            {
+                var f = boxed as Java.Lang.Float
+                    ?? throw new InvalidCastException(
+                        $"Expected java.lang.Float in Slider.onValueChange; got '{boxed?.Class?.Name ?? "null"}'.");
+                _owner.OnValueChanged(f.FloatValue());
+            });
+
+            // Thumb slot — Painter wins over drawable id (matches
+            // ImageHandler / ImageButtonHandler), so a freshly-loaded
+            // BitmapPainter immediately replaces any stale fast-path
+            // resource id.
+            var thumbNode = _painter is { } p
+                ? new ComposeImage(p) { Modifier = s_thumbSize }
+                : _drawableId is int id
+                    ? new ComposeImage(id) { Modifier = s_thumbSize }
+                    : (ComposableNode)new Box { Modifier = s_thumbSize };
+            IFunction3 thumb = ComposableLambdas.Wrap3(
+                composer,
+                c => thumbNode.Render(c));
+
+            SliderColors? colors = null;
+            if (_thumbColor is not null || _minTrack is not null || _maxTrack is not null)
+                colors = composer.SliderColors(
+                    thumbColor:         _thumbColor,
+                    activeTrackColor:   _minTrack,
+                    inactiveTrackColor: _maxTrack);
+
+            IClosedFloatingPointRange? valueRange = null;
+            if (_min != 0f || _max != 1f)
+                valueRange = RangesKt.RangeTo(_min, _max);
+
+            var modifier = Modifier.FillMaxWidth()
+                .ApplyGestures(_virtualView, _owner.MauiContext)
+                .ApplySemantics(_virtualView);
+
+            // $default mask — set a bit for every slot we leave at its
+            // Kotlin default (null / 0 / stock theme). value, onValueChange,
+            // modifier and thumb are always supplied so their bits stay
+            // cleared. enabled is supplied explicitly so bit 3 clears.
+            int defaultMask =
+                BitOnValueChangeFinished |
+                BitInteractionSource |
+                BitSteps |
+                BitTrack;
+            if (colors is null)     defaultMask |= BitColors;
+            if (valueRange is null) defaultMask |= BitValueRange;
+
+            SliderKt.Slider(
+                value:                  _value,
+                onValueChange:          onValueChange,
+                modifier:               modifier.Build(),
+                enabled:                true,
+                onValueChangeFinished:  null,
+                colors:                 colors,
+                interactionSource:      null,
+                p7:                     0,
+                thumb:                  thumb,
+                track:                  null,
+                valueRange:             valueRange,
+                _composer:              composer,
+                steps:                  0,
+                _changed:               0,
+                _changed1:              defaultMask);
+        }
+    }
 }

From 02725dc527e41a6326bda4872019989759c09e0b Mon Sep 17 00:00:00 2001
From: Jonathan Peppers <jonathan.peppers@microsoft.com>
Date: Mon, 15 Jun 2026 18:17:27 -0500
Subject: [PATCH 3/6] Sharpen TODO reasons for unmapped handler keys
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Rewrites the inline TODOs for the three properties that genuinely
can't be wired without major new work, so a future contributor sees
the concrete blocker instead of a one-liner:

* ScrollViewHandler.{Horizontal,Vertical}ScrollBarVisibility —
  Compose Foundation 1.9 / 1.10 / 1.11 has no public Scrollbar API
  on Android (the androidx.compose.foundation.v2.scrollbar extension
  is desktop-only). Implementing the Default/Always/Never enum needs
  a hand-built ScrollState + animated overlay drawn into a sibling
  Box.

* ImageHandler.IsAnimationPlaying /
  ImageButtonHandler.IsAnimationPlaying — ImageSourceLoader
  rasterises the resolved Drawable into a Bitmap before wrapping as a
  BitmapPainter, so even AnimatedImageDrawable sources don't animate
  through our Compose path. Fixing it needs either a hand-rolled
  DrawablePainter JCW (forward DrawScope.onDraw -> Drawable.draw +
  gate start/stop on the slot) or routing source resolution through
  coil-compose.

No behaviour change.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Handlers/ImageButtonHandler.cs            | 15 ++++++++---
 .../Handlers/ImageHandler.cs                  | 25 +++++++++++++------
 .../Handlers/ScrollViewHandler.cs             | 19 +++++++++-----
 3 files changed, 42 insertions(+), 17 deletions(-)

diff --git a/src/Microsoft.AndroidX.Compose.Maui/Handlers/ImageButtonHandler.cs b/src/Microsoft.AndroidX.Compose.Maui/Handlers/ImageButtonHandler.cs
index 8c3849f6..5a2b969d 100644
--- a/src/Microsoft.AndroidX.Compose.Maui/Handlers/ImageButtonHandler.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui/Handlers/ImageButtonHandler.cs
@@ -53,9 +53,18 @@ public partial class ImageButtonHandler : ComposeElementHandler<MauiIImageButton
             [nameof(IButtonStroke.CornerRadius)]         = MapCornerRadius,
             [nameof(IPadding.Padding)]                   = MapPadding,
             // TODO: IImage.IsAnimationPlaying — same caveat as
-            // ImageHandler. Compose animates GIFs/WebPs only through
-            // coil-compose, which isn't wired into ImageSourceLoader.
-            // Leaving unmapped so the coverage report flags the gap.
+            // ImageHandler.MapSource. `ImageSourceLoader` rasterises
+            // the resolved `Drawable` to a static `Bitmap` before
+            // wrapping it as a `BitmapPainter`, so even when the
+            // underlying source is an `AnimatedImageDrawable` the
+            // snapshot in Compose's slot table doesn't animate.
+            // Honouring this property needs either a hand-rolled
+            // `DrawablePainter` JCW whose `DrawScope.onDraw` forwards
+            // into `Drawable.draw(Canvas)` (with `start()` / `stop()`
+            // gated on the slot), or routing source resolution
+            // through coil-compose's `AsyncImagePainter`. Leaving
+            // unmapped so the coverage report flags the gap rather
+            // than claiming a no-op wire.
         };
 
     /// <summary>Command mapper (inherits view-level commands; no extras).</summary>
diff --git a/src/Microsoft.AndroidX.Compose.Maui/Handlers/ImageHandler.cs b/src/Microsoft.AndroidX.Compose.Maui/Handlers/ImageHandler.cs
index e3e61871..c4c9718c 100644
--- a/src/Microsoft.AndroidX.Compose.Maui/Handlers/ImageHandler.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui/Handlers/ImageHandler.cs
@@ -53,14 +53,23 @@ public partial class ImageHandler : ComposeElementHandler<MauiIImage>
         {
             [nameof(IImageSourcePart.Source)] = MapSource,
             [nameof(MauiIImage.Aspect)]       = MapAspect,
-            // TODO: IImage.IsAnimationPlaying — Compose's Image composable
-            // animates GIFs/WebPs only when the painter wraps a Coil
-            // ImageRequest. ImageSourceLoader currently materialises a
-            // static BitmapPainter (or PainterResource for packaged
-            // drawables); routing through coil-compose is a separate
-            // dependency + handler rewrite. Leaving unmapped so the
-            // coverage report flags the gap rather than claiming a no-op
-            // wire.
+            // TODO: IImage.IsAnimationPlaying — Compose's `Image`
+            // composable takes a `Painter`, not an animated
+            // `Drawable`, and our `ImageSourceLoader` rasterises the
+            // resolved `Drawable` to a static `Bitmap` (via
+            // `DrawableKt.ToBitmap`) before wrapping it in a
+            // `BitmapPainter`. The Android-native `AnimatedImageDrawable`
+            // (API 28+) keeps animating, but the snapshot we hand to
+            // Compose doesn't — its first frame is what gets sampled.
+            // Honouring this property therefore needs either (a) a
+            // hand-rolled `DrawablePainter` JCW subclass of
+            // `androidx.compose.ui.graphics.painter.Painter` whose
+            // `DrawScope.onDraw` forwards into `Drawable.draw(Canvas)`
+            // and toggles `start()` / `stop()` based on the slot, or
+            // (b) routing source resolution through coil-compose's
+            // `AsyncImagePainter`. Both are larger surgery + a real
+            // new dependency. Leaving unmapped so the coverage report
+            // flags the gap rather than claiming a no-op wire.
         };
 
     /// <summary>Command mapper (inherits view-level commands; no extras).</summary>
diff --git a/src/Microsoft.AndroidX.Compose.Maui/Handlers/ScrollViewHandler.cs b/src/Microsoft.AndroidX.Compose.Maui/Handlers/ScrollViewHandler.cs
index 59445f61..6dd2d100 100644
--- a/src/Microsoft.AndroidX.Compose.Maui/Handlers/ScrollViewHandler.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui/Handlers/ScrollViewHandler.cs
@@ -35,12 +35,19 @@ public partial class ScrollViewHandler : ComposeElementHandler<IScrollView>
             [nameof(IScrollView.Orientation)] = MapOrientation,
             [nameof(IScrollView.Content)]     = MapContent,
             // TODO: IScrollView.HorizontalScrollBarVisibility /
-            // VerticalScrollBarVisibility — Compose's
-            // Modifier.verticalScroll / horizontalScroll API doesn't
-            // expose a scrollbar-visibility flag. Suppressing the
-            // overlay scrollbar requires a hand-built rememberScrollState
-            // + custom Scrollbar overlay; revisit when porting
-            // PullToRefresh-style scroll affordances.
+            // VerticalScrollBarVisibility — Compose Foundation 1.9 /
+            // 1.10 / 1.11 (and the Material3 layer on top) don't
+            // expose any public Scrollbar / scrollbar API on Android.
+            // The androidx.compose.foundation.v2.scrollbar extension
+            // exists only on the Multiplatform desktop target;
+            // Modifier.verticalScroll / horizontalScroll have no
+            // scrollbar-visibility flag at all. Wiring even the
+            // Default / Always / Never enum to a visible affordance
+            // therefore requires a hand-built ScrollState +
+            // animated overlay drawn into a sibling Box — meaningful
+            // surgery and a non-trivial new public surface. Leaving
+            // unmapped so the coverage report flags the gap rather
+            // than claiming a no-op wire.
         };
 
     /// <summary>Command mapper (inherits view-level commands; no extras).</summary>

From 3dbf470b9d9ca12211b4d3ba71d7a94a38705645 Mon Sep 17 00:00:00 2001
From: Jonathan Peppers <jonathan.peppers@microsoft.com>
Date: Tue, 16 Jun 2026 09:44:34 -0500
Subject: [PATCH 4/6] Extend Slider/PullToRefreshBox facades; refactor MAUI
 handlers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds two slots to the public facades that the MAUI handlers needed:

 * Slider.Thumb (rich SliderKt.Slider overload — was previously

   unbound through the facade).

 * PullToRefreshBox.Indicator (Phase 8 hybrid container with

   Scope = "Box").

Adds a new public PullToRefreshIndicator class that wraps

PullToRefreshDefaults.Instance.Indicator(...) — exposed so MAUI

(and any other consumer) can override the spinner without dropping

down to the binding.

Refactors RefreshViewHandler and SliderHandler to use the public

facades instead of hand-rolled ComposableNode subclasses calling

the bindings directly. Net effect: the MAUI handler code shrinks

and no longer relies on internal helpers like ComposableLambda0/1,

ComposableLambdas.Wrap*, or Modifier.Build().

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 docs/maui-coverage.md                         |   2 +-
 .../Handlers/RefreshViewHandler.cs            | 179 +++-------------
 .../Handlers/SliderHandler.cs                 | 195 +++---------------
 .../ComposeBridges.cs                         |  32 ++-
 .../ComposeDefaults.cs                        |  16 +-
 .../PublicAPI.Unshipped.txt                   |  49 +++--
 .../PullToRefreshBox.cs                       |  16 +-
 .../PullToRefreshIndicator.cs                 | 103 +++++++++
 src/Microsoft.AndroidX.Compose/Slider.cs      |  20 +-
 9 files changed, 252 insertions(+), 360 deletions(-)
 create mode 100644 src/Microsoft.AndroidX.Compose/PullToRefreshIndicator.cs

diff --git a/docs/maui-coverage.md b/docs/maui-coverage.md
index 68563bf3..b6ad5524 100644
--- a/docs/maui-coverage.md
+++ b/docs/maui-coverage.md
@@ -1,6 +1,6 @@
 # .NET MAUI ⇄ Microsoft.AndroidX.Compose.Maui backend coverage
 
-Generated by `scripts/maui-coverage.cs` on 2026-06-15 23:16 UTC.
+Generated by `scripts/maui-coverage.cs` on 2026-06-16 14:43 UTC.
 
 Pinned MAUI version: **10.0.20** (from `Directory.Build.targets`).
 
diff --git a/src/Microsoft.AndroidX.Compose.Maui/Handlers/RefreshViewHandler.cs b/src/Microsoft.AndroidX.Compose.Maui/Handlers/RefreshViewHandler.cs
index 272c8ff0..6c361259 100644
--- a/src/Microsoft.AndroidX.Compose.Maui/Handlers/RefreshViewHandler.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui/Handlers/RefreshViewHandler.cs
@@ -1,8 +1,6 @@
 using AndroidX.Compose;
-using AndroidX.Compose.Material3.PullToRefresh;
 using AndroidX.Compose.Runtime;
 using AndroidX.Compose.UI.Platform;
-using Kotlin.Jvm.Functions;
 using Microsoft.AndroidX.Compose.Maui.Platform;
 using Microsoft.Maui.Handlers;
 using ComposePullToRefreshBox = AndroidX.Compose.PullToRefreshBox;
@@ -42,14 +40,10 @@ namespace Microsoft.AndroidX.Compose.Maui.Handlers;
 /// nested Compose-backed views fold into the parent composition.</para>
 ///
 /// <para><see cref="IRefreshView.RefreshColor"/> maps to the spinner
-/// glyph color via <see cref="PullToRefreshDefaults"/>'s
-/// <c>Indicator(state, isRefreshing, modifier, containerColor, color,
-/// maxDistance, ...)</c> helper. When unset the spinner falls back to
-/// Material 3's default tint and we render the plain
-/// <see cref="ComposePullToRefreshBox"/> facade; when set we render
-/// directly through the bound <c>PullToRefreshKt.PullToRefreshBox</c>
-/// with a custom indicator <c>IFunction3</c> slot that supplies the
-/// packed color.</para>
+/// glyph color via the public
+/// <see cref="PullToRefreshIndicator"/> facade, which wraps
+/// <c>PullToRefreshDefaults.Instance.Indicator(...)</c>. When unset
+/// the spinner falls back to Material 3's default tint.</para>
 /// </remarks>
 public partial class RefreshViewHandler : ComposeElementHandler<IRefreshView>
 {
@@ -97,21 +91,18 @@ public override ComposableNode BuildNode(IComposer composer)
         var context = MauiContext
             ?? throw new InvalidOperationException("MauiContext not set on RefreshViewHandler.");
 
-        bool isEnabled = _isEnabled.Value;
+        bool isEnabled    = _isEnabled.Value;
+        bool isRefreshing = _isRefreshing.Value;
 
-        // When RefreshColor is set we drop into the
-        // PullToRefreshBox-with-custom-indicator path so the spinner
-        // glyph picks up the caller-supplied tint. The default path
-        // keeps using the existing facade, which lets Material 3's
-        // theme drive the indicator colors.
-        if (_refreshColor.Value is long packedColor)
-        {
-            return new ColoredIndicatorBox(
-                this, view, context, isEnabled, packedColor);
-        }
+        // Share one PullToRefreshState wrapper between the box and
+        // the optional Indicator override. The box's Render populates
+        // state.Jvm during the first composition; the indicator
+        // lambda runs inside that same Render afterwards, so it sees
+        // the populated handle.
+        var state = new PullToRefreshState();
 
         var box = new ComposePullToRefreshBox(
-            isRefreshing: _isRefreshing.Value,
+            isRefreshing: isRefreshing,
             onRefresh:    () =>
             {
                 // Mirror MAUI's stock Android RefreshView handler: only
@@ -132,7 +123,19 @@ public override ComposableNode BuildNode(IComposer composer)
                 if (!isEnabled) return;
                 _isRefreshing.Value = true;
                 view.IsRefreshing   = true;
-            });
+            },
+            state: state);
+
+        // RefreshColor → spinner glyph tint. null/non-SolidPaint
+        // falls through to Material 3's default; non-null swaps in
+        // the public PullToRefreshIndicator facade.
+        if (_refreshColor.Value is long packedColor)
+        {
+            box.Indicator = new PullToRefreshIndicator(state, isRefreshing)
+            {
+                Color = packedColor,
+            };
+        }
 
         // FillMaxSize so the gesture region matches MAUI's full-bleed
         // RefreshView semantics, plus ApplyViewProperties for Opacity /
@@ -171,10 +174,9 @@ public static void MapIsRefreshEnabled(RefreshViewHandler handler, IRefreshView
     /// <summary>
     /// Map <see cref="IRefreshView.RefreshColor"/> to the spinner
     /// glyph color. <c>null</c> (or a non-<see cref="SolidPaint"/>
-    /// brush) falls back to Material 3's default theme tint and the
-    /// handler renders the plain <see cref="ComposePullToRefreshBox"/>
-    /// facade; a non-null solid color switches us to the
-    /// custom-indicator render path.
+    /// brush) falls back to Material 3's default theme tint; a
+    /// non-null solid color swaps in a
+    /// <see cref="PullToRefreshIndicator"/> with the packed color.
     /// </summary>
     /// <remarks>
     /// <see cref="IRefreshView.RefreshColor"/> is a
@@ -185,127 +187,4 @@ public static void MapIsRefreshEnabled(RefreshViewHandler handler, IRefreshView
     /// </remarks>
     public static void MapRefreshColor(RefreshViewHandler handler, IRefreshView view) =>
         handler._refreshColor.Value = ColorMapping.ToPackedLong((view.RefreshColor as SolidPaint)?.Color);
-
-    /// <summary>
-    /// Hand-written <see cref="ComposableNode"/> that drives the
-    /// <c>PullToRefreshKt.PullToRefreshBox</c> binding directly so the
-    /// indicator slot can pipe a caller-supplied
-    /// <see cref="IRefreshView.RefreshColor"/> through to
-    /// <see cref="PullToRefreshDefaults.Instance"/>'s
-    /// <c>Indicator(...)</c> helper. Lives here (not as a generated
-    /// facade) because no current <c>[ComposeFacade]</c> shape models
-    /// "rebuild PullToRefreshBox with a custom indicator slot whose
-    /// only deviation from Material 3's default is the spinner color".
-    /// </summary>
-    sealed class ColoredIndicatorBox : ComposableNode
-    {
-        // PullToRefreshBox $default mask bits — order mirrors
-        // PullToRefreshBoxDefault in ComposeDefaults.cs.
-        const int BitContentAlignment = 1 << 4;
-
-        // PullToRefreshDefaults.Indicator $default mask bits — order
-        // matches the bound JNI signature
-        // (state, isRefreshing, modifier, containerColor, color,
-        // maxDistance). Bits 0/1 are always supplied; bit 4 is
-        // cleared when we pass our own color.
-        const int IndicatorBitModifier       = 1 << 2;
-        const int IndicatorBitContainerColor = 1 << 3;
-        const int IndicatorBitMaxDistance    = 1 << 5;
-
-        readonly RefreshViewHandler _owner;
-        readonly IRefreshView       _view;
-        readonly IMauiContext       _context;
-        readonly bool               _isEnabled;
-        readonly long               _packedColor;
-
-        public ColoredIndicatorBox(
-            RefreshViewHandler owner,
-            IRefreshView       view,
-            IMauiContext       context,
-            bool               isEnabled,
-            long               packedColor)
-        {
-            _owner       = owner;
-            _view        = view;
-            _context     = context;
-            _isEnabled   = isEnabled;
-            _packedColor = packedColor;
-        }
-
-        public override void Render(IComposer composer)
-        {
-            // Mirror RefreshViewHandler.BuildNode's IsRefreshEnabled
-            // gesture-swallow guard (see comments there).
-            var onRefresh = new ComposableLambda0(() =>
-            {
-                if (!_isEnabled) return;
-                _owner._isRefreshing.Value = true;
-                _view.IsRefreshing         = true;
-            });
-
-            // Remember the JVM PullToRefreshState. RememberPullToRefreshState
-            // is itself a @Composable that internally uses `remember`,
-            // so calling it directly during Render returns the same
-            // instance across recompositions (Kotlin slot-table identity).
-            // No outer `composer.Remember(...)` wrapper needed.
-            var state = PullToRefreshKt.RememberPullToRefreshState(composer, 0);
-
-            bool isRefreshing = _owner._isRefreshing.Value;
-
-            // Custom indicator slot — calls the bound
-            // PullToRefreshDefaults.Indicator(...) with our packed
-            // color.
-            IFunction3 indicator = ComposableLambdas.Wrap3(
-                composer,
-                c =>
-                {
-                    int indicatorMask =
-                        IndicatorBitModifier |
-                        IndicatorBitContainerColor |
-                        IndicatorBitMaxDistance;
-                    PullToRefreshDefaults.Instance.Indicator(
-                        state:           state,
-                        isRefreshing:    isRefreshing,
-                        modifier:        null,
-                        containerColor:  0L,
-                        color:           _packedColor,
-                        maxDistance:     0f,
-                        _composer:       c,
-                        p7:              indicatorMask,
-                        _changed:        0);
-                });
-
-            // Content lambda — same walk as the default path.
-            IFunction3 content = ComposableLambdas.Wrap3(
-                composer,
-                c =>
-                {
-                    if (_view.Content is { } child)
-                        ComposeWalker.Render(child, c, _context);
-                });
-
-            var modifier = Modifier.FillMaxSize()
-                .ApplyViewProperties(_view)
-                .ApplySemantics(_view);
-
-            // PullToRefreshBox $default mask. Bits we always pass —
-            // isRefreshing(0), onRefresh(1), modifier(2), state(3),
-            // indicator(5), content(6) — stay cleared. Bit 4
-            // (contentAlignment) is set so Kotlin uses its default
-            // (Alignment.TopCenter for the indicator placement).
-            int boxMask = BitContentAlignment;
-
-            PullToRefreshKt.PullToRefreshBox(
-                isRefreshing:     isRefreshing,
-                onRefresh:        onRefresh,
-                modifier:         modifier.Build(),
-                state:            state,
-                contentAlignment: null,
-                indicator:        indicator,
-                content:          content,
-                _composer:        composer,
-                p8:               boxMask,
-                _changed:         0);
-        }
-    }
 }
diff --git a/src/Microsoft.AndroidX.Compose.Maui/Handlers/SliderHandler.cs b/src/Microsoft.AndroidX.Compose.Maui/Handlers/SliderHandler.cs
index 7982d5cf..081aa8cc 100644
--- a/src/Microsoft.AndroidX.Compose.Maui/Handlers/SliderHandler.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui/Handlers/SliderHandler.cs
@@ -2,13 +2,11 @@
 using AndroidX.Compose.Material3;
 using AndroidX.Compose.Runtime;
 using AndroidX.Compose.UI.Platform;
-using Kotlin.Jvm.Functions;
 using Kotlin.Ranges;
 using Microsoft.AndroidX.Compose.Maui.Loaders;
 using Microsoft.AndroidX.Compose.Maui.Platform;
 using Microsoft.Maui.Handlers;
 using ComposeImage   = AndroidX.Compose.Image;
-using ComposePainter = AndroidX.Compose.UI.Graphics.Painter.Painter;
 using ComposeSlider  = AndroidX.Compose.Slider;
 
 namespace Microsoft.AndroidX.Compose.Maui.Handlers;
@@ -46,13 +44,11 @@ namespace Microsoft.AndroidX.Compose.Maui.Handlers;
 ///
 /// <para><see cref="ISlider.ThumbImageSource"/> is resolved through
 /// the shared <see cref="ImageSourceLoader"/> (the same helper that
-/// backs <see cref="ImageHandler"/>). When a thumb image is supplied
-/// the handler swaps to a hand-written
-/// <see cref="ComposableNode"/> that calls the lower-level
-/// <c>SliderKt.Slider(..., thumb = { ... })</c> overload directly with
-/// an <see cref="ComposeImage"/> thumb slot — Material 3's stock
-/// <c>Slider</c> draws its thumb as a fixed circle and has no public
-/// way to inject a custom drawable.</para>
+/// backs <see cref="ImageHandler"/>). When the loader resolves a
+/// painter (or drawable id) the handler assigns a
+/// <see cref="ComposeImage"/> to <see cref="ComposeSlider.Thumb"/>;
+/// while the load is in flight (or no source is set) the slider
+/// keeps its default Material 3 thumb circle.</para>
 /// </remarks>
 public partial class SliderHandler : ComposeElementHandler<ISlider>
 {
@@ -104,26 +100,26 @@ public override ComposableNode BuildNode(IComposer composer)
         var virtualView = VirtualView
             ?? throw new InvalidOperationException("VirtualView not set on SliderHandler.");
 
-        var min        = _min.Value;
-        var max        = _max.Value;
-        var thumb      = _thumbColor.Value;
-        var minTrack   = _minTrackColor.Value;
-        var maxTrack   = _maxTrackColor.Value;
+        var min      = _min.Value;
+        var max      = _max.Value;
+        var thumb    = _thumbColor.Value;
+        var minTrack = _minTrackColor.Value;
+        var maxTrack = _maxTrackColor.Value;
 
-        // When the consumer set a ThumbImageSource and it resolved to
-        // either a packaged drawable id or a runtime-decoded
-        // BitmapPainter, drop into the hand-written thumb-slot path
-        // so the image actually paints in the thumb slot.
-        if (_thumbLoader is { } loader &&
-            (loader.Painter.Value is not null || loader.DrawableResourceId.Value is not null))
+        var slider = new ComposeSlider(_value.Value, OnValueChanged);
+
+        // ThumbImageSource → ComposeImage in the Thumb slot. Painter
+        // wins over drawable id (matches ImageHandler), so a freshly
+        // loaded BitmapPainter immediately replaces any stale fast-path
+        // resource id.
+        if (_thumbLoader is { } loader)
         {
-            return new ImageThumbSlider(
-                this, virtualView, _value.Value, min, max, thumb, minTrack, maxTrack,
-                loader.DrawableResourceId.Value, loader.Painter.Value);
+            if (loader.Painter.Value is { } painter)
+                slider.Thumb = new ComposeImage(painter) { Modifier = s_thumbSize };
+            else if (loader.DrawableResourceId.Value is int drawableId)
+                slider.Thumb = new ComposeImage(drawableId) { Modifier = s_thumbSize };
         }
 
-        var slider = new ComposeSlider(_value.Value, OnValueChanged);
-
         // Only allocate a Kotlin ClosedFloatingPointRange when the
         // bounds aren't Compose's stock [0, 1] — RangeTo always
         // allocates so this is the cheapest skip.
@@ -142,6 +138,11 @@ public override ComposableNode BuildNode(IComposer composer)
         return slider;
     }
 
+    // Compose's stock thumb is a 20-dp filled circle; sizing the
+    // image slightly bigger keeps the source bitmap visible without
+    // overflowing the slider's intrinsic height.
+    static readonly Modifier s_thumbSize = Modifier.Size(40);
+
     /// <inheritdoc/>
     protected override void DisconnectHandler(ComposeView platformView)
     {
@@ -190,11 +191,10 @@ public static void MapThumbColor(SliderHandler handler, ISlider slider) =>
     /// <summary>
     /// Map <see cref="ISlider.ThumbImageSource"/> through the shared
     /// <see cref="ImageSourceLoader"/>. When the loader resolves a
-    /// painter or drawable id, <see cref="BuildNode"/> swaps to the
-    /// hand-written <see cref="ImageThumbSlider"/> render path; while
-    /// the load is in flight (or the source is null) the default
-    /// <see cref="ComposeSlider"/> facade keeps drawing the Material
-    /// stock thumb circle.
+    /// painter or drawable id, <see cref="BuildNode"/> assigns a
+    /// <see cref="ComposeImage"/> to <see cref="ComposeSlider.Thumb"/>;
+    /// while the load is in flight (or the source is null) the
+    /// default <see cref="ComposeSlider"/> thumb circle keeps drawing.
     /// </summary>
     /// <remarks>
     /// Declared <c>async void</c> deliberately — mirrors
@@ -223,139 +223,4 @@ sealed class SliderThumbImageSourcePart : IImageSourcePart
 
         public void UpdateIsLoading(bool isLoading) { /* no-op */ }
     }
-
-    /// <summary>
-    /// Hand-written <see cref="ComposableNode"/> that drives the
-    /// <c>SliderKt.Slider(value, onValueChange, ..., thumb)</c>
-    /// overload directly so the thumb slot can render a caller-supplied
-    /// <see cref="ISlider.ThumbImageSource"/>. Lives here (not as a
-    /// generated facade) because no current <c>[ComposeFacade]</c>
-    /// shape models "swap the thumb slot with an
-    /// <see cref="ComposeImage"/> built from a runtime-resolved
-    /// painter or drawable resource id".
-    /// </summary>
-    sealed class ImageThumbSlider : ComposableNode
-    {
-        // SliderKt.Slider(value, onValueChange, modifier, enabled,
-        //                 onValueChangeFinished, colors, interactionSource,
-        //                 steps, thumb, track, valueRange,
-        //                 _composer, $changed, $changed1, $default)
-        // — $default mask bits 0..10, one per user param above (skipping
-        // _composer and the two $changed slots).
-        const int BitEnabled               = 1 << 3;
-        const int BitOnValueChangeFinished = 1 << 4;
-        const int BitColors                = 1 << 5;
-        const int BitInteractionSource     = 1 << 6;
-        const int BitSteps                 = 1 << 7;
-        const int BitTrack                 = 1 << 9;
-        const int BitValueRange            = 1 << 10;
-
-        // Compose's stock thumb is a 20-dp filled circle; sizing the
-        // image slightly bigger keeps the source bitmap visible without
-        // overflowing the slider's intrinsic height.
-        static readonly Modifier s_thumbSize = Modifier.Size(40);
-
-        readonly SliderHandler   _owner;
-        readonly ISlider         _virtualView;
-        readonly float           _value;
-        readonly float           _min;
-        readonly float           _max;
-        readonly long?           _thumbColor;
-        readonly long?           _minTrack;
-        readonly long?           _maxTrack;
-        readonly int?            _drawableId;
-        readonly ComposePainter? _painter;
-
-        public ImageThumbSlider(
-            SliderHandler   owner,
-            ISlider         virtualView,
-            float           value,
-            float           min,
-            float           max,
-            long?           thumbColor,
-            long?           minTrack,
-            long?           maxTrack,
-            int?            drawableId,
-            ComposePainter? painter)
-        {
-            _owner       = owner;
-            _virtualView = virtualView;
-            _value       = value;
-            _min         = min;
-            _max         = max;
-            _thumbColor  = thumbColor;
-            _minTrack    = minTrack;
-            _maxTrack    = maxTrack;
-            _drawableId  = drawableId;
-            _painter     = painter;
-        }
-
-        public override void Render(IComposer composer)
-        {
-            var onValueChange = new ComposableLambda1(boxed =>
-            {
-                var f = boxed as Java.Lang.Float
-                    ?? throw new InvalidCastException(
-                        $"Expected java.lang.Float in Slider.onValueChange; got '{boxed?.Class?.Name ?? "null"}'.");
-                _owner.OnValueChanged(f.FloatValue());
-            });
-
-            // Thumb slot — Painter wins over drawable id (matches
-            // ImageHandler / ImageButtonHandler), so a freshly-loaded
-            // BitmapPainter immediately replaces any stale fast-path
-            // resource id.
-            var thumbNode = _painter is { } p
-                ? new ComposeImage(p) { Modifier = s_thumbSize }
-                : _drawableId is int id
-                    ? new ComposeImage(id) { Modifier = s_thumbSize }
-                    : (ComposableNode)new Box { Modifier = s_thumbSize };
-            IFunction3 thumb = ComposableLambdas.Wrap3(
-                composer,
-                c => thumbNode.Render(c));
-
-            SliderColors? colors = null;
-            if (_thumbColor is not null || _minTrack is not null || _maxTrack is not null)
-                colors = composer.SliderColors(
-                    thumbColor:         _thumbColor,
-                    activeTrackColor:   _minTrack,
-                    inactiveTrackColor: _maxTrack);
-
-            IClosedFloatingPointRange? valueRange = null;
-            if (_min != 0f || _max != 1f)
-                valueRange = RangesKt.RangeTo(_min, _max);
-
-            var modifier = Modifier.FillMaxWidth()
-                .ApplyGestures(_virtualView, _owner.MauiContext)
-                .ApplySemantics(_virtualView);
-
-            // $default mask — set a bit for every slot we leave at its
-            // Kotlin default (null / 0 / stock theme). value, onValueChange,
-            // modifier and thumb are always supplied so their bits stay
-            // cleared. enabled is supplied explicitly so bit 3 clears.
-            int defaultMask =
-                BitOnValueChangeFinished |
-                BitInteractionSource |
-                BitSteps |
-                BitTrack;
-            if (colors is null)     defaultMask |= BitColors;
-            if (valueRange is null) defaultMask |= BitValueRange;
-
-            SliderKt.Slider(
-                value:                  _value,
-                onValueChange:          onValueChange,
-                modifier:               modifier.Build(),
-                enabled:                true,
-                onValueChangeFinished:  null,
-                colors:                 colors,
-                interactionSource:      null,
-                p7:                     0,
-                thumb:                  thumb,
-                track:                  null,
-                valueRange:             valueRange,
-                _composer:              composer,
-                steps:                  0,
-                _changed:               0,
-                _changed1:              defaultMask);
-        }
-    }
 }
diff --git a/src/Microsoft.AndroidX.Compose/ComposeBridges.cs b/src/Microsoft.AndroidX.Compose/ComposeBridges.cs
index 55fa838c..6c3ff0c1 100644
--- a/src/Microsoft.AndroidX.Compose/ComposeBridges.cs
+++ b/src/Microsoft.AndroidX.Compose/ComposeBridges.cs
@@ -1360,7 +1360,7 @@ public static IntPtr RememberSheetState(
                     "Landroidx/compose/ui/Alignment;Lkotlin/jvm/functions/Function3;" +
                     "Lkotlin/jvm/functions/Function3;Landroidx/compose/runtime/Composer;II)V",
         Defaults  = typeof(PullToRefreshBoxDefault))]
-    [ComposeFacade]
+    [ComposeFacade(Scope = "Box")]
     public static partial void PullToRefreshBox(
         bool        isRefreshing,
         IFunction0  onRefresh,
@@ -1368,6 +1368,7 @@ public static partial void PullToRefreshBox(
                      StateType = typeof(PullToRefreshState))]
         IntPtr      state,
         IModifier?  modifier,
+        IFunction3? indicator,
         IFunction3  content,
         int         defaults,
         IComposer   composer);
@@ -3750,6 +3751,8 @@ public static partial void Slider(
         [Callback(typeof(float))]
         IFunction1                  onValueChange,
         IModifier?                  modifier,
+        [Slot("Thumb")]
+        IFunction3?                 thumb,
         IClosedFloatingPointRange?  valueRange,
         SliderColors?               colors,
         bool                        enabled  = true,
@@ -3757,25 +3760,34 @@ public static partial void Slider(
         int                         defaults = 0,
         IComposer                   composer = null!);
 
-    // Slot rename pattern: C# `p5` is the real Kotlin `steps` Int; C# named
-    // `steps:` is the JVM `$changed` recomposition int; `_changed` is `$default`.
-    // Cross-check with RangeSlider above, which uses the same SliderKt
-    // overload (both pass `steps: 0` for $changed and route the user-facing
-    // steps through `p5:`).
-    public static partial void Slider(float value, IFunction1 onValueChange, IModifier? modifier, IClosedFloatingPointRange? valueRange, SliderColors? colors, bool enabled, int steps, int defaults, IComposer composer)
+    // Wrapper-passthrough that calls the rich (Float, ..., thumb, track,
+    // valueRange) overload of SliderKt.Slider directly. The 11-user-param
+    // shape lets the facade expose a `Thumb` slot. We never supply
+    // `track:` — Kotlin's default is a stock track lambda — so bit 9
+    // (`track`) is force-OR'd into the $default mask before forwarding.
+    //
+    // Slot rename pattern (matches RangeSlider above):
+    //   C# `p7` = real Kotlin `steps` Int
+    //   C# `steps:` (after `_composer`) = JVM `$changed` int
+    //   C# `_changed` = JVM `$changed1`
+    //   C# `_changed1` = JVM `$default` ← the bitmask we forward
+    public static partial void Slider(float value, IFunction1 onValueChange, IModifier? modifier, IFunction3? thumb, IClosedFloatingPointRange? valueRange, SliderColors? colors, bool enabled, int steps, int defaults, IComposer composer)
         => SliderKt.Slider(
             value:                  value,
             onValueChange:          onValueChange,
             modifier:               modifier,
             enabled:                enabled,
-            valueRange:             valueRange,
-            p5:                     steps,
             onValueChangeFinished:  null,
             colors:                 colors,
             interactionSource:      null,
+            p7:                     steps,
+            thumb:                  thumb,
+            track:                  null,
+            valueRange:             valueRange,
             _composer:              composer,
             steps:                  0,
-            _changed:               defaults);
+            _changed:               0,
+            _changed1:              defaults | (int)SliderDefault.Track);
 
     // FlowRow / FlowColumn — Phase 8 wrapper-passthrough facades. The
     // simpler 7-Kotlin-param overloads (no FlowRowOverflow / FlowColumnOverflow
diff --git a/src/Microsoft.AndroidX.Compose/ComposeDefaults.cs b/src/Microsoft.AndroidX.Compose/ComposeDefaults.cs
index c78932df..1730f701 100644
--- a/src/Microsoft.AndroidX.Compose/ComposeDefaults.cs
+++ b/src/Microsoft.AndroidX.Compose/ComposeDefaults.cs
@@ -881,14 +881,16 @@
     "disabledActiveTickColor", "disabledInactiveTrackColor",
     "disabledInactiveTickColor")]
 
-// androidx.compose.material3.SliderKt.Slider (simple float overload):
-// 9 user params; bits 0 (value) and 1 (onValueChange) always provided.
-// The longer overload with Function3 thumb/track slots has non-null
-// Kotlin defaults that can't be safely substituted, so we lock in this
-// simpler shape via the declarative form.
+// androidx.compose.material3.SliderKt.Slider (rich float overload with
+// thumb / track slots): 11 user params. Bits 0 (value) and 1
+// (onValueChange) always provided; bit 9 (track) is forced set
+// because Kotlin's default for that slot is a non-null lambda
+// (`SliderDefaults.Track(...)`) we cannot substitute with `null`
+// without an NPE. The simpler 9-param overload is no longer used —
+// this rich shape is required so the facade can expose a `Thumb` slot.
 [assembly: ComposeDefaults("SliderDefault",
-    "!value", "!onValueChange", "modifier", "enabled", "valueRange",
-    "steps", "onValueChangeFinished", "colors", "interactionSource")]
+    "!value", "!onValueChange", "modifier", "enabled", "onValueChangeFinished",
+    "colors", "interactionSource", "steps", "thumb", "track", "valueRange")]
 
 // androidx.compose.material3.SliderKt.RangeSlider (simple
 // ClosedFloatingPointRange overload): 8 user params; bits 0 (value)
diff --git a/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt b/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt
index 4e5cd21d..47cc151a 100644
--- a/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt
+++ b/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt
@@ -174,8 +174,8 @@ AndroidX.Compose.Color.WithAlpha(byte alpha) -> AndroidX.Compose.Color
 AndroidX.Compose.Color.WithOpacity(float opacity) -> AndroidX.Compose.Color
 AndroidX.Compose.Column
 AndroidX.Compose.Column.Column() -> void
-AndroidX.Compose.Column.Column(AndroidX.Compose.Arrangement? verticalArrangement) -> void
 AndroidX.Compose.Column.Column(AndroidX.Compose.Arrangement? verticalArrangement, AndroidX.Compose.Alignment.Horizontal? horizontalAlignment) -> void
+AndroidX.Compose.Column.Column(AndroidX.Compose.Arrangement? verticalArrangement) -> void
 AndroidX.Compose.ComposableContainer
 AndroidX.Compose.ComposableContainer.Add(AndroidX.Compose.ComposableNode? child) -> void
 AndroidX.Compose.ComposableContainer.Add(AndroidX.Compose.Modifier! modifier) -> void
@@ -220,10 +220,10 @@ AndroidX.Compose.DatePickerState.DatePickerState() -> void
 AndroidX.Compose.DatePickerState.DatePickerState(long? initialSelectedDateMillis = null, Kotlin.Ranges.IntRange? initialYearRange = null, AndroidX.Compose.Material3.ISelectableDates? initialSelectableDates = null) -> void
 AndroidX.Compose.DatePickerState.DisplayedMonthMillis.get -> long
 AndroidX.Compose.DatePickerState.DisplayedMonthMillis.set -> void
-AndroidX.Compose.DatePickerState.InitialDisplayMode.get -> int?
-AndroidX.Compose.DatePickerState.InitialDisplayMode.set -> void
 AndroidX.Compose.DatePickerState.InitialDisplayedMonthMillis.get -> Java.Lang.Long?
 AndroidX.Compose.DatePickerState.InitialDisplayedMonthMillis.set -> void
+AndroidX.Compose.DatePickerState.InitialDisplayMode.get -> int?
+AndroidX.Compose.DatePickerState.InitialDisplayMode.set -> void
 AndroidX.Compose.DatePickerState.InitialSelectableDates.get -> AndroidX.Compose.Material3.ISelectableDates?
 AndroidX.Compose.DatePickerState.InitialSelectableDates.set -> void
 AndroidX.Compose.DatePickerState.InitialSelectedDateMillis.get -> Java.Lang.Long?
@@ -232,18 +232,6 @@ AndroidX.Compose.DatePickerState.InitialYearRange.get -> Kotlin.Ranges.IntRange?
 AndroidX.Compose.DatePickerState.InitialYearRange.set -> void
 AndroidX.Compose.DatePickerState.SelectedDateMillis.get -> long?
 AndroidX.Compose.DatePickerState.SelectedDateMillis.set -> void
-AndroidX.Compose.DateRangeSelectableDates
-AndroidX.Compose.DateRangeSelectableDates.DateRangeSelectableDates() -> void
-AndroidX.Compose.DateRangeSelectableDates.IsSelectableDate(long utcTimeMillis) -> bool
-AndroidX.Compose.DateRangeSelectableDates.IsSelectableYear(int year) -> bool
-AndroidX.Compose.DateRangeSelectableDates.MaxUtcMillis.get -> long?
-AndroidX.Compose.DateRangeSelectableDates.MaxUtcMillis.set -> void
-AndroidX.Compose.DateRangeSelectableDates.MaxYear.get -> int?
-AndroidX.Compose.DateRangeSelectableDates.MaxYear.set -> void
-AndroidX.Compose.DateRangeSelectableDates.MinUtcMillis.get -> long?
-AndroidX.Compose.DateRangeSelectableDates.MinUtcMillis.set -> void
-AndroidX.Compose.DateRangeSelectableDates.MinYear.get -> int?
-AndroidX.Compose.DateRangeSelectableDates.MinYear.set -> void
 AndroidX.Compose.DateRangePicker
 AndroidX.Compose.DateRangePicker.DateRangePicker(AndroidX.Compose.DateRangePickerState? state = null) -> void
 AndroidX.Compose.DateRangePickerDialog
@@ -263,6 +251,18 @@ AndroidX.Compose.DateRangePickerState.SelectedEndDateMillis.set -> void
 AndroidX.Compose.DateRangePickerState.SelectedStartDateMillis.get -> long?
 AndroidX.Compose.DateRangePickerState.SelectedStartDateMillis.set -> void
 AndroidX.Compose.DateRangePickerState.SetSelection(long? startDateMillis, long? endDateMillis) -> void
+AndroidX.Compose.DateRangeSelectableDates
+AndroidX.Compose.DateRangeSelectableDates.DateRangeSelectableDates() -> void
+AndroidX.Compose.DateRangeSelectableDates.IsSelectableDate(long utcTimeMillis) -> bool
+AndroidX.Compose.DateRangeSelectableDates.IsSelectableYear(int year) -> bool
+AndroidX.Compose.DateRangeSelectableDates.MaxUtcMillis.get -> long?
+AndroidX.Compose.DateRangeSelectableDates.MaxUtcMillis.set -> void
+AndroidX.Compose.DateRangeSelectableDates.MaxYear.get -> int?
+AndroidX.Compose.DateRangeSelectableDates.MaxYear.set -> void
+AndroidX.Compose.DateRangeSelectableDates.MinUtcMillis.get -> long?
+AndroidX.Compose.DateRangeSelectableDates.MinUtcMillis.set -> void
+AndroidX.Compose.DateRangeSelectableDates.MinYear.get -> int?
+AndroidX.Compose.DateRangeSelectableDates.MinYear.set -> void
 AndroidX.Compose.DerivedState<T>
 AndroidX.Compose.DerivedState<T>.Value.get -> T
 AndroidX.Compose.DisableSelection
@@ -544,6 +544,7 @@ AndroidX.Compose.Image.Image(AndroidX.Compose.UI.Graphics.Painter.Painter! paint
 AndroidX.Compose.Image.Image(AndroidX.Compose.UI.Graphics.Painter.Painter! painter) -> void
 AndroidX.Compose.Image.Image(int drawableResourceId, string? contentDescription) -> void
 AndroidX.Compose.Image.Image(int drawableResourceId) -> void
+AndroidX.Compose.ImeAction
 AndroidX.Compose.InputChip
 AndroidX.Compose.InputChip.Avatar.get -> AndroidX.Compose.ComposableNode?
 AndroidX.Compose.InputChip.Avatar.set -> void
@@ -559,9 +560,8 @@ AndroidX.Compose.InputChip.TrailingIcon.set -> void
 AndroidX.Compose.IState<T>
 AndroidX.Compose.IState<T>.Value.get -> T
 AndroidX.Compose.IStateFlow<T>
-AndroidX.Compose.ImeAction
-AndroidX.Compose.KeyboardOptionsCompanion
 AndroidX.Compose.KeyboardActionsHelper
+AndroidX.Compose.KeyboardOptionsCompanion
 AndroidX.Compose.KeyboardType
 AndroidX.Compose.LargeFlexibleTopAppBar
 AndroidX.Compose.LargeFlexibleTopAppBar.Actions.get -> AndroidX.Compose.ComposableNode?
@@ -971,7 +971,17 @@ AndroidX.Compose.PrimaryTabRow
 AndroidX.Compose.PrimaryTabRow.PrimaryTabRow(int selectedTabIndex) -> void
 AndroidX.Compose.ProvidedValue
 AndroidX.Compose.PullToRefreshBox
+AndroidX.Compose.PullToRefreshBox.Indicator.get -> AndroidX.Compose.ComposableNode?
+AndroidX.Compose.PullToRefreshBox.Indicator.set -> void
 AndroidX.Compose.PullToRefreshBox.PullToRefreshBox(bool isRefreshing, System.Action! onRefresh, AndroidX.Compose.PullToRefreshState? state = null) -> void
+AndroidX.Compose.PullToRefreshIndicator
+AndroidX.Compose.PullToRefreshIndicator.Color.get -> long
+AndroidX.Compose.PullToRefreshIndicator.Color.set -> void
+AndroidX.Compose.PullToRefreshIndicator.ContainerColor.get -> long
+AndroidX.Compose.PullToRefreshIndicator.ContainerColor.set -> void
+AndroidX.Compose.PullToRefreshIndicator.MaxDistance.get -> AndroidX.Compose.Dp?
+AndroidX.Compose.PullToRefreshIndicator.MaxDistance.set -> void
+AndroidX.Compose.PullToRefreshIndicator.PullToRefreshIndicator(AndroidX.Compose.PullToRefreshState! state, bool isRefreshing) -> void
 AndroidX.Compose.PullToRefreshState
 AndroidX.Compose.PullToRefreshState.DistanceFraction.get -> float
 AndroidX.Compose.PullToRefreshState.IsAnimating.get -> bool
@@ -1115,6 +1125,8 @@ AndroidX.Compose.Slider
 AndroidX.Compose.Slider.Colors.get -> AndroidX.Compose.Material3.SliderColors?
 AndroidX.Compose.Slider.Colors.set -> void
 AndroidX.Compose.Slider.Slider(float value, System.Action<float>! onValueChange, bool enabled = true, int steps = 0) -> void
+AndroidX.Compose.Slider.Thumb.get -> AndroidX.Compose.ComposableNode?
+AndroidX.Compose.Slider.Thumb.set -> void
 AndroidX.Compose.Slider.ValueRange.get -> Kotlin.Ranges.IClosedFloatingPointRange?
 AndroidX.Compose.Slider.ValueRange.set -> void
 AndroidX.Compose.SmallFloatingActionButton
@@ -1489,6 +1501,7 @@ override AndroidX.Compose.PermanentNavigationDrawer.Render(AndroidX.Compose.Runt
 override AndroidX.Compose.PrimaryScrollableTabRow.Render(AndroidX.Compose.Runtime.IComposer! composer) -> void
 override AndroidX.Compose.PrimaryTabRow.Render(AndroidX.Compose.Runtime.IComposer! composer) -> void
 override AndroidX.Compose.PullToRefreshBox.Render(AndroidX.Compose.Runtime.IComposer! composer) -> void
+override AndroidX.Compose.PullToRefreshIndicator.Render(AndroidX.Compose.Runtime.IComposer! composer) -> void
 override AndroidX.Compose.RadioButton.Render(AndroidX.Compose.Runtime.IComposer! composer) -> void
 override AndroidX.Compose.RangeSlider.Render(AndroidX.Compose.Runtime.IComposer! composer) -> void
 override AndroidX.Compose.Row.Render(AndroidX.Compose.Runtime.IComposer! composer) -> void
@@ -2009,9 +2022,9 @@ static AndroidX.Compose.ImeAction.Previous.get -> int
 static AndroidX.Compose.ImeAction.Search.get -> int
 static AndroidX.Compose.ImeAction.Send.get -> int
 static AndroidX.Compose.ImeAction.Unspecified.get -> int
+static AndroidX.Compose.KeyboardActionsHelper.Create(System.Action? onDone = null, System.Action? onGo = null, System.Action? onNext = null, System.Action? onPrevious = null, System.Action? onSearch = null, System.Action? onSend = null) -> AndroidX.Compose.Foundation.Text.KeyboardActions!
 static AndroidX.Compose.KeyboardOptionsCompanion.Default.get -> AndroidX.Compose.Foundation.Text.KeyboardOptions!
 static AndroidX.Compose.KeyboardOptionsCompanion.Get() -> AndroidX.Compose.Foundation.Text.KeyboardOptions.Companion!
-static AndroidX.Compose.KeyboardActionsHelper.Create(System.Action? onDone = null, System.Action? onGo = null, System.Action? onNext = null, System.Action? onPrevious = null, System.Action? onSearch = null, System.Action? onSend = null) -> AndroidX.Compose.Foundation.Text.KeyboardActions!
 static AndroidX.Compose.KeyboardType.Ascii.get -> int
 static AndroidX.Compose.KeyboardType.Decimal.get -> int
 static AndroidX.Compose.KeyboardType.Email.get -> int
diff --git a/src/Microsoft.AndroidX.Compose/PullToRefreshBox.cs b/src/Microsoft.AndroidX.Compose/PullToRefreshBox.cs
index 62c6c04b..9eba17c4 100644
--- a/src/Microsoft.AndroidX.Compose/PullToRefreshBox.cs
+++ b/src/Microsoft.AndroidX.Compose/PullToRefreshBox.cs
@@ -12,11 +12,15 @@ namespace AndroidX.Compose;
 /// observe pull progress (<see cref="PullToRefreshState.DistanceFraction"/> /
 /// <see cref="PullToRefreshState.IsAnimating"/>) for a custom indicator
 /// or analytics; omit it and Compose creates one internally via
-/// <c>rememberPullToRefreshState()</c>. The stock Material 3 spinner is
-/// always used — indicator customization is not yet exposed (the
-/// underlying container + optional <c>Function3</c> slot is the same
-/// hybrid shape the facade generator can't model for <c>BottomAppBar</c>;
-/// see <c>.github/copilot-instructions.md</c>).
+/// <c>rememberPullToRefreshState()</c>. Override the indicator by
+/// assigning <see cref="Indicator"/> — typically a
+/// <see cref="PullToRefreshIndicator"/> bound to the same
+/// <see cref="PullToRefreshState"/> — to recolor the stock spinner
+/// or supply a fully custom one. <see cref="Indicator"/> left
+/// <c>null</c> uses Material 3's default.
+///
+/// The body lambda runs inside Material's <c>Box</c> scope, so children
+/// can use <c>Modifier.Align(...)</c> / <c>Modifier.MatchParentSize()</c>.
 ///
 /// <code>
 /// var refreshing = Remember(() =&gt; new MutableState&lt;bool&gt;(false));
@@ -61,4 +65,4 @@ namespace AndroidX.Compose;
 /// }
 /// </code>
 /// </remarks>
-public sealed partial class PullToRefreshBox;
+public sealed partial class PullToRefreshBox { }
diff --git a/src/Microsoft.AndroidX.Compose/PullToRefreshIndicator.cs b/src/Microsoft.AndroidX.Compose/PullToRefreshIndicator.cs
new file mode 100644
index 00000000..9591ad63
--- /dev/null
+++ b/src/Microsoft.AndroidX.Compose/PullToRefreshIndicator.cs
@@ -0,0 +1,103 @@
+using AndroidX.Compose.Material3.PullToRefresh;
+using AndroidX.Compose.Runtime;
+
+namespace AndroidX.Compose;
+
+/// <summary>
+/// Material 3 pull-to-refresh indicator (the spinning arrow / progress
+/// glyph that appears as the user drags), exposed as a
+/// <see cref="ComposableNode"/> so it can be plugged into
+/// <see cref="PullToRefreshBox.Indicator"/>.
+/// </summary>
+/// <remarks>
+/// <para>Wraps the bound
+/// <see cref="PullToRefreshDefaults"/>.<c>Instance.Indicator(...)</c>
+/// helper. The indicator must share its <see cref="PullToRefreshState"/>
+/// with the parent <see cref="PullToRefreshBox"/> — pass the same
+/// wrapper instance to both, like:</para>
+/// <code>
+/// var state = new PullToRefreshState();
+/// new PullToRefreshBox(isRefreshing, onRefresh, state: state)
+/// {
+///     Indicator = new PullToRefreshIndicator(state, isRefreshing) { Color = 0xFFFF0000L },
+/// };
+/// </code>
+/// <para>Material 3's stock indicator picks up colors from the active
+/// <c>ColorScheme</c>; supply <see cref="ContainerColor"/> /
+/// <see cref="Color"/> only to override one (or both) of those slots.
+/// Any color left at <c>0L</c> falls through to the theme default.</para>
+/// </remarks>
+public sealed class PullToRefreshIndicator : ComposableNode
+{
+    // PullToRefreshDefaults.Indicator $default mask bits — order
+    // matches the bound JNI signature
+    // (state, isRefreshing, modifier, containerColor, color, maxDistance).
+    // Bits 0/1 are always supplied (state, isRefreshing).
+    const int BitModifier       = 1 << 2;
+    const int BitContainerColor = 1 << 3;
+    const int BitColor          = 1 << 4;
+    const int BitMaxDistance    = 1 << 5;
+
+    readonly PullToRefreshState _state;
+    readonly bool               _isRefreshing;
+
+    /// <summary>
+    /// Construct an indicator bound to <paramref name="state"/> (which
+    /// must be the same instance handed to the parent
+    /// <see cref="PullToRefreshBox"/>) and tracking
+    /// <paramref name="isRefreshing"/>.
+    /// </summary>
+    public PullToRefreshIndicator(PullToRefreshState state, bool isRefreshing)
+    {
+        ArgumentNullException.ThrowIfNull(state);
+        _state        = state;
+        _isRefreshing = isRefreshing;
+    }
+
+    /// <summary>
+    /// ARGB-packed background color (Compose <c>Color</c> long packing).
+    /// <c>0L</c> falls through to <c>ColorScheme.surfaceContainerHighest</c>.
+    /// </summary>
+    public long ContainerColor { get; set; }
+
+    /// <summary>
+    /// ARGB-packed glyph color (Compose <c>Color</c> long packing).
+    /// <c>0L</c> falls through to <c>ColorScheme.onSurfaceVariant</c>.
+    /// </summary>
+    public long Color { get; set; }
+
+    /// <summary>
+    /// Optional drag-distance threshold in dp. <c>null</c> falls through
+    /// to Material's default (<c>80.dp</c>). Increase for sliders /
+    /// dense lists where the gesture region competes with content.
+    /// </summary>
+    public Dp? MaxDistance { get; set; }
+
+    /// <inheritdoc/>
+    public override void Render(IComposer composer)
+    {
+        var jvm = _state.Jvm
+            ?? throw new InvalidOperationException(
+                "PullToRefreshIndicator's state is not bound. " +
+                "Pass the same PullToRefreshState wrapper to PullToRefreshBox " +
+                "(it populates state.Jvm during the box's first render).");
+
+        int mask = 0;
+        var modifier = BuildModifier();
+        if (modifier is null)         mask |= BitModifier;
+        if (ContainerColor == 0L)     mask |= BitContainerColor;
+        if (Color          == 0L)     mask |= BitColor;
+        if (MaxDistance    is null)   mask |= BitMaxDistance;
+
+        PullToRefreshDefaults.Instance.Indicator(
+            state:          jvm,
+            isRefreshing:   _isRefreshing,
+            modifier:       modifier,
+            containerColor: ContainerColor,
+            color:          Color,
+            maxDistance:    MaxDistance?.Value ?? 0f,
+            _composer:      composer,
+            p7:             mask,
+            _changed:       0);
+    }
+}
diff --git a/src/Microsoft.AndroidX.Compose/Slider.cs b/src/Microsoft.AndroidX.Compose/Slider.cs
index cec3a3a5..00b32e3a 100644
--- a/src/Microsoft.AndroidX.Compose/Slider.cs
+++ b/src/Microsoft.AndroidX.Compose/Slider.cs
@@ -5,9 +5,9 @@ namespace AndroidX.Compose;
 /// <code>
 /// new Slider(value: pos.Value, onValueChange: v => pos.Value = v)
 /// </code>
-/// Calls the simple <c>(Float, (Float) -&gt; Unit)</c> overload — the
-/// richer overloads (with custom <c>thumb</c> / <c>track</c> slots, or
-/// a <c>SliderState</c> first param) aren't exposed in this facade.
+/// Calls the rich <c>(Float, (Float) -&gt; Unit, …, thumb)</c> overload —
+/// custom <c>track</c> slot and the <c>SliderState</c>-first overload
+/// aren't exposed.
 ///
 /// Optional <c>ValueRange</c> property surfaces Kotlin's
 /// <c>ClosedFloatingPointRange&lt;Float&gt;</c> — build with
@@ -16,5 +16,19 @@ namespace AndroidX.Compose;
 /// <see cref="AndroidX.Compose.Material3.SliderColors"/>; build via
 /// <c>composer.SliderColors(...)</c> to override individual color slots
 /// without restating the full theme.
+///
+/// Optional <c>Thumb</c> property replaces the stock 20-dp filled
+/// circle with any <see cref="ComposableNode"/>:
+/// <code>
+/// new Slider(value: pos.Value, onValueChange: v => pos.Value = v)
+/// {
+///     Thumb = new Image(Resource.Drawable.dotnet_bot) { Modifier = Modifier.Size(40) },
+/// }
+/// </code>
+/// The slot's Kotlin signature is <c>@Composable (SliderState) -&gt; Unit</c>;
+/// the C# property ignores the <c>SliderState</c> arg, so a thumb that
+/// reacts to drag / focus state isn't expressible from this facade — drop
+/// to the binding directly with a hand-written
+/// <see cref="ComposableNode"/> when needed.
 /// </summary>
 public sealed partial class Slider;

From 7b6a5f40b7213ce5a727cc848181de24af307c8a Mon Sep 17 00:00:00 2001
From: Jonathan Peppers <jonathan.peppers@microsoft.com>
Date: Tue, 16 Jun 2026 09:55:17 -0500
Subject: [PATCH 5/6] Regenerate maui-coverage.md after merging main

The 4 PRs merged from main (NavigationPageHandler, CollectionViewHandler,
RadioButton stroke, VerticalTextAlignment) brought in new handlers and
mapper keys; refresh the report so the totals match HEAD.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 docs/maui-coverage.md | 155 +++++++++++++++++-------------------------
 1 file changed, 64 insertions(+), 91 deletions(-)

diff --git a/docs/maui-coverage.md b/docs/maui-coverage.md
index b6ad5524..5223c794 100644
--- a/docs/maui-coverage.md
+++ b/docs/maui-coverage.md
@@ -1,6 +1,6 @@
 # .NET MAUI ⇄ Microsoft.AndroidX.Compose.Maui backend coverage
 
-Generated by `scripts/maui-coverage.cs` on 2026-06-16 14:43 UTC.
+Generated by `scripts/maui-coverage.cs` on 2026-06-16 14:54 UTC.
 
 Pinned MAUI version: **10.0.20** (from `Directory.Build.targets`).
 
@@ -14,16 +14,16 @@ collected transitively across base mappers (`ViewHandler.ViewMapper`,
 ## Summary
 
 - **Stock MAUI handlers in scope**: 43
-- **Handlers we override**: 24 (**55.8%**)
-- **Property-mapper keys covered**: 885 / 1224 (**72.3%**)
+- **Handlers we override**: 25 (**58.1%**)
+- **Property-mapper keys covered**: 922 / 1224 (**75.3%**)
 
 ### Per-category coverage
 
 | Category | Handlers | Keys |
 | --- | --- | --- |
-| **Pages / Navigation** | 1/4 (25%) | 33/130 (25%) |
+| **Pages / Navigation** | 2/4 (50%) | 64/130 (49%) |
 | **Containers** | 5/5 (100%) | 167/174 (96%) |
-| **Leaves** | 18/18 (100%) | 685/695 (99%) |
+| **Leaves** | 18/18 (100%) | 691/695 (99%) |
 | **Menus / Toolbar** | 0/7 (0%) | 0/1 (0%) |
 | **Shapes** | 0/1 (0%) | 0/41 (0%) |
 | **App / Window** | 0/2 (0%) | 0/8 (0%) |
@@ -36,7 +36,7 @@ Sorted by category. ✅ = fully covered (100%), 🟡 = partial, ❌ = not implem
 | Status | Stock handler | Category | Virtual view(s) | Our handler | Keys |
 | --- | --- | --- | --- | --- | --- |
 | ❌ | `FlyoutViewHandler` | Pages / Navigation | `FlyoutPage` | — | 0 / 35 (0%) |
-| ❌ | `NavigationViewHandler` | Pages / Navigation | `NavigationPage` | — | 0 / 31 (0%) |
+| ✅ | `NavigationViewHandler` | Pages / Navigation | `NavigationPage` | `NavigationPageHandler` | 31 / 31 (100%) |
 | ✅ | `PageHandler` | Pages / Navigation | `Page` | `PageHandler` | 33 / 33 (100%) |
 | ❌ | `TabbedViewHandler` | Pages / Navigation | `TabbedPage` | — | 0 / 31 (0%) |
 | 🟡 | `BorderHandler` | Containers | `Border` | `BorderHandler` | 35 / 40 (88%) |
@@ -48,16 +48,16 @@ Sorted by category. ✅ = fully covered (100%), 🟡 = partial, ❌ = not implem
 | ✅ | `ButtonHandler` | Leaves | `Button` | `ButtonHandler` | 40 / 40 (100%) |
 | ✅ | `CheckBoxHandler` | Leaves | `CheckBox` | `CheckBoxHandler` | 33 / 33 (100%) |
 | ✅ | `DatePickerHandler` | Leaves | `DatePicker` | `DatePickerHandler` | 39 / 39 (100%) |
-| 🟡 | `EditorHandler` | Leaves | `Editor` | `EditorHandler` | 45 / 46 (98%) |
-| 🟡 | `EntryHandler` | Leaves | `Entry` | `EntryHandler` | 48 / 49 (98%) |
+| ✅ | `EditorHandler` | Leaves | `Editor` | `EditorHandler` | 46 / 46 (100%) |
+| ✅ | `EntryHandler` | Leaves | `Entry` | `EntryHandler` | 49 / 49 (100%) |
 | 🟡 | `ImageButtonHandler` | Leaves | `ImageButton` | `ImageButtonHandler` | 37 / 38 (97%) |
 | 🟡 | `ImageHandler` | Leaves | `Image` | `ImageHandler` | 33 / 34 (97%) |
 | ✅ | `IndicatorViewHandler` | Leaves | `IndicatorView` | `IndicatorViewHandler` | 39 / 39 (100%) |
-| 🟡 | `LabelHandler` | Leaves | `Label` | `LabelHandler` | 39 / 40 (98%) |
-| 🟡 | `PickerHandler` | Leaves | `Picker` | `PickerHandler` | 40 / 41 (98%) |
+| ✅ | `LabelHandler` | Leaves | `Label` | `LabelHandler` | 40 / 40 (100%) |
+| ✅ | `PickerHandler` | Leaves | `Picker` | `PickerHandler` | 41 / 41 (100%) |
 | ✅ | `ProgressBarHandler` | Leaves | `ProgressBar` | `ProgressBarHandler` | 33 / 33 (100%) |
-| 🟡 | `RadioButtonHandler` | Leaves | `RadioButton` | `RadioButtonHandler` | 36 / 39 (92%) |
-| 🟡 | `SearchBarHandler` | Leaves | `SearchBar` | `SearchBarHandler` | 46 / 47 (98%) |
+| 🟡 | `RadioButtonHandler` | Leaves | `RadioButton` | `RadioButtonHandler` | 37 / 39 (95%) |
+| ✅ | `SearchBarHandler` | Leaves | `SearchBar` | `SearchBarHandler` | 47 / 47 (100%) |
 | ✅ | `SliderHandler` | Leaves | `Slider` | `SliderHandler` | 38 / 38 (100%) |
 | ✅ | `StepperHandler` | Leaves | `Stepper` | `StepperHandler` | 35 / 35 (100%) |
 | ✅ | `SwitchHandler` | Leaves | `Switch` | `SwitchHandler` | 34 / 34 (100%) |
@@ -91,7 +91,6 @@ the same Material 3 / Compose pipeline as the rest of the page.
 - **`FlyoutViewHandler`** (FlyoutPage) — 35 stock keys, Pages / Navigation
 - **`GraphicsViewHandler`** (GraphicsView) — 32 stock keys, Other / advanced
 - **`SwipeItemViewHandler`** (SwipeItemView) — 32 stock keys, Other / advanced
-- **`NavigationViewHandler`** (NavigationPage) — 31 stock keys, Pages / Navigation
 - **`TabbedViewHandler`** (TabbedPage) — 31 stock keys, Pages / Navigation
 - **`HybridWebViewHandler`** (HybridWebView) — 31 stock keys, Other / advanced
 - **`WindowHandler`** (Window) — 7 stock keys, App / Window
@@ -113,15 +112,10 @@ Most often this is a non-trivial property we haven't wired up yet
 dashed stroke patterns on `Border`).
 
 - **`BorderHandler`** (88%) — missing: `StrokeDashOffset`, `StrokeDashPattern`, `StrokeLineCap`, `StrokeLineJoin`, `StrokeMiterLimit`
-- **`RadioButtonHandler`** (92%) — missing: `CornerRadius`, `StrokeColor`, `StrokeThickness`
 - **`ScrollViewHandler`** (94%) — missing: `HorizontalScrollBarVisibility`, `VerticalScrollBarVisibility`
+- **`RadioButtonHandler`** (95%) — missing: `CornerRadius`, `StrokeThickness`
 - **`ImageHandler`** (97%) — missing: `IsAnimationPlaying`
 - **`ImageButtonHandler`** (97%) — missing: `IsAnimationPlaying`
-- **`LabelHandler`** (98%) — missing: `VerticalTextAlignment`
-- **`PickerHandler`** (98%) — missing: `VerticalTextAlignment`
-- **`EditorHandler`** (98%) — missing: `VerticalTextAlignment`
-- **`SearchBarHandler`** (98%) — missing: `VerticalTextAlignment`
-- **`EntryHandler`** (98%) — missing: `VerticalTextAlignment`
 
 ## Per-handler property detail
 
@@ -175,43 +169,43 @@ _No Compose backend handler. Stock MAUI handler keeps the AppCompat backend._
 
 </details>
 
-### ❌ `NavigationViewHandler` — `NavigationPage`
+### ✅ `NavigationViewHandler` — `NavigationPage`
 
-_No Compose backend handler. Stock MAUI handler keeps the AppCompat backend._
+Backed by `NavigationPageHandler`. **31 / 31 keys (100%)**.
 
-<details><summary>Stock keys (not covered)</summary>
+<details><summary>All stock keys</summary>
 
-- [ ] `AnchorX`
-- [ ] `AnchorY`
-- [ ] `AutomationId`
-- [ ] `Background`
-- [ ] `Border`
-- [ ] `Clip`
-- [ ] `ContainerView`
-- [ ] `FlowDirection`
-- [ ] `Height`
-- [ ] `InputTransparent`
-- [ ] `IsEnabled`
-- [ ] `MaximumHeight`
-- [ ] `MaximumWidth`
-- [ ] `MinimumHeight`
-- [ ] `MinimumWidth`
-- [ ] `Opacity`
-- [ ] `Rotation`
-- [ ] `RotationX`
-- [ ] `RotationY`
-- [ ] `SafeAreaEdges`
-- [ ] `Scale`
-- [ ] `ScaleX`
-- [ ] `ScaleY`
-- [ ] `Semantics`
-- [ ] `Shadow`
-- [ ] `ToolTip`
-- [ ] `Toolbar`
-- [ ] `TranslationX`
-- [ ] `TranslationY`
-- [ ] `Visibility`
-- [ ] `Width`
+- [x] `AnchorX`
+- [x] `AnchorY`
+- [x] `AutomationId`
+- [x] `Background`
+- [x] `Border`
+- [x] `Clip`
+- [x] `ContainerView`
+- [x] `FlowDirection`
+- [x] `Height`
+- [x] `InputTransparent`
+- [x] `IsEnabled`
+- [x] `MaximumHeight`
+- [x] `MaximumWidth`
+- [x] `MinimumHeight`
+- [x] `MinimumWidth`
+- [x] `Opacity`
+- [x] `Rotation`
+- [x] `RotationX`
+- [x] `RotationY`
+- [x] `SafeAreaEdges`
+- [x] `Scale`
+- [x] `ScaleX`
+- [x] `ScaleY`
+- [x] `Semantics`
+- [x] `Shadow`
+- [x] `ToolTip`
+- [x] `Toolbar`
+- [x] `TranslationX`
+- [x] `TranslationY`
+- [x] `Visibility`
+- [x] `Width`
 
 </details>
 
@@ -734,13 +728,9 @@ Extra keys we map (no stock counterpart):
 
 </details>
 
-### 🟡 `EditorHandler` — `Editor`
-
-Backed by `EditorHandler`. **45 / 46 keys (98%)**.
+### ✅ `EditorHandler` — `Editor`
 
-Missing keys:
-
-- [ ] `VerticalTextAlignment`
+Backed by `EditorHandler`. **46 / 46 keys (100%)**.
 
 Extra keys we map (no stock counterpart):
 
@@ -791,19 +781,15 @@ Extra keys we map (no stock counterpart):
 - [x] `Toolbar`
 - [x] `TranslationX`
 - [x] `TranslationY`
-- [ ] `VerticalTextAlignment`
+- [x] `VerticalTextAlignment`
 - [x] `Visibility`
 - [x] `Width`
 
 </details>
 
-### 🟡 `EntryHandler` — `Entry`
-
-Backed by `EntryHandler`. **48 / 49 keys (98%)**.
-
-Missing keys:
+### ✅ `EntryHandler` — `Entry`
 
-- [ ] `VerticalTextAlignment`
+Backed by `EntryHandler`. **49 / 49 keys (100%)**.
 
 Extra keys we map (no stock counterpart):
 
@@ -857,7 +843,7 @@ Extra keys we map (no stock counterpart):
 - [x] `Toolbar`
 - [x] `TranslationX`
 - [x] `TranslationY`
-- [ ] `VerticalTextAlignment`
+- [x] `VerticalTextAlignment`
 - [x] `Visibility`
 - [x] `Width`
 
@@ -1009,13 +995,9 @@ Backed by `IndicatorViewHandler`. **39 / 39 keys (100%)**.
 
 </details>
 
-### 🟡 `LabelHandler` — `Label`
+### ✅ `LabelHandler` — `Label`
 
-Backed by `LabelHandler`. **39 / 40 keys (98%)**.
-
-Missing keys:
-
-- [ ] `VerticalTextAlignment`
+Backed by `LabelHandler`. **40 / 40 keys (100%)**.
 
 Extra keys we map (no stock counterpart):
 
@@ -1060,19 +1042,15 @@ Extra keys we map (no stock counterpart):
 - [x] `Toolbar`
 - [x] `TranslationX`
 - [x] `TranslationY`
-- [ ] `VerticalTextAlignment`
+- [x] `VerticalTextAlignment`
 - [x] `Visibility`
 - [x] `Width`
 
 </details>
 
-### 🟡 `PickerHandler` — `Picker`
-
-Backed by `PickerHandler`. **40 / 41 keys (98%)**.
-
-Missing keys:
+### ✅ `PickerHandler` — `Picker`
 
-- [ ] `VerticalTextAlignment`
+Backed by `PickerHandler`. **41 / 41 keys (100%)**.
 
 Extra keys we map (no stock counterpart):
 
@@ -1119,7 +1097,7 @@ Extra keys we map (no stock counterpart):
 - [x] `Toolbar`
 - [x] `TranslationX`
 - [x] `TranslationY`
-- [ ] `VerticalTextAlignment`
+- [x] `VerticalTextAlignment`
 - [x] `Visibility`
 - [x] `Width`
 
@@ -1169,12 +1147,11 @@ Backed by `ProgressBarHandler`. **33 / 33 keys (100%)**.
 
 ### 🟡 `RadioButtonHandler` — `RadioButton`
 
-Backed by `RadioButtonHandler`. **36 / 39 keys (92%)**.
+Backed by `RadioButtonHandler`. **37 / 39 keys (95%)**.
 
 Missing keys:
 
 - [ ] `CornerRadius`
-- [ ] `StrokeColor`
 - [ ] `StrokeThickness`
 
 <details><summary>All stock keys</summary>
@@ -1209,7 +1186,7 @@ Missing keys:
 - [x] `ScaleY`
 - [x] `Semantics`
 - [x] `Shadow`
-- [ ] `StrokeColor`
+- [x] `StrokeColor`
 - [ ] `StrokeThickness`
 - [x] `TextColor`
 - [x] `ToolTip`
@@ -1221,13 +1198,9 @@ Missing keys:
 
 </details>
 
-### 🟡 `SearchBarHandler` — `SearchBar`
-
-Backed by `SearchBarHandler`. **46 / 47 keys (98%)**.
-
-Missing keys:
+### ✅ `SearchBarHandler` — `SearchBar`
 
-- [ ] `VerticalTextAlignment`
+Backed by `SearchBarHandler`. **47 / 47 keys (100%)**.
 
 Extra keys we map (no stock counterpart):
 
@@ -1281,7 +1254,7 @@ Extra keys we map (no stock counterpart):
 - [x] `Toolbar`
 - [x] `TranslationX`
 - [x] `TranslationY`
-- [ ] `VerticalTextAlignment`
+- [x] `VerticalTextAlignment`
 - [x] `Visibility`
 - [x] `Width`
 

From d8c486e921c773838eace40ca83a3cb72bd4b2e9 Mon Sep 17 00:00:00 2001
From: Jonathan Peppers <jonathan.peppers@microsoft.com>
Date: Tue, 16 Jun 2026 09:59:28 -0500
Subject: [PATCH 6/6] Regenerate maui-coverage.md after merging #278

PR #278 (Border dashed-stroke geometry) brought BorderHandler from
35/40 to 40/40. Refresh the per-handler table + summary so they
match HEAD.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 docs/maui-coverage.md | 31 +++++++++++--------------------
 1 file changed, 11 insertions(+), 20 deletions(-)

diff --git a/docs/maui-coverage.md b/docs/maui-coverage.md
index 5223c794..a737508f 100644
--- a/docs/maui-coverage.md
+++ b/docs/maui-coverage.md
@@ -1,6 +1,6 @@
 # .NET MAUI ⇄ Microsoft.AndroidX.Compose.Maui backend coverage
 
-Generated by `scripts/maui-coverage.cs` on 2026-06-16 14:54 UTC.
+Generated by `scripts/maui-coverage.cs` on 2026-06-16 14:59 UTC.
 
 Pinned MAUI version: **10.0.20** (from `Directory.Build.targets`).
 
@@ -15,14 +15,14 @@ collected transitively across base mappers (`ViewHandler.ViewMapper`,
 
 - **Stock MAUI handlers in scope**: 43
 - **Handlers we override**: 25 (**58.1%**)
-- **Property-mapper keys covered**: 922 / 1224 (**75.3%**)
+- **Property-mapper keys covered**: 927 / 1224 (**75.7%**)
 
 ### Per-category coverage
 
 | Category | Handlers | Keys |
 | --- | --- | --- |
 | **Pages / Navigation** | 2/4 (50%) | 64/130 (49%) |
-| **Containers** | 5/5 (100%) | 167/174 (96%) |
+| **Containers** | 5/5 (100%) | 172/174 (99%) |
 | **Leaves** | 18/18 (100%) | 691/695 (99%) |
 | **Menus / Toolbar** | 0/7 (0%) | 0/1 (0%) |
 | **Shapes** | 0/1 (0%) | 0/41 (0%) |
@@ -39,7 +39,7 @@ Sorted by category. ✅ = fully covered (100%), 🟡 = partial, ❌ = not implem
 | ✅ | `NavigationViewHandler` | Pages / Navigation | `NavigationPage` | `NavigationPageHandler` | 31 / 31 (100%) |
 | ✅ | `PageHandler` | Pages / Navigation | `Page` | `PageHandler` | 33 / 33 (100%) |
 | ❌ | `TabbedViewHandler` | Pages / Navigation | `TabbedPage` | — | 0 / 31 (0%) |
-| 🟡 | `BorderHandler` | Containers | `Border` | `BorderHandler` | 35 / 40 (88%) |
+| ✅ | `BorderHandler` | Containers | `Border` | `BorderHandler` | 40 / 40 (100%) |
 | ✅ | `ContentViewHandler` | Containers | `ContentView`, `IContentView` | `ContentViewHandler` | 32 / 32 (100%) |
 | ✅ | `LayoutHandler` | Containers | `Layout` | `LayoutHandler` | 32 / 32 (100%) |
 | ✅ | `RefreshViewHandler` | Containers | `RefreshView` | `RefreshViewHandler` | 35 / 35 (100%) |
@@ -111,7 +111,6 @@ Most often this is a non-trivial property we haven't wired up yet
 (`CharacterSpacing`, `Font`, `Padding` on `Button`; `CornerRadius`, 
 dashed stroke patterns on `Border`).
 
-- **`BorderHandler`** (88%) — missing: `StrokeDashOffset`, `StrokeDashPattern`, `StrokeLineCap`, `StrokeLineJoin`, `StrokeMiterLimit`
 - **`ScrollViewHandler`** (94%) — missing: `HorizontalScrollBarVisibility`, `VerticalScrollBarVisibility`
 - **`RadioButtonHandler`** (95%) — missing: `CornerRadius`, `StrokeThickness`
 - **`ImageHandler`** (97%) — missing: `IsAnimationPlaying`
@@ -291,17 +290,9 @@ _No Compose backend handler. Stock MAUI handler keeps the AppCompat backend._
 
 </details>
 
-### 🟡 `BorderHandler` — `Border`
+### ✅ `BorderHandler` — `Border`
 
-Backed by `BorderHandler`. **35 / 40 keys (88%)**.
-
-Missing keys:
-
-- [ ] `StrokeDashOffset`
-- [ ] `StrokeDashPattern`
-- [ ] `StrokeLineCap`
-- [ ] `StrokeLineJoin`
-- [ ] `StrokeMiterLimit`
+Backed by `BorderHandler`. **40 / 40 keys (100%)**.
 
 Extra keys we map (no stock counterpart):
 
@@ -338,11 +329,11 @@ Extra keys we map (no stock counterpart):
 - [x] `Shadow`
 - [x] `Shape`
 - [x] `Stroke`
-- [ ] `StrokeDashOffset`
-- [ ] `StrokeDashPattern`
-- [ ] `StrokeLineCap`
-- [ ] `StrokeLineJoin`
-- [ ] `StrokeMiterLimit`
+- [x] `StrokeDashOffset`
+- [x] `StrokeDashPattern`
+- [x] `StrokeLineCap`
+- [x] `StrokeLineJoin`
+- [x] `StrokeMiterLimit`
 - [x] `StrokeThickness`
 - [x] `ToolTip`
 - [x] `Toolbar`