func (w *WidgetBase) AddBinding(b Unbinder) {
	if b == nil {
		return
	}
	w.mu.Lock()
	defer w.mu.Unlock()
	w.bindings = append(w.bindings, b)
}

func (w *WidgetBase) AddChild(child Widget) {
	if child == nil {
		return
	}
	w.mu.Lock()
	defer w.mu.Unlock()
	w.children = append(w.children, child)
	// Try to set parent if child supports it
	if setter, ok := child.(interface{ SetParent(Widget) }); ok {
		// Note: We can't pass w here because we only have *WidgetBase, not the containing widget
		// The parent should be set by the containing widget type if needed
		_ = setter	// Avoid unused variable
	}
}

func (w *WidgetBase) AddEffect(e Stopper) {
	if e == nil {
		return
	}
	w.mu.Lock()
	defer w.mu.Unlock()
	w.effects = append(w.effects, e)
}

func (w *WidgetBase) Bounds() geometry.Rect {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.bounds
}

func (w *WidgetBase) ChildAt(index int) Widget {
	w.mu.RLock()
	defer w.mu.RUnlock()
	if index < 0 || index >= len(w.children) {
		return nil
	}
	return w.children[index]
}

func (w *WidgetBase) ChildCount() int {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return len(w.children)
}

func (w *WidgetBase) Children() []Widget {
	w.mu.RLock()
	defer w.mu.RUnlock()
	if len(w.children) == 0 {
		return nil
	}
	// Return a copy to prevent modification
	result := make([]Widget, len(w.children))
	copy(result, w.children)
	return result
}

func (w *WidgetBase) CleanupBindings() {
	w.mu.Lock()
	bindings := w.bindings
	effects := w.effects
	w.bindings = nil
	w.effects = nil
	w.mu.Unlock()

	for _, b := range bindings {
		b.Unbind()
	}
	for _, e := range effects {
		e.Stop()
	}
}

func (w *WidgetBase) ClearChildren() {
	w.mu.Lock()
	defer w.mu.Unlock()
	// Clear references for GC
	for i := range w.children {
		w.children[i] = nil
	}
	w.children = w.children[:0]
}

func (w *WidgetBase) ClearCompositorClip() {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.compositorClip = geometry.Rect{}
	w.hasCompositorClip = false
}

func (w *WidgetBase) ClearRedraw() {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.needsRedraw = false
}

func (w *WidgetBase) CompositorClip() geometry.Rect {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.compositorClip
}

func (w *WidgetBase) ContainsPoint(p geometry.Point) bool {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.bounds.Contains(p)
}

func (w *WidgetBase) GlobalToLocal(p geometry.Point) geometry.Point {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return p.Sub(w.screenOrigin)
}

func (w *WidgetBase) HasChildren() bool {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return len(w.children) > 0
}

func (w *WidgetBase) HasCompositorClip() bool {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.hasCompositorClip
}

func (w *WidgetBase) ID() string {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.id
}

func (w *WidgetBase) InsertChild(index int, child Widget) {
	if child == nil {
		return
	}
	w.mu.Lock()
	defer w.mu.Unlock()
	if index < 0 {
		index = 0
	}
	if index >= len(w.children) {
		w.children = append(w.children, child)
		return
	}
	// Insert at index
	w.children = append(w.children, nil)
	copy(w.children[index+1:], w.children[index:])
	w.children[index] = child
}

func (w *WidgetBase) IsEnabled() bool {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.enabled
}

func (w *WidgetBase) IsFocused() bool {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.focused
}

func (w *WidgetBase) IsMounted() bool {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.mounted
}

func (w *WidgetBase) IsScreenOriginValid() bool {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.screenOriginValid
}

func (w *WidgetBase) IsVisible() bool {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.visible
}

func (w *WidgetBase) LocalToGlobal(p geometry.Point) geometry.Point {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return p.Add(w.screenOrigin)
}

func (w *WidgetBase) MarkRedrawLocal() {
	w.markDirtyLocal()
}

func (w *WidgetBase) NeedsRedraw() bool {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.needsRedraw
}

func NewWidgetBase() *WidgetBase {
	return &WidgetBase{
		visible:	true,
		enabled:	true,
		needsRedraw:	true,
	}
}

func (w *WidgetBase) Parent() Widget {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.parent
}

func (w *WidgetBase) Position() geometry.Point {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.bounds.Min
}

func (w *WidgetBase) RemoveChild(child Widget) bool {
	if child == nil {
		return false
	}
	w.mu.Lock()
	defer w.mu.Unlock()
	for i, c := range w.children {
		if c != child {
			continue
		}
		// Remove by replacing with last element and truncating
		lastIdx := len(w.children) - 1
		w.children[i] = w.children[lastIdx]
		w.children[lastIdx] = nil	// Clear reference for GC
		w.children = w.children[:lastIdx]
		return true
	}
	return false
}

