@object-ui/react 17.6.0 → 18.0.0

package/dist/context/RelatedRecordActionsContext.d.ts

@@ -30,6 +30,10 @@
  * it can route to, so the low-level renderers on a record page can turn a
  * lookup VALUE into a link to the referenced record without assembling a URL
  * of their own. Same provider, same builder, one route shape.
+ *
+ * Since objectui#12703 it also publishes the object-list URL builder
+ * ({@link RelatedRecordActionsValue.listHref} / `openList`), for a renderer
+ * that shows a few of an object's records and links to the rest.
  */
 import React from 'react';
 /** A child-object action surfaced in a related list's row menu. */
@@ -83,7 +87,11 @@ export interface RelatedRecordHandlers {
      * the deletion resolves.
      */
     onDelete?: (recordId: string | number, record?: unknown) => void | Promise<void>;
-    /** Child object row-level actions (`locations: ['list_item']`), localized. */
+    /**
+     * Child object row-level actions, localized: its `list_item` actions, and
+     * its `record_related` ones when the list sits inside a parent record
+     * (objectui#11270).
+     */
     rowActions?: RelatedRowActionDef[];
     /** Execute one of {@link rowActions} against a specific child row. */
     onRowAction?: (action: RelatedRowActionDef, record: unknown) => void | Promise<void>;
@@ -96,8 +104,40 @@ export interface RelatedRecordHandlers {
     toolbarActions?: RelatedRowActionDef[];
     /** Execute one of {@link toolbarActions} (no row context). */
     onToolbarAction?: (action: RelatedRowActionDef) => void | Promise<void>;
+    /**
+     * Open the child object's full list page, scoped to THIS parent on the
+     * relationship `resolve` was handed (objectui#12741). The related list's
+     * "View all" link calls it, unless the block declares `showViewAll: false`.
+     *
+     * The host builds the destination because only the host knows the console's
+     * routes, as it does for {@link onView}. It omits the handler when no route
+     * it has can show that scoped list, and the link is then not drawn. One case
+     * is a multi-value relationship: the list route's URL filter has no
+     * membership operator. Another is a relationship field the viewer cannot
+     * read: the list route drops that condition and would show every row.
+     */
+    onViewAll?: () => void;
 }
-/** Input to {@link RelatedRecordActionsValue.resolve}. */
+/**
+ * Input to {@link RelatedRecordActionsValue.resolve}.
+ *
+ * Its SHAPE says which kind of list asks (objectui#13089):
+ *
+ *  - **A related list always names its `relationshipField`.** The spec's
+ *    `record:related_list` declares it required, so a spec-valid related list
+ *    resolves with it, with or without a resolved `parentId`.
+ *  - **An input with no `relationshipField` (absent or empty) asks for an
+ *    OBJECT-SCOPED list's handlers**, a list of the object's own records with
+ *    no parent: a page `list-view` node resolves `{ objectName }` for its
+ *    `addRecord` Add button. A host may serve such an input a create that
+ *    links no parent, which it must not serve a related list whose parent did
+ *    not resolve.
+ *
+ * ⚠️ The limit of reading the shape: a future consumer that resolves a list
+ * with no parent and no relationship, and must NOT be offered a create, cannot
+ * say so here. It needs an explicit member on this input, not a second reading
+ * of the same shape.
+ */
 export interface ResolveRelatedRecordActionsInput {
     /** Child object machine name (the related list's `api`). */
     objectName: string;
@@ -128,6 +168,11 @@ export interface RelatedRecordActionsValue {
      *
      * Returns `null` when the host cannot route to that object (unknown object,
      * no app context), which consumers must render as the plain value.
+     *
+     * The value is a document href, read by the browser on "open in new tab" and
+     * "copy link address", so it carries the host router's basename (for
+     * example `/_console/apps/…`), while {@link openRecord} navigates by the
+     * router path (objectui#12233).
      */
     recordHref?: (objectName: string, recordId: string | number) => string | null;
     /**
@@ -136,6 +181,31 @@ export interface RelatedRecordActionsValue {
      * in-app; a modifier click is left to the browser and the href.
      */
     openRecord?: (objectName: string, recordId: string | number) => void;
+    /**
+     * The host's list-page URL for an object it can route to, optionally opened
+     * on one of the object's saved views (objectui#12703). The list-side twin of
+     * {@link recordHref}: a renderer that shows a few of an object's records (the
+     * compact list a page draws in a narrow region) presents "View all" as a real
+     * anchor to this destination, without assembling a URL of its own.
+     *
+     * `viewName` names a saved view of that object, as the block binding states
+     * it (`dataSource.view`); absent, the destination is the object's own list.
+     * The destination is a view or the object, never a query: a caller does not
+     * encode its own filter, columns or sort into it, and the host has no
+     * argument to receive them.
+     *
+     * Returns `null` when the host cannot route to that object (unknown object,
+     * no app context); consumers then draw no link. Like {@link recordHref} it is
+     * a document href that carries the router's basename, while {@link openList}
+     * navigates by the router path.
+     */
+    listHref?: (objectName: string, viewName?: string) => string | null;
+    /**
+     * SPA-navigate to the destination {@link listHref} addresses. Consumers call
+     * this from a plain left click on the anchor; a modifier click is left to the
+     * browser and the href.
+     */
+    openList?: (objectName: string, viewName?: string) => void;
 }
 export declare const RelatedRecordActionsProvider: React.FC<{
     value: RelatedRecordActionsValue;

package/dist/context/RelatedRecordActionsContext.js

@@ -31,6 +31,10 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * it can route to, so the low-level renderers on a record page can turn a
  * lookup VALUE into a link to the referenced record without assembling a URL
  * of their own. Same provider, same builder, one route shape.
+ *
+ * Since objectui#12703 it also publishes the object-list URL builder
+ * ({@link RelatedRecordActionsValue.listHref} / `openList`), for a renderer
+ * that shows a few of an object's records and links to the rest.
  */
 import { createContext, useContext } from 'react';
 const RelatedRecordActionsContext = createContext(null);

package/dist/context/SchemaRendererContext.d.ts

@@ -1,14 +1,40 @@
 import React from 'react';
 import type { DebugFlags } from '@object-ui/core';
+import type { DataSource } from '@object-ui/types';
 /**
- * Host-provided fetch used for `provider: 'api'` view data sources so custom
- * endpoints carry the same credentials (Authorization, tenant, locale headers)
- * as the native data channel. Optional — when absent, ApiDataSource falls back
- * to the bare global fetch (cookies only).
+ * Host-provided fetch the renderers use for their own reads of the host's API
+ * (a chart's metadata reads, dataset dimension labels, record-permission
+ * probes), so those reads carry the same credentials (Authorization, tenant,
+ * locale headers) as the native data channel. Optional — when absent, those
+ * reads fall back to the bare global fetch (cookies only). A view does not
+ * reach it: a view binds `provider: 'object'` or `provider: 'value'`, and a
+ * code-built `ApiDataSource` takes its own `fetch` in its config.
  */
 export type ApiFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 interface SchemaRendererContextType {
-    dataSource: any;
+    /**
+     * The adapter the host injected, as the published `DataSource` contract
+     * declares it (objectui#7912).
+     *
+     * Typed, not `any`: this is the injection point for the ENTIRE renderer tree,
+     * and `useSchemaContext()` hands whatever is declared here to every consumer
+     * that reads it back. While it was `any`, a bare string passed where the
+     * host's adapter belongs raised nothing at compile time and failed at runtime
+     * on the first `find()` — the shape of a config value read from the wrong
+     * place. The type was never unknown: `@object-ui/types` exports `DataSource`,
+     * `useSettledSchema` in this same package already declares its parameter as
+     * `DataSource<any> | null | undefined`, and `app-shell`'s README writes
+     * `DataSource` against this very seam.
+     *
+     * `null | undefined` are part of the contract, not a weakening of it: a host
+     * renders with no adapter bound (a Studio preview, a react page before the
+     * AdapterProvider connects, a widget test that drives `apiFetch` alone), and
+     * every reader in the tree already guards for it. The union states the three
+     * states that actually occur and refuses everything else — a string, `{}`, a
+     * plain data bag, a partial adapter missing a required member. It is spelled
+     * exactly as `useSettledSchema` spells it, one hop away.
+     */
+    dataSource: DataSource | null | undefined;
     debug?: boolean;
     debugFlags?: DebugFlags;
     apiFetch?: ApiFetch;
@@ -17,10 +43,39 @@ declare const SchemaRendererContext: React.Context<SchemaRendererContextType | n
 export { SchemaRendererContext };
 export declare const SchemaRendererProvider: ({ children, dataSource, debug, debugFlags, apiFetch, }: {
     children: React.ReactNode;
-    dataSource: any;
+    /** The host's adapter — see {@link SchemaRendererContextType.dataSource}. */
+    dataSource: DataSource | null | undefined;
     debug?: boolean;
     debugFlags?: DebugFlags;
     apiFetch?: ApiFetch;
 }) => React.JSX.Element;
 export declare const useSchemaContext: () => SchemaRendererContextType;
+/**
+ * Resolve a `bind` path against the ambient predicate scope.
+ *
+ * ## What it reads, and what it deliberately does not (objectui#9308)
+ *
+ * The scope a host publishes through `PredicateScopeProvider` — the same
+ * channel `useCondition` / `useExpression` merge under a locally-passed
+ * context, and the one app-shell's `ExpressionProvider` already feeds. It is
+ * NOT `SchemaRendererContext.dataSource`.
+ *
+ * `dataSource` is the host's injected ADAPTER, declared as the published
+ * `DataSource` contract (objectui#7912). An adapter has no `users` member, no
+ * `value` member, no member a `bind` path names — so walking it resolved
+ * `undefined` for every conformant host, and the nine production readers of
+ * this hook have all been running their fallback (`boundData || schema.items`,
+ * `|| schema.nodes`, or a fall-through to their own fetch chain) ever since.
+ * The only hosts it answered were ones injecting a data bag through a key the
+ * contract says is an adapter, which has been a compile error since
+ * objectui#7912.
+ *
+ * Maintainer ruling 2026-09-13 (option B) points it at the channel that can
+ * actually answer it. No published key is added: the provider, the hook and
+ * the host wiring all already exist.
+ *
+ * Returns `undefined` for an absent or empty path, and for any path the scope
+ * does not carry — the readers' fallbacks are what run then, exactly as
+ * before.
+ */
 export declare const useDataScope: (path?: string) => any;

package/dist/context/SchemaRendererContext.js

@@ -1,11 +1,12 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext, useMemo } from 'react';
+import { usePredicateScope } from '../hooks/useExpression.js';
 const SchemaRendererContext = createContext(null);
 export { SchemaRendererContext };
 export const SchemaRendererProvider = ({ children, dataSource, debug, debugFlags, apiFetch, }) => {
     // Nested providers (react-page, studio preview surfaces) re-wrap with their
     // own dataSource but rarely know about the host's authenticated fetch —
-    // inherit it from the parent context so provider:'api' auth survives nesting.
+    // inherit it from the parent context so the host's auth survives nesting.
     const parent = useContext(SchemaRendererContext);
     const effectiveApiFetch = apiFetch ?? parent?.apiFetch;
     const value = useMemo(() => ({ dataSource, debug, debugFlags, apiFetch: effectiveApiFetch }), [dataSource, debug, debugFlags, effectiveApiFetch]);
@@ -18,13 +19,45 @@ export const useSchemaContext = () => {
     }
     return context;
 };
+/**
+ * Resolve a `bind` path against the ambient predicate scope.
+ *
+ * ## What it reads, and what it deliberately does not (objectui#9308)
+ *
+ * The scope a host publishes through `PredicateScopeProvider` — the same
+ * channel `useCondition` / `useExpression` merge under a locally-passed
+ * context, and the one app-shell's `ExpressionProvider` already feeds. It is
+ * NOT `SchemaRendererContext.dataSource`.
+ *
+ * `dataSource` is the host's injected ADAPTER, declared as the published
+ * `DataSource` contract (objectui#7912). An adapter has no `users` member, no
+ * `value` member, no member a `bind` path names — so walking it resolved
+ * `undefined` for every conformant host, and the nine production readers of
+ * this hook have all been running their fallback (`boundData || schema.items`,
+ * `|| schema.nodes`, or a fall-through to their own fetch chain) ever since.
+ * The only hosts it answered were ones injecting a data bag through a key the
+ * contract says is an adapter, which has been a compile error since
+ * objectui#7912.
+ *
+ * Maintainer ruling 2026-09-13 (option B) points it at the channel that can
+ * actually answer it. No published key is added: the provider, the hook and
+ * the host wiring all already exist.
+ *
+ * Returns `undefined` for an absent or empty path, and for any path the scope
+ * does not carry — the readers' fallbacks are what run then, exactly as
+ * before.
+ */
 export const useDataScope = (path) => {
-    const context = useContext(SchemaRendererContext);
-    const dataSource = context?.dataSource;
+    const scope = usePredicateScope();
     if (!path)
         return undefined;
-    if (!dataSource)
+    if (!scope)
         return undefined;
-    // Simple path resolution for now. In real app might be more complex
-    return path.split('.').reduce((acc, part) => acc && acc[part], dataSource);
+    // Simple path resolution for now. In real app might be more complex.
+    //
+    // The accumulator is `any` BY DECLARATION: this walk addresses arbitrary
+    // member names on a host-published bag, and `Record<string, any>` declares
+    // none of them beyond the first segment. The hook's published return type is
+    // unchanged — `any` before and after — so no reader of `useDataScope` moves.
+    return path.split('.').reduce((acc, part) => acc && acc[part], scope);
 };

package/dist/context/ThemeContext.js

@@ -131,7 +131,7 @@ export function ThemeProvider({ themes: themesInput = [], defaultTheme, defaultM
         // Apply mode class
         el.classList.remove('light', 'dark');
         el.classList.add(resolvedMode);
-        // No favicon here: spec v17 (#3494) pruned `Theme.logo`, so the key is
+        // No favicon here: spec v17 (objectstack-ai/objectstack#3494) pruned `Theme.logo`, so the key is
         // stripped at parse and could never arrive. The live favicon comes from
         // operator branding (`getFaviconUrl()`), applied in the console's
         // index.html, main.tsx, and on route change.

package/dist/context/actionRunnerTranslator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ */
+/** What `ActionRunner.setTranslator` takes. */
+type ActionRunnerTranslate = (key: string, options: {
+    defaultValue: string;
+}) => string;
+/**
+ * The translator both React owners of an `ActionRunner` — `<ActionProvider>`
+ * and `useActionRunner` — install on the runner they build, so the text the
+ * runner writes itself (the generic success toast an action with no
+ * `successMessage` ends in) renders in the session's language instead of
+ * English. Internal to this package; not re-exported from its entry.
+ *
+ * The function is created once per mount and reads the latest `t` when it is
+ * CALLED, so a language switch reaches a runner that was built before it. Both
+ * owners rebuild their runner only when their `context` changes, and a
+ * translator captured at build time would keep answering in the language that
+ * was active then. The identity comes from `useState`'s initializer, not from a
+ * memo, so nothing depends on a `useMemo` result staying put (AGENTS.md #10).
+ */
+export declare function useActionRunnerTranslator(): ActionRunnerTranslate;
+export {};

package/dist/context/actionRunnerTranslator.js

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+import { useEffect, useRef, useState } from 'react';
+import { useObjectTranslation } from '@object-ui/i18n';
+/**
+ * The translator both React owners of an `ActionRunner` — `<ActionProvider>`
+ * and `useActionRunner` — install on the runner they build, so the text the
+ * runner writes itself (the generic success toast an action with no
+ * `successMessage` ends in) renders in the session's language instead of
+ * English. Internal to this package; not re-exported from its entry.
+ *
+ * The function is created once per mount and reads the latest `t` when it is
+ * CALLED, so a language switch reaches a runner that was built before it. Both
+ * owners rebuild their runner only when their `context` changes, and a
+ * translator captured at build time would keep answering in the language that
+ * was active then. The identity comes from `useState`'s initializer, not from a
+ * memo, so nothing depends on a `useMemo` result staying put (AGENTS.md #10).
+ */
+export function useActionRunnerTranslator() {
+    const { t } = useObjectTranslation();
+    const latest = useRef(t);
+    // No dependency list: after every render, the ref holds that render's `t`.
+    // Actions run from user events, which arrive after the commit.
+    useEffect(() => {
+        latest.current = t;
+    });
+    const [translate] = useState(() => {
+        const read = (key, options) => String(latest.current(key, options));
+        return read;
+    });
+    return translate;
+}

package/dist/context/index.d.ts

@@ -11,3 +11,4 @@ export * from './DiscussionContext.js';
 export * from './DrillNavigationContext.js';
 export * from './HostNavigationContext.js';
 export * from './RelatedRecordActionsContext.js';
+export * from './PrintPageContext.js';

package/dist/context/index.js

@@ -11,3 +11,4 @@ export * from './DiscussionContext.js';
 export * from './DrillNavigationContext.js';
 export * from './HostNavigationContext.js';
 export * from './RelatedRecordActionsContext.js';
+export * from './PrintPageContext.js';

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

@@ -0,0 +1,28 @@
+/**
+ * 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 error panel of a page element's API binding (objectui#12197), titled in
+ * the page's language.
+ *
+ * `SchemaRenderer` draws it in place of a node whose binding the spec refused
+ * or whose read failed. The translation hook lives HERE, not in
+ * `SchemaRenderer`'s body: that body runs for every node on every page, and a
+ * language subscription there would re-render the whole tree on a language
+ * change. This component mounts only on the error path, so only it subscribes.
+ * The panel itself is {@link ElementDataSourceErrorPanel}; the inline
+ * `defaultValue`s are the `en` pack's values (`pnpm check:i18n-keys`).
+ */
+import * as React from 'react';
+export interface ElementApiDataSourcePanelProps {
+    /** `data-testid` stem — the node's registry key. */
+    testId: string;
+    /** `refused`: the spec's schema refused the binding. `error`: the read failed. */
+    state: 'refused' | 'error';
+    /** Why — the spec's refusal, or the failed read's sentence. */
+    message?: string;
+}
+export declare function ElementApiDataSourcePanel({ testId, state, message, }: ElementApiDataSourcePanelProps): React.ReactElement;

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

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useObjectTranslation } from '@object-ui/i18n';
+import { ElementDataSourceErrorPanel } from './ElementDataSourceGate.js';
+export function ElementApiDataSourcePanel({ testId, state, message, }) {
+    const { t } = useObjectTranslation();
+    const title = state === 'refused'
+        ? t('element.component.apiRefused', { defaultValue: 'This component’s API data source is refused' })
+        : t('element.component.apiUnreadable', { defaultValue: 'This component’s API data source could not be read' });
+    return _jsx(ElementDataSourceErrorPanel, { testId: testId, title: title, message: message });
+}

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
@@ -163,7 +193,10 @@ export interface ElementDataSourceStatusPanelProps {
      * asserting about rather than a shared anonymous id.
      */
     testId: string;
-    /** Panel heading; defaults to a block-neutral sentence. */
+    /**
+     * Panel heading; defaults to a block-neutral sentence read from the bundle
+     * (objectui#12920). A passed `title`, an empty string included, wins.
+     */
     title?: string;
     /** The author-facing explanation from {@link useElementDataSourceSchema}. */
     message?: string;
@@ -178,6 +211,13 @@ export declare function ElementDataSourceErrorPanel({ testId, title, 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"
  * would flash a configuration error on every mount.
+ *
+ * Its copy reads `common.loading` (objectui#12889), the key the rest of the
+ * tree reads for a bare "Loading…": it printed an English "Loading view…" on
+ * every locale before. `useObjectTranslation` runs only while a view resolves,
+ * for the reason {@link ElementDataSourceMalformedFilterPanel} gives, and the
+ * inline `defaultValue` is the `en` pack's value, held byte-identical to it by
+ * `pnpm check:i18n-keys`.
  */
 export declare function ElementDataSourceLoadingPanel({ testId, }: Pick<ElementDataSourceStatusPanelProps, 'testId'>): React.ReactElement;
 /**
@@ -225,6 +265,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;
@@ -253,6 +350,24 @@ export interface ElementDataSourceGateProps<S> {
     requiresDataSource?: boolean;
     /** Explanation for the no-adapter panel; see {@link noDataSourceMessage}. */
     noDataSourceMessage?: string;
+    /**
+     * Whether THIS placement has nothing to show unless it names an object — when
+     * true and the bound schema names none on the mapping's object key (neither
+     * the node's own key nor `dataSource.object` landing on it), the gate renders
+     * the "no object named" hint instead of the block (objectui#11605).
+     *
+     * Read AFTER the binding is applied, so a node bound by `dataSource.object`
+     * is never told it names no object; and AFTER the view states, so a binding
+     * that is still resolving or failed to resolve keeps its own panel.
+     *
+     * The call site states it, for the reason {@link requiresDataSource} gives:
+     * the other record sources a block can draw from (inline `data`, inline
+     * `customFields`, a `dataset`, a `bind` path) are each block's own, and a
+     * predicate guessed here would paint a configuration hint over a block that
+     * is working. A mapping whose `object` is `false` lands no object key, so
+     * this prop does nothing there.
+     */
+    requiresObject?: boolean;
     /**
      * Renders the block with the bound schema. Called during the gate's own
      * render, so it must RETURN AN ELEMENT and never call hooks itself — the
@@ -269,4 +384,4 @@ export interface ElementDataSourceGateProps<S> {
  * against a half-resolved query is how a page shows a wider answer than the one
  * that was authored.
  */
-export declare function ElementDataSourceGate<S>({ schema, mapping, dataSource, testId, errorTitle, requiresDataSource, noDataSourceMessage: noDataSourceText, children, }: ElementDataSourceGateProps<S>): React.ReactElement | null;
+export declare function ElementDataSourceGate<S>({ schema, mapping, dataSource, testId, errorTitle, requiresDataSource, noDataSourceMessage: noDataSourceText, requiresObject, children, }: ElementDataSourceGateProps<S>): React.ReactElement | null;