AOT batch: nav POCO state, DataGrid DAM, ArrayOps runtime gate

Three independent AOT compatibility improvements from issue #70:

1. NavigationHandle no longer dictates serialization. GetState() returns
   a new public NavigationState<TRoute> record; SetState takes that record.
   Apps pick their own serializer (JSON via JsonSerializerContext, MessagePack,
   binary, etc.). Removes the IL2026/IL3050 suppressions that were on
   GetState/SetState and drops System.Text.Json from the framework call site.

2. DataGrid<T> propagates [DynamicallyAccessedMembers(PublicProperties |
   PublicConstructors)] from the column-discovery code (AutoColumns<T>) up
   through DataGridElement<T>, DataGridComponent<T>, both factory overloads,
   and SelectionChanged<T>. The blanket #pragma warning disable IL2091 is
   gone — the analyzer is satisfied without suppression.

3. ArrayOperations.Add / RemoveAt: replace [RequiresDynamicCode] with a
   RuntimeFeature.IsDynamicCodeSupported check around Array.CreateInstance,
   plus a focused [UnconditionalSuppressMessage(""AOT"", ""IL3050"")]. The
   List<T>/ObservableCollection<T> path is now fully AOT-safe; the rare
   T[] path throws NotSupportedException only when actually exercised
   under native AOT.

Tests / samples / docs updated to teach the POCO + JsonSerializerContext
pattern. NavigationDemo's AppRoute gains [JsonPolymorphic] /
[JsonDerivedType] so polymorphic state round-trips correctly.

Build: 0 errors, 0 warnings.
Reactor.Tests: 8130 passed, 46 skipped, 0 failed.
Reactor.SelfTests: 735 passed, 0 failed.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: codemonkeychris

docs/_pipeline/ai-author-skill.md

@@ -562,7 +562,7 @@ class MyComponent : Component<MyProps>
 `.CanGoForward`, `.ForwardStack`, `.GoForward()` — forward navigation,
 `.PopTo(predicate)` — pop until matching route,
 `.Navigate(route, NavigateOptions)` — with transition override and `PushToBackStack` flag,
-`.GetState(options?)` / `.SetState(json)` — serialize/restore full nav state.
+`.GetState()` / `.SetState(state)` — capture/restore full nav state as a `NavigationState<TRoute>` POCO (serialize externally — e.g. `JsonSerializer.Serialize(snapshot, MyJsonContext.Default.NavigationStateRoute)`).
 
 **Validation & forms:**
 

docs/_pipeline/apps/navigation/App.cs

@@ -243,29 +243,37 @@ class StateSerializationDemo : Component
     public override Element Render()
     {
         var nav = UseNavigation(Route.Home);
-        var (savedState, setSavedState) = UseState<string?>(null);
+        var (savedJson, setSavedJson) = UseState<string?>(null);
 
         return VStack(12,
             SubHeading("State Serialization"),
             HStack(8,
                 Button("Navigate", () =>
                     nav.Navigate(Route.Settings)),
                 Button("Save State", () =>
-                    setSavedState(nav.GetState())),
+                    setSavedJson(System.Text.Json.JsonSerializer.Serialize(
+                        nav.GetState(), DocsNavJsonContext.Default.NavigationStateRoute))),
                 Button("Restore State", () =>
                 {
-                    if (savedState is not null)
-                        nav.SetState(savedState);
-                }).IsEnabled(!(savedState is null))
+                    if (savedJson is not null)
+                    {
+                        var state = System.Text.Json.JsonSerializer.Deserialize(
+                            savedJson, DocsNavJsonContext.Default.NavigationStateRoute);
+                        if (state is not null) nav.SetState(state);
+                    }
+                }).IsEnabled(savedJson is not null)
             ),
             TextBlock($"Current: {nav.CurrentRoute}"),
-            TextBlock($"Saved: {savedState?[..Math.Min(50, savedState?.Length ?? 0)] ?? "(none)"}")
+            TextBlock($"Saved: {savedJson?[..Math.Min(50, savedJson?.Length ?? 0)] ?? "(none)"}")
                 .FontSize(12).Opacity(0.6),
             NavigationHost(nav, route =>
                 TextBlock($"Page: {route}").Padding(16))
         ).Padding(24);
     }
 }
+
+[System.Text.Json.Serialization.JsonSerializable(typeof(NavigationState<Route>))]
+partial class DocsNavJsonContext : System.Text.Json.Serialization.JsonSerializerContext { }
 // </snippet:state-serialization>
 
 // <snippet:diagnostics>

docs/_pipeline/templates/navigation.md.dt

@@ -149,7 +149,7 @@ async cancellation.
 <!-- ai:caveat -->
 `Reset(route)`, `Replace(route)`, and `PopTo(predicate)` all run the
 `onNavigatingFrom` guard — `ctx.Cancel()` will block them. But
