func (c *ContextImpl) BeginFrame(now time.Time) {
	c.mu.Lock()
	defer c.mu.Unlock()
	dt := now.Sub(c.lastFrame)
	if dt < 0 {
		dt = 0
	}
	if dt > maxDeltaTime {
		dt = maxDeltaTime
	}
	c.deltaTime = dt
	c.lastFrame = now
	c.now = now
}

func (c *ContextImpl) CapturePointer(w Widget) {
	c.mu.RLock()
	cb := c.onCapturePointer
	c.mu.RUnlock()
	if cb != nil {
		cb(w)
	}
}

func (c *ContextImpl) ClearInvalidation() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.invalidated = false
	c.invalidateRect = geometry.Rect{}
}

func (c *ContextImpl) Cursor() CursorType {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.cursor
}

func (c *ContextImpl) DeltaTime() time.Duration {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.deltaTime
}

func (c *ContextImpl) DirtyTracker() DirtyTrackerRef {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.dirtyTracker
}

func (c *ContextImpl) DrawStats() *DrawStats {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.drawStats
}

func (c *ContextImpl) FocusedWidget() Widget {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.focusedWidget
}

func (c *ContextImpl) ImageCache() ImageCacheRef {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.imageCache
}

func (c *ContextImpl) Invalidate() {
	c.mu.Lock()
	c.invalidated = true
	callback := c.onInvalidate
	c.mu.Unlock()

	if callback != nil {
		callback()
	}
}

func (c *ContextImpl) InvalidateRect(r geometry.Rect) {
	c.mu.Lock()
	if c.invalidated {
		// Already doing a full invalidation, no need for partial
		c.mu.Unlock()
		return
	}
	if c.invalidateRect.IsEmpty() {
		c.invalidateRect = r
	} else {
		c.invalidateRect = c.invalidateRect.Union(r)
	}
	callback := c.onInvalidateRect
	c.mu.Unlock()

	if callback != nil {
		callback(r)
	}
}

func (c *ContextImpl) InvalidatedRect() geometry.Rect {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.invalidateRect
}

func (c *ContextImpl) IsFocused(w Widget) bool {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.focusedWidget == w
}

func (c *ContextImpl) IsInvalidated() bool {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.invalidated
}

func NewContext() *ContextImpl {
	now := time.Now()
	return &ContextImpl{
		now:		now,
		lastFrame:	now,
		scale:		1.0,
		cursor:		CursorDefault,
	}
}

func (c *ContextImpl) Now() time.Time {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.now
}

func (c *ContextImpl) OverlayManager() OverlayManager {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.overlayManager
}

func (c *ContextImpl) RegisterDirtyBoundary(key uint64) {
	c.mu.RLock()
	cb := c.onRegisterDirtyBoundary
	c.mu.RUnlock()
	if cb != nil {
		cb(key)
	}
}

func (c *ContextImpl) ReleaseFocus(w Widget) {
	c.mu.Lock()
	defer c.mu.Unlock()

	if c.focusedWidget != w {
		return	// Widget doesn't have focus
	}

	if setter, ok := c.focusedWidget.(interface{ SetFocused(bool) }); ok {
		setter.SetFocused(false)
	}
	c.focusedWidget = nil
}

func (c *ContextImpl) ReleasePointer(w Widget) {
	c.mu.RLock()
	cb := c.onReleasePointer
	c.mu.RUnlock()
	if cb != nil {
		cb(w)
	}
}

func (c *ContextImpl) RequestFocus(w Widget) {
	c.mu.Lock()
	defer c.mu.Unlock()

	if c.focusedWidget == w {
		return	// Already focused
	}

	// Clear focus from previous widget
	if c.focusedWidget != nil {
		if setter, ok := c.focusedWidget.(interface{ SetFocused(bool) }); ok {
			setter.SetFocused(false)
		}
	}

	// Set focus to new widget
	c.focusedWidget = w
	if w != nil {
		if setter, ok := w.(interface{ SetFocused(bool) }); ok {
			setter.SetFocused(true)
		}
	}
}

func (c *ContextImpl) ResetCursor() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.cursor = CursorDefault
}

func (c *ContextImpl) Scale() float32 {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.scale
}

func (c *ContextImpl) ScheduleAnimationFrame() {
	c.mu.RLock()
	cb := c.onScheduleAnimation
	c.mu.RUnlock()
	if cb != nil {
		cb()
		return
	}
	// Fallback: no animation scheduler wired → use immediate InvalidateRect.
	// This happens in headless tests and legacy contexts without Window.
	c.InvalidateRect(geometry.Rect{})
}

func (c *ContextImpl) Scheduler() SchedulerRef {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.scheduler
}

func (c *ContextImpl) SetCursor(cursor CursorType) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.cursor = cursor
}

func (c *ContextImpl) SetDirtyTracker(tracker DirtyTrackerRef) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.dirtyTracker = tracker
}

