func (g *Group) Children() []widget.Widget {
	g.mu.RLock()
	defer g.mu.RUnlock()

	children := make([]widget.Widget, len(g.items))
	for i, it := range g.items {
		children[i] = it
	}
	return children
}

func (g *Group) Draw(ctx widget.Context, canvas widget.Canvas) {
	// Copy items under lock, then draw without holding the lock.
	// Item.Draw calls g.isSelected which acquires RLock — holding
	// RLock here would deadlock if a Lock waiter exists (RWMutex
	// is not reentrant in Go).
	g.mu.RLock()
	items := make([]*Item, len(g.items))
	copy(items, g.items)
	g.mu.RUnlock()

	// Items are positioned in local coordinates (0,0)-based.
	// Push the group's position so items render at the correct screen location.
	canvas.PushTransform(g.Bounds().Min)
	for _, it := range items {
		widget.StampScreenOrigin(it, canvas)
		it.Draw(ctx, canvas)
	}
	canvas.PopTransform()
}

func (g *Group) Event(ctx widget.Context, e event.Event) bool {
	// Copy items under lock, then dispatch without holding the lock.
	// Item event handlers may call back into Group (selectValue),
	// which requires a write lock — holding RLock here would deadlock.
	g.mu.RLock()
	items := make([]*Item, len(g.items))
	copy(items, g.items)
	g.mu.RUnlock()

	// For mouse events, translate to Group-local coordinates and hit-test.
	// This mirrors PushTransform(g.Bounds().Min) used in Draw.
	// MouseEnter/MouseLeave are about the Group container, not items —
	// items get their own Enter/Leave from updateHover. Do NOT forward
	// these to children, otherwise items set Pointer cursor on the
	// entire container area.
	if me, ok := e.(*event.MouseEvent); ok {
		if me.MouseType == event.MouseEnter || me.MouseType == event.MouseLeave {
			return false
		}
		local := *me
		local.Position = me.Position.Sub(g.Bounds().Min)
		for _, it := range items {
			if it.Bounds().Contains(local.Position) && it.Event(ctx, &local) {
				return true
			}
		}
		return false
	}

	for _, it := range items {
		if it.Event(ctx, e) {
			return true
		}
	}
	return false
}

func (g *Group) IsFocusable() bool {
	return false
}

func (g *Group) ItemAt(index int) *Item {
	g.mu.RLock()
	defer g.mu.RUnlock()
	return g.items[index]
}

func (g *Group) ItemCount() int {
	g.mu.RLock()
	defer g.mu.RUnlock()
	return len(g.items)
}

func (g *Group) Layout(ctx widget.Context, constraints geometry.Constraints) geometry.Size {
	g.mu.RLock()
	defer g.mu.RUnlock()

	if len(g.items) == 0 {
		return geometry.Size{}
	}

	var preferred geometry.Size
	if g.cfg.direction == Vertical {
		preferred = g.layoutVertical(ctx, constraints)
	} else {
		preferred = g.layoutHorizontal(ctx, constraints)
	}

	return constraints.Constrain(preferred)
}

func (g *Group) Mount(ctx widget.Context) {
	sched := ctx.Scheduler()
	if sched == nil {
		return
	}
	if g.cfg.selectedSignal != nil {
		b := state.BindToScheduler(g.cfg.selectedSignal, g, sched)
		g.AddBinding(b)
	}
	if g.cfg.readonlyDisabledSig != nil {
		b := state.BindToScheduler(g.cfg.readonlyDisabledSig, g, sched)
		g.AddBinding(b)
	} else if g.cfg.disabledSignal != nil {
		b := state.BindToScheduler(g.cfg.disabledSignal, g, sched)
		g.AddBinding(b)
	}
}

func NewGroup(opts ...GroupOption) *Group {
	g := &Group{
		selected: -1,
	}
	g.SetVisible(true)
	g.SetEnabled(true)

	for _, opt := range opts {
		opt(&g.cfg)
	}

	// Determine the painter.
	painter := Painter(DefaultPainter{})
	if g.cfg.painter != nil {
		painter = g.cfg.painter
	}

	// Create items from definitions.
	for _, def := range g.cfg.items {
		it := newItem(def, g, painter)
		g.items = append(g.items, it)
	}

	// Apply initial selection.
	// Use ResolvedSelected to support signal-based initial values.
	initialSelected := g.cfg.ResolvedSelected()
	if initialSelected != "" {
		for i, it := range g.items {
			if it.value == initialSelected {
				g.selected = i
				break
			}
		}
	}

	// ADR-028: parent chain for upward dirty propagation.
	// Flutter: RenderObject.adoptChild sets parent on each child.
	for _, it := range g.items {
		it.SetParent(g)
	}

	return g
}

func (g *Group) Select(value string) {
	g.mu.Lock()
	defer g.mu.Unlock()
	g.setSelectedLocked(value)
}

func (g *Group) Selected() string {
	g.mu.RLock()
	defer g.mu.RUnlock()
	if g.cfg.selectedSignal != nil {
		return g.cfg.selectedSignal.Get()
	}
	if g.selected < 0 || g.selected >= len(g.items) {
		return ""
	}
	return g.items[g.selected].value
}

func (g *Group) Unmount() {
	// Bindings are cleaned up automatically by WidgetBase.CleanupBindings().
}

type Group struct {
	widget.WidgetBase
	mu		sync.RWMutex
	cfg		groupConfig
	items		[]*Item
	selected	int	// index of selected item, -1 = none
}