-`SetState(json)` does **not**: it routes through `NavigationStack.RestoreState`
+`SetState(state)` does **not**: it routes through `NavigationStack.RestoreState`
 which bypasses `InvokeGuard` entirely and fires `Navigated` with
 `NavigationMode.Reset` after the stacks are already rewritten. If your
 unsaved-changes guard lives only in `onNavigatingFrom`, an app that
@@ -254,20 +254,25 @@ Use tabs when users need to switch freely between parallel workspaces.
 
 ## State Serialization
 
-`NavigationHandle` can serialize and restore the full navigation state —
-back stack, current route, and forward stack — as JSON. Use this to persist
-navigation state across app restarts or to restore deep-linked sessions:
+`NavigationHandle` can capture and restore the full navigation state —
+back stack, current route, and forward stack — as a plain
+`NavigationState<TRoute>` snapshot. Reactor intentionally does **not**
+pick a serialization format: persist the snapshot however you like
+(JSON via your own source-gen context, MessagePack, hand-rolled binary).
 
 ```csharp snippet="navigation/state-serialization"
 ```
 
 ![State serialization](screenshot://navigation/state-serialization)
 
-`GetState()` returns a JSON string. `SetState(json)` restores the stacks
-and fires `Navigated` with `Reset` mode. Pass `JsonSerializerOptions` if
-your route type needs custom serialization. For polymorphic route
-hierarchies, mark the base type with `[JsonPolymorphic]` and
-`[JsonDerivedType]` so the round trip preserves the discriminator.
+`GetState()` returns a `NavigationState<TRoute>` record. `SetState(state)`
+restores the stacks and fires `Navigated` with `Reset` mode. The record
+carries `[JsonPropertyName]` metadata so a one-line
+`JsonSerializer.Serialize(snapshot, MyJsonContext.Default.NavigationStateRoute)`
+gives you camelCase JSON for free — fully AOT-safe when paired with a
+`JsonSerializerContext`. For polymorphic route hierarchies, mark the base
+type with `[JsonPolymorphic]` and `[JsonDerivedType]` so the round trip
+preserves the discriminator.
 
 ## Frame Events
 

docs/guide/navigation.md

@@ -243,7 +243,7 @@ async cancellation.
 
 > **Caveat:** `Reset(route)`, `Replace(route)`, and `PopTo(predicate)` all run the
 > `onNavigatingFrom` guard — `ctx.Cancel()` will block them. But
-> `SetState(json)` does **not**: it routes through `NavigationStack.RestoreState`
+> `SetState(state)` does **not**: it routes through `NavigationStack.RestoreState`
 > which bypasses `InvokeGuard` entirely and fires `Navigated` with
 > `NavigationMode.Reset` after the stacks are already rewritten. If your
 > unsaved-changes guard lives only in `onNavigatingFrom`, an app that
@@ -491,48 +491,61 @@ Use tabs when users need to switch freely between parallel workspaces.
 
 ## State Serialization
 
-`NavigationHandle` can serialize and restore the full navigation state —
-back stack, current route, and forward stack — as JSON. Use this to persist
-navigation state across app restarts or to restore deep-linked sessions:
+`NavigationHandle` can capture and restore the full navigation state —
+back stack, current route, and forward stack — as a plain
+`NavigationState<TRoute>` snapshot. Reactor intentionally does **not**
+pick a serialization format: persist the snapshot however you like
+(JSON via your own source-gen context, MessagePack, hand-rolled binary).
 
 ```csharp
 class StateSerializationDemo : Component
 {
     public override Element Render()
     {
         var nav = UseNavigation(Route.Home);
-        var (savedState, setSavedState) = UseState<string?>(null);
+        var (savedJson, setSavedJson) = UseState<string?>(null);
 
         return VStack(12,
             SubHeading("State Serialization"),
             HStack(8,
                 Button("Navigate", () =>
                     nav.Navigate(Route.Settings)),
                 Button("Save State", () =>
-                    setSavedState(nav.GetState())),
+                    setSavedJson(System.Text.Json.JsonSerializer.Serialize(
+                        nav.GetState(), DocsNavJsonContext.Default.NavigationStateRoute))),
                 Button("Restore State", () =>
                 {
-                    if (savedState is not null)
-                        nav.SetState(savedState);
-                }).IsEnabled(!(savedState is null))
+                    if (savedJson is not null)
+                    {
+                        var state = System.Text.Json.JsonSerializer.Deserialize(
+                            savedJson, DocsNavJsonContext.Default.NavigationStateRoute);
+                        if (state is not null) nav.SetState(state);
+                    }
+                }).IsEnabled(savedJson is not null)
             ),
             TextBlock($"Current: {nav.CurrentRoute}"),
-            TextBlock($"Saved: {savedState?[..Math.Min(50, savedState?.Length ?? 0)] ?? "(none)"}")
+            TextBlock($"Saved: {savedJson?[..Math.Min(50, savedJson?.Length ?? 0)] ?? "(none)"}")
                 .FontSize(12).Opacity(0.6),
             NavigationHost(nav, route =>
                 TextBlock($"Page: {route}").Padding(16))
         ).Padding(24);
     }
 }
+
+[System.Text.Json.Serialization.JsonSerializable(typeof(NavigationState<Route>))]
+partial class DocsNavJsonContext : System.Text.Json.Serialization.JsonSerializerContext { }
 ```
 
 ![State serialization](images/navigation/state-serialization.png)
 
-`GetState()` returns a JSON string. `SetState(json)` restores the stacks
-and fires `Navigated` with `Reset` mode. Pass `JsonSerializerOptions` if
-your route type needs custom serialization. For polymorphic route
-hierarchies, mark the base type with `[JsonPolymorphic]` and
-`[JsonDerivedType]` so the round trip preserves the discriminator.
+`GetState()` returns a `NavigationState<TRoute>` record. `SetState(state)`
+restores the stacks and fires `Navigated` with `Reset` mode. The record
+carries `[JsonPropertyName]` metadata so a one-line
+`JsonSerializer.Serialize(snapshot, MyJsonContext.Default.NavigationStateRoute)`
+gives you camelCase JSON for free — fully AOT-safe when paired with a
+`JsonSerializerContext`. For polymorphic route hierarchies, mark the base
+type with `[JsonPolymorphic]` and `[JsonDerivedType]` so the round trip
+preserves the discriminator.
 
 ## Frame Events
 

docs/specs/011-navigation-design.md

@@ -1010,18 +1010,20 @@ restored on relaunch.
 #### API
 
 ```csharp
-// Save
-string json = nav.GetState();
-// json: {"backStack":[{"$type":"Home"},{"$type":"Detail","Id":42}],
-//        "current":{"$type":"Settings"},
+// Save (caller picks the storage format)
+NavigationState<AppRoute> state = nav.GetState();
+string json = JsonSerializer.Serialize(state, AppJsonContext.Default.NavigationStateAppRoute);
+// json: {"backStack":[{"$type":"home"},{"$type":"detail","Id":42}],
+//        "current":{"$type":"settings"},
 //        "forwardStack":[]}
 
 ApplicationData.Current.LocalSettings.Values["nav_state"] = json;
 
 // Restore
 if (ApplicationData.Current.LocalSettings.Values.TryGetValue("nav_state", out var saved))
 {
-    nav.SetState((string)saved);
+    var restored = JsonSerializer.Deserialize((string)saved, AppJsonContext.Default.NavigationStateAppRoute);
+    if (restored is not null) nav.SetState(restored);
 }
 ```
 

plugins/reactor/skills/reactor-navigation/SKILL.md

@@ -233,8 +233,21 @@ Caching preserves scroll position, text input, and component state.
 ## 10. State serialization
 
 ```csharp
-var json = nav.GetState();          // serialize full nav state
-nav.SetState(json);                 // restore stacks + navigate
+var state = nav.GetState();         // NavigationState<TRoute> snapshot
+nav.SetState(state);                // restore stacks + fire Navigated(Reset)
+```
+
+Reactor returns a plain `NavigationState<TRoute>` POCO and lets you pick the
+storage format. For JSON persistence pair the snapshot with a
+`JsonSerializerContext` (AOT-safe):
+
+```csharp
+[JsonSerializable(typeof(NavigationState<AppRoute>))]
+partial class AppJsonContext : JsonSerializerContext { }
+
+var json = JsonSerializer.Serialize(nav.GetState(), AppJsonContext.Default.NavigationStateAppRoute);
+// later…
+nav.SetState(JsonSerializer.Deserialize(json, AppJsonContext.Default.NavigationStateAppRoute)!);
 ```
 
 Use for persisting navigation across app restarts.

samples/NavigationDemo/App.cs

@@ -61,6 +61,13 @@ static class AuthState
 
 // ─── Route types ──────────────────────────────────────────────────────────────
 
+[System.Text.Json.Serialization.JsonPolymorphic(TypeDiscriminatorPropertyName = "$type")]
+[System.Text.Json.Serialization.JsonDerivedType(typeof(Home), "home")]
+[System.Text.Json.Serialization.JsonDerivedType(typeof(Detail), "detail")]
+[System.Text.Json.Serialization.JsonDerivedType(typeof(Settings), "settings")]
+[System.Text.Json.Serialization.JsonDerivedType(typeof(Profile), "profile")]
+[System.Text.Json.Serialization.JsonDerivedType(typeof(DocsPage), "docs")]
+[System.Text.Json.Serialization.JsonDerivedType(typeof(AdminPage), "admin")]
 abstract record AppRoute;
 sealed record Home : AppRoute;
 sealed record Detail(int Id, string Tab = "overview") : AppRoute;
@@ -69,6 +76,10 @@ sealed record Profile(string Name) : AppRoute;
 sealed record DocsPage(string Path) : AppRoute;
 sealed record AdminPage : AppRoute;
 
+// App-side source-gen context for AOT-safe JSON persistence of nav state.
+[System.Text.Json.Serialization.JsonSerializable(typeof(NavigationState<AppRoute>))]
+partial class NavDemoJsonContext : System.Text.Json.Serialization.JsonSerializerContext { }
+
 // Settings sub-routes for nested navigation
 abstract record SettingsRoute;
 sealed record GeneralSettings : SettingsRoute;
@@ -629,11 +640,14 @@ public override Element Render()
 
                 // Serialization demo
                 SubHeading("State Serialization").Margin(0, 24, 0, 0),
-                TextBlock("Save and restore the entire navigation stack as JSON."),
+                TextBlock("Save and restore the entire navigation stack. GetState/SetState " +
+                          "return a plain POCO; persist it however you like (here we use System.Text.Json)."),
                 HStack(8,
                     Button("Save State", () =>
                     {
-                        var json = nav.GetState();
+                        var snapshot = nav.GetState();
+                        var json = System.Text.Json.JsonSerializer.Serialize(
+                            snapshot, NavDemoJsonContext.Default.NavigationStateAppRoute);
                         Debug.WriteLine($"Navigation state: {json}");
                     }),
                     Button("Log Stack Info", () =>

skills/navigation.md

@@ -233,8 +233,21 @@ Caching preserves scroll position, text input, and component state.
 ## 10. State serialization
 
 ```csharp
-var json = nav.GetState();          // serialize full nav state
-nav.SetState(json);                 // restore stacks + navigate
+var state = nav.GetState();         // NavigationState<TRoute> snapshot
+nav.SetState(state);                // restore stacks + fire Navigated(Reset)
+```
+
+Reactor returns a plain `NavigationState<TRoute>` POCO and lets you pick the
+storage format. For JSON persistence pair the snapshot with a
+`JsonSerializerContext` (AOT-safe):
+
+```csharp
+[JsonSerializable(typeof(NavigationState<AppRoute>))]
+partial class AppJsonContext : JsonSerializerContext { }
+
+var json = JsonSerializer.Serialize(nav.GetState(), AppJsonContext.Default.NavigationStateAppRoute);
+// later…
+nav.SetState(JsonSerializer.Deserialize(json, AppJsonContext.Default.NavigationStateAppRoute)!);
 ```
 
 Use for persisting navigation across app restarts.

src/Reactor/Controls/DataGrid/DataGridComponent.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.UI.Reactor.Core;
 using Microsoft.UI.Reactor.Data;
 using Microsoft.UI.Reactor.Hooks;
@@ -24,7 +25,7 @@ namespace Microsoft.UI.Reactor.Controls;
 /// callback, same item count), and the Reactor reconciler only updates the cells whose
 /// output changed — as property updates on existing controls, not collection changes.
 /// </summary>
-public class DataGridComponent<T> : Component<DataGridElement<T>>
+public class DataGridComponent<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicConstructors)] T> : Component<DataGridElement<T>>
 {
     /// <summary>
     /// Input to the row-commit mutation. Bundles the row key, the post-edit item
@@ -45,9 +46,7 @@ public override Element Render()
         // affecting CellRenderers). Auto-columns are cached by UseMemo.
         var columns = el.Columns is not null
             ? el.Columns
-#pragma warning disable IL2091 // Generic type parameter flows through without DynamicallyAccessedMembers annotation
             : UseMemo(() => Factories.AutoColumns<T>(registry, el.ColumnOverrides));
-#pragma warning restore IL2091
 
         // Create the headless state machine once and hold it in a ref.
         var stateRef = UseRef<DataGridState<T>>(null!);

src/Reactor/Controls/DataGrid/DataGridElement.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.UI.Reactor.Core;
 using Microsoft.UI.Reactor.Data;
 using Microsoft.UI.Reactor.Controls;
@@ -8,7 +9,7 @@ namespace Microsoft.UI.Reactor.Controls;
 /// Element record for the DataGrid component.
 /// Defines the full API surface for data grid rendering and interaction.
 /// </summary>
-public record DataGridElement<T> : Element
+public record DataGridElement<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicConstructors)] T> : Element
 {
     /// <summary>The data source providing rows.</summary>
     public required IDataSource<T> Source { get; init; }