spec(ui): widen record:related_list.columns to the saved-view ListColumn union (#19235)

Fixes #18639
Clause-②: yes (widening)

Ruling A on objectstack-ai/objectui#9593 — decision batch #144 item 3,
maintainer verbatim 「9593 A,其他同意」 (comment 5713646766). This is the
upstream spec half. The objectui half is objectstack-ai/objectui#9593;
it unblocks on the released package and the pin bump, not on this merge,
and nothing here touches that repository.

## The disagreement this closes

`RecordRelatedListProps.columns` declared `z.array(z.string())`. The
saved-view key the **same spec** declares — `listViews[].columns` —
declared `z.union([z.array(z.string()), z.array(ListColumnSchema)])`.
And objectui copies a saved view's `columns` onto the block
**verbatim**: `composeElementDataSource` does `const columns =
savedViewColumns(view); if (columns !== undefined) composed.columns =
columns;` with no normalisation in between
(`packages/core/src/data-scope/element-data-source.ts`, read at objectui
`dda8f3815d`). So a view whose columns carried `label` / `width` /
`hidden` / `summary` arrived at a block that declared it could not carry
them. Two published declarations, one key.

## What changed

`packages/spec/src/ui/component.zod.ts` — one key:

- `columns` becomes the same union, with `ListColumnSchema` **imported
from the view face** rather than re-spelled. `component.zod.ts` already
takes `NavigationConfigSchema` and `TimelineConfigSchema` from
`./view.zod` for exactly this reason, and `InterfacePageConfigSchema` in
`page.zod.ts` already composes this very union the same way.
`packages/spec/src/ui/view.zod.ts` is **read only** — it is not edited
by this PR.
- the `describe()` names the override chain (child `highlightFields` →
field-level `relatedListColumns` → this inline list), says a
view-supplied list may arrive in the `ListColumn` spelling and why, and
says the two arms are exclusive.

`.changeset/18639-related-list-columns-listcolumn-union.md` —
`@objectstack/spec` **minor**, carrying the `Clause-②: yes (widening)`
line.

Generated artefacts: `check:generated` proved exactly **2 of 16** stale
and `--fix` regenerated those two and no others —
`packages/spec/api-surface-declarations/ui.txt` and
`content/docs/references/ui/component.mdx`, which now renders the nested
`RecordRelatedListProps.columns[number]` table. Nothing was hand-edited
or anchor-edited.

## The union is the SAME union, and the pins say so three ways

1. **Reference identity.** The object arm's array element is asserted
`toBe(ListColumnSchema)` — for this key *and* for
`ListViewSchema.shape.columns`, then the two are asserted equal to each
other. One def, two carriers.
2. **Verdict parity.** Ten fixtures (string arrays, decorated arrays, an
unknown member, a mixed array, a bad nested `prefix.type`, an empty
object, two non-arrays) are asserted to get the **same** accept/refuse
answer from this block key and from the saved-view key.
3. **The refusal text.** An unknown member is refused with
`unrecognized_keys` whose message names *this list column* —
`ListColumnSchema`'s own surface word. A re-spelled lookalike would also
refuse, and would not say that.

Acceptance is pinned on the parsed **value**, not on `success`: the
decoration keys the ruling wants on the screen are asserted still
present after the parse. A schema that accepted and stripped would be
the same defect one layer up.

## Prose and schema agree, and the agreement is pinned

The `describe()` claims exclusivity, so exclusivity is measured:
`['name', { field: 'amount' }]` matches neither arm and is refused
(`invalid_union`). A separate pin reads the description back and asserts
it still carries the override chain, the `ListColumn` spelling, the
`listViews[].columns` reference and the exclusivity clause — so the two
cannot drift apart silently.

## Ablation — two legs, each proven on disk

Both legs go through `scripts/ablation-replace.mjs`, which refuses an
anchor that does not hit exactly once and verifies the write against the
**disk** (anchor count down, replacement count up, `git hash-object`
blob changed) rather than against an exit code, then restores in WRAP
mode and proves the restore against `HEAD`. No rebuild is needed between
legs: `component.test.ts` imports `./component.zod` as **source** inside
the same package, so nothing resolves through `dist/` here.

**Leg A — remove the widened arm.** `z.array(ListColumnSchema)` becomes
`z.array(z.string())`. On disk: anchor `x1 -> x0`, blob `4d341f733c82`
-> `7cadd11f55f7`. Reading: **4 failed | 347 passed (351)** — the
acceptance pin, the identity pin, the verdict-parity pin and the
strictness pin all go red together. The mixed-array, non-array and
`describe()` pins stay green, and that is the point: with the arm gone
the description would still have promised the `ListColumn` spelling
while the schema refused it, which is the prose-without-schema shape
this PR is careful about.

**Leg B — a LOOKALIKE object arm instead of the saved-view def.**
`z.array(z.object({ field, label?, width? }))`. On disk: anchor `x1 ->
x0`, blob `4d341f733c82` -> `1a95d6eb5996`. Reading: **4 failed | 347
passed (351)**, and the failures say exactly why a lookalike is not good
enough:

- the decoration-survival pin prints `link`, `align`, `summary`,
`hidden` and `sortable` **silently stripped** from the parsed value —
the lookalike accepts the input and throws away the keys the ruling
wants rendered;
- the strictness pin shows `{ field: 'amount', bogus: 1 }` now
**accepted** — `z.object` strips unknown keys where `ListColumnSchema`
names them;
- the identity and parity pins go red on their own terms.

So the "SAME union, not a lookalike" requirement is not decoration on
the commit message; it is the thing three of these pins measure.

**Restore — proven, both legs.** `blob after restore == blob at HEAD
(4d341f7)` and `git diff HEAD` empty, asserted by the tool on the
absolute path (an empty hash would be read as failure, not as a match).
Final green leg on the restored tree: **351 passed (351)**, and `git
status --porcelain` is empty at `007310f74d`.

## Scope fences from the ruling — held by measurement, not by intent

- `field.relatedListColumns` (`data/field.zod.ts`) is **unchanged** and
still strings-only: the pin drives a real `FieldSchema` parse and
asserts a `ListColumn`-shaped entry is refused with the derivation
prescription (`FIELD-NAME strings`).
- the `field-column-lists-canonicalized` conversion
(`conversions/registry.ts`) is **unchanged**: the pin asserts its
declared surface string and that its fixture still folds `{ field:
'status', label: 'Status' }` down to `'status'` — the decoration is
still dropped on that key, which is exactly what widening the block
sibling does not do.

## Verification

- `pnpm --filter @objectstack/spec test` — **500 test files / 14636
tests passed**; `src/ui/component.test.ts` alone is 351.
- `pnpm --filter @objectstack/spec typecheck` — green, all three legs
(`tsc --noEmit`, `check:scripts-typecheck`, `check:test-typecheck`: 54
files / 259 errors / 144 pinned signatures, ledger unchanged).
- `pnpm check:adr-anchors` — exit **0**: `check-adr-anchors: OK (53
anchored file(s), every governing ADR still referenced; 133 decision
number(s) ...; 36678 citation(s) across 4723 file(s) resolve ...)`. This
PR writes **no** ADR id anywhere — source, test, changeset or this body.
- `node scripts/pm/dispatch-gates.mjs --commands --repo
objectstack-ai/objectstack` derived **107** families at `007310f74d`;
all 107 were run, each exit code captured before any pipe, and
reconciled with `--ran` in the tool’s `COMMAND :: exit CODE` form: **107
accounted, 105 run, 2 NOT MEASURED, 0 unrun.** Seven were non-zero on
the first sweep and every one of them refused its own prerequisite
rather than reporting a finding — six with exit 3, and
`check:skill-examples` with exit **1**, which is the conflation carded
as #19227. Five went green once their closure was built (`pnpm --filter
'@objectstack/lint...' --filter '@objectstack/client-react...' --filter
'@objectstack/objectql...' build`): `check:doc-formula-expressions`,
`check:doc-security-posture`, `check:docs-transcript-drift`,
`check:lean-entry-closure`, `check:skill-examples`. The two that stay
**NOT MEASURED** are `check:dual-build-cjs-loads` and
`check:type-check-debt`; both need every workspace package built, both
say so in their own output, and both are CI's to answer.
- `pnpm --filter @objectstack/spec check:generated` — green after the
regeneration (16 artefacts).
- `pnpm --filter @objectstack/spec check:api-surface-declarations` —
`declaration text unchanged ✓ (17 entry points, 5362 declarations)`.
- `MANIFEST=... check:react-declaration-parity --strict` — exit 0, `no
new DECLARATION divergence vs accepted baseline`. The registry still
declares `columns` as `{ type: 'array', of: 'string' }`; this gate
compares prop NAMES, not types, so the widening does not move it. The
type half is the objectui card's.
- `pnpm check:nul-bytes` — `OK (scanned 9012 text file(s) ... no raw
ASCII control bytes)`, plus a direct control-byte scan over the three
hand-written files.

## Two line numbers on the card are stale

The card says to anchor on the symbol, and the tree disagrees with its
line numbers. Re-derived on `origin/main` `e233db9dbb`:
`RecordRelatedListProps` is at `component.zod.ts:1136` (card: near
:1092) and the saved-view union is at `view.zod.ts:2230` with
`ListColumnSchema` at `:821` (card: :2021). The card's substantive
reading holds.

## Acceptance notes

Noted, not filed — a stale cross-reference this PR creates, in two
**in-repo source comments**, neither of which reaches published docs:

- `packages/spec/src/data/field.zod.ts` — the TSDoc above
`relatedListColumns` says "the page-block sibling
`record:related_list.columns` is the same strings-only shape". After
this PR it is not. Only the `.describe()` below it renders into
`content/docs/references/data/field.mdx`, and that sentence stays true,
so nothing published is wrong.
- `packages/spec/src/data/inline-related-columns.test.ts` — its file
header repeats the same clause in item 4.

Not corrected here: the ruling fences `field.zod.ts` by name, and the
dispatch repeats that fence, so the correction is left for the seat
rather than crossed quietly. Both files were measured **free** across
all 20 open PRs (340 changed paths, read 2026-09-20), so it is a
one-edit follow-up whenever the seat wants it. The new TSDoc on
`component.zod.ts` states the current truth from this side, so a reader
arriving from the block never sees the stale claim.

---
_Generated by [Claude
Code](https://claude.ai/code/session_01JbZnqu8bt6YqfJsr9vaFb3)_

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: os-bill

.changeset/18639-related-list-columns-listcolumn-union.md

@@ -0,0 +1,15 @@
+---
+"@objectstack/spec": minor
+---
+
+`record:related_list.columns` now declares the SAME union the saved-view key declares — `z.union([z.array(z.string()), z.array(ListColumnSchema)])` — so a saved view's per-column decoration reaches the related list instead of being refused at the block door (#18639, the upstream half of objectui#9593).
+
+**Clause-②: yes (widening)** — one published accept set grows: the key admitted `string[]` and now also admits `ListColumn[]`. Nothing previously admitted is refused, no key is renamed or retired, and no producer is required to write the new arm. Contract-review tier.
+
+Two published declarations disagreed about one key. `RecordRelatedListProps.columns` (`ui/component.zod.ts`) was `z.array(z.string())`, while `listViews[].columns` (`ui/view.zod.ts`) was already the union — and objectui composes a saved view's `columns` onto this block **verbatim** (`dataSource.view` → `composeElementDataSource` → `savedViewColumns`). A view whose columns carried `label` / `width` / `hidden` / `summary` therefore arrived at a block that declared it could not carry them.
+
+- **The same union, by reference — not a lookalike.** `ListColumnSchema` is imported from the view face rather than re-spelled, so the object arm is one def with two carriers. The pin asserts reference identity on both sides and then asserts block and saved view return the same verdict for every fixture: two spellings of one key is the defect this closes, so a second spelling would not have fixed it.
+- **The arms are exclusive, and the description says so because the schema enforces it.** `['name', { field: 'amount' }]` matches neither arm and is refused. The decoration also survives the parse — a description promising keys a parse strips would be the same defect one layer up, so the pin asserts the parsed value, not merely `success`.
+- **Unchanged, by ruling and by measurement.** `field.relatedListColumns` stays child field-name STRINGS only and still refuses a column object with its derivation prescription, and the `field-column-lists-canonicalized` conversion still folds an object entry on that key to its identity string. Both are pinned next to the widening so the fences cannot erode quietly.
+
+No migration: authors writing `string[]` are unaffected, and the new arm is opt-in.

content/docs/references/ui/component.mdx

@@ -1366,7 +1366,7 @@ Type: `string`
 | **objectName** | `string` | ✅ | Related object name (e.g., "task", "opportunity") |
 | **relationshipField** | `string` | ✅ | Field on related object that points to this record (e.g., "account_id") |
 | **relationshipValueField** | `string` | optional (default: `"id"`) | Parent-record field whose value relationshipField stores (default 'id'; e.g. 'name' for name-keyed junctions). |
-| **columns** | `string[]` | optional | Fields to display in the related list. Optional: when omitted, columns derive from the related object's highlightFields / default list columns (a related list is just another surface that lists that object). Override chain: child highlightFields → field-level relatedListColumns → this inline list. |
+| **columns** | `string[] \| { field: string; label?: string \| Record<string, string>; width?: number; align?: Enum<'left' \| 'center' \| 'right'>; … }[]` | optional | Fields to display in the related list — either plain field-name strings, or the same per-column entries a saved list view declares (`ListColumn`: `field`, plus `label`, `width`, `align`, `hidden`, `sortable`, `summary`, …). A view-supplied list may arrive in the `ListColumn` spelling: objectui composes a saved view's `columns` onto this block verbatim, and this key declares the SAME union as `listViews[].columns`. One spelling per list — the two arms are exclusive, so an array mixing strings and column objects is refused. Optional: when omitted, columns derive from the related object's highlightFields / default list columns (a related list is just another surface that lists that object). Override chain: child highlightFields → field-level relatedListColumns (field-name strings only) → this inline list. |
 | **sort** | `string \| { field: string; order: Enum<'asc' \| 'desc'> }[]` | optional | Sort order for related records |
 | **limit** | `integer` | optional (default: `5`) | Number of records to display initially |
 | **filter** | `{ field: string; operator: Enum<'equals' \| 'not_equals' \| 'contains' \| 'not_contains' \| 'icontains' \| …>; value?: string \| number \| boolean \| null \| (string \| number)[] }[]` | optional | Additional filter criteria for related records |
@@ -1378,6 +1378,25 @@ Type: `string`
 | **redactFields** | `string[]` | optional | Field names this list never renders, whatever the permission answer (renderer default: render every column authored or derived). Applies to the authored `columns` AND to the columns the list derives for itself when none are authored. Presentation only, evaluated in the browser after the rows are fetched — the values are still in the page, so this is NOT a data-access control and NOT the object's `publicSharing.redactFields`, which removes them server-side. To keep a value from the caller, gate the field itself (`requiredPermissions` / `maskingRule`, ADR-0066 D3) or the permission set. |
 | **aria** | `{ ariaLabel?: string \| Record<string, string>; ariaDescribedBy?: string; role?: string }` | optional | ARIA accessibility attributes |
 
+### Nested Shape: `RecordRelatedListProps.columns[number]`
+
+| Property | Type | Required | Description |
+| :--- | :--- | :--- | :--- |
+| **field** | `string` | ✅ | Field name (snake_case) |
+| **label** | `string \| Record<string, string>` | optional | Display label override |
+| **width** | `number` | optional | Column width in pixels |
+| **align** | `Enum<'left' \| 'center' \| 'right'>` | optional | Text alignment |
+| **hidden** | `boolean` | optional | Hide column by default |
+| **sortable** | `boolean` | optional | Allow sorting by this column |
+| **resizable** | `boolean` | optional | Allow resizing this column |
+| **wrap** | `boolean` | optional | Allow text wrapping |
+| **type** | `string` | optional | Renderer type override (e.g., "currency", "date") |
+| **pinned** | `Enum<'left' \| 'right'>` | optional | Pin/freeze column to left or right side |
+| **summary** | `Enum<'none' \| 'count' \| 'count_empty' \| 'count_filled' \| 'count_unique' \| …> \| { type: Enum<'none' \| 'count' \| 'count_empty' \| 'count_filled' \| 'count_unique' \| …>; field?: string }` | optional | Footer aggregation for this column — the function alone, or `{ type, field }` to aggregate another field |
+| **prefix** | `{ field: string; type: Enum<'badge' \| 'text'> }` | optional | Field rendered inline before this cell value |
+| **link** | `boolean` | optional | Functions as the primary navigation link (triggers View navigation) |
+| **action** | `string` | optional | Registered Action ID to execute when clicked |
+
 ### Nested Shape: `RecordRelatedListProps.filter[number]`
 
 View filter rule

packages/spec/api-surface-declarations/ui.txt

@@ -3097,7 +3097,74 @@ declare const ComponentPropsMap: {
         objectName: z.ZodString;
         relationshipField: z.ZodString;
         relationshipValueField: z.ZodDefault<z.ZodString>;
-        columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        columns: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
+                key?: never;
+                defaultValue?: never;
+            }, Record<string, string> & {
+                key?: never;
+                defaultValue?: never;
+            }, z.core.$ZodTypeInternals<Record<string, string> & {
+                key?: never;
+                defaultValue?: never;
+            }, Record<string, string> & {
+                key?: never;
+                defaultValue?: never;
+            }>>]>>;
+            width: z.ZodOptional<z.ZodNumber>;
+            align: z.ZodOptional<z.ZodEnum<{
+                left: "left";
+                right: "right";
+                center: "center";
+            }>>;
+            hidden: z.ZodOptional<z.ZodBoolean>;
+            sortable: z.ZodOptional<z.ZodBoolean>;
+            resizable: z.ZodOptional<z.ZodBoolean>;
+            wrap: z.ZodOptional<z.ZodBoolean>;
+            type: z.ZodOptional<z.ZodString>;
+            pinned: z.ZodOptional<z.ZodEnum<{
+                left: "left";
+                right: "right";
+            }>>;
+            summary: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                count: "count";
+                none: "none";
+                min: "min";
+                max: "max";
+                sum: "sum";
+                avg: "avg";
+                count_empty: "count_empty";
+                count_filled: "count_filled";
+                count_unique: "count_unique";
+                percent_empty: "percent_empty";
+                percent_filled: "percent_filled";
+            }>, z.ZodObject<{
+                type: z.ZodEnum<{
+                    count: "count";
+                    none: "none";
+                    min: "min";
+                    max: "max";
+                    sum: "sum";
+                    avg: "avg";
+                    count_empty: "count_empty";
+                    count_filled: "count_filled";
+                    count_unique: "count_unique";
+                    percent_empty: "percent_empty";
+                    percent_filled: "percent_filled";
+                }>;
+                field: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>]>>;
+            prefix: z.ZodOptional<z.ZodObject<{
+                field: z.ZodString;
+                type: z.ZodDefault<z.ZodEnum<{
+                    text: "text";
+                    badge: "badge";
+                }>>;
+            }, z.core.$strict>>;
+            link: z.ZodOptional<z.ZodBoolean>;
+            action: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>]>>;
         sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodEnum<{
@@ -19236,7 +19303,74 @@ declare const RecordRelatedListProps: z.ZodObject<{
     objectName: z.ZodString;
     relationshipField: z.ZodString;
     relationshipValueField: z.ZodDefault<z.ZodString>;
-    columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    columns: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
+            key?: never;
+            defaultValue?: never;
+        }, Record<string, string> & {
+            key?: never;
+            defaultValue?: never;
+        }, z.core.$ZodTypeInternals<Record<string, string> & {
+            key?: never;
+            defaultValue?: never;
+        }, Record<string, string> & {
+            key?: never;
+            defaultValue?: never;
+        }>>]>>;
+        width: z.ZodOptional<z.ZodNumber>;
+        align: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+            center: "center";
+        }>>;
+        hidden: z.ZodOptional<z.ZodBoolean>;
+        sortable: z.ZodOptional<z.ZodBoolean>;
+        resizable: z.ZodOptional<z.ZodBoolean>;
+        wrap: z.ZodOptional<z.ZodBoolean>;
+        type: z.ZodOptional<z.ZodString>;
+        pinned: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>>;
+        summary: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            count: "count";
+            none: "none";
+            min: "min";
+            max: "max";
+            sum: "sum";
+            avg: "avg";
+            count_empty: "count_empty";
+            count_filled: "count_filled";
+            count_unique: "count_unique";
+            percent_empty: "percent_empty";
+            percent_filled: "percent_filled";
+        }>, z.ZodObject<{
+            type: z.ZodEnum<{
+                count: "count";
+                none: "none";
+                min: "min";
+                max: "max";
+                sum: "sum";
+                avg: "avg";
+                count_empty: "count_empty";
+                count_filled: "count_filled";
+                count_unique: "count_unique";
+                percent_empty: "percent_empty";
+                percent_filled: "percent_filled";
+            }>;
+            field: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+        prefix: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            type: z.ZodDefault<z.ZodEnum<{
+                text: "text";
+                badge: "badge";
+            }>>;
+        }, z.core.$strict>>;
+        link: z.ZodOptional<z.ZodBoolean>;
+        action: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>]>>;
     sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         order: z.ZodEnum<{

packages/spec/src/data/field.zod.ts

@@ -1454,8 +1454,19 @@ export const FieldSchema = lazySchema(() => {
    * Deliberately narrower than `inlineColumns`: the related list is not an
    * editable grid, and per-column display overrides are not part of its
    * measured renderer contract (objectui RelatedList hydrates string entries
-   * fully; the page-block sibling `record:related_list.columns` is the same
-   * strings-only shape). Column OBJECTS are refused with a prescription.
+   * fully). Column OBJECTS are refused with a prescription.
+   *
+   * ⚠️ AND deliberately narrower than the PAGE-BLOCK sibling, which is no
+   * longer the same shape (#18639). `record:related_list.columns`
+   * (`ui/component.zod.ts`) now declares the SAME union as the saved-view key
+   * `listViews[].columns` — field-name strings OR `ListColumnSchema` entries —
+   * because objectui composes a saved view's `columns` onto that block
+   * VERBATIM, so a decorated list arrives there already in the `ListColumn`
+   * spelling. THIS key stays strings-only BY RULING: objectui#9593 ruling A
+   * widened that one and fenced this one in the same breath, and the
+   * `field-column-lists-canonicalized` conversion still folds an object entry
+   * here down to its identity string. The two keys diverge ON PURPOSE —
+   * ⛔ do not "align" them.
    */
   relatedListColumns: z.array(z.string({
     error: (issue) => issue.code === 'invalid_type'

packages/spec/src/data/inline-related-columns.test.ts

@@ -25,9 +25,14 @@
  *      parse clean and render every computed cell '—'. The refusal is the
  *      producer-side guard for that renderer fact.
  *   4. `relatedListColumns`: child field-name STRINGS only, matching every
- *      in-repo usage and the strings-only page-block sibling
- *      (`record:related_list.columns`, ui/component.zod.ts). A column OBJECT
- *      is refused with the derivation prescription.
+ *      in-repo usage. A column OBJECT is refused with the derivation
+ *      prescription. ⚠️ Since #18639 this is NO LONGER the same shape as the
+ *      page-block sibling: `record:related_list.columns`
+ *      (ui/component.zod.ts) declares the saved-view `ListColumnSchema` union,
+ *      because a saved view's columns are composed onto that block verbatim.
+ *      THIS key stays strings-only by ruling — objectui#9593 ruling A widened
+ *      that one and fenced this one — so the divergence is DELIBERATE, and
+ *      every pin below is unchanged by it.
  *   5. The showcase invoice fixture form — identity-only `{ name }` entries —
  *      parses, so the one authored in-repo usage stays green in the spelling
  *      the renderer actually reads.