# Input

> Operator value entry written to a point: the box takes what the point takes, and refuses the rest with the reason.

**Input** is the operator's entry field: a draft the operator owns, and a **Set** key
that sends it to a point through the station's single write funnel. It draws no reading
of its own — whoever wants the point's value beside the box composes a
[Value](component-value) next to it, and naming the field is a
[Label](component-label). It is a *Control* component; a new one occupies 4 × 1 cells.

The draft belongs to the operator: the live refresh never overwrites what was typed,
and a refused entry stays in the box so the correction is an edit, not a retype.

## Data {#data}

| Field | What it does | Values | Default |
|---|---|---|---|
| Address | The rooted Logic address of the written point: a memory variable, a writable tag, a unit's staging field (`Next.<field>`) or the run comment point (`Commands.Comment`). Nothing is ruled out here — what the box then accepts is read off the point itself. | Free text; suggestions from the live point list | empty |

Under the address, the panel prints what the field takes right now ("This field takes a
number, 0 to 100, to 1 decimal place."), so a two-state point is seen turning the row
into a key per state before the screen ever runs.

## What the box takes {#what-the-box-takes}

The entry kind is **derived from the point**, never chosen beside it — a category you
could state against the point would be a second declaration, free to disagree with the
one the point already makes:

| The point | The box | Conduct |
|---|---|---|
| A Bool point | A key per state (**On** / **Off**) instead of a box | One touch is the whole instruction. The keys carry absolute values, so they stay usable under bad quality — unlike the [Toggle](component-toggle), which must know the reading it negates. Neither key shows the point's state. |
| An integer point | A whole-number box | Decimal entries are refused; the touch keyboard offers digits. |
| A real (decimal) point | A number box | Judged against the band and the declared places when **Set** is pressed, never per keystroke; the touch keyboard offers a decimal pad. |
| Text, an instant, a staging or comment point, or an address nothing answers yet | A free text box | The band and decimals are not read, and the panel says so. |

## Number {#number}

The band and the fineness the operator states *on top of* the point:

| Field | What it does | Values | Default |
|---|---|---|---|
| Minimum | Lowest number the field sends. Blank leaves that side of the band open. | Any number, or blank | blank |
| Maximum | Highest number the field sends. Blank leaves that side open. A minimum above the maximum leaves no number between them, and the panel warns that the field would refuse every entry. | Any number, or blank | blank |
| Decimals | How fine an entry the field sends. Blank sends whatever precision was typed. A point that counts pins it at 0 whatever is stored. The places are asked of the value, not the digits: `12.500` is `12.5`, so trailing zeros a keypad added are never refused. | 0 to 15, or blank | blank |

A tag that declares limits of its own (its **Limits** conversion stage enabled) tightens
whatever is stated here: the field accepts only what the typed value pipeline would
carry through unchanged.

An entry outside the band, too fine, or not a number at all is **refused with the
reason and nothing is written**. The number is an instruction to the plant, and a
different one taken at the edge would be the station deciding for the operator. This is
deliberately the opposite of the editor's own configuration fields, which take an
out-of-band entry at the nearest edge and say so.

## Write semantics {#write-semantics}

- **Memory variable** — the draft is validated against the variable's output category,
  then written through the logic funnel. An empty box writes an empty value.
- **Writable tag** — the draft is coerced to the tag's node type; the funnel de-scales
  the engineering value on its way to the wire (the tag's conversion pipeline in
  reverse).
- **`Next.<field>`** — stores the text in the unit's staging area for the next run.
  Staging is preparation, not a plant write: no funnel, no journal entry. The answer
  line says "Staged".
- **`Commands.Comment`** — appends a run comment (or a post-run note while idle) to the
  unit's active context, attributed to the signed-in operator; the box clears and the
  answer line says "Comment added". An empty comment is refused.

The transient answer line reports every outcome and expires after a few seconds.
Authorization is re-checked at the press.

## Permissions and the lock {#permissions-and-the-lock}

Writing a variable or tag needs the role permission to operate dashboards; the staging
and comment points are Process mutations and need the run-procedures permission
instead. A blocked press draws the shared lock mark with the reason in the tooltip, and
the box itself is disabled while locked (see the [dashboards page](home)). A bound point
that fails to read wears the shared bad-reading mark — the flag keys and the text box
remain usable, since their instruction does not depend on the reading.

The shared Appearance, Identification, Position and layer and Actions sections are
described on the [components page](components#the-shared-property-sections).