@object-ui/components 17.5.0 → 17.7.0

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

@@ -5,14 +5,24 @@ import { UIActionSchema } from '@object-ui/types';
  * `locations`, `enabled` and `size` are all modern-only keys this renderer
  * forwards, and the legacy `crud.ts` `ActionSchema` is `@deprecated` and pins
  * `type: 'action'` where this renderer's own registry `inputs` declare
- * `'script' | 'url' | 'modal' | 'flow' | 'api'`.
+ * `'script' | 'url' | 'modal' | 'flow' | 'api'`. `actionType` is the DECLARED
+ * input carrying that execution type (objectui#7415), for the same reason it is
+ * on `action:button`; `type` stays on the intersection as the SDUI envelope's
+ * component discriminator and is not read as an action type here.
  */
-export interface ActionIconProps {
+export interface ActionIconRendererProps {
     schema: UIActionSchema & {
         type: string;
         className?: string;
+        actionType?: string;
     };
     className?: string;
     context?: Record<string, any>;
+    /**
+     * The host-EVALUATED enablement verdict — see `ActionButtonRendererProps` for the
+     * mechanism (objectui#9131). Declared rather than left to the index
+     * signature, consumed by name below, never re-spread onto the DOM.
+     */
+    disabled?: boolean;
     [key: string]: any;
 }

package/dist/renderers/action/action-menu.d.ts

@@ -12,8 +12,11 @@ export interface ActionMenuSchema {
     variant?: string;
     /** Trigger size */
     size?: string;
-    /** Visibility condition */
-    visible?: string;
+    /** Visibility predicate: a boolean, a CEL string, or a `{ dialect, source }` envelope */
+    visible?: boolean | string | {
+        dialect: string;
+        source?: string;
+    };
     /** Custom CSS class */
     className?: string;
     [key: string]: any;

package/dist/renderers/action/auto-trigger.d.ts

@@ -11,10 +11,25 @@
  * another. Deliberately strict: only the literal `true` arms it.
  */
 export declare function hasAutoTrigger(action: unknown): boolean;
+/** The fields of an action this module reads. */
+export interface AutoTriggerSubject {
+    autoTrigger?: unknown;
+    visible?: unknown;
+    name?: string;
+    label?: string;
+}
 /**
- * Run `run` at most once, as soon as `armed` is true.
+ * Run `run` at most once, as soon as `action` asks to be auto-triggered — unless
+ * the action's own declared `visible` gate hides it, in which case the trigger
+ * is refused and reported instead (objectui#4191).
  *
- * `run` may change identity freely (it is rebuilt from `schema` on most
- * renders); the ref is what makes this once-only, so depending on it is safe.
+ * @param action    The action the renderer received (read: `autoTrigger`,
+ *                  `visible`, `name`, `label`).
+ * @param isVisible The renderer's own evaluated `visible` verdict — the same
+ *                  value its early return consults. Only consulted when the
+ *                  action DECLARES a gate, exactly like that early return.
+ * @param run       The renderer's click path. It may change identity freely (it
+ *                  is rebuilt from `schema` on most renders); the ref is what
+ *                  makes this once-only, so depending on it is safe.
  */
-export declare function useAutoTriggerOnce(armed: boolean, run: () => void | Promise<void>): void;
+export declare function useAutoTriggerOnce(action: AutoTriggerSubject, isVisible: boolean, run: () => void | Promise<void>): void;

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,79 @@
+/**
+ * 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;
+/**
+ * A container MEMBER with its `properties` evaluated (objectui#10290).
+ *
+ * `action:bar`, `action:group` and `action:menu` draw their member actions
+ * themselves, so a member never passes through the `SchemaRenderer` memo that
+ * evaluates a node's `properties`. Its static values ride `properties.params`
+ * (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
+ * container evaluates the member's `properties` with the memo's own evaluator
+ * and scope (`evaluateBag`, from `useConfigBagEvaluator()`), once, where it
+ * composes or runs 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.
+ */
+export declare function withEvaluatedProperties<T extends object>(member: T, evaluateBag: ConfigBagEvaluator): T;
+/**
+ * A container member's static values (objectui#10290): its `properties.params`,
+ * evaluated through {@link withEvaluatedProperties}, or `undefined`.
+ *
+ * For `action:group` / `action:menu` items, which run the member themselves.
+ * (`action:bar` hands an inline member to `action:button` / `action:icon` with
+ * its `properties` already evaluated, and `readStaticParamValues` reads it
+ * there.)
+ */
+export declare function readMemberStaticParamValues(member: StaticParamsSubject, evaluateBag: ConfigBagEvaluator): Record<string, unknown> | undefined;
+/**
+ * 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.
+ * (An `action:group` / `action:menu` item is also a container member, so its
+ * static values are read from `properties.params` and evaluated by the
+ * container through {@link readMemberStaticParamValues} (objectui#10290).
+ * `UIActionSchema` declares no `properties`, so on a container member this bag
+ * is read off the authored object, not off a declared key. `element:button`'s
+ * inline `action` and `page:header`'s actions do not read
+ * `properties.params`.)
+ *
+ * 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/elements.d.ts

@@ -15,12 +15,15 @@
  *   - element:divider                            (no-props separator)
  *   - ElementButtonProps  -> element:button
  *
- * Heavier interactive elements (element:filter, element:form) live in their
- * owning plugins and are left to those packages. element:record_picker — which
- * writes its selection into a page variable — ships alongside in `./record-picker`.
+ * Heavier interactive elements (element:form) live in their owning plugins and
+ * are left to those packages. element:record_picker — which writes its
+ * selection into a page variable — ships alongside in `./record-picker`.
  *
  * 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` also reads the node-level `dataSource` binding: its
+ * `object` wins over the flat one, and its filter is AND-combined with the
+ * flat one (objectui#10909).
  */
 export {};

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

@@ -7,13 +7,17 @@
  *
  * Safe native HTML element passthrough renderers (ADR: kind:'html').
  *
- * A `kind:'html'` page is authored as a constrained JSX/Tailwind string that is
+ * A `kind:'html'` page is authored as a constrained JSX string that is
  * 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/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 by `BaseSchema`'s `[key: string]: any`, 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/form/validationRuleKeys.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 validation-rule names react-hook-form actually RUNS (objectui#5099).
+ *
+ * react-hook-form's field validator destructures a FIXED key set off the
+ * field descriptor and silently drops every other key. From the installed
+ * 7.85.0 bundle (`dist/index.cjs.js`, minified):
+ *
+ *     const{ref:c,refs:f,required:m,maxLength:y,minLength:p,min:g,max:b,
+ *           pattern:V,validate:A,name:x,valueAsNumber:S,mount:k}=e._f
+ *
+ * Of those twelve, seven are authorable validation rules — the rest are
+ * field-descriptor internals react-hook-form writes itself and an author
+ * never supplies through `FieldValidationRules`. Any rule name outside the
+ * seven — a misspelled `minlength`, an invented `email`, the numeric keys
+ * left by spreading an ARRAY into `validation` — is dropped without a trace:
+ * the field renders, the form looks validated, and the rule never runs. The
+ * form renderer reports such names loudly (dev-time `console.error`; see
+ * `form.tsx`).
+ *
+ * Both lists are PINNED against the installed react-hook-form bundle by
+ * `__tests__/rhf-recognized-rule-keys.test.ts`, which re-derives the
+ * destructured set from `dist/index.cjs.js` at test time. A react-hook-form
+ * bump that changes the set turns that test red — forcing a human to re-sort
+ * the new key into one of these two lists — instead of silently rotting the
+ * diagnostic.
+ */
+/**
+ * Keys react-hook-form's validator destructures that are NOT authorable
+ * rules: descriptor internals the library maintains itself.
+ */
+export declare const RHF_DESCRIPTOR_NON_RULE_KEYS: readonly string[];
+/**
+ * The authorable rule names react-hook-form's validator reads. Exactly the
+ * declared key set of `FieldValidationRules` in `@object-ui/types` —
+ * declared = enforced; anything else in a field's `validation` object is a
+ * bug in the metadata, not a rule.
+ */
+export declare const RHF_RECOGNIZED_RULE_KEYS: ReadonlySet<string>;

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

@@ -17,13 +17,4 @@
  *   - PageContainerProps -> page:footer / page:sidebar / page:section
  *                           (the thin wrappers; one shared `children` slot)
  */
-/**
- * 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.
- *
- * Exported for unit tests.
- */
-export declare function cleanupTitleSeparators(s: string): string;
+export {};