@object-ui/react 17.6.0 → 17.7.0

package/dist/element-data-source/ElementDataSourceGate.d.ts

@@ -50,6 +50,27 @@
  * designer emits for an unconfigured column list, and supplying the columns is
  * exactly why a view was named.
  *
+ * The row cap answers "did the component author one?" the same way, and for the
+ * same reason (objectui#9899). A cap the contract REFUSES — `pageSize: 0`,
+ * a negative, a fraction — is not a cap this relay may treat as the author's
+ * intent, so it does not suppress the one the bound view supplies. Deciding
+ * that question by PRESENCE is how a view's legitimate cap was dropped in
+ * favour of the consuming renderer's own default: measured end to end on
+ * `list-view` before the repair, a component carrying `pagination.pageSize: 0`
+ * under a view supplying `7` put `$top: 100` on the wire — the view's cap never
+ * reached it, so the read was WIDER than the view asked for.
+ *
+ * The VIEW's own cap can be refused too, and `@object-ui/core` drops it before
+ * it reaches this relay (objectui#9928). The drop is right, but it left the
+ * consuming renderer nothing to refuse, so it went silent — and this relay
+ * reports the view's refusal instead (objectui#10015). See
+ * {@link describeRefusedViewRowLimit} for when that message applies.
+ *
+ * The BINDING's own cap follows the same rule (objectui#10016): a `limit` the
+ * contract refuses is not authored, so `@object-ui/core` lets the view's cap
+ * through in its place, and that cap is a baseline here like any other
+ * view-sourced value. See {@link describeRefusedBindingRowLimit}.
+ *
  * ## What a mapping may NOT do
  *
  * {@link ElementDataSourceMapping} names only keys the target block genuinely
@@ -79,7 +100,7 @@
  * like it works.
  */
 import * as React from 'react';
-import { type ElementDataSourceConfig } from '@object-ui/core';
+import { type ElementDataSourceConfig, type FilterOperatorError } from '@object-ui/core';
 import { type ElementDataSourceStatus } from '../hooks/useElementDataSource.js';
 /**
  * Where a block's row cap lives. Three spellings are real in this repo and each
@@ -139,6 +160,15 @@ export interface UseElementDataSourceSchemaResult<S> {
     config?: ElementDataSourceConfig;
     /** Author-facing explanation, set only for `missing`. */
     error?: string;
+    /**
+     * The refused filter that stopped the binding from applying — set only with
+     * `missing`, and `error` then carries its message (objectui#10789). Either
+     * merge can refuse: the view's filter with the binding's own
+     * ({@link useElementDataSource}), or the component's filter with that result
+     * (this hook). {@link ElementDataSourceGate} draws the malformed-filter
+     * notice from it.
+     */
+    filterRefusal?: FilterOperatorError;
 }
 /**
  * Resolve a block's `dataSource` binding and apply it to the block's own schema
@@ -225,6 +255,63 @@ export declare function noDataSourceMessage(blockKey: string, objectName?: unkno
  * metadata is answerable, so the answer is rendered where the author can see it.
  */
 export declare function NoDataSourcePanel({ testId, title, message, }: ElementDataSourceStatusPanelProps): React.ReactElement;
+/**
+ * The wrapping seam — mark `renderer` as one that wraps {@link
+ * ElementDataSourceGate}, so its registrations DECLARE the `dataSource` key this
+ * gate READS (objectui#6678).
+ *
+ * ```tsx
+ * export const ObjectMapRenderer = elementDataSourceBlock<React.FC<any>>(({ schema }) => (
+ *   <ElementDataSourceGate schema={schema} testId="object-map" …>
+ *     {(bound) => <ObjectMap schema={bound} />}
+ *   </ElementDataSourceGate>
+ * ));
+ * ```
+ *
+ * ## What this closes
+ *
+ * `PageComponentSchema.dataSource` is the one spelling that resolves a saved
+ * view for an object-bound block. It works — and because no registration
+ * declared it, `sdui-parser`'s `validateTree` reported it with the SAME
+ * `unknown-prop` warning it gives the spellings that do nothing. On the tier
+ * built to accept AI-authored pages the diagnostic IS the contract, so the
+ * tier's only signal pointed away from the one key that works.
+ *
+ * ## Why a seam and not nine declarations
+ *
+ * Maintainer ruling, 2026-08-29: option B **in the injection form**. Nine
+ * hand-written copies across nine packages is the shape that ruling refused —
+ * they drift, and the tenth block forgets. Passing through here is the only
+ * thing a block does; `Registry.register` emits the declaration
+ * (`withElementDataSourceInput`), and `ELEMENT_DATA_SOURCE_INPUT` in
+ * `@object-ui/core` is its single copy, beside the binding's own semantics.
+ *
+ * ## And it cannot be forgotten
+ *
+ * `scripts/check-element-data-source-declaration.mjs` fails any source that
+ * renders `ElementDataSourceGate` for a registration without passing that
+ * registration's renderer through this function. That is the mechanical half of
+ * "a tenth block gets it automatically"; this function is the seam it enforces.
+ *
+ * Returns the renderer UNCHANGED (the mark is held in a `WeakSet`), so it is safe
+ * over a `React.forwardRef` object, over `React.memo`, and over a component that
+ * something else already re-exports by reference.
+ *
+ * ⚠️ Re-exported from `@object-ui/core` — where the marker and the declaration
+ * live — rather than wrapped here: ONE function under ONE name. This export
+ * exists for DISCOVERABILITY, so the seam is findable beside the gate it is
+ * about; **call sites must import it from `@object-ui/core`**, and
+ * `check:element-data-source-declaration` enforces that.
+ *
+ * The rule is measured, not stylistic. A registration runs at MODULE SCOPE, 101
+ * suites in this repo partially mock `@object-ui/react` by hand-listing the
+ * exports they return, and a module-scope read of a name absent from such a list
+ * throws at COLLECTION time — the importing test file dies before running one
+ * assertion. Taking the seam from here reddened 17 files across all four CI
+ * shards with zero failed assertions among them. Nothing mocks `@object-ui/core`,
+ * and every registration module already imports `ComponentRegistry` from it.
+ */
+export { elementDataSourceBlock } from '@object-ui/core';
 export interface ElementDataSourceGateProps<S> {
     /** The block's schema node. */
     schema: S;

package/dist/element-data-source/ElementDataSourceGate.js

@@ -51,6 +51,27 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * designer emits for an unconfigured column list, and supplying the columns is
  * exactly why a view was named.
  *
+ * The row cap answers "did the component author one?" the same way, and for the
+ * same reason (objectui#9899). A cap the contract REFUSES — `pageSize: 0`,
+ * a negative, a fraction — is not a cap this relay may treat as the author's
+ * intent, so it does not suppress the one the bound view supplies. Deciding
+ * that question by PRESENCE is how a view's legitimate cap was dropped in
+ * favour of the consuming renderer's own default: measured end to end on
+ * `list-view` before the repair, a component carrying `pagination.pageSize: 0`
+ * under a view supplying `7` put `$top: 100` on the wire — the view's cap never
+ * reached it, so the read was WIDER than the view asked for.
+ *
+ * The VIEW's own cap can be refused too, and `@object-ui/core` drops it before
+ * it reaches this relay (objectui#9928). The drop is right, but it left the
+ * consuming renderer nothing to refuse, so it went silent — and this relay
+ * reports the view's refusal instead (objectui#10015). See
+ * {@link describeRefusedViewRowLimit} for when that message applies.
+ *
+ * The BINDING's own cap follows the same rule (objectui#10016): a `limit` the
+ * contract refuses is not authored, so `@object-ui/core` lets the view's cap
+ * through in its place, and that cap is a baseline here like any other
+ * view-sourced value. See {@link describeRefusedBindingRowLimit}.
+ *
  * ## What a mapping may NOT do
  *
  * {@link ElementDataSourceMapping} names only keys the target block genuinely
@@ -80,9 +101,135 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * like it works.
  */
 import * as React from 'react';
-import { isElementDataSourceConfig, mergeFilterNodes, } from '@object-ui/core';
+import { elementDataSourceRefusedLimitMessage, filterRefusalSubject, isElementDataSourceConfig, mergeFilterNodes, toFilterNodeSafely, } from '@object-ui/core';
+import { useObjectTranslation } from '@object-ui/i18n';
 import { useElementDataSource, } from '../hooks/useElementDataSource.js';
 import { SchemaRendererContext } from '../context/SchemaRendererContext.js';
+/**
+ * What the contract admits as a row cap (objectui#9899).
+ *
+ * `@objectstack/spec` has already answered what `0` means for the keys this
+ * branch writes. Its view pagination config declares `pageSize` a positive
+ * integer with a default; every component row cap its component props map
+ * declares is `z.number().int().positive()`; and that flat `limit` is the key a
+ * view's `pagination.pageSize` is LOWERED INTO for the blocks that read it. So
+ * `0`, a negative and a fraction are not spellings this relay may assign a
+ * meaning to — they are values the contract refuses.
+ *
+ * ⚠️ Said precisely, because it is easy to overstate: the `object-grid` props
+ * face declares its OWN `pagination` key `z.unknown()`, so a save gate does not
+ * refuse a component-level `pagination.pageSize: 0` on that face, and the flat
+ * `pageSize` shorthand beside it is a bare `z.number()`. The refusal rests on
+ * the pagination CONFIG contract and on the `limit` the value is lowered into —
+ * the same ground objectui#9853, objectui#9897 and objectui#9925 already stood
+ * on at the renderer sites.
+ *
+ * ⛔ Deliberately a LOCAL restatement of the predicate objectui#9925 landed at
+ * the renderer sites, not an import and not a shared helper: hoisting it would
+ * be a cross-package extraction this card may not make. The cost is stated
+ * rather than hidden — one rule now has a spelling at every site that enforces
+ * it, and `git grep 'isUsableRowLimit\|isUsablePageSize'` is what enumerates
+ * them; the day one is meant to change, all of them are.
+ */
+function isUsableRowLimit(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0;
+}
+/**
+ * The loud half, and the reason a RELAY owes one at all.
+ *
+ * A relay that merely declines to treat a value as authored could reasonably
+ * say nothing — the renderer it forwards to has its own refusal and its own
+ * message. Measured rather than assumed: BEFORE this repair, a `list-view`
+ * carrying `pagination.pageSize: 0` under a bound view was told about it, once,
+ * by `ListView`'s own diagnostic. AFTER it, the gate writes the view's usable
+ * cap, that renderer sees a value it accepts, and its message correctly goes
+ * silent — so the repair REMOVES the only place the author was being told.
+ * This restores that one message at the layer that now makes the decision.
+ *
+ * ⛔ NOT a second guard: the predicate lives once, in {@link isUsableRowLimit},
+ * and this reads it. `null` means "nothing to say" — an absent cap is not a
+ * mistake and a usable one is not either, which is what keeps this from
+ * becoming an always-on marker that states nothing.
+ */
+const describeDisplacedRowLimit = (authored, key, used, componentType, objectName) => {
+    if (authored === undefined || authored === null)
+        return null;
+    if (isUsableRowLimit(authored))
+        return null;
+    const type = typeof componentType === 'string' && componentType ? componentType : 'component';
+    const where = typeof objectName === 'string' && objectName ? `${type} on ${objectName}` : type;
+    return (`[ObjectUI] ElementDataSourceGate row cap: ${where} declared ${key}: ${String(authored)}, `
+        + 'which is not a positive integer. A row cap must be a positive integer '
+        + '(the spec refuses zero and negative values), so it was ignored and the cap '
+        + `from this component's bound data source (${used}) was used instead.`);
+};
+/**
+ * The loud half for a cap the SAVED VIEW declared and the contract refuses
+ * (objectui#10015).
+ *
+ * `@object-ui/core` drops such a cap while composing, so `composed.limit`
+ * never carries it and the renderer below never sees it. Its own diagnostic
+ * treats an absent key as "not a mistake", so after that drop nothing said
+ * anything. The wording is the core builder's, not this file's: it is the one
+ * sentence both consumers of the composed binding use, and `ViewDataProvider`
+ * already reports it on the path with no renderer. The builder is pure because
+ * the composer runs inside a `useMemo`; this relay reports its result from an
+ * effect, the same way it reports {@link describeDisplacedRowLimit}.
+ *
+ * It speaks only when the refusal CHANGED what this block receives — when a
+ * usable view cap would have been written here:
+ *
+ *  - the binding declared no usable `limit` of its own (if it did, the
+ *    binding's cap is what the block gets whatever the view carries). The
+ *    builder applies this condition itself, because `ViewDataProvider` needs
+ *    it too (objectui#10016), so this relay hands it the binding; and
+ *  - the component's own cap is not a usable one (a usable one wins over any
+ *    view cap).
+ *
+ * In both of those excluded cases the builder's sentence — the block falls
+ * back to its own default — would not be true, so silence is the honest
+ * answer, not a gap. The caller adds the third condition: the block reads a
+ * row cap at all.
+ *
+ * ## Never together with {@link describeDisplacedRowLimit}
+ *
+ * That message needs a usable cap to have been WRITTEN. With a refused view
+ * cap, the only usable cap left is a binding's usable `limit`, and that is
+ * excluded above. So the two are exclusive by construction. When the component
+ * AND the view both carry a refused cap, this message names the view and the
+ * renderer names the component: two declarations, one message each.
+ */
+const describeRefusedViewRowLimit = (view, config, authored) => {
+    if (!config)
+        return null;
+    if (isUsableRowLimit(authored))
+        return null;
+    return elementDataSourceRefusedLimitMessage(view, config.view, config.object, config);
+};
+/**
+ * The loud half for a cap the BINDING declared and the contract refuses
+ * (objectui#10016), in the core builder's words for that operand.
+ *
+ * `@object-ui/core` treats such a cap as not authored: it lets the view's
+ * usable cap through in its place, or none. Nothing downstream can see the
+ * refused value any more, so this relay reports it, from an effect, the same
+ * way it reports the view's refusal.
+ *
+ * It needs no condition beyond the caller's (the block reads a row cap at
+ * all). A usable binding cap is written whatever the component or the view
+ * carries, so a refused one is always a cap this block did not get.
+ *
+ * It can fire beside the other two, and that is one message per declaration,
+ * not two per mistake: beside {@link describeRefusedViewRowLimit} when the view
+ * ALSO carries a refused cap, and beside {@link describeDisplacedRowLimit} when
+ * the component ALSO carries a refused cap and the view's usable one displaced
+ * it.
+ */
+const describeRefusedBindingRowLimit = (view, config) => {
+    if (!config)
+        return null;
+    return elementDataSourceRefusedLimitMessage(view, config.view, config.object, config, 'binding');
+};
 const readLimit = (base, key) => {
     if (key === 'pagination.pageSize')
         return base.pagination?.pageSize;
@@ -122,10 +269,16 @@ export function useElementDataSourceSchema(schema, mapping = {}, dataSource) {
     const { object: objectKey = 'objectName', columns, filter, sort, limit, viewType } = mapping;
     const mapped = React.useMemo(() => {
         const composed = binding.composed;
+        // BY REFERENCE when there is nothing to apply — a fresh object every render
+        // would remount the block and refetch. The wrapper is memoised alongside it,
+        // so the identity this carries is the one the caller sees.
         if (!composed)
-            return schema;
+            return { schema, capMessage: null, viewCapMessage: null, bindingCapMessage: null };
         const base = (schema ?? {});
         const next = { ...base };
+        let capMessage = null;
+        let viewCapMessage = null;
+        let bindingCapMessage = null;
         if (objectKey !== false)
             next[objectKey] = composed.object;
         if (columns) {
@@ -139,7 +292,23 @@ export function useElementDataSourceSchema(schema, mapping = {}, dataSource) {
             // Component filter AND (view filter AND binding filter). `composed.filter`
             // already carries the latter pair; a single surviving source comes back
             // unwrapped, so the common "only the view filters" case stays flat.
-            const merged = mergeFilterNodes(base.filter, composed.filter);
+            //
+            // ⚠️ Each source is lowered through `toFilterNodeSafely` first, the way
+            // `RelatedList` and `LineItemsPanel` lower their own filter before they
+            // merge it — objectui#10789. This is a RENDER-time `useMemo`, and the
+            // lowering refuses malformed authored shapes with a `FilterOperatorError`:
+            // uncaught, that was a render error, thrown BEFORE the wrapped block
+            // reached its own safe lowering and its malformed-filter state. The
+            // refusal is returned as a VALUE and the block is not rendered at all —
+            // never merged as "no filter", which would run it unconstrained. The
+            // merge below then only re-reads nodes the lowering already produced.
+            const own = toFilterNodeSafely(base.filter);
+            if (!own.ok)
+                return { schema, capMessage: null, viewCapMessage: null, bindingCapMessage: null, filterRefusal: own.refusal };
+            const bound = toFilterNodeSafely(composed.filter);
+            if (!bound.ok)
+                return { schema, capMessage: null, viewCapMessage: null, bindingCapMessage: null, filterRefusal: bound.refusal };
+            const merged = mergeFilterNodes(own.node, bound.node);
             if (merged !== undefined)
                 next.filter = merged;
             else
@@ -153,22 +322,65 @@ export function useElementDataSourceSchema(schema, mapping = {}, dataSource) {
                 next.sort = composed.sort;
         }
         if (limit && composed.limit !== undefined) {
-            const fromView = binding.config?.limit === undefined;
-            if (!fromView || readLimit(base, limit) === undefined) {
+            // For the row cap, "declared one" means a cap the contract admits
+            // (objectui#10016): a refused binding `limit` is not authored, so the
+            // composer let the view's cap through in its place, and that cap is a
+            // baseline the component's usable cap still wins over.
+            const fromView = !isUsableRowLimit(binding.config?.limit);
+            // PRESENCE is not authorship (objectui#9899) — the same question the
+            // `columns` branch above answers by CONTENT, answered the same way here.
+            const authored = readLimit(base, limit);
+            if (!fromView || !isUsableRowLimit(authored)) {
                 writeLimit(next, base, limit, composed.limit);
+                capMessage = describeDisplacedRowLimit(authored, limit, composed.limit, base.type, composed.object);
             }
         }
+        // Outside the branch above on purpose: a refused cap never reaches
+        // `composed.limit`, so that branch does not run for it (objectui#10015,
+        // and objectui#10016 for the binding's).
+        if (limit) {
+            viewCapMessage = describeRefusedViewRowLimit(binding.view, binding.config, readLimit(base, limit));
+            bindingCapMessage = describeRefusedBindingRowLimit(binding.view, binding.config);
+        }
         if (viewType && composed.viewType !== undefined && base.viewType === undefined) {
             next.viewType = composed.viewType;
         }
-        return next;
-    }, [schema, binding.composed, binding.config, objectKey, columns, filter, sort, limit, viewType]);
-    return React.useMemo(() => ({
-        status: binding.status,
-        schema: mapped,
-        config: binding.config,
-        error: binding.error,
-    }), [binding.status, binding.config, binding.error, mapped]);
+        return { schema: next, capMessage, viewCapMessage, bindingCapMessage };
+    }, [schema, binding.composed, binding.config, binding.view, objectKey, columns, filter, sort, limit, viewType]);
+    // Keyed on the MESSAGE, so it is one warning per declaration rather than one
+    // per render — and it fires from an effect, never from render, which is the
+    // same shape the renderer sites use for "you declared it, we dropped it".
+    // One effect per message, so a change to one never re-emits another.
+    const { schema: boundSchema, capMessage, viewCapMessage, bindingCapMessage, filterRefusal: mergeRefusal } = mapped;
+    React.useEffect(() => {
+        if (capMessage)
+            console.warn(capMessage);
+    }, [capMessage]);
+    React.useEffect(() => {
+        if (viewCapMessage)
+            console.warn(viewCapMessage);
+    }, [viewCapMessage]);
+    React.useEffect(() => {
+        if (bindingCapMessage)
+            console.warn(bindingCapMessage);
+    }, [bindingCapMessage]);
+    // A refused filter — from either merge — is `missing`, the one state every
+    // caller already answers by withholding the block (objectui#10789).
+    const filterRefusal = binding.filterRefusal ?? mergeRefusal;
+    return React.useMemo(() => filterRefusal
+        ? {
+            status: 'missing',
+            schema: boundSchema,
+            config: binding.config,
+            error: filterRefusal.message,
+            filterRefusal,
+        }
+        : {
+            status: binding.status,
+            schema: boundSchema,
+            config: binding.config,
+            error: binding.error,
+        }, [binding.status, binding.config, binding.error, boundSchema, filterRefusal]);
 }
 /**
  * The "named view does not resolve" panel. Same posture (and shape) as
@@ -178,6 +390,41 @@ export function useElementDataSourceSchema(schema, mapping = {}, dataSource) {
 export function ElementDataSourceErrorPanel({ testId, title = 'This component’s data source could not be resolved', message, }) {
     return (_jsxs("div", { className: "p-4 border border-red-500 rounded text-red-500 bg-red-50 my-2", role: "alert", "data-testid": `${testId}-datasource-error`, children: [_jsx("p", { className: "font-medium", children: title }), message ? _jsx("p", { className: "text-sm mt-1", children: message }) : null] }));
 }
+/**
+ * The malformed-filter notice, drawn IN PLACE OF the block when a filter the
+ * gate had to merge is refused (objectui#10789).
+ *
+ * It is the notice the wrapped blocks draw themselves (objectui#9050 step 2 —
+ * `record:related_list`, the line-items panel, `object-grid`): the same
+ * sentence (`view.malformedFilter`), naming the refused operator or field in a
+ * separately addressable headline, with the refusal's own message beneath it.
+ * The gate draws it because its merge refuses FIRST — before the block's own
+ * safe lowering ever runs — so without it the author would get the error
+ * boundary's "failed to render" instead of the sentence those blocks give.
+ *
+ * ⚠️ A separate component, so `useObjectTranslation` runs only on this path:
+ * the gate wraps every object-bound block, and a translation hook in the
+ * gate's own body would run for all of them, including under the many suites
+ * that mock `@object-ui/i18n` by hand.
+ *
+ * The provider-less default is the sentence itself, written the way the
+ * sibling blocks carry it: a LITERAL copy of the `en` pack's value, never a
+ * read of the pack object. The siblings keep theirs in a module-scope
+ * `createSafeTranslation` table, which this module cannot have: it is
+ * re-exported from the package entry, so a factory call at module scope would
+ * run on import for every consumer (`NonGridRowCeilingNote` records that
+ * hazard). So the copy sits in the call's inline `defaultValue`, where
+ * `pnpm check:i18n-keys` holds it byte-identical to the pack, as the siblings'
+ * tables are held. With an `I18nProvider` the pack's value wins, and without
+ * one this literal is interpolated (objectui#6219).
+ */
+function ElementDataSourceMalformedFilterPanel({ testId, refusal, }) {
+    const { t } = useObjectTranslation();
+    return (_jsxs("div", { role: "alert", className: "rounded-md border border-amber-300 bg-amber-50 p-3 my-2 text-sm text-amber-800", "data-testid": `${testId}-malformed-filter`, children: [_jsx("p", { className: "font-medium", "data-testid": `${testId}-malformed-filter-subject`, children: t('view.malformedFilter', {
+                    subject: filterRefusalSubject(refusal) ?? '',
+                    defaultValue: 'This view’s filter is malformed, so no records are shown: the {{subject}} condition cannot be applied.',
+                }) }), _jsx("p", { className: "mt-1 text-xs opacity-80", children: refusal.message })] }));
+}
 /**
  * The "saved views are still being fetched" placeholder. Distinct from the error
  * panel because a component that treated "not resolved yet" as "does not exist"
@@ -203,6 +450,9 @@ export function ElementDataSourceLoadingPanel({ testId, }) {
  * it off and you get `unknown`, which is the honest default.
  */
 export function useResolvedDataSource(explicit) {
+    // Read AS DECLARED (objectui#7209): the only cast in this hook is the
+    // caller's `T` on the way out, never one erasing the context on the way in.
+    // Pinned by `useResolvedDataSource.schemaRendererContextRead-7209.test.ts`.
     const context = React.useContext(SchemaRendererContext);
     const named = isElementDataSourceConfig(explicit) ? undefined : explicit;
     return (named ?? context?.dataSource ?? undefined);
@@ -244,6 +494,63 @@ export function noDataSourceMessage(blockKey, objectName) {
 export function NoDataSourcePanel({ testId, title = 'No data source resolved', message, }) {
     return (_jsxs("div", { className: "p-4 border border-red-500 rounded text-red-500 bg-red-50 my-2", role: "alert", "data-testid": `${testId}-no-data-source`, children: [_jsx("p", { className: "font-medium", children: title }), message ? _jsx("p", { className: "text-sm mt-1", children: message }) : null] }));
 }
+/**
+ * The wrapping seam — mark `renderer` as one that wraps {@link
+ * ElementDataSourceGate}, so its registrations DECLARE the `dataSource` key this
+ * gate READS (objectui#6678).
+ *
+ * ```tsx
+ * export const ObjectMapRenderer = elementDataSourceBlock<React.FC<any>>(({ schema }) => (
+ *   <ElementDataSourceGate schema={schema} testId="object-map" …>
+ *     {(bound) => <ObjectMap schema={bound} />}
+ *   </ElementDataSourceGate>
+ * ));
+ * ```
+ *
+ * ## What this closes
+ *
+ * `PageComponentSchema.dataSource` is the one spelling that resolves a saved
+ * view for an object-bound block. It works — and because no registration
+ * declared it, `sdui-parser`'s `validateTree` reported it with the SAME
+ * `unknown-prop` warning it gives the spellings that do nothing. On the tier
+ * built to accept AI-authored pages the diagnostic IS the contract, so the
+ * tier's only signal pointed away from the one key that works.
+ *
+ * ## Why a seam and not nine declarations
+ *
+ * Maintainer ruling, 2026-08-29: option B **in the injection form**. Nine
+ * hand-written copies across nine packages is the shape that ruling refused —
+ * they drift, and the tenth block forgets. Passing through here is the only
+ * thing a block does; `Registry.register` emits the declaration
+ * (`withElementDataSourceInput`), and `ELEMENT_DATA_SOURCE_INPUT` in
+ * `@object-ui/core` is its single copy, beside the binding's own semantics.
+ *
+ * ## And it cannot be forgotten
+ *
+ * `scripts/check-element-data-source-declaration.mjs` fails any source that
+ * renders `ElementDataSourceGate` for a registration without passing that
+ * registration's renderer through this function. That is the mechanical half of
+ * "a tenth block gets it automatically"; this function is the seam it enforces.
+ *
+ * Returns the renderer UNCHANGED (the mark is held in a `WeakSet`), so it is safe
+ * over a `React.forwardRef` object, over `React.memo`, and over a component that
+ * something else already re-exports by reference.
+ *
+ * ⚠️ Re-exported from `@object-ui/core` — where the marker and the declaration
+ * live — rather than wrapped here: ONE function under ONE name. This export
+ * exists for DISCOVERABILITY, so the seam is findable beside the gate it is
+ * about; **call sites must import it from `@object-ui/core`**, and
+ * `check:element-data-source-declaration` enforces that.
+ *
+ * The rule is measured, not stylistic. A registration runs at MODULE SCOPE, 101
+ * suites in this repo partially mock `@object-ui/react` by hand-listing the
+ * exports they return, and a module-scope read of a name absent from such a list
+ * throws at COLLECTION time — the importing test file dies before running one
+ * assertion. Taking the seam from here reddened 17 files across all four CI
+ * shards with zero failed assertions among them. Nothing mocks `@object-ui/core`,
+ * and every registration module already imports `ComponentRegistry` from it.
+ */
+export { elementDataSourceBlock } from '@object-ui/core';
 /**
  * Wrap an object-bound block so its `dataSource` binding reaches the keys it
  * reads, and so the two non-final resolution states render once, the same way,
@@ -264,6 +571,12 @@ export function ElementDataSourceGate({ schema, mapping, dataSource, testId, err
     if (requiresDataSource && adapter == null) {
         return _jsx(NoDataSourcePanel, { testId: testId, message: noDataSourceText });
     }
+    // A refused filter is `missing` too, but it gets the malformed-filter notice
+    // rather than the "could not be resolved" panel: the binding resolved, and
+    // what the author has to fix is a filter condition (objectui#10789).
+    if (bound.filterRefusal) {
+        return _jsx(ElementDataSourceMalformedFilterPanel, { testId: testId, refusal: bound.filterRefusal });
+    }
     if (bound.status === 'missing') {
         return _jsx(ElementDataSourceErrorPanel, { testId: testId, title: errorTitle, message: bound.error });
     }

package/dist/hooks/index.d.ts

@@ -7,6 +7,7 @@
  */
 export * from './useExpression.js';
 export * from './useFilterScope.js';
+export * from './useResolvedFilter.js';
 export * from './useActionRunner.js';
 export * from './useNavigationOverlay.js';
 export * from './usePageVariables.js';
@@ -23,7 +24,6 @@ export * from './useReducedMotion.js';
 export * from './useAnimation.js';
 export * from './useDensityMode.js';
 export * from './useViewSharing.js';
-export * from './useClientNotifications.js';
 export * from './useOffline.js';
 export * from './usePerformance.js';
 export * from './usePerformanceBudget.js';
@@ -36,7 +36,9 @@ export * from './useDebugMode.js';
 export * from './useActionEngine.js';
 export * from './useActionTextLocalizer.js';
 export * from './useCapabilityGate.js';
+export * from './useConfigBagEvaluator.js';
 export * from './useDatasetDimensionLabels.js';
 export * from './useDataRefresh.js';
 export * from './usePageAssignment.js';
 export * from './useRecordSearch.js';
+export * from './useSettledSchema.js';

package/dist/hooks/index.js

@@ -8,6 +8,9 @@
 export * from './useExpression.js';
 // Session scope for filter placeholders ({current_user_id}/{current_org_id}).
 export * from './useFilterScope.js';
+// The ONE hold a data node resolves its own authored `filter` through
+// (objectui#10666), fed by `useFilterScope()`.
+export * from './useResolvedFilter.js';
 export * from './useActionRunner.js';
 export * from './useNavigationOverlay.js';
 export * from './usePageVariables.js';
@@ -25,7 +28,6 @@ export * from './useReducedMotion.js';
 export * from './useAnimation.js';
 export * from './useDensityMode.js';
 export * from './useViewSharing.js';
-export * from './useClientNotifications.js';
 export * from './useOffline.js';
 export * from './usePerformance.js';
 export * from './usePerformanceBudget.js';
@@ -40,6 +42,9 @@ export * from './useActionEngine.js';
 // authored strings an action carries (label / confirmText / successMessage).
 export * from './useActionTextLocalizer.js';
 export * from './useCapabilityGate.js';
+// The `SchemaRenderer` memo's `properties` evaluation, for an action container's
+// members, which are drawn without `SchemaRenderer` (objectui#10290).
+export * from './useConfigBagEvaluator.js';
 // The analytics label net's React glue, consumed by BOTH plugin-dashboard's
 // `DatasetWidget` and plugin-report's dataset block (objectui#4389). It lives
 // here rather than in `@object-ui/core` because it reads `SchemaRendererContext`
@@ -48,3 +53,7 @@ export * from './useDatasetDimensionLabels.js';
 export * from './useDataRefresh.js';
 export * from './usePageAssignment.js';
 export * from './useRecordSearch.js';
+// The settled-schema RESOLUTION half shared across ObjectKanban / ObjectView /
+// ObjectCalendar's hand copies (objectui#6482, maintainer ruling Option A).
+// Gate PLACEMENT stays per-component — see the hook's own doc comment.
+export * from './useSettledSchema.js';