func (c *ContextImpl) SetDrawStats(stats *DrawStats) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.drawStats = stats
}

func (c *ContextImpl) SetImageCache(cache ImageCacheRef) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.imageCache = cache
}

func (c *ContextImpl) SetNow(now time.Time) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.now = now
}

func (c *ContextImpl) SetOnCapturePointer(callback func(w Widget)) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.onCapturePointer = callback
}

func (c *ContextImpl) SetOnInvalidate(callback func()) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.onInvalidate = callback
}

func (c *ContextImpl) SetOnInvalidateRect(callback func(geometry.Rect)) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.onInvalidateRect = callback
}

func (c *ContextImpl) SetOnRegisterDirtyBoundary(callback func(key uint64)) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.onRegisterDirtyBoundary = callback
}

func (c *ContextImpl) SetOnReleasePointer(callback func(w Widget)) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.onReleasePointer = callback
}

func (c *ContextImpl) SetOnScheduleAnimation(callback func()) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.onScheduleAnimation = callback
}

func (c *ContextImpl) SetOverlayManager(om OverlayManager) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.overlayManager = om
}

func (c *ContextImpl) SetScale(scale float32) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.scale = scale
}

func (c *ContextImpl) SetScheduler(s SchedulerRef) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.scheduler = s
}

func (c *ContextImpl) SetThemeProvider(tp ThemeProvider) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.themeProvider = tp
}

func (c *ContextImpl) SetWindowSize(size geometry.Size) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.windowSize = size
}

func (c CursorType) String() string {
	switch c {
	case CursorDefault:
		return "Default"
	case CursorPointer:
		return "Pointer"
	case CursorText:
		return "Text"
	case CursorCrosshair:
		return "Crosshair"
	case CursorMove:
		return "Move"
	case CursorResizeNS:
		return "ResizeNS"
	case CursorResizeEW:
		return "ResizeEW"
	case CursorResizeNESW:
		return "ResizeNESW"
	case CursorResizeNWSE:
		return "ResizeNWSE"
	case CursorNotAllowed:
		return "NotAllowed"
	case CursorWait:
		return "Wait"
	case CursorNone:
		return "None"
	default:
		return unknownStr
	}
}

func (c *ContextImpl) ThemeProvider() ThemeProvider {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.themeProvider
}

func (c *ContextImpl) WindowSize() geometry.Size {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.windowSize
}

type ContextImpl struct {
	mu	sync.RWMutex

	// Focus state
	focusedWidget	Widget

	// Time tracking
	now		time.Time
	lastFrame	time.Time
	deltaTime	time.Duration

	// Invalidation
	invalidated	bool
	invalidateRect	geometry.Rect

	// Cursor
	cursor	CursorType

	// Display scale
	scale	float32

	// Theme provider
	themeProvider	ThemeProvider

	// Callback for invalidation (called when Invalidate is called)
	onInvalidate	func()

	// Callback for invalidate rect (called when InvalidateRect is called)
	onInvalidateRect	func(geometry.Rect)

	// Callback for animation frame scheduling (deferred, not immediate)
	onScheduleAnimation	func()

	// Overlay manager
	overlayManager	OverlayManager

	// Window size
	windowSize	geometry.Size

	// Signal scheduler
	scheduler	SchedulerRef

	// drawStats collects per-frame rendering statistics during the draw pass.
	// Set by DrawTree/drawWidgetsInRegion before drawing, read by
	// RepaintBoundary to increment CachedWidgets on cache hit.
	drawStats	*DrawStats

	// dirtyTracker provides spatial dirty region queries during the draw pass.
	// Set by Window.DrawTo/drawIncremental before drawing, cleared after.
	// RepaintBoundary uses this for O(regions) fast path to avoid expensive
	// O(tree_depth) NeedsRedrawInTree checks when bounds don't intersect
	// any dirty region.
	dirtyTracker	DirtyTrackerRef

	// imageCache provides a centralized LRU cache for RepaintBoundary pixel
	// buffers. When set, RepaintBoundary uses this shared cache instead of
	// per-widget local cache fields. This enables memory budget enforcement
	// and LRU eviction across all boundaries in a window.
	// Set by Window during initialization, cleared on close.
	imageCache	ImageCacheRef

	// onRegisterDirtyBoundary is called when a RepaintBoundary transitions
	// from clean to dirty via upward propagation. The Window wires this
	// callback to AddDirtyBoundary during initialization, populating the
	// flat dirty boundary set for O(1) frame skip decisions.
	// This is the Flutter _nodesNeedingPaint.add() equivalent.
	onRegisterDirtyBoundary	func(key uint64)

	// onCapturePointer is called when a widget requests pointer capture
	// during drag operations (ADR-031). The Window wires this callback
	// to set capturedWidget. When set, mouse events are delivered directly
	// to the captured widget, bypassing tree hit-testing.
	onCapturePointer	func(w Widget)

	// onReleasePointer is called when a widget releases pointer capture.
	// The Window wires this callback to clear capturedWidget.
	onReleasePointer	func(w Widget)
}

