> For the complete documentation index, see [llms.txt](https://docs.heisenware.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.heisenware.com/release-notes/v93-blue-meth.md).

# v93 — Blue Meth

Unreleased

<div align="left"><figure><img src="https://3495989837-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FE5Ketpww1s7TauSAJrJ8%2Fuploads%2Fgit-blob-d491f316a62c1a6638a8688cd223482fe7998635%2Fv93-blue-meth.webp?alt=media" alt="" width="375"><figcaption></figcaption></figure></div>

v93 is a new platform under the old name: a new engine, an assistant that builds with you, an MCP server for your own AI, and Ask for the people who use your Apps. Read [Breaking changes and what you must do](#breaking-changes-and-what-you-must-do) before you upgrade.

## The headlines

* **One new engine**: one engine now runs your flows both while you build in the [App Builder](https://docs.heisenware.com/app-builder/app-builder.md) and while users work in the [App Player](https://docs.heisenware.com/app-player/app-player.md). Existing Apps migrate the first time they load, and older `.hwt` bundles migrate on [import](https://docs.heisenware.com/app-builder/app-builder/test-and-deploy.md). Almost everything below rests on it.
* **An assistant for every member**: the assistant is part of the platform. It plans Apps with you in the [App Manager](https://docs.heisenware.com/app-manager/app-manager/planning.md) and builds them with you in the [App Builder](https://docs.heisenware.com/app-builder/app-builder/assistant.md): widgets, flows, sections, subflows, pages, variables, endpoints and the data model. The experimental assistant and its activation switch are gone.
* **Your own AI in the workspace**: every workspace has its own [MCP server](https://docs.heisenware.com/ai-assistant/mcp-server.md), and you build with the same tools the assistant uses. Claude, ChatGPT, Copilot Studio, Claude Code, VS Code, Gemini CLI, Mistral Le Chat and any other MCP client take the workspace's MCP address and sign in with your App Manager login: nothing to install. Microsoft 365 Copilot is set up once for your organization. You see and end every connection on the new [AI clients](https://docs.heisenware.com/app-manager/app-manager/ai-clients.md) page.
* **Ask, for the people who use your App** (beta): the invited users of an App question the workspace's data with an AI in their own words: what happened, what is, what to do. They ask in a panel inside the App or from their own AI client, and take the answer as a report. See [Ask](https://docs.heisenware.com/app-manager/app-manager/ask.md).
* **Variables and endpoints**: an App has named values and published actions. [Variables](https://docs.heisenware.com/concepts/variables-and-endpoints.md) store App-wide values and read as `$name`; [endpoints](https://docs.heisenware.com/concepts/variables-and-endpoints.md) publish a function under a stable public name that other Apps, external systems and Ask can run.
* **A data model for the workspace's database**: the workspace's own database keeps the shape of its tables, with a history of who changed what, and you shape it in the [Database editor](https://docs.heisenware.com/app-builder/app-builder/database-editor.md)'s Model tab.
* **Several workspaces per account**: an account can hold several [workspaces](https://docs.heisenware.com/app-manager/app-manager/workspaces.md), each with its own Apps, databases, files, agents and integrations.

## The assistant and your own AI

* **Planning in the App Manager**: the [**Planning**](https://docs.heisenware.com/app-manager/app-manager/planning.md) screen plans Apps with you across the whole workspace. Drop requirements, data samples and logos into **Project knowledge**; the assistant distills decisions into project notes that stay with the workspace, and scaffolds the Apps. An App it names is a link, into the App Builder and to the deployed App.
* **The Console in the App Builder**: the AI button opens the [**Console**](https://docs.heisenware.com/app-builder/app-builder/assistant.md) under the [Flowboard](https://docs.heisenware.com/app-builder/app-builder/flowboard.md), docked or over the whole board. The assistant shows its work on the canvas, follows itself to the page and screen it works on, leaves you alone once you click elsewhere, and stops whenever you say so. Every [checkpoint](https://docs.heisenware.com/app-builder/app-builder/test-and-deploy.md) it makes is one you can roll back to.
* **Project notes stay yours**: a conversation outside Planning reads the workspace's project notes only after you agree, and says how large they are before you do. One yes covers that conversation.
* **What needs your go**: deleting an executor, a widget or a page asks nothing, because a [rollback](https://docs.heisenware.com/app-builder/app-builder/test-and-deploy.md) restores it. Deleting a whole App, deploying, reshaping the data model and ending a registration do ask.
* **It knows what older Apps did differently**: the platform keeps one registry of every change that breaks what an older App does. `check_migration` applies it to one App and names the executors, modifiers, triggers, inputs and widgets that have to change. [`describe_app`](https://docs.heisenware.com/ai-assistant/mcp-tools.md) says when an App leans on an older behavior at all.
* **The workspace's MCP address**: `https://<host>/<domain>/mcp`, for example `https://acme.heisenware.cloud/acme.default/mcp`. The client finds the sign-in by itself; you sign in and allow it once, choosing **Build apps** or **Only look**. A connection nobody uses for 90 days is dropped, and a member holds at most 20.
* **The AI clients page**: each client with its own logo and its numbered steps, the address or the line to paste in the step that takes it. Connected clients are listed with their access, when they connected and when they were last used, and **Disconnect** ends one at once. Connecting a client is marked **Beta**.
* **One server name per workspace**: every snippet names the MCP server after its workspace, `heisenware` for `default` and `heisenware-<workspace>` for the others, so two workspaces meet in one client without a collision.
* **Microsoft 365 Copilot**: Heisenware becomes an agent of your organization. It is its own [integration](https://docs.heisenware.com/app-manager/app-manager/integrations.md) now, set up in four steps with your Microsoft 365 admin: register the agent's sign-in in the Teams Developer Portal, enter the registration ID here, deploy the agent package in the Microsoft 365 admin center, and everyone chosen signs in once.
* **Reach from outside**: an on-premise installation publishes a second address through its own door for AI clients that live in a cloud, under **Reach from outside** on the AI clients page.
* **A local MCP server for your own computer**: the [Integrations](https://docs.heisenware.com/app-manager/app-manager/integrations.md) panel builds a self-contained package with the credentials inside, plus the lines to paste into Claude Code, Claude Code on Windows or Claude Desktop, and the prompt that loads the platform law. One per member, optionally read-only, with a warning in the menu when a platform update has left it behind.
* **AI usage and credits**: [**Plan & Billing**](https://docs.heisenware.com/app-manager/app-manager/plan-and-billing.md) shows what the assistant did for your account: the charge of the month, tokens, runs, the months before, and the members who spent it. In the cloud the assistant runs on credits, which arrive with a paid period or as a pack you buy; your own AI through the MCP server uses none.
* **Inform Heisenware**: when the platform contradicts its own rules in front of the assistant, it does not work around it. It writes a short report of what it expected, what it observed and what it tried, and shows it as a card. Nothing leaves your workspace unless you click **Inform Heisenware**, and the card says whether the conversation rides along, with credential-shaped values redacted. A self-hosted installation sends nothing home and offers **Copy report** instead.
* **Live values can be held back**: a read-only connection, and an installation that sets its value-read policy, keep live values from an AI: no value reads, no data queries, no screenshots, no logs, no reports. The refusal says so instead of answering with nothing.

## Ask, for the users of an App

* **Switch it on per App**: **Ask** is a switch in an App's **Access Settings**, marked **Beta**, and it holds only on an App that invited users alone can open. Its users then find **Ask** at the bottom right of every page. See [Ask](https://docs.heisenware.com/app-manager/app-manager/ask.md).
* **Or from the user's own AI**: the App has an **Ask address** of its own on the workspace's MCP server. A user adds it to ChatGPT, Claude or Microsoft Copilot, signs in there with their account of this App, and allows the connection on the App's own page. The panel's **Your own AI** tab hands them the address and the three steps.
* **What Ask reads**: every database and InfluxDB of the workspace, read-only, plus the workspace's container and agent logs and what each App is made of. PostgreSQL, MySQL and SQLite answer in a read-only transaction the database itself enforces; a dialect for which that cannot be proven is refused, with the reason. A database and a time-series database describe themselves to whoever is about to query them. Nothing is changed except through an endpoint.
* **What Ask runs**: the endpoints of its own App, as the user, on the released App. An endpoint marked as needing approval runs only after the user says yes to exactly that call, on an approval card in the panel.
* **It computes what one query cannot shape**: two reads side by side, one column per machine, differences, shares, statistics and moving windows. It never reckons from rows it read itself.
* **Charts and reports**: Ask draws charts beside its answer with the App's own chart, gauge and timeline widgets, so you see them before they go anywhere. A report is a download in the App's look, as PDF, Word, Excel or CSV, and it belongs to the user who asked.
* **It opens the files a row points to**: photos, PDFs, Excel and Word files. It shows them in its answers, takes a file the user hands it, and puts photos and signatures into reports.
* **The conversations stay with the user** and go with them, and a member's preview shows the launcher where users will see it, disabled.

## Building logic

* **Variables**: store named, App-wide values. Create them in the [Variables explorer](https://docs.heisenware.com/app-builder/app-builder/variables.md), or right-click any function output, [modifier](https://docs.heisenware.com/app-builder/app-builder/flowboard/modifier.md), [filter](https://docs.heisenware.com/app-builder/app-builder/flowboard/filter.md) or [error handler](https://docs.heisenware.com/app-builder/app-builder/flowboard/error-handler.md) and choose **Make variable…**. Read them as `$name` in static inputs and as bindings in JavaScript or JSONata expressions. A secret variable is encrypted and masked everywhere. See [Variables and endpoints](https://docs.heisenware.com/concepts/variables-and-endpoints.md).
* **Three built-ins**: `$USER` holds the signed-in user of the scope a run happens in, `$LOCALE` the App's language (`de-DE`), and `$TIMEZONE` the time zone the user's browser reported (`Europe/Berlin`). In the shared scope `$USER` and `$TIMEZONE` are empty. See [Languages and time zones](https://docs.heisenware.com/concepts/languages-and-time-zones.md).
* **Endpoints**: publish any [function](https://docs.heisenware.com/concepts/executors-and-instances.md) under a stable public name from the [Endpoints explorer](https://docs.heisenware.com/app-builder/app-builder/endpoints.md) or the function's context menu. External [VRPC](https://docs.heisenware.com/developers/developers/vrpc.md) clients set its inputs, trigger it by name and subscribe to its output; another App of the workspace reaches it at one address, in the Builder and in production ([Suites of apps](https://docs.heisenware.com/concepts/suites-of-apps.md)). An endpoint says what its inputs are, and whether an AI has to ask the user before running it.
* **Event outputs**: what a function hands a callback or an event listener arrives as value pills directly below the function's output, one row per handler. A value shows the last payload, wires to inputs, triggers and widgets, and carries its own extension nodes, exactly like the output. Values named in the function's documentation carry their names. See [Backend events](https://docs.heisenware.com/concepts/backend-events.md).
* **Subscriptions and registrations**: an executor declares what it listens to; the agent keeps one registration per instance, function and set of arguments, and everyone asking for the same joins it. The board shows one dot per scope with who listens, **Stop listening** on the event item ends an executor's subscriptions until its next trigger, and the Functions explorer's **Registrations…** lists every live registration with its events per second and an **End** for each.
* **Events reach every viewer**: a backend event whose subscription was declared in the shared scope reaches every viewer of a deployed App. An event function keeps listening after a restart of the platform or of a deployed App, and a payload that cannot travel as JSON is reported instead of silently lost.
* **Loops on every function**: **Process One By One** runs an executor once per element of a list, with an optional pace between elements, and collects the results as a list. **On all inputs** is the zip loop: several lists iterate together, row by row, and a list of instances or agents of the same length runs row *i* on target *i*. A failing element becomes its error message in the result list, and the loop goes on. See [When streams meet](https://docs.heisenware.com/concepts/when-streams-meet.md).
* **Constructors create a list of instances**: a constructor's instance input takes one name, a list of names, a `$variable` holding either, or a wire, so a new machine is a data row and not a new node. Creating a name that exists changes nothing, so a poll or App start can keep the promise. A name with a glob promises instances born on demand by the calls that need them, and such a birth waits until the constructor's required parameters hold values.
* **Instances per user**: an instance name carrying `<client>` gives every connected user their own. It is never restored after a restart or a version switch: the next call of that user makes a fresh one.
* **Dynamic addresses**: an executor's address is three parts, agent, class and instance, and each can be fixed or taken from a value at run time: a name, a list, a glob for every live target, a variable or a wire. A list or glob without a loop broadcasts in parallel, one result per target. The node's status follows its whole address and names the level that is offline.
* **Scopes**: a value lives in the shared scope, in the scope of one user, or in the scope of one subflow call. A user's values and subscriptions wait three hours after the browser left and are then dropped; a page reporting back later starts a new session. A poll whose inputs or expressions read a variable a user wrote fans out to every viewer, each in their own scope. See [Scopes](https://docs.heisenware.com/concepts/scopes.md).
* **Subflow timeouts**: a [subflow](https://docs.heisenware.com/concepts/subflows.md) blueprint says how long a call may take, **Time out** on its trigger, 25 seconds by default, and every caller follows unless it sets its own. Two identical calls at the same time are two calls with two scopes. A failing node inside fails the caller at once, with that node's own message instead of a timeout.
* **Filters hand on what they let through**: a [filter](https://docs.heisenware.com/app-builder/app-builder/flowboard/filter.md)'s value is the value that passed, and `passed` is the verdict. A trigger source on a filter fires on a pass only. See [Extensions, branching and errors](https://docs.heisenware.com/concepts/extensions-branching-and-errors.md).
* **Error handlers hand on the reason as text**: an [error handler](https://docs.heisenware.com/app-builder/app-builder/flowboard/error-handler.md) receives `{ message, cause, originalPayload }`, with `cause` the reason as text. A toast in the browser can now show "message, because: cause", which it could not while the reason travelled as an error object.
* **"All updated" trigger mode**: a [trigger](https://docs.heisenware.com/concepts/triggers-and-wires.md) with several sources can wait until every source has delivered and then fire once. It pairs the n-th delivery of each source, so a slow source never runs with a fresh value from a fast one.
* **Polling is immediate and live**: a function with an **App Start** repeat interval runs the moment its App starts, and adding, changing or removing the interval while the App runs takes effect at once.
* **Annotation cards**: [annotations](https://docs.heisenware.com/app-builder/app-builder/flowboard.md#annotations) on the Flowboard are documentation cards written in Markdown: headings, lists, tables, pictures, links and mermaid diagrams, with a color palette and a zoom behavior that never overlaps its neighbors. They explain more than one executor; what one node does belongs in its comment.
* **Section colors**: tint [sections](https://docs.heisenware.com/app-builder/app-builder/flowboard.md#grouping-sections) on the Flowboard from a palette in the section header. A note joins a section when it lies mostly inside it, and auto-format lets both keep their room.
* **A calmer Flowboard**: the view controls moved into the toolbar, a large App no longer slows the board down, zoomed out it draws a skeleton, **Evaluate** runs the pipeline you are looking at, a long static input folds into a pill that edits in a popup, and a pipeline node can carry a caption. Backspace deletes the selection, here and on the page canvas.
* **Files beside the board**: the Flowboard is a tab, and every file the Files explorer opens is a closable tab next to it: code with highlighting, text, rendered Markdown, pictures and PDFs. The board never reloads.
* **Explorer order**: the explorers read Functions, Pages and actions, Files, Variables, Endpoints.

## Pages and widgets

* **Widget General tab**: every [widget's](https://docs.heisenware.com/concepts/widgets-and-links.md) settings open on a **General** tab that lists what it receives and emits. Linked rows show the live value, unlinked rows offer demo data you inject with one click, and you drop a function output straight onto a row to link it. The tab also holds **Visible** and **Sticky**.
* **Per-screen layouts**: every widget has a reference screen, the one it was first placed on. Other screens follow it automatically until you touch the widget there; from then on that screen keeps its own layout. Dots on the selected widget show which screens are automatic, authored or the reference, and **Reset position to auto** returns a screen to automatic. The [Page editor](https://docs.heisenware.com/app-builder/app-builder/page-editor.md) preview and the deployed App render layouts identically. See [Screens and layouts](https://docs.heisenware.com/concepts/screens-and-layouts.md).
* **The App's reference screen is derived**: it is the screen most of the App's page widgets reference, the wider one where two tie, and the widest screen the App serves while nothing is placed. Nothing stores it, so it follows your work. A widget created without a screen lands there, and the answer says which screen that was.
* **The two tablets**: the handheld tablet held upright is 800×1280 and the panel mounted at a machine is 1280×800, the sizes of today's devices. Upright screens fit the window's width and scroll; landscape screens fit whole, so a one-screen page stays one screen.
* **A disabled screen is never drawn**: a phone or tablet whose canvas is switched off hands over to the next enabled one, its own orientation first. An App always serves at least one screen.
* **Pins**: a widget setting is shared across screens until you pin it. Hover a field and click the pin to give the selected screen its own value for that field alone; a faded pin shows the field is pinned on another screen. Column counts, font sizes, spacing, legend placement and **Visible** are pinned by nature and always belong to the screen you set them on: switch a widget off on the phone and it stays on the desktop, faded in the Builder, gone in the App.
* **Pages and the menu pin the same way**: page name and icon pin per screen in the page settings, the page height is pinned by nature, and the navigation menu is one form with a pin on every field. The former **Detach configuration** and **Different navigation menus per screen** are gone, and what you had configured per screen is kept as pins.
* **Widgets inside a group have no pins**: the tile is one thing on every screen, so every setting of a child is shared, and grouping folds the pins of the screen you group on into the children.
* **Sticky widgets**: a sticky widget stays where the screen puts it while the page scrolls beneath it, above the content. A card with a title and a logout button, grouped and made sticky, is the App's own header bar; a bar at the bottom is a footer, a button in a corner a "back to top". The Builder marks it with a badge and keeps it in place on the canvas; the test run and the App are where it sticks. A child follows its group.
* **Groups are references**: a [group](https://docs.heisenware.com/reference/widgets/layout/group.md) lists its children by name and renders them where they are, and the tile is their bounding box: move or resize a child and every tile follows. Children keep their own executor links, and `<Current Value>` hands a child the whole row. See [Groups and tiles](https://docs.heisenware.com/concepts/groups-and-tiles.md).
* **The menu drawer**: the burger button sits in a top corner of the page you choose, fixed to the screen while the page scrolls beneath it. It opens from the left or the right, over the page and dimming it, or pushing it aside, as wide as you set. A menu set to shrink the page now pushes it, because the page is drawn at one scale and shrinking only cut off its far edge.
* **App actions**: the [Pages and actions explorer](https://docs.heisenware.com/app-builder/app-builder/pages.md) ends with a row of App actions you drop on a button, an icon or an image for a click, or on a function output, modifier, filter or error handler for a value. **Logout** ends a session on a shared device: the App forgets the device's credentials, revokes the session and starts afresh. **Reload** restarts the App with cleared caches. **Back** returns to the previous page, and the browser's back button and a phone's back gesture now walk the App's pages too. **Open link** and **Switch page** complete the family. See [Pages and App actions](https://docs.heisenware.com/concepts/pages-and-app-actions.md).
* **Toast is an App action**: the toast leaves the widget palette and joins the others. Dropped on an output or an error handler it pops once, whatever page the user is on, where a toast widget copied to every page popped once per page. Click an action's chip on the Flowboard to change its settings.
* **An action can take the live value**: the action's dialog offers **Take message from the live value**, and the same for a URL and a page. Switched on, an error handler's error appears as "message, because: cause", and your logic chooses where to go or what to say.
* **Introduced the polar chart widget**: draw radar and wind-rose style charts, with one series per numeric field seeded automatically. See [Polar chart](https://docs.heisenware.com/reference/widgets/display/polar-chart.md).
* **Introduced the gallery widget**: show several files as pictures to look through, one large with thumbnails to pick from, from a list of files or from the rows that hold them. See [Gallery](https://docs.heisenware.com/reference/widgets/display/gallery.md).
* **A frame around a widget is a Card behind it**: **Toggle tile view** is gone from the widget's context menu. A [Card](https://docs.heisenware.com/reference/widgets/display/card.md) frames one widget or several at once, and every widget fills its whole box.
* **Text box takes Markdown**: the [Text Box](https://docs.heisenware.com/reference/widgets/display/text-box.md) renders headings, lists, tables, quotes, code and links in one consistent style in the App theme's colors, written in its rich-text editor or as Markdown. It gets a regular settings panel with a **Content** and a **Look & feel** tab.
* **Theming as one recipe**: an App's look is a record of its own, a base theme plus the variables changed on it, and it travels with export, import and rollback. The [Theme editor](https://docs.heisenware.com/app-builder/app-builder/theme-editor.md) and the assistant write the same recipe, an open Builder swaps the compiled stylesheet in place without reloading, and a deployed App keeps the look it was released with until the next deploy. An App nobody themed shows the platform's look.
* **Settings panel overhaul**: range settings combine a slider with a number input, long tabs fold into collapsible sections, labels use sentence case, and every widget's data tab is **Content** and its appearance tab **Look & feel**. Every setting carries a title, and the text and chat widgets get a settings panel.
* **Automatic colors everywhere**: every color field, chart axes and palettes, map markers, kanban and status lamps included, accepts **Automatic** and previews the theme color it resolves to. A chart without colors paints its series in shades of the App's accent. The color keyword `gray` becomes `auto`; the old keyword keeps working.
* [**Data grid**](https://docs.heisenware.com/reference/widgets/display/data-grid.md): color cells or whole rows by rules on column values, dates included. Columns are typed from the data contract instead of guessed, a nested field is addressed by dot path, a date range edits in a range box and sorts by its start, and a column's media type offers **No preview** as a named choice. A column layout you deploy reaches every browser, and what a user rearranges is remembered per screen, in the Player only.
* [**Charts**](https://docs.heisenware.com/reference/widgets/display/chart.md): a series can be written to any pane and axis the chart declares and is scaled by that axis, a click on a pie slice can feed a flow, a constant line says where its label goes, and live data redraws at once unless you ask for animation.
* [**Forms**](https://docs.heisenware.com/reference/widgets/input/form.md): a form nests by dot paths, writes while you type, keeps its columns on a phone, and a cleared form looks as it did when first shown. `formData` goes out one second after the last keystroke, and `submitted` once per entry.
* **Dates as data**: a date leaves a form, grid, list or tiles as a calendar date (`2026-10-01`), an instant (`2026-10-01T06:30:00Z`) or a time of day (`08:30:00`), never as display text, and a date picked on 1 October stays the 1st wherever it is read. A date field that cannot read its value shows empty instead of disappearing. See [Files, data and dates](https://docs.heisenware.com/concepts/files-data-and-dates.md).
* [**Photo**](https://docs.heisenware.com/reference/widgets/input/photo.md) **widget**: the camera shows the full frame, streams in Full HD, mirrors the front camera, and the captured preview matches the live view.
* [**Progress bar**](https://docs.heisenware.com/reference/widgets/display/progress-bar.md): configure the bar width, and bind `min`, `max` and `showStatus` individually.
* **One App speaks one language**: the App's **Language** in its **General Settings** governs its widgets, the Player's own screens and the documents it makes, and the browser's language never decides. An App in another language is a translated copy with its own URL, backend and users, made and refreshed in one step and never edited by hand.
* **Open a page by URL**: append `?page=<name>` to an App's URL to open it on that page.
* **Smoother live data**: widgets keep their live values when moved or reconfigured, updates render at most once per frame, and the Player renders plain DOM, which gives exact click handling on charts.

## Data

* **A data model for the workspace's database**: the workspace's own database keeps its model inside itself, an append-only record of every change of a table with who made it and when. The [Database editor](https://docs.heisenware.com/app-builder/app-builder/database-editor.md)'s **Model** tab draws every table as a card and every relation as a line, answers the hand like the Flowboard, keeps every card where you place it and places a new table beside the ones it links to. You shape it there: add a field, change a type, relate two tables by the sentence that is true, switch on an audit log, duplicate a table. Removing a field, a relation or a table and changing a type first tell what is lost, the Apps that use the table included.
* **Drift and adopt**: a table, field or relation made outside the model, by SQL from elsewhere, by a database import or by an App built before, is marked, and **Adopt** takes it into the model without touching the database.
* **SQL is recorded**: a `CREATE`, `ALTER`, `DROP` or `RENAME` through `executeSql` on the workspace's database goes into the model with the statement and who ran it. `executeSql` and `read` take bound parameters, answer the rows of every statement that reads them, and carry `actorId`.
* **The database keeps its audit log and announces its changes**: on PostgreSQL, the workspace's own database included, the database itself writes a table's [audit log](https://docs.heisenware.com/reference/functions/storage/relational-database.md#audit-logging) and announces its changes to [`onChange`](https://docs.heisenware.com/reference/functions/storage/relational-database.md#onchange), whoever writes: a row function, `executeSql`, another system. Who acts travels with the write.
* **One row contract on every database**: a row read by `getRow`, `findRow`, `findRows` or `getTableData` carries the rows it points to by the relation's name (`order.customer`, with a role `order.payer`, many-to-many `post.tags`), and child rows when `include` names them (`customer.orders`, `customer.payerOrders`). The same on every database, while the App runs and after a restart. See [Related rows in a result](https://docs.heisenware.com/reference/functions/storage/relational-database.md#related-rows-in-a-result).
* **Every table of every database is read**: a [relational database](https://docs.heisenware.com/reference/functions/storage/relational-database.md) instance reads the tables it did not make itself with the database library's own queries, now for every dialect it offers, Oracle and Snowflake included. A table without a primary key can be written and read, and one table the instance cannot read no longer costs the others.
* **Files a row keeps**: a table row keeps a file as a small entry, and the file itself lies in the workspace's file store behind the media server. Two field types say how many: `file` holds one file, `files` a list of them. The [upload](https://docs.heisenware.com/reference/widgets/input/upload.md), [photo](https://docs.heisenware.com/reference/widgets/input/photo.md) and [signature](https://docs.heisenware.com/reference/widgets/input/signature.md) widgets deliver exactly that, the media view, gallery, data grid and form show it, and the HTTP, Email, File and PDF functions take it wherever they took a path. The same file is stored once however often it is uploaded, and nobody deletes one: thirty days after the last row let go of it, the platform's clean-up removes it. See [Files](https://docs.heisenware.com/reference/functions/storage/files.md).
* **New database functions**: the [relational database](https://docs.heisenware.com/reference/functions/storage/relational-database.md) gains `dumpDatabase`, `importDatabase`, `duplicateTable`, `countRows`, `clearTable`, `enforceUniqueField`, `generateFakeRelationalData` and the model functions `getDataModel`, `getDataModelHistory`, `getDataModelDrift`, `adoptDrift`, `previewRemoval`, `removeField`, `removeRelation`, `previewTypeChange` and `changeFieldType`. `updateRow` takes the row's `id` or a `uniqueKey` as an option and merges JSON fields with `merge`.
* **New time-series functions**: the [timeseries database](https://docs.heisenware.com/reference/functions/storage/timeseries-database.md) gains `deletePoint`, `updatePoint`, `readRows`, `exportData`, `importData`, `exportMeasurementData`, `adoptLadder`, `getMeasurementDetails`, `getMeasurementStats` and `generateFakeInfluxData`. `writePoint` accepts a timestamp, `writePoints` and `writeDownsampled` accept one timestamp per point, and `read` supports `offset` and `sortDesc`.
* **Series stay apart**: a measurement whose points carry tags holds several series, and `withTags` reads them apart, one row per series with its tags. Without it a window joins the series by the function asked for. The editor's rows, charts and CSV export ask with it.
* **The Database editor is the workspace's**: it opens from the Builder's toolbar inside any App, and from the App Manager's **Databases** entry without one. Create tables, insert and edit rows, duplicate tables, export tables as CSV, export and import complete SQL dumps, write time-series points, export measurements, back up and restore all time-series data, and generate test data. A table's card counts its rows, a JSON value opens in a viewer, and it browses databases running on native agents. The Data Visualizer of v92 is this editor.
* **A time-series database has a Model tab too**: how it keeps points, the downsampling ladder, and its measurements as cards with their fields, tags and rows, where each is kept, and the Apps that use them.
* **An exported App carries its tables**: a `.hwt` [bundle](https://docs.heisenware.com/app-builder/app-builder/test-and-deploy.md) carries the shape of the tables its App uses and the uploaded files it references, so it looks and works the same after an import on another server. Rows stay behind, and so do secrets; the import summary lists what has to be entered. An import adds what the workspace lacks without changing what it has.

## Running an App, and who may open it

* **Sign-in in the App's own look**: the sign-in card of an App shows the App's icon and name on top and the step under it, in the App's theme, and an invitee also sees which address was invited. These screens speak the App's language. See [Sign up and sign in](https://docs.heisenware.com/getting-started/sign-up-and-sign-in.md).
* **An invitation link that no longer works says so**: as it opens, and it leads on to the App's own sign-in. A link lives 30 days, a new user's first invitation outlives the invitations and resets after it, and an App's mails speak the App's language.
* **A user who cannot get in is offered a reset**: inviting someone who already has access offers to send a password-reset link instead.
* **Kiosks and shared devices**: the Player signs in on its own screens, and Google by redirect, so no token passes through the browser's address bar. A public or password-protected App signs a returning visitor back in as the user it remembered, and the master password of a protected App stays on the server. The **Logout** App action ends a session, on a button or from your logic, for example a Timer for a session limit.
* **Files of an App's users**: a user brings files in through the upload and photo widgets, into the file store, and reads the files a row shows them. Their access no longer reaches anything else on the file server, and every upload and every download of a runtime file needs an access ticket.
* **An App's state is one word**: **Running**, **Not running**, **Restarting**, **Stopped**, **Unknown**, **Not deployed**, the same word in the Dashboard, on the Apps screen, on an App's page and in the menu, with a hover that says why. A stopped App tells its users it is under maintenance instead of loading for ever.

## Agents and connectivity

* **Agents panel: fleets and remote updates**: the App Manager's new [Agents](https://docs.heisenware.com/app-manager/app-manager/agents.md) panel lists every agent of the workspace, grouped by fleet, with its online state, when it was last seen, its build and where it stands against the fleet's current build. [Native agents](https://docs.heisenware.com/app-manager/app-manager/agents/native-agent.md) are built there, with a note per build and the sentences of what each connector can do on the host, restarted from there, and updated from there. Building moved out of the App Builder, which still shows each agent's build, restarts it and fetches its log. See [Agents and where code runs](https://docs.heisenware.com/concepts/agents-and-where-code-runs.md).
* **Rollouts**: a rollout brings a build to a fleet all at once, canary first, or in batches. It starts at once, tells a wave while the wave runs, queues agents that are offline, pauses on a refused update and on the next failure if you ask it to, resumes where it stopped, and shows every agent's phase. On the host the agent downloads the build over HTTPS from the platform, verifies checksum and the platform's signature, swaps its executable, restarts through the service manager, and swaps back by itself when the new build does not connect.
* **Requirements for IT**: every build comes with a sheet naming the host, both ports, the service, its paths and what the build can do on the host. The same text ships in the installer, the installer line can be copied as a link and a shell line, and a machine can be given its fleet name in the installer before its first start.
* **Native agents are named native-agent**: a new agent logs in as `native-agent-<id>@<domain>`, a fleet as `<prefix>-native-agent-<id>@<domain>`. Agents built before v93 are shown as legacy, keep their `edge-connect` names, keep logging in and keep onboarding, and need one installation by hand; a rebuild keeps the name the account has. A fleet name is lowercase letters and digits only.
* **Native agents as ctrlX OS apps**: a Linux or ARM 64 build can be packaged as a snap and installed on a ctrlX CORE or COREvirtual under **Apps**: choose **ctrlX OS app** as the package in the build dialog. The agent runs as a confined app on the device, starts with it, and the ctrlX connector talks to the device's own Data Layer at `localhost`. A newer build is installed the same way; remote updates stay with the Debian and Windows builds. See [Running on a ctrlX CORE](https://docs.heisenware.com/app-manager/app-manager/agents/native-agent.md#running-on-a-ctrlx-core).
* **ctrlX Data Layer connector**: the new [ctrlX Data Layer](https://docs.heisenware.com/reference/functions/connectors/ctrlx-data-layer.md) connector talks to a Bosch Rexroth ctrlX CORE (or COREvirtual) over the REST API of ctrlX OS: `read`, `write`, `browse`, `metadata`, `bulkRead`, `bulkWrite`, and `subscribe` to value changes with the device's own settings (`publishInterval`, `samplingInterval`, `deadBandValue`, …). It logs in with a ctrlX user, renews an expired session on its own and reopens a lost subscription stream. Timestamps arrive as ISO time.
* **Trusted certificates**: machines and servers on your own network show certificates nobody trusts yet, and every connector used to solve that on its own. The new [Trusted certificates](https://docs.heisenware.com/reference/functions/connectors/trusted-certificates.md) functions trust a server once for the whole workspace: `trustServer` with the device's address, `addCertificateAuthority` with the company certificate from IT, `list` and `remove`. HTTP / REST, the ctrlX connector, the OPC UA client, Hydra MIP, the MQTT client, Email, InfluxDB and the relational databases consult the same list, and a database or mail server is asked for TLS the way its own client does. The `tls` option of a connector stays the exception on top.
* **OPC UA client monitors parameter sets**: `monitorVariable` and `monitorNode` of the [OPC UA client](https://docs.heisenware.com/reference/functions/connectors/opc-ua-client.md) accept a list of addresses. One block subscribes to a machine's whole parameter set with as few server requests as the server takes, and every change arrives tagged with its address and `nodeId`. `stopMonitor` takes the same list. The client learns the operation limit a server does not state, and stops guessing in a handful of small places.
* **OPC UA server rebuilt**: the [OPC UA server](https://docs.heisenware.com/reference/functions/connectors/opc-ua-server.md) connector works again on the current OPC UA stack and does what its page promised. Setters store what clients write and fire `onSet` on every write, requestors answer reads through `onRequest`, values set before `start` are served, subscribed clients are notified immediately, and getters are read-only. Every node has a stable node id built from its path, or an explicit `nodeId`, and a `namespaceUri` places the model in its own namespace. New: `users` for password logins, `securityModes`/`securityPolicies`, `hostname`, `getValue`, `setValues`, `describe`, `getEndpointUrl`, `offSet`/`offRequest`, and `setValue` takes a status code and a source timestamp. It takes a hundred clients and names the cap when it refuses.
* **Signal simulation**: the new [Signal simulation](https://docs.heisenware.com/reference/functions/utilities/signal-simulation.md) class (`SignalSimulator`, Utilities) is the one producer for every source that is not connected yet. An instance owns a simulated clock (tick interval, time scale, start time, pause, step, seek) and signals declared as JSON in sixteen kinds (constant, random, random walk, waves, ramp, integrator, counter, lag, sequence, switch, state machine, pulse, daily profile, replay of recorded samples or a CSV from the Files explorer, expression), with decorators on any of them (noise, clamp, precision, quantize, dropout with quality, spikes, stuck), runtime control (force and release, trigger, state changes, fault injection, scripted scenarios), `generate` for histories without running, and presets: silo, tank, pump, conveyor, machine, CNC machine as the Heidenhain connector reports it, an injection moulding machine at 10 ms with its cycle phases, curves, events and per-cycle KPIs, energy meter, production orders arriving like an ERP export. Everything is deterministic under a seed, and its value map feeds `OpcuaServer.setValues` as it is.
* **GPIO counter**: the [GPIO counter](https://docs.heisenware.com/reference/functions/connectors/gpio-counter.md) counts one machine on several inputs, filters double pulses, takes new rules while it runs, learns the pace its pulses really have and watches a slow machine against the order's target time. It loses no event: it journals every pulse, replays the journal at birth and counts through a restart and a power cut. It refuses loudly on a Pi whose GPIO chip it cannot open.
* **Connector contracts**: every connector function says what it takes and what it gives back, and a read says that it changes nothing. A flow can ask a serial port whether it is open and why not, the Modbus and MQTT connectors notice a dispose that lands while they connect, and a Zebra command ends with what happened to it instead of a timeout.
* **Stateful utility classes got complete contracts**: the [Buffer](https://docs.heisenware.com/reference/functions/storage/buffer.md), [Accumulator](https://docs.heisenware.com/reference/functions/storage/accumulator.md), [Data store](https://docs.heisenware.com/reference/functions/storage/data-store.md), [Counter](https://docs.heisenware.com/reference/functions/utilities/counter.md), [Timer](https://docs.heisenware.com/reference/functions/utilities/timer.md), [Event simulation](https://docs.heisenware.com/reference/functions/utilities/event-simulation.md), [Stopwatch](https://docs.heisenware.com/reference/functions/utilities/stopwatch.md) and [Cron](https://docs.heisenware.com/reference/functions/utilities/cron.md) classes document every input and output, every event has a payload, and invalid inputs fail with a message instead of misbehaving. New: `Buffer.onFull` (sliding and tumbling windows), `Accumulator.onComplete` (values from different sources meet in one record), `Counter.onChange` and `setCount`, `DataStore.onChange`, `find`, `filter`, `update` and `remove` by condition, `Trigger.debounce` with `onDebounced`, a payload on `triggerManually`, `Cron.onTick` and a schedule set at creation that survives restarts, and a `Stopwatch` tick interval set at creation.

## The App Manager

* **The Dashboard**: the App Manager opens on the [Dashboard](https://docs.heisenware.com/app-manager/app-manager.md). **Needs you** names the Apps that are meant to run and do not, the agents that are offline or behind the current build, and the local MCP servers a platform update left behind, each a link to its screen. Four tiles count the users signed in today, the Apps running, the agents online and, for an owner, the account's credits. A table says how each App of the workspace runs and how it is used, and a short checklist leads from an idea to a live App.
* **The Apps screen**: every App of the workspace as a card with its icon, name, id, version and status, a search from seven Apps on, a door into the App Builder and one to the deployed App, and a share panel with the link and a QR code. **New app** starts a blank App without a dialog, or one [**From a file**](https://docs.heisenware.com/app-manager/app-manager/apps.md): drop an `.hwt` bundle, see what is inside it (language, pages, widgets, files, tables, the secrets to enter, the agents that are not connected here) and create the App from it.
* **Multiple workspaces**: an account can hold several [workspaces](https://docs.heisenware.com/app-manager/app-manager/workspaces.md), each isolated from the others: its own Apps, databases, files, agents and integrations. Switch between them at the top of the App Manager's menu, add one with **Add workspace**, and delete one by typing its name. How many an account holds is part of its plan.
* **Dividing the plan's Apps**: the plan's Apps are the account's pool. Give a workspace **Apps reserved** and it may hold that many; the workspaces without a reservation share what the reservations leave. The **Workspaces** card of **Plan & Billing** shows the allowance of each.
* **Owners and editors**: a [member](https://docs.heisenware.com/app-manager/app-manager/members.md) is an owner or an editor of a workspace, or an owner of the account, who reaches every workspace. An owner of a workspace builds there and chooses who else does; an editor builds there. An invitation names what it grants, and access that is withdrawn ends the member's open connections at once. The v92 roles are gone.
* **Integrations belong to a workspace**: only the members who build in a workspace see and change its integrations, and an integration that is removed takes its connection with it. [Native agents](https://docs.heisenware.com/app-manager/app-manager/agents.md) have their own panel.
* **Plan and billing**: [**Plan & Billing**](https://docs.heisenware.com/app-manager/app-manager/plan-and-billing.md) reads as cards: **Subscription** with the Apps and workspaces in use, **Workspaces** with their allowance, **Credits** and **AI usage**. An on-premise installation sees its **License** instead, uploads a license file there, and is warned before a license ends.
* **A new front door**: sign-up is one screen that asks for an account name, an email address and a password, says what is missing instead of doing nothing, and signs you in when it is done. Every door of the platform shares one frame. See [Sign up and sign in](https://docs.heisenware.com/getting-started/sign-up-and-sign-in.md).
* **Deleting an App**: deleting an App in the App Manager also deletes the users it leaves with no other App. Deleting a workspace deletes everything in it, and says what that is before you confirm.
* **Removed the widget import and export action** from the App Builder.

## Self-hosting

* **One front door**: a release package no longer carries secrets in `docker-compose.yml`. They live in `.env`, and the package ships `start.sh`, the same front door every other installation mode has: it generates missing secrets, validates them, and starts the services. `./start.sh status` says what is `ok`, `default` or `missing`, and `./start.sh rotate` renews the internal secrets. Every environment variable has its row and its words in the manifest. See [Install](https://docs.heisenware.com/self-hosting/self-hosting/install.md).
* **Upgrading from v92**: `install.sh` recognizes a v92 installation and moves its secrets into `.env` before anything else, so your data keeps the credentials it was created with. See [Upgrading from v92](https://docs.heisenware.com/self-hosting/self-hosting/upgrading-from-v92.md).
* **Nothing reports home unless you ask it to**: telemetry is off unless the installation names a broker, and an installation that already wrote the old default into its `.env` keeps reporting until that row is removed. A self-hosted installation never sends an **Inform Heisenware** report either: the card offers **Copy report** instead. There is no update check and no crash reporting.
* **Remote support**: an installation can dial out to Heisenware's support over one outbound connection, nothing inbound, armed only by the keys you paste into `.env`. Support then runs the platform's own tools against your installation, reads its containers and their logs, and nothing else crosses. You can make the session read-only, forbid live values, and give it an end date; every call is logged. See [Remote support](https://docs.heisenware.com/self-hosting/self-hosting/remote-support.md).
* [**Rollback**](https://docs.heisenware.com/self-hosting/self-hosting/install.md): backups include the platform version, so a restore rolls back data and version together and warns when old images were pruned.
* **Backups stay yours**: a backup takes only the platform's own volumes, and a restore leaves the volumes of other software on the same machine untouched.
* **Backup upload**: `./install.sh upload` sends a backup to a private S3-compatible bucket with nothing but `curl` and `openssl`: the request is presigned locally, and the key support hands out is upload-only.
* **Certificates**: each installation generates its own self-signed TLS certificate on its first install, and release packages no longer carry one. An installation set up from an earlier package shares that package's key with every other one: delete the `certs` folder and run the installer again, or install your own certificate.
* **Google sign-in is gone on-premise**: whatever the installation's environment says. Members sign in with their email address and a password, and set one through **Forgot password** if they have none.
* **No assistant on-premise**: an on-premise installation runs no assistant service, so it has no **Planning** screen and no assistant in the Builder. Its members connect their own AI to the workspace's MCP server instead.
* **The platform runs on Node 24**, and the connectors on a Debian that still gets updates.

## Fixes

* **App Manager reloads**: a service of a workspace restarting no longer fills the screen with **Lost connection** messages and reloads the page. A real loss is told once, after five seconds, until the connection is back.
* **Member invitations**: someone who is already a user of an App now gets the email when you invite them as a member, and a member whose invitation went missing is invited again instead of deleted.
* **Sign-in and invitation forms**: they say what is missing instead of doing nothing, and browsers fill a saved email into **Email**, not into **Account name**.
* **Multiple tabs**: closing or reloading one browser tab no longer silences live data in another tab of the same user. Every tab holds its own connection and its own session, and a tab whose backend lost its session starts a new one.
* **Deployed App integrity**: deleting a page in the App Builder no longer removes widgets of the deployed twin, a redeploy releases exactly the version it names, and a version switch leaves the released App alone.
* **Connector instances**: instances created in the Functions explorer survive a restart of the connector service, and a table made by `defineTable` takes rows after one.
* **Boot and first load**: clicking a widget while an App is still loading no longer crashes it, grids show current data instead of the snapshot taken at deploy time, a value box fetches on mount, and an App that was never released says so instead of loading for ever.
* **Buttons in groups**: a button inside a group widget triggers its function, opens its page and runs its action in deployed Apps.
* **Form fields**: forms bound to a function input no longer lose typed fields, and a form picks up the last autofill when it appears.
* **Lost updates under load**: widget values, uploads and form commits reach the backend reliably under load, and toasts are no longer dropped while the App is busy.
* **App start on subpages**: data emitted on App start reaches data grids on subpages.
* **Page switching**: programmatic page switches no longer replay after a reload or get swallowed, and every page dropped on a function output gets a switcher of its own: two functions no longer switch to the first one's page, and removing one link keeps the others working.
* **Wiring**: connecting and disconnecting functions is atomic, values arrive before triggers fire, removing one wire leaves the peer's other wires alone, and a removed extension takes its wires along at both ends.
* **Unlinked data widgets**: data grids, lists and tiles show their configured columns but never stale rows until they are linked.
* **Chart aggregation**: fixed an aggregation bug in the [chart](https://docs.heisenware.com/reference/widgets/display/chart.md) widget, and a chart scrolls under a sticky header like every other widget.
* **Audit tables**: tables with a custom primary key create their audit log correctly, a failing `auditLog` reports the error instead of blocking writes, and a table that grows new columns keeps its audit log, history and change events.
* **Database notifications after commit**: `onChange` fires only once a transaction is committed; a rolled-back write is no change.
* **Protected file zones**: the [Files explorer](https://docs.heisenware.com/app-builder/app-builder/files.md) no longer lets you delete or move system folders, and it says why an upload or a copied link failed.
* **Account sign-up**: an account whose name is a prefix of an existing one gets its routing, duplicate workspace entries are no longer created and are healed on boot, and the workspace list is correct after switching accounts.
* [**Integrations**](https://docs.heisenware.com/app-manager/app-manager/integrations.md): clients marked for deletion no longer show as online, and the context menu action for a widget's value scope works again.
* **Utility classes**: fixed `Counter.reset(0)`, the `DataStore.update` crash on a missing id, stacked auto triggers, cron schedules that fired once, and division by zero on a zero-second timer.
* **Relation naming**: foreign keys use proper singularization (`roastBatches` yields `roastBatchId`). Existing databases are untouched. A role is written like every other name, in camelCase (`payer`), and `Payer` is taken as `payer`.

## Breaking changes and what you must do

An App built on v92 keeps running, and the platform converts what it can by itself. What it cannot convert is below, grouped the way you will meet it.

The complete, checkable list lives in [What older Apps must change](https://docs.heisenware.com/reference/older-apps.md): the platform keeps it as data, applies it to one App's records with `check_migration`, and that page is rendered from the same registry, so the two can never drift apart. Ask the assistant to check an App and it names the executors, modifiers, triggers, inputs and widgets that have to change. Change a place only where it leans on the old behavior.

### Before you start

* **Member roles**: at its first start, v93 makes every member who held the v92 `admin` role an owner of the account and deletes the v92 roles. Check your [members](https://docs.heisenware.com/app-manager/app-manager/members.md) afterwards. Going back to v92 needs a backup restore. See [Upgrading from v92](https://docs.heisenware.com/self-hosting/self-hosting/upgrading-from-v92.md).
* **What an import drops**: a v92 bundle loses its App icon (set it again), the top bar (build your own band of widgets), the tile frame of a widget (put a [Card](https://docs.heisenware.com/reference/widgets/display/card.md) behind it), a trigger's **Delay by…** (set the delay on the trigger source that should wait), and everything about automatic translation (`autoTranslate`, `supportedLanguages`, a widget's `translate` list and its props per language).
* **The tablet screens changed size**: 768×1024 and 1024×768 are now 800×1280 and 1280×800. An import centres a v92 tablet layout on them; check those screens.

### Flows, triggers and values

* **A filter's value is what it lets through**, where it was the verdict `true` or `false`; the verdict is now `passed`. A trigger source on a filter fires on a pass only. An edge that must hear "became false" hangs on a modifier with the same expression.
* **An error handler's payload is `{ message, cause, originalPayload }`**, with `cause` the reason as text. A modifier that read into the thrown error (`x.cause.code`) reads `x.originalPayload.cause`.
* **`$USER` in an expression is a binding, not text.** It was spliced into the source, so it was written quoted (`x.owner === "$USER"`). Write the bare `$USER`; the quoted one is now the literal text.
* **`$USER` in a static value is a token**, `$USER` or `${USER}`, in values only and never in object keys, and it is `null` where no user is in scope. `$USERS` stays text.
* **`onChange` compares per user.** It compared a user's first value with the shared one; a user's first value is a change now, so the target runs once more per new user.
* **A user's values are dropped** three hours after their browser left, and at a backend restart. They used to be kept for good.
* **The Trigger node reaches every tab** of the user, not only the tab that clicked. A page switch or an App action meant for the clicking tab goes on the button itself.
* **`off…` functions are gone**, with `removeListener` and `removeAllListeners`. Listening ends at the executor: **Stop listening**, or **End** on the registration.

### Databases

An executor that calls a removed function fails at run time with an unknown-function error. Open the App, re-point the node and reconnect its wires.

* **`autoUpsertRow` and `autoAddRows` are gone.** A table is declared, not inferred: declare it with `defineTable` or in the [Database editor](https://docs.heisenware.com/app-builder/app-builder/database-editor.md), then use `upsertRow` / `addRows`.
* **`changeRow(table, id, data)` is `updateRow(table, data, { id })`**, and `patchRow` is `updateRow` with `merge: true`. Nested objects now merge at every depth.
* **`getTableRowCount` is `countRows`**, and **`findOne` is `findRow`**.
* **`getHistoricalData` and the `trackHistory` option are gone.** Switch the table's `auditLog` on and read `getAuditLog`. An existing `<table>History` table stays as a plain table.
* **`autoJoin` is `include`.** A read joins the rows a row points to, never child rows unless named: a flow that read `customer.orders` from `getRow` adds `include: ['orders']`, and `autoJoin: false` is `include: false`.
* **Names in joined rows changed.** A many-to-many relation is named after the other table (`post.tags`, `tag.posts`), after a restart too, where it was named after its column (`tagId_tags`, on the internal database `tagIdTags`). A role's child list is `customer.payerOrders`. On a table made by SQL, the relation of a foreign key column not named after its parent is named after the column (`payer_id`: `order.payer`, `customer.payerOrders`).
* **Real names on the internal database.** A table or field made by SQL with a snake\_case name (`customer_id`) is addressed by that name; it was translated to camelCase (`customerId`).
* **Reads answer data, not text.** `getTableData`, `getHistoricalData` and `executeSql` took `locale`, `dateStyle` and `timeStyle` and answered dates as text. The options are gone, dates come as data, and widgets format them in the viewer's time zone.
* **`executeSql` answers the rows of every read.** It answered rows for a statement starting with `SELECT` and `[results, metadata]` for any other read, a `WITH` among them. Drop the `[0]`.
* **A filter, `fields` or `order` names a column.** What was written went into the SQL as it stood; an unknown name now fails with `Unknown field`.
* **`onChange` on PostgreSQL** fires a moment after the commit, for every change from any connection, once per row: a bulk insert calls the handler once per row instead of once with an array. A deleted row arrives as it was. Using `auditLog` or `onChange` on an external PostgreSQL installs a function and a trigger in that database, and timestamps inside a diff are written as PostgreSQL writes them.
* **`ssl: true` does what it says.** It changed nothing before; it now encrypts and wants a certificate the system or the workspace trusts ([Trusted certificates](https://docs.heisenware.com/reference/functions/connectors/trusted-certificates.md)). Omitted, the database decides.
* **A relation names its parent in the English singular**: `batches` gives `batch` and `batchId`, where one `s` was cut off (`batche`, `batcheId`). Existing databases are untouched, but an App that declares such a relation again gets a second column.

### Time series

* **A numeric `timestamp` is epoch milliseconds**, where it was read as nanoseconds.
* **Points carry no `app` tag.** The recorder tagged every point with its App; only backup and restore ever read it.
* **`exportAppData(appId)` and `importAppData(appId, file)` are `exportData()` and `importData(file)`**, the whole database's, with `exportMeasurementData(name)` beside them.
* **Connecting an InfluxDB no longer writes into it.** It created Heisenware's downsampling tiers; a database the workspace connected is read as it is, and the tiers are made only where they are asked for (`ladder: true`) or adopted (`adoptLadder()`).

### Files

A file is an entry now, and one file is no longer a list of one. Stored rows are converted by the platform shortly after its first start.

* **An upload or photo widget that holds one file delivers that file**, where it delivered a list with one file in it: remove the `[0]` from modifiers that read it. Holding several files it delivers a list as before, and an empty widget delivers nothing.
* **A file is an entry, not a path.** Widgets no longer deliver `{ name, type, path }` and rows no longer hold it. An entry is a reference `{ id, name, type, size }` into the file store, or content up to 64 kB. Logic that read the `path` hands the whole entry to the function instead; the File, HTTP, Email and PDF functions take it.
* **The signature widget delivers a file entry** with its PNG inside, where it delivered a base64 string: the string is the entry's `base64`.
* **A `file` field holds one file.** Several files belong in a `files` field, and `changeFieldType` converts between the two. Writing a list into a `file` field, or one file into a `files` field, is refused.
* **`upsertRow` writes no file.** It turned base64 content into a file on the file server; it now stores the entry it is given and refuses content above 64 kB. A file a flow produced goes to the store with `Files.store`.
* **A user of an App reads `runtime-files/`**, uploads into the file store and deletes nothing, where they reached the whole file server. A flow that showed a user a file from another folder moves it.

### Widgets and pages

* **Top bar menu types removed**: **Top bar** and **Top bar and bottom tabs** are gone from the [App menu](https://docs.heisenware.com/app-builder/app-builder/pages.md#app-menu). The bar showed the page title and the App icon, switched no page, and painted over the top of every page. An App with **Top bar** opens without a menu now, one with **Top bar and bottom tabs** keeps its bottom tabs. A title bar of your own is widgets on the page: a Card as the band, an image for the logo, a text for the title and a button carrying the **Logout** App action, grouped and made sticky.
* **Tile view removed**: a widget that was shown as a tile loses its frame on first load and fills its whole box. Put a [Card](https://docs.heisenware.com/reference/widgets/display/card.md) behind it.
* **Toast widgets become Toast actions** on the output or error handler they were linked to, the first time the App loads in the App Builder, and the widget type is gone. A toast popped once per page that held one; an action pops once, whatever page is shown.
* **A button's "Reload app" toggle becomes a Reload action** on its click.
* **`onUpdate` is gone** from the data grid, list and tiles. `onChange` carries the whole row and `onDelete` the key: bind `onChange`.
* **A form writes `formData` one second after the last keystroke**, where it wrote on every change. Once per entry is `submitted`.
* **Dates are no longer timestamps.** Form, grid, list and tiles deliver a calendar date (`2026-10-01`), an instant (`2026-10-01T06:30:00Z`) or a time of day (`08:30:00`).
* **A nested field is named by dot path.** `address-street` is `address.street`, in a form's and a grid's events and in a chart's series; a dash is a plain character now.
* **A timeline's null value ends a block**, where it carried the block on, and the first track is the top row, where tracks were drawn bottom-up.

### Utility classes

Across all of them: invalid inputs now fail with a message where they used to be accepted silently, and every function answers a value where it used to answer nothing.

* **`CircularBuffer` is `Buffer`.** Executors addressing `CircularBuffer` must be re-pointed; the class no longer appears. `pushBack` and `pushFront` answer the number of values held, a missing value is refused, and `popFront` / `popBack` on an empty buffer fail with `Buffer is empty`.
* **`Accumulator` builds one record and nothing else.** `accumulate` takes an object of fields and rejects plain values and arrays; `getObject` is `getRecord`; `reset` answers the record. Collect plain values in a `DataStore` (`pushBack`, `toArray`) or a `Buffer` instead. A template at creation names the expected keys, and `onComplete` fires when they have all arrived.
* **`DataStore` speaks the family's words.** `push` / `pop` are `pushBack` / `popBack`, `length` is `getSize`, and `removeAt` and `set` answer the item. `update(where, fields)` takes the condition first, updates **every** matching record and answers them; the implicit `id` lookup and the index fallback are gone. `indexOf` and `includes` are gone: select records by condition (`find`, `filter`), positions by index.
* **`Counter`**: `reset(0)` now resets to 0, where it was ignored, and `reset` answers the count.
* **`Timer`**: `start` answers the state instead of a number, a `totalSeconds` below 1 fails at creation, progress is no longer rounded to whole numbers, `setTotalSeconds` answers the value, `stop` answers `true`, and `getRelativeTime` fails on an invalid time instead of answering nonsense.
* **`Trigger` (Event simulation)**: `startAutoTrigger` replaces a running auto trigger instead of stacking a second one, so a flow that relied on two intervals running fires once per interval now. `onManualTrigger` listeners get a second value, the payload given to `triggerManually`.
* **`Stopwatch`**: `create` takes an options object with `tickInterval`, `start` / `stop` answer `true` / `false`, `lap` answers the lap time, and `setTickInterval` fails on an invalid value instead of falling back to one second.
* **`Cron`**: `schedule(expression, options)` takes no listener; react with `onTick`. A callback handed as the second argument by an older App keeps being called. `getNextRun` answers an ISO timestamp, `getStatus` answers `unscheduled` instead of failing while nothing is scheduled, `execute` answers `true`, and `destroy` leaves the instance reusable. A schedule set at creation is restored after a restart of the platform; one set through `schedule` is not, as before.
* **`SiloSimulator` is gone.** Create a `SignalSimulator` with the `silo` preset instead; it produces the same draining and refilling `level` signal, deterministically under a seed.
* **The Process Simulations add-on is retired.** The Functions explorer no longer offers it. `EnergySimulator` and `SiloSimulator` are `SignalSimulator` presets now (`energyMeter` with the same live rates and totals, `silo`), and the `MachineSimulator` of the docs is the `cncMachine` preset. An App that loaded the add-on keeps its container until you remove it; rebuild those flows on the presets.
* **`SignalSimulator`**: `offTick` and `offSignal` release exactly the listener given; calling them without a listener no longer removes every listener.

### Connectors

* **The SensorThings connector is gone**, with its FROST-Server add-on.
* **HTTP / REST**: every verb but `get` answers `{ status, statusText, headers, data }`, where it answered the raw response, and an unknown option is refused instead of passed on. See [HTTP / REST](https://docs.heisenware.com/reference/functions/connectors/http-rest.md).
* **OPC UA client**: `readVariable` fails on an unknown node, where it answered nothing, and a list of addresses answers `[{ address, nodeId, value }]`. An unknown `securityMode` or `securityPolicy`, the once documented `'unauthorized'` among them, fails at creation instead of being ignored: use `None`, or a mode and a policy the server offers.
* **OPC UA server**: it changed throughout. Rebuild each call from the connector's [reference](https://docs.heisenware.com/reference/functions/connectors/opc-ua-server.md). A node without an explicit id or `offset` is `s=<path>` now, instead of an order-dependent numeric id.
* **Hydra MIP**: it changed throughout. Rebuild each call from the connector's [reference](https://docs.heisenware.com/reference/functions/connectors/hydra-mip.md). It books what MIP takes and says why when MIP refuses.
* **GPIO counter**: `onCount`, `onStateChange`, `getCount` and `getState` are `onEvent`, `getEvents` and `getData`. See [GPIO counter](https://docs.heisenware.com/reference/functions/connectors/gpio-counter.md).
* **Siemens S7**: `readAllItems` needs a connection first, where it asked the PLC without looking, and a bad item stands as `'BAD 255'`. See [Siemens S7](https://docs.heisenware.com/reference/functions/connectors/siemens-s7.md).
* **File I/O**: a text read takes four options, `preserveLineBreaks`, `preserveOnlyMultipleLineBreaks`, `includeAltText` and `typeOverride`, and refuses any other. See [File I/O](https://docs.heisenware.com/reference/functions/connectors/file-i-o.md).

### Self-hosted installations

* **`HW_AUTH_CLIENT_TOKEN` is now `HW_PLATFORM_PUBLISHABLE_KEY`**, and the installer carries the old value over under the new name.
* **The assistant reads `HW_ANTHROPIC_API_KEY`.** Without it there is no assistant anywhere: no **Planning** in the App Manager and no assistant in the App Builder.
* **AI usage is priced for accounts** by `HW_AI_PRICE_MARGIN` and `HW_AI_PRICE_EUR_PER_USD`; a month keeps the pricing it started with.
* **Sign-up can be switched off** with `HW_ALLOW_SIGN_UP=false`. Invitations still join.
* **The file store has its own settings**: `HW_FILES_MAX_MB` (250) limits an uploaded file, `HW_FILES_GRACE_DAYS` (30) is how long a file that no row points to is kept, and `HW_FILES_CLEANUP=remove` lets the nightly clean-up remove such files; without it the clean-up only reports them. A workspace's media server takes these when it is created.
* **Live values can be withheld** from an AI connection with the installation's value-read setting.
* **The assistant keeps its own usage ledger** per account and per month on its data volume and re-sends any run the auth service missed at every start. `npm run replay-usage` inside the assistant container does the same on demand.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.heisenware.com/release-notes/v93-blue-meth.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
