spec(047): Phase 3-final Batch F — Image events + Path.Data + InfoBar.ActionButton

Three more descriptor-surface ports. ImageDescriptor adds ImageOpened/ImageFailed via .HandCodedEvent over the existing ImageEventPayload (event entries declared before Source .OneWay so subscriptions land before the cached-image synchronous fire). PathDescriptor adds the pre-built Geometry Data path as .OneWayConditional (reference comparer, gated on PathDataString being null so the legacy XamlReader/parser path stays the single owner for that surface) plus FillRule propagation onto PathGeometry. InfoBarDescriptor adds ActionButton as .OneWayBridged<string?> that builds the inner Button and wires Click via a static-trampoline reading the parent InfoBar's Tag — record-with that swaps OnActionButtonClick picks up automatically.

Shipped:
- Image: ImageOpened + ImageFailed .HandCodedEvent entries (live-element via Tag)
- Path: Data .OneWayConditional + FillRule .OneWayConditional onto PathGeometry
- InfoBar: ActionButton .OneWayBridged with Click trampoline

Carved to Phase 4:
- Expander.HeaderTemplate: requires a NamedSlots strategy, conflicts with the existing SingleContent Children — only one Children strategy per descriptor today.
- TeachingTip.Target: cross-element reference resolution (Target points at a sibling's mounted control); descriptor framework can't reference another element's resolved native control.
- Path.PathDataString: legacy XamlReader + PathDataParser strategies need string-diff-against-old-element comparer and old+new+xaml+parser error context the engine's per-prop comparer can't replicate.
- Icon polymorphic: already done in existing descriptors (InfoBar/TeachingTip/AutoSuggestBox/SelectorBar use Reconciler.ResolveIconSource / ResolveIconForDescriptor).

V1 ON: 511 ok / 0 failures
V1 OFF: 511 ok / 0 failures

Author: codemonkeychris

src/Reactor/Core/V1Protocol/Descriptor/Descriptors/ImageDescriptor.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Media.Imaging;
 using WinUI = Microsoft.UI.Xaml.Controls;
 
@@ -12,40 +13,64 @@ namespace Microsoft.UI.Reactor.Core.V1Protocol.Descriptor.Descriptors;
 /// <para><b>Coverage:</b> a display leaf with a single complex prop
 /// (<c>Source</c> — string parsed to <see cref="Uri"/>, then to either
 /// <see cref="BitmapImage"/> or <see cref="SvgImageSource"/>) plus three
-/// optional layout props.</para>
+/// optional layout props, plus <c>ImageOpened</c> / <c>ImageFailed</c> as
+/// fire-only <see cref="ControlDescriptor{TElement,TControl}.HandCodedEvent{TPayload,TDelegate}"/>
+/// entries (Phase 3-final Batch F).</para>
 ///
-/// <para><b>Phase 1 parity note:</b> the legacy arm threads the element
-/// through <c>EnsureImageWiring</c> trampolines so <c>ImageOpened</c> /
-/// <c>ImageFailed</c> can route back to the element callbacks. The
-/// descriptor relies on the V1 handler adapter to set the element tag (it
-/// already does before invoking the descriptor) — but the descriptor never
-/// calls <c>EnsureImageWiring</c>, so <c>ImageOpened</c> /
-/// <c>ImageFailed</c> events ARE NOT fired by the descriptor path.</para>
+/// <para><b>Behavior parity vs. legacy:</b> the legacy <c>MountImage</c> arm
+/// threads the element through <c>EnsureImageWiring</c> trampolines so
+/// <c>ImageOpened</c>/<c>ImageFailed</c> route back to the element
+/// callbacks. The descriptor reuses <see cref="ImageEventPayload"/> with the
+/// established slot-gating shape; trampolines read the live element via
+/// <see cref="Reconciler.GetElementTag"/> and fire the corresponding
+/// callback only when it's wired — mirrors the
+/// "always subscribe, read latest callback per fire" pattern.</para>
 ///
-/// <para><b>Known gaps vs. hand-coded handler:</b>
+/// <para><b>Known nuances vs. hand-coded handler:</b>
 /// <list type="bullet">
-///   <item><b><c>OnImageOpened</c> / <c>OnImageFailed</c> callbacks:</b> not
-///   fired by the descriptor — Batch 3 covers zero-event props only (no
-///   <c>Controlled</c> / <c>HandCoded*</c>). Authors who need image-load
-///   notifications must continue to use the legacy arm (V1-OFF) until the
-///   descriptor is extended.</item>
 ///   <item><b><c>Source</c> diffing:</b> the legacy arm reassigns
 ///   <c>image.Source</c> only when the source string changes
 ///   (<c>o.Source != n.Source</c>). The descriptor's per-prop comparer
 ///   captures the same intent — write happens only when the string differs.</item>
 ///   <item><b>Malformed URI:</b> the legacy <c>MountImage</c> swallows
 ///   <see cref="UriFormatException"/> at construction time. The descriptor
 ///   mirrors this exactly in its <c>set</c> lambda.</item>
+///   <item><b>Mount-time event ordering:</b> the legacy arm wires
+///   ImageOpened/ImageFailed BEFORE assigning Source so a cached-image
+///   synchronous fire still routes. The V1 handler adapter wires
+///   <c>.HandCodedEvent</c> entries in the order the descriptor declares
+///   them — the event entries are declared BEFORE the Source <c>.OneWay</c>
+///   entry below, so the same synchronous-fire path is preserved.</item>
 /// </list></para>
 /// </summary>
 [Experimental("REACTOR_V1_PREVIEW")]
 internal static class ImageDescriptor
 {
+    private static readonly RoutedEventHandler ImageOpenedTrampoline = (s, _) =>
+        (Reconciler.GetElementTag((UIElement)s!) as ImageElement)?.OnImageOpened?.Invoke();
+
+    private static readonly ExceptionRoutedEventHandler ImageFailedTrampoline = (s, args) =>
+        (Reconciler.GetElementTag((UIElement)s!) as ImageElement)?.OnImageFailed?.Invoke(args.ErrorMessage);
+
     public static readonly ControlDescriptor<ImageElement, WinUI.Image> Descriptor =
         new ControlDescriptor<ImageElement, WinUI.Image>
         {
             GetSetters = static e => e.Setters,
         }
+        // Event entries first so subscriptions land BEFORE the Source write
+        // (cached images can synchronously fire ImageOpened during the assign).
+        .HandCodedEvent<ImageEventPayload, RoutedEventHandler>(
+            subscribe:        static (c, h) => c.ImageOpened += h,
+            callbackPresent:  static e => e.OnImageOpened,
+            trampoline:       ImageOpenedTrampoline,
+            slotIsNull:       static p => p.ImageOpenedTrampoline is null,
+            setSlot:          static (p, h) => p.ImageOpenedTrampoline = h)
+        .HandCodedEvent<ImageEventPayload, ExceptionRoutedEventHandler>(
+            subscribe:        static (c, h) => c.ImageFailed += h,
+            callbackPresent:  static e => e.OnImageFailed,
+            trampoline:       ImageFailedTrampoline,
+            slotIsNull:       static p => p.ImageFailedTrampoline is null,
+            setSlot:          static (p, h) => p.ImageFailedTrampoline = h)
         .OneWay(
             get: static e => e.Source,
             set: static (c, v) =>

src/Reactor/Core/V1Protocol/Descriptor/Descriptors/InfoBarDescriptor.cs

@@ -27,17 +27,19 @@ namespace Microsoft.UI.Reactor.Core.V1Protocol.Descriptor.Descriptors;
 ///   <see cref="Reconciler.ResolveIconSource(IconData?)"/>.</item>
 /// </list></para>
 ///
-/// <para><b>Known gaps:</b>
-/// <list type="bullet">
-///   <item><b>ActionButton + <c>OnActionButtonClick</c> is escape-hatched</b>.
-///   The legacy arm constructs an inner <c>Button</c> dynamically when
-///   <c>ActionButtonContent</c> is non-null, then wires <c>Click</c> on
-///   that dynamically-created child. The descriptor framework binds events
-///   to the primary control, not a sub-control created during mount, so
-///   this asymmetric pattern doesn't fit. Authors who need the action
-///   button stay on V1 OFF (legacy arm), or use a <c>.Set</c> imperative
-///   setter to construct the button themselves.</item>
-/// </list></para>
+/// <para><b>ActionButton + <c>OnActionButtonClick</c> (Phase 3-final Batch F):</b>
+/// the legacy arm constructs an inner <c>Button</c> dynamically when
+/// <c>ActionButtonContent</c> is non-null, then wires <c>Click</c> on the
+/// dynamically-created child. The descriptor models this as a
+/// <c>.OneWayBridged&lt;string?&gt;</c> entry whose set lambda creates the
+/// <c>Button</c>, wires <c>Click</c> via a closure over the parent InfoBar
+/// reference (which is rooted by the InfoBar's Tag — Click resolves
+/// <c>OnActionButtonClick</c> through <see cref="Reconciler.GetElementTag"/>
+/// so a record-with that updates the callback picks up automatically). The
+/// gate matches the legacy "set when non-null" treatment: a non-null →
+/// non-null content swap rebuilds the inner button (legacy doesn't rebuild,
+/// but the rebuild is observably the same when the click handler reads the
+/// live element tag).</para>
 /// </summary>
 [Experimental("REACTOR_V1_PREVIEW")]
 internal static class InfoBarDescriptor
@@ -84,6 +86,27 @@ internal static class InfoBarDescriptor
             set:         static (c, v) => c.IconSource = Reconciler.ResolveIconSource(v),
             shouldWrite: static e => e.IconSource is not null,
             comparer:    IconDataReferenceComparer.Instance)
+        // ActionButton (Phase 3-final Batch F). Dynamically construct the inner
+        // Button; Click trampoline reads the live element via GetElementTag so a
+        // later record-with that updates OnActionButtonClick picks up
+        // automatically (Update keeps the InfoBar's Tag fresh).
+        .OneWayBridged<string?>(
+            get:         static e => e.ActionButtonContent,
+            set:         static (c, v, _, _) =>
+            {
+                if (v is null)
+                {
+                    c.ActionButton = null;
+                    return;
+                }
+                var btn = new WinUI.Button { Content = v };
+                var infoBar = c;
+                btn.Click += (_, _) =>
+                    (Reconciler.GetElementTag(infoBar) as InfoBarElement)
+                        ?.OnActionButtonClick?.Invoke();
+                c.ActionButton = btn;
+            },
+            shouldWrite: static e => e.ActionButtonContent is not null)
         .HandCodedEvent<InfoBarEventPayload,
             TypedEventHandler<WinUI.InfoBar, WinUI.InfoBarClosedEventArgs>>(
             subscribe:        static (c, h) => c.Closed += h,

src/Reactor/Core/V1Protocol/Descriptor/Descriptors/PathDescriptor.cs

@@ -1,4 +1,6 @@
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.UI.Xaml.Media;
 using WinShapes = Microsoft.UI.Xaml.Shapes;
 
 namespace Microsoft.UI.Reactor.Core.V1Protocol.Descriptor.Descriptors;
@@ -7,35 +9,37 @@ namespace Microsoft.UI.Reactor.Core.V1Protocol.Descriptor.Descriptors;
 /// Spec 047 §14 Phase 3 (batch 10) — descriptor variant of the hand-coded
 /// <c>MountPath</c> / <c>UpdatePath</c> arms in <see cref="Reconciler"/>.
 ///
-/// <para><b>Coverage:</b> a zero-event shape leaf — styling and stroke props
-/// only. All paint / dash / cap / join / transform props use
-/// <see cref="ControlDescriptor{TElement,TControl}.OneWay"/> or
-/// <see cref="ControlDescriptor{TElement,TControl}.OneWayConditional"/>.</para>
+/// <para><b>Coverage:</b> a zero-event shape leaf — styling and stroke props,
+/// plus the pre-built <see cref="Geometry"/> <c>Data</c> path
+/// (Phase 3-final Batch F). All paint / dash / cap / join / transform props
+/// use <see cref="ControlDescriptor{TElement,TControl}.OneWay"/> or
+/// <see cref="ControlDescriptor{TElement,TControl}.OneWayConditional"/>;
+/// <c>Data</c> uses <c>.OneWayConditional</c> with a reference comparer.</para>
+///
+/// <para><b>Behavior parity vs. legacy:</b> the legacy <c>MountPath</c>
+/// branches between three strategies for <c>Path.Data</c>:
+/// (1) XamlReader-load a constructed <c>&lt;Path Data="..."/&gt;</c> when
+/// <c>PathDataString</c> is set; (2) assign a pre-built
+/// <see cref="Geometry"/> via <c>pa.Data</c> with structured error reporting;
+/// (3) fall back to <c>PathDataParser.Parse</c> for the SVG-string case.
+/// The descriptor ports strategy (2) — the pre-built <see cref="Geometry"/>
+/// path — under the <c>PathDataString is null</c> gate. Authors who use
+/// <c>PathDataString</c> stay on V1 OFF for that string-parse path.</para>
 ///
 /// <para><b>Known gaps vs. hand-coded handler:</b>
 /// <list type="bullet">
-///   <item><b><c>Data</c> / <c>PathDataString</c> is escape-hatched.</b> The
-///   legacy <c>MountPath</c> branches between three strategies to set
-///   <c>Path.Data</c>: (1) XamlReader-load a constructed
-///   <c>&lt;Path Data="..."/&gt;</c> when <c>PathDataString</c> is set
-///   (avoids COM re-parent issues); (2) assign a pre-built
-///   <see cref="Microsoft.UI.Xaml.Media.Geometry"/> via <c>pa.Data</c> with
-///   structured error reporting; (3) fall back to
-///   <c>PathDataParser.Parse</c> for the SVG-string case. <c>UpdatePath</c>
-///   also gates the Data write on <c>PathDataString</c> string-diff (since
-///   parser output never reference-equals). None of these fit a single
-///   <c>OneWay</c> setter — the engine's general per-prop comparer can't
-///   replicate the string-diff-against-old-element trick, and the error
-///   reporting needs both old + new + xaml-text + parser-text context.
-///   Authors who need <c>Path.Data</c> stay on V1 OFF; the descriptor handles
-///   the rest of the surface (Fill / Stroke / dash / cap / join / transform),
-///   which is the bulk of the per-render write pressure for a D3-style
-///   chart.</item>
-///   <item><b><c>FillRule</c> propagation</b> in the legacy handler writes
-///   <c>FillRule</c> onto the inner <see cref="Microsoft.UI.Xaml.Media.PathGeometry"/>
-///   (not the <see cref="WinShapes.Path"/> itself). Since the descriptor
-///   doesn't set Data, the inner PathGeometry is not the descriptor's to
-///   inspect — also escape-hatched.</item>
+///   <item><b><c>PathDataString</c> (the XamlReader / PathDataParser
+///   strategies) is escape-hatched.</b> The engine's general per-prop
+///   comparer can't replicate the string-diff-against-old-element trick that
+///   the legacy <c>UpdatePath</c> uses, and the error reporting needs both
+///   old + new + xaml-text + parser-text context. The descriptor's
+///   <c>Data</c> entry is skipped when <c>PathDataString</c> is non-null so
+///   the legacy arm stays the single source of truth for that path.</item>
+///   <item><b><c>FillRule</c> propagation</b> writes <c>FillRule</c> onto the
+///   inner <see cref="PathGeometry"/> (not the <see cref="WinShapes.Path"/>
+///   itself). The descriptor inspects <c>p.Data</c> after the Data write
+///   and propagates FillRule when it owns a <see cref="PathGeometry"/> —
+///   matches the legacy arm's "set FillRule when we can" treatment.</item>
 /// </list></para>
 /// </summary>
 [Experimental("REACTOR_V1_PREVIEW")]
@@ -46,6 +50,25 @@ internal static class PathDescriptor
         {
             GetSetters = static e => e.Setters,
         }
+        .OneWayConditional(
+            get:         static e => e.Data,
+            set:         static (c, v) => c.Data = v,
+            // Gate: skip when PathDataString owns Data (legacy XamlReader /
+            // PathDataParser strategies — see xmldoc). Also skip when Data is
+            // null so we don't write null on top of a legacy-loaded geometry.
+            shouldWrite: static e => e.PathDataString is null && e.Data is not null,
+            comparer:    GeometryReferenceComparer.Instance)
+        // FillRule propagation onto the inner PathGeometry (only meaningful
+        // when the descriptor wrote a PathGeometry above; non-EvenOdd writes
+        // on a non-PathGeometry are a no-op). Mirrors the legacy arm's
+        // <c>p.Data is PathGeometry pg => pg.FillRule = n.FillRule</c>.
+        .OneWayConditional(
+            get:         static e => e.FillRule,
+            set:         static (c, v) =>
+            {
+                if (c.Data is PathGeometry pg && pg.FillRule != v) pg.FillRule = v;
+            },
+            shouldWrite: static e => e.PathDataString is null && e.Data is PathGeometry)
         .OneWayConditional(
             get:         static e => e.Fill,
             set:         static (c, v) => c.Fill = v,
@@ -83,4 +106,18 @@ internal static class PathDescriptor
         .OneWay(
             get: static e => e.StrokeDashOffset,
             set: static (c, v) => c.StrokeDashOffset = v);
+
+    /// <summary>Reference-identity comparer over <c>Geometry?</c>. The legacy
+    /// <c>UpdatePath</c> arm gates the Data write on string-diff against
+    /// <c>PathDataString</c> (parser output never reference-equals); for the
+    /// pre-built <see cref="Geometry"/> path the descriptor uses reference
+    /// identity, which matches author intent (the Geometry instance is the
+    /// thing being identified).</summary>
+    private sealed class GeometryReferenceComparer : IEqualityComparer<Geometry?>
+    {
+        public static readonly GeometryReferenceComparer Instance = new();
+        public bool Equals(Geometry? x, Geometry? y) => ReferenceEquals(x, y);
+        public int GetHashCode(Geometry obj)
+            => global::System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
+    }
 }