13 Commits

Include renames

Author	SHA1	Message	Date
stroblmeandClaude Opus 5	518231aa39	Touch is a panel setting, and the rail grows with it ... It described the wrong object. A dashboard is a document that may hang on a hallway tablet and in a desk browser at the same time, and only one of those has fingers on it — so the flag moves off `DashboardDef.settings` and onto `PanelDef` as a plain bool, ticked in the Panels dialog. `useCanvasRoot` takes it as an argument rather than reading the document, and `/panel/{id}` is the only surface with a panel to ask. Dropping the message binding with it is deliberate: nothing drove it, and a flow deciding whether a screen has fingers on it was never the point. A stored `settings.touch` is inert rather than migrated, which `_check_settings` skipping unknown names already guaranteed. The rail was the other half. It had no touch behaviour at all and its 40px buttons met neither branch of the 44/32 rule. `[data-touch] .dui-rail{-item}` in `ui/core/core.css` spends the padding and the gap on the buttons instead, so they reach the 44px target and the rail comes out taller at exactly the same width — `RAIL_INSET` never moves, and the arrangement under it does not either. Also closes the panels-dialog icon gap: `DashboardSummary` carries the `icon` now, so the dialog draws each assigned dashboard's rail glyph beside its checkbox. `initials()` went from three identical copies in the looks to one in `Dashboard/icons.ts`, so the dialog and the rail fall back the same way. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Va7ExQDtuwKN7kNpHhWWNQ	2026-08-31 19:04:20 +02:00
stroblmeandClaude Opus 5	bdad6d7fc2	Make the docs state things rather than argue them ... The site read as a design journal: rationale paragraphs, hedges ("deliberately", "on purpose", "genuinely"), meta-commentary about the docs themselves, and one em-dash every ten lines carrying an aside. Roughly twenty rationale blocks are gone or reduced to what a reader needs in order to use the thing. Em-dashes go from 507 to 135, and what is left is structural rather than prose: list and definition separators, table cells, and four inside code blocks that quote what the CLI actually prints. Also: api.example.com becomes api.fluksio.com (the emails stay, since bootstrap.py really defaults to admin@example.com and RFC 2606 reserves it); the mqtt table gains the two settings it had drifted behind on and inject's wording matches the engine; llms.txt lists the two connector pages that were in the nav but not in it; and the two device/device_policy notes now agree. Builds clean under `zensical build --strict`. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015YrQnKV3bnQd4K342y8tKj	2026-08-31 10:49:58 +02:00
stroblmeandClaude Opus 5	d01a8dad37	Rename Installation to Instance ... Follows the portal: the noun is "instance" everywhere the app says it — UI strings, CLI output, error details, docs and comments. The wire keys (`instance_id`, `instance_token`) and the hub route this calls move with it. An existing cloud.json is adopted rather than refused: without the key alias the dataclass fails to parse, which the caller swallows and reads as "never enrolled" instead of "reconnect". `instance_key` on a node type becomes `target_key`. It means the outside thing a node points at, which is a different sense of the word, and keeping both would put two meanings of "instance" in one codebase. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015YrQnKV3bnQd4K342y8tKj	2026-08-31 10:12:01 +02:00
stroblme	67c35093e6	Add a player widget, and let a slider be drawn as a fader ... The player is the one tile that both reads and publishes, so it has two bindings: it shows a `record` describing what is playing — title, artist, album, status, and position and duration in seconds — and publishes transport words back to one `str` message (`toggle`, `next`, `prev`, `seek:<seconds>`). Those are a streamer's own vocabulary rather than this app's, which is what lets one tile drive whatever is on the other end. The position counts forward in the browser between readings, so the bar moves at one second while the device behind it is polled at whatever rate suits it; every reading that arrives is taken as the truth and the count restarts there. That is also why this is one record rather than five messages — a tile drawn from five would redraw itself five times, and show a new title against the old duration in between. Being both is why `INPUT_WIDGETS` does not gain it: what that set means is "the message this widget publishes is its only binding", which is exactly what a player is not. Its reading is checked the usual way and its `target` separately. The fader beside it needed nothing new. `ui/core` has had `orientation` on the slider all along and all three looks draw it; only the widget never passed it, so a volume control — the one thing reached for without looking, where up is louder — could not be a column. Now it can, and the tile's height is the track.	2026-08-30 14:17:16 +02:00
stroblme	565d6d2433	Docs: warn about the half-filled bucket, and say which node schedules ... Say on the querying-chart page that a flow doing its own binning has to drop the newest bucket, as the observability endpoints already do, and make plain that `inject` is the scheduler while `trigger` is a debounce and hold.	2026-08-28 14:55:06 +02:00
stroblmeandClaude Opus 5	0ffcabfdb9	Media dtypes: image, audio and video as narrowed artifact references ... A port may now declare `image`, `audio` or `video`. Each is the artifact reference the engine already had, narrowed by the `media_type` on it, so a speech recogniser declares what it eats rather than taking any bytes at all and finding out. Bytes still never travel as a message and nothing on the wire stops being JSON: a camera publishes one reference per frame, a microphone one per chunk, and a reference may carry a `meta` dict nothing here interprets. Streaming media is therefore an ordinary streaming port — with one change to what that means. An emission used to journal an item with no payload, so downstream read whatever was current when the item was claimed; a consumer slower than its producer saw only the newest chunk and the ones between were lost. That is right for a training curve and wrong for a second of speech, so an emission now journals a `kind="emission"` item carrying its values, and the executor hands them to the nodes reading that message instead of writing them to state again. The value in state stays the latest, which is what everything else reads, and the wave is filtered by what actually changed rather than walking everything reachable. No queue serialization change — the existing `outputs` field carries it. Continuous media makes the store's missing GC a real problem, so this closes it: `sweep_artifacts` runs hourly, keeps every digest a `run_artifact` row records or a live message holds, spares anything written in the last hour, and stands aside entirely while a run is in flight, since a node may store a checkpoint long before it returns the reference to it. That also collects the orphans a deleted flow has always left behind. `ARTIFACT_GC_INTERVAL_S=0` turns it off. Around the edges: `GET /artifacts/{digest}` serves the media type the caller passes and answers ranged requests, so a browser plays a clip rather than downloading it; `PUT` spools to disk instead of holding the whole body in memory, as does `save_artifact` given a path; a Media widget draws whatever its message points at, and a wall panel may fetch the bytes its own tiles are showing and nothing else; and a connector gets `save_artifact`, for a device whose readings are bytes. What this cannot do is live video: a frame every second or two is a glance, and the honest answer above that is the camera's own stream, which the widget takes as a URL and the browser plays from source. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-08-26 23:44:55 +02:00
stroblme	49bc8994f3	Add the Fluksio look, and make it the one a dashboard starts in ... Two looks were somebody else's language spoken well, and neither was the product's. A dashboard nobody has dressed yet should look like the rest of the app, so there is now a third set that follows the root DESIGN-GUIDELINES.md to the letter — `--card` surfaces told from the page by a hairline and a low shadow rather than by colour, every control a pill, 16px panels, frosted floating chrome, one slate-blue accent spent on what a person can act on — and it is what `look` means when nothing says otherwise. That also turns the exemption the other way round. The dashboard is still allowed to look unlike the product; it just no longer does so by default. An existing dashboard, which has never named a look, lands on the design it had before any of this. Restraint is the style rather than an omission here: no ripple, no glow, no lift, and a press answered by the colour changing. The one deliberate departure is the selector, which holds its choice in `--primary` rather than the `--accent` the segmented rule asks for — that is a decision about the widget, not about the look, and a control must not change what it signals when the drawing changes. All three sets hold it the same way.	2026-08-24 14:25:13 +02:00
stroblme	6238728dce	Draw the panel as a panel ... Five things a wall panel showed that a wall panel should not. **A tile's body no longer clips.** It scrolled, and a box that scrolls also cuts whatever crosses its edge — which took the glow off a lit button at exactly the width where the button filled its tile, and off a gauge's arc at exactly the height where the dial filled its own. Only what is written or listed asks for a scroller now; everything else is a picture drawn to fit, and what overflows is left to the frame, which clips at the tile's edge where a shadow has already faded out. The slider's phantom scrollbar goes with it. **The selector is a selector.** Named for what it does rather than what it is, and the choice it is holding is held in the dashboard's own primary — a pill that slides between the options rather than a grey one that had to be looked for. The stored type is untouched, so no document changes meaning. **The arrangement is held off the panel's edges**, by the same distance it holds between two widgets. The ground is not held off with it: a background covers the whole panel, and only what is arranged on it has a margin. No stored panel loses a row to it. **The rail is drawn on the panel.** It was chrome bolted to the edge of the screen beside the canvas — in the app's own design rather than the dashboard's, and on a scaled canvas not even lined up with it. It now takes a column out of the canvas the way the margin does, scaled with it and wearing its look. Which cell each widget sits in is unchanged; only how big a cell is. Two of these were the same mistake twice: an unlayered rule stating `position` for everything wearing a class — `.gl-surface` on a rail placed by a utility, and a blanket lift over every child of a pressable on a pill placed by `layoutId`. Both now say it one element at a time.	2026-08-24 10:44:53 +02:00
stroblme	0b5ce4fcbb	Rework the dashboard into two looks over one behaviour ... A dashboard is a wall panel somebody hangs in their own hallway, so it now wears what they choose: a look, and a palette of their own colours. Two complete component sets live under `Dashboard/ui/` — `glass` (translucent panes over a slowly moving ground) and `material` (Material 3 tonal cards) — behind one prop contract. Every control's state, keyboard and `aria-` live in `ui/core` and are shared, so the two sets are the same dashboard drawn twice rather than two products: a set only decides what a control looks like while doing it. Four settings join the channel, each drivable by a flow like any other: `look`, `palette`, `background` and `touch`. A palette is an ordered list of hex colours — background, surface, primary, accent, text, then more chart colours — pasted from a coolors.co link or typed, written onto the canvas as the token variables everything already reads. Trailing roles are derived, so three colours are a whole dashboard, and derived text is held to AA rather than trusted (`theme.check.ts` measures it). A palette also decides light or dark, since its first colour is the ground. Widgets are measured against their own tile with container queries rather than against the viewport, animate through `motion`, and can be drawn without their title. The three reworks: - a bar draws a row per reading, up to eight, each in the dashboard's own data colours and each able to carry its own scale — replacing readings nested in one fill, which could only ever share one colour and stop at three. Documents written the old way are read as rows. - a chart's range picker moved to a column down its right-hand edge, which gives the plot back a whole row of a short tile. - the colour wheel became a disc: hue is the angle and saturation the distance from the middle, so a colour is one gesture rather than three, with brightness on a slider beside it. `index.css` and `lib/motion.ts` are untouched — the dashboard overrides token *values* on its canvas, never the blocks the two repos share.	2026-08-23 21:52:14 +02:00
stroblmeandClaude Opus 5	d958d7cde6	Add the dashboard settings channel, wired for theme and lock ... A dashboard could only ever receive as a set of tiles. This adds the dashboard itself as a receiver: `settings` maps a name to a value plus an optional binding. Unbound, the setting is simply its value — a wall panel that is always dark costs no flow. Bound, a flow drives it live and the value is the fallback. Two settings are wired: `theme` (system/light/dark) and `locked` (read-only). There is no schedule field on purpose — a node publishing to the bound message on a cron is what a schedule is here, which is the point of a channel. - `messages_for()` now walks a dashboard's bound settings as well as its widgets' bindings. Without this a paired screen is refused its own theme message, on the one surface the setting exists for; it bounds the socket too. - `locked` is gated in `usePublish`, so every control inherits it, and each control also draws itself disabled — a dead button reads as broken otherwise. The panel surface says Read-only in the corner. - The theme is a class on the dashboard's own surface, never the root: inside the app shell it must not flip the chrome. `.light` gains the tokens `.dark` already had (mirrored in the index repo) so both directions work on a subtree. - Settings bindings are type-checked from the document alone, the rule widget bindings follow, and mirrored on the server. - A bound setting is drawn on the flow canvas as a dashboard-level endpoint. - The demo's house flow now publishes `home.panel_theme`, which the demo dashboard's theme binds to: the panel goes dark after sunset, at no tile cost. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_018tULRZJUkZsw7rMJ3h4xvu	2026-08-22 13:17:56 +02:00
stroblme	8224d12c8c	Add a colour-wheel widget to the dashboard ... A custom hue ring — a conic gradient, not a canvas — with saturation and brightness sliders beside or under it depending on the tile's shape, sized for a wall panel and reachable from a keyboard. It publishes [h, s, v] by default, which is what the reference installation's DMX encoders read, and `format` switches that to [r, g, b] or "#rrggbb". `usePublish` moves to its own module so a widget in a file of its own can reach it without importing `widgets.tsx` back.	2026-08-22 12:50:59 +02:00
stroblmeandClaude Opus 5	6d84316ce5	Bound a panel credential to its own widgets, and let one screen be re-paired ... Three things a paired wall panel needed. The scope check now walks the panel's widgets instead of allowing the `/messages/` prefix wholesale: a screen may publish what its own controls and querying charts point at, read the history of what its tiles draw, and nothing else — the catalogue of every message in the installation included. The same walk that already bounds its socket, so both surfaces agree. Pending pairing codes moved out of the per-process dictionary into Redis, keyed per code with the code's own TTL and indexed in a zset so the fifty-code cap means the same thing to every worker. Without a Redis there is one process by definition, and the dictionary stays. And a per-panel nonce in the token, bumped by `POST /panels/{id}/unpair`: that refuses the screen hanging there without touching the panel, its dashboards or their arrangement. A save cannot write the nonce back, so a stale client cannot undo a revocation. Only for a credential this installation signed — one the portal minted carries no nonce and is revoked at the hub. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_018tULRZJUkZsw7rMJ3h4xvu	2026-08-22 11:57:37 +02:00
stroblmeandClaude Opus 5	11e032386b	Publish the documentation site: docs.fluksio.com ... A zensical site under docs/, served by a new `docs` compose service behind Traefik, built with --strict in CI. Same pattern the sibling n3xd workspace uses. Getting started splits the way the landing page does — one path is `pip install fluksio` and a training script, the other is a Docker stack and an afternoon in the browser — because the two audiences will not spend the same amount of time. Everything after that is shared: the concepts, the web interface (app and portal), the CLI and the API, and a reference for node types, payload types and configuration. The three flow guides move here from the docs submodule rather than being copied, so there is one version of them. Styling mirrors DESIGN-GUIDELINES.md: the app's token palette remapped onto Material's variables in both schemes, Inter, the 16px panel radius, and the one terracotta accent spent on the facility lane of the audience split. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01M7Xv3cJEW5c8AXxn2hoojV	2026-08-22 05:55:34 +02:00