# The address space

> The seven reserved roots every point lives under, how an address is spelled and sanitized, where a point ends and a member begins, what the filter box narrows, and the three ways to enter an address in an editor.

Every point an expression, a script, a dashboard binding or an agent tool can name lives under one of seven reserved roots. Your own names always live under a root, so they never collide with the roots themselves. The Logic page's column draws the same roots, split under two captions, and what the tree shows is exactly what you type: the address of a row is the text an expression uses.

## The seven roots {#the-seven-roots}

| Root | What it holds | Caption in the column | Edited |
| --- | --- | --- | --- |
| `System` | Four diagnostics the application publishes about itself | From other pages | Nowhere |
| `Server` | Four diagnostics of the embedded OPC UA server | From other pages | In [Settings](settings-opcua-configuration) |
| `Connector` | The live driver, folder, device and tag tree | From other pages | On the [Connector](connector) page |
| `Variables` | The variables you define here, in their folders | Defined here | Here |
| `Alarms` | The live state of the alarms you define here, in their folders | Defined here | Here (the state itself is read only) |
| `Process` | Each model's units: channels, run state, productivity, commands, staging | From other pages | On the [Process](process) page |
| `Assets` | The library's Images, Icons and Colors, addressable by name | Defined here, as the Assets root | On the [Assets](logic-assets) panels |

Actions and Triggers are sections of the column but not roots of the address space: they are referenced by identity, not by address, and carry no live value. The `Assets` root exists for expressions and the Browse… picker; in the column its place is taken by the Assets library root, so the tree never shows two roots of that name. The fixed points of `System` and `Server`, and the shape of the `Connector` and `Process` branches, are listed on [From other pages](logic-from-other-pages).

## How an address is spelled {#how-an-address-is-spelled}

An address is dot-separated segments rooted at a reserved root: `Connector.Simulated.Air.CompressedAir.HeaderPressure`, `Variables.Forno.Setpoint`, `Alarms.HighLevel`, `System.Now`, `Assets.Colors.Red`. Display names stay free text; the address uses each name's sanitized segment: every character that is not a letter or digit becomes `_`, and a name starting with a digit gains a leading `_` (`Forno de teste` answers to `Forno_de_teste`, `3rd zone` to `_3rd_zone`, an empty name to `_`). Segments are always identifiers, so the dot form always works; a segment may also be written in bracket form with a string literal, `Variables["Setpoint"]`, and the evaluator reads it as the same address.

Where the point ends and member access begins depends on the root. `Connector` addresses carry the device's folder levels between the driver and the device (a Modbus RTU line adds no level), and `Variables` and `Alarms` carry up to three folder levels before the name, so under these roots the point is the longest prefix that resolves and what follows it is a member (`.Value`, `.State()`). `Assets` is always two segments below the root; `Process` is four for an ordinary point, six for a productivity summary point and seven for a productivity output or procedure point. A chain shorter than its root allows is refused as an incomplete address.

Addresses in expressions and scripts must be static: every segment an identifier or a string literal, never a computed value. `Variables[someName]` is refused at validation with "Addresses must be static".

## Address collisions {#address-collisions}

One level of one section is one segment namespace shared by the folders and the definitions filed there. Two variables named `Setpoint` in different folders are fine; a variable and a folder that both sanitize to `Forno` at the same level are not, and neither are `Pump 1` and `Pump_1` side by side. The editors refuse such a name as you type, naming what already answers to the address: "'Pump 1' already answers to 'Variables.Pump_1'. Names filed in one folder must sanitize to distinct segments." Assets follow the same rule inside each category: two of your images, icons or colors may not share a segment, and a user icon or color whose segment matches a system entry overrides it at the address.

## Entering an address {#entering-an-address}

Three ways to enter an address in an [expression](logic-expressions), a condition or a script:

- **Type it.** The editor autocompletes address tokens: root names for a bare token (`Con` offers `Connector`), then the children of the path typed so far, matched by prefix without regard to case, and a point's readable members once the token names a point. Each candidate replaces the whole token.
- **Browse…** opens a picker over the member-level tree of every root, the `Assets` root included. Select a row and press **Insert**, or double-click it, to place its address at the caret. The footer shows the text the selected row inserts, or "Double-click (or Insert) to add to the editor." while nothing is selected.
- **Copy from a point.** Selecting any point in the column opens the [point panel](logic-from-other-pages#the-point-panel), whose Address field is read-only text you can select and copy, beside the live value, its quality and its timestamp. A variable or alarm editor echoes its own address under the Name field.

Below a point, the picker lists its readable members (`Value`, `ValueToReal()`, `State()` and so on). A member is not an address of its own: it is what you append to the point's address. [Expressions](logic-expressions#the-read-surface-of-a-point) lists the same surface, with what each member returns.

## The filter box {#the-filter-box}

The **Filter…** box above the column narrows the tree to rows whose name contains the typed text, without regard to case. A point survives only when it matches; a folder survives when it matches or any descendant does, and opens to its matches. The Actions and Triggers sections list only the rows whose name matches (their own name keeps the section listed, but empty); the Assets root narrows to the categories whose name matches (typing `Col` leaves Colors) and comes whole when only its own name matches; an address-space root whose own name matches stays listed and loads its branch when expanded. Members are never part of the filtered view, and the filter belongs to your window alone: another browser on the same station keeps its own.

## What the address space does not do {#what-the-address-space-does-not-do}

It publishes nothing for a disabled device, for a device whose tags are not materialized in the embedded server, or for a Process channel without a binding (such a channel is listed but offers no members). Names are not translated: the address is the sanitized display name, so renaming a variable, an alarm, a folder, a device, a tag or an image is an address change, which the app rewrites in every reference through the safe rename ([Variables](logic-variables#name-and-address), [Device folders](connector-folders)).