@object-ui/components 17.6.0 → 18.0.0

package/dist/renderers/action/resolve-icon.d.ts

@@ -1,6 +1,31 @@
 import { LucideIcon } from 'lucide-react';
 /**
- * Resolve a Lucide icon by its kebab-case name.
- * Returns null if not found.
+ * The lookup this seam performs, exposed for DIAGNOSTICS only.
+ *
+ * `renderers/basic/icon.tsx` names both halves in its objectui#5631 warning
+ * (`lookup: "Home" -> "House"`), and that message is under a maintainer ruling
+ * 一字不动. Without this it would need its own copy of the tokeniser and the
+ * map to keep saying the same thing — which is precisely the duplication this
+ * card removed. ⛔ It decides nothing: no call site can change what resolves by
+ * reading it.
+ */
+export declare function describeIconLookup(name: string): {
+    pascal: string;
+    key: string;
+};
+/**
+ * Resolve an authored Lucide icon name to its component.
+ *
+ * Accepts kebab-case, snake_case, space-separated and PascalCase spellings.
+ * Returns `null` when the name is absent or names no live glyph — deciding what
+ * to draw instead belongs to the caller (see the module docblock).
+ *
+ * ⚠️ The component this returns draws its `<svg>` — with lucide's own classes,
+ * box and attributes — SYNCHRONOUSLY, and fills in the path data when the
+ * icon's module arrives (objectui#9251). So `svg.lucide-house` matches on the
+ * first frame and nothing reflows, while the 1,781 icon modules stay off the
+ * eager path. ⛔ A test that asserts on the PATHS inside the svg must await
+ * them (`findBy*` / `waitFor`); everything that asks which icon this is —
+ * including `null` vs not — is answered in the same tick, as before.
  */
 export declare function resolveIcon(name: string | undefined): LucideIcon | null;

package/dist/renderers/action/static-params.d.ts

@@ -0,0 +1,71 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/** The two keys this module reads off an action node. */
+export interface StaticParamsSubject {
+    params?: unknown;
+    properties?: unknown;
+    name?: unknown;
+    label?: unknown;
+}
+/** Reset the warn-once memo. Exported for tests. */
+export declare function resetStaticParamsWarnings(): void;
+/**
+ * The static values to forward as the runner's `ActionDef.params`: the node's
+ * `properties.params` when it is an object bag, otherwise `undefined`.
+ *
+ * A node-level OBJECT `params` that is not the hoisted `properties.params` is
+ * never returned; it triggers the development warning above.
+ */
+export declare function readStaticParamValues(subject: StaticParamsSubject, where: string): Record<string, unknown> | undefined;
+/**
+ * Evaluates a config bag the way `SchemaRenderer` evaluates `properties`: the
+ * function `useConfigBagEvaluator()` (`@object-ui/react`) returns.
+ */
+export type ConfigBagEvaluator = (bag: unknown) => unknown;
+/**
+ * An `action:bar` member with its `properties` evaluated (objectui#10290).
+ *
+ * `action:bar` mounts its inline members on `action:button` / `action:icon`
+ * itself, so a member never passes through the `SchemaRenderer` memo that
+ * evaluates a node's `properties`. The renderer it lands on reads the static
+ * values off `properties.params` ({@link readStaticParamValues},
+ * objectui#10289), and they are templates (objectui#7867): on a record page,
+ * `"recordId": "${record.id}"` has to reach the handler as the record's id. The
+ * bar evaluates the member's `properties` with the memo's own evaluator and
+ * scope (`evaluateBag`, from `useConfigBagEvaluator()`), once, where it
+ * composes the member.
+ *
+ * Returns the member itself when it carries no `properties` bag. Only
+ * `properties` is evaluated. It is not copied onto the member (the memo's
+ * hoist), and the member's other keys are left as authored.
+ *
+ * `action:group` and `action:menu` do not call this: their members carry no
+ * `properties` bag (objectui#11638).
+ */
+export declare function withEvaluatedProperties<T extends object>(member: T, evaluateBag: ConfigBagEvaluator): T;
+/**
+ * The same ruling on a spec ACTION ENTRY (objectui#10462): `element:button`'s
+ * inline `action`, `action:group` / `action:menu` items and `page:header`'s
+ * actions. `params` is an entry's `ActionParam[]` input list and nothing else.
+ * (No entry surface reads a `properties.params` bag. `UIActionSchema` declares
+ * no `properties`, and the spec refuses one on an `action:group` /
+ * `action:menu` member: its static parameter values are not part of the inline
+ * action vocabulary, and an action that needs them is its own `action:button`
+ * node (objectui#11638).)
+ *
+ * One type is still different: `api`. The objectstack#5777 window keeps the
+ * runner reading an object `params` as the request payload (with its own
+ * development warning, naming `bodyExtra`) until 18, so for `api` the object is
+ * returned unchanged. For every other type it is not returned, and a
+ * development build says so once per action.
+ *
+ * `type` is the executor the surface dispatches the entry as. Call this on the
+ * non-array branch only; an array `params` is the input list, forwarded as
+ * `actionParams`.
+ */
+export declare function readActionEntryParamValues(entry: StaticParamsSubject, type: unknown, where: string): Record<string, unknown> | undefined;

