@object-ui/react 17.3.0 → 17.6.0

package/dist/spec-bridge/SpecBridge.d.ts

@@ -5,18 +5,24 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import type { SchemaNode } from '@object-ui/core';
-import type { BridgeContext, BridgeFn } from './types';
+import type { BaseSchema } from '@object-ui/types';
+import type { BridgeContext, BridgeFn } from './types.js';
 export declare class SpecBridge {
     private bridges;
     private context;
     constructor(context?: BridgeContext);
     register(specType: string, bridge: BridgeFn): void;
-    /** Transform a spec schema into a SchemaNode tree */
-    transform(specType: string, spec: any): SchemaNode;
+    /**
+     * Transform a spec schema into a schema node tree.
+     *
+     * Returns `BaseSchema` rather than `SchemaNode` — see {@link BridgeFn} for
+     * the ruling (objectui#4580 Q4-B) and the measurement behind it. A registered
+     * bridge always produces an object; the union only made callers narrow.
+     */
+    transform(specType: string, spec: any): BaseSchema;
     /** Transform a ListView spec */
-    transformListView(spec: any): SchemaNode;
+    transformListView(spec: any): BaseSchema;
     /** Transform a FormView spec */
-    transformFormView(spec: any): SchemaNode;
+    transformFormView(spec: any): BaseSchema;
     updateContext(ctx: Partial<BridgeContext>): void;
 }

package/dist/spec-bridge/SpecBridge.js

