The Field Designer is the column-schema editor for Opbox’s data tables. Pick a table and you see its columns laid out as a schema: each column’s key, display name, storage type, order, and the flags that tell you how it behaves - computed, PII, required, unique. From here you add a column, change its type, hide it from a view, reorder it, or remove it. The schema is not edited in a vacuum: the same column keys you shape here are what every read and write resolves against, so designing the field is the same act as defining how the data is stored, derived, and protected.
What it does
The schema, read straight from the kernel. Open a table and the designer lists its columns from column.list: key, name, type, display order, and the per-column flags. The list is the same schema contract the data plane uses, so what you see here is exactly what cell.set, row.patch, and row.list resolve a write or a read against. Nothing is a separate copy of the schema that could drift; the panel renders from the kernel’s own column descriptor.
Typed columns, including computed ones. Add a column and you give it a storage type, so the data plane knows how to hold and coerce its values. A column can also be computed: a computed column has no stored value of its own (INV-6), it is derived at read time, and the designer flags it as Computed so it is clear which fields are canonical facts and which are derived. Computed columns are never writable: a write to one through cell.set, row.patch, or row.bulk is a hard reject.
PII, required, and unique flags. A column carries the flags that govern how its values are treated. A PII column is marked so you can see at a glance which fields hold regulated data; values in a PII column are stored encrypted and never round-tripped as plaintext through the grid (INV-7). Required and unique flags show the constraints the column places on the data. These are read back from the schema, not guessed, so the designer reflects the true shape of the table.
Changing a column’s type safely. Retype a column and the change is schema-altering: the kernel attempts a best-effort coercion of the existing values into the new type and never silently deletes data to make the conversion fit. Retyping is an Admin-tier operation because it reshapes how every existing and future value in that column is stored.
Hiding versus deleting. Hiding a column is reversible: it adjusts the view without touching the data, so a field you do not want on screen stays in the store and can be brought back. Deleting a column is a teardown that removes the column for good, and when the column is a link, its reverse-link column is deleted in the same transaction so the two sides never fall out of step. The designer makes the difference explicit and asks you to confirm a delete, because it cannot be undone.
Reordering the layout. Reorder columns to set the order they appear in, so the table reads the way the work reads. The order is part of the schema the designer renders from, so a reorder is reflected everywhere the table is shown.
Canonical cell writes and locks. Beneath the column schema, the data is held as facts: one canonical value per cell, written through cell.set (the one-source-of-truth write bound to a field key). A hand-verified cell can be pinned with cell.lock so an automated write cannot overwrite a value a person has checked. Locking is role-gated and tracked as a sensitive operation, because the lock marker is exactly the kind of control that must not be set by a back door.
Governed and audited, every change. Every operation in the designer is a kernel verb that passes through the one front door: permission-checked, scope-checked, and audited before it runs. Shaping a column is Member or Admin tier depending on how far-reaching the change is - adding or reordering a column is a Member write, while retyping, deleting, and hiding a column are Admin, and locking a cell is an Admin operation rated Sensitive. A table from another workspace simply reads back as not-found, so the designer can only ever shape tables you are entitled to.
How you use it
Open a table’s schema. Open the Field Designer and pick a table from the list. The designer reads the table’s columns and shows them as a schema: key, name, type, order, and the Computed, PII, Required, and Unique flags. Switch back to the table picker at any time to shape a different table.
Add or retype a column. Add a column with the type the field needs, or mark it computed when the value should be derived rather than stored. To change an existing column’s type, retype it: the kernel coerces the existing values where it can and never drops data to force the conversion.
Tidy the layout. Reorder columns so the table reads in the order the work expects, and hide a column you do not want on screen. Hiding is reversible and leaves the data untouched, so you can bring a hidden column back later.
Remove a column. Delete a column when it is genuinely no longer part of the table. The designer confirms first, because a delete is a teardown that cannot be undone; if the column is a link, its reverse side is removed in the same transaction.
Pin a verified value. Set a cell’s canonical value, and where a value has been hand-checked, lock the cell so a later automated write cannot quietly overwrite it. Unlock it again when the value should be free to change.
The kernel verbs behind it
Every action above runs through the kernel’s one front door: each call is permission-checked, scope-checked, and audited before it executes. These are the key verbs.
column.list- read a table’s columns as a schema: keys, types, order, and the computed, PII, required, and unique flags.column.add- add a typed or computed column to a table.column.retype- change a column’s storage type, with best-effort coercion and never a silent delete.column.reorder- set the order the columns appear in.column.hide- hide a column from the view, reversibly, without touching its data.column.delete- drop a column for good, deleting any reverse-link column in the same transaction.cell.set- write one canonical value to a cell, bound to its field key (the one-source-of-truth write).cell.lock- pin or unpin a hand-verified cell so it cannot be overwritten automatically.
See the full set in the column verb reference and the cell verb reference.