ui-template: replayed messages cannot be distinguished from live messages

[henrikekblad]

Current Behavior

When a Dashboard ui-template is loaded/reloaded, Dashboard replays the last message stored for that widget. The replayed message appears identical to the original live message: it retains the original _msgid, payload and custom properties, with no metadata indicating that it came from the Dashboard datastore.

This is problematic when the authoritative state is maintained elsewhere in Node-RED. In my case, a mailbox widget receives count: 1 when mail arrives, while the authoritative current state is stored in global context. After the mailbox is cleared, the authoritative state can be count: 0, but a newly loaded Dashboard can initially replay an older count: 1 message.

I use ui-event / $pageview to fetch the authoritative state and send it to the ui-template:

ui-event ($pageview)
    -> Fetch global state
    -> ui-template

This means two independent messages can reach the widget during page loading: the Dashboard datastore replay and the current state fetched in response to $pageview.

I have observed the replay followed by the current state, but I cannot find a documented ordering guarantee. If the two mechanisms race, simply overwriting the replay with the $pageview result is not sufficient.

The workaround I now use is to ignore all messages until an explicit fetchGlobal message initializes the widget, and to attach a state timestamp/version to backend state so that an older replay arriving after initialization can also be rejected. This works, but requires application-specific synchronization logic solely because the template cannot identify a replayed message.

Checking _msgid alone does not help: normal live Node-RED messages also have _msgid, and the replay preserves the original value.

Exported ui-template nodes also contain properties such as:

"storeOutMessages": true,
"passthru": false,
"resendOnRefresh": true

resendOnRefresh sounds related, but I cannot find a corresponding option in the current ui-template editor, and it is unclear whether this property is currently implemented/used by Dashboard 2.

Expected Behavior

For applications where Node-RED owns the authoritative state, there should ideally be a supported way to distinguish datastore replay from a new live message.

For example, replayed messages could carry metadata such as:

msg._dashboard = {
    replay: true
};

Alternatively, it would be useful to allow datastore replay to be disabled per widget, e.g. an option such as Restore last message on client load.

A documented guarantee that datastore replay always occurs before $pageview would also make explicit synchronization possible, although marking replayed messages or allowing replay to be disabled would seem more robust.

Steps To Reproduce

1. Create a ui-template that displays a value from msg.payload.count.
2. Send a live message to it, for example:

msg.payload = {
    count: 1,
    date: Date.now()
};
msg.mailSource = "increase";
return msg;

3. Observe the message in the template. For example:

{
    payload: {
        count: 1,
        date: 1786717839872
    },
    topic: "",
    _msgid: "4c284f268c64dd58",
    mailSource: "increase"
}

4. Maintain/change the authoritative application state separately (for example, set the corresponding global state to count: 0).
5. Add a ui-event $pageview path that reads that authoritative state and sends count: 0 to the ui-template when the page loads.
6. Reload/open the Dashboard page.
7. Observe that the ui-template also receives the previously stored count: 1 message. From inside the template it is indistinguishable from the original live message; the original _msgid and custom properties are preserved.

Environment

• Dashboard version: 1.30.2
• Node-RED version: 5
• Node.js version:
• npm version:
• Platform/OS:
• Browser:

Have you provided an initial effort estimate for this issue?

I am not a FlowFuse team member

[colinl]

Just send the new value to the template whenever it changes, it does not matter whether it is currently displayed or not. Usually there is no need to send it when the page becomes visible.

[henrikekblad]

Thanks — I found the actual cause, and your suggestion pointed me in the right direction.

The problem was msg._client.

When the mailbox was reset from inside the ui-template, I used:

this.send({ mailSource: "clear", payload: { count: 0 } });

That message gets _client information attached to it. It then went through my Node-RED flow, updated the authoritative global state, and was sent back to the ui-template.

However, I did not remove _client before sending the updated state back to the template.

So the reset message was client-specific. The client that performed the reset correctly displayed count: 0, but the Dashboard's shared datastore was not updated with that state.

The previous global message, e.g. count: 1, therefore remained the value that was replayed after a page reload.

This also explains why manually triggering the same reset flow from an Inject node always worked: that message had no _client.

The fix was simply to remove the client information when publishing the new global state:

delete msg._client;

msg.payload = {
    count: 0,
    date: global.get("MailDate")
};

msg.mailSource = "reset";
return msg;

Now every state change is sent to the template as global state, the Dashboard datastore contains the correct latest value, and replay on reload works exactly as intended.

So in this case $pageview synchronization and my replay-detection workaround are not needed.

Thanks for the help — I think this issue can be closed.