func (w *WidgetBase) RemoveChildAt(index int) Widget {
	w.mu.Lock()
	defer w.mu.Unlock()
	if index < 0 || index >= len(w.children) {
		return nil
	}
	child := w.children[index]
	// Remove while preserving order
	copy(w.children[index:], w.children[index+1:])
	w.children[len(w.children)-1] = nil	// Clear reference for GC
	w.children = w.children[:len(w.children)-1]
	return child
}

func (w *WidgetBase) ScreenBounds() geometry.Rect {
	w.mu.RLock()
	defer w.mu.RUnlock()
	size := w.bounds.Size()
	return geometry.FromPointSize(w.screenOrigin, size)
}

func (w *WidgetBase) ScreenOrigin() geometry.Point {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.screenOrigin
}

func (w *WidgetBase) SetBounds(bounds geometry.Rect) {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.bounds = bounds
}

func (w *WidgetBase) SetCompositorClip(clip geometry.Rect) {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.compositorClip = clip
	w.hasCompositorClip = true
}

func (w *WidgetBase) SetEnabled(enabled bool) {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.enabled = enabled
}

func (w *WidgetBase) SetFocused(focused bool) {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.focused = focused
}

func (w *WidgetBase) SetID(id string) {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.id = id
}

func (w *WidgetBase) SetMounted(m bool) {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.mounted = m
}

func (w *WidgetBase) SetNeedsRedraw(v bool) {
	w.mu.Lock()
	alreadyDirty := w.needsRedraw
	w.needsRedraw = v
	isBoundary := w.isRepaintBoundary
	parent := w.parent
	w.mu.Unlock()

	// Propagate upward only when setting dirty, and only if not already dirty
	// (O(1) guard prevents redundant walks).
	if v && !alreadyDirty {
		// Flutter markNeedsPaint: if THIS widget is a RepaintBoundary,
		// invalidate its own scene and stop — don't propagate to parent.
		// This is critical for animated widgets (spinner): dirty stays
		// at the spinner's boundary, parent tree stays clean.
		if isBoundary {
			w.InvalidateScene()
			return
		}
		propagateDirtyUpward(parent)
	}
}

func (w *WidgetBase) SetParent(parent Widget) {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.parent = parent
}

func (w *WidgetBase) SetScreenOrigin(origin geometry.Point) {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.screenOrigin = origin
	w.screenOriginValid = true
}

func (w *WidgetBase) SetVisible(visible bool) {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.visible = visible
}

func (w *WidgetBase) Size() geometry.Size {
	w.mu.RLock()
	defer w.mu.RUnlock()
	return w.bounds.Size()
}

type WidgetBase struct {
	mu			sync.RWMutex
	bounds			geometry.Rect	// Cached layout bounds
	screenOrigin		geometry.Point	// Window-space origin, set during Draw pass
	screenOriginValid	bool		// true after first StampScreenOrigin call
	focused			bool		// Whether widget has focus
	visible			bool		// Whether widget is visible
	enabled			bool		// Whether widget accepts input
	needsRedraw		bool		// Whether widget needs re-rendering (retained mode)
	id			string		// Optional ID for debugging
	children		[]Widget	// Child widgets
	parent			Widget		// Parent widget (if any)
	bindings		[]Unbinder	// Signal bindings (cleaned up on unmount)
	effects			[]Stopper	// Effects (stopped on unmount)
	mounted			bool		// Whether widget is currently mounted

	// --- RepaintBoundary property (ADR-024) ---
	// When isRepaintBoundary is true, this widget owns a scene.Scene that
	// caches its subtree rendering. Clean boundaries replay cached content
	// instead of re-executing Draw on every descendant.
	isRepaintBoundary	bool
	boundaryCacheKey	uint64		// Unique ID for dirty-set deduplication
	cachedScene		*scene.Scene	// Recorded display list for the subtree
	sceneDirty		bool		// Whether the cached scene needs re-recording
	sceneCacheVersion	uint64		// Monotonic counter (increments on re-record)
	sceneCacheWidth		int		// Cache dimensions for size-change detection
	sceneCacheHeight	int		// Cache dimensions for size-change detection
	onBoundaryDirty		func()		// Callback when boundary transitions to dirty
	suppressDirtyCallback	bool		// Suppressed during Draw recording (animation defers render)

	// --- Compositor clip (for per-boundary GPU textures) ---
	// When this boundary is skipped during parent BoundaryRecording (DrawChild),
	// the parent's current clip rect is stored here in screen-space coordinates.
	// compositeTextures uses this to skip/clip textures outside the viewport
	// (e.g., ListView items scrolled outside ScrollView bounds).
	compositorClip		geometry.Rect
	hasCompositorClip	bool
}

type Unbinder interface {
	Unbind()
}

type Stopper interface {
	Stop()
}