Interface StackNode

Linear layout container - lays its children sequentially along direction (row = left -> right, column = top -> bottom) with gap between them.

Sizing:

• If width/height is set on the relevant axis, that size is used.
• If omitted on the flow axis, the stack hugs the sum of children sizes (including their margin) + gaps on that axis.
• If omitted on the cross axis, the stack hugs the maximum of children sizes (including their margin) on that axis.
• The fractional-Length rule applies per-axis: a child's fractional width/height on an auto-sized axis does not contribute to the stack's hug there (it would be circular) and resolves against the stack's final size at layout; the hug comes from "Npx"/intrinsic children.

Positioning of stacked children (unified with GroupNode's slot model - every child sits in a slot in the parent's inner area):

• The stack flow distribution gives each child a slot whose flow extent matches its allocation and whose cross extent is the stack's full inner cross span. Inside that slot, size and position follow the same rules as for a group child: insets, explicit width/height, centerX/centerY, and min/max clamping. The only stack-specific extras are align (default cross positioning when no centre/inset is set) and the autofill rule on the cross axis (see below).
• Size on each axis, in priority order:
  1. Dual inset on the axis -> fillSize - a - b (fillSize = slot size minus the child's margin on the axis).
  2. Explicit width/height -> as declared.
  3. Single inset on the axis with autofill -> fillSize - inset.
  4. Autofill (no inset, no explicit) -> fillSize.
  5. Intrinsic. Autofill applies to: rect children always; non-rect children only when nothing pins the axis - no inset and no centerX/centerY on it (on the cross axis align: stretch is additionally required). A single inset anchors a non-rect at its intrinsic size - exactly as in a group - while a rect still autofills from the anchor. min/max constraints do not change the regime - they clamp the autofilled size like any other computed size. So a rect with no height and centerY: 0 autofills the cross slot (and centerY: 0 is moot since the fill already centres it); the same rect with height: "8px" and centerY: 0 is 8px tall and centred.
• Position on each axis, in priority order:
  1. Leading inset (left/top) -> fillStart + inset.
  2. Trailing inset alone -> fillEnd - inset - size.
  3. centerX/centerY -> fillStart + (fillSize - size)/2 + value.
  4. Cross axis with no positional field -> align.
  5. Otherwise -> fillStart. Insets and centerX/centerY resolve against the slot's size (both the anchor and the fraction's multiplier live in the slot); explicit dims and min/max resolve against the stack's inner size.
• Negative single inset on rect autofill: left: "-4px" with no width autofills fillSize - (-4) = fillSize + 4 and anchors at fillStart + (-4) - the rect extends 4px past the leading slot edge while still reaching the trailing edge. Same idea on any axis. If a single inset places the child fully outside the slot, autofill collapses to size 0.
• align still controls cross positioning for children with no cross-axis positional field. stretch (the default) is the autofill trigger for non-rect children. Per-child align overrides are not supported.
• Positional tweens target def[prop] so they inherit the same rules. A { property: "centerY", from: -1 } on a row-stack child animates the cross centre offset (slot-relative). A { property: "top", from: "30px" } on a row-stack child shifts the autofill range / single-inset anchor over time.