type Context interface {
	// RequestFocus requests focus for the given widget.
	//
	// If another widget currently has focus, it will receive a focus lost event.
	// The widget parameter should implement the Widget interface.
	RequestFocus(w Widget)

	// ReleaseFocus releases focus from the given widget.
	//
	// If the widget doesn't have focus, this is a no-op.
	// After calling this, FocusedWidget() will return nil.
	ReleaseFocus(w Widget)

	// IsFocused returns true if the given widget currently has focus.
	IsFocused(w Widget) bool

	// FocusedWidget returns the currently focused widget, or nil if none.
	FocusedWidget() Widget

	// Now returns the current time.
	//
	// This is the time at the start of the current frame/event cycle.
	// Use this for animations and time-based effects.
	Now() time.Time

	// DeltaTime returns the time elapsed since the previous frame.
	//
	// This is useful for smooth animations that should be frame-rate independent.
	// Returns 0 for the first frame.
	DeltaTime() time.Duration

	// Invalidate marks the entire window as needing a redraw.
	//
	// Call this when widget state changes require visual updates.
	// Multiple calls per frame are coalesced into a single redraw.
	Invalidate()

	// InvalidateRect marks a specific rectangular area as needing a redraw.
	//
	// Use this for more efficient partial redraws when only a small
	// part of the UI has changed.
	InvalidateRect(r geometry.Rect)

	// Cursor returns the current cursor type.
	Cursor() CursorType

	// SetCursor changes the mouse cursor.
	//
	// The cursor is typically reset to CursorDefault at the start of each frame.
	SetCursor(cursor CursorType)

	// Scale returns the display scale factor (DPI scaling).
	//
	// Returns 1.0 for standard displays, 2.0 for Retina/HiDPI displays, etc.
	// Use this to scale coordinates and sizes for proper rendering.
	Scale() float32

	// ThemeProvider returns the current theme for this context.
	//
	// Returns nil if no theme is set (headless mode without a theme).
	// Widgets should check for nil before using the returned provider.
	ThemeProvider() ThemeProvider

	// OverlayManager returns the overlay manager for pushing/removing overlays.
	//
	// Returns nil if no overlay manager is set (headless mode without a window).
	// Widgets should check for nil before calling overlay methods.
	OverlayManager() OverlayManager

	// WindowSize returns the current window size in logical pixels.
	WindowSize() geometry.Size

	// Scheduler returns the signal scheduler for this context.
	//
	// Returns nil if no scheduler is set (headless mode without signal support).
	// Widgets should check for nil before using the returned scheduler.
	Scheduler() SchedulerRef
}

type SchedulerRef interface {
	MarkDirty(w Widget)
}

type OverlayManager interface {
	// PushOverlay pushes a widget as an overlay. The onDismiss callback is
	// called when the overlay should be closed (e.g. click outside, Escape key).
	PushOverlay(w Widget, onDismiss func())

	// PopOverlay removes the topmost overlay from the stack.
	PopOverlay()

	// RemoveOverlay removes a specific overlay widget from the stack.
	RemoveOverlay(w Widget)
}

type DirtyTrackerRef interface {
	// Intersects returns true if the given bounds intersect any dirty region.
	// Used by RepaintBoundary for O(regions) early exit: when bounds don't
	// overlap any dirty region, the subtree is guaranteed clean and the
	// expensive O(tree_depth) NeedsRedrawInTree walk can be skipped.
	Intersects(bounds geometry.Rect) bool
}

type DirtyTrackerProvider interface {
	DirtyTracker() DirtyTrackerRef
}

type DirtyBoundaryRegistrar interface {
	RegisterDirtyBoundary(key uint64)
}

type ImageCacheRef interface {
	// Get retrieves a cached image by key. Returns the image and true if
	// found, nil and false otherwise. On hit, the entry is promoted in LRU.
	Get(key uint64) (*image.RGBA, bool)

	// Put stores an image in the cache with the given key and version.
	// Evicts LRU entries if the memory budget is exceeded.
	Put(key uint64, img *image.RGBA, version uint64)

	// Invalidate removes a specific entry from the cache by key.
	Invalidate(key uint64)
}

type ImageCacheProvider interface {
	ImageCache() ImageCacheRef
}

type PointerCapturer interface {
	// CapturePointer requests exclusive mouse event delivery for the widget.
	// While captured, MouseMove, MouseRelease, and MousePress events are
	// delivered directly to this widget without tree hit-testing.
	// Only one widget can have capture at a time.
	CapturePointer(w Widget)

	// ReleasePointer releases the pointer capture. This is a no-op if the
	// given widget does not currently hold the capture.
	ReleasePointer(w Widget)
}

type AnimationScheduler interface {
	ScheduleAnimationFrame()
}