drawnui-react 0.1.0-preview.16 → 0.1.0-preview.18

package/README.md

@@ -27,7 +27,7 @@ await Super.UseDrawnUi()
 ## Install
 
 ```
-npm i drawnui-react@preview react react-dom
+npm i drawnui-react react react-dom
 ```
 
 `drawnui-react` = React tags + every engine type, `drawnui-react/core` = the engine only. Ships ES modules + `.d.ts`;

package/SKIPPED.md

@@ -10,11 +10,11 @@ DrawnUi name and semantics; nothing here is a redesign, only an omission.
 | `UseCache` | partial | `None`, `Operations` / `OperationsFull` (SkPicture replay), `Image` (offscreen surface snapshot, GPU-backed on WebGL, nearest-sampled blit), `ImageDoubleBuffered` (`RenderObjectPrevious` kept and drawn when a new cache cannot be produced yet, `DrawPlaceholder(ctx)` hook when there is none; recording itself is synchronous — no background thread, same as DrawnUi.Blazor with `CanUseCacheDoubleBuffering = false`), `ImageComposite` / `ImageCompositeGPU` (per-child composite, see the `UseCache="ImageComposite"` row below). `GPU` resolves to `Image` and `ImageCompositeGPU` to `ImageComposite`: no separate GPU-only path. `Super.CacheEnabled`, `RenderObject`/`CachedObject`, `InvalidateCache`, `DestroyRenderingObject`, `Canvas.DisposeObject` (deleted after flush). Defaults per C#: `SkiaLabel`/`SkiaSvg` Operations, everything else None. Not ported: `CacheSharing`, `AllowCaching`, offscreen bake threads, cache validity by GRContext. |
 | Incremental invalidation | partial | `Measure` returns the previous size when `!NeedMeasure` and constraints+scale are unchanged; `Update()`/`InvalidateMeasure()` bubble up and stale every ancestor cache; `Repaint()` keeps caches. Arrange still runs per frame for the whole tree; no dirty regions, no `DirtyChildrenTracker`. Post-animators on a control nested INSIDE a cached ancestor are drawn only when that ancestor re-records. |
 | Gestures core: `Canvas.Gestures` (Disabled/Enabled/Lock), `ProcessGestures(args, apply)`, `ConsumeGestures`, `Tapped`/`ChildTapped`, `InputTransparent`, `BlockGesturesBelow`, `LockChildrenGestures`, `HitBoxAuto`/`HitIsInside`/`IsGestureForChild`, `SkiaGesturesParameters`/`GestureEventProcessingInfo`/`SkiaGesturesInfo`/`ControlTappedEventArgs` | ported | Pointer events -> per-pointer `OnTouchAction` state machine (port of DrawnUi.Blazor) -> Down/Panning/Tapped/Up, queued and processed at frame start. Tap slop = 16pt like AppoMobi TouchEffect. The control that consumes a gesture keeps receiving it until it lets go (DrawnUi `Canvas.HadInput`, one pointer here instead of C#'s set): without it a drag handle, a slider thumb or a held button stops getting `Panning` the moment the finger leaves its box, and a control that stops consuming hands routing straight back to the tree (a button whose press turns into a scroll pan). Every mouse button is delivered (`Event.Pointer`: `Button`, `ButtonNumber`, `DeviceType`, `PressedButtons`, the AppoMobi.Gestures PointerData): a right click is Down / Up / Tapped with `Button` "Right" plus a `ContextMenu`; handlers that must be primary-only check `e.Parameters.Event.Pointer?.Button`. |
-| Gestures: `LongPressing`, `Pointer` (routed as a gesture; hover itself is ported, see `ReceivesHover`), multi-touch pinch, `SoftLock`, `AddGestures` attached props, `OnGestures` delegate | skipped | The enum members exist for parity and are never produced; there is no pinch member at all. Ported instead of skipped: velocity (`Gestures.ts` fills `Distance.Velocity` per move, the scroll / snapping physics run on it) and transform-aware mapping — a child receives the point through the inverse `RenderTransformMatrix` (`TransformPointToLocalSpace`), so rotated / scaled / translated controls hit-test correctly. `ChildOffset` stays zero because that inverse matrix replaces the C# cache-offset math (`TranslateInputCoords`), not because transforms are missing. `Wheel` IS produced (`Canvas.onWheel`). |
+| Gestures: `Pointer` (routed as a gesture; hover itself is ported, see `ReceivesHover`; `LongPressing` is produced since 2026-10-10: `Canvas.LongPressTimeMs` 1500 held still, no Tapped after it), multi-touch pinch, `SoftLock`, `AddGestures` attached props, `OnGestures` delegate | skipped | The enum members exist for parity and are never produced; there is no pinch member at all. Ported instead of skipped: velocity (`Gestures.ts` fills `Distance.Velocity` per move, the scroll / snapping physics run on it) and transform-aware mapping — a child receives the point through the inverse `RenderTransformMatrix` (`TransformPointToLocalSpace`), so rotated / scaled / translated controls hit-test correctly. `ChildOffset` stays zero because that inverse matrix replaces the C# cache-offset math (`TranslateInputCoords`), not because transforms are missing. `Wheel` IS produced (`Canvas.onWheel`). |
 | C# multi-subscriber `event`s | changed shape | One callback per event prop (`Tapped={fn}`), same names. `Command*` (ICommand) variants not ported. |
 | `Opacity`, `TranslationX/Y`, `Rotation`, `ScaleX/Y` (+`Scale`), `SkewX/Y`, `AnchorX/Y`, `HasTransform`, `RenderTransformMatrix`, `TransformPointToLocalSpace` | ported | Same matrix order as C# `ApplyTransforms` (pivot → rotation → scale/skew → translation), opacity = `saveLayer` alpha over the subtree, gestures mapped through the inverse matrix (`IsGestureForChild`, child receives the local point), accessibility rect = transformed bounds. Animations: `AnimateAsync`, `AnimateRangeAsync`, `FadeToAsync`, `ScaleToAsync`, `TranslateToAsync`, `RotateToAsync` as Promises with `AbortSignal` (one running per kind, like the C# per-property cancellation). Not ported: `RotationX/Y/Z`, `TranslationZ`, `Perspective1/2`, `CameraAngle`, `LinkTransforms`, `AddTranslationX/Y`, `UseTranslation*` overrides, `CustomizeLayerPaint`, `SkipRenderingOutOfBounds`. |
 | `Left` / `Top` | ported (as a translate) | Same paint-time offset in points, but folded into the render matrix (a `canvas.translate`, hit-testing follows) for every control, cached or not; C# applies them only when blitting a cache. |
-| `AnimatedFramesRenderer` / `SkiaLottie` / `SkiaGif` | ported | `AutoPlay`, `Repeat`, `SpeedRatio`, `DefaultFrame` (-1 = last), `Start(delay)`/`Stop`/`Seek`, `IsPlaying`, `Started`/`Finished`, `PlayWhenAvailable`, `GetFrameAt`. Lottie on CanvasKit Skottie (needs the `full` build, +0.9 MB raw wasm): `Source` (URL / app path, JSON cached per source, in-flight dedup), `ColorTint` / `Colors` (C# `ApplyTint` JSON rewrite), `IsOn` + `DefaultFrameWhenOn` + `ApplyIsOnWhenNotPlaying`, `StopAtCurrentFrame`, `ProcessJson`, `GoToStart`/`GoToEnd`, `SetAnimation`, `LoadSource`, `CreateAnimation`, `TotalFrames`; `UseCache=ImageDoubleBuffered` re-recorded per frame. GIF on CanvasKit AnimatedImage: every frame decoded once (`GifAnimation`: `SeekFrame`, `GetFrameNumber`, `DurationMs`, `TotalFrames`), `Aspect` (AspectFitFill), alignment, `Success`/`Error`. Not ported: `SkiaGif.Display` inner SkiaImage (frames are drawn directly), custom-control ctor `SkiaGif(display)`, `SkiaLottie` Skottie property/slot editing, sound, `ReloadSource` sync file paths, `Dispose` wiring on unmount (no engine hook from the reconciler yet). |
+| `AnimatedFramesRenderer` / `SkiaLottie` / `SkiaGif` | ported | `AutoPlay`, `Repeat`, `SpeedRatio`, `DefaultFrame` (-1 = last), `Start(delay)`/`Stop`/`Seek`, `IsPlaying`, `Started`/`Finished`, `PlayWhenAvailable`, `GetFrameAt`. Lottie on CanvasKit Skottie (needs the `full` build, +0.9 MB raw wasm): `Source` (URL / app path, JSON cached per source, in-flight dedup), `ColorTint` / `Colors` (C# `ApplyTint` JSON rewrite), `IsOn` + `DefaultFrameWhenOn` + `ApplyIsOnWhenNotPlaying`, `StopAtCurrentFrame`, `ProcessJson`, `GoToStart`/`GoToEnd`, `SetAnimation`, `LoadSource`, `CreateAnimation`, `TotalFrames`; default cache `Operations` (C# ImageDoubleBuffered, see PARITY "Lottie and GIF default caches"). GIF on CanvasKit AnimatedImage: every frame decoded once (`GifAnimation`: `SeekFrame`, `GetFrameNumber`, `DurationMs`, `TotalFrames`), `Aspect` (AspectFitFill), alignment, `Success`/`Error`, default cache `None` (C# ImageDoubleBuffered). Not ported: `SkiaGif.Display` inner SkiaImage (frames are drawn directly), custom-control ctor `SkiaGif(display)`, `SkiaLottie` Skottie property/slot editing, sound, `ReloadSource` sync file paths, `Dispose` wiring on unmount (no engine hook from the reconciler yet). |
 | `SkiaBackdrop` | ported | `Blur` (5), `Brightness` (gamma), `UseContext`, `BackgroundColor` tint, `HasEffects`, `GetImage`; children drawn first and blurred with the snapshot (C# order); `UseContext` snapshots the surface the pixels end up on (on-screen, or the nearest Image cache surface through its `Origin`), also while an Operations picture is being recorded, since caches record inline; after each paint the ancestors' caches are staled for the next frame (no frame requested) so content that changes beneath without invalidating this branch (an image loading later) is picked up by the next frame. Used by the shell popups/modals (`ShellDefaults.PopupsBackgroundBlur`). Not ported: `CacheSource`, the ghost mode. |
 | Disposal (`Dispose` / `OnDisposing`) | ported | The React renderer calls `Dispose()` when an element leaves the tree (`detachDeletedInstance`): caches, gradient shaders, running `*ToAsync` animations, overlay effects, the accessibility node, then the children (static and templated pool); `SkiaScroll`/`SnappingLayout` stop their animators, `SkiaSvg` drops its raster, `SkiaLottie`/`SkiaGif` free the Skottie animation / frames; `Canvas.Dispose` disposes the content. Not ported: `IsDisposing` staged disposal, `Disposing` event, `OnWillDisposeWithChildren`. |
 | Hover: `ReceivesHover` (opt-in; on by default in SkiaButton, SkiaSlider, the toggles, SkiaRadioButton, SkiaCarousel, SkiaDrawer), `IsHovered`, `HoverChanged` (turns `ReceivesHover` on, as C# `OnHovered`) | ported | drawnui-cross 6m: every opted-in control under the mouse is hovered; nothing changes while a scroll, carousel or drawer moves its content, one check at the last pointer position when it stops and after an add / remove, a rebind, a hidden hovered control or an instant scroll jump; pointerleave clears at once; touch never hovers (`Canvas.Hover`, a `HoverManager`). Not ported: C# `SetHover`, `CheckHovered` / `OnHover` / `IsPointerOver` (no Pointer gestures are routed), SkiaSpinner / wheel picker (no such controls). |
@@ -71,14 +71,14 @@ DrawnUi name and semantics; nothing here is a redesign, only an omission.
 | `MeasureItemsStrategy="MeasureVisible"` + background measurement | ported | Initial pass measures enough items to fill the viewport (≥ `BackgroundMeasurementBatchSize`), content extent = exact prefix + average × remaining (C# MeasureList estimate), visible cells measured on demand and laid out with their real heights, the prefix grows in `requestIdleCallback` slices (time-budgeted, then one `InvalidateMeasure`), `LastMeasuredIndex`, `DebugString` shows `measured n/N`. Not ported: cancellation/`_pendingStructureChanges` interplay, `UsePreparedViews`, windowed sources, anchor correction when an estimate above the viewport changes (content may shift by the delta). |
 | `SkiaLayout` Wrap (static children) + `SkiaWrap` alias | ported | Left-to-right flow, `Spacing` between items and rows, row height = tallest item. Not ported: `Split`, main-axis `Fill` children sharing a row (1.9.7.4 flex-fill), `UseDynamicColumns`, RTL. |
 | `SkiaLayout` Grid (static children) + `SkiaGrid` alias | ported | Port of `SkiaGridStructure` (MAUI grid manager): `ColumnDefinitions`/`RowDefinitions` as `"*, 2*, Auto, 100"` or arrays, `DefaultColumnDefinition`/`DefaultRowDefinition` (Auto, like C#), `ColumnSpacing`/`RowSpacing`, child `Column`/`Row`/`ColumnSpan`/`RowSpan` (plain props instead of attached properties), implicit tracks, unknown/known measure passes, span resolution, star compression, Fill-child minimums, last-track stretch when the grid fills, remeasure at final cells. Not ported: `Split`/`Invert` (templated grids), `UseDynamicColumns`, `SkiaDecoratedGrid`, `GetOrderedSubviews` ZIndex ordering. |
-| `SkiaLabel` | partial | Word wrap (+ character break for long words), `MaxLines` with tail ellipsis, `LineBreakMode` (NoWrap / wraps / Tail; Head/Middle behave as Tail), `HorizontalTextAlignment` Start/Center/End (Fill* accepted, align Start), `VerticalTextAlignment`, `LineSpacing`, `LineHeight`, `FontWeight` + `FontAttributes` via faces registered per weight (`AddFont(src, alias, weight)`, nearest weight wins, synthetic bold (`setEmbolden`) when the nearest face is lighter than 600 — C# `Font.Embolden`; italic = synthetic skew when no italic face; empty `FontFamily` = the first registered family, weights included), `TextTransform`, `Padding`, `LinesCount`; defaults as C# (`FontSize` 12, `TextColor` GreenYellow). `FontFamilyFallback` ported and extended: comma-separated chain (`"FontSymbols,FontSymbols2"`), per-codepoint run segmentation, spaces always stay on the main font; `fonts.AddSymbols()` (`FontSymbols` = Noto Sans Math subset, `FontSymbols2` = Noto Sans Symbols 2 subset) and `fonts.AddEmojis()` (`FontEmoji` = Noto Color Emoji faces+hands subset) ship the same subsets as DrawnUi.Blazor. `Spans` ported as `<TextSpan>` children: `Text`, `TextColor`/`FontSize`/`FontFamily` (unset = inherit from the label, like C# HasSetColor/HasSetSize/HasSetFont), `FontWeight`, `IsBold`, `IsItalic`, `Underline`/`UnderlineWidth`, `Strikeout`/`StrikeoutWidth`/`StrikeoutColor` (Red default), `BackgroundColor`, `Tapped` + `ForceCaptureInput` (hit-tested through per-fragment `Rects`, ripple on the label, `OnSpanTapped` overridable), mixed sizes on one line share a baseline. TextSpan not ported: `ParagraphColor`, `CommandTapped`, per-span `LineSpacing`/`LineHeight`, `AutoFindFont`, `DrawingOffset`, `Shape`/glyph shaping. Not ported: `AutoFont`, `CharacterSpacing`, `AutoSize`/`AutoSizeText`, `DropShadow*`, text `StrokeColor`/`StrokeWidth`/`StrokeGradient`, `GradientByLines`, `MonoForDigits`, `ParagraphSpacing`, `KeepSpacesOnLineBreaks`, `Format`, RTL/bidi, hyphenation, `SkiaRichLabel`/markdown. |
+| `SkiaLabel` | partial | Word wrap (+ character break for long words), `MaxLines` with tail ellipsis, `LineBreakMode` (NoWrap / wraps / Tail; Head/Middle behave as Tail), `HorizontalTextAlignment` Start/Center/End (Fill* accepted, align Start), `VerticalTextAlignment`, `LineSpacing`, `LineHeight`, `FontWeight` + `FontAttributes` via faces registered per weight (`AddFont(src, alias, weight)`, nearest weight wins, synthetic bold (`setEmbolden`) when the nearest face is lighter than 600 — C# `Font.Embolden`; italic = synthetic skew when no italic face; empty `FontFamily` = the first registered family, weights included), `TextTransform`, `Padding`, `LinesCount`; defaults as C# (`FontSize` 12, `TextColor` GreenYellow). `FontFamilyFallback` ported and extended: comma-separated chain (`"FontSymbols,FontSymbols2"`), per-codepoint run segmentation, spaces always stay on the main font; `fonts.AddSymbols()` (`FontSymbols` = Noto Sans Math subset, `FontSymbols2` = Noto Sans Symbols 2 subset) and `fonts.AddEmojis()` (`FontEmoji` = Noto Color Emoji faces+hands subset) ship the same subsets as DrawnUi.Blazor. `Spans` ported as `<TextSpan>` children: `Text`, `TextColor`/`FontSize`/`FontFamily` (unset = inherit from the label, like C# HasSetColor/HasSetSize/HasSetFont), `FontWeight`, `IsBold`, `IsItalic`, `Underline`/`UnderlineWidth`, `Strikeout`/`StrikeoutWidth`/`StrikeoutColor` (Red default), `BackgroundColor`, `Tapped` + `ForceCaptureInput` (hit-tested through per-fragment `Rects`, ripple on the label, `OnSpanTapped` overridable), mixed sizes on one line share a baseline. TextSpan not ported: `ParagraphColor`, `CommandTapped`, per-span `LineSpacing`/`LineHeight`, `AutoFindFont`, `DrawingOffset`, `Shape`/glyph shaping. `CharacterSpacing` (C#: (value - 1) points after every glyph, measured, wrapped and cut at the drawn width), Chinese / Japanese line breaks between characters with kinsoku (C# FitAtBreak, `CanBreakInsideWord`). Not ported: `AutoFont`, `AutoSize`/`AutoSizeText`, `DropShadow*`, text `StrokeColor`/`StrokeWidth`/`StrokeGradient`, `GradientByLines`, `MonoForDigits`, `KeepSpacesOnLineBreaks`, `Format`, RTL/bidi, hyphenation, `SkiaRichLabel`/markdown. |
 | `SkiaHotspot` | ported | Fill/Fill, `Tapped`, `Down`, `Up`, `LockPanning`, `TouchDown`; consumes only Tapped like the C# one. No `AnimationTapped`/ripple/shimmer. |
-| `SkiaButton` | partial | Default look only: rounded frame radius 8 (hardcoded like the C# default content), centered label, `Text`/`TextColor`/`FontSize`/`FontFamily`/`BackgroundColor`/`IsPressed`/`IsDisabled`/`LockPanning`, `Tapped`/`Down`/`Up`. `IsPressed` is tracked but has no visual; press feedback = `ApplyEffect="Ripple"`. No `ButtonStyle` platform looks, icons, `TextCase`, elevation, shimmer, `BtnText`/`BtnShape` templating. |
+| `SkiaButton` | partial | Default look only: rounded frame radius 8 (hardcoded like the C# default content), centered label, `Text`/`TextColor`/`FontSize`/`FontFamily`/`BackgroundColor`/`IsPressed`/`RespondsToGestures` (`IsDisabled` = its obsolete opposite)/`LockPanning`, `Tapped`/`Down`/`Up`. `RespondsToGestures = false`: no press, no `Tapped`/`Down`/`Up`, a press or tap on it stops there, keyboard skips it, reported disabled (drawnui-cross 6w). `IsPressed` is tracked but has no visual; press feedback = `ApplyEffect="Ripple"`. No `ButtonStyle` platform looks, icons, `TextCase`, elevation, shimmer, `BtnText`/`BtnShape` templating. |
 | `SkiaImage` | partial | Effects ported: `AddEffect` (BlackAndWhite/Grayscale, Pastel, Sepia, InvertColors, Tint + `ColorTint`/`EffectBlendMode`, Darken, Lighten, Contrast, Saturation, Brightness, TSL, Gamma ≈ linear fit — CanvasKit has no table color filter), `Blur` (image filter, mirror tile), `ZoomX/ZoomY`, `HorizontalOffset/VerticalOffset`; C# color matrices use 0..255 translations, CanvasKit 0..1 — converted. `HSL` (hue from `Gamma`, `Saturation`, `Brightness`, tint blend), `Custom` = your own `PaintColorFilter` (C# public fields `PaintColorFilter` / `PaintImageFilter`, the latter replaces `Blur`), `ImageBitmap` (decoded image shared, not owned), `LoadPriority` of the queued `Source` load. Not ported: `UseGradient`/`StartColor`/`EndColor`, sprites, `InflateAmount`, `EraseChangedContent`, `RescaleSource`/`RescalingQuality`. `Source` (URL), `Aspect` (all `TransformAspect` values; `Tile` is a no-op like C#, tiling is `SkiaImageTiles`, same `RescaleAspect` math), `HorizontalAlignment`/`VerticalAlignment`, `Success`/`Error`, `IsLoading`, `LoadedSource`, `DisplayRect`, `AspectScale`; overflow clipped to the box. Not ported: `LoadSourceOnFirstDraw`, `PreviewBase64`, `ImageBitmap`/`LoadedImageSource`, `RescaleSource`/`CacheRescaledSource`/`RescalingQuality`, all adjustments (`Brightness`…`Blur`, `ColorTint`, gradient, `Zoom*`, offsets), sprites, `DrawWhenEmpty`, `EraseChangedContent`, `UseAssembly`. Measure: bounded box taken as is, unbounded axis from source aspect; no `NeedAutoWidth/Height` from Start alignment. |
 | `SkiaImageManager` | partial | `Instance.LoadImageAsync(url, signal)` (direct), `LoadImageManagedAsync(url, signal, priority)` through the priority queue (High > Normal > Low, `MaxParallelLoads` 5 in flight like the C# semaphore, one fetch per url serves every requester), `PreloadImage` / `PreloadImages(urls, priority)`, `CancelAll`, `GetFromCache`, `CanReload` callback on failure, `QueuedCount` / `RunningCount`, `ReuseBitmaps`, `Clear()`; in-memory cache of decoded images only. No `CacheLongevitySecs` eviction, no platform loaders, no `LoadImageOnlineAsync` retry policy, no `ImageSource` types (urls only). |
 | `SkiaImageTiles` | ported | `TileWidth` / `TileHeight` (points, nothing drawn until set), `TileAspect` (AspectCover), `TileOffsetX` / `TileOffsetY` (wrap), `TileCacheType` (Image) for the inner tile `SkiaImage` sharing the decoded source, clipped to bounds. |
 | `SkiaSvg` | partial | Inline `SvgString` without `xmlns` gets it injected (browsers refuse to decode an `<img>` SVG without it, SkiaSharp does not care) — the C# check-mark markup relies on that. `Source` (URL) / `SvgString`, `Aspect` (default `AspectFitFill`, uses the shared `RescaleAspect` math, not SkiaSvg's own matrix path), alignments, `TintColor` (SrcIn), `Success`/`Error`, `IsLoading`, `DisplayRect`. Rendering: browser decodes the SVG, rasterized at the displayed pixel size and cached per size (CanvasKit npm has no SVG module). Not ported: shadows, FontAwesome duotone colors, `FillGradient`, `Zoom*`/offsets/`InflateAmount`, `IconFilePath`/embedded resources, `UseCache=Operations` default (no caching yet). |
-| `SkiaScroll` | partial | `Orientation` Vertical/Horizontal/Both/Neither (Neither: pans never move the viewport, the wheel is not consumed so a parent scroll may take it; programmatic `ScrollTo` still works), single `Content`, `ViewportOffsetX/Y` (points, <= 0), pan with the C# 0.85 delta interpolation, fling on the DrawnUi deceleration curve (`FrictionScrolled`, `ChangeVelocityScrolled`, `MaxVelocity`, edge-cut duration), rubber-band overscroll (`Bounces`, `RubberEffect`) + spring bounce (`RubberDamping`, `MaxBounceVelocity`), mouse wheel (`WheelLineSize` per notch, an event moving by its share of a notch: `Canvas.WheelDeltaPerNotch` 100 CSS px after `deltaMode` lines x 40 / pages x 800, dominant axis, as the C# browser heads; `AutoScrollingSpeedMs` glide for a notch, an event under half a notch moves at once (touchpads, see PARITY); events accumulate onto the running move's exact target, and a restarted glide starts at the event so a fast swipe moves on every frame; `Wheel.IsHorizontal`: a vertical scroll leaves horizontal events, a horizontal scroll takes both, C# ba03cb20), `ScrollTo`/`ScrollToTop`/`ScrollToBottom`/`StopScrolling`, `Scrolled`, `IgnoreWrongDirection`, `RespondsToGestures`, `IsUserPanning`/`IsScrolling`, `ContentSize`, `ContentOffsetBounds`, `OverScrolled`. `Header` / `Footer` (JSX children with `Tag="Header"` / `Tag="Footer"`; the header scrolls in the flow, `HeaderSticky` pins it at the viewport start drawn over the content, `HeaderBehind` draws it under the content, `HeaderParallaxRatio` (1 = with the content, 0.5 = half speed), `ParallaxOverscrollEnabled`, `ContentOffset` between a behind / sticky header and the content; both add to the scroll extent), scroll bars (`ScrollBarsVisibility` None / Vertical / Horizontal / Both creating default `SkiaScrollBar`s, `ScrollBar` / `ScrollBarHorizontal` custom `IScrollBar` controls via `Tag="ScrollBar"` / `"ScrollBarHorizontal"`, `ScrollBarThumbColor` / `ScrollBarTrackColor`; `SkiaScrollBar`: `Dock`, `ThumbColor`, `TrackColor`, `Thickness` 4, `EdgeMargin` 2, `MinThumbSize` 32, `AutoHide` + `HideDelaySecs` 1 + `HideDurationSecs` 0.25, thumb squashed on overscroll, `IsDraggable` + `GrabPadding` 8: the scroll takes a gesture that starts on the bar from down to up, thumb drag keeps the grab point, a track press jumps the thumb under the pointer, the content gets neither the pan nor the tap; a custom `IScrollBar` opts in by implementing `IsDraggable` / `BeginDrag` / `GetDragProgress`; bars are parent-independent (C# `IsParentIndependent`): a thumb resize invalidates the bar alone and the scroll re-measures it on draw, nothing above re-measures), pull to refresh (`RefreshEnabled`, `RefreshCommand` callback, `IsRefreshing` two-way, `RefreshDistanceLimit` 150, `RefreshShowDistance` 50, `RefreshIndicator` `IRefreshIndicator` control via `Tag="RefreshIndicator"`; `RefreshIndicator` base: `Orientation`, `SetDragRatio` slides the view in with the pull and parks it at RefreshShowDistance, `IsRunning` + `OnIsRunningChanged`, `VisibleRatio`), `SnapToChildren` Center / Side after a fling or a release (`Snap`, `CheckNeedToSnap`), `TrackIndexPosition` Start / Center / End + `TrackIndexPositionOffset` reporting `CurrentIndex` / `CurrentIndexChanged`. Not ported: `ScrollToIndex` with `Center`/deferred ordered scroll for unmeasured indexes (Start/End on measured structures ported), zoom (`ViewportZoom`, `ZoomLocked`), `ReverseGestures` (inverted chat), keyboard adaptation, `ResetScrollPositionOnContentSizeChanged`, `ScrollType`, `ScrollingEnded` event, `LottieRefreshIndicator`, virtualization hooks (`Virtualisation`, `UseVirtual`, windowed content bounds); the C# refresh-indicator position curve is replaced by a linear slide-in. |
+| `SkiaScroll` | partial | `Orientation` Vertical/Horizontal/Both/Neither (Neither: pans never move the viewport, the wheel is not consumed so a parent scroll may take it; programmatic `ScrollTo` still works), single `Content`, `ViewportOffsetX/Y` (points, <= 0), pan with the C# 0.85 delta interpolation, fling on the DrawnUi deceleration curve (`FrictionScrolled`, `ChangeVelocityScrolled`, `MaxVelocity`, edge-cut duration), rubber-band overscroll (`Bounces`, `RubberEffect`) + spring bounce (`RubberDamping`, `MaxBounceVelocity`), mouse wheel (`WheelLineSize` per notch, an event moving by its share of a notch: `Canvas.WheelDeltaPerNotch` 100 CSS px after `deltaMode` lines x 40 / pages x 800, dominant axis, as the C# browser heads; `AutoScrollingSpeedMs` glide for a notch, an event under half a notch moves at once (touchpads, see PARITY); events accumulate onto the running move's exact target, and a restarted glide starts at the event so a fast swipe moves on every frame; `Wheel.IsHorizontal`: a vertical scroll leaves horizontal events, a horizontal scroll takes both, C# ba03cb20), `ScrollTo`/`ScrollToTop`/`ScrollToBottom`/`StopScrolling`, `Scrolled`, `IgnoreWrongDirection`, `RespondsToGestures`, `IsUserPanning`/`IsScrolling`, `ContentSize`, `ContentOffsetBounds`, `OverScrolled`. `Header` / `Footer` (JSX children with `Tag="Header"` / `Tag="Footer"`; the header scrolls in the flow, `HeaderSticky` pins it at the viewport start drawn over the content, `HeaderBehind` draws it under the content, `HeaderParallaxRatio` (1 = with the content, 0.5 = half speed), `ParallaxOverscrollEnabled`, `ContentOffset` between a behind / sticky header and the content; both add to the scroll extent), scroll bars (`ScrollBarsVisibility` None / Vertical / Horizontal / Both creating default `SkiaScrollBar`s, `ScrollBar` / `ScrollBarHorizontal` custom `IScrollBar` controls via `Tag="ScrollBar"` / `"ScrollBarHorizontal"`, `ScrollBarThumbColor` / `ScrollBarTrackColor`; `SkiaScrollBar`: `Dock`, `ThumbColor`, `TrackColor`, `Thickness` 4, `EdgeMargin` 2, `MinThumbSize` 32, `AutoHide` + `HideDelaySecs` 1 + `HideDurationSecs` 0.25, thumb squashed on overscroll, `IsDraggable` + `GrabPadding` 8: the scroll takes a gesture that starts on the bar from down to up, thumb drag keeps the grab point, a track press jumps the thumb under the pointer, the content gets neither the pan nor the tap; a custom `IScrollBar` opts in by implementing `IsDraggable` / `BeginDrag` / `GetDragProgress`; bars are parent-independent (C# `IsParentIndependent`): a thumb resize invalidates the bar alone and the scroll re-measures it on draw, nothing above re-measures), pull to refresh (`RefreshEnabled`, `RefreshCommand` callback, `IsRefreshing` two-way, `RefreshDistanceLimit` 150, `RefreshShowDistance` 50, `RefreshIndicator` `IRefreshIndicator` control via `Tag="RefreshIndicator"`; `RefreshIndicator` base: `Orientation`, `SetDragRatio` slides the view in with the pull and parks it at RefreshShowDistance, `IsRunning` + `OnIsRunningChanged`, `VisibleRatio`), `SnapToChildren` Center / Side after a fling or a release (`Snap`, `CheckNeedToSnap`), `TrackIndexPosition` Start / Center / End + `TrackIndexPositionOffset` reporting `CurrentIndex` / `CurrentIndexChanged`. `ScrollToIndex` Start / Center / End as an open order (C# OrderedScrollToIndex): a row not measured yet is gone to by the estimate and aimed again every frame until its place is measured and the viewport stands on it; a press, the wheel or another scroll drops it; LoadMore waits while it is open. Controls outside the clip are skipped with their subtree (C# stack Virtualisation, for every control; see PARITY). Not ported: zoom (`ViewportZoom`, `ZoomLocked`), `ReverseGestures` (inverted chat), keyboard adaptation, `ResetScrollPositionOnContentSizeChanged`, `ScrollType`, `ScrollingEnded` event, `LottieRefreshIndicator`, virtualization hooks (`Virtualisation`, `UseVirtual`, windowed content bounds); the C# refresh-indicator position curve is replaced by a linear slide-in. |
 | `SkiaShape` (+ `SkiaFrame`) | partial | `BevelType` Bevel / Emboss + `Bevel` (`Depth`, `LightColor`, `ShadowColor`, `Opacity`; C# `PaintBevelEffect` edge paths for Rectangle, rounded Rectangle, Circle/Ellipse, Polygon, Path via ContourMeasure halves).  `Shadows` (`SkiaShadow` X/Y/Blur/Opacity/Color/ShadowOnly, plain literals accepted): fill painted once per shadow with a DropShadow image filter (C# `PaintWithShadowsInternal`), hollow shapes clip their outline away so only the outside shadow remains; caches record the effects margin (`3·Blur·scale ± offset`, C# `MergeShadowMargin`) via `ComputeEffectsMargin`/`ExpandedCacheRect`. Not ported: `PlatformShadow` (MAUI `Shadow` brush), `ExpandDirtyRegion`, bevel/emboss. `Type` Rectangle/Circle/Ellipse/Arc (`Value1` start, `Value2` sweep)/Polygon+Line (`Points` ratios)/Path (`PathData`, fitted + centered), `CornerRadius` (uniform or per-corner), `StrokeWidth` (points, negative = px) drawn inside the bounds, `StrokeColor`, `StrokeCap`, `ClipBackgroundColor`, children laid out inside the stroke and clipped to the shape, `CreateClip` = shape, `FillGradient` fill, `UseCache=Operations` default. Not ported: `Squricle`, `Custom`, `SmoothPoints`, `StrokePath` (dashes), `StrokeGradient`, `StrokeBlendMode`, sub-1px stroke compensation, `MeasuredStrokeAware*` exposure, `LayoutChildren` override hook. |
 | `SkiaButton` | partial | Now a `SkiaLayout` hosting a `SkiaShape` frame (`Tag="BtnShape"`) + `SkiaLabel` (`Tag="BtnText"`), sized from the label + Padding; `CornerRadius` (default 8), `StrokeColor`/`StrokeWidth`, `BackgroundColor`, text props, `ApplyEffect`, `Tapped`/`Down`/`Up`. Still no `ButtonStyle` looks, icons, `TextCase`, elevation, shimmer, custom templating through tags. |
 | `SnappingLayout` | ported | `Animated`, `RespondsToGestures`, `IgnoreWrongDirection`, `Bounces`, `RubberDamping`, `RubberEffect`, `AutoVelocityMultiplyPts`, `SnapDistanceRatio`, `SnapPoints`, `CurrentPosition`, `CurrentSnap`, `ContentOffsetBounds`, `IsUserPanning`/`IsUserFocused`, `InTransition`, `Scrolled`/`TransitionChanged`/`Stopped`, `ClampOffset` (rubber), `FindNearestAnchor`, `SelectNextAnchor` (dot product), `ScrollToNearestAnchor`, `ScrollToOffset` (spring `Spring(1+RubberDamping, 200, 0.5·(1+RubberDamping))` when `Bounces`, else 0.1–0.8 s from velocity). The settled state is reported when the snap animation stops (C# relies on `ApplyPosition` ticks). Not ported: `AnimatorSpring` reuse, `SnapDistanceRatio` for non-carousel layouts, hover. |
@@ -103,9 +103,9 @@ DrawnUi name and semantics; nothing here is a redesign, only an omission.
 | Area | Status | Notes |
 |---|---|---|
 | Custom `react-reconciler` renderer, PascalCase props mapped 1:1 to control properties | ported | |
-| `SkiaToggle` / `SkiaSwitch` / `SkiaCheckbox` / `SkiaRadioButton` | ported | Same names: `IsToggled`, `Toggled`, `DefaultValue`, `IsAnimated`, `RespondsToGestures`, `ColorThumbOn/Off`, `ColorFrameOn/Off` (+ `ColorCheckOn`), `ControlStyle` with the Default / Cupertino / Material / Material3 / Windows looks and geometry of the C# style builders (changing it after the first measure rebuilds the content and re-pins only the sizes the style set, C# `RebuildDefaultContent`) (`Frame`/`Thumb`, `FrameOff`/`FrameOn`/`ViewCheckOn`, `On` ring + `Text`), thumb animated with `TranslateToAsync` (`AnimationSpeed` 200 ms), radio groups by `GroupName` or parent. Not ported: `CommandToggled`/`CommandTapped`, hover (`CheckHovered`), `TransformView` hotspot (the toggle itself takes the tap), `Platform` style resolves from the browser UA. |
+| `SkiaToggle` / `SkiaSwitch` / `SkiaCheckbox` / `SkiaRadioButton` | ported | Same names: `IsToggled`, `Toggled`, `DefaultValue`, `IsAnimated`, `RespondsToGestures` (false: a tap does not toggle it and stops there, keyboard skips it, reported disabled), `ColorThumbOn/Off`, `ColorFrameOn/Off` (+ `ColorCheckOn`), `ControlStyle` with the Default / Cupertino / Material / Material3 / Windows looks and geometry of the C# style builders (changing it after the first measure rebuilds the content and re-pins only the sizes the style set, C# `RebuildDefaultContent`) (`Frame`/`Thumb`, `FrameOff`/`FrameOn`/`ViewCheckOn`, `On` ring + `Text`), thumb animated with `TranslateToAsync` (`AnimationSpeed` 200 ms), radio groups by `GroupName` or parent. Not ported: `CommandToggled`/`CommandTapped`, hover (`CheckHovered`), `TransformView` hotspot (the toggle itself takes the tap), `Platform` style resolves from the browser UA. |
 | `SkiaControl.ExecuteAfterCreated` / fluent `.Initialize(...)` | skipped | C# runs it once when the control gets its parent so code-behind can reach `.Assign`'d refs; in React the element tree is declarative and `ref` / `useEffect` cover it. |
-| `SkiaProgress` / `SkiaSlider` | ported (painted, not composed) | `Value`/`Min`/`Max`, `TrackColor`/`ProgressColor`; slider `Min`/`Max`/`Step`/`Start`/`End`/`EnableRange`/`RangeMin`/`SliderHeight`/`ThumbColor`/`TrackColor`/`TrackSelectedColor`/`ClickOnTrailEnabled`/`StartChanged`/`EndChanged`, `StartThumbX`/`EndThumbX`, the C# position<->value math (`SliderHeight` = thumb box, `Step` rounding, `RangeMin` clamps), drag + click-on-trail + per-style looks (track heights, thumb sizes, palettes, Material3 gap + stop dot). Track/trail/thumbs are painted directly instead of child shapes (`SliderTrail`/`SliderThumb` not exposed). Not ported: `Orientation` Vertical, `Invert`, `ValueStringFormat`/`MinMaxStringFormat` + `StartDesc`/`EndDesc`, `IgnoreWrongDirection`, `AvailableWidthAdjustment`, `Trail*Offset`, `Cupertino*` sizing props, hover. |
+| `SkiaProgress` / `SkiaSlider` | ported (painted, not composed) | Screen readers: `AccessibilityValue` (aria-valuenow / min / max, valuetext "65%" or "20 – 80", a slider horizontal), the name only from `AccessibilityLabel` (drawnui-cross 6c). `Value`/`Min`/`Max`, `TrackColor`/`ProgressColor`; slider `Min`/`Max`/`Step`/`Start`/`End`/`EnableRange`/`RangeMin`/`SliderHeight`/`ThumbColor`/`TrackColor`/`TrackSelectedColor`/`ClickOnTrailEnabled`/`StartChanged`/`EndChanged`, `StartThumbX`/`EndThumbX`, the C# position<->value math (`SliderHeight` = thumb box, `Step` rounding, `RangeMin` clamps), drag + click-on-trail + per-style looks (track heights, thumb sizes, palettes, Material3 gap + stop dot). Track/trail/thumbs are painted directly instead of child shapes (`SliderTrail`/`SliderThumb` not exposed). Not ported: `Orientation` Vertical, `Invert`, `ValueStringFormat`/`MinMaxStringFormat` + `StartDesc`/`EndDesc`, `IgnoreWrongDirection`, `AvailableWidthAdjustment`, `Trail*Offset`, `Cupertino*` sizing props, hover. |
 | `SkiaButton.ControlStyle` | ported | Cupertino / Material / Material3 / Windows accent, corner radius, font size/weight and minimum content size from the C# style builders, applied only when the user left `BackgroundColor`/`CornerRadius`(8)/`FontSize`(15)/`MinimumWidthRequest`/`MinimumHeightRequest` unset; default look is now the C# Crimson accent. `SetDefaultMinimumContentSize` is mirrored for BOTH axes (every C# style passes width 100, heights 41/36/40/40/32) and for the default `Unset` style too, skipped on a `Fill` axis or when a `WidthRequest`/`HeightRequest` is set, so short captions clamp to 100pt as in C#; the C# value adds `Margins` because it compares against a margin-inclusive size, here Measure applies it margin-exclusive and adds the margin after. Not ported: `Background` brushes, pressed-state shadow changes. |
 | `SkiaButton.FontFamilyFallback` | React extension | Pass-through to the inner label so icon-glyph buttons render with `AddSymbols()` faces. |
 | Accessibility (`ISkiaAccessibilityNode` + `SkiaAccessibilityManager` + Blazor ARIA overlay) | ported | `AccessibilityRole/Label/Hint/CanInteract/IsPressed/Live`, `Aria` constants, `IsAccessibilityElement`, `GetAccessibilityPixelRect`, `NotifyAccessibility`, `OnAccessibilityActivated` (synthetic Tapped), `OnAccessibilityFocused`, snapshot rate-limited by `MinUpdateIntervalMs`, reading order by rows (tops within half the smaller height form one row, read left to right), `AccessibilityCanInteract` only while a tap could reach the control (`CanReceiveGesture`: the control and its ancestors visible, none `InputTransparent`, no ancestor `LockChildrenGestures` holding the gesture, `AcceptsInput`, false for a disabled `SkiaButton`), `SkiaButton` hides its inner label. Extensions: per-class `DefaultAccessibilityRole`, label/interaction defaults derived from text / `Tapped`, `pointer-events:none` overlay, detached/off-canvas nodes pruned at rebuild (no explicit unregister on removal). Not ported: `WithAccessibility*` fluent helpers, `FocusChanged` event consumers, UIA/AT-SPI (browser only), `aria-level` for headings. |

package/dist/controls/AnimatedFramesRenderer.d.ts

@@ -38,6 +38,13 @@ export declare class AnimatedFramesRenderer extends SkiaControl {
     protected OnLayoutChanged(): void;
     PlayIfNeeded(): void;
     InitializeAnimator(): void;
+    /**
+     * Animation time (ms, the animator's range) of the next change of what is shown after `value`, or undefined when it
+     * may change every frame (Lottie). A GIF or a sprite returns its next frame's start.
+     */
+    protected NextChangeMs(_value: number): number | undefined;
+    /** The animator sleeps until the next change: no ticks and no frames in between (DrawnUi.Rust sleeping frame animators). */
+    private SleepUntilNextChange;
     /** Configure the animator range/speed once the frames source is known. */
     protected OnAnimatorInitializing(): void;
     /** The animator produced a new frame value. */

package/dist/controls/AnimatedFramesRenderer.js

@@ -69,7 +69,7 @@ export class AnimatedFramesRenderer extends SkiaControl {
     InitializeAnimator() {
         if (!this.Animator) {
             const a = new SkiaValueAnimator(this);
-            a.OnUpdated = (v) => this.OnAnimatorUpdated(v);
+            a.OnUpdated = (v) => { this.OnAnimatorUpdated(v); this.SleepUntilNextChange(a, v); };
             a.OnStart = () => { this.WasStarted = true; this.OnStarted(); };
             a.OnStop = () => { if (this.WasStarted)
                 this.OnFinished(); this.WasStarted = false; };
@@ -82,6 +82,21 @@ export class AnimatedFramesRenderer extends SkiaControl {
             this.Start();
         }
     }
+    /**
+     * Animation time (ms, the animator's range) of the next change of what is shown after `value`, or undefined when it
+     * may change every frame (Lottie). A GIF or a sprite returns its next frame's start.
+     */
+    NextChangeMs(_value) { return undefined; }
+    /** The animator sleeps until the next change: no ticks and no frames in between (DrawnUi.Rust sleeping frame animators). */
+    SleepUntilNextChange(a, value) {
+        const next = this.NextChangeMs(value), range = a.mMaxValue - a.mMinValue;
+        if (next === undefined || !(range > 0) || !(a.Speed > 0) || next <= value) {
+            a.SleepUntilNanos = 0;
+            return;
+        }
+        const wallMs = (Math.min(next, a.mMaxValue) - value) * (a.Speed / range);
+        a.SleepUntilNanos = a.LastFrameTimeNanos + wallMs * 1_000_000;
+    }
     /** Configure the animator range/speed once the frames source is known. */
     OnAnimatorInitializing() { }
     /** The animator produced a new frame value. */

package/dist/controls/DrawnGame.d.ts

@@ -24,7 +24,10 @@ export declare class DrawnGame extends SkiaLayout {
     StopLoop(): void;
     /** Starts the game loop. */
     StartLoop(delayMs?: number): void;
-    /** Internal, override `GameLoop` for your game. Frame time is in nanoseconds. */
+    /**
+     * Internal, override `GameLoop` for your game. Frame time is in nanoseconds. The first frame after StartLoop or
+     * Resume gets a delta of 0, not the time since the clock's origin or since the stop (DrawnUi.Rust game_loop).
+     */
     protected GameTick(frameTimeNanos: number): void;
     get IsPaused(): boolean;
     set IsPaused(value: boolean);

package/dist/controls/DrawnGame.js

@@ -34,11 +34,15 @@ export class DrawnGame extends SkiaLayout {
     /** Starts the game loop. */
     StartLoop(delayMs = 0) {
         this.appLoop ??= new ActionOnTickAnimator(this, (t) => this.GameTick(t));
+        this.LastFrameTimeNanos = 0; // the first frame of a (re)started loop has no previous one: its delta is 0
         this.appLoop.Start(delayMs);
     }
-    /** Internal, override `GameLoop` for your game. Frame time is in nanoseconds. */
+    /**
+     * Internal, override `GameLoop` for your game. Frame time is in nanoseconds. The first frame after StartLoop or
+     * Resume gets a delta of 0, not the time since the clock's origin or since the stop (DrawnUi.Rust game_loop).
+     */
     GameTick(frameTimeNanos) {
-        const deltaSeconds = (frameTimeNanos - this.LastFrameTimeNanos) / 1_000_000_000;
+        const deltaSeconds = this.LastFrameTimeNanos === 0 ? 0 : (frameTimeNanos - this.LastFrameTimeNanos) / 1_000_000_000;
         this.LastFrameTimeNanos = frameTimeNanos;
         this.GameLoop(deltaSeconds);
     }
@@ -49,7 +53,7 @@ export class DrawnGame extends SkiaLayout {
         this.OnPaused();
     }
     Resume() {
-        this.LastFrameTimeNanos = Math.round(performance.now() * 1_000_000);
+        this.LastFrameTimeNanos = 0; // the frame clock restarts: the next delta is 0
         this.IsPaused = false;
         this.OnResumed();
     }

package/dist/controls/GridStructure.d.ts

@@ -17,7 +17,7 @@ export declare class DefinitionInfo {
 /** Parses "*, 2*, Auto, 100" (or an array of the same values) into tracks. */
 export declare function ParseDefinitions(defs: string | GridLength[] | undefined): DefinitionInfo[];
 /** What the structure reads from a child: a control, or the slot of a recycled templated item (measured on a pooled view). */
-export type GridChild = Pick<SkiaControl, "IsVisible" | "Row" | "Column" | "RowSpan" | "ColumnSpan" | "HorizontalOptions" | "VerticalOptions" | "MinimumWidthRequest" | "MinimumHeightRequest" | "Margin" | "MeasuredSize" | "Measure">;
+export type GridChild = Pick<SkiaControl, "IsVisible" | "Row" | "Column" | "RowSpan" | "ColumnSpan" | "HorizontalOptions" | "VerticalOptions" | "MinimumWidthRequest" | "MinimumHeightRequest" | "HeightRequest" | "Margin" | "MeasuredSize" | "Measure">;
 /**
  * Port of DrawnUi SkiaGridStructure (itself adapted from the MAUI Grid manager). Works in POINTS: constraints come in
  * already reduced by the grid's padding, cells are returned relative to the padded box. Children are measured in
@@ -65,6 +65,18 @@ export declare class SkiaGridStructure {
     private ResolveStars;
     private ResolveStarColumns;
     private ResolveStarRows;
+    /**
+     * C# SizesAutoRow: the child decides the height of its single Auto row, so it is measured with the height that row
+     * could still grow to, not with the row's current size (drawnui-cross 6p).
+     */
+    private SizesAutoRow;
+    private static NeedFillY;
+    /**
+     * C# HeightOnAutoRow: the height the single Auto row could still grow to, unbounded for a vertical Fill child (which
+     * would take the whole constraint). The row's size so far came from a first pass at the grid's whole width, so a
+     * label wrapping in a star column was measured against its one-line height.
+     */
+    private HeightOnAutoRow;
     private MeasureKnownCells;
     private AvailableWidth;
     private AvailableHeight;

package/dist/controls/GridStructure.js

@@ -294,7 +294,20 @@ export class SkiaGridStructure {
     ResolveStarRows(heightConstraint) {
         this.ResolveStars(this.Rows, heightConstraint - this.GridHeight(), (c) => c.IsRowSpanStar, (v) => v.MeasuredSize.Units.Height);
     }
+    /**
+     * C# SizesAutoRow: the child decides the height of its single Auto row, so it is measured with the height that row
+     * could still grow to, not with the row's current size (drawnui-cross 6p).
+     */
+    SizesAutoRow(cell) { return cell.RowSpan === 1 && this.Rows[cell.Row].IsAuto; }
+    static NeedFillY(child) { return child.VerticalOptions === "Fill" && child.HeightRequest < 0; }
+    /**
+     * C# HeightOnAutoRow: the height the single Auto row could still grow to, unbounded for a vertical Fill child (which
+     * would take the whole constraint). The row's size so far came from a first pass at the grid's whole width, so a
+     * label wrapping in a star column was measured against its one-line height.
+     */
+    HeightOnAutoRow(cell, child) { return SkiaGridStructure.NeedFillY(child) ? Infinity : this.AvailableHeight(cell); }
     MeasureKnownCells() {
+        let autoRowGrew = false;
         for (const cell of this.cells) {
             if (!cell.NeedsKnownMeasurePass)
                 continue;
@@ -307,12 +320,30 @@ export class SkiaGridStructure {
                 continue;
             const child = this.children[cell.ViewIndex];
             const rect = this.GetCellBoundsFor(child);
-            this.MeasurePx(child, rect.Width, rect.Height);
+            if (child.IsVisible && this.SizesAutoRow(cell)) {
+                // the row grows to the child at its real width, within the room the grid has left
+                let grown = this.MeasurePx(child, rect.Width, this.HeightOnAutoRow(cell, child)).Height;
+                const available = this.AvailableHeight(cell);
+                if (isFinite(available) && grown > available)
+                    grown = available;
+                if (grown > this.Rows[cell.Row].Size) {
+                    this.Rows[cell.Row].Update(grown);
+                    autoRowGrew = true;
+                }
+            }
+            else
+                this.MeasurePx(child, rect.Width, rect.Height);
             if (cell.IsColumnSpanStar && cell.ColumnSpan > 1)
                 this.TrackSpan({ Key: `c${cell.Column}:${cell.ColumnSpan}`, Start: cell.Column, Length: cell.ColumnSpan, IsColumn: true, Requested: rect.Width });
             if (cell.IsRowSpanStar && cell.RowSpan > 1)
                 this.TrackSpan({ Key: `r${cell.Row}:${cell.RowSpan}`, Start: cell.Row, Length: cell.RowSpan, IsColumn: false, Requested: rect.Height });
         }
+        if (autoRowGrew) {
+            // star rows were resolved against the smaller Auto rows: they get what is left now, nothing when Auto took it all
+            SkiaGridStructure.ZeroOutStars(this.Rows);
+            if (this.heightConstraint - this.GridHeight() > 0)
+                this.ResolveStarRows(this.heightConstraint);
+        }
     }
     AvailableWidth(cell) {
         let w = 0, absolute = true;
@@ -390,10 +421,15 @@ export class SkiaGridStructure {
     RemeasureChildrenAtFinalCells() {
         for (const cell of this.cells) {
             const child = this.children[cell.ViewIndex];
+            if (!child.IsVisible)
+                continue;
             const rect = this.GetCellBoundsFor(child);
             if (rect.Width <= 0 || rect.Height <= 0)
                 continue;
-            const m = this.MeasurePx(child, rect.Width, rect.Height);
+            // on an Auto row a child that is not Fill vertically keeps the height the row can grow to, as in
+            // MeasureKnownCells: the same request returns at once, and wrapped text is not cut to the row
+            const height = this.SizesAutoRow(cell) && !SkiaGridStructure.NeedFillY(child) ? Math.max(rect.Height, this.AvailableHeight(cell)) : rect.Height;
+            const m = this.MeasurePx(child, rect.Width, height);
             if (cell.ColumnSpan === 1 && this.Columns[cell.Column].IsAuto && m.Width > this.Columns[cell.Column].Size)
                 this.Columns[cell.Column].Update(m.Width);
             if (cell.RowSpan === 1 && this.Rows[cell.Row].IsAuto && m.Height > this.Rows[cell.Row].Size)

package/dist/controls/SkiaButton.d.ts

@@ -26,7 +26,17 @@ export declare class SkiaButton extends SkiaLayout {
     StrokeColor: Color;
     StrokeWidth: number;
     IsPressed: boolean;
-    IsDisabled: boolean;
+    private respondsToGestures;
+    /**
+     * False switches the button off for the user: taps, presses and keyboard activation do nothing (no Tapped, Down, Up),
+     * a tap on it does not reach controls under it, and screen readers report it disabled. Code can still change it.
+     * Same property as on toggles, sliders, scrolls and drawers (drawnui-cross 6w). Default true.
+     */
+    get RespondsToGestures(): boolean;
+    set RespondsToGestures(v: boolean);
+    /** @deprecated The opposite of RespondsToGestures, which every control uses: set `RespondsToGestures = false`. */
+    get IsDisabled(): boolean;
+    set IsDisabled(v: boolean);
     LockPanning: boolean;
     /** Touch feedback played on Down (DrawnUi SkiaButton.ApplyEffect). */
     ApplyEffect: SkiaTouchAnimation;
@@ -43,7 +53,7 @@ export declare class SkiaButton extends SkiaLayout {
     static DefaultAccessibilityRole?: string;
     protected DefaultAccessibilityLabel(): string | undefined;
     protected DefaultAccessibilityCanInteract(): boolean;
-    /** A disabled button ignores taps, so keyboard navigation skips it too. */
+    /** With RespondsToGestures = false the button ignores taps, keyboard navigation skips it and it is reported disabled. */
     protected AcceptsInput(): boolean;
     /** The button's own BackgroundColor/CornerRadius/Stroke are the frame's; the button itself paints nothing. */
     protected PaintBackground(): void;

package/dist/controls/SkiaButton.js

@@ -26,7 +26,20 @@ export class SkiaButton extends SkiaLayout {
     StrokeColor = Colors.Transparent;
     StrokeWidth = 0;
     IsPressed = false;
-    IsDisabled = false;
+    respondsToGestures = true;
+    /**
+     * False switches the button off for the user: taps, presses and keyboard activation do nothing (no Tapped, Down, Up),
+     * a tap on it does not reach controls under it, and screen readers report it disabled. Code can still change it.
+     * Same property as on toggles, sliders, scrolls and drawers (drawnui-cross 6w). Default true.
+     */
+    get RespondsToGestures() { return this.respondsToGestures; }
+    set RespondsToGestures(v) { if (this.respondsToGestures !== v) {
+        this.respondsToGestures = v;
+        this.NotifyAccessibility();
+    } }
+    /** @deprecated The opposite of RespondsToGestures, which every control uses: set `RespondsToGestures = false`. */
+    get IsDisabled() { return !this.respondsToGestures; }
+    set IsDisabled(v) { this.RespondsToGestures = !v; }
     LockPanning = false;
     /** Touch feedback played on Down (DrawnUi SkiaButton.ApplyEffect). */
     ApplyEffect = "Ripple"; // C# default
@@ -60,9 +73,9 @@ export class SkiaButton extends SkiaLayout {
     /** Set to `Aria.RoleButton` to expose every button (React extension). */
     static DefaultAccessibilityRole;
     DefaultAccessibilityLabel() { return this.Text || undefined; }
-    DefaultAccessibilityCanInteract() { return !this.IsDisabled; }
-    /** A disabled button ignores taps, so keyboard navigation skips it too. */
-    AcceptsInput() { return !this.IsDisabled; }
+    DefaultAccessibilityCanInteract() { return this.respondsToGestures; }
+    /** With RespondsToGestures = false the button ignores taps, keyboard navigation skips it and it is reported disabled. */
+    AcceptsInput() { return this.respondsToGestures; }
     /** The button's own BackgroundColor/CornerRadius/Stroke are the frame's; the button itself paints nothing. */
     PaintBackground() { }
     get UsingControlStyle() { return ResolveControlStyle(this.ControlStyle); }
@@ -130,8 +143,8 @@ export class SkiaButton extends SkiaLayout {
         this.Repaint();
     }
     ProcessGestures(args, apply) {
-        if (this.IsDisabled)
-            return null;
+        if (!this.respondsToGestures)
+            return this.BlockedGestureResult(args); // no press, no Down / Up / Tapped; a tap on it stops here
         const point = args.Event.Location;
         if (args.Type === "Down") {
             this.IsPressed = true;

package/dist/controls/SkiaCarousel.d.ts

@@ -101,7 +101,7 @@ export declare class SkiaCarousel extends SnappingLayout {
     private GetVirtualSnapPoints;
     protected GetVirtualAnchor(current: SKPoint): SnapPoint;
     protected FindNearestAnchorInternal(current: SKPoint, velocity: SKPoint): SKPoint;
-    /** C# SkiaCarousel.ScrollToNearestAnchor: velocity below 100 counts as none; looped snaps around virtual anchors. */
+    /** C# SkiaCarousel.ScrollToNearestAnchor: velocity below SnapVelocityThreshold counts as none; looped snaps around virtual anchors. */
     ScrollToNearestAnchor(location: SKPoint, velocity: SKPoint): void;
     /** C# SkiaCarousel.SelectNextAnchor: base choice, plus a wrap to the virtual anchor at the strip borders when looped. */
     SelectNextAnchor(origin: SKPoint, velocity: SKPoint): SKPoint;

package/dist/controls/SkiaCarousel.js

@@ -232,9 +232,10 @@ export class SkiaCarousel extends SnappingLayout {
         }
         return super.FindNearestAnchorInternal(current, velocity);
     }
-    /** C# SkiaCarousel.ScrollToNearestAnchor: velocity below 100 counts as none; looped snaps around virtual anchors. */
+    /** C# SkiaCarousel.ScrollToNearestAnchor: velocity below SnapVelocityThreshold counts as none; looped snaps around virtual anchors. */
     ScrollToNearestAnchor(location, velocity) {
-        velocity = new SKPoint(Math.abs(velocity.X) < 100 ? 0 : velocity.X, Math.abs(velocity.Y) < 100 ? 0 : velocity.Y);
+        const t = this.SnapVelocityThreshold;
+        velocity = new SKPoint(Math.abs(velocity.X) < t ? 0 : velocity.X, Math.abs(velocity.Y) < t ? 0 : velocity.Y);
         if (this.ApplyLoopedLogic) {
             const origin = this.FindNearestAnchorInternal(location, velocity);
             const target = this.SelectNextAnchor(origin, velocity);

package/dist/controls/SkiaEditor.d.ts

@@ -58,7 +58,8 @@ export declare class SkiaEditor extends SkiaShape {
     private readonly placeholder;
     private scrollX;
     private scrollY;
-    private blink;
+    /** The caret blinks on a timer, asleep between blinks: no frame runs while it waits (DrawnUi.Rust editor_rules). */
+    private blinkTimer;
     private caretVisible;
     private subscribed;
     private stubSelectionStop;
@@ -102,6 +103,9 @@ export declare class SkiaEditor extends SkiaShape {
     set CursorPosition(v: number);
     get SelectionLength(): number;
     set SelectionLength(v: number);
+    /** Shows the caret for a full half second, then blinks every 500 ms. */
+    private StartBlink;
+    private StopBlink;
     private OnCursorMoved;
     get IsFocused(): boolean;
     set IsFocused(v: boolean);

package/dist/controls/SkiaEditor.js

@@ -1,6 +1,5 @@
 import { SKPoint } from "../core/Gestures";
 import { Super } from "../core/Super";
-import { SkiaValueAnimator } from "../core/Animators";
 import { ResolveControlStyle } from "../core/ControlStyle";
 import { KeyboardManager } from "../core/KeyboardManager";
 import { TextInputProxy } from "../core/TextInputProxy";
@@ -67,7 +66,8 @@ export class SkiaEditor extends SkiaShape {
     placeholder = new SkiaLabel();
     scrollX = 0;
     scrollY = 0;
-    blink = new SkiaValueAnimator(this);
+    /** The caret blinks on a timer, asleep between blinks: no frame runs while it waits (DrawnUi.Rust editor_rules). */
+    blinkTimer = 0;
     caretVisible = true;
     subscribed = false;
     stubSelectionStop = -1;
@@ -98,15 +98,6 @@ export class SkiaEditor extends SkiaShape {
         this.placeholder.IsVisible = false;
         this.AddSubView(this.placeholder);
         this.AddSubView(this.Label);
-        this.blink.mMinValue = 0;
-        this.blink.mMaxValue = 1;
-        this.blink.Speed = 1000;
-        this.blink.Repeat = -1;
-        this.blink.OnUpdated = (v) => { const visible = v < 0.5; if (visible !== this.caretVisible) {
-            this.caretVisible = visible;
-            this.InvalidateCache();
-            this.RepaintComposition();
-        } };
         this.ApplyControlStyleVisuals();
         this.UpdateLabel();
     }
@@ -197,9 +188,22 @@ export class SkiaEditor extends SkiaShape {
         this.selectionLength = l;
         this.OnCursorMoved();
     }
+    /** Shows the caret for a full half second, then blinks every 500 ms. */
+    StartBlink() {
+        this.StopBlink();
+        this.caretVisible = true;
+        this.blinkTimer = window.setInterval(() => { this.caretVisible = !this.caretVisible; this.InvalidateCache(); this.RepaintComposition(); }, 500);
+    }
+    StopBlink() { if (this.blinkTimer) {
+        clearInterval(this.blinkTimer);
+        this.blinkTimer = 0;
+    } }
     OnCursorMoved() {
         this.ScrollToCaret();
-        this.caretVisible = true;
+        if (this.isFocused)
+            this.StartBlink();
+        else
+            this.caretVisible = true;
         TextInputProxy.Sync(this);
         this.CursorMoved?.(this);
         this.InvalidateCache();
@@ -215,8 +219,7 @@ export class SkiaEditor extends SkiaShape {
                 SkiaEditor.Focused.IsFocused = false;
             SkiaEditor.Focused = this;
             this.SetFocusNative(true);
-            this.caretVisible = true;
-            this.blink.Start();
+            this.StartBlink();
         }
         else {
             if (SkiaEditor.Focused === this)
@@ -225,7 +228,7 @@ export class SkiaEditor extends SkiaShape {
             this.dragSelecting = false;
             this.stubSelectionStop = -1;
             this.selectionMovingEdge = -1;
-            this.blink.Stop();
+            this.StopBlink();
             this.SetFocusNative(false);
         }
         this.FocusChanged?.(this, v);
@@ -819,8 +822,7 @@ export class SkiaEditor extends SkiaShape {
         return out;
     }
     OnDisposing() {
-        this.blink.Stop();
-        this.blink.Dispose();
+        this.StopBlink();
         if (SkiaEditor.Focused === this)
             SkiaEditor.Focused = undefined;
         this.SetFocusNative(false);

package/dist/controls/SkiaGif.d.ts

@@ -14,6 +14,8 @@ export declare class GifAnimation {
     private positionsMs;
     /** Negative = the last frame. */
     SeekFrame(frame: number): void;
+    /** Start (ms) of the frame after the one at `msTime`; DurationMs after the last one. */
+    NextFrameStartMs(msTime: number): number;
     GetFrameNumber(msTime: number): number;
     /** Decodes every frame of an encoded GIF (CanvasKit AnimatedImage). */
     LoadFromBytes(bytes: ArrayBuffer): void;
@@ -37,6 +39,7 @@ export declare class SkiaGif extends AnimatedFramesRenderer {
     set Source(v: string);
     Start(delayMs?: number): void;
     protected OnAnimatorUpdated(value: number): void;
+    protected NextChangeMs(value: number): number | undefined;
     /** Seeks by time in ms (the animator range is 0..DurationMs). */
     protected OnAnimatorSeeking(time: number): void;
     protected OnAnimatorInitializing(): void;

package/dist/controls/SkiaGif.js

@@ -21,6 +21,13 @@ export class GifAnimation {
         if (frame >= 0 && frame <= this.TotalFrames - 1)
             this.Frame = this.Frames[frame];
     }
+    /** Start (ms) of the frame after the one at `msTime`; DurationMs after the last one. */
+    NextFrameStartMs(msTime) {
+        for (let i = 0; i < this.positionsMs.length; i++)
+            if (msTime < this.positionsMs[i])
+                return this.positionsMs[i];
+        return this.DurationMs;
+    }
     GetFrameNumber(msTime) {
         if (this.positionsMs.length === 0 || this.DurationMs <= 0)
             return 0;
@@ -87,7 +94,9 @@ export class SkiaGif extends AnimatedFramesRenderer {
     loadGeneration = 0;
     constructor() {
         super();
-        this.UseCache = "ImageDoubleBuffered";
+        // C# ImageDoubleBuffered pays off where a thread bakes the bitmap; on the web it is one offscreen pass per frame
+        // change, so the web engines draw a GIF frame with no cache (drawnui-cross rule 3)
+        this.UseCache = "None";
     }
     get Source() { return this.source; }
     set Source(v) { if (this.source !== v) {
@@ -97,6 +106,7 @@ export class SkiaGif extends AnimatedFramesRenderer {
     Start(delayMs = 0) { if ((this.Animation?.TotalFrames ?? 0) > 0)
         super.Start(delayMs); }
     OnAnimatorUpdated(value) { this.Seek(value); }
+    NextChangeMs(value) { return this.Animation && this.Animation.DurationMs > 0 ? this.Animation.NextFrameStartMs(value) : undefined; }
     /** Seeks by time in ms (the animator range is 0..DurationMs). */
     OnAnimatorSeeking(time) {
         const a = this.Animation;

package/dist/controls/SkiaImage.js

@@ -164,20 +164,25 @@ export class SkiaImage extends SkiaControl {
     MeasureAbsolute(widthConstraint, heightConstraint, scale) {
         const img = this.LoadedSource;
         let w = widthConstraint, h = heightConstraint;
-        if (img) {
-            const aspect = img.width() / img.height();
-            if (!isFinite(w) && isFinite(h))
-                w = h * aspect;
-            else if (!isFinite(h) && isFinite(w))
-                h = w / aspect;
+        // nothing loaded: the box it is offered (C# OnMeasuring), an unbounded side 0
+        if (!img) {
+            this.AspectScale = { X: 0, Y: 0 };
+            return ScaledSize.FromPixels(isFinite(w) ? w : 0, isFinite(h) ? h : 0, scale);
         }
-        if (!isFinite(w) || !isFinite(h)) {
+        const iw = img.width(), ih = img.height();
+        if (!isFinite(w) && isFinite(h))
+            w = h * iw / ih;
+        else if (!isFinite(h) && isFinite(w))
+            h = w * ih / iw;
+        if (!isFinite(w) || !isFinite(h) || iw <= 0 || ih <= 0) {
             this.AspectScale = { X: 0, Y: 0 };
             return ScaledSize.FromPixels(0, 0, scale);
         }
-        if (img)
-            this.AspectScale = SkiaImage.RescaleAspect(img.width(), img.height(), SKRect.Create(0, 0, w, h), this.Aspect);
-        return ScaledSize.FromPixels(w, h, scale);
+        // C# OnMeasuring / DrawnUi.Rust: an auto-sized side is the bitmap's pixels scaled by the aspect for this box, never
+        // more than the box (a Fill or requested side still takes its box in Measure)
+        const s = SkiaImage.RescaleAspect(iw, ih, SKRect.Create(0, 0, w, h), this.Aspect);
+        this.AspectScale = s;
+        return ScaledSize.FromPixels(Math.min(iw * s.X, w), Math.min(ih * s.Y, h), scale);
     }
     Paint(ctx) {
         const img = this.LoadedSource;