HotLoop Flow 2.7.0 release notes

HotLoop Flow 2.7.0 is the first cut of FlowLab, a second way to run a tab for test benches and data loggers. Flows run exactly as they did, and a flow file you have today loads and saves byte for byte. FlowLab only starts when you add a tab to it, so if you don’t, the one thing that changes for you is the sessions fix, the last item below.

What’s new

FlowLab diagrams. A diagram is a tab where every node runs once, when each wired input has a value, and two nodes with no wire between them run at the same time. Add one with the new FlowLab button next to the subflow button. It gets a bar over the canvas with Run and Stop, and everything it draws is on the wires: the last value on every wire after a run, a probe on any wire that keeps the last 100 values, and a breakpoint on a node or a wire. Pause, step into, step over and step out work node by node, and highlight execution slows a run down enough to follow it and turns itself off after ten minutes. None of the debugging changes what a run does, and a test checks that a run with a probe ends with the same value on every wire as one without.

What is in the box. While and for loops with values carried from one pass to the next, a for loop over a count or an array, and an error wire: a node with an error coming in does nothing and passes it on, and an error wired into a loop stops it with the source and a code on the loop’s error out. An after wire sets the order of two nodes that share no data. There are 21 node types in the new FlowLab section of the palette: constant, math, compare, logic, wait, bundle, field, build array, the two loops and their body in and body out, a serial port with read and write, a reading parser, a stable value detector, a log to a text file, and a control, an indicator and a chart for the panel. docs/diagrams.md has each one.

A panel an operator can open on a phone. /panel/<diagram id> signs in the way the editor does and shows the diagram’s controls, indicators and charts while a run is live. A chart keeps the last 1,024 points unless you change it and counts what it let go. A control is checked on the server against its kind, range and choices, and who set it goes in the audit log.

A serial port that survives a pulled cable. A read that gets nothing, or a port that goes away, is a fault on the error wire. The next read tries to open the port again once a second, and counts the loss and the return. The example in examples/diagram-scale-logger reads a scale, parses the weight and unit, says when the last five readings agree, shows it all on the panel with a trend chart, and appends it to a CSV file. Set autostart on the tab and it runs with no browser open, and again after every deploy.

New API. GET /diagrams, GET /diagrams/{id}, and POST for run, stop and debug, PUT for controls/{node}, breakpoints and probes. Reading needs status.read. Running, stopping, setting a control and debugging need a new permission, diagram.run, and each is in the audit log with who did it.

Sessions are not overwritten by a failed read. A sessions file that exists but can’t be read, an I/O error or a volume that came up late, is no longer replaced by the next sign-in, and a file with unreadable JSON is kept beside the original instead of being lost.

What changed

• A tab that carries ew_diagram is left out of the message runtime. Every other tab runs as before. The new keys are ew_diagram on the tab and ew_in on a node, and both survive the round trip, which two new tests and the old one check.
• The README counted 79 node types and “about 36,000 lines of Go”, and both were out of date. It now says 79 node types for messages and 21 for FlowLab. It counts 104,000 lines of Go, a little under 40 percent of it tests, by git ls-files '*.go' less third_party, and I did not count it the way the old number was counted, because nobody wrote that down.
• The Hotloop MCP client node’s test now writes through HotLoop’s gate, because HotLoop ships its MCP writes on. That is CI only, nothing ships.
• A deploy restarts every diagram’s run, even one it didn’t change.
• FlowLab added about 370 KB to the binary, measured on one machine before and after. The binary is 41.4 MB and the amd64 image is 45.34 MB.
• The README’s pictures were retaken for the new button and the new palette section.

New settings

None. The permission diagram.run is new. A user whose permission list is ["*"] has it. Someone with an explicit list can read a diagram and its panel with status.read and can’t run one until you add diagram.run.

Upgrade

On amd64, a plain helm upgrade to the 2.7.0 image and chart, and on arm64 stay where you are until 2.7.1, or the new tag in your Quadlet unit. Nothing happens on first start, there is nothing to migrate, and your flows, deployment records and credentials are not touched. If you roll back after saving a flow file with a diagram in it, the older build keeps the file byte for byte and says unknown node type for each FlowLab node, which then don’t run. I checked that against the build before this one.

What isn’t proven, and what isn’t here yet

It has been run against a program that writes scale frames on a pseudo terminal, at 5 frames a second for minutes. No physical scale has been on the wire, and nothing has run for a day on a Pi. The browser tests are headless Chromium, and the phone view is a phone sized window and not a phone.

What a FlowLab diagram can’t do yet: a case structure, records and shared types, waveforms, TDMS and binary logs, a database or an MQTT write, instrument sessions, a data acquisition client, analysis such as filters and statistics, sub-diagrams, serial flow control, hotloop-flow test and CI checks for diagrams, event handlers, an operator only panel with its own permissions, a panel layout editor, and a diagram as an MCP tool. Diagrams don’t use durable wires. The serial library prints a line to the log when a pulled device closes. It’s harmless and I haven’t silenced it. FlowLab does not do hard real time: a node can be late by milliseconds, and work with a deadline belongs in a PLC.

Image: ghcr.io/hotloop-io/hotloop-flow:2.7.0, linux/amd64 only. I build amd64 first, let it read stable in production, and then one small 2.7.1 with nothing else in it adds arm64. Until then the 2 tag holds the new amd64 image and the arm64 image from 2.6.0, so a box on arm64 that follows 2 or 2.6 keeps what it has, and a box that is pinned to 2.7.0 needs amd64. Chart: https://hotloop.io/hotloop-flow/. The README at this tag has the rest, with pictures: https://github.com/HotLoop-io/hotloop-flow/blob/v2.7.0/README.md