@object-ui/react 17.6.0 → 18.0.0

package/dist/hooks/useDatasetDimensionLabels.js

@@ -77,7 +77,12 @@ import { SchemaRendererContext } from '../context/SchemaRendererContext.js';
 export function useDatasetDimensionMeta(object, dimensionFields, dimensions, options) {
     // The host's AUTHENTICATED fetch (objectui#4121) — see property 1 in the
     // file header for why it is read off the context directly.
-    const apiFetch = useContext(SchemaRendererContext)?.apiFetch;
+    const context = useContext(SchemaRendererContext);
+    const apiFetch = context?.apiFetch;
+    // The host data source, when it can answer `getObjectSchema` (objectui#13039):
+    // the data layer's shared request-key cache, so N dataset widgets over one
+    // object make ONE `meta/object/NAME` request instead of one each.
+    const dataSource = context?.dataSource;
     const enabled = options?.enabled ?? true;
     // LOCALE-FREE state (objectui#4030) — see property 2 in the file header.
     const [meta, setMeta] = useState(null);
@@ -103,14 +108,22 @@ export function useDatasetDimensionMeta(object, dimensionFields, dimensions, opt
         (async () => {
             try {
                 const doFetch = apiFetch ?? fetch;
-                const loadObjectSchema = async (name) => {
-                    const r = await doFetch(`/api/v1/meta/object/${encodeURIComponent(name)}`, {
-                        headers: { accept: 'application/json' },
-                        credentials: 'include',
-                    });
-                    const doc = await r.json().catch(() => null);
-                    return doc?.item ?? doc?.data ?? doc;
-                };
+                // objectui#13039 — through the data source's `getObjectSchema` when one
+                // that answers it is in scope: the read the dashboard's chart, metric
+                // and table widgets make, which the adapter's metadata cache joins while
+                // it is in flight. It answers the bare object document, which is what
+                // the raw leg's unwrap yields, so core gets one shape from either leg.
+                // The raw read stays as the fallback for a surface with no such source.
+                const loadObjectSchema = typeof dataSource?.getObjectSchema === 'function'
+                    ? (name) => dataSource.getObjectSchema(name)
+                    : async (name) => {
+                        const r = await doFetch(`/api/v1/meta/object/${encodeURIComponent(name)}`, {
+                            headers: { accept: 'application/json' },
+                            credentials: 'include',
+                        });
+                        const doc = await r.json().catch(() => null);
+                        return doc?.item ?? doc?.data ?? doc;
+                    };
                 // ONE walk for every dimension, memoized per call inside core — sibling
                 // dimensions sharing a relationship prefix read that object once, and
                 // the base object is seeded so it is never re-read.
@@ -133,8 +146,10 @@ export function useDatasetDimensionMeta(object, dimensionFields, dimensions, opt
         // (objectui#4030 / PR #4324). `apiFetch` comes from the provider's
         // memoized context value, and this hook's own `setState` cannot re-render
         // the provider, so its identity is stable across the effect's own updates.
+        // `dataSource` joins for the same reason and from the same value
+        // (objectui#13039): it decides which leg the read takes.
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [signature, apiFetch]);
+    }, [signature, apiFetch, dataSource]);
     return meta;
 }
 /**

package/dist/hooks/useDensityMode.d.ts

@@ -50,8 +50,14 @@ export interface DensityResult {
  *
  * @example
  * ```tsx
- * const density = useDensityMode(activeView?.densityMode ?? 'comfortable', {
- *   onChange: (m) => dataSource.updateViewConfig(obj, vid, { densityMode: m }),
+ * import { DENSITY_MODE_TO_ROW_HEIGHT, rowHeightToDensityMode } from '@object-ui/core';
+ *
+ * // A view stores the protocol's `rowHeight`; the legacy `densityMode` key is
+ * // retired on `NamedListView` (objectui#7924), so persist the spec value —
+ * // here into the host's own per-user store (`saveUserRowHeight` is the
+ * // host's; the console keeps the choice on the user's own list state).
+ * const density = useDensityMode(rowHeightToDensityMode(activeView?.rowHeight) ?? 'comfortable', {
+ *   onChange: (m) => saveUserRowHeight(vid, DENSITY_MODE_TO_ROW_HEIGHT[m]),
  * });
  * ```
  */

package/dist/hooks/useDensityMode.js

@@ -35,8 +35,14 @@ const DENSITY_ORDER = ['compact', 'comfortable', 'spacious'];
  *
  * @example
  * ```tsx
- * const density = useDensityMode(activeView?.densityMode ?? 'comfortable', {
- *   onChange: (m) => dataSource.updateViewConfig(obj, vid, { densityMode: m }),
+ * import { DENSITY_MODE_TO_ROW_HEIGHT, rowHeightToDensityMode } from '@object-ui/core';
+ *
+ * // A view stores the protocol's `rowHeight`; the legacy `densityMode` key is
+ * // retired on `NamedListView` (objectui#7924), so persist the spec value —
+ * // here into the host's own per-user store (`saveUserRowHeight` is the
+ * // host's; the console keeps the choice on the user's own list state).
+ * const density = useDensityMode(rowHeightToDensityMode(activeView?.rowHeight) ?? 'comfortable', {
+ *   onChange: (m) => saveUserRowHeight(vid, DENSITY_MODE_TO_ROW_HEIGHT[m]),
  * });
  * ```
  */

package/dist/hooks/useDiscovery.d.ts

@@ -40,17 +40,8 @@ export interface DiscoveryInfo {
     /** Server name and version */
     name?: string;
     version?: string;
-    /** Runtime mode (e.g., 'development', 'production', 'preview') */
+    /** Runtime mode the server reports (`RuntimeMode` in `@objectstack/spec`) */
     mode?: string;
-    /** Preview mode configuration from the kernel (present when mode is 'preview') */
-    previewMode?: {
-        autoLogin?: boolean;
-        simulatedRole?: 'admin' | 'user' | 'viewer';
-        simulatedUserName?: string;
-        readOnly?: boolean;
-        expiresInSeconds?: number;
-        bannerMessage?: string;
-    };
     /** Service availability status */
     services?: {
         /** Authentication service status */

package/dist/hooks/useETagCache.js

@@ -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 { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useInsertionEffect, useMemo, useRef, useState } from 'react';
 // ---------------------------------------------------------------------------
 // Defaults
 // ---------------------------------------------------------------------------
@@ -141,9 +141,30 @@ export function useETagCache(userConfig = {}) {
     const swUrl = userConfig.serviceWorkerUrl ?? DEFAULTS.serviceWorkerUrl;
     const [cacheSize, setCacheSize] = useState(0);
     const [serviceWorkerActive, setServiceWorkerActive] = useState(false);
-    // Keep config in a ref so callbacks always see latest values
-    const configRef = useRef({ enabled, storage, storagePrefix, maxEntries, ttl });
-    configRef.current = { enabled, storage, storagePrefix, maxEntries, ttl };
+    // Keep config in a ref so callbacks always see latest values. Every reader
+    // below is a `useCallback` with `[]` deps whose identity consumers may key
+    // effects on, so the config has to reach them without changing it — that is
+    // the ref's job. Only the WRITE moves: done in the render body it also ran
+    // for renders React discards or replays, publishing config from a tree that
+    // never committed. `useInsertionEffect` runs in the mutation phase, ahead of
+    // every layout effect, ref attachment and paint, so the sole window deferred
+    // is the render phase — where `fetchWithETag` / `clearCache` and the other
+    // side effects are not callable anyway.
+    //
+    // The object itself is built by `useMemo` rather than inline at the two
+    // places that consume it. `useRef({ ... })` evaluates its argument on EVERY
+    // render and keeps only the first result, so every later render allocated a
+    // five-key object that was thrown away (objectui#6817) — the same shape PR
+    // objectui#6796 repaired in `useSchemaPersistence`. Its identity is
+    // unobservable from outside the hook: the ref is private and every reader
+    // only reads fields off `.current`, so a memo React chooses to discard is
+    // harmless — it rebuilds an equal object, which is what every render used
+    // to do unconditionally.
+    const config = useMemo(() => ({ enabled, storage, storagePrefix, maxEntries, ttl }), [enabled, storage, storagePrefix, maxEntries, ttl]);
+    const configRef = useRef(config);
+    useInsertionEffect(() => {
+        configRef.current = config;
+    });
     // Hydrate memory cache from localStorage on mount
     useEffect(() => {
         if (storage === 'localStorage') {

package/dist/hooks/useElementDataSource.d.ts

@@ -19,7 +19,7 @@
  * still ignores `view`), and the remaining object-bound blocks will need the same
  * resolution. One resolver in the runtime layer, not one per plugin.
  */
-import { type ComposedElementDataSource, type ElementDataSourceConfig, type ElementSavedView } from '@object-ui/core';
+import { FilterOperatorError, type ComposedElementDataSource, type ElementDataSourceConfig, type ElementSavedView } from '@object-ui/core';
 /**
  * Where a resolution attempt stands. Distinguishing `loading` from `missing`
  * matters: a component that treated "not resolved yet" as "does not exist" would
@@ -34,7 +34,12 @@ export type ElementDataSourceStatus =
  | 'loading'
 /** The named `view` was found and composed in. */
  | 'resolved'
-/** The named `view` does not exist on the object (or could not be read). */
+/**
+ * The binding cannot be applied: the named `view` does not exist on the
+ * object (or could not be read), or a filter it combines is REFUSED by the
+ * filter converter — then `filterRefusal` carries the refusal (objectui#10789).
+ * Either way `composed` is withheld, so no query runs without the filter.
+ */
  | 'missing';
 export interface UseElementDataSourceResult {
     status: ElementDataSourceStatus;
@@ -50,6 +55,14 @@ export interface UseElementDataSourceResult {
     view?: ElementSavedView;
     /** Author-facing explanation, set only for `missing`. */
     error?: string;
+    /**
+     * Why the binding could not be composed, when the reason is a refused
+     * filter — set only with `missing`, and `error` then carries its message
+     * (objectui#10789). A caller that draws the malformed-filter notice reads the
+     * refused operator or field off it (`filterRefusalSubject`) rather than
+     * scraping `error`.
+     */
+    filterRefusal?: FilterOperatorError;
 }
 /**
  * Resolve a schema node's `dataSource` binding, fetching the named saved view.

package/dist/hooks/useElementDataSource.js

@@ -20,7 +20,7 @@
  * resolution. One resolver in the runtime layer, not one per plugin.
  */
 import { useContext, useEffect, useMemo, useState } from 'react';
-import { collectSavedViews, composeElementDataSource, elementDataSourceViewNotFoundMessage, isElementDataSourceConfig, resolveSavedView, } from '@object-ui/core';
+import { collectSavedViews, composeElementDataSource, elementDataSourceViewNotFoundMessage, FilterOperatorError, isElementDataSourceConfig, resolveSavedView, } from '@object-ui/core';
 import { SchemaRendererContext } from '../context/SchemaRendererContext.js';
 const isRecord = (v) => !!v && typeof v === 'object';
 /**
@@ -71,6 +71,9 @@ async function fetchSavedViews(dataSource, object) {
  * ```
  */
 export function useElementDataSource(schema, dataSource) {
+    // Read AS DECLARED (objectui#7209) — no cast between the hook and the value,
+    // so a member the context does not declare is a compile error here. Pinned by
+    // `useElementDataSource.schemaRendererContextRead-7209.test.ts`.
     const context = useContext(SchemaRendererContext);
     const adapter = (dataSource ?? context?.dataSource ?? null);
     const config = useMemo(() => {
@@ -131,11 +134,25 @@ export function useElementDataSource(schema, dataSource) {
             return { status: 'loading', config };
         if (resolved.view === null)
             return { status: 'missing', config, error: resolved.error };
-        return {
-            status: 'resolved',
-            config,
-            view: resolved.view,
-            composed: composeElementDataSource(config, resolved.view),
-        };
+        // objectui#10789 — composing the view's filter with the binding's own is a
+        // MERGE, and the merge lowers both through the throwing converter form.
+        // This is a render-time `useMemo`, so an uncaught refusal was a render
+        // error: the block's error boundary instead of a sentence naming the
+        // operator. The refusal is kept as a VALUE and reported as `missing`,
+        // which every caller already answers by withholding the query — never as
+        // `undefined`, which would read as "no filter" and widen the read. Only a
+        // `FilterOperatorError` is caught, the rule `toFilterNodeSafely` states:
+        // anything else is a defect, not a statement about the author's filter.
+        // (The `ready` branch above composes no view, so nothing is merged there.)
+        let composed;
+        try {
+            composed = composeElementDataSource(config, resolved.view);
+        }
+        catch (error) {
+            if (!(error instanceof FilterOperatorError))
+                throw error;
+            return { status: 'missing', config, error: error.message, filterRefusal: error };
+        }
+        return { status: 'resolved', config, view: resolved.view, composed };
     }, [config, resolved, requestKey]);
 }

package/dist/hooks/useExpression.d.ts

@@ -60,56 +60,49 @@ export { toPredicateInput } from '@object-ui/core';
  * Build the predicate context for a **row record** — the bag to hand
  * {@link useCondition} when the thing being gated is scoped to one record.
  *
- * The row is bound the THREE ways the platform's row surfaces bind it:
- * `record.status` (spec/canonical), bare `status` (row-action shorthand), and
- * `data.status` (legacy). This is not three dialects; it is one rule, and it is
- * `evalRowPredicate`'s rule (`core/evaluator/listConditional.ts` — the record
- * header, list rows, the row kebab and conditional formatting all evaluate
- * through it), restated here for the `useCondition` tier so both tiers answer
- * an author's `visible:` the same way.
- *
- * ## Why a helper and not "just spread the row" (objectui#4075)
- *
- * `useCondition` evaluates on `new ExpressionEvaluator({ ...scope, ...context })`,
- * so a caller that passes the row spread flat resolves the shorthand spelling
- * and NOTHING else. The canonical spelling is the `record.` root — it is what
- * `ExpressionEvaluator`'s CEL path binds (`bag.record` as the record
- * namespace), what `evalRowPredicate` binds, and what the server enforces
- * with. Under a root-only bag `record.viewer.can_act` does not read as `false`:
- * the evaluator throws `record is not defined`, and a fail-closed `visible`
- * turns that throw into "hidden". A correctly-authored predicate then deletes
- * its own button, indistinguishably from the gate having said no.
- *
- * That was live, not theoretical: every declared action on framework's
- * `sys_approval_request` gates on `record.viewer.*` (framework#3310 / #3424),
- * so the whole server-declared approval decision set was invisible wherever
- * `DeclaredActionsBar` rendered until objectui#4077 bound the row this way —
- * and the four generic action renderers carried the same root-only binding
- * until objectui#4075.
- *
- * ## The canon is `record.*` (objectui#5330, ruled 2026-08-20)
- *
- * All three spellings are bound here, and that is unchanged — but they are NOT
- * peers. `record.*` is the CONTRACT; the bare shorthand and `data.*` are
- * tolerances in a deprecation window, kept because stored metadata carries
- * them, reported once by `warnNonCanonicalRowSpelling` from `useCondition`
- * below, and removable only after a stored-metadata survey sizes the window
- * (⛔ no removal before the survey — part of the same ruling).
- *
- * The canon states the SERVER's accept set, which is narrower than this bag:
- * measured on `@objectstack/formula@17.1.0`, `buildScope({ record })` mounts
- * exactly `['record']`, so of the three spellings this helper binds, only
- * `record.*` evaluates server-side — a bare field faults `Unknown variable:
- * status` and `data.*` faults `Unknown variable: data`. This three-way bag has
- * no server counterpart at all, which is exactly why the warning belongs on
- * this side. `@object-ui/core`'s `evaluator/rowPredicateCanon.ts` carries the
- * full measurement and the layer scoping (`data` stays canonical one layer
- * over, in a metadata-editing form — ADR-0089 D3).
- *
- * `record` and `data` are written AFTER the spread deliberately: a row that
- * happens to carry a field literally named `record` or `data` must not shadow
- * the root every predicate is written against. Same precedence as
- * `evalRowPredicate`.
+ * The row is bound ONE way: `record.status` — the canon (objectui#5330, ruled
+ * 2026-08-20; Phase 2 executed by `83fe6e741`). This is not a dialect choice;
+ * it is one rule, and it is `evalRowPredicate`'s rule
+ * (`core/evaluator/listConditional.ts` — the record header, list rows, the row
+ * kebab and conditional formatting all evaluate through it), restated here for
+ * the `useCondition` tier so both tiers answer an author's `visible:` the same
+ * way.
+ *
+ * ## The two retired spellings (`83fe6e741`)
+ *
+ * Until Phase 2 this bag also carried the row spread flat (bare `status`, the
+ * row-action shorthand) and as `data` (legacy), and `useCondition` below warned
+ * once per non-canonical spelling (Phase 1, `d1ab06f0f`). Both bindings and the
+ * warning are gone. A bare-field or `data.*` predicate against this bag now
+ * faults exactly as it always did on the server (`buildScope({ record })`
+ * mounts exactly `['record']`: `Unknown variable: status` / `Unknown variable:
+ * data`), and each `useCondition` leg applies its EXISTING fault policy — the
+ * throwing legs (`throwOnError`: every action `visible` — `action:button`,
+ * `action:menu`, `action:bar`, `DeclaredActionsBar`, and since objectui#11212
+ * `action:group`, `action:icon` and the related-list toolbar) hide and report
+ * `was hidden/disabled: its predicate threw`, naming the variable; the
+ * non-throwing legs fail soft to `true`. The same holds for a legacy `${data.x}` / `${x}` string: one bag
+ * shape, both dialects. Nothing detects a retired spelling here; it is simply
+ * unbound. `@object-ui/core`'s `evaluator/rowPredicateCanon.ts` carries the
+ * canon statement, the server measurement, the layer scoping (`data` stays
+ * canonical one layer over, in a metadata-editing form — ADR-0089 D3) and the
+ * offline detector.
+ *
+ * ## Why a helper and not "just `{ record }`" (objectui#4075 / #4080)
+ *
+ * Because the rule has two halves and every predicate face has to get both:
+ * the SHAPE — `record` is the row's one name, so `record.viewer.can_act`, what
+ * every declared action on framework's `sys_approval_request` gates on
+ * (framework#3310 / objectstack-ai/objectstack#3424), reaches the row — and the NO-ROW case below.
+ * `DeclaredActionsBar` and the four generic action renderers once carried
+ * inline copies of this bag and drifted (objectui#4077 / #4079); one named
+ * helper is what keeps a fifth copy from drifting again.
+ *
+ * Note the direction of the merge: `useCondition` evaluates on
+ * `new ExpressionEvaluator({ ...scope, ...context })`, so this bag's `record`
+ * shadows an ambient `record` a host put in the predicate scope — the row is
+ * the subject — while every OTHER ambient key (`features`, `user`, a host's own
+ * `data`) survives to the predicate as the host's own.
  *
  * This is the BINDING rule only. It deliberately does not touch the evaluation
  * entry — `useCondition` / `toPredicateInput` / `hasDeclaredVisibilityGate`
@@ -121,10 +114,10 @@ export { toPredicateInput } from '@object-ui/core';
  * ## No row → bind NOTHING, do not bind an empty one
  *
  * `null` / `undefined` / a non-object returns an EMPTY bag, not
- * `{ record: {}, data: {} }`. The difference is load-bearing: `useCondition`
- * merges this context OVER the ambient predicate scope, so binding an empty
- * record would blank out a `record` that a host had put in the scope itself —
- * which is exactly how `action:group`'s dropdown leaf is driven in
+ * `{ record: {} }`. The difference is load-bearing: `useCondition` merges this
+ * context OVER the ambient predicate scope, so binding an empty record would
+ * blank out a `record` that a host had put in the scope itself — which is
+ * exactly how `action:group`'s dropdown leaf is driven in
  * `action-group-dropdown-visible.test.tsx`, and it is a legitimate way for a
  * host to supply the row. "This surface has no row of its own" must stay
  * distinct from "this surface's row is empty"; only the latter is entitled to
@@ -159,11 +152,11 @@ export declare function useCondition(condition: string | boolean | undefined | {
  * routes to `@object-ui/core`'s `evalRowPredicate`: a bare string is CEL (the
  * spec contract for `ActionSchema.visible`), a `{ dialect: 'cel', source }`
  * envelope is always CEL, and only a legacy-dialect string falls back to the
- * old engine (with a deprecation warning). The row is bound as `record.*` — the
- * CANON (objectui#5330) — and, for stored metadata only, as bare fields and
- * `data.*`, both of which now warn once; the ambient predicate scope
- * (`features` / `user` / …) is merged alongside so deployment-level gates keep
- * resolving.
+ * old engine (with a deprecation warning). The row is bound as `record.*` only
+ * — the canon (objectui#5330; the bare-field and `data.*` spellings retired in
+ * `83fe6e741` and fault here like any unknown variable); the ambient
+ * predicate scope (`features` / `user` / …) is merged alongside so
+ * deployment-level gates keep resolving.
  *
  * @param pred     The raw predicate: `boolean` (returned as-is), a CEL string,
  *                 an `{ dialect, source }` envelope, or `null`/`undefined`/`''`.

package/dist/hooks/useExpression.js

@@ -6,12 +6,14 @@
  * LICENSE file in the root directory of this source tree.
  */
 import { createContext, createElement, useContext, useMemo } from 'react';
-import { ExpressionEvaluator, evalRowPredicate, isLegacyDialectSource, warnNonCanonicalRowSpelling, } from '@object-ui/core';
+import { ExpressionEvaluator, evalRowPredicate } from '@object-ui/core';
 /**
  * Global predicate scope — populated by host shells (e.g. app-shell's
  * `ExpressionProvider`) so renderers like action buttons can resolve
- * deployment-level flags (`features`, `user`, `app`, …) without needing
- * to import the host shell directly.
+ * deployment-level flags (`features`, `user`, …) without needing
+ * to import the host shell directly. (⛔ Not `app`: objectui#8155 removed that
+ * root from `buildExpressionScope`, so no host shell in this repo publishes
+ * one.)
  *
  * `useCondition` / `useExpression` merge this scope under the
  * locally-passed `context`, so per-row `record` overrides still win.
@@ -74,56 +76,49 @@ export { toPredicateInput } from '@object-ui/core';
  * Build the predicate context for a **row record** — the bag to hand
  * {@link useCondition} when the thing being gated is scoped to one record.
  *
- * The row is bound the THREE ways the platform's row surfaces bind it:
- * `record.status` (spec/canonical), bare `status` (row-action shorthand), and
- * `data.status` (legacy). This is not three dialects; it is one rule, and it is
- * `evalRowPredicate`'s rule (`core/evaluator/listConditional.ts` — the record
- * header, list rows, the row kebab and conditional formatting all evaluate
- * through it), restated here for the `useCondition` tier so both tiers answer
- * an author's `visible:` the same way.
+ * The row is bound ONE way: `record.status` — the canon (objectui#5330, ruled
+ * 2026-08-20; Phase 2 executed by `83fe6e741`). This is not a dialect choice;
+ * it is one rule, and it is `evalRowPredicate`'s rule
+ * (`core/evaluator/listConditional.ts` — the record header, list rows, the row
+ * kebab and conditional formatting all evaluate through it), restated here for
+ * the `useCondition` tier so both tiers answer an author's `visible:` the same
+ * way.
  *
- * ## Why a helper and not "just spread the row" (objectui#4075)
+ * ## The two retired spellings (`83fe6e741`)
  *
- * `useCondition` evaluates on `new ExpressionEvaluator({ ...scope, ...context })`,
- * so a caller that passes the row spread flat resolves the shorthand spelling
- * and NOTHING else. The canonical spelling is the `record.` root — it is what
- * `ExpressionEvaluator`'s CEL path binds (`bag.record` as the record
- * namespace), what `evalRowPredicate` binds, and what the server enforces
- * with. Under a root-only bag `record.viewer.can_act` does not read as `false`:
- * the evaluator throws `record is not defined`, and a fail-closed `visible`
- * turns that throw into "hidden". A correctly-authored predicate then deletes
- * its own button, indistinguishably from the gate having said no.
+ * Until Phase 2 this bag also carried the row spread flat (bare `status`, the
+ * row-action shorthand) and as `data` (legacy), and `useCondition` below warned
+ * once per non-canonical spelling (Phase 1, `d1ab06f0f`). Both bindings and the
+ * warning are gone. A bare-field or `data.*` predicate against this bag now
+ * faults exactly as it always did on the server (`buildScope({ record })`
+ * mounts exactly `['record']`: `Unknown variable: status` / `Unknown variable:
+ * data`), and each `useCondition` leg applies its EXISTING fault policy — the
+ * throwing legs (`throwOnError`: every action `visible` — `action:button`,
+ * `action:menu`, `action:bar`, `DeclaredActionsBar`, and since objectui#11212
+ * `action:group`, `action:icon` and the related-list toolbar) hide and report
+ * `was hidden/disabled: its predicate threw`, naming the variable; the
+ * non-throwing legs fail soft to `true`. The same holds for a legacy `${data.x}` / `${x}` string: one bag
+ * shape, both dialects. Nothing detects a retired spelling here; it is simply
+ * unbound. `@object-ui/core`'s `evaluator/rowPredicateCanon.ts` carries the
+ * canon statement, the server measurement, the layer scoping (`data` stays
+ * canonical one layer over, in a metadata-editing form — ADR-0089 D3) and the
+ * offline detector.
  *
- * That was live, not theoretical: every declared action on framework's
- * `sys_approval_request` gates on `record.viewer.*` (framework#3310 / #3424),
- * so the whole server-declared approval decision set was invisible wherever
- * `DeclaredActionsBar` rendered until objectui#4077 bound the row this way —
- * and the four generic action renderers carried the same root-only binding
- * until objectui#4075.
+ * ## Why a helper and not "just `{ record }`" (objectui#4075 / #4080)
  *
- * ## The canon is `record.*` (objectui#5330, ruled 2026-08-20)
+ * Because the rule has two halves and every predicate face has to get both:
+ * the SHAPE — `record` is the row's one name, so `record.viewer.can_act`, what
+ * every declared action on framework's `sys_approval_request` gates on
+ * (framework#3310 / objectstack-ai/objectstack#3424), reaches the row — and the NO-ROW case below.
+ * `DeclaredActionsBar` and the four generic action renderers once carried
+ * inline copies of this bag and drifted (objectui#4077 / #4079); one named
+ * helper is what keeps a fifth copy from drifting again.
  *
- * All three spellings are bound here, and that is unchanged — but they are NOT
- * peers. `record.*` is the CONTRACT; the bare shorthand and `data.*` are
- * tolerances in a deprecation window, kept because stored metadata carries
- * them, reported once by `warnNonCanonicalRowSpelling` from `useCondition`
- * below, and removable only after a stored-metadata survey sizes the window
- * (⛔ no removal before the survey — part of the same ruling).
- *
- * The canon states the SERVER's accept set, which is narrower than this bag:
- * measured on `@objectstack/formula@17.1.0`, `buildScope({ record })` mounts
- * exactly `['record']`, so of the three spellings this helper binds, only
- * `record.*` evaluates server-side — a bare field faults `Unknown variable:
- * status` and `data.*` faults `Unknown variable: data`. This three-way bag has
- * no server counterpart at all, which is exactly why the warning belongs on
- * this side. `@object-ui/core`'s `evaluator/rowPredicateCanon.ts` carries the
- * full measurement and the layer scoping (`data` stays canonical one layer
- * over, in a metadata-editing form — ADR-0089 D3).
- *
- * `record` and `data` are written AFTER the spread deliberately: a row that
- * happens to carry a field literally named `record` or `data` must not shadow
- * the root every predicate is written against. Same precedence as
- * `evalRowPredicate`.
+ * Note the direction of the merge: `useCondition` evaluates on
+ * `new ExpressionEvaluator({ ...scope, ...context })`, so this bag's `record`
+ * shadows an ambient `record` a host put in the predicate scope — the row is
+ * the subject — while every OTHER ambient key (`features`, `user`, a host's own
+ * `data`) survives to the predicate as the host's own.
  *
  * This is the BINDING rule only. It deliberately does not touch the evaluation
  * entry — `useCondition` / `toPredicateInput` / `hasDeclaredVisibilityGate`
@@ -135,10 +130,10 @@ export { toPredicateInput } from '@object-ui/core';
  * ## No row → bind NOTHING, do not bind an empty one
  *
  * `null` / `undefined` / a non-object returns an EMPTY bag, not
- * `{ record: {}, data: {} }`. The difference is load-bearing: `useCondition`
- * merges this context OVER the ambient predicate scope, so binding an empty
- * record would blank out a `record` that a host had put in the scope itself —
- * which is exactly how `action:group`'s dropdown leaf is driven in
+ * `{ record: {} }`. The difference is load-bearing: `useCondition` merges this
+ * context OVER the ambient predicate scope, so binding an empty record would
+ * blank out a `record` that a host had put in the scope itself — which is
+ * exactly how `action:group`'s dropdown leaf is driven in
  * `action-group-dropdown-visible.test.tsx`, and it is a legitimate way for a
  * host to supply the row. "This surface has no row of its own" must stay
  * distinct from "this surface's row is empty"; only the latter is entitled to
@@ -150,8 +145,7 @@ export function usePredicateRecordContext(record) {
     return useMemo(() => {
         if (record == null || typeof record !== 'object' || Array.isArray(record))
             return {};
-        const row = record;
-        return { ...row, record: row, data: row };
+        return { record: record };
     }, [record]);
 }
 /**
@@ -188,37 +182,11 @@ export function useCondition(condition, context = {}, options) {
     const scope = usePredicateScope();
     // We evaluate directly without caching the evaluator to avoid issues with context changes
     return useMemo(() => {
-        // objectui#5330 Phase 1 — report a deprecated row-predicate spelling on
-        // the `useCondition` tier. This is the BINDING half's evaluation entry:
-        // `usePredicateRecordContext` sees the row but never the predicate text,
-        // so it structurally cannot detect a spelling, and this is the first
-        // point where the two meet.
-        //
-        // Two guards, both of which can only remove a report:
-        //  - the bag must carry the `usePredicateRecordContext` signature, `data`
-        //    and `record` being the SAME object by identity. A host scope that
-        //    merely happens to carry a `data` key cannot satisfy that, so a
-        //    non-row `useCondition` call is never judged as a row predicate.
-        //  - the source must be CEL. In this tier's legacy `${…}` dialect
-        //    (`'${data.status === "active"}'` — this hook's own doc example)
-        //    `data.*` is the NORMAL spelling, and reporting it would be a false
-        //    positive on every legacy predicate.
-        const bag = context;
-        const boundRow = bag.record != null && typeof bag.record === 'object' && bag.record === bag.data
-            ? bag.record
-            : undefined;
-        if (boundRow !== undefined) {
-            const celSource = typeof condition === 'string'
-                ? isLegacyDialectSource(condition)
-                    ? undefined
-                    : condition
-                : condition && typeof condition === 'object' && condition.dialect === 'cel'
-                    ? condition.source
-                    : undefined;
-            if (typeof celSource === 'string') {
-                warnNonCanonicalRowSpelling(celSource, boundRow, true, options?.label);
-            }
-        }
+        // No row-spelling detector on this tier (`83fe6e741` removed the
+        // Phase-1 warning with the bindings): a retired bare-field / `data.*`
+        // spelling against a `usePredicateRecordContext` bag is simply unbound
+        // and faults like any other unknown variable, and each leg's existing
+        // fault report below is what names it.
         const evaluator = new ExpressionEvaluator({ ...scope, ...context });
         if (options?.throwOnError) {
             // Fail-closed: a predicate that can't be evaluated hides/disables
@@ -256,11 +224,11 @@ export function useCondition(condition, context = {}, options) {
  * routes to `@object-ui/core`'s `evalRowPredicate`: a bare string is CEL (the
  * spec contract for `ActionSchema.visible`), a `{ dialect: 'cel', source }`
  * envelope is always CEL, and only a legacy-dialect string falls back to the
- * old engine (with a deprecation warning). The row is bound as `record.*` — the
- * CANON (objectui#5330) — and, for stored metadata only, as bare fields and
- * `data.*`, both of which now warn once; the ambient predicate scope
- * (`features` / `user` / …) is merged alongside so deployment-level gates keep
- * resolving.
+ * old engine (with a deprecation warning). The row is bound as `record.*` only
+ * — the canon (objectui#5330; the bare-field and `data.*` spellings retired in
+ * `83fe6e741` and fault here like any unknown variable); the ambient
+ * predicate scope (`features` / `user` / …) is merged alongside so
+ * deployment-level gates keep resolving.
  *
  * @param pred     The raw predicate: `boolean` (returned as-is), a CEL string,
  *                 an `{ dialect, source }` envelope, or `null`/`undefined`/`''`.