@@ -5,8 +5,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { bridgeListView } from './bridges/list-view';
-import { bridgeFormView } from './bridges/form-view';
+import { bridgeListView } from './bridges/list-view.js';
+import { bridgeFormView } from './bridges/form-view.js';
 export class SpecBridge {
     constructor(context = {}) {
         Object.defineProperty(this, "bridges", {
@@ -28,7 +28,13 @@ export class SpecBridge {
     register(specType, bridge) {
         this.bridges.set(specType, bridge);
     }
-    /** Transform a spec schema into a SchemaNode tree */
+    /**
+     * Transform a spec schema into a schema node tree.
+     *
+     * Returns `BaseSchema` rather than `SchemaNode` — see {@link BridgeFn} for
+     * the ruling (objectui#4580 Q4-B) and the measurement behind it. A registered
+     * bridge always produces an object; the union only made callers narrow.
+     */
     transform(specType, spec) {
         const bridge = this.bridges.get(specType);
         if (!bridge) {

package/dist/spec-bridge/bridges/form-view.d.ts

@@ -5,8 +5,68 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import type { BridgeFn } from '../types';
-interface FormField {
+/**
+ * Form-view bridge input — the documented SUBSET of `@objectstack/spec`'s
+ * FormViewSchema this bridge consumes, with every drift-prone key's TYPE bound
+ * to the contract instead of restated (objectui#5652).
+ *
+ * The subset stays hand-listed on purpose: this declaration is load-bearing
+ * documentation, and its NON-declarations are a retirement ledger
+ * (`defaultSort` / `aria`, objectui#3901 / #3974) that a blanket
+ * `Omit<FormView, ...>` would erase. What was never deliberate is the TYPE each
+ * declared key was given. Three of them had drifted from what the contract
+ * accepts, and nothing ever compared the two descriptions — the mirror shape
+ * `scripts/check-spec-symbol-derivation.mjs` exists to catch. The sibling
+ * bridge in this directory (`list-view.ts`) was converted the same way and for
+ * the same reason (objectui#2231): the shape derives, so it cannot drift.
+ *
+ * ## What the contract actually answers
+ *
+ * Measured with `safeParse` against the installed `@objectstack/spec` while
+ * fixing this, NOT copied from the finding — two of its three rows were wrong,
+ * in ways that change the repair:
+ *
+ *   FormSection.columns    `1 | 2 | 3 | 4 | '1' | '2' | '3' | '4'`. The string
+ *                          arm IS admitted, and the section schema's own pipe
+ *                          folds it to a number. The bridge declared `number`
+ *                          and refused it.
+ *   FormView.columns       `number`, with NO string arm: `FormViewSchema`
+ *                          rejects `columns: '3'` at the FORM level while
+ *                          `FormSectionSchema` accepts it at the SECTION level.
+ *                          The bridge's `number` was already right here — it is
+ *                          bound to the contract so the asymmetry cannot rot,
+ *                          and the two answers are pinned side by side.
+ *   FormField.dependsOn    a BARE parent-field name. The array arm is rejected
+ *                          by the contract outright. The bridge declared
+ *                          `string[]`, so it admitted only the arm the contract
+ *                          refuses and refused the only arm it admits — the one
+ *                          configuration that makes `field-selector` and
+ *                          `dynamic-config` work (objectui#5040).
+ *   *.visibleWhen          `string | { dialect, source?, ast?, meta? }`, with
+ *                          `dialect` REQUIRED and enum-typed. `{ dialect?,
+ *                          source }` is a DIFFERENT layer's type — the
+ *                          evaluator's `FieldRulePredicate` (`@object-ui/core`,
+ *                          ADR-0089) — and the contract does not accept it: an
+ *                          object arm without `dialect` is refused. The bridge
+ *                          declared `string` and refused the object arm
+ *                          entirely.
+ *
+ * ## Declaring an arm is not consuming it
+ *
+ * A key that is declarable but dropped on the way out is the same defect one
+ * layer over (objectui#5542 / #5594), so each widened arm is followed all the
+ * way onto the `object-form` node by `FormViewWidenedArms.test.ts`, and the one
+ * arm that needs a translation to get there gets it — see `normalizeColumns`.
+ */
+import type { DependsOnInput } from '@object-ui/types';
+import type { FormFieldInput, FormSection, FormView } from '@objectstack/spec/ui';
+import type { BridgeFn } from '../types.js';
+/**
+ * A form field as authored. Exported so the derivation pins in
+ * `__tests__/FormViewWidenedArms.test.ts` can name the declared types; NOT
+ * re-exported by `spec-bridge/index.ts`, so the package surface is unchanged.
+ */
+export interface FormFieldSpec {
     field: string;
     /** Field type (spec FormFieldSchema reuses Data.FieldType; auto-infers widget). */
     type?: string;
@@ -22,23 +82,45 @@ interface FormField {
     hidden?: boolean;
     colSpan?: number;
     widget?: string;
-    dependsOn?: string[];
-    /** Canonical conditional-visibility predicate (ADR-0089). */
-    visibleWhen?: string;
-    /** @deprecated ADR-0089 → `visibleWhen`. */
-    visibleOn?: string;
+    /**
+     * Sibling field name whose value this field's widget reads (objectui#5040).
+     *
+     * The contract admits a BARE NAME and refuses an array. This is the wider
+     * {@link DependsOnInput} rather than the contract's `string` alone because
+     * the value is FORWARDED, unread, into the node slot that is declared with
+     * exactly this type (`FormField.dependsOn`, `@object-ui/types`) and read by
+     * `resolveCascadingOptions` / `resolveDependsOnFields` (`@object-ui/core`),
+     * whose parameter is also exactly this type (framework#4074). Narrowing to
+     * the contract's `string` would refuse array-authored layouts that the
+     * runtime has always honoured, on the same never-parsed inputs `groups` and
+     * `visibleOn` below are still read for. The contract's arm is a subset of
+     * this one, which is what the derivation pin asserts — so a spec that widens
+     * `dependsOn` fails the pin instead of silently outgrowing the declaration.
+     */
+    dependsOn?: DependsOnInput;
+    /** Canonical conditional-visibility predicate (ADR-0089), bound to the contract. */
+    visibleWhen?: FormFieldInput['visibleWhen'];
+    /** @deprecated ADR-0089 -> `visibleWhen`. */
+    visibleOn?: FormFieldInput['visibleOn'];
 }
-interface FormSection {
+/** One section of a form layout, as authored. */
+export interface FormSectionSpec {
     /** Stable section identifier for i18n lookup (spec FormSectionSchema.name). */
     name?: string;
     label?: string;
     description?: string;
     collapsible?: boolean;
     collapsed?: boolean;
-    columns?: number;
-    /** Section-level conditional-visibility predicate (ADR-0089). */
-    visibleWhen?: string;
-    fields?: FormField[];
+    /** Bound to the contract: the string spelling of a column count is admitted. */
+    columns?: FormSection['columns'];
+    /** Section-level conditional-visibility predicate (ADR-0089), bound to the contract. */
+    visibleWhen?: FormSection['visibleWhen'];
+    /**
+     * The authored field list. A bare string is the spec's shorthand for "this
+     * object's own field, rendered with its defaults" — the same shorthand
+     * `mapColumn` already honours on the list bridge.
+     */
+    fields?: Array<string | FormFieldSpec>;
 }
 /**
  * The subset of `@objectstack/spec` FormViewSchema the bridge consumes.
@@ -46,10 +128,11 @@ interface FormSection {
  * or listed here with an explicit reason for being ignored — the bridge must
  * never silently drop spec configuration (#2545).
  */
-interface FormViewSpec {
+export interface FormViewSpec {
     type?: string;
     layout?: string;
-    columns?: number;
+    /** Bound to the contract, which admits NO string arm here — unlike a section. */
+    columns?: FormView['columns'];
     title?: string;
     description?: string;
     defaultTab?: string;
@@ -63,20 +146,13 @@ interface FormViewSpec {
     drawerWidth?: string;
     modalSize?: string;
     data?: any;
-    sections?: FormSection[];
+    sections?: FormSectionSpec[];
     /** Legacy alias of `sections` (spec: "Legacy support → alias to sections"). */
-    groups?: FormSection[];
+    groups?: FormSectionSpec[];
     /** Inline master-detail child collections. */
     subforms?: any[];
-    defaultSort?: any;
     sharing?: any;
-    aria?: {
-        ariaLabel?: string;
-        ariaDescribedBy?: string;
-        role?: string;
-    };
     submitBehavior?: any;
 }
 /** Transforms a FormView spec into a Form SchemaNode */
 export declare const bridgeFormView: BridgeFn<FormViewSpec>;
-export {};

package/dist/spec-bridge/bridges/form-view.js

@@ -5,6 +5,21 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
+/**
+ * Fold the contract's string spelling of a column count onto the number the
+ * node carries.
+ *
+ * `FormSectionSchema` accepts `'2'` and `2` and normalises the string away in
+ * its own pipe; the `object-form` node's section declares `columns?: 1|2|3|4`
+ * and `FormSectionContainer` indexes its grid-class map by that number. Its
+ * header states where the fold belongs: "The normalisation belongs at the seam
+ * that parses authored metadata, not in the container's props." This bridge is
+ * that seam. Forwarding `'2'` verbatim hands every downstream renderer a value
+ * outside the type it declares.
+ */
+function normalizeColumns(columns) {
+    return typeof columns === 'string' ? Number(columns) : columns;
+}
 function mapField(field) {
     const mapped = {
         name: field.field,
@@ -30,12 +45,23 @@ function mapField(field) {
         mapped.colSpan = field.colSpan;
     if (field.widget)
         mapped.widget = field.widget;
+    // Forwarded unread into the node's `dependsOn`, which is declared with the
+    // same type and read by `@object-ui/core`'s cascading-option resolver.
     if (field.dependsOn)
         mapped.dependsOn = field.dependsOn;
     // ADR-0089: `visibleWhen` is the canonical view-form-field visibility predicate
     // (the spec folds the deprecated `visibleOn` into it at parse). Prefer it and
     // fall back to `visibleOn` for raw / un-normalized metadata. The ObjectForm
     // renderer reads this view-level predicate from the node's `visibleOn` slot.
+    //
+    // Both contract arms travel whole: the bare CEL string, and the expression
+    // object. `evalFieldPredicate` reads `{ dialect, source }` back out of the
+    // object arm, which is how a spec-authored `{ dialect: 'cel', source: ... }`
+    // now drives visibility instead of being refused by this declaration. An
+    // `ast`-only expression (legal metadata: the contract requires `dialect` plus
+    // one of `source` / `ast`) is forwarded whole rather than dropped, but no
+    // evaluator in this repo reads an `ast` today — that gap is the evaluator's,
+    // and the bridge must not hide it by discarding the key.
     const visiblePredicate = field.visibleWhen ?? field.visibleOn;
     if (visiblePredicate)
         mapped.visibleOn = visiblePredicate;
@@ -43,7 +69,12 @@ function mapField(field) {
 }
 function mapSection(section) {
     const mapped = {
-        fields: (section.fields ?? []).map(mapField),
+        // A bare field name is the spec's shorthand and is forwarded verbatim: the
+        // node's `fields` slot admits it and `normalizeSectionField`
+        // (@object-ui/plugin-form) resolves it against the object schema. Running
+        // it through `mapField` instead produced `{ name: undefined }` — a field
+        // with no identity — for the most ordinary section a form can declare.
+        fields: (section.fields ?? []).map((field) => typeof field === 'string' ? field : mapField(field)),
     };
     if (section.name)
         mapped.name = section.name;
@@ -56,7 +87,8 @@ function mapSection(section) {
     if (section.collapsed != null)
         mapped.collapsed = section.collapsed;
     if (section.columns != null)
-        mapped.columns = section.columns;
+        mapped.columns = normalizeColumns(section.columns);
+    // Whole, both arms — same predicate contract as the field above.
     if (section.visibleWhen)
         mapped.visibleWhen = section.visibleWhen;
     return mapped;
@@ -113,14 +145,26 @@ export const bridgeFormView = (spec, _context) => {
         if (spec[key] != null)
             node[key] = spec[key];
     }
-    if (spec.defaultSort)
-        node.defaultSort = spec.defaultSort;
     if (spec.submitBehavior)
         node.submitBehavior = spec.submitBehavior;
-    // P1.6 — i18n & ARIA
+    // P1.6 — sharing
     if (spec.sharing)
         node.sharing = spec.sharing;
-    if (spec.aria)
-        node.aria = spec.aria;
+    // `defaultSort` (#3974) and `aria` (#3901) USED to be copied here. Both are
+    // `retiredKey()` tombstones on spec 17's FormViewSchema, so a FormView that
+    // parsed can never carry either — the guards were unreachable, and their
+    // shape invited the next reader to copy a dead pattern. Removed under the
+    // maintainer's 2026-08-11 enforce-or-remove ruling; measured dormant at BOTH
+    // ends before removal:
+    //   - producer: `FormViewSchema.safeParse` rejects both keys by name
+    //     (`form.defaultSort` / `form.aria` removed in the #3896 close-out).
+    //   - consumer: no form renderer reads either off the node — plugin-form
+    //     reads neither, and `SchemaRenderer`'s generic ARIA injection resolves
+    //     FLAT `ariaLabel`/`ariaDescribedBy`/`role` (SchemaRenderer.tsx:109-119),
+    //     never a nested `aria` object.
+    // The nested `aria` copy is still correct on the LIST bridge
+    // (`list-view.ts:214`), whose carrier stayed live and IS consumed at
+    // `plugin-list/src/ListView.tsx:2389-2392` — do not "align" the two.
+    // Pinned by `__tests__/FormViewRetiredKeys.test.ts`.
     return node;
 };

package/dist/spec-bridge/bridges/list-view.d.ts

@@ -5,7 +5,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import type { BridgeFn } from '../types';
+import type { BridgeFn } from '../types.js';
 import type { ListView } from '@objectstack/spec/ui';
 /**
  * Bridge input: the spec-canonical ListView (#2231 — the former hand-written

package/dist/spec-bridge/bridges/list-view.js

@@ -5,15 +5,48 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
+/**
+ * A spec `ListColumn` in, the same column out — in the spelling the spec
+ * declares (objectui#5068).
+ *
+ * This used to down-translate every column to the data-table adapter's
+ * `{ accessorKey, header }` before handing it to an `object-grid` node, and
+ * `ObjectGrid` translated it straight back through a tolerance branch that
+ * sniffed `columns[0]`. A round trip whose input was ALREADY canonical: the
+ * bridge's own parameter is `@objectstack/spec/ui`'s `ListColumn`, where
+ * `field` is required and `accessorKey` / `header` are refused by name
+ * (`ListColumnSchema` is a strict object). So the producer emitted a spelling
+ * the contract rejects, and the renderer grew a second de-facto contract to
+ * read it back — exactly the shape AGENTS.md #0.1 forbids, and the disposition
+ * objectui#3951 already settled: unify at the producer, no consumer-side alias.
+ *
+ * `accessorKey` is not retired as a concept — it is the TanStack adapter key
+ * `@object-ui/core` deliberately keeps OUT of the metadata identity fold
+ * (`column-identity.ts`'s `TABLE_ADAPTER_COLUMN_KEY`). `ObjectGrid` still
+ * applies it on the way OUT, at the one boundary that owns it. Metadata
+ * vocabulary comes in; adapter vocabulary goes out; one translation, one place.
+ *
+ * Nothing is invented on the way through, which is the second half of the fix.
+ * `header: col.label ?? col.field` used to turn "no label declared" into "the
+ * machine name was declared as the label", and that synthesized value then
+ * pre-empted `ObjectGrid`'s own header chain — `col.label` → the OBJECT
+ * FIELD's label → the prettified name — whose whole purpose is a column
+ * authored as a bare `{ field }`, and whose middle step exists so a localized
+ * field label wins over the name-derived English one on a non-English app. A
+ * bridged view therefore rendered raw machine names where a directly authored
+ * `object-grid` rendered the field's real, localizable label. It now forwards
+ * the declaration and lets the renderer resolve what was left unsaid.
+ */
 function mapColumn(col) {
-    // Spec-legacy shorthand: a bare field name stands for a default column.
+    // Spec shorthand: a bare field name stands for a default column.
     if (typeof col === 'string') {
-        return { accessorKey: col, header: col };
+        return { field: col };
     }
     const mapped = {
-        accessorKey: col.field,
-        header: col.label ?? col.field,
+        field: col.field,
     };
+    if (col.label != null)
+        mapped.label = col.label;
     if (col.width != null)
         mapped.width = col.width;
     if (col.align)
@@ -38,21 +71,113 @@ function mapColumn(col) {
         mapped.action = col.action;
     return mapped;
 }
+/**
+ * The spec's five row heights collapsed onto the renderer's three densities.
+ *
+ * `Record<RowHeight, …>` on purpose (objectui#4352): the key set is the spec's,
+ * so a row height added upstream fails the build here instead of silently
+ * arriving with no density. The table used to carry four more keys —
+ * `comfortable`, `spacious`, `small`, `large` — which `RowHeightSchema` does
+ * not admit, so no spec-valid list view could ever reach them; they only
+ * survived because the parameter was widened back to `string` and the fixture
+ * asserting three of them compiled against nothing. Deleting them is AGENTS.md
+ * #0.1: a renderer-side dialect for off-spec metadata is a second de-facto
+ * contract, and one strict contract beats N. An off-spec `rowHeight` now falls
+ * through to `undefined` — the producer is where it gets fixed.
+ */
+const ROW_HEIGHT_TO_DENSITY = {
+    compact: 'compact',
+    short: 'compact',
+    medium: 'comfortable',
+    tall: 'spacious',
+    extra_tall: 'spacious',
+};
+/**
+ * Runtime reader for {@link ROW_HEIGHT_TO_DENSITY} — the five spec row heights
+ * and **nothing else**.
+ *
+ * `hasOwnProperty`, not a bare index (objectui#4442): the table is a plain
+ * object literal, so indexing it with an unchecked key reaches
+ * `Object.prototype`. The parameter is typed `RowHeight`, but the boundary a
+ * host's stored view definition actually crosses is `SpecBridge.transformListView`,
+ * whose parameter is `any` — so `rowHeight: 'toString'` used to come back as
+ * `Object.prototype.toString`, a FUNCTION returned from a signature that
+ * promises three strings or nothing. `bridgeListView` then writes the key under
+ * `if (density)`, and a function is truthy, so it landed on the SchemaNode.
+ *
+ * This is the same guard `@object-ui/core`'s `rowHeightToDensityMode` grew in
+ * objectui#4440, and the repo's existing convention (`freeze-schema.ts:135`,
+ * `metadata-admin/predicate.ts:305`, six more). Both rowHeight surfaces now
+ * abstain identically on every off-spec spelling; the agreement is pinned by
+ * `__tests__/RowHeightDensityAgreement.test.ts`.
+ *
+ * `typeof rowHeight !== 'string'`, not `!rowHeight` (objectui#4459): the
+ * truthiness guard this replaces rejected only FALSY values, so every truthy
+ * non-string walked past it into a lookup that coerces its key — both
+ * `hasOwnProperty.call` and the index run `String(...)`. `['compact']`, a boxed
+ * `String('compact')` and `{ toString: () => 'compact' }` therefore each
+ * selected a real density, where core's twin abstained
+ * (`packages/core/src/utils/normalize-list-view.ts:83`, which has opened with
+ * the type guard since #4440). Note the direction against #4442: that leak produced a
+ * FUNCTION, visibly wrong to everything downstream; this one produced a
+ * legitimate-looking `'compact'` that nothing can tell apart from an authored
+ * value. The type guard subsumes the old one — `undefined`, `null`, `0` and
+ * `false` are all non-strings — and `''` keeps its answer while changing route:
+ * a string, so it passes here and is refused by `hasOwnProperty` one line down.
+ */
 function mapDensity(rowHeight) {
-    if (!rowHeight)
+    if (typeof rowHeight !== 'string')
         return undefined;
-    const map = {
-        compact: 'compact',
-        short: 'compact',
-        comfortable: 'comfortable',
-        spacious: 'spacious',
-        small: 'compact',
-        medium: 'comfortable',
-        large: 'spacious',
-        tall: 'spacious',
-        extra_tall: 'spacious',
-    };
-    return map[rowHeight];
+    if (!Object.prototype.hasOwnProperty.call(ROW_HEIGHT_TO_DENSITY, rowHeight)) {
+        return undefined;
+    }
+    return ROW_HEIGHT_TO_DENSITY[rowHeight];
+}
+/**
+ * The spec's own parse-time lift, applied where `parse` cannot reach
+ * (objectui#4585).
+ *
+ * `@objectstack/spec` accepts BOTH spellings of `view.exportOptions` and lifts
+ * the legacy bare format array to the object form at parse (objectstack#8010,
+ * `ui/view.zod.ts`):
+ *
+ *     z.array(ListViewExportFormatSchema).transform((formats) => ({ formats }))
+ *
+ * That transform never runs on this path. The bridge's input is a TypeScript
+ * type, not a parsed value — there is no `parse`/`safeParse` anywhere under
+ * `spec-bridge/` — so a host that parses first hands over the object form while
+ * a host that forwards raw stored metadata hands over whatever was authored,
+ * and nothing here can tell them apart. The legacy array therefore used to
+ * reach the `object-grid` node verbatim, where `ObjectGrid` reads
+ * `exportOptions.formats` and only that: `.formats` on an array is `undefined`,
+ * the renderer's `['csv', 'json']` default won, and the view's declared formats
+ * were dropped with no error and no console line — the export button still
+ * showed, because a non-empty array is truthy.
+ *
+ * This mirrors that transform and NOTHING more: the same contract applied one
+ * layer out, not a second de-facto one (AGENTS.md #0.1 — the consumer-side
+ * `Array.isArray` fallback in the renderer is what that rule forbids). Hence:
+ *
+ * - the object form passes through by reference, unread and unrewritten;
+ * - an empty array lifts to `{ formats: [] }`, exactly as the spec's transform
+ *   does — its `z.array()` carries no `.min(1)`, so `[]` is a legal input that
+ *   wraps rather than defaults. ObjectGrid then offers no format and hides the
+ *   export button: "declared zero formats", read literally;
+ * - a `'pdf'` stored before its retirement is carried, not filtered. The spec
+ *   REFUSES `'pdf'` at parse with a migration prescription (objectstack#8010;
+ *   PDF export itself was declined as objectstack#1301 NOT_PLANNED) — it does
+ *   not silently drop the value, so neither may this. Such a format dies
+ *   downstream in ObjectGrid's format-AGNOSTIC menu filter, kept deliberately
+ *   at objectui#4535 for metadata predating `os migrate meta --from 16`.
+ */
+function liftExportOptions(exportOptions) {
+    if (!Array.isArray(exportOptions))
+        return exportOptions;
+    // The pinned `@objectstack/spec@17.0.0-rc.6` still admits `'pdf'` as an array
+    // member (the enum narrowing arrives with the pin bump), so the element type
+    // here is wider than the renderer-side `ListViewExportFormat`. Narrowing it by
+    // filtering would invent precisely the silent drop the spec declines to do.
+    return { formats: exportOptions };
 }
 /** Transforms a ListView spec into a DataTable SchemaNode */
 export const bridgeListView = (spec, _context) => {
@@ -86,10 +211,6 @@ export const bridgeListView = (spec, _context) => {
         node.filterableFields = spec.filterableFields;
     if (spec.resizable != null)
         node.resizable = spec.resizable;
-    if (spec.striped != null)
-        node.striped = spec.striped;
-    if (spec.bordered != null)
-        node.bordered = spec.bordered;
     if (spec.navigation)
         node.navigation = spec.navigation;
     if (spec.kanban)
@@ -109,14 +230,12 @@ export const bridgeListView = (spec, _context) => {
         node.bulkActions = spec.bulkActions;
     if (spec.bulkActionDefs)
         node.bulkActionDefs = spec.bulkActionDefs;
-    if (spec.virtualScroll != null)
-        node.virtualScroll = spec.virtualScroll;
     if (spec.conditionalFormatting)
         node.conditionalFormatting = spec.conditionalFormatting;
     if (spec.inlineEdit != null)
         node.inlineEdit = spec.inlineEdit;
     if (spec.exportOptions)
-        node.exportOptions = spec.exportOptions;
+        node.exportOptions = liftExportOptions(spec.exportOptions);
     if (spec.emptyState)
         node.emptyState = spec.emptyState;
     if (spec.userActions)

package/dist/spec-bridge/index.d.ts

@@ -5,7 +5,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-export { SpecBridge } from './SpecBridge';
-export type { BridgeContext, BridgeFn, ObjectDefLite } from './types';
-export { bridgeListView } from './bridges/list-view';
-export { bridgeFormView } from './bridges/form-view';
+export { SpecBridge } from './SpecBridge.js';
+export type { BridgeContext, BridgeFn, ObjectDefLite } from './types.js';
+export { bridgeListView } from './bridges/list-view.js';
+export { bridgeFormView } from './bridges/form-view.js';

package/dist/spec-bridge/index.js

@@ -5,6 +5,6 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-export { SpecBridge } from './SpecBridge';
-export { bridgeListView } from './bridges/list-view';
-export { bridgeFormView } from './bridges/form-view';
+export { SpecBridge } from './SpecBridge.js';
+export { bridgeListView } from './bridges/list-view.js';
+export { bridgeFormView } from './bridges/form-view.js';

package/dist/spec-bridge/types.d.ts

@@ -5,7 +5,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import type { SchemaNode } from '@object-ui/core';
+import type { BaseSchema } from '@object-ui/types';
 /** Context passed to all bridge functions */
 export interface BridgeContext {
     /** Current user context for permission checks */
@@ -30,5 +30,26 @@ export interface ObjectDefLite {
         }>;
     }>;
 }
-/** A bridge function transforms a spec schema into a SchemaNode tree */
-export type BridgeFn<T = any> = (spec: T, context: BridgeContext) => SchemaNode;
+/**
+ * A bridge function transforms a spec schema into a schema node tree.
+ *
+ * Returns **`BaseSchema`**, not `SchemaNode` (objectui#4580, ruling Q4-B).
+ * Once core's `SchemaNode` became `@object-ui/types`' union
+ * (`BaseSchema | string | number | boolean | null | undefined`), declaring the
+ * return as `SchemaNode` made every caller re-ask a question no bridge has ever
+ * answered "yes" to: *is this a bare string / null?* Both shipped bridges end
+ * in a single `return node` on an object literal — `bridges/list-view.ts:226`
+ * and `bridges/form-view.ts:195` — so the wider declaration described nothing
+ * real while forcing a narrowing at every read.
+ *
+ * That cost was measured, not assumed: round 1 of this card recorded **272**
+ * mechanical errors across five spec-bridge suites, all of them TS18049
+ * (`'node' is possibly 'null' or 'undefined'`) and TS2339
+ * (`Property 'formType' does not exist on type
+ * 'string | number | boolean | BaseSchema'`) — the union being destructured by
+ * tests reading properties off a node the bridge always produces.
+ *
+ * This is a type ANNOTATION only: no runtime behaviour changes, and the emitted
+ * JavaScript is byte-identical (proven by bundle sha256 on this PR).
+ */
+export type BridgeFn<T = any> = (spec: T, context: BridgeContext) => BaseSchema;