package/dist/renderers/action/visibility-gate.d.ts

@@ -34,9 +34,13 @@
  *     scope (objectui#3848).
  *
  * The ruling: a gate is declared when normalization still leaves a condition to
- * evaluate. `''`, a whitespace-only string, an empty-`source` envelope and any
- * non-predicate value are therefore NOT declared, and one definition in core
- * says so for the renderers, `SchemaRenderer` and the execution entry alike.
+ * evaluate. `''`, a whitespace-only string and an empty-`source` envelope are
+ * therefore NOT declared, and one definition in core says so for the
+ * renderers, `SchemaRenderer` and the execution entry alike. (A non-predicate
+ * value — `0`, `{}`, an array, an `ast`-only envelope — was in that list until
+ * objectui#11358, which made it a DECLARED gate that cannot be evaluated: the
+ * normalizer keeps it, the evaluator faults on it, and each leg fails it in
+ * its key's fault direction — `visible` hidden, `disabled` greyed out.)
  *
  * The NAME is kept (`hasDeclaredVisibilityGate`) and this module keeps
  * re-exporting it: the five member-action call sites — `action:button`,
@@ -68,6 +72,10 @@
  *   | `{ source: '' }`             | shown → shown     | GREY → on         | on → on           |
  *   | `'   '` (whitespace)         | HIDDEN → shown    | on → on           | GREY → on         |
  *   | `0` / `{}` (not a predicate) | shown → shown     | GREY → on         | on → on           |
+ *
+ * (The table is objectui#3850's measurement. Since objectui#11358 the `0` /
+ * `{}` row reads HIDDEN / GREY / on: declared and faulting, each leg's fault
+ * direction — pinned in `__tests__/action-empty-predicate-scope.test.tsx`.)
  *   | `true` / `false` / CEL / `${…}`| unchanged        | unchanged         | unchanged         |
  *
  * The whitespace row is the one that moves on `visible`, and it moves toward the

package/dist/renderers/basic/data-list.d.ts

@@ -14,6 +14,7 @@
  *                               row, no toolbar/card/pagination.
  *
  * Props are read off `schema.properties` (spec convention) with a `schema.props`
- * fallback, matching the other `element:*` renderers.
+ * fallback, matching the other `element:*` renderers. The repeater's query is
+ * the node-level `dataSource` binding alone (objectui#11880, objectui#12345).
  */
 export {};

package/dist/renderers/basic/elements.d.ts

@@ -22,5 +22,7 @@
  * All props are read off `schema.properties` per the spec's
  * `UIComponent.properties` convention; `schema.props` is also accepted
  * as a fallback so authors transitioning between conventions keep working.
+ * `element:number` reads its query from the node-level `dataSource` binding
+ * ONLY: its `object` and its `filter` (objectui#10909, objectui#11880).
  */
 export {};

package/dist/renderers/basic/html-elements.d.ts

@@ -11,9 +11,13 @@
  * PARSED (never executed) into the SDUI tree. For that tier to live up to its
  * name, the everyday HTML tags an author reaches for — headings, paragraphs,
  * lists, links, images, emphasis — must each resolve to a renderer (otherwise
- * the parser flags them `unknown-component`). div / span / table / code / label
- * and the semantic sectioning tags are registered elsewhere; this module fills
- * in the rest of the safe flow/inline set.
+ * the parser flags them `unknown-component`). div / span / table / label and
+ * the semantic sectioning tags are registered elsewhere; this module fills in
+ * the rest of the safe flow/inline set — `code` included (objectui#10756): the
+ * bare `code` key used to be the `field:code` widget's namespace fallback, so
+ * `<code>inline</code>` on an html page drew a code EDITOR and dropped its
+ * text. The widget now stands down from the bare key (`FIELD_TYPES_SKIP_FALLBACK`
+ * in `@object-ui/fields`) and stays reachable as `field:code`.
  *
  * Safety: these render real DOM, but the html tier never executes JS, so props
  * are static literals from the parser. As defense-in-depth the passthrough

package/dist/renderers/basic/readProps.d.ts

@@ -0,0 +1,60 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * The config bag an `element:*` renderer reads — THE one definition of it in
+ * `@object-ui/components` (objectui#6783).
+ *
+ * Per spec, element components carry their config in `schema.properties`;
+ * `schema.props` is tolerated as the legacy alias so JSON written either way
+ * works. `properties` wins a contested key — the 2026-08-18 cross-channel
+ * ruling (objectui#5123), whose spread order is preserved here verbatim and
+ * pinned by `packages/components/src/__tests__/alias-precedence-cross-channel.test.tsx`.
+ *
+ * ## The third channel (objectui#6783)
+ *
+ * This body used to be copied into five renderer modules — `elements.tsx`,
+ * `data-list.tsx`, `text-input.tsx`, `record-picker.tsx`,
+ * `metadata-viewer.tsx` — each spelling the two halves as
+ * `(schema?.properties ?? {}) as T`. `??` only replaces `null`/`undefined`, so
+ * a DEGENERATE bag (a string, a number, an array) went straight into the
+ * object spread and was re-read as its own indexed keys: for
+ * `properties: 'not-a-bag'` the bag a renderer received was
+ * `{ '0': 'n', '1': 'o', … '8': 'g' }` — nine keys nobody authored.
+ *
+ * That is the same hazard objectui#6752 and objectui#6760 closed in
+ * `packages/react/src/SchemaRenderer.tsx` on the two channels UPSTREAM of this
+ * one (the `props` evaluation memo plus `propsWithoutCanonicalKeys`, and the
+ * `properties` hoist). Those guards do not reach here, and are not meant to:
+ * what they buy is that the AUTHORED value's shape survives into the node, so
+ * a renderer downstream still receives `schema.properties === 'not-a-bag'` and
+ * gets to answer the question for itself. The three channels are in SERIES.
+ *
+ * ## Why it asks `isConfigBag` rather than carrying its own predicate
+ *
+ * Because a copy that DRIFTS produces no error — each spelling is a boolean
+ * expression, so two channels answering "is this a real config bag?"
+ * differently is silent by construction. objectui#6761 ended that inside
+ * `@object-ui/react` by converging six occurrences behind one exported
+ * definition and pinning it (`utils/configBag.pin.test.ts` fails on a seventh
+ * spelling); `@object-ui/components` depends on `@object-ui/react` — every one
+ * of the five modules above already imports from it — so the reachable answer
+ * here is to READ that definition, not to write the seventh spelling one
+ * package over where its pin cannot see it.
+ *
+ * ## What the guard buys, measured
+ *
+ * Not a rendered pixel, on today's tree: all five renderers read NAMED keys
+ * off this bag, and the one onward spread (`metadata-viewer`'s
+ * `<StateMachineView {...props} />`) hands them to components that destructure
+ * named fields, so the indexed keys were computed and then discarded. What it
+ * buys is the same thing objectui#6752 measured its own guard buys — the
+ * authored value's shape is not reinterpreted — one channel further down,
+ * which is exactly the property that stops mattering only until the first of
+ * these five spreads its bag onto a DOM element.
+ */
+export declare function readProps<T extends Record<string, any>>(schema: any): T;

package/dist/renderers/basic/record-picker.d.ts

@@ -10,8 +10,9 @@
  *
  * Data binding follows the spec's ElementDataSource (`schema.dataSource`):
  *   { object, view?, filter?, sort?, limit? }
- * with `properties.object` accepted as a fallback. Display config is read off
- * `schema.properties`:
+ * and is read from there ONLY: the flat `properties.object` / `filter` /
+ * `sort` / `limit` are not read (objectui#11880, objectstack#11509 ruled
+ * A-narrow). Display config is read off `schema.properties`:
  *   { labelField='name', valueField='id', label?, placeholder?, emptyText? }
  *
  * The selection is written through `usePageVariableBinding(schema.id)`: the

package/dist/renderers/complex/data-table.d.ts

@@ -40,26 +40,43 @@ type BuiltinRowPredicates = NonNullable<DataTableSchema['rowEditPredicates'] | D
 export declare function isBuiltinRowActionVisible(predicates: Pick<BuiltinRowPredicates, 'visibleWhen'> | undefined, name: 'edit' | 'delete', row: any, scope: Record<string, unknown>): boolean;
 /**
  * Does this schema-driven custom row action render for THIS row? Same
- * single-definition rule as the built-ins above.
+ * single-definition rule as the built-ins above, and the ONE definition for
+ * every row menu: this file's (the related list's data table) and
+ * plugin-grid's `RowActionMenu` (its "⋮" items, its inline primary buttons and
+ * its "⋮" guard), which imports it from the `@object-ui/components` barrel
+ * rather than keeping a twin (objectui#11294).
  *
- * A gate counts as DECLARED by `!= null && !== ''`, never by truthiness
- * (objectui#3758). Truthiness cannot answer the question: `visible: false` is a
- * declared gate that excludes every row, and testing `!action.visible`
- * classified it as *ungated* — so the most explicit way to say "never show this"
- * rendered the item for everyone, and counted toward the "⋮" guard. This is the
- * invariant objectui#3492 established for the selection bar (plugin-grid's
- * `hasVisibilityGate`), and the same `!= null` posture the built-in `visibleWhen`
- * gate above has always had. The boolean then decides in
- * {@link evalRowActionVisibility}, which short-circuits it instead of handing it
- * to the engine.
+ * Whether a gate is DECLARED at all is asked with `hasDeclaredVisibilityGate`,
+ * the action family's one definition (objectui#3812): the related list's
+ * toolbar, `action:*`, `DeclaredActionsBar` and the rest ask it too, so an
+ * action cannot show in a list's header and be missing from its rows.
  *
- * `''` is grouped with `null` deliberately: an empty predicate is nothing to
- * evaluate, so it must not hide the item from everyone either.
+ * - `visible: false` is a declared gate that excludes every row. Truthiness
+ *   cannot answer the question: testing `!action.visible` read it as ungated
+ *   and rendered the item for everyone (objectui#3758). The boolean then
+ *   decides in {@link evalRowActionVisibility}, which short-circuits it instead
+ *   of handing it to the engine.
+ * - A blank predicate is no gate, so the action shows: `''`, a whitespace-only
+ *   string, and an envelope whose `source` is blank. The blank is still
+ *   reported (ADR-0137 D4) through the family's one `[blank]` report, once per
+ *   blank spelling rather than once per row. This test used to be
+ *   `pred == null || pred === ''`, so a whitespace-only `visible` counted as
+ *   declared, was evaluated, and failed closed: the action showed in a related
+ *   list's toolbar and was missing from its rows (objectui#11294).
+ * - A value that is not a predicate at all (`0`, `{}`, an array, an
+ *   `ast`-only envelope) IS a declared gate, one that cannot be evaluated
+ *   (objectui#11358): the family's definition answers "declared", the row fold
+ *   faults on it and fails closed, so the action is hidden and the fault is
+ *   reported — as on every other member of the family.
+ *
+ * `fields` is the object's field definitions, for a caller that has them:
+ * plugin-grid passes them so a relation compares as its stored foreign key
+ * (see `evalRowPredicate`). This file's own callers pass none.
  */
 export declare function isCustomRowActionVisible(action: {
     name?: string;
     visible?: unknown;
-} | undefined, row: any, scope: Record<string, unknown>): boolean;
+} | undefined, row: any, scope: Record<string, unknown>, fields?: unknown): boolean;
 /** What the row overflow menu will actually render for ONE row. */
 export interface DataTableRowMenuPlan {
     /** The built-in Edit item renders for this row. */

package/dist/renderers/complex/dataTableBindDiagnostic.d.ts

@@ -0,0 +1,187 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * The diagnostics that say out loud what `data-table` has always done silently
+ * with a key the AUTHOR wrote.
+ *
+ * TWO questions, one channel. The file is named for the first because it came
+ * first (objectui#6575); it was never limited to it.
+ *
+ *   1. `bind` was authored — and `data-table` does not read `bind` at all
+ *      (objectui#6575, maintainer ruling 2026-08-27, option A: 「同意」).
+ *   2. `data` was authored and is NOT an array — so the renderer dropped it to
+ *      zero rows at `data-table.tsx`'s
+ *      `Array.isArray(rawData) ? rawData : EMPTY_ROWS` (objectui#6665).
+ *
+ * They are deliberately two predicates asking two questions, not one widened
+ * predicate. The nodes that trip #2 carry no `bind` AT ALL, so #6575 staying
+ * silent on them is correct behaviour rather than a gap — the triage ruling on
+ * objectui#6665 is explicit about that, and widening #6575's question would
+ * have made its silence look like the defect. See {@link describeNonArrayData}.
+ *
+ * ## The first defect this names
+ *
+ * `bind` is the data-scope binding vocabulary: a path string resolved by
+ * `useDataScope()`. `list`, `tree-view` and the `object-*` plugin widgets read
+ * it. `DataTableRenderer` does NOT — it takes its rows from `data: rawData =
+ * EMPTY_ROWS` off the node, and the file calls no such hook.
+ *
+ * A `bind` on a `data-table` is nevertheless accepted by every gate: the TS
+ * side because `BaseSchema` declares `bind` for every node (objectui#6357), the
+ * zod side by `BaseSchema` being `.passthrough()` (which `DataTableSchema.extend(…)` inherits). So the
+ * author gets a table drawing a correct-looking header over the "No results
+ * found" empty state, with no error, no warning and no diagnostic — the
+ * hardest failure shape for a human OR an AI author to self-check, because a
+ * rendered header reads as a success receipt.
+ *
+ * The platform was already paying a teaching cost for it rather than a
+ * diagnostic cost: `skills/objectui/rules/protocol.md` documents the pothole
+ * verbatim, and `skill-guide-data-table-binding.test.tsx` pins the behaviour.
+ * This module moves the warning from the docs to the console, where the author
+ * who did not read the docs is standing.
+ *
+ * ## What it deliberately does NOT do
+ *
+ * It changes NO behaviour. `data-table` still does not read `bind`, and the
+ * ruling is explicit that it must not start: making it a `useDataScope` reader
+ * (option B) is a separate published-surface question needing its own ruling.
+ * Refusing the key at parse (option C) stays blocked on the `.passthrough()`
+ * ceiling (objectui#5155 / objectui#6269). So the trap stops being silent; it
+ * does not stop being a trap.
+ *
+ * ⭐ The `data`-vs-`bind` PRECEDENCE half of that open question DISSOLVED at
+ * objectui#9308 rather than being answered. While `useDataScope` walked the
+ * injected adapter, `bind` and the node's own `data` were two spellings of one
+ * idea — "where this table's rows come from" — and a reader of both would have
+ * needed a rule. Since that ruling `bind` resolves a path in the ambient
+ * predicate scope and `data` is an inline array on the node: different
+ * channels, different questions, no precedence to decide. objectui#6575's
+ * ruling that `data-table` must not read `bind` is untouched by that, and this
+ * diagnostic's job is unchanged.
+ *
+ * ## Why a console warning, and only a console warning
+ *
+ * The same channel `plugin-grid`'s `columnSpellingDiagnostics.ts` uses for the
+ * identical shape of failure ("you declared something and the renderer dropped
+ * it"): a pure `describe…` function returning `string | null`, called from a
+ * `useEffect` keyed on the schema slice, one `console.warn`, no NODE_ENV
+ * branch. Deliberately the SAME shape rather than a second, differently-shaped
+ * one next to it. Rendering an in-table message instead would be user-facing
+ * copy needing all ten locale packs in `@object-ui/i18n`; a throw would take
+ * the surrounding page down for a defect that costs one table.
+ *
+ * The rate limit is the `useEffect` key, and that is enough HERE for a reason
+ * `visibilityDiagnostic.ts` does not have available: a node gate is evaluated
+ * once per row, so it needs a module-level dedupe `Set` to keep one authoring
+ * bug from printing N lines. A `data-table` is one node rendered once — the
+ * effect key is one line per mount per distinct `bind`, which is already the
+ * "one line per distinct authoring bug" ceiling that `Set` exists to buy.
+ *
+ * ## The message never asserts something it did not check
+ *
+ * A node can carry BOTH an inline `data` array and a `bind`. That table is not
+ * empty, so the "header over an empty body" consequence would be false there —
+ * and a diagnostic that overstates its own consequence teaches authors to
+ * distrust it. The two cases get two different consequence clauses, decided by
+ * looking at the rows the renderer actually resolved.
+ */
+/** Prefix for every `bind` line — the handle tests and greps hold. */
+export declare const DATA_TABLE_BIND_DIAGNOSTIC_PREFIX = "[ObjectUI] DataTable bind:";
+/** The key `data-table` really reads its rows from. */
+export declare const DECLARED_ROWS_KEY = "data";
+/** Where the offending node lives, for the first line of either message. */
+export interface DataTableNodeAddress {
+    /** The schema node's `type` — `data-table`, or an alias that routes here. */
+    blockType?: unknown;
+    /** The node's `id`, when it has one. */
+    id?: unknown;
+    /** The table's authored caption — often the only human-readable name. */
+    caption?: unknown;
+}
+/**
+ * Was a `bind` authored on this node?
+ *
+ * `undefined` is absence — a destructuring default or an omitted key. Every
+ * other value, including `null` and the empty string, is something the author
+ * WROTE, and writing it bought nothing. Exported so the renderer's effect key
+ * and this judgement cannot drift apart: one predicate, two readers.
+ */
+export declare function hasAuthoredBind(bind: unknown): boolean;
+/**
+ * The message for a `data-table` node carrying a `bind`, or `null` when there
+ * is nothing to say.
+ *
+ * `rows` is what the renderer resolved for the body — passed in rather than
+ * re-derived, so the consequence sentence is measured against the same array
+ * the reader is looking at.
+ *
+ * Naming the ADDRESS is the point: which node, which path it spells, what the
+ * renderer did instead, and what to write to get the rows on screen. A message
+ * that only said something went wrong would leave the author where the silence
+ * did.
+ */
+export declare function describeIgnoredBind(bind: unknown, rows: unknown, address: DataTableNodeAddress): string | null;
+/** Prefix for every non-array `data` line — the handle tests and greps hold. */
+export declare const DATA_TABLE_DATA_DIAGNOSTIC_PREFIX = "[ObjectUI] DataTable data:";
+/**
+ * Was `data` authored as something that is not an array?
+ *
+ * `undefined` is absence — an omitted key, or the renderer's destructuring
+ * default. Everything else the author WROTE, and `data-table.tsx` reduces every
+ * non-array value of it to `EMPTY_ROWS` without a word.
+ *
+ * ## Why this is not {@link hasAuthoredBind}'s question
+ *
+ * That one asks "was a `bind` authored?" — a key `data-table` does not read at
+ * all. This asks about `data`, the key it genuinely does read, and asks a
+ * SHAPE question about it rather than a presence one. The nodes that trip this
+ * carry no `bind`, so #6575's predicate is correctly silent on them; that
+ * silence is precisely why a second question had to be asked here instead of
+ * the first one being widened.
+ *
+ * ## Why the predicate is not keyed on the `${...}` shape
+ *
+ * The expression string is the spelling that was REPORTED, but it is not the
+ * defect. `Array.isArray(rawData) ? rawData : EMPTY_ROWS` swallows a number, an
+ * object, a `null` and a plain string exactly as silently, so a predicate that
+ * only caught `${...}` would leave the next non-array spelling to arrive as a
+ * fresh card. The shape only chooses the wording (see {@link TEMPLATE_SHAPE}).
+ *
+ * Exported so the renderer and this judgement cannot drift apart: one
+ * predicate, two readers.
+ */
+export declare function hasNonArrayAuthoredData(rawData: unknown): boolean;
+/**
+ * The message for a `data-table` node whose `data` is not an array, or `null`
+ * when there is nothing to say.
+ *
+ * ## Why no measured-consequence clause, unlike {@link describeIgnoredBind}
+ *
+ * That one has to look at the rows the renderer resolved, because a node can
+ * carry BOTH a `bind` and a real inline `data` array — "header over an empty
+ * body" would be false there. Here it cannot be: `data` is the ONLY row source
+ * `data-table` has, and this function is called exactly when that source is not
+ * an array, so the body is `EMPTY_ROWS` by construction. The consequence is
+ * stated because the predicate already established it, not asserted on faith.
+ *
+ * ## What it deliberately does NOT say
+ *
+ * It does not tell the author to move the expression under `properties`. The
+ * same expression IS evaluated there — that contrast is what makes this a
+ * defect rather than a design — but whether `properties` is an authoring
+ * channel for the `ui:*` / `page:*` namespaces is an open contract question,
+ * recorded in `skills/objectui/rules/protocol.md` rather than recommended by
+ * it. A console line is the wrong place to settle that, so the message teaches
+ * the one route the guides do teach: the host resolves the rows.
+ *
+ * It also changes NO behaviour. Making node-level `data` evaluate expressions
+ * is a behaviour change on a published component; the objectui#6665 triage
+ * ruling put that arm on the maintainer floor and dispatched only this one.
+ * The trap stops being silent; it does not stop being a trap.
+ */
+export declare function describeNonArrayData(rawData: unknown, address: DataTableNodeAddress): string | null;

package/dist/renderers/layout/box.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export {};

package/dist/renderers/layout/containers.d.ts

@@ -1,29 +1,34 @@
+import { default as React } from 'react';
 /**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
+ * The props of {@link PageHeaderActions}.
  *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * Spec-aligned container renderers for the `page:*` component namespace.
- * Backs the Page-as-root record detail page model (Salesforce Lightning
- * Record Page parity).
- *
- * Maps `packages/spec/src/ui/component.zod.ts` props:
- *   - PageTabsProps      -> page:tabs
- *   - PageCardProps      -> page:card
- *   - PageAccordionProps -> page:accordion
- *   - PageHeaderProps    -> page:header
- *   - PageContainerProps -> page:footer / page:sidebar / page:section
- *                           (the thin wrappers; one shared `children` slot)
+ * `actions`, `maxVisible` and `mobileMaxVisible` are `page:header`'s own
+ * authored keys, read as that block reads them; the system actions are not a
+ * prop, they come from `RecordContext.headerSystemActions` as they always did.
  */
+export interface PageHeaderActionsProps {
+    /** The authored `actions` array: action ids (the contract) or, during the transition, inline action objects. */
+    actions?: unknown;
+    /** The inline-button budget on desktop, as `page:header`'s `maxVisible`; an out-of-contract value falls back to 3. */
+    maxVisible?: unknown;
+    /** The inline-button budget on mobile, as `page:header`'s `mobileMaxVisible`; an out-of-contract value falls back to 1. */
+    mobileMaxVisible?: unknown;
+    /** Drawn in place of the action row when no action survives the gates. */
+    emptySlot?: React.ReactNode;
+}
 /**
- * Strip dangling connectors that survive when a `titleFormat` interpolates
- * with one side empty — e.g. `{number} - {name}` becomes `CTR-0001 -` when
- * `name` is blank. Removes a trailing/leading hyphen / middle-dot / colon /
- * slash / pipe (optionally surrounded by whitespace) and collapses
- * adjacent whitespace into a single space. Idempotent.
+ * A record's header actions: the declared actions placed at `record_header` /
+ * `record_more` and the host's system actions (Edit / Share / Delete), gated,
+ * ordered, split into inline buttons and the `⋯` overflow, and dispatched
+ * through the action runner.
  *
- * Exported for unit tests.
+ * This is `page:header`'s action row, lifted out of `PageHeaderRenderer` so
+ * that a host can draw the same row where a page has no `page:header`
+ * (objectui#12906): a page that declares `print` may hold only the printable
+ * component types, and `page:header` is not one of them, so the console's
+ * record view draws this row in its screen-only chrome beside Print. It is
+ * the ONE resolver for both surfaces, ⛔ never a second one. It must render
+ * inside the record's `RecordContext` and `ActionProvider`, as `page:header`
+ * does.
  */
-export declare function cleanupTitleSeparators(s: string): string;
+export declare const PageHeaderActions: React.FC<PageHeaderActionsProps>;

package/dist/renderers/layout/page-block-grid.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+/**
+ * Lays a list of page blocks on the 12-column block grid (objectui#12624):
+ * each block takes the span its kind gets from `./page-block-span`, folded by
+ * breakpoint. One component for every block list that folds this way: a
+ * region's blocks (`RegionContent` in `./page.tsx`) and the children of
+ * `page:card` / `page:section` (`./containers.tsx`), so a container in a
+ * region spans 12 by its own kind and its children fold like region blocks.
+ * A cell is `empty:hidden`, so a block that renders nothing leaves no gap.
+ */
+export declare const PageBlockGrid: React.FC<{
+    nodes: readonly unknown[];
+    className?: string;
+    /** Marks the list as a rail's: every block in it, nested ones too, spans 12. */
+    rail?: boolean;
+    /** Key prefix for blocks with no `id`. */
+    keyPrefix?: string;
+    /** Maps a node to the schema `SchemaRenderer` renders (identity by default). */
+    toSchema?: (node: unknown) => unknown;
+    attributes?: Record<string, string | undefined>;
+    /** The grid element, for a caller that measures it (the region's posture, objectui#12703). */
+    gridRef?: React.Ref<HTMLDivElement>;
+}>;
+/**
+ * A container's child slot as a block grid: a list goes on the grid, while a
+ * bare node or text renders as it did (`renderChildren`), since there is
+ * nothing to lay out beside it.
+ */
+export declare function renderBlockChildren(children: unknown, render: (c: unknown) => React.ReactNode): React.ReactNode;

package/dist/renderers/layout/page-block-span.d.ts

@@ -0,0 +1,50 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * How wide a page block sits in its region's 12-column block grid
+ * (objectui#12624).
+ *
+ * The width is DERIVED from the block's kind, never authored:
+ * `@objectstack/spec`'s `PageComponentSchema` declares no `span`, and on
+ * `PageRegionSchema` `span` is only a refused alias of `width`. So this file
+ * adds no key an author can write; it names, once, which registered block
+ * types are metric tiles (3 of 12) and which are charts (6 of 12). Every other
+ * type, a type this table does not name included, spans the full 12.
+ *
+ * The keys are the registry keys the blocks are registered under (the bare
+ * key where the registration keeps one, and the namespaced key). The page
+ * renderer (`RegionContent` in `./page.tsx`) and the Studio page designer's
+ * block card (app-shell `PageBlockCanvas`) both read this table, so the span
+ * the designer shows is the span the page draws.
+ */
+export type PageBlockSpan = 3 | 6 | 12;
+/** Registered block type → its span, for the types narrower than 12. */
+export declare const PAGE_BLOCK_SPANS: ReadonlyMap<string, 3 | 6>;
+/**
+ * The span a block of this type takes; a type the table does not name takes
+ * 12. A block in a `rail` region (below) takes 12 whatever its kind: a rail is
+ * a narrow column, where a fold by viewport width would squeeze a tile to a
+ * sliver.
+ */
+export declare function pageBlockSpan(type: unknown, rail?: boolean): PageBlockSpan;
+/**
+ * Is this region a rail — the narrow `sidebar` / `aside` column beside `main`?
+ * Both are on every layout that places those slots beside `main` (no
+ * template, `default`, `full-width`, `three-column`); `header-sidebar-main`
+ * places only `sidebar` there (an `aside` joins `main`'s column); the
+ * `dashboard` template makes every region but `header` / `footer` a grid cell,
+ * so it has none. The page renderer passes the same answer structurally, by
+ * the slot it places a region in.
+ */
+export declare function isPageRailRegion(regionName: unknown, template?: unknown): boolean;
+/**
+ * The span folded by breakpoint: as declared from `xl` (1280px) up; between
+ * `md` (768px) and `xl` tiles take 6 and charts 12; under `md` every block
+ * takes 12. LITERAL class strings so Tailwind's scanner emits them.
+ */
+export declare const PAGE_BLOCK_SPAN_CLASS: Readonly<Record<PageBlockSpan, string>>;