rotor-framework 0.7.2 → 0.7.3

package/README.md

@@ -96,7 +96,7 @@ You can find [🌱](./docs/ai/readme.opt.yaml) symbols in all documentation page
 
 ## 📚 Learn More
 
-![Version](https://img.shields.io/badge/version-v0.7.2-blue?label=Documents%20TAG)
+![Version](https://img.shields.io/badge/version-v0.7.3-blue?label=Documents%20TAG)
 
 ### Framework Core
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rotor-framework",
-	"version": "0.7.2",
+	"version": "0.7.3",
 	"description": "Roku toolkit library providing a ViewBuilder, full UI lifecycle with focus handling and many core features, plus MVI-based state management.",
 	"author": "Balázs Molnár",
 	"license": "Apache-2.0",

package/src/source/RotorFramework.bs

@@ -4,7 +4,7 @@
 ' ▐▛▀▚▖▐▌ ▐▌ █ ▐▌ ▐▌▐▛▀▚▖    ▐▛▀▀▘▐▛▀▚▖▐▛▀▜▌▐▌  ▐▌▐▛▀▀▘▐▌ ▐▌▐▌ ▐▌▐▛▀▚▖▐▛▚▖
 ' ▐▌ ▐▌▝▚▄▞▘ █ ▝▚▄▞▘▐▌ ▐▌    ▐▌   ▐▌ ▐▌▐▌ ▐▌▐▌  ▐▌▐▙▄▄▖▐▙█▟▌▝▚▄▞▘▐▌ ▐▌▐▌ ▐▌
 ' Rotor Framework™
-' Version 0.7.2
+' Version 0.7.3
 ' © 2025 Balázs Molnár — Apache License 2.0
 ' =========================================================================
 
@@ -21,8 +21,8 @@ import "engine/animator/Animator.bs"
 
 ' base classes
 import "base/BaseWidget.bs"
-import "base/DispatcherCreator.bs"
-import "base/DispatcherExternal.bs"
+import "base/DispatcherOriginal.bs"
+import "base/DispatcherCrossThread.bs"
 import "base/BaseReducer.bs"
 import "base/BaseModel.bs"
 import "base/BaseStack.bs"
@@ -86,7 +86,7 @@ namespace Rotor
     class Framework
 
         name = "Rotor Framework"
-        version = "0.7.2"
+        version = "0.7.3"
 
         config = {
             tasks: invalid, ' @array    (optional)
@@ -121,10 +121,8 @@ namespace Rotor
         ' plugin adapter workspace
         plugins = {}
 
-        ' sync
-        taskOperationalFlag = {}
-        taskSyncReadyFlag = {}
-        taskNodes = {}
+        ' sync - task tracking with phase: pending → operational → synced
+        tasks = {}                      ' taskId -> { node, phase, dispatchers[] }
 
         enableRendering = true
 
@@ -360,15 +358,17 @@ namespace Rotor
             taskNode = rootNode.createChild(taskName)
             taskId = Rotor.Utils.getUUIDHex(16)
 
-            m.taskNodes[taskId] = taskNode ' collection for later usage
-            m.taskOperationalFlag[taskId] = false ' collection for later usage
+            m.tasks[taskId] = {
+                node: taskNode,
+                phase: "pending",
+                dispatchers: []
+            }
 
             Rotor.Utils.setCustomFields(taskNode, {
                 taskId: taskId,
                 rootNode: rootNode
             })
 
-            ' taskNode.observeFieldScoped("rotorSync", "Rotor_syncCallback")
             taskNode.control = "RUN"
         end sub
 
@@ -378,136 +378,108 @@ namespace Rotor
         ' @param {object} taskList - Array of task names to set up
         '
         sub setupAdditionalTasks(taskList as object)
-            ' check additional tasks
             if taskList = invalid then return
-
-            taskNames = Rotor.Utils.ensureArray(taskList)
-            for each taskName in taskNames
+            for each taskName in Rotor.Utils.ensureArray(taskList)
                 m.setupTaskForSyncing(taskName)
             end for
         end sub
 
         ' ---------------------------------------------------------------------
-        ' areAllTasksOperational - Checks if all task threads are operational
+        ' allTasksInPhase - Checks if all tasks are in given phase
         '
-        ' @returns {boolean} True if all tasks have signaled operational status
+        ' @param {string} phase - Phase to check ("pending", "operational", "synced")
+        ' @returns {boolean} True if all tasks are in the given phase
         '
-        function areAllTasksOperational() as boolean
-            ' Check if all nodes ready (very basic logic (< future improvement)
-            if m.taskOperationalFlag.Count() = 0 then return false
-
-            for each flag in m.taskOperationalFlag.Items()
-                if flag.value <> true then return false
+        function allTasksInPhase(phase as string) as boolean
+            if m.tasks.Count() = 0 then return false
+            for each taskId in m.tasks
+                if m.tasks[taskId].phase <> phase then return false
             end for
-
             return true
         end function
 
         ' ---------------------------------------------------------------------
-        ' collectExternalDispatcherRegistrations - Collects external dispatcher info for tasks
-        '
-        ' Creates a map of which external dispatchers need to be registered in which tasks.
-        '
-        ' @returns {object} AA mapping taskId to array of dispatcher registration configs
-        '
-        function collectExternalDispatcherRegistrations() as object
-            registrations = {}
-            dispatcherIds = m.dispatcherProvider.getAll().keys()
-
-            for each taskEntry in m.taskNodes.Items()
-                taskNode = taskEntry.value
-
-                for each dispatcherId in dispatcherIds
-                    dispatcherInstance = m.dispatcherProvider.get(dispatcherId)
-                    externalTaskNode = dispatcherInstance.taskNode
-
-                    if not taskNode.isSameNode(externalTaskNode)
-                        m.taskSyncReadyFlag[taskNode.taskId] = false ' collection for later usage
-                        if registrations[taskNode.taskId] = invalid then registrations[taskNode.taskId] = []
-                        registrations[taskNode.taskId].push({
-                            dispatcherId: dispatcherId,
-                            externalTaskNode: externalTaskNode
-                        })
-                    end if
-                end for
+        ' getDispatchersNotOnTask - Gets dispatchers that are NOT on given task
+        '
+        ' @param {object} taskNode - Task node to exclude
+        ' @returns {object} Array of { dispatcherId, stateNode } for foreign dispatchers
+        '
+        function getDispatchersNotOnTask(taskNode as object) as object
+            result = []
+            for each dispatcherId in m.dispatcherProvider.getAll().keys()
+                stateNode = m.dispatcherProvider.get(dispatcherId).stateNode
+                if not taskNode.isSameNode(stateNode)
+                    result.push({ dispatcherId: dispatcherId, stateNode: stateNode })
+                end if
             end for
-
-            return registrations
+            return result
         end function
 
         ' ---------------------------------------------------------------------
-        ' dispatchExternalDispatcherRegistrations - Sends dispatcher registration to tasks
-        '
-        ' @param {object} registrations - Map of taskId to dispatcher registration configs
-        '
-        sub dispatchExternalDispatcherRegistrations(registrations as object)
-            for each taskId in registrations
-                taskNode = m.taskNodes[taskId]
-                taskNode.setField("rotorSync", {
-                    type: Rotor.Const.ThreadSyncType.REGISTER_EXTERNAL_DISPATCHER,
-                    externalDispatcherList: registrations[taskId]
-                })
+        ' broadcastDispatchersToTasks - Sends foreign dispatchers to each task
+        '
+        ' For each task, sends list of dispatchers that exist on other threads.
+        '
+        sub broadcastDispatchersToTasks()
+            for each taskId in m.tasks
+                task = m.tasks[taskId]
+                foreignDispatchers = m.getDispatchersNotOnTask(task.node)
+
+                if foreignDispatchers.Count() > 0
+                    task.node.setField("rotorSync", {
+                        type: Rotor.Const.ThreadSyncType.REGISTER_CROSS_THREAD_DISPATCHER,
+                        crossThreadDispatcherList: foreignDispatchers
+                    })
+                else
+                    task.phase = "synced"
+                end if
             end for
-        end sub
 
-        ' ---------------------------------------------------------------------
-        ' haveAllTasksSynced - Checks if all tasks have completed syncing
-        '
-        ' @returns {boolean} True if all tasks have synced successfully
-        '
-        function haveAllTasksSynced() as boolean
-            ' Check if all nodes ready (very basic logic (< future improvement)
-            if m.taskSyncReadyFlag.Count() = 0 then return false
-
-            for each flag in m.taskSyncReadyFlag.Items()
-                if flag.value <> true then return false
-            end for
-
-            return true
-        end function
+            ' If no tasks needed dispatchers, we're done
+            if m.allTasksInPhase("synced")
+                m.isReady()
+            end if
+        end sub
 
         ' ---------------------------------------------------------------------
         ' handleTaskSyncing - Handles task syncing phase
         '
-        ' Registers external dispatchers and sets up cross-thread communication.
+        ' Called when a task reports its dispatchers. Registers cross-thread
+        ' dispatchers and broadcasts dispatcher map when all tasks are ready.
         '
-        ' @param {object} sync - Sync payload from task thread
+        ' @param {object} sync - Sync payload { taskNode, dispatcherIds, tasks }
         '
         sub handleTaskSyncing(sync as object)
             taskNode = sync.taskNode
+            taskId = taskNode.taskId
 
+            ' Setup any additional tasks this task declared
             m.setupAdditionalTasks(sync.tasks)
 
-            ' register incoming dispatchers
-            dispatcherIds = sync.dispatcherIds
-            if dispatcherIds <> invalid
-                m.dispatcherProvider.registerExternalDispatchers(dispatcherIds, taskNode)
-            end if
+            ' Store dispatcher IDs for this task
+            m.tasks[taskId].dispatchers = sync.dispatcherIds ?? []
+            m.tasks[taskId].phase = "operational"
 
-            ' update task status
-            m.taskOperationalFlag[taskNode.taskId] = true
+            ' Register cross-thread dispatchers on render thread
+            if sync.dispatcherIds <> invalid
+                m.dispatcherProvider.registerCrossThreadDispatchers(sync.dispatcherIds, taskNode)
+            end if
 
-            if not m.areAllTasksOperational() then return
+            ' Wait for all tasks to be operational
+            if not m.allTasksInPhase("operational") then return
 
-            ' if allTasksRunning then create external dispatchers in all tasks
-            registrations = m.collectExternalDispatcherRegistrations()
-            if registrations.Count() > 0
-                m.dispatchExternalDispatcherRegistrations(registrations)
-            else
-                m.isReady()
-            end if
+            ' All tasks ready - broadcast dispatcher map
+            m.broadcastDispatchersToTasks()
         end sub
 
         ' ---------------------------------------------------------------------
         ' handleTaskSynced - Handles task synced confirmation
         '
-        ' Marks task as synced and checks if all tasks are ready.
-        '
         ' @param {string} taskId - ID of the task that has synced
         '
         sub handleTaskSynced(taskId as string)
-            m.taskSyncReadyFlag[taskId] = true
-            if m.haveAllTasksSynced()
+            m.tasks[taskId].phase = "synced"
+            if m.allTasksInPhase("synced")
                 m.isReady()
             end if
         end sub
@@ -549,15 +521,15 @@ namespace Rotor
         public sub destroy()
 
             rootNode = m.getRootNode()
-            for each taskId in m.taskNodes
-                taskNode = m.taskNodes[taskId]
-                taskNode.setField("rotorSync", {
+            for each taskId in m.tasks
+                task = m.tasks[taskId]
+                task.node.setField("rotorSync", {
                     type: Rotor.Const.ThreadSyncType.DESTROY
                 })
-                rootNode.removeChild(taskNode)
+                rootNode.removeChild(task.node)
             end for
 
-            m.taskNodes.Clear()
+            m.tasks.Clear()
 
             rootNode.unobserveFieldScoped("rotorSync")
 

package/src/source/RotorFrameworkTask.bs

@@ -4,7 +4,7 @@
 ' ▐▛▀▚▖▐▌ ▐▌ █ ▐▌ ▐▌▐▛▀▚▖    ▐▛▀▀▘▐▛▀▚▖▐▛▀▜▌▐▌  ▐▌▐▛▀▀▘▐▌ ▐▌▐▌ ▐▌▐▛▀▚▖▐▛▚▖
 ' ▐▌ ▐▌▝▚▄▞▘ █ ▝▚▄▞▘▐▌ ▐▌    ▐▌   ▐▌ ▐▌▐▌ ▐▌▐▌  ▐▌▐▙▄▄▖▐▙█▟▌▝▚▄▞▘▐▌ ▐▌▐▌ ▐▌
 ' Rotor Framework™
-' Version 0.7.2
+' Version 0.7.3
 ' © 2025 Balázs Molnár — Apache License 2.0
 ' =========================================================================
 
@@ -16,8 +16,8 @@ import "engine/providers/DispatcherProvider.bs"
 import "engine/providers/Dispatcher.bs"
 
 ' base classes
-import "base/DispatcherCreator.bs"
-import "base/DispatcherExternal.bs"
+import "base/DispatcherOriginal.bs"
+import "base/DispatcherCrossThread.bs"
 import "base/BaseReducer.bs"
 import "base/BaseModel.bs"
 import "base/BaseStack.bs"
@@ -70,7 +70,7 @@ namespace Rotor
     class FrameworkTask
 
         name = "Rotor Framework"
-        version = "0.7.2"
+        version = "0.7.3"
 
         config = {
             tasks: invalid, ' optional
@@ -87,6 +87,7 @@ namespace Rotor
         dispatcherProvider as object
         port as object
         asyncTransferRegistry = {} ' transferId -> { dispatcherId, context }
+        deviceInfoRegistry = {} ' deviceInfoId -> { dispatcherId, context, deviceInfo }
         onTick as function
 
         ' ---------------------------------------------------------------------
@@ -148,6 +149,27 @@ namespace Rotor
             }
         end sub
 
+        ' ---------------------------------------------------------------------
+        ' registerDeviceInfo - Registers a roDeviceInfo for event listening
+        '
+        ' This method associates a roDeviceInfo object with a dispatcher ID.
+        ' When device info events occur (linkStatus, etc.), the framework will
+        ' route them to the correct dispatcher's asyncReducerCallback.
+        '
+        ' @param {string} deviceInfoId - Unique identifier for this registration
+        ' @param {string} dispatcherId - Dispatcher ID that will handle events
+        ' @param {object} deviceInfo - The roDeviceInfo object (must have SetMessagePort called)
+        ' @param {object} context - Optional user data to pass back in callback
+        '
+        public sub registerDeviceInfo(deviceInfoId as string, dispatcherId as string, deviceInfo as object, context = invalid as dynamic)
+            deviceInfo.SetMessagePort(m.port)
+            m.deviceInfoRegistry[deviceInfoId] = {
+                dispatcherId: dispatcherId,
+                deviceInfo: deviceInfo,
+                context: context
+            }
+        end sub
+
         ' ---------------------------------------------------------------------
         ' sync - Starts the message loop for cross-thread communication
         '
@@ -205,10 +227,10 @@ namespace Rotor
                                 ' taskIntent = Rotor.Utils.deepCopy(intent)
                                 dispatcherInstance.dispatch(intent)
 
-                            else if sync.type = Rotor.Const.ThreadSyncType.REGISTER_EXTERNAL_DISPATCHER
+                            else if sync.type = Rotor.Const.ThreadSyncType.REGISTER_CROSS_THREAD_DISPATCHER
 
-                                for each item in sync.externalDispatcherList
-                                    m.dispatcherProvider.registerExternalDispatchers(item.dispatcherId, item.externalTaskNode)
+                                for each item in sync.crossThreadDispatcherList
+                                    m.dispatcherProvider.registerCrossThreadDispatchers(item.dispatcherId, item.stateNode)
                                 end for
 
                                 m.notifySyncStatus(Rotor.Const.ThreadSyncType.TASK_SYNCED)
@@ -251,6 +273,22 @@ namespace Rotor
                             end if
 
                         end if
+                    else if msgType = "roDeviceInfoEvent"
+                        ' Handle device info events (ignore appFocused, etc.)
+                        if m.deviceInfoRegistry.count() > 0
+                            eventInfo = msg.GetInfo()
+                            ' Only process linkStatus events, ignore appFocused and other events
+                            if eventInfo?.linkStatus <> invalid
+                                ' Route to all registered device info dispatchers
+                                for each deviceInfoId in m.deviceInfoRegistry
+                                    registryEntry = m.deviceInfoRegistry[deviceInfoId]
+                                    dispatcherInstance = m.dispatcherProvider.get(registryEntry.dispatcherId)
+                                    if dispatcherInstance <> invalid
+                                        dispatcherInstance.asyncReducerCallback(eventInfo, registryEntry?.context as dynamic)
+                                    end if
+                                end for
+                            end if
+                        end if
                     end if
                 end if
             end while
@@ -317,6 +355,7 @@ namespace Rotor
         '
         public sub destroy()
             m.asyncTransferRegistry.clear()
+            m.deviceInfoRegistry.clear()
             m.dispatcherProvider.destroy()
 
             globalScope = GetGlobalAA()

package/src/source/base/BaseWidget.bs

@@ -87,22 +87,24 @@ namespace Rotor
         ' These are optionally injected by plugins
 
         ' Focus Plugin Methods (from FocusPlugin.bs)
-        optional enableFocusNavigation as function   ' Enable focus navigation
+        optional enableFocusNavigation as function    ' Enable focus navigation
         optional isFocusNavigationEnabled as function ' Check if focus enabled
-        optional setFocus as function                ' Set focus on widget
-        optional getFocusedWidget as function        ' Get currently focused widget
-        optional proceedLongPress as function        ' Trigger long press
-        optional isLongPressActive as function       ' Check if long press active
+        optional setFocus as function                 ' Set focus on widget
+        optional getFocusedWidget as function         ' Get currently focused widget
+        optional proceedLongPress as function         ' Trigger long press
+        optional isLongPressActive as function        ' Check if long press active
+        optional triggerKeyPress as function          ' Trigger key press event
+        optional setGroupLastFocusedId as function    ' Set the last focused widget ID within the current focus group (used to restore focus when re-entering the group)
 
         ' =============================================================
         ' PRIVATE PROPERTIES (Engine Use Only)
         ' =============================================================
 
-        private HID as string           ' Hierarchical ID (e.g., "0.header.logo")
-        private vmHID as string         ' Owning ViewModel's HID
-        private isRootChild as boolean  ' True if direct child of root
+        private HID as string             ' Hierarchical ID (e.g., "0.header.logo")
+        private vmHID as string           ' Owning ViewModel's HID
+        private isRootChild as boolean    ' True if direct child of root
         private childrenHIDhash as object ' Hash of child HIDs for fast lookup
-        private parentHID as string     ' Parent's HID
+        private parentHID as string       ' Parent's HID
 
     end class
 

package/src/source/base/{ListenerForDispatchers.bs → DispatcherCore.bs}

@@ -16,10 +16,15 @@ end interface
 namespace Rotor
 
     ' =====================================================================
-    ' ListenerForDispatchers - Base class for dispatcher state change listener management
+    ' DispatcherCore - Core base class for dispatcher implementations
     '
-    ' Provides listener registration, notification, and lifecycle management
-    ' for both internal and external dispatchers.
+    ' Provides shared properties and listener management for both
+    ' DispatcherOriginal and DispatcherCrossThread.
+    '
+    ' Shared Properties:
+    '   - dispatcherId: Unique identifier for this dispatcher
+    '   - stateNode: SceneGraph node for state exposure
+    '   - listeners: Array of registered state change listeners
     '
     ' Listener Features:
     '   - State mapping: mapStateToProps for updating widget props
@@ -33,12 +38,15 @@ namespace Rotor
     '   3. Invoke callback functions
     '   4. Remove 'once' listeners
     ' =====================================================================
-    class ListenerForDispatchers
+    class DispatcherCore
 
         ' =============================================================
         ' MEMBER VARIABLES
         ' =============================================================
 
+        dispatcherId as string          ' Dispatcher identifier
+        stateNode as object             ' Node for cross-thread state exposure
+
         listeners = []                  ' Array of listener configurations
 
         ' =============================================================

package/src/source/base/{DispatcherExternal.bs → DispatcherCrossThread.bs}

@@ -1,9 +1,9 @@
-import "ListenerForDispatchers.bs"
+import "DispatcherCore.bs"
 
 namespace Rotor
 
     ' =====================================================================
-    ' DispatcherExternal - External dispatcher for cross-thread MVI state management
+    ' DispatcherCrossThread - Cross-thread dispatcher for MVI state management
     '
     ' This dispatcher is used when accessing dispatchers from a different thread
     ' than where they were created (render thread accessing task thread dispatcher
@@ -11,25 +11,22 @@ namespace Rotor
     '
     ' Responsibilities:
     '   - Dispatches intents across thread boundaries via rotorSync field
-    '   - Observes state changes on task node field
+    '   - Observes state changes on state node field
     '   - Manages cross-thread listener notifications
     '   - Lazy observer setup (only when listeners are added)
     '   - Auto cleanup when last listener is removed
     '
     ' MVI Cross-Thread Flow:
     '   Render Thread: dispatch(intent) → rotorSync field → Task Thread
-    '   Task Thread: reduce state → task node field → Render Thread observer callback
+    '   Task Thread: reduce state → state node field → Render Thread observer callback
     ' =====================================================================
-    class DispatcherExternal extends ListenerForDispatchers
+    class DispatcherCrossThread extends DispatcherCore
 
         ' =============================================================
         ' MEMBER VARIABLES
         ' =============================================================
 
-        dispatcherId as string          ' Dispatcher identifier
-        taskNode as object              ' Task node for cross-thread communication
         threadType as string            ' Current thread type (RENDER or TASK)
-        isExternal = true               ' True for external dispatchers
         isStateObserved = false         ' Tracks if observer is active
 
         ' =============================================================
@@ -37,18 +34,18 @@ namespace Rotor
         ' =============================================================
 
         ' ---------------------------------------------------------------------
-        ' Constructor - Initializes external dispatcher
+        ' Constructor - Initializes cross-thread dispatcher
         '
         ' @param {string} dispatcherId - Dispatcher identifier
-        ' @param {object} taskNode - Task node for cross-thread communication
+        ' @param {object} stateNode - Node for cross-thread state communication
         ' @param {string} threadType - Current thread type (RENDER or TASK)
         '
-        sub new(dispatcherId as string, taskNode as object, threadType as string)
+        sub new(dispatcherId as string, stateNode as object, threadType as string)
             super()
 
             ' Store dispatcher configuration
             m.dispatcherId = dispatcherId
-            m.taskNode = taskNode
+            m.stateNode = stateNode
             m.threadType = threadType
         end sub
 
@@ -73,7 +70,7 @@ namespace Rotor
             end if
 
             ' Send intent to task thread via rotorSync field
-            m.taskNode.setField("rotorSync", {
+            m.stateNode.setField("rotorSync", {
                 type: Rotor.Const.ThreadSyncType.DISPATCH,
                 payload: {
                     dispatcherId: m.dispatcherId,
@@ -87,17 +84,17 @@ namespace Rotor
         ' =============================================================
 
         ' ---------------------------------------------------------------------
-        ' getState - Returns current state from task node field (optionally mapped)
+        ' getState - Returns current state from state node field (optionally mapped)
         '
-        ' Reads state from task node field set by internal dispatcher.
+        ' Reads state from state node field set by internal dispatcher.
         '
         ' @param {dynamic} mapStateToProps - Optional mapping function
         ' @param {object} callerScope - Caller scope for mapping function
         ' @returns {object} Current state
         '
         function getState(mapStateToProps = invalid as Dynamic, callerScope = invalid as object) as object
-            ' Read state from task node field
-            state = m.taskNode.getField(m.dispatcherId)
+            ' Read state from state node field
+            state = m.stateNode.getField(m.dispatcherId)
 
             ' Apply optional state mapping
             m.runMapStateToProps(state, mapStateToProps, callerScope)
@@ -150,7 +147,7 @@ namespace Rotor
         ' =============================================================
 
         ' ---------------------------------------------------------------------
-        ' setupObserver - Sets up observer for state changes on task node field
+        ' setupObserver - Sets up observer for state changes on state node field
         '
         ' Thread-specific observer setup:
         '   - RENDER thread: Uses observeFieldScoped with callback name
@@ -159,12 +156,12 @@ namespace Rotor
         sub setupObserver()
             if m.threadType = Rotor.Const.ThreadType.RENDER
                 ' Render thread: use native SceneGraph observer
-                m.taskNode.observeFieldScoped(m.dispatcherId, "Rotor_dispatcherStateCallback")
+                m.stateNode.observeFieldScoped(m.dispatcherId, "Rotor_dispatcherStateCallback")
             else
                 ' Task thread: use framework observer system
                 fieldId = m.dispatcherId
                 frameworkInstance = GetGlobalAA().rotor_framework_helper.frameworkInstance
-                frameworkInstance.addObserver(fieldId, m.taskNode)
+                frameworkInstance.addObserver(fieldId, m.stateNode)
             end if
 
             m.isStateObserved = true
@@ -178,12 +175,12 @@ namespace Rotor
         sub removeObserver()
             if m.threadType = Rotor.Const.ThreadType.RENDER
                 ' Render thread: unobserve SceneGraph field
-                m.taskNode.unobserveFieldScoped(m.dispatcherId)
+                m.stateNode.unobserveFieldScoped(m.dispatcherId)
             else
                 ' Task thread: remove framework observer
                 fieldId = m.dispatcherId
                 frameworkInstance = GetGlobalAA().rotor_framework_helper.frameworkInstance
-                frameworkInstance.removeObserver(fieldId, m.taskNode)
+                frameworkInstance.removeObserver(fieldId, m.stateNode)
             end if
 
             m.isStateObserved = false
@@ -194,7 +191,7 @@ namespace Rotor
         ' =============================================================
 
         ' ---------------------------------------------------------------------
-        ' destroy - Cleans up external dispatcher resources
+        ' destroy - Cleans up cross-thread dispatcher resources
         '
         ' Cleanup steps:
         '   1. Call parent cleanup
@@ -210,16 +207,16 @@ namespace Rotor
             ' Remove observer if active
             if m.isStateObserved = true
                 if m.threadType = Rotor.Const.ThreadType.RENDER
-                    m.taskNode.unobserveFieldScoped(m.dispatcherId)
+                    m.stateNode.unobserveFieldScoped(m.dispatcherId)
                 else
                     fieldId = m.dispatcherId
-                    frameworkInstance.removeObserver(fieldId, m.taskNode)
+                    frameworkInstance.removeObserver(fieldId, m.stateNode)
                 end if
             end if
 
             ' Clear all references
             m.listeners.Clear()
-            m.taskNode = invalid
+            m.stateNode = invalid
 
             ' Deregister from provider
             frameworkInstance.dispatcherProvider.deregisterDispatcher(m.dispatcherId)
@@ -235,7 +232,7 @@ namespace Rotor
     ' dispatcherStateCallback - Global callback function for dispatcher state changes on render thread
     '
     ' This function is called by SceneGraph's observeFieldScoped when a dispatcher's
-    ' state field changes on the task node. It routes the state change to the
+    ' state field changes on the state node. It routes the state change to the
     ' appropriate dispatcher instance for listener notification.
     '
     ' Process flow:

package/src/source/base/{DispatcherCreator.bs → DispatcherOriginal.bs}

@@ -1,4 +1,4 @@
-import "ListenerForDispatchers.bs"
+import "DispatcherCore.bs"
 
 namespace Rotor
 
@@ -13,11 +13,11 @@ namespace Rotor
     ' @returns {Dispatcher} Dispatcher facade instance
     ' =====================================================================
     sub createDispatcher(customDispatcherId as string, modelInstance as Model, reducerInstance as Reducer)
-        m.dispatcherInstance = new Rotor.DispatcherCreator(customDispatcherId, modelInstance, reducerInstance)
+        m.dispatcherInstance = new Rotor.DispatcherOriginal(customDispatcherId, modelInstance, reducerInstance)
     end sub
 
     ' =====================================================================
-    ' DispatcherCreator - Internal dispatcher implementation for MVI pattern state management
+    ' DispatcherOriginal - Internal dispatcher implementation for MVI pattern state management
     '
     ' Responsibilities:
     '   - Dispatches intents to reducer
@@ -29,21 +29,17 @@ namespace Rotor
     ' MVI Flow:
     '   dispatch(intent) → reducer.reduce() → update state → notify listeners
     ' =====================================================================
-    class DispatcherCreator extends ListenerForDispatchers
+    class DispatcherOriginal extends DispatcherCore
 
         ' =============================================================
         ' MEMBER VARIABLES
         ' =============================================================
 
         middlewares = []                ' Middleware array (unused, handled by Reducer)
-        isExternal = false              ' False for internal dispatchers
         isDispatchingInProgress = false ' Prevents reentrant dispatch
         dispatchQueue = []              ' Queue for intents during active dispatch
-        dispatcherId as string          ' Dispatcher identifier
-        taskNode as object              ' Task node for cross-thread state exposure
         reducerInstance as object       ' Reducer instance
         modelInstance as object         ' Model instance holding state
-        listeners = []                  ' State change listeners
 
         ' =============================================================
         ' CONSTRUCTOR
@@ -62,7 +58,7 @@ namespace Rotor
             m.dispatcherId = dispatcherId
 
             globalScope = GetGlobalAA()
-            m.taskNode = globalScope.top
+            m.stateNode = globalScope.top
 
             ' Link reducer to this dispatcher
             m.reducerInstance = reducerInstance
@@ -71,7 +67,7 @@ namespace Rotor
             m.modelInstance = modelInstance
 
             ' Create field on task node for render thread communication
-            m.taskNode.addField(m.dispatcherId, "node", true)
+            m.stateNode.addField(m.dispatcherId, "node", true)
 
             ' Expose initial state
             m.exposeState()
@@ -94,7 +90,7 @@ namespace Rotor
         sub exposeState()
             newState = CreateObject("roSGNode", "ContentNode")
             newState.addFields(m.modelInstance.state)
-            m.taskNode.setField(m.dispatcherId, newState)
+            m.stateNode.setField(m.dispatcherId, newState)
         end sub
 
         ' ---------------------------------------------------------------------
@@ -131,6 +127,7 @@ namespace Rotor
             end if
 
             if m.isDispatchingInProgress = false
+
                 ' Execute reducer
                 currentState = m.modelInstance.state
                 newState = m.reducerInstance.reduce(currentState, intent)
@@ -148,7 +145,7 @@ namespace Rotor
                     m.dispatch(intent)
                 end if
             else
-                ' Queue intent to prevent reentrancy
+                ' Queue intent for later processing
                 m.dispatchQueue.push(intent)
             end if
         end sub
@@ -183,7 +180,7 @@ namespace Rotor
             frameworkInstance = GetGlobalAA().rotor_framework_helper.frameworkInstance
             frameworkInstance.dispatcherProvider.deregisterDispatcher(m.dispatcherId)
 
-            m.taskNode = invalid
+            m.stateNode = invalid
             m.modelInstance = invalid
             m.reducerInstance = invalid
         end sub

package/src/source/engine/Constants.bs

@@ -57,7 +57,7 @@ namespace Rotor
 
         enum ThreadSyncType
             TASK_SYNCING = "taskSyncing"
-            REGISTER_EXTERNAL_DISPATCHER = "registerExternalDispatcher"
+            REGISTER_CROSS_THREAD_DISPATCHER = "registerCrossThreadDispatcher"
             DESTROY = "destroy"
             TASK_SYNCED = "taskSynced"
             SYNC_COMPLETED = "sync_completed"

package/src/source/engine/providers/Dispatcher.bs

@@ -2,7 +2,7 @@
 namespace Rotor
 
     ' =====================================================================
-    ' Dispatcher - Dispatcher Facade that provides a simplified interface for state management
+    ' Dispatcher FACADE - Dispatcher Facade that provides an interface for state management
     '
     ' Acts as a proxy to the underlying dispatcher instance, managing intents,
     ' listeners, and state access. The facade pattern allows for clean separation
@@ -12,11 +12,12 @@ namespace Rotor
     class Dispatcher
 
         dispatcherId as string
-        listenerId as string
-        listenerScope as object
-        dispatcherInstance as object
 
-        sub new(dispatcherInstance as dynamic, dispatcherId as string, listenerId = "" as string, listenerScope = invalid as object)
+        private listenerId as string
+        private listenerScope as object
+        private dispatcherInstance as object
+
+        private sub new(dispatcherInstance as dynamic, dispatcherId as string, listenerId = "" as string, listenerScope = invalid as object)
             m.dispatcherId = dispatcherId
             m.listenerScope = listenerScope
             m.listenerId = listenerId
@@ -28,7 +29,7 @@ namespace Rotor
         '
         ' @param {Intent} intent - The intent object containing action type and payload
         '
-        sub dispatch(intent)
+        public sub dispatch(intent)
             m.dispatcherInstance.dispatch(intent)
         end sub
 
@@ -37,31 +38,31 @@ namespace Rotor
         '
         ' @param {Dynamic} listenerConfig - Configuration object for the listener (can be a function or object with mapStateToProps)
         '
-        sub addListener(listenerConfig as dynamic)
+        public sub addListener(listenerConfig as dynamic)
             m.dispatcherInstance.addListener(listenerConfig, m.listenerId, m.listenerScope)
         end sub
 
-        ' ---------------------------------------------------------------------
-        ' removeAllListenersByListenerId - Removes all listeners associated with this dispatcher's listener ID
-        '
-        sub removeAllListenersByListenerId()
-            m.dispatcherInstance.removeAllListenersByListenerId(m.listenerId)
-        end sub
-
         ' ---------------------------------------------------------------------
         ' getState - Retrieves the current state from the dispatcher, optionally mapped through a selector function
         '
         ' @param {Dynamic} mapStateToProps - Optional function to map/select specific parts of the state
         ' @returns {Object} The current state object (mapped if selector provided)
         '
-        function getState(mapStateToProps = invalid as Dynamic) as object
+        public function getState(mapStateToProps = invalid as Dynamic) as object
             return m.dispatcherInstance.getState(mapStateToProps, m.listenerScope)
         end function
 
+        ' ---------------------------------------------------------------------
+        ' removeAllListenersByListenerId - Removes all listeners associated with this dispatcher's listener ID
+        '
+        private sub removeAllListenersByListenerId()
+            m.dispatcherInstance.removeAllListenersByListenerId(m.listenerId)
+        end sub
+
         ' ---------------------------------------------------------------------
         ' destroy - Cleans up the dispatcher facade by removing all listeners and clearing references
         '
-        sub destroy()
+        public sub destroy()
             m.removeAllListenersByListenerId()
             m.listenerScope = invalid
             m.dispatcherInstance = invalid

package/src/source/engine/providers/DispatcherProvider.bs

@@ -6,7 +6,7 @@ namespace Rotor
     '
     ' Manages a collection of dispatcher instances and provides facade access
     ' to dispatchers. Extends BaseStack to store and organize dispatchers by ID.
-    ' Handles both internal and external dispatcher registration/deregistration.
+    ' Handles both local and cross-thread dispatcher registration/deregistration.
     ' =====================================================================
     class DispatcherProvider extends Rotor.BaseStack
 
@@ -59,15 +59,15 @@ namespace Rotor
         end sub
 
         ' ---------------------------------------------------------------------
-        ' registerExternalDispatchers - Registers external dispatchers from another thread
+        ' registerCrossThreadDispatchers - Registers cross-thread dispatchers from another thread
         '
         ' @param {dynamic} dispatcherIds - Single ID string or array of dispatcher IDs
-        ' @param {object} taskNode - The task node for cross-thread communication
+        ' @param {object} stateNode - The node for cross-thread state communication
         '
-        sub registerExternalDispatchers(dispatcherIds as dynamic, taskNode as object)
+        sub registerCrossThreadDispatchers(dispatcherIds as dynamic, stateNode as object)
             dispatcherIds = Rotor.Utils.ensureArray(dispatcherIds)
             for each dispatcherId in dispatcherIds
-                dispatcherInstance = new Rotor.DispatcherExternal(dispatcherId, taskNode, m.threadType)
+                dispatcherInstance = new Rotor.DispatcherCrossThread(dispatcherId, stateNode, m.threadType)
                 m.set(dispatcherId, dispatcherInstance)
             end for
         end sub

package/src/source/engine/services/Tts.bs

@@ -114,13 +114,15 @@ namespace Rotor.ViewBuilder
             m.audioGuide = CreateObject("roAudioGuide")
             m.debounceTimer = CreateObject("roTimespan")
 
-            if m.audioGuide = invalid
-                #if debug
-                    ? "[TTS_SERVICE][ERROR] Failed to create roAudioGuide instance"
-                #end if
-                m.isEnabled = false
-                return
-            end if
+            #if not unittest
+                if m.audioGuide = invalid
+                    #if debug
+                        ? "[TTS_SERVICE][ERROR] Failed to create roAudioGuide instance"
+                    #end if
+                    m.isEnabled = false
+                    return
+                end if
+            #end if
 
             ' Create timer node for threshold (one-shot, started on demand)
             rootNode = m.frameworkInstance.getRootNode()
@@ -377,7 +379,10 @@ namespace Rotor.ViewBuilder
             end if
 
             ' Speak text (Say() handles flushing if shouldFlush=true)
-            speechId = m.audioGuide.Say(text, shouldFlush, dontRepeat)
+            speechId = 0
+            if m.audioGuide <> invalid
+                speechId = m.audioGuide.Say(text, shouldFlush, dontRepeat)
+            end if
             m.lastSpeech = text
 
             ' Set protection flag if requested
@@ -542,7 +547,9 @@ namespace Rotor.ViewBuilder
         '
         public sub stopSpeech()
             if not m.isEnabled or not m.getIsDeviceAudioGuideEnabled() then return
-            m.audioGuide.Flush()
+            if m.audioGuide <> invalid
+                m.audioGuide.Flush()
+            end if
             m.preventNextFlushFlag = false
             m.pendingSpeech = invalid
             m.isPendingProtected = false

package/src/source/plugins/FocusPlugin.bs

@@ -324,14 +324,14 @@ namespace Rotor
             end function,
 
             ' ---------------------------------------------------------------------
-            ' setGroupLastFocusedHID - Updates the lastFocusedHID of this widget's focus group
+            ' setGroupLastFocusedId - Updates the lastFocusedHID of this widget's focus group
             '
             ' If called on a focusGroup widget, updates its own lastFocusedHID.
             ' If called on a focusItem widget, finds and updates the parent group's lastFocusedHID.
             '
             ' @param {string} id - The widget id to set as lastFocusedHID
             '
-            setGroupLastFocusedHID: sub(id as string)
+            setGroupLastFocusedId: sub(id as string)
                 plugin = m.getFrameworkInstance().plugins[PRIMARY_FOCUS_PLUGIN_KEY]
 
                 ' Determine ancestorHID for search context

package/src/source/plugins/FontStylePlugin.bs

@@ -1,22 +1,21 @@
-import "../base/BasePlugin.bs"
-
 namespace Rotor
 
     ' =====================================================================
     ' FontStylePlugin - Rotor Framework plugin for font styling on Labels
     '
-    ' Handles dynamic font styling on Label nodes with function evaluation
-    ' and @-prefixed expression interpolation for dynamic font selection.
-    ' Automatically updates font styles on widget lifecycle changes.
+    ' Applies font styles to Label nodes with @ operator resolution.
     '
-    ' Key Features:
-    '   - Applies font styles specifically to Label nodes
-    '   - Evaluates function-based font style values
-    '   - Interpolates @-prefixed expressions for dynamic font selection
-    '   - Automatically updates font styles on widget lifecycle changes
+    ' Usage:
+    '   fontStyle: { uri: "pkg:/assets/fonts/Roboto.ttf", size: 24 }
+    '   fontStyle: { uri: "@l10n.fonts.regular", size: 24 }
+    '   fontStyle: { uri: "@fontUri", size: "@fontSize" }
+    '   fontStyle: function() as object
+    '       return { uri: m.props.fontUri, size: 24 }
+    '   end function
     '
     ' Expression Syntax:
-    '   @key.path - Resolves from widget.viewModelState
+    '   @l10n.key.path - Resolves from widget.viewModelState.l10n
+    '   @key.path      - Resolves from widget.viewModelState
     '
     ' Note: Only affects widgets with nodeType = "Label"
     ' =====================================================================
@@ -24,123 +23,49 @@ namespace Rotor
 
         pluginKey = "fontStyle"
 
-        ' =============================================================
-        ' MEMBER VARIABLES
-        ' =============================================================
-
-        ' Regex pattern for matching @-prefixed expressions
-        ' Matches: @ followed by any characters except space, @, or comma
-        configRegex = /(\@)([^\s\@\,]*)/i
-
-        ' Regex pattern for extracting plugin key prefix (unused but kept for compatibility)
-        pluginKeyRegex = /^[^\.]*/i
-
-          ' =============================================================
-        ' LIFECYCLE HOOKS
-        ' =============================================================
-
         hooks = {
-            ' ---------------------------------------------------------------------
-            ' beforeMount - Sets font style when widget is mounted
-            '
-            ' Evaluates and applies font style after Label widget creation.
-            '
-            ' @param {object} scope - Plugin instance (m)
-            ' @param {object} widget - Widget being mounted
-            '
             beforeMount: sub(scope as object, widget as object)
                 scope.setFontAttribute(widget)
             end sub,
 
-            ' ---------------------------------------------------------------------
-            ' beforeUpdate - Updates font style when widget config changes
-            '
-            ' Re-evaluates and applies font style when fontStyle property changes.
-            '
-            ' @param {object} scope - Plugin instance (m)
-            ' @param {object} widget - Widget being updated
-            ' @param {dynamic} newValue - New font style configuration
-            ' @param {dynamic} oldValue - Previous font style configuration
-            '
             beforeUpdate: sub(scope as object, widget as object, newValue, oldValue)
                 widget[scope.pluginKey] = newValue ?? ""
                 scope.setFontAttribute(widget)
             end sub
         }
 
-        ' =============================================================
-        ' FONT STYLE PROCESSING
-        ' =============================================================
-
-        ' ---------------------------------------------------------------------
-        ' setFontAttribute - Evaluates and applies font style to Label node
-        '
-        ' Processing logic:
-        '   1. Checks if widget is a Label node (only Labels support font styles)
-        '   2. Resolves font style value through function evaluation or interpolation
-        '   3. Applies resolved font style to the node
-        '
-        ' Font Style Resolution:
-        '   - Functions are executed in widget scope
-        '   - @-prefixed strings are interpolated from viewModelState
-        '   - Direct strings are used as-is
-        '
-        ' @param {object} widget - Widget instance
-        '
         sub setFontAttribute(widget as object)
-            ' Font styles only apply to Label nodes
-            if widget.nodeType = "Label"
-                value = widget[m.pluginKey]
-                node = widget.node
-
-                ' Step 1: Resolve function-based font style
-                if Rotor.Utils.isFunction(value)
-                    fontStyle = Rotor.Utils.callbackScoped(value, widget)
+            if widget.nodeType <> "Label" then return
 
-                    ' Step 2: Process string interpolation
-                else if Rotor.Utils.isString(value)
-                    results = m.configRegex.MatchAll(value)
+            value = widget[m.pluginKey]
 
-                    if results.Count() > 0 and Rotor.Utils.isString(value)
-                        for each result in results
-                            matchKey = result[2] ' The key path after @
-                            sourceTypeOperator = result[1] ' The @ symbol
-
-                            ' Determine source based on operator
-                            if sourceTypeOperator = "@"
-                                source = widget.viewModelState
-                            else
-                                source = widget
-                            end if
-
-                            if source <> invalid
-                                ' Resolve font style from key path
-                                assetValue = Rotor.Utils.getValueByKeyPath(source, matchKey)
+            ' Evaluate function if fontStyle is a function
+            if Rotor.Utils.isFunction(value)
+                value = Rotor.Utils.callbackScoped(value, widget)
+            end if
 
-                                ' Handle string vs non-string results
-                                if Rotor.Utils.isString(assetValue)
-                                    ' String interpolation - replace in original string
-                                    replaceRegex = CreateObject("roRegex", sourceTypeOperator + matchKey, "ig")
-                                    value = replaceRegex.ReplaceAll(value, assetValue)
-                                else
-                                    ' Non-string value - replace entire font style
-                                    value = assetValue
-                                    exit for
-                                end if
-                            end if
-                        end for
+            if type(value) <> "roAssociativeArray" then return
+
+            ' Resolve @ operators in properties
+            fontStyle = {}
+            for each key in value
+                propValue = value[key]
+                if Rotor.Utils.isString(propValue)
+                    if propValue.StartsWith("@l10n.")
+                        ' @l10n.fonts.regular -> resolve from viewModelState.l10n.fonts.regular
+                        fontStyle[key] = Rotor.Utils.getValueByKeyPath(widget.viewModelState.l10n, propValue.Mid(6))
+                    else if propValue.StartsWith("@")
+                        ' @key.path -> resolve from viewModelState
+                        fontStyle[key] = Rotor.Utils.getValueByKeyPath(widget.viewModelState, propValue.Mid(1))
+                    else
+                        fontStyle[key] = propValue
                     end if
-
-                    fontStyle = value
-
-                    ' Step 3: Direct value assignment
                 else
-                    fontStyle = value
+                    fontStyle[key] = propValue
                 end if
+            end for
 
-                ' Apply font style to the Label node
-                Rotor.Utils.setFontAttribute(node, fontStyle)
-            end if
+            Rotor.Utils.setFontAttribute(widget.node, fontStyle)
         end sub
 
     end class