diff --git a/docs/maui-backend.md b/docs/maui-backend.md
index ecbbb42d..90f5797c 100644
--- a/docs/maui-backend.md
+++ b/docs/maui-backend.md
@@ -1873,6 +1873,182 @@ handler and the auto-default-mask machinery clears their
   rather than the previous `2000-01-01` default; otherwise MAUI's
   range validator silently rewrote the value back inside bounds.
 
+#### Phase 3 Slice 1 — `CollectionViewHandler` ✅ shipped
+
+Opens Phase 3 with the most-requested handler — `CollectionView` folded
+into the page composition as a Compose lazy list rather than the stock
+per-cell `ComposeView` islands. Wraps the existing `LazyColumn<T>` /
+`LazyRow<T>` / `LazyVerticalGrid<T>` facades with an `ItemsLayout` →
+facade dispatch.
+
+**Investigation finding (worth documenting up front).**
+`CollectionView` *does* already render via the `AndroidView` fallback —
+`HomePage`'s own catalog list relies on that path. `uiautomator dump`
+showed each row carrying its own `androidx.compose.ui.platform.ComposeView`
+node because the cells contain Compose-folded leaves; the page therefore
+ends up with `n + 1` Composer roots (page + one per visible row), each
+re-installing `MaterialTheme` and its own snapshot graph. The handler
+trades that for **one** composer per page — the page's — and inherits
+theme + snapshot state directly.
+
+**Delivered.**
+
+- `MauiCollectionView` → `CollectionViewHandler`:
+  - `LinearItemsLayout` (vertical / horizontal) → `LazyColumn<T>` /
+    `LazyRow<T>`. `ItemSpacing` lowers to `Arrangement.SpacedBy(dp)`
+    on the matching axis.
+  - `GridItemsLayout` → `LazyVerticalGrid<T>` with
+    `GridCells.Fixed(Span)`. `VerticalItemSpacing` /
+    `HorizontalItemSpacing` lower to the new `VerticalArrangement` /
+    `HorizontalArrangement` facade props on `LazyVerticalGrid<T>`.
+    Horizontal `GridItemsLayout` (rare in practice) falls back to
+    `LazyRow<T>` for v1 — a future `LazyHorizontalGrid` wrapper would
+    unlock that without changing the handler.
+  - `ItemTemplate` / `ItemTemplateSelector`: per-item
+    `template.CreateContent()` with `BindingContext = item`, then
+    `ComposeWalker.Render(view, …)` wrapped in a private
+    `DeferredViewNode`. The wrapper exists because lazy-list item
+    realisation happens at measure time (inside `SubcomposeLayout`),
+    not composition time, so the `ComposableLambdas.Instantiate4`
+    factory path that `LazyColumn<T>` already uses is the only safe
+    way to surface a live composer to the item; `DeferredViewNode`
+    defers the actual walk until that lambda fires.
+  - `EmptyView` (string / `IView` / `EmptyViewTemplate`) renders as a
+    centered `Column` with `verticalArrangement: Arrangement.Center` +
+    `horizontalAlignment: CenterHorizontally`. (Compose's `Box` facade
+    is parameterless — no `contentAlignment` ctor — so a `Column` was
+    the simplest single-axis centering primitive.)
+  - Per-item `Modifier.Clickable {}` wires
+    `SelectionMode = Single` / `Multiple` straight through to
+    `view.SelectedItem` / `view.SelectedItems` — `SelectionChanged`
+    + `SelectionChangedCommand` fire from MAUI's
+    `BindableProperty` setter. The wrapper is suppressed when
+    `SelectionMode = None` so non-selectable lists don't pay the
+    extra `Box` layer. Selected-row highlight styling is still
+    follow-up.
+  - `INotifyCollectionChanged`: handler subscribes to the live source
+    in `MapItemsSource` and unsubscribes on swap / `DisconnectHandler`.
+    Add / Remove / Replace / Move / Reset all collapse to a single
+    `MutableState<int> _itemsVersion` bump that causes `BuildNode` to
+    re-snapshot the source and rebuild.
+  - `ItemsLayout` is read live inside `BuildNode` (it's a
+    `BindableObject`; consumers can swap orientation or span at
+    runtime). A second `MutableState<int>` slot bumps on layout change.
+- `LazyColumn<T>` gained `VerticalArrangement` (for `ItemSpacing` on
+  vertical linear lists).
+- `LazyVerticalGrid<T>` gained `VerticalArrangement` +
+  `HorizontalArrangement` (for the two grid spacings). Both new
+  arrangement props validate axis at assignment time and throw
+  `ArgumentException` for cross-axis values
+  (e.g. `Arrangement.Start` on the vertical axis).
+- `CollectionsPage` sample drives three `CollectionView`s off one
+  `ObservableCollection<Fruit>`: vertical list, horizontal chips
+  (`ItemSpacing = 12`), grid (`Span = 3`,
+  `VerticalItemSpacing = HorizontalItemSpacing = 8`). Add / Remove /
+  Clear buttons exercise `INotifyCollectionChanged`; a fourth
+  CollectionView demos the EmptyView toggle.
+
+**Deferred (explicit list — pick up in follow-up slices).**
+
+- Selected-row highlight styling and `SelectionMode.Multiple` UI
+  affordances (checkmark, ripple emphasis). The handler already
+  wires the data path for Single + Multiple selection, but the
+  visual state is a follow-up.
+- `ScrollTo(int)` / `ScrollTo(item)` / `Scrolled` event
+  (`LazyListState.AnimateScrollToItemAsync` already exists; wiring
+  MAUI's `ScrollToRequested` is mechanical).
+- `ItemsUpdatingScrollMode` (`KeepItemsInView` /
+  `KeepScrollOffset` / `KeepLastItemInView`) — needs index-stability
+  tracking on `CollectionChanged`.
+- `RemainingItemsThreshold` / endless-scroll.
+- Grouping (`IsGrouped` / `GroupHeaderTemplate` /
+  `GroupFooterTemplate`).
+- `ListView` (deprecated; defer until a clear ask).
+- `TableView` (rare in modern MAUI).
+- `CarouselView` two-way `Position` ↔ `IndicatorView.Position`
+  (separate slice — needs `PagerState` Phase-4b state-holder with a
+  parameterised `pageCount` Remember).
+- `SwipeView` (`SwipeToDismissBox` doesn't match SwipeView's
+  left/right action panels; needs more bridge work).
+
+**Lessons learned.**
+
+- **The `Wrap*` vs `Instantiate4` distinction is exactly the trap the
+  repo's instructions call out.** Lazy-list item content runs at
+  measure time inside `SubcomposeLayout`, *outside* the composer that
+  built the list. The existing `LazyColumn` / `LazyRow` /
+  `LazyVerticalGrid` facades already use
+  `ComposableLambdas.Instantiate4` (the composer-less factory) for
+  exactly this reason; the handler just contributes a
+  `Func<T, ComposableNode>` that fires inside that lambda. Building
+  the per-item node with `Wrap4(composer, …)` instead would crash with
+  `Expected applyChanges() to have been called`.
+- **`Box`'s facade is parameterless.** The Kotlin
+  `Box(contentAlignment:)` overload is mangled (lowered through
+  `Alignment` value-class lowering) and the C# facade therefore has
+  no `contentAlignment` ctor. Centering inside a Box requires
+  `Modifier.Align(Alignment.Center)` on the child — which needs
+  `BoxScope`, which isn't surfaced cleanly. The simpler workaround is
+  a `Column` with `verticalArrangement: Center` +
+  `horizontalAlignment: CenterHorizontally`; that fits the empty-view
+  shape (single child or text) with no facade churn.
+- **`AndroidX.Compose.Text` collides with `Microsoft.AndroidX.Compose.Text`
+  inside the handler namespace.** Inside
+  `Microsoft.AndroidX.Compose.Maui.Handlers`, bare
+  `AndroidX.Compose.Text` resolves to the (non-existent)
+  `Microsoft.AndroidX.Compose.Text` because of C#'s "innermost
+  namespace wins" rule. Workaround: `using ComposeText =
+  AndroidX.Compose.Text;` alias at the top of the file.
+- **`MutableState<T>` doesn't accept arbitrary structs.** The
+  underlying Compose `MutableState` only round-trips `Java.Lang.Object`
+  subclasses, primitives, strings, and `Nullable<primitive>`. The
+  established workaround on Phase 2 handlers (`SliderHandler`,
+  `LayoutHandler`, etc.) is the **version-counter pattern**: declare
+  a `MutableState<int>` slot, bump it whenever the live MAUI value
+  changes, and read the actual value off `VirtualView` inside
+  `BuildNode`. This slice reuses that pattern for both
+  `ItemsSource`/`CollectionChanged` and `ItemsLayout` changes.
+- **`DataTemplateSelector.SelectTemplate(item, container)` is called
+  with `view` (the source `CollectionView`) as the container** so
+  selectors that branch on the host (e.g. "different template under a
+  CarouselView vs a list") see the same `BindableObject` stock MAUI's
+  adapter passes.
+- **Per-item handler allocation cost is real, but acceptable for v1.**
+  Each `template.CreateContent()` allocates a fresh `BindableObject`
+  per render of `BuildNode`. Compose's slot table memoises the
+  *rendered* output but not the View / Handler. Memoising keyed on
+  item identity + template type is straightforward follow-up; defer
+  until profiling shows it matters.
+- **Investigation discipline matters more than ever at Phase 3 scope.**
+  Three of the original Phase 3 candidates (`ListView`, `TableView`,
+  `SwipeView`) are deferred outright, and one (`CarouselView`) is its
+  own slice. Shipping `CollectionViewHandler` alone is ~370 LOC of
+  handler + facade-prop additions; bundling the rest would have
+  produced an unreviewable PR.
+- **Globally registering `CollectionViewHandler` regresses any app
+  that depends on `SelectionChanged` for navigation.** The sample's
+  own `HomePage.xaml` uses `CollectionView` + `SelectionMode="Single"`
+  + `SelectionChanged="OnDemoSelected"` for the demo nav list. The
+  first cut of this slice deferred selection — that broke navigation
+  the moment `UseAndroidXCompose` registered the handler globally.
+  Minimal Single/Multiple selection (per-row `Modifier.Clickable {}`
+  → `view.SelectedItem = item` / `view.SelectedItems.Add/Remove`) is
+  therefore **mandatory, not optional**; only the selected-row
+  highlight styling can defer.
+- **`LazyColumn` inside a vertical `ScrollView` requires an explicit
+  height.** Compose's lazy lists check max-height constraints in
+  `CheckScrollableContainerConstraintsKt` and throw
+  `IllegalStateException: Vertically scrollable component was measured
+  with an infinity maximum height constraints` when the parent is also
+  vertically scrollable. The handler now honors
+  `VisualElement.WidthRequest` / `HeightRequest` (mirroring
+  `BoxViewHandler`'s size switch) — `FillMaxSize` only when neither is
+  set, otherwise `Modifier.Size` / `Modifier.Width(.).FillMaxHeight` /
+  `Modifier.FillMaxWidth().Height(.)`. Hosting a `CollectionView`
+  inside a `ScrollView` still requires the consumer to set
+  `HeightRequest` (or use a bounded `Layout` like `Grid` row), the
+  same constraint Compose enforces on raw `LazyColumn`.
+
 ### Phase 3 — collection + container (target: list-driven apps)
 
 `CollectionView` → `LazyColumn<T>` / `LazyRow<T>` / `LazyVerticalGrid<T>`
diff --git a/src/Microsoft.AndroidX.Compose.Maui.Sample/AppShell.xaml.cs b/src/Microsoft.AndroidX.Compose.Maui.Sample/AppShell.xaml.cs
index b7e10b01..6dab46c8 100644
--- a/src/Microsoft.AndroidX.Compose.Maui.Sample/AppShell.xaml.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui.Sample/AppShell.xaml.cs
@@ -35,6 +35,7 @@ public AppShell()
         Routing.RegisterRoute("gestures",       typeof(GesturesPage));
         Routing.RegisterRoute("refresh",        typeof(RefreshPage));
         Routing.RegisterRoute("indicator",      typeof(IndicatorPage));
+        Routing.RegisterRoute("collections",    typeof(CollectionsPage));
         Routing.RegisterRoute("semantics",      typeof(SemanticsPage));
         Routing.RegisterRoute("navigation",     typeof(NavigationDemoPage));
 
diff --git a/src/Microsoft.AndroidX.Compose.Maui.Sample/HomePage.xaml.cs b/src/Microsoft.AndroidX.Compose.Maui.Sample/HomePage.xaml.cs
index 5242ab62..ba3f83d7 100644
--- a/src/Microsoft.AndroidX.Compose.Maui.Sample/HomePage.xaml.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui.Sample/HomePage.xaml.cs
@@ -130,6 +130,11 @@ public HomePage()
                 "IndicatorView dot strip; Prev/Next buttons cycle Position.",
                 Color.FromArgb("#9C27B0"),
                 "indicator"),
+            new DemoEntry(
+                "Collections",
+                "CollectionView vertical / horizontal / grid backed by ObservableCollection<T>.",
+                Color.FromArgb("#7E57C2"),
+                "collections"),
             new DemoEntry(
                 "Semantics",
                 "SemanticProperties.Description / Hint / HeadingLevel + AutomationId routed to Compose `Modifier.Semantics { … }`.",
diff --git a/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/CollectionsPage.xaml b/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/CollectionsPage.xaml
new file mode 100644
index 00000000..2961c683
--- /dev/null
+++ b/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/CollectionsPage.xaml
@@ -0,0 +1,153 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             xmlns:local="clr-namespace:Microsoft.AndroidX.Compose.Maui.Sample.Pages"
+             x:Class="Microsoft.AndroidX.Compose.Maui.Sample.Pages.CollectionsPage"
+             x:DataType="local:CollectionsPage"
+             x:Name="Self"
+             Title="Collections">
+
+    <!--
+        Exercises `CollectionViewHandler` (Phase 3 Slice 1).
+
+        Three CollectionViews on one page exercise the layout dispatch
+        path:
+
+          * VerticalList — default LinearItemsLayout.Vertical → LazyColumn.
+            Mutate via Add / Remove / Clear buttons; the
+            ObservableCollection wired to ItemsSource raises
+            CollectionChanged, the handler bumps its items version slot,
+            and BuildNode re-snapshots and re-walks the templates.
+
+          * HorizontalChips — LinearItemsLayout horizontal + ItemSpacing
+            → LazyRow with Arrangement.SpacedBy.
+
+          * GridList — GridItemsLayout Span=3 →
+            LazyVerticalGrid(GridCells.Fixed(3)) with vertical +
+            horizontal item spacing.
+
+        EmptyDemo flips ItemsSource between a populated collection and
+        an empty one; the handler renders EmptyView (a centered Label)
+        when the source is empty.
+    -->
+    <ScrollView>
+        <VerticalStackLayout Padding="20" Spacing="24">
+
+            <!-- ===== Vertical list ===== -->
+
+            <Label Text="Vertical list (LazyColumn)"
+                   Style="{StaticResource Headline}" />
+
+            <Label Text="ObservableCollection&lt;Fruit&gt; with Add / Remove / Clear. Each row uses a DataTemplate with two labels and a colored bar; mutations rebuild the list via INotifyCollectionChanged."
+                   LineBreakMode="WordWrap" />
+
+            <HorizontalStackLayout Spacing="8">
+                <Button Text="Add"    Clicked="OnAddFruit" />
+                <Button Text="Remove" Clicked="OnRemoveFruit" />
+                <Button Text="Clear"  Clicked="OnClearFruits" />
+            </HorizontalStackLayout>
+
+            <CollectionView x:Name="VerticalList"
+                            ItemsSource="{Binding Fruits, Source={x:Reference Self}, x:DataType=local:CollectionsPage}"
+                            HeightRequest="280">
+                <CollectionView.ItemsLayout>
+                    <LinearItemsLayout Orientation="Vertical" ItemSpacing="6" />
+                </CollectionView.ItemsLayout>
+                <CollectionView.ItemTemplate>
+                    <DataTemplate x:DataType="local:Fruit">
+                        <Grid Padding="8" ColumnDefinitions="8,*,Auto">
+                            <BoxView Grid.Column="0" Color="{Binding Accent}" WidthRequest="6" />
+                            <VerticalStackLayout Grid.Column="1" Padding="10,0,0,0" Spacing="2">
+                                <Label Text="{Binding Name}"   FontAttributes="Bold" />
+                                <Label Text="{Binding Origin}" FontSize="12" />
+                            </VerticalStackLayout>
+                            <Label  Grid.Column="2" Text="{Binding Calories, StringFormat='{0} kcal'}" FontSize="12" VerticalOptions="Center" />
+                        </Grid>
+                    </DataTemplate>
+                </CollectionView.ItemTemplate>
+            </CollectionView>
+
+            <!-- ===== Horizontal chips ===== -->
+
+            <Label Text="Horizontal chips (LazyRow)"
+                   Style="{StaticResource Headline}" />
+
+            <Label Text="Same items, LinearItemsLayout.Horizontal with ItemSpacing=12."
+                   LineBreakMode="WordWrap" />
+
+            <CollectionView x:Name="HorizontalChips"
+                            ItemsSource="{Binding Fruits, Source={x:Reference Self}, x:DataType=local:CollectionsPage}"
+                            HeightRequest="64">
+                <CollectionView.ItemsLayout>
+                    <LinearItemsLayout Orientation="Horizontal" ItemSpacing="12" />
+                </CollectionView.ItemsLayout>
+                <CollectionView.ItemTemplate>
+                    <DataTemplate x:DataType="local:Fruit">
+                        <Border Stroke="{Binding Accent}"
+                                StrokeThickness="1.5"
+                                StrokeShape="RoundRectangle 16"
+                                Padding="14,8">
+                            <Label Text="{Binding Name}" />
+                        </Border>
+                    </DataTemplate>
+                </CollectionView.ItemTemplate>
+            </CollectionView>
+
+            <!-- ===== Grid ===== -->
+
+            <Label Text="Grid (LazyVerticalGrid, Span=3)"
+                   Style="{StaticResource Headline}" />
+
+            <Label Text="GridItemsLayout Span=3 with Vertical / Horizontal item spacing 8dp."
+                   LineBreakMode="WordWrap" />
+
+            <CollectionView x:Name="GridList"
+                            ItemsSource="{Binding Fruits, Source={x:Reference Self}, x:DataType=local:CollectionsPage}"
+                            HeightRequest="280">
+                <CollectionView.ItemsLayout>
+                    <GridItemsLayout Orientation="Vertical"
+                                     Span="3"
+                                     VerticalItemSpacing="8"
+                                     HorizontalItemSpacing="8" />
+                </CollectionView.ItemsLayout>
+                <CollectionView.ItemTemplate>
+                    <DataTemplate x:DataType="local:Fruit">
+                        <Border Stroke="{Binding Accent}" StrokeThickness="1" Padding="10">
+                            <VerticalStackLayout Spacing="4">
+                                <Label Text="{Binding Name}"    FontAttributes="Bold" />
+                                <Label Text="{Binding Calories, StringFormat='{0} kcal'}" FontSize="11" />
+                            </VerticalStackLayout>
+                        </Border>
+                    </DataTemplate>
+                </CollectionView.ItemTemplate>
+            </CollectionView>
+
+            <!-- ===== Empty view ===== -->
+
+            <Label Text="Empty view"
+                   Style="{StaticResource Headline}" />
+
+            <Label Text="Toggle between a populated source and an empty one. EmptyView is a centered Label rendered when ItemsSource is null/empty."
+                   LineBreakMode="WordWrap" />
+
+            <Button Text="Toggle population" Clicked="OnToggleEmpty" />
+
+            <CollectionView x:Name="EmptyDemo"
+                            HeightRequest="180">
+                <CollectionView.EmptyView>
+                    <Label Text="No items yet — tap 'Toggle population' to add some."
+                           HorizontalOptions="Center"
+                           VerticalOptions="Center"
+                           FontAttributes="Italic" />
+                </CollectionView.EmptyView>
+                <CollectionView.ItemTemplate>
+                    <DataTemplate x:DataType="x:String">
+                        <Label Text="{Binding .}" Padding="10,6" />
+                    </DataTemplate>
+                </CollectionView.ItemTemplate>
+            </CollectionView>
+
+        </VerticalStackLayout>
+    </ScrollView>
+
+</ContentPage>
diff --git a/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/CollectionsPage.xaml.cs b/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/CollectionsPage.xaml.cs
new file mode 100644
index 00000000..5137661e
--- /dev/null
+++ b/src/Microsoft.AndroidX.Compose.Maui.Sample/Pages/CollectionsPage.xaml.cs
@@ -0,0 +1,78 @@
+using System.Collections.ObjectModel;
+
+namespace Microsoft.AndroidX.Compose.Maui.Sample.Pages;
+
+/// <summary>
+/// Sample data row for the <see cref="CollectionsPage"/> grid /
+/// list demos.
+/// </summary>
+/// <param name="Name">Display name shown on each row.</param>
+/// <param name="Origin">Free-form second line under the name.</param>
+/// <param name="Calories">Trailing kcal stat.</param>
+/// <param name="Accent">Accent colour used for the row's side bar.</param>
+public sealed record Fruit(string Name, string Origin, int Calories, Color Accent);
+
+/// <summary>
+/// Collections demo — exercises
+/// <see cref="Microsoft.AndroidX.Compose.Maui.Handlers.CollectionViewHandler"/>:
+/// vertical, horizontal, and grid CollectionViews backed by a shared
+/// <see cref="ObservableCollection{T}"/> with Add / Remove / Clear
+/// mutations + an empty-view demo.
+/// </summary>
+public partial class CollectionsPage : ContentPage
+{
+    static readonly Fruit[] s_seed =
+    {
+        new("Apple",      "USA",        95,  Colors.IndianRed),
+        new("Banana",     "Ecuador",   105,  Colors.Gold),
+        new("Cherry",     "Turkey",     50,  Colors.Crimson),
+        new("Date",       "Iran",      282,  Colors.SaddleBrown),
+        new("Elderberry", "Europe",     73,  Colors.Purple),
+        new("Fig",        "Greece",     74,  Colors.Plum),
+        new("Grape",      "Italy",      67,  Colors.MediumPurple),
+    };
+
+    int _addCursor;
+
+    /// <summary>Backing collection driving all three CollectionViews on this page.</summary>
+    public ObservableCollection<Fruit> Fruits { get; } = new(s_seed);
+
+    /// <summary>Build the page.</summary>
+    public CollectionsPage()
+    {
+        InitializeComponent();
+        _addCursor = Fruits.Count;
+    }
+
+    void OnAddFruit(object? sender, EventArgs e)
+    {
+        // Cycle through the seed so the list keeps gaining distinct items
+        // rather than always re-appending the same one.
+        var template = s_seed[_addCursor % s_seed.Length];
+        Fruits.Add(template with { Name = $"{template.Name} #{_addCursor + 1}" });
+        _addCursor++;
+    }
+
+    void OnRemoveFruit(object? sender, EventArgs e)
+    {
+        if (Fruits.Count > 0)
+            Fruits.RemoveAt(Fruits.Count - 1);
+    }
+
+    void OnClearFruits(object? sender, EventArgs e) => Fruits.Clear();
+
+    void OnToggleEmpty(object? sender, EventArgs e)
+    {
+        if (EmptyDemo.ItemsSource is null)
+        {
+            EmptyDemo.ItemsSource = new[]
+            {
+                "First", "Second", "Third", "Fourth",
+            };
+        }
+        else
+        {
+            EmptyDemo.ItemsSource = null;
+        }
+    }
+}
diff --git a/src/Microsoft.AndroidX.Compose.Maui/Handlers/CollectionViewHandler.cs b/src/Microsoft.AndroidX.Compose.Maui/Handlers/CollectionViewHandler.cs
new file mode 100644
index 00000000..62f5f5e5
--- /dev/null
+++ b/src/Microsoft.AndroidX.Compose.Maui/Handlers/CollectionViewHandler.cs
@@ -0,0 +1,565 @@
+using System.Collections;
+using System.Collections.Specialized;
+using AndroidX.Compose;
+using AndroidX.Compose.Runtime;
+using AndroidX.Compose.UI.Platform;
+using Microsoft.AndroidX.Compose.Maui.Platform;
+using Microsoft.Maui.Handlers;
+using ComposeText           = AndroidX.Compose.Text;
+using MauiCollectionView    = Microsoft.Maui.Controls.CollectionView;
+using MauiDataTemplate      = Microsoft.Maui.Controls.DataTemplate;
+using MauiDataTemplateSel   = Microsoft.Maui.Controls.DataTemplateSelector;
+using MauiGridItemsLayout   = Microsoft.Maui.Controls.GridItemsLayout;
+using MauiItemsLayout       = Microsoft.Maui.Controls.IItemsLayout;
+using MauiItemsLayoutOrient = Microsoft.Maui.Controls.ItemsLayoutOrientation;
+using MauiLinearItemsLayout = Microsoft.Maui.Controls.LinearItemsLayout;
+
+namespace Microsoft.AndroidX.Compose.Maui.Handlers;
+
+/// <summary>
+/// MAUI <see cref="MauiCollectionView"/> handler that folds the list
+/// directly into the enclosing page composition as a Compose
+/// <see cref="LazyColumn{T}"/>, <see cref="LazyRow{T}"/>, or
+/// <see cref="LazyVerticalGrid{T}"/> chosen by
+/// <see cref="Microsoft.Maui.Controls.StructuredItemsView.ItemsLayout"/>.
+/// Replaces the stock <c>RecyclerView</c> island when the consumer
+/// calls <see cref="Hosting.AppHostBuilderExtensions.UseAndroidXCompose"/>.
+/// </summary>
+/// <remarks>
+/// <para>The stock <c>CollectionViewHandler</c> wraps each cell in its
+/// own <c>ComposeView</c> when the cell contains Compose-folded leaves.
+/// That works, but pays for one Recomposer per visible row and re-installs
+/// the <c>MaterialTheme</c> per cell. Folding into the page composition
+/// means one Recomposer, one snapshot graph, and one
+/// <c>MaterialTheme</c> scope for the whole list.</para>
+///
+/// <para><b>Layout dispatch.</b>
+/// <see cref="Microsoft.Maui.Controls.StructuredItemsView.ItemsLayout"/>
+/// is read live inside <see cref="BuildNode(IComposer)"/> (it's a
+/// <see cref="BindableObject"/> the consumer can swap at runtime):</para>
+/// <list type="bullet">
+///   <item><description><see cref="MauiLinearItemsLayout"/>
+///     <see cref="MauiItemsLayoutOrient.Vertical"/> → <see cref="LazyColumn{T}"/>.</description></item>
+///   <item><description><see cref="MauiLinearItemsLayout"/>
+///     <see cref="MauiItemsLayoutOrient.Horizontal"/> → <see cref="LazyRow{T}"/>.</description></item>
+///   <item><description><see cref="MauiGridItemsLayout"/>
+///     <see cref="MauiItemsLayoutOrient.Vertical"/> → <see cref="LazyVerticalGrid{T}"/>
+///     with <see cref="GridCells.Fixed(int)"/>.</description></item>
+/// </list>
+///
+/// <para><b>Horizontal grid not yet wired.</b> Compose's
+/// <c>LazyHorizontalGrid</c> is bound but its facade isn't exercised here
+/// because <see cref="MauiGridItemsLayout"/> with horizontal orientation
+/// is uncommon and surfaces additional spacing nuances; tracked as a
+/// follow-up. Until then a horizontal grid layout falls back to a
+/// <see cref="LazyRow{T}"/> with single-row items.</para>
+///
+/// <para><b>Item template.</b>
+/// <see cref="Microsoft.Maui.Controls.ItemsView.ItemTemplate"/> /
+/// <see cref="MauiDataTemplateSel"/> is invoked per item — each item gets
+/// a fresh <see cref="BindableObject"/> with its
+/// <see cref="BindableObject.BindingContext"/> assigned to the item, then
+/// walked through <see cref="ComposeWalker.Render(IView, IComposer, IMauiContext)"/>.
+/// Per-item handler allocation cost is accepted for this slice;
+/// memoization is a follow-up.</para>
+///
+/// <para><b>Reactive sources.</b> Any
+/// <see cref="MauiCollectionView.ItemsSource"/> implementing
+/// <see cref="INotifyCollectionChanged"/> is subscribed to; any
+/// mutation bumps the items version slot, which re-runs
+/// <see cref="BuildNode(IComposer)"/> and re-snapshots the source into
+/// an <see cref="IReadOnlyList{T}"/> the lazy facades index into.</para>
+///
+/// <para><b>Empty view.</b> When the source is null or empty and
+/// <see cref="MauiCollectionView.EmptyView"/> is set, the handler renders
+/// the empty-view content instead of the list. A <see cref="string"/> is
+/// surfaced as a centered <see cref="AndroidX.Compose.Text"/>; an
+/// <see cref="IView"/> is walked through <see cref="ComposeWalker"/>;
+/// <see cref="MauiCollectionView.EmptyViewTemplate"/> is honored when
+/// set (the template's content is materialised once and re-used).</para>
+///
+/// <para><b>Out of scope for this slice (follow-up):</b>
+/// selected-row highlight styling (the handler already routes Single +
+/// Multiple selection writes into MAUI via
+/// <see cref="Microsoft.Maui.Controls.SelectableItemsView.SelectedItem"/> /
+/// <see cref="Microsoft.Maui.Controls.SelectableItemsView.SelectedItems"/>
+/// so <see cref="Microsoft.Maui.Controls.SelectableItemsView.SelectionChanged"/>
+/// fires — but the selected row is not yet visually emphasised);
+/// <see cref="Microsoft.Maui.Controls.ItemsView.ScrollTo(int, int, Microsoft.Maui.Controls.ScrollToPosition, bool)"/>
+/// /
+/// <see cref="Microsoft.Maui.Controls.ItemsView.Scrolled"/> event;
+/// <see cref="Microsoft.Maui.Controls.ItemsView.ItemsUpdatingScrollMode"/>
+/// stability;
+/// <see cref="Microsoft.Maui.Controls.ItemsView.RemainingItemsThreshold"/>
+/// endless-scroll;
+/// <see cref="Microsoft.Maui.Controls.StructuredItemsView.Header"/> /
+/// <see cref="Microsoft.Maui.Controls.StructuredItemsView.Footer"/> /
+/// <see cref="Microsoft.Maui.Controls.StructuredItemsView.ItemSizingStrategy"/>;
+/// grouping;
+/// item-handler caching.</para>
+/// </remarks>
+public partial class CollectionViewHandler : ComposeElementHandler<MauiCollectionView>
+{
+    /// <summary>
+    /// Property mapper that forwards MAUI <see cref="MauiCollectionView"/>
+    /// changes to the Compose-backed <see cref="ComposeView"/>.
+    /// </summary>
+    public static IPropertyMapper<MauiCollectionView, CollectionViewHandler> Mapper =
+        new PropertyMapper<MauiCollectionView, CollectionViewHandler>(ViewHandler.ViewMapper)
+        {
+            [nameof(MauiCollectionView.ItemsSource)]                            = MapItemsSource,
+            [nameof(MauiCollectionView.ItemTemplate)]                           = MapTemplateChanged,
+            [nameof(MauiCollectionView.ItemsLayout)]                            = MapLayoutChanged,
+            [nameof(MauiCollectionView.EmptyView)]                              = MapEmptyChanged,
+            [nameof(MauiCollectionView.EmptyViewTemplate)]                      = MapEmptyChanged,
+            [nameof(MauiCollectionView.SelectionMode)]                          = MapSelectionModeChanged,
+            [nameof(Microsoft.Maui.Controls.VisualElement.WidthRequest)]        = MapSizeRequest,
+            [nameof(Microsoft.Maui.Controls.VisualElement.HeightRequest)]       = MapSizeRequest,
+        };
+
+    /// <summary>Command mapper (inherits view-level commands; no extras).</summary>
+    public static CommandMapper<MauiCollectionView, CollectionViewHandler> CommandMapper =
+        new(ViewCommandMapper);
+
+    // One version slot for "anything that should re-snapshot the items
+    // source and re-walk the templates". Bumped by every mapper above
+    // plus by INotifyCollectionChanged events on the live source. Read
+    // off the top of BuildNode so a single Compose dependency edge fans
+    // out to the whole list subtree.
+    readonly MutableState<int> _itemsVersion = new(0);
+
+    // Tracks the currently-subscribed INotifyCollectionChanged source so
+    // we can unsubscribe before swapping to a new source or disposing
+    // the handler. Null when the source doesn't implement the
+    // notification interface (we still snapshot it on every version
+    // bump — the swap itself triggers a bump).
+    INotifyCollectionChanged? _observedSource;
+
+    /// <summary>Construct a handler with the default mappers.</summary>
+    public CollectionViewHandler() : base(Mapper, CommandMapper) { }
+
+    /// <summary>Construct a handler with custom mappers.</summary>
+    public CollectionViewHandler(IPropertyMapper? mapper, CommandMapper? commandMapper = null)
+        : base(mapper ?? Mapper, commandMapper ?? CommandMapper) { }
+
+    /// <inheritdoc/>
+    protected override void DisconnectHandler(ComposeView platformView)
+    {
+        UnsubscribeFromSource();
+        base.DisconnectHandler(platformView);
+    }
+
+    /// <inheritdoc/>
+    public override ComposableNode BuildNode(IComposer composer)
+    {
+        // Re-run when anything list-shaped or template-shaped changes.
+        _ = _itemsVersion.Value;
+        SubscribeToViewProperties();
+
+        var view = VirtualView
+            ?? throw new InvalidOperationException("VirtualView not set on CollectionViewHandler.");
+        var context = MauiContext
+            ?? throw new InvalidOperationException("MauiContext not set on CollectionViewHandler.");
+
+        var items    = Snapshot(view.ItemsSource);
+        var template = view.ItemTemplate;
+        var clickable = view.SelectionMode != Microsoft.Maui.Controls.SelectionMode.None;
+
+        // Empty-view fallback. Stock MAUI surfaces EmptyView whenever
+        // ItemsSource is null or empty AND EmptyView is set; we match.
+        // ItemTemplate being null is NOT an empty-state trigger — stock
+        // MAUI falls through to ToString-per-item rendering in that case.
+        if (items.Count == 0 && view.EmptyView is not null)
+        {
+            return BuildEmptyView(view, context);
+        }
+
+        // No template + non-empty source: stock MAUI renders the
+        // ToString() of each item in a TextCell-equivalent. Match that
+        // so the handler degrades gracefully instead of throwing.
+        Func<object, ComposableNode> rawItemContent = template is null
+            ? item => new ComposeText(item?.ToString() ?? string.Empty)
+            : item => BuildFromTemplate(template, item, view, context);
+
+        // SelectionMode != None: wrap each item in a Clickable Box so
+        // tapping a row fires MAUI's SelectionChanged + Command. Single
+        // assigns SelectedItem; Multiple toggles SelectedItems
+        // membership. We intentionally do NOT highlight the selected
+        // row yet — selection styling is a follow-up slice. The
+        // wrapper is necessary even when the template's root is a
+        // touchable Layout because MAUI's stock click delivery routes
+        // through CollectionView's adapter, which we're replacing.
+        Func<object, ComposableNode> itemContent = clickable
+            ? item => WrapClickable(rawItemContent(item), () => OnItemTapped(view, item))
+            : rawItemContent;
+
+        // Read the layout live — it's a BindableObject the consumer can
+        // swap at runtime, and the mapper bumped _itemsVersion if so.
+        var layout = view.ItemsLayout;
+        return BuildList(view, layout, items, itemContent, context);
+    }
+
+    ComposableNode BuildList(
+        MauiCollectionView view,
+        MauiItemsLayout? layout,
+        IReadOnlyList<object> items,
+        Func<object, ComposableNode> itemContent,
+        IMauiContext context)
+    {
+        // ApplyViewProperties wraps the OUTER frame so opacity, scale,
+        // rotation, clip, shadow, IsVisible affect the entire list.
+        // Gestures + semantics chain in the canonical order so a list
+        // tagged with SemanticProperties.Description aggregates under
+        // mergeDescendants on the same node hit by tap detectors.
+        var outer = Modifier.Companion
+            .ApplyViewProperties(view)
+            .ApplyGestures(view, context)
+            .ApplySemantics(view);
+        outer = ApplyListSize(outer, view);
+
+        return layout switch
+        {
+            MauiGridItemsLayout grid when grid.Orientation == MauiItemsLayoutOrient.Vertical =>
+                BuildVerticalGrid(items, itemContent, grid, outer, context),
+
+            // Horizontal grid: no LazyHorizontalGrid facade dispatch
+            // yet — fall back to LazyRow per the <remarks> note.
+            MauiGridItemsLayout grid =>
+                BuildLazyRow(items, itemContent, ItemSpacingOf(grid.HorizontalItemSpacing), outer),
+
+            MauiLinearItemsLayout lin when lin.Orientation == MauiItemsLayoutOrient.Horizontal =>
+                BuildLazyRow(items, itemContent, ItemSpacingOf(lin.ItemSpacing), outer),
+
+            // Vertical linear is the default for CollectionView when no
+            // ItemsLayout is set (LinearItemsLayout.Vertical singleton).
+            MauiLinearItemsLayout lin =>
+                BuildLazyColumn(items, itemContent, ItemSpacingOf(lin.ItemSpacing), outer),
+
+            // Unknown layout: degrade to a vertical list with no spacing.
+            _ => BuildLazyColumn(items, itemContent, spacing: null, outer),
+        };
+    }
+
+    static ComposableNode BuildLazyColumn(
+        IReadOnlyList<object> items,
+        Func<object, ComposableNode> itemContent,
+        Arrangement? spacing,
+        Modifier outer)
+    {
+        return new LazyColumn<object>(items, itemContent)
+        {
+            Modifier            = outer,
+            VerticalArrangement = spacing,
+        };
+    }
+
+    static ComposableNode BuildLazyRow(
+        IReadOnlyList<object> items,
+        Func<object, ComposableNode> itemContent,
+        Arrangement? spacing,
+        Modifier outer)
+    {
+        return new LazyRow<object>(items, itemContent)
+        {
+            Modifier              = outer,
+            HorizontalArrangement = spacing,
+        };
+    }
+
+    static ComposableNode BuildVerticalGrid(
+        IReadOnlyList<object> items,
+        Func<object, ComposableNode> itemContent,
+        MauiGridItemsLayout grid,
+        Modifier outer,
+        IMauiContext context)
+    {
+        _ = context; // reserved for future per-cell handler caching
+        int span = grid.Span > 0 ? grid.Span : 1;
+        return new LazyVerticalGrid<object>(GridCells.Fixed(span), items, itemContent)
+        {
+            Modifier              = outer,
+            VerticalArrangement   = ItemSpacingOf(grid.VerticalItemSpacing),
+            HorizontalArrangement = ItemSpacingOf(grid.HorizontalItemSpacing),
+        };
+    }
+
+    static Arrangement? ItemSpacingOf(double spacingDp) =>
+        spacingDp > 0 ? Arrangement.SpacedBy(new Dp((float)spacingDp)) : null;
+
+    ComposableNode BuildEmptyView(MauiCollectionView view, IMauiContext context)
+    {
+        // Column with `verticalArrangement: Arrangement.Center` +
+        // `horizontalAlignment: CenterHorizontally` centers the empty
+        // payload inside the list's slot. Box-with-contentAlignment
+        // would also work but Box's facade is parameterless — Column
+        // takes both alignments straight on the ctor.
+        var outer = Modifier.Companion
+            .ApplyViewProperties(view)
+            .ApplyGestures(view, context)
+            .ApplySemantics(view);
+        outer = ApplyListSize(outer, view);
+
+        // Template wins over raw EmptyView when both are set, matching
+        // stock MAUI's resolution order (EmptyViewTemplate is preferred
+        // because it carries data binding for the EmptyView object).
+        if (view.EmptyViewTemplate is MauiDataTemplate emptyTemplate)
+        {
+            var content = MaterialiseTemplate(emptyTemplate, view.EmptyView ?? view);
+            if (content is IView contentView)
+            {
+                return CenteredColumn(outer, new DeferredViewNode(contentView, context));
+            }
+        }
+
+        return view.EmptyView switch
+        {
+            IView emptyView => CenteredColumn(outer, new DeferredViewNode(emptyView, context)),
+            string text     => CenteredColumn(outer, new ComposeText(text)),
+            // Unknown object: surface its ToString so the empty state
+            // is still visible rather than rendering a blank list area.
+            { } other => CenteredColumn(outer, new ComposeText(other.ToString() ?? string.Empty)),
+            null      => CenteredColumn(outer, child: null),
+        };
+    }
+
+    static ComposableNode CenteredColumn(Modifier outer, ComposableNode? child)
+    {
+        var column = new Column(
+            verticalArrangement: Arrangement.Center,
+            horizontalAlignment: Alignment.Horizontal.CenterHorizontally)
+        {
+            Modifier = outer,
+        };
+        if (child is not null)
+            column.Add(child);
+        return column;
+    }
+
+    static ComposableNode BuildFromTemplate(MauiDataTemplate template, object item, MauiCollectionView view, IMauiContext context)
+    {
+        // Pass `view` (the source CollectionView) as the container so
+        // DataTemplateSelector subclasses that branch on the host
+        // (e.g. "different template under a CarouselView vs a list")
+        // see the same BindableObject stock MAUI's adapter passes.
+        var resolved = template is MauiDataTemplateSel selector
+            ? selector.SelectTemplate(item, container: view)
+            : template;
+
+        var content = MaterialiseTemplate(resolved, item);
+        if (content is not IView contentView)
+        {
+            // Template materialised to a non-View (e.g. a Cell only). We
+            // fall back to ToString so the list keeps rendering.
+            return new ComposeText(item?.ToString() ?? string.Empty);
+        }
+
+        // ComposeWalker.Render needs a live IComposer, but the lazy
+        // facade defers item rendering until the Lazy* scope's measure
+        // pass actually pulls the index. We materialise the template up
+        // front so its BindingContext is set on the UI thread before any
+        // composer reads, then wrap the resolved IView in a deferred
+        // node whose own Render(IComposer) runs ComposeWalker.Render at
+        // the correct moment inside Instantiate4's composition.
+        return new DeferredViewNode(contentView, context);
+    }
+
+    /// <summary>
+    /// Wraps a MAUI <see cref="IView"/> so that
+    /// <see cref="ComposeWalker.Render(IView, IComposer, IMauiContext)"/>
+    /// runs lazily, with the live composer supplied by the lazy facade's
+    /// <c>Instantiate4</c> path. Materialised eagerly so the
+    /// template's <see cref="BindableObject.BindingContext"/> is bound
+    /// on the UI thread before any composition reads.
+    /// </summary>
+    sealed class DeferredViewNode : ComposableNode
+    {
+        readonly IView _view;
+        readonly IMauiContext _context;
+
+        public DeferredViewNode(IView view, IMauiContext context)
+        {
+            _view    = view;
+            _context = context;
+        }
+
+        public override void Render(IComposer composer) =>
+            ComposeWalker.Render(_view, composer, _context).Render(composer);
+    }
+
+    static object? MaterialiseTemplate(MauiDataTemplate template, object item)
+    {
+        var content = template.CreateContent();
+        if (content is BindableObject bindable)
+        {
+            bindable.BindingContext = item;
+        }
+        return content;
+    }
+
+    static IReadOnlyList<object> Snapshot(IEnumerable? source)
+    {
+        if (source is null)
+            return Array.Empty<object>();
+
+        if (source is IReadOnlyList<object> roList)
+            return roList;
+
+        if (source is IList list)
+        {
+            var arr = new object[list.Count];
+            for (int i = 0; i < list.Count; i++)
+                arr[i] = list[i] ?? new object();
+            return arr;
+        }
+
+        var buffer = new List<object>();
+        foreach (var item in source)
+            buffer.Add(item ?? new object());
+        return buffer;
+    }
+
+    void SubscribeToSource(MauiCollectionView view)
+    {
+        UnsubscribeFromSource();
+        if (view.ItemsSource is INotifyCollectionChanged ncc)
+        {
+            _observedSource = ncc;
+            ncc.CollectionChanged += OnSourceCollectionChanged;
+        }
+    }
+
+    void UnsubscribeFromSource()
+    {
+        if (_observedSource is not null)
+        {
+            _observedSource.CollectionChanged -= OnSourceCollectionChanged;
+            _observedSource = null;
+        }
+    }
+
+    void OnSourceCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+    {
+        // Add / Remove / Move / Reset / Replace all collapse to "re-snapshot
+        // and rebuild" for this slice. ItemsUpdatingScrollMode is a
+        // follow-up that distinguishes between these.
+        _itemsVersion.Value++;
+    }
+
+    /// <summary>
+    /// Swap the observed <see cref="INotifyCollectionChanged"/> subscription
+    /// to the new <see cref="MauiCollectionView.ItemsSource"/> and bump
+    /// the items version slot.
+    /// </summary>
+    public static void MapItemsSource(CollectionViewHandler handler, MauiCollectionView view)
+    {
+        handler.SubscribeToSource(view);
+        handler._itemsVersion.Value++;
+    }
+
+    /// <summary>Bump the items version slot when the item template changes.</summary>
+    public static void MapTemplateChanged(CollectionViewHandler handler, MauiCollectionView _) =>
+        handler._itemsVersion.Value++;
+
+    /// <summary>Bump the items version slot when the layout object changes.</summary>
+    public static void MapLayoutChanged(CollectionViewHandler handler, MauiCollectionView _) =>
+        handler._itemsVersion.Value++;
+
+    /// <summary>Bump the items version slot when the empty-view payload changes.</summary>
+    public static void MapEmptyChanged(CollectionViewHandler handler, MauiCollectionView _) =>
+        handler._itemsVersion.Value++;
+
+    /// <summary>Bump the items version slot when selection mode flips.</summary>
+    public static void MapSelectionModeChanged(CollectionViewHandler handler, MauiCollectionView _) =>
+        handler._itemsVersion.Value++;
+
+    /// <summary>
+    /// Bump the items version slot when
+    /// <see cref="Microsoft.Maui.Controls.VisualElement.WidthRequest"/> or
+    /// <see cref="Microsoft.Maui.Controls.VisualElement.HeightRequest"/>
+    /// changes. Honoring these is mandatory because the lazy facades
+    /// inherit their parent's max constraints — nesting an unsized
+    /// list inside a vertical <see cref="Microsoft.Maui.Controls.ScrollView"/>
+    /// throws "Vertically scrollable component was measured with an
+    /// infinity maximum height constraints" from
+    /// <c>androidx.compose.foundation.CheckScrollableContainerConstraintsKt</c>.
+    /// </summary>
+    public static void MapSizeRequest(CollectionViewHandler handler, MauiCollectionView _) =>
+        handler._itemsVersion.Value++;
+
+    /// <summary>
+    /// Apply <see cref="Microsoft.Maui.Controls.VisualElement.WidthRequest"/> /
+    /// <see cref="Microsoft.Maui.Controls.VisualElement.HeightRequest"/> to
+    /// the outer list modifier. Mirrors <c>BoxViewHandler</c>'s size
+    /// switch. The "neither set" path falls back to <c>FillMaxSize</c>
+    /// for the common case where the list is the page's primary
+    /// content (e.g. a navigation list directly under <c>ContentPage</c>);
+    /// when the consumer hosts the list inside a vertical
+    /// <see cref="Microsoft.Maui.Controls.ScrollView"/> they MUST set
+    /// <see cref="Microsoft.Maui.Controls.VisualElement.HeightRequest"/>
+    /// (or wrap the list in a bounded
+    /// <see cref="Microsoft.Maui.Controls.Layout"/>) — the same constraint
+    /// Compose enforces on raw <c>LazyColumn</c>.
+    /// </summary>
+    static Modifier ApplyListSize(Modifier modifier, MauiCollectionView view)
+    {
+        var widthReq  = view.WidthRequest;
+        var heightReq = view.HeightRequest;
+        return (widthReq, heightReq) switch
+        {
+            ( >= 0d, >= 0d ) => modifier.Size(new Dp((float)widthReq), new Dp((float)heightReq)),
+            ( >= 0d, _    ) => modifier.Width(new Dp((float)widthReq)).FillMaxHeight(),
+            ( _,    >= 0d ) => modifier.FillMaxWidth().Height(new Dp((float)heightReq)),
+            _                => modifier.FillMaxSize(),
+        };
+    }
+
+    static ComposableNode WrapClickable(ComposableNode child, Action onClick)
+    {
+        // Box facade is parameterless; the wrapper carries the
+        // Clickable modifier (which Compose merges into pointer-input
+        // and accessibility semantics) plus FillMaxWidth so the whole
+        // row receives taps, not just the slot the inner content
+        // happens to fill. Compose's default Clickable applies the
+        // platform ripple via `indication = LocalIndication.current`.
+        // Object-init + collection-init can't be mixed in one
+        // initializer, so build the Box then Add the child explicitly.
+        var box = new Box
+        {
+            Modifier = Modifier.Companion.FillMaxWidth().Clickable(onClick),
+        };
+        box.Add(child);
+        return box;
+    }
+
+    static void OnItemTapped(MauiCollectionView view, object item)
+    {
+        switch (view.SelectionMode)
+        {
+            case Microsoft.Maui.Controls.SelectionMode.Single:
+                // MAUI's SelectedItem two-way binding + SelectionChanged
+                // event fire from the BindableProperty setter, so a plain
+                // assignment is enough. No feedback-loop guard is needed
+                // because we're not reading SelectedItem inside BuildNode
+                // — clicks are pure write-throughs into MAUI.
+                view.SelectedItem = item;
+                break;
+
+            case Microsoft.Maui.Controls.SelectionMode.Multiple:
+                // Toggle membership. The SelectedItems list is a
+                // `MarshalingObservableCollection` under the hood;
+                // mutating it raises CollectionChanged which MAUI
+                // wires into SelectionChanged.
+                var selected = view.SelectedItems;
+                if (selected is null)
+                    return;
+                if (selected.Contains(item))
+                    selected.Remove(item);
+                else
+                    selected.Add(item);
+                break;
+
+            // SelectionMode.None never reaches this method because the
+            // Clickable wrapper is suppressed in BuildNode.
+        }
+    }
+}
diff --git a/src/Microsoft.AndroidX.Compose.Maui/Hosting/AppHostBuilderExtensions.cs b/src/Microsoft.AndroidX.Compose.Maui/Hosting/AppHostBuilderExtensions.cs
index 4d224bf8..9c7f89ae 100644
--- a/src/Microsoft.AndroidX.Compose.Maui/Hosting/AppHostBuilderExtensions.cs
+++ b/src/Microsoft.AndroidX.Compose.Maui/Hosting/AppHostBuilderExtensions.cs
@@ -5,6 +5,7 @@
 using MauiBoxView = Microsoft.Maui.Controls.BoxView;
 using MauiButton = Microsoft.Maui.Controls.Button;
 using MauiCheckBox = Microsoft.Maui.Controls.CheckBox;
+using MauiCollectionView = Microsoft.Maui.Controls.CollectionView;
 using MauiContentView = Microsoft.Maui.Controls.ContentView;
 using MauiDatePicker = Microsoft.Maui.Controls.DatePicker;
 using MauiEditor = Microsoft.Maui.Controls.Editor;
@@ -83,6 +84,19 @@ public static class AppHostBuilderExtensions
     ///     <see cref="MauiIndicatorView"/> synthesises a Compose
     ///     <c>Row</c> of dot tiles. CarouselView ↔ IndicatorView
     ///     two-way wiring lands in Phase 3.</description></item>
+    ///   <item><description>Lists
+    ///     (<see cref="MauiCollectionView"/>):
+    ///     <see cref="CollectionViewHandler"/> folds the list into the
+    ///     page composition as a Compose <see cref="LazyColumn{T}"/>,
+    ///     <see cref="LazyRow{T}"/>, or <see cref="LazyVerticalGrid{T}"/>
+    ///     (chosen by
+    ///     <see cref="Microsoft.Maui.Controls.StructuredItemsView.ItemsLayout"/>)
+    ///     instead of MAUI's stock <c>RecyclerView</c>-per-cell-island
+    ///     pattern. Each item template is materialised through
+    ///     <see cref="ComposeWalker"/>, so Compose-folded leaves inside
+    ///     cells inherit the page's <c>MaterialTheme</c> and snapshot
+    ///     graph. Selection / <c>ScrollTo</c> / grouping / sticky
+    ///     headers are follow-up slices.</description></item>
     ///   <item><description><see cref="MauiNavigationPage"/> →
     ///     <see cref="NavigationPageHandler"/> renders the stack
     ///     through Material 3 <see cref="Scaffold"/> +
@@ -183,6 +197,12 @@ public static MauiAppBuilder UseAndroidXCompose(this MauiAppBuilder builder)
             handlers.AddHandler<MauiRefreshView,            RefreshViewHandler>();
             handlers.AddHandler<MauiIndicatorView,          IndicatorViewHandler>();
 
+            // Phase 3 Slice 1 — CollectionView folded into the page
+            // composition as LazyColumn / LazyRow / LazyVerticalGrid
+            // (dispatched by ItemsLayout) instead of the stock
+            // per-cell ComposeView island.
+            handlers.AddHandler<MauiCollectionView,         CollectionViewHandler>();
+
             // Phase 4 Slice 1 — stack navigation. Replaces stock
             // NavigationViewHandler (which hosts pushed pages in
             // fragments under FragmentContainerView + AppCompat
diff --git a/src/Microsoft.AndroidX.Compose/LazyColumn.cs b/src/Microsoft.AndroidX.Compose/LazyColumn.cs
index 96cda98c..67096de5 100644
--- a/src/Microsoft.AndroidX.Compose/LazyColumn.cs
+++ b/src/Microsoft.AndroidX.Compose/LazyColumn.cs
@@ -2,6 +2,7 @@
 using AndroidX.Compose.Foundation.Lazy;
 using AndroidX.Compose.Foundation.Layout;
 using AndroidX.Compose.Runtime;
+using BindingArrangement = AndroidX.Compose.Foundation.Layout.Arrangement;
 
 namespace AndroidX.Compose;
 
@@ -81,6 +82,16 @@ public LazyColumn(IReadOnlyList<T> items, Func<T, ComposableNode> itemContent)
     /// </summary>
     public PaddingValues? ContentPadding { get; set; }
 
+    /// <summary>
+    /// Optional vertical arrangement (e.g. <see cref="Arrangement.SpacedBy(int)"/>)
+    /// applied between items. Leave <see langword="null"/> to use Compose's
+    /// default (<c>Arrangement.Top</c>). Must wrap a vertical-capable
+    /// Compose <see cref="Arrangement"/>; throws
+    /// <see cref="ArgumentException"/> at render time for a
+    /// horizontal-only value (e.g. <see cref="Arrangement.Start"/>).
+    /// </summary>
+    public Arrangement? VerticalArrangement { get; set; }
+
     /// <summary>
     /// When a parent layout (typically <see cref="Scaffold"/>) hands us
     /// a runtime <c>PaddingValues</c>, route it into LazyColumn's own
@@ -145,10 +156,22 @@ public override void Render(IComposer composer)
 
         var contentPadding = ContentPadding?.Jvm ?? _runtimeContentPadding;
 
+        BindingArrangement.IVertical? vertical = null;
+        if (VerticalArrangement is not null)
+        {
+            vertical = VerticalArrangement.Vertical
+                ?? throw new ArgumentException(
+                    $"{nameof(VerticalArrangement)} must wrap a vertical " +
+                    $"or horizontal-or-vertical Compose Arrangement; got a " +
+                    $"horizontal-only value (e.g. Arrangement.Start / Arrangement.End).",
+                    nameof(VerticalArrangement));
+        }
+
         int defaults = (int)LazyColumnDefault.All;
         if (modifier       is not null) defaults &= ~(int)LazyColumnDefault.Modifier;
         if (State          is not null) defaults &= ~(int)LazyColumnDefault.State;
         if (contentPadding is not null) defaults &= ~(int)LazyColumnDefault.ContentPadding;
+        if (vertical       is not null) defaults &= ~(int)LazyColumnDefault.VerticalArrangement;
         // Bool params lower to a single $default bit. Kotlin's default
         // is false, so only clear the bit when the caller asked for
         // true — otherwise let Kotlin substitute its own false and
@@ -160,7 +183,7 @@ public override void Render(IComposer composer)
             state:               State?.Jvm,
             contentPadding:      contentPadding,
             reverseLayout:       ReverseLayout,
-            verticalArrangement: null,
+            verticalArrangement: vertical,
             horizontalAlignment: null,
             flingBehavior:       null,
             userScrollEnabled:   true,
diff --git a/src/Microsoft.AndroidX.Compose/LazyVerticalGrid.cs b/src/Microsoft.AndroidX.Compose/LazyVerticalGrid.cs
index efbaa365..75e3c2dc 100644
--- a/src/Microsoft.AndroidX.Compose/LazyVerticalGrid.cs
+++ b/src/Microsoft.AndroidX.Compose/LazyVerticalGrid.cs
@@ -1,5 +1,6 @@
 using AndroidX.Compose.Foundation.Lazy.Grid;
 using AndroidX.Compose.Runtime;
+using BindingArrangement = AndroidX.Compose.Foundation.Layout.Arrangement;
 
 namespace AndroidX.Compose;
 
@@ -45,6 +46,24 @@ public LazyVerticalGrid(IGridCells columns, IReadOnlyList<T> items, Func<T, Comp
     /// </summary>
     public PaddingValues? ContentPadding { get; set; }
 
+    /// <summary>
+    /// Optional vertical arrangement (e.g. <see cref="Arrangement.SpacedBy(int)"/>)
+    /// applied between grid rows. Leave <see langword="null"/> to use Compose's
+    /// default (<c>Arrangement.Top</c>). Must wrap a vertical-capable Compose
+    /// <see cref="Arrangement"/>; throws <see cref="ArgumentException"/> at
+    /// render time for a horizontal-only value.
+    /// </summary>
+    public Arrangement? VerticalArrangement { get; set; }
+
+    /// <summary>
+    /// Optional horizontal arrangement (e.g. <see cref="Arrangement.SpacedBy(int)"/>)
+    /// applied between grid columns. Leave <see langword="null"/> to use
+    /// Compose's default (<c>Arrangement.Start</c>). Must wrap a
+    /// horizontal-capable Compose <see cref="Arrangement"/>; throws
+    /// <see cref="ArgumentException"/> at render time for a vertical-only value.
+    /// </summary>
+    public Arrangement? HorizontalArrangement { get; set; }
+
     public override void Render(IComposer composer)
     {
         var modifier = BuildModifier();
@@ -71,6 +90,30 @@ public override void Render(IComposer composer)
         if (State          is not null) defaults &= ~(int)LazyVerticalGridDefault.State;
         if (ContentPadding is not null) defaults &= ~(int)LazyVerticalGridDefault.ContentPadding;
 
+        BindingArrangement.IVertical? vertical = null;
+        if (VerticalArrangement is not null)
+        {
+            vertical = VerticalArrangement.Vertical
+                ?? throw new ArgumentException(
+                    $"{nameof(VerticalArrangement)} must wrap a vertical " +
+                    $"or horizontal-or-vertical Compose Arrangement; got a " +
+                    $"horizontal-only value (e.g. Arrangement.Start / Arrangement.End).",
+                    nameof(VerticalArrangement));
+            defaults &= ~(int)LazyVerticalGridDefault.VerticalArrangement;
+        }
+
+        BindingArrangement.IHorizontal? horizontal = null;
+        if (HorizontalArrangement is not null)
+        {
+            horizontal = HorizontalArrangement.Horizontal
+                ?? throw new ArgumentException(
+                    $"{nameof(HorizontalArrangement)} must wrap a horizontal " +
+                    $"or horizontal-or-vertical Compose Arrangement; got a " +
+                    $"vertical-only value (e.g. Arrangement.Top / Arrangement.Bottom).",
+                    nameof(HorizontalArrangement));
+            defaults &= ~(int)LazyVerticalGridDefault.HorizontalArrangement;
+        }
+
         // 11 user params → Compose splits $changed into two ints
         // (p12, _changed) and $default lives in the trailing _changed1.
         LazyGridDslKt.LazyVerticalGrid(
@@ -79,8 +122,8 @@ public override void Render(IComposer composer)
             state:                 State,
             contentPadding:        ContentPadding?.Jvm,
             reverseLayout:         false,
-            verticalArrangement:   null,
-            horizontalArrangement: null,
+            verticalArrangement:   vertical,
+            horizontalArrangement: horizontal,
             flingBehavior:         null,
             userScrollEnabled:     true,
             overscrollEffect:      null,
diff --git a/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt b/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt
index 4e5cd21d..a06060d8 100644
--- a/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt
+++ b/src/Microsoft.AndroidX.Compose/PublicAPI.Unshipped.txt
@@ -603,6 +603,8 @@ AndroidX.Compose.LazyColumn<T>.ReverseLayout.get -> bool
 AndroidX.Compose.LazyColumn<T>.ReverseLayout.set -> void
 AndroidX.Compose.LazyColumn<T>.State.get -> AndroidX.Compose.LazyListState?
 AndroidX.Compose.LazyColumn<T>.State.set -> void
+AndroidX.Compose.LazyColumn<T>.VerticalArrangement.get -> AndroidX.Compose.Arrangement?
+AndroidX.Compose.LazyColumn<T>.VerticalArrangement.set -> void
 AndroidX.Compose.LazyHorizontalGrid<T>
 AndroidX.Compose.LazyHorizontalGrid<T>.ContentPadding.get -> AndroidX.Compose.PaddingValues?
 AndroidX.Compose.LazyHorizontalGrid<T>.ContentPadding.set -> void
@@ -638,8 +640,12 @@ AndroidX.Compose.LazyVerticalGrid<T>
 AndroidX.Compose.LazyVerticalGrid<T>.ContentPadding.get -> AndroidX.Compose.PaddingValues?
 AndroidX.Compose.LazyVerticalGrid<T>.ContentPadding.set -> void
 AndroidX.Compose.LazyVerticalGrid<T>.LazyVerticalGrid(AndroidX.Compose.Foundation.Lazy.Grid.IGridCells! columns, System.Collections.Generic.IReadOnlyList<T>! items, System.Func<T, AndroidX.Compose.ComposableNode!>! itemContent) -> void
+AndroidX.Compose.LazyVerticalGrid<T>.HorizontalArrangement.get -> AndroidX.Compose.Arrangement?
+AndroidX.Compose.LazyVerticalGrid<T>.HorizontalArrangement.set -> void
 AndroidX.Compose.LazyVerticalGrid<T>.State.get -> AndroidX.Compose.Foundation.Lazy.Grid.LazyGridState?
 AndroidX.Compose.LazyVerticalGrid<T>.State.set -> void
+AndroidX.Compose.LazyVerticalGrid<T>.VerticalArrangement.get -> AndroidX.Compose.Arrangement?
+AndroidX.Compose.LazyVerticalGrid<T>.VerticalArrangement.set -> void
 AndroidX.Compose.LazyVerticalStaggeredGrid<T>
 AndroidX.Compose.LazyVerticalStaggeredGrid<T>.ContentPadding.get -> AndroidX.Compose.PaddingValues?
 AndroidX.Compose.LazyVerticalStaggeredGrid<T>.ContentPadding.set -> void