@object-ui/react 17.7.0 → 18.0.0

package/dist/SchemaRenderer.d.ts

@@ -7,6 +7,32 @@
  */
 import React, { Component, type ForwardRefExoticComponent, type RefAttributes } from 'react';
 import type { DeclaredNode } from '@object-ui/types';
+/**
+ * The scope a page node's values are evaluated against: its `visibleWhen`
+ * gate and every other expression the evaluation memo in
+ * {@link SchemaRenderer} evaluates on the node. Four roots, in this order:
+ *
+ * 1. **the ambient predicate scope**: every root `predicateScope` carries (the
+ *    host scope `usePredicateScope()` publishes, plus a node's API-bound
+ *    `data` once it has answered), spread first;
+ * 2. **`current_user`**: aliased to the ambient `user`, so `user.email` and
+ *    `current_user.email` read the same value;
+ * 3. **`record`**: the page's bound row, ONLY when there is one (a non-array
+ *    object). No row binds nothing, so a `record` the ambient scope supplies
+ *    is not shadowed by an empty one; a row, written after the spread, wins;
+ * 4. **`page`**: the page variables (`PageSchema.variables`) as `page.<var>`.
+ *
+ * Why each root is (and `data` is not) bound is stated where the memo builds
+ * its evaluator from this.
+ *
+ * The ONE builder of this scope. The memo and {@link evaluateConfigBagInScope}
+ * call it, so they cannot build two different scopes (objectui#10290), and it
+ * is exported for the `page:tabs` derived badge in `@object-ui/components`,
+ * which decides the `visibleWhen` gates in front of a related list the way the
+ * tab body decides them (objectui#12987, objectui#12992). A root added here
+ * reaches every one of them.
+ */
+export declare function buildNodeEvaluationScope(predicateScope: Record<string, unknown>, boundRecord: unknown, pageVariables: unknown): Record<string, unknown>;
 /**
  * The `properties` evaluation of the {@link SchemaRenderer} memo, for a config
  * bag that does not pass through `SchemaRenderer` (objectui#10290): the same
@@ -77,7 +103,7 @@ export declare class SchemaErrorBoundary extends Component<{
  * `element:record_picker`, a stored page document under its page kind), and
  * the types an application declares in `CustomNodeRegistry`. It has no
  * `type: string` arm, so a node whose `type` no declaration names is refused
- * here, and each node's own keys are judged: once objectui#8347 removes
+ * here, and each node's own keys are judged: since objectui#8347 removed
  * `BaseSchema`'s index signature, a misspelled key is refused while the
  * declared spelling compiles. ⛔ The prop is widened by declared types only,
  * never by an index signature, a `Record` or a `type: string` arm.

package/dist/SchemaRenderer.js

@@ -10,11 +10,15 @@ import React, { forwardRef, useContext, useMemo, useEffect, useReducer, useState
 import { ComponentRegistry, ExpressionEvaluator, isObjectUIError, ERROR_CODES, debugLog, debugTime, debugTimeEnd, DebugCollector, validateSchema, hasDeclaredPredicate, hasResponsiveStyles, scopeClassFor, compileScopedStyles, recordSourceDataArmForType, } from '@object-ui/core';
 import { SchemaRendererContext } from './context/SchemaRendererContext.js';
 import { useRecordContext } from './context/RecordContext.js';
-import { usePredicateScope } from './hooks/useExpression.js';
+import { usePredicateScope, PredicateScopeProvider } from './hooks/useExpression.js';
+import { useElementApiDataSource } from './element-data-source/useElementApiDataSource.js';
+import { ElementDataSourceLoadingPanel } from './element-data-source/ElementDataSourceGate.js';
+import { ElementApiDataSourcePanel } from './element-data-source/ElementApiDataSourcePanel.js';
 import { usePageVariables } from './hooks/usePageVariables.js';
 import { resolveKeyedI18nLabel } from './utils/i18n.js';
 import { isConfigBag } from './utils/configBag.js';
 import { PARAMS_KEY, isParamsBag, mapParamsLeaves } from './utils/paramsBag.js';
+import { isInlineLocaleMap, mapLocaleMapMembers } from './utils/localeMap.js';
 import { reportUnevaluatedExpressions } from './utils/unevaluatedExpression.js';
 import { reportDroppedPropsBag, reportRefusedPropsPredicate } from './utils/propsBagDiagnostic.js';
 import { reportRefusedDataPropSpread } from './utils/refusedDataPropDiagnostic.js';
@@ -221,10 +225,10 @@ function propsWithoutCanonicalKeys(propsBag, propertiesBag) {
  * means *hidden* and the wider `!== undefined` test would vanish a node for
  * `hidden: ''` (objectui#3955). See {@link winningVisibilityKey}.
  */
-const VISIBILITY_SHOW_KEYS = ['visibleWhen', 'visible', 'visibleOn', 'visibility'];
+const VISIBILITY_SHOW_KEYS = ['visibleWhen', 'visible', 'visibleOn'];
 const VISIBILITY_HIDE_KEYS = ['hidden', 'hiddenOn'];
 /**
- * The same six legs as a lookup, so the config-bag evaluation loops below can
+ * The same five legs as a lookup, so the config-bag evaluation loops below can
  * ask "is this key a visibility predicate?" off the SAME declaration the chain
  * is built from rather than a second list that can drift from it.
  *
@@ -351,7 +355,7 @@ const isCelEnvelope = (value) => isConfigBag(value)
  * `has(record.x) && …` throws — and the two polarities of the chain then fail
  * in OPPOSITE directions, both silently:
  *
- *   * on the four SHOW legs the fail-soft `true` is negated to "do not hide",
+ *   * on the three SHOW legs the fail-soft `true` is negated to "do not hide",
  *     so a gate authored to conceal renders on every row — measured in a real
  *     browser against a real app instance (the card), where a duplicate-lead
  *     banner showed on 6 of 6 leads whose field was `null`;
@@ -476,37 +480,66 @@ const isExpressionEnvelope = (value) => isConfigBag(value)
  * whole. Nothing is walked: a template nested inside a data object stays raw,
  * as it always did for an object without a `source`. The loops stay per-value
  * and shallow, which is the radius the unevaluated-expression diagnostic reads.
+ *
+ * One object this answers `true` for is not handed over as authored: an inline
+ * locale map (`utils/localeMap.ts`, objectui#12936). It is a display string
+ * written once per language, so {@link evaluateConfigValueWith} evaluates each
+ * member like a plain string on the same key. That is one level, and only for
+ * a map whose every key is a locale tag and every value a string, in the
+ * spec's own `InlineLocaleMapSchema` sense; every other data object keeps this
+ * rule, and the diagnostic reads the members through the same module.
  */
 const isDataObjectValue = (key, value) => !PREDICATE_CHAIN_KEYS.has(key) && isConfigBag(value) && !isExpressionEnvelope(value);
 /**
- * The scope the evaluation memo in {@link SchemaRenderer} evaluates a node's
- * values against: the ambient host scope, `current_user` aliased to `user`, the
- * page's bound row as `record` (only when there is one), and page variables as
- * `page`. Why each root is (and `data` is not) bound is stated where the memo
- * builds its evaluator from this.
- *
- * One function, so the memo and {@link evaluateConfigBagInScope} cannot build
- * two different scopes (objectui#10290).
+ * The scope a page node's values are evaluated against: its `visibleWhen`
+ * gate and every other expression the evaluation memo in
+ * {@link SchemaRenderer} evaluates on the node. Four roots, in this order:
+ *
+ * 1. **the ambient predicate scope**: every root `predicateScope` carries (the
+ *    host scope `usePredicateScope()` publishes, plus a node's API-bound
+ *    `data` once it has answered), spread first;
+ * 2. **`current_user`**: aliased to the ambient `user`, so `user.email` and
+ *    `current_user.email` read the same value;
+ * 3. **`record`**: the page's bound row, ONLY when there is one (a non-array
+ *    object). No row binds nothing, so a `record` the ambient scope supplies
+ *    is not shadowed by an empty one; a row, written after the spread, wins;
+ * 4. **`page`**: the page variables (`PageSchema.variables`) as `page.<var>`.
+ *
+ * Why each root is (and `data` is not) bound is stated where the memo builds
+ * its evaluator from this.
+ *
+ * The ONE builder of this scope. The memo and {@link evaluateConfigBagInScope}
+ * call it, so they cannot build two different scopes (objectui#10290), and it
+ * is exported for the `page:tabs` derived badge in `@object-ui/components`,
+ * which decides the `visibleWhen` gates in front of a related list the way the
+ * tab body decides them (objectui#12987, objectui#12992). A root added here
+ * reaches every one of them.
  */
-const configEvaluationScope = (predicateScope, boundRecord, pageVariables) => ({
-    ...predicateScope,
-    current_user: predicateScope?.user,
-    ...(boundRecord && typeof boundRecord === 'object' && !Array.isArray(boundRecord)
-        ? { record: boundRecord }
-        : null),
-    page: pageVariables,
-});
+export function buildNodeEvaluationScope(predicateScope, boundRecord, pageVariables) {
+    return {
+        ...predicateScope,
+        current_user: predicateScope?.user,
+        ...(boundRecord && typeof boundRecord === 'object' && !Array.isArray(boundRecord)
+            ? { record: boundRecord }
+            : null),
+        page: pageVariables,
+    };
+}
 /**
  * Evaluate ONE config value by its key. This is the per-key rule of the
  * evaluation memo (the `params` rule, objectui#7867, is stated there): a
- * `params` bag has every string leaf evaluated, a data object is handed over as
- * authored, and every other value is evaluated per value and shallow, with a
- * CEL predicate envelope preserved.
+ * `params` bag has every string leaf evaluated, an inline locale map has each
+ * member evaluated like a plain string on the same key (objectui#12936,
+ * `utils/localeMap.ts`), any other data object is handed over as authored, and
+ * every other value is evaluated per value and shallow, with a CEL predicate
+ * envelope preserved.
  */
 const evaluateConfigValueWith = (evaluator, key, value) => key === PARAMS_KEY && isParamsBag(value)
     ? mapParamsLeaves(value, (leaf) => evaluator.evaluate(leaf))
     : isDataObjectValue(key, value)
-        ? value
+        ? isInlineLocaleMap(value)
+            ? mapLocaleMapMembers(value, (member) => evaluator.evaluate(member))
+            : value
         : preservePredicateEnvelope(key, value, (v) => evaluator.evaluate(v));
 /**
  * Evaluate every value of a config bag with {@link evaluateConfigValueWith}.
@@ -539,7 +572,7 @@ const evaluateConfigBagWith = (evaluator, bag) => {
 export function evaluateConfigBagInScope(bag, predicateScope, boundRecord, pageVariables) {
     if (!isConfigBag(bag))
         return bag;
-    const evaluator = new ExpressionEvaluator(configEvaluationScope(predicateScope, boundRecord, pageVariables));
+    const evaluator = new ExpressionEvaluator(buildNodeEvaluationScope(predicateScope, boundRecord, pageVariables));
     return evaluateConfigBagWith(evaluator, bag);
 }
 /**
@@ -549,7 +582,7 @@ export function evaluateConfigBagInScope(bag, predicateScope, boundRecord, pageV
  * ## The defect this closes
  *
  * `evaluateCondition` answers an unevaluable predicate with `true` on every
- * path. On the four SHOW legs the chain negates that answer, so the node is
+ * path. On the three SHOW legs the chain negates that answer, so the node is
  * SHOWN and the reporter's "the gate did NOT bite" is true. On the two HIDE
  * legs the chain returns it UN-negated (see `shouldHide` below), so the same
  * `true` sets `_hidden` and this component returns `null`: the gate bit, and
@@ -839,7 +872,38 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
     // Ambient host scope (user / features), fed by app-shell's
     // ExpressionProvider. Threaded into `visible`/expression evaluation so
     // component predicates can gate on the signed-in user & deployment flags.
-    const predicateScope = usePredicateScope();
+    const ambientScope = usePredicateScope();
+    // ── The API binding (objectui#12197) ──────────────────────────────────────
+    //
+    // `@objectstack/spec`'s `ElementApiDataSourceSchema` declares what a node
+    // with `dataSource: { provider: 'api', read: { url }, path? }` does: it reads
+    // that one same-origin endpoint with the host's signed-in fetch and binds the
+    // selected value, "which the element reads as `data` in its expression holes
+    // and its `visibleWhen`". Both are evaluated in the memo below, so this is
+    // where the binding is honoured, for every node type: the read is the hook's
+    // (`element-data-source/useElementApiDataSource.ts`), and its answer becomes
+    // the `data` root of this node's evaluation scope.
+    //
+    // ⚠️ This is NOT the adapter-as-`data` root objectui#9308 retired. That root
+    // published the injected adapter, against which every `data.*` path resolved
+    // `undefined`; this one is the value the node's own binding selected, and it
+    // exists only on a node that declares one. A node with no API binding is
+    // byte-for-byte what it was: `ambientScope` passes through untouched.
+    //
+    // The answer is also published to the node's SUBTREE through
+    // `PredicateScopeProvider` (below), because a block's members are evaluated
+    // there — `useConfigBagEvaluator` reads the predicate scope, as does every
+    // nested `SchemaRenderer` — so a member's `${data.x}` resolves against the
+    // same value as the node's own.
+    //
+    // The evaluation memo builds its scope from the answer's VALUE (the hook's
+    // state) and keys on it, never on a memo's identity (AGENTS.md #10). The
+    // subtree's copy is memoised for cost only: an evaluation keyed on it
+    // recomputes the same values if React discards it.
+    const apiBinding = useElementApiDataSource(schema);
+    const apiStatus = apiBinding.status;
+    const apiData = apiBinding.data;
+    const subtreeScope = useMemo(() => (apiStatus === 'ready' ? { ...ambientScope, data: apiData } : ambientScope), [ambientScope, apiStatus, apiData]);
     // The row the page is about, from `RecordContextProvider` (objectui#5454).
     //
     // `@objectstack/spec` has always DECLARED that a component node's
@@ -902,6 +966,9 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
         // an object spread.
         if (!schema || typeof schema !== 'object')
             return schema;
+        // The scope's host roots, plus the node's API-bound `data` once it has
+        // answered (see "The API binding" above).
+        const predicateScope = apiStatus === 'ready' ? { ...ambientScope, data: apiData } : ambientScope;
         // The ambient host scope, plus the roots this tier can answer itself.
         // `current_user` is aliased to `user` so both `user.email` and
         // `current_user.email` resolve in component `visible`/`visibleOn`
@@ -940,14 +1007,22 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
         // no row of its own" into "this surface's row is empty" — only the latter
         // is entitled to shadow.
         //
-        // Built by `configEvaluationScope`, which `useConfigBagEvaluator` shares, so
-        // an action container's members evaluate against this same scope
-        // (objectui#10290).
-        const evaluator = new ExpressionEvaluator(configEvaluationScope(predicateScope, boundRecord, pageVariables));
+        // Built by `buildNodeEvaluationScope`, which `useConfigBagEvaluator`
+        // shares, so an action container's members evaluate against this same
+        // scope (objectui#10290), and which the `page:tabs` badge in
+        // `@object-ui/components` calls for its `visibleWhen` gates
+        // (objectui#12992).
+        const evaluator = new ExpressionEvaluator(buildNodeEvaluationScope(predicateScope, boundRecord, pageVariables));
         // Shallow copy: the interpreter's working copy, typed as renderer state
         // rather than as the authoring face (objectui#11349). See
         // `InterpreterWorkingCopy` for what it declares and why.
         const newSchema = { ...schema };
+        // A node whose API binding has not answered is not evaluated: its holes
+        // name a `data` that does not exist yet, so evaluating them would report
+        // every one as unresolvable and decide its `visibleWhen` against nothing.
+        // The render pass below draws the binding's state instead.
+        if (apiStatus !== 'absent' && apiStatus !== 'ready')
+            return newSchema;
         /**
          * Evaluate ONE visibility predicate, and make an unresolvable one LOUD
          * (objectui#5454, leg 3 of the 2026-08-21 ruling).
@@ -1201,7 +1276,9 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
         //
         // A DATA OBJECT on any other key ({@link isDataObjectValue},
         // objectui#10288) is handed over as authored: `evaluate` would collapse
-        // one that carries a string `source` to that string.
+        // one that carries a string `source` to that string. An inline locale map
+        // is the one object that is not: each member is evaluated like a plain
+        // string on the same key (objectui#12936, `utils/localeMap.ts`).
         //
         // The rule itself is `evaluateConfigValueWith`, at module scope, so that
         // `useConfigBagEvaluator` applies the same one to an action container's
@@ -1244,8 +1321,10 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
         //
         // ONE key is deep, by that separate decision, and on both spellings at once:
         // `params` (objectui#7867, ruling A) — every string leaf of a `params` bag
-        // is evaluated, through {@link evaluateConfigValue} above. Every other key
-        // keeps the shallow reading this paragraph describes.
+        // is evaluated, through {@link evaluateConfigValue} above. ONE value shape
+        // is one level deep, on any non-predicate key and both spellings: an inline
+        // locale map's members (objectui#12936). Every other value keeps the
+        // shallow reading this paragraph describes.
         //
         // "Passed through" used to have one exception: `evaluate` unwraps an object
         // with a string `source` to that string, so a data object carrying a
@@ -1560,12 +1639,13 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
          * above rather than re-listed here.
          */
         reportRefusedPropsPredicate(newSchema.type, newSchema.id, NODE_GATE_PREDICATE_KEYS, propsWithoutCanonicalKeys(newSchema.props, newSchema.properties));
-        // Evaluate visibility: visibleWhen / visible / visibleOn / visibility / hidden / hiddenOn
+        // Evaluate visibility: visibleWhen / visible / visibleOn / hidden / hiddenOn
         const shouldHide = (() => {
             // `visibleWhen` is the single canonical conditional-visibility predicate
             // across every layer since ADR-0089 (show-when-truthy), and it is the one
             // this shape DECLARES: `PageComponentSchema` is a closed object that
-            // declares `visibleWhen` (+ the deprecated `visibility`) and REFUSES a
+            // declares `visibleWhen` (its old `visibility` spelling is retired, see
+            // `WorkingCopyAuthoredKeys`) and REFUSES a
             // node-level `visible` outright, with the prescription "move it up one
             // level to the component node's own `visibleWhen` … inside `properties`
             // it is hoisted onto the node by the renderer but evaluated by nothing"
@@ -1585,23 +1665,17 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
                 return !evaluateVisibilityPredicate(newSchema.visibleWhen, 'visibleWhen');
             }
             // `visible` — objectui's own `BaseSchema` tier (`@object-ui/types`), and
-            // the landing spot of a hoisted `properties.visible`. Kept ABOVE the two
-            // deprecated aliases: they normalize into `visibleWhen` at parse, so a
-            // spec-parsed page never reaches them, and re-ranking them would move
+            // the landing spot of a hoisted `properties.visible`. Kept ABOVE
+            // `BaseSchema`'s deprecated `visibleOn`: re-ranking it would move
             // verdicts for raw metadata that objectui#5454 did not rule on.
             if (newSchema.visible !== undefined) {
                 return !evaluateVisibilityPredicate(newSchema.visible, 'visible');
             }
-            // @deprecated ADR-0089 → `visibleWhen`. Defensive read for raw /
-            // un-normalized metadata reaching the renderer.
+            // `BaseSchema.visibleOn`, @deprecated ADR-0089 → `visibleWhen`.
+            // objectui's own node key; the spec's page component never declared it.
             if (newSchema.visibleOn !== undefined) {
                 return !evaluateVisibilityPredicate(newSchema.visibleOn, 'visibleOn');
             }
-            // @deprecated ADR-0089 → `visibleWhen` (was PageNodeSchema.visibility,
-            // an ExpressionInput) — show-when-truthy, same semantics as `visibleOn`.
-            if (newSchema.visibility !== undefined) {
-                return !evaluateVisibilityPredicate(newSchema.visibility, 'visibility');
-            }
             // Ask "is a `hidden` gate DECLARED?" — not "is the key present?"
             // (objectui#3955). These two legs are the only ones in this chain whose
             // verdict is NOT negated, so the evaluator's single default for "there is
@@ -1645,7 +1719,7 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
         // as an internal flag either: `_disabled` is forwarded below as a real
         // `disabled` prop.
         //
-        // The `visible` / `visibleWhen` / `visibleOn` / `visibility` legs above keep
+        // The `visible` / `visibleWhen` / `visibleOn` legs above keep
         // `!== undefined` deliberately: their `true` is NEGATED, so an empty predicate
         // already lands on "shown", which is what "no gate" means anyway, and
         // narrowing them would change ALIAS PRECEDENCE rather than fix anything. The
@@ -1683,7 +1757,7 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
             newSchema._disabled = true;
         }
         return newSchema;
-    }, [schema, dataSource, predicateScope, pageVariables, boundRecord]);
+    }, [schema, dataSource, ambientScope, pageVariables, boundRecord, apiStatus, apiData]);
     /**
      * SDUI scoped styling (ADR-0065): a node's `responsiveStyles` compiles to
      * id-scoped CSS injected as a `<style>` tag, and a scope class is appended to
@@ -1762,6 +1836,17 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
     // component type: undefined" box, which said nothing true about the input.
     if (typeof evaluatedSchema !== 'object')
         return _jsx(_Fragment, { children: String(evaluatedSchema) });
+    // The API binding's non-final states (objectui#12197), drawn in place of the
+    // node — before its visibility, which may read `data` and so cannot be
+    // decided yet. A refused binding names the spec's refusal; nothing was read.
+    // The error panel titles itself in the page's language: its translation
+    // hook mounts with it, never in this body, which runs for every node.
+    if (apiStatus === 'loading') {
+        return _jsx(ElementDataSourceLoadingPanel, { testId: String(evaluatedSchema.type) });
+    }
+    if (apiStatus === 'refused' || apiStatus === 'error') {
+        return (_jsx(ElementApiDataSourcePanel, { testId: String(evaluatedSchema.type), state: apiStatus, message: apiBinding.error }));
+    }
     // Handle visibility: if evaluated schema is hidden, render nothing.
     //
     // Reads AFTER the primitive narrowing above (objectui#4548) so the property
@@ -1800,7 +1885,7 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
     // Note: We don't forward the ref to the Component because components in the registry
     // may not support refs. The SchemaRenderer itself can still receive refs for its own use.
     // Extract schema metadata properties that should NOT be passed as React props
-    const { type: _type, children: _children, body: _body, schema: _schema, visible: _visible, visibleWhen: _visibleWhen, visibleOn: _visibleOn, visibility: _visibility, hidden: _hidden, hiddenOn: _hiddenOn, disabled: _disabled, disabledOn: _disabledOn, 
+    const { type: _type, children: _children, body: _body, schema: _schema, visible: _visible, visibleWhen: _visibleWhen, visibleOn: _visibleOn, hidden: _hidden, hiddenOn: _hiddenOn, disabled: _disabled, disabledOn: _disabledOn, 
     // stripped: `PageComponentSchema.dataSource` is the spec's per-element data
     // BINDING (`{ object, view, filter, sort, limit }`) — schema metadata, like
     // `visibleWhen` above, not a visual prop. Renderers that consume it read
@@ -2023,6 +2108,10 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
                 ...props
             })] }));
     debugTimeEnd(`render:${evaluatedSchema.type}:${evaluatedSchema.id ?? 'anon'}`);
+    // The bound value reaches the subtree as `data` (see "The API binding").
+    const output = apiStatus === 'ready'
+        ? _jsx(PredicateScopeProvider, { scope: subtreeScope, children: rendered })
+        : rendered;
     // Report render perf to DebugCollector when debug mode is active
     if (isDebug && renderStart) {
         const durationMs = performance.now() - renderStart;
@@ -2033,6 +2122,6 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
             timestamp: Date.now(),
         });
     }
-    return rendered;
+    return output;
 });
 SchemaRenderer.displayName = 'SchemaRenderer';

package/dist/context/AppShellContext.d.ts

@@ -45,6 +45,33 @@ export interface MetadataContextValue extends MetadataCacheState {
      * context values in tests keep working; absent means "always ready".
      */
     getTypeStatus?: (type: string) => MetadataTypeStatus;
+    /**
+     * The object definitions one app reads (objectui#12811): the objects of
+     * `packageId` (`GET /api/v1/meta/object?package=`), plus each of `names`
+     * that package does not hold, fetched by name. Each is shaped exactly as the
+     * same definition in `objects`; `served` holds the same definitions as the
+     * server served them, before views are merged (as `getItemsByType('object')`
+     * holds the whole list). `missing` lists the `names` the server answered
+     * without a definition; `settled` is true once the package list and every
+     * name have been answered.
+     *
+     * With `names` and no `packageId` it is a names-only scope (objectui#12980):
+     * no package list, each of `names` fetched by name, for a reader with no
+     * package to scope by (a page route in an app item without `_packageId`).
+     * With neither it is the whole registry, as `objects` is; `objects` keeps
+     * that meaning everywhere. Optional, as `getTypeStatus` is: a
+     * hand-rolled context without it has nothing narrower to offer, and its
+     * readers read `objects`.
+     */
+    readObjectScope?: (scope: {
+        packageId?: string;
+        names?: readonly string[];
+    }) => {
+        objects: any[];
+        served: any[];
+        missing: readonly string[];
+        settled: boolean;
+    };
 }
 export declare const MetadataCtx: import("react").Context<MetadataContextValue | null>;
 export declare function useMetadata(): MetadataContextValue;

package/dist/context/DiscussionContext.d.ts

@@ -40,6 +40,21 @@ export interface DiscussionContextValue {
     onAddComment?: (text: string, attachments?: DiscussionAttachment[]) => void | Promise<void>;
     onAddReply?: (parentId: string, text: string) => void | Promise<void>;
     onToggleReaction?: (itemId: string, reaction: string) => void | Promise<void>;
+    /**
+     * Edit the text of a comment the viewer wrote (objectui#12268). The feed
+     * offers it on a `comment` row whose `authoredByViewer` the host set. A
+     * returned promise that REJECTS means the edit was not stored: the editor
+     * keeps the draft and the row keeps its old text, and reporting why is the
+     * host's job. Typed by the feed's own item id (`FeedItem['id']`), so the
+     * feed hands it on without a cast.
+     */
+    onEditComment?: (itemId: string | number, text: string) => void | Promise<void>;
+    /**
+     * Delete a comment the viewer wrote (objectui#12268), offered on the same
+     * rows. The host asks for confirmation before it deletes; a rejection means
+     * nothing was deleted.
+     */
+    onDeleteComment?: (itemId: string | number) => void | Promise<void>;
     /** Optional list of users (or any mentionable entities) the comment
      *  input can suggest after the user types `@`. When omitted the input
      *  falls back to free-text @-mentions without autocompletion. */

package/dist/context/DiscussionContext.js

@@ -24,6 +24,8 @@ export const DiscussionContextProvider = ({ children, ...value }) => {
         value.onAddComment,
         value.onAddReply,
         value.onToggleReaction,
+        value.onEditComment,
+        value.onDeleteComment,
         value.mentionSuggestions,
         value.onUploadAttachments,
         value.loading,

package/dist/context/InlineEditContext.d.ts

@@ -50,6 +50,57 @@ export interface ApprovalProgress {
         satisfied: boolean;
     }>;
 }
+/**
+ * The approval state a record surface shows (objectui#2902): whether an
+ * approval is running on the record (`pending`, which drives the status band
+ * and the recall lever) and whether it also forbids edits (`locked`).
+ */
+export interface ApprovalLockState {
+    pending: boolean;
+    locked: boolean;
+}
+/** Input to {@link resolveApprovalLock}. */
+export interface ApprovalLockInput {
+    /**
+     * Whether the approvals read ANSWERED (a 2xx) for this record. When it did,
+     * the open request is the whole answer and the record's `approval_status`
+     * column is not consulted. `false` covers a route that is absent (404 /
+     * 501), a read that has not landed yet, and a read that failed before it
+     * ever answered.
+     */
+    readAnswered: boolean;
+    /**
+     * The open approval on the record, reduced to its lock policy, or `null`
+     * when there is none. For a host this is the pending request it found
+     * (`locked` from the node's `lock_record`); for a renderer it is the verdict
+     * a host threaded through {@link InlineEditContextValue}.
+     */
+    openApproval: {
+        locked: boolean;
+    } | null;
+    /** The record's own `approval_status` value, read only as the fallback. */
+    recordStatus: unknown;
+}
+/**
+ * THE approval-lock rule of a record surface (objectui#12220). The record page
+ * host (`@object-ui/app-shell` `RecordDetailView`) and the detail body's
+ * approval band (`@object-ui/plugin-detail` `DetailView`) both call this, so
+ * the two cannot disagree about when a record is locked.
+ *
+ * 1. An open approval decides: it is pending, and it locks exactly when its
+ *    node's `lockRecord` policy says so (objectui#2902).
+ * 2. With none, an approvals read that ANSWERED means no approval is running:
+ *    not pending, not locked. The record's `approval_status` column is not a
+ *    second opinion there. A composition without the approvals service answers
+ *    the read `200 { data: [] }` and enforces no lock, so a `pending` left in
+ *    the column by any writer would otherwise lock the record with nothing to
+ *    recall and nothing the server refuses.
+ * 3. Only when no read answered does the column stand in: `pending` or
+ *    `in_approval` reads as pending AND locked. It carries no node granularity,
+ *    so it can only mean "locked", the conservative read for a backend that
+ *    mirrors the status but exposes no approvals API (objectui#2618).
+ */
+export declare function resolveApprovalLock({ readAnswered, openApproval, recordStatus, }: ApprovalLockInput): ApprovalLockState;
 export interface InlineEditContextValue {
     /** True while the record is in inline-edit mode. */
     editing: boolean;
@@ -86,6 +137,18 @@ export interface InlineEditContextValue {
      * still get a coherent band. Defaults to `false`.
      */
     approvalPending: boolean;
+    /**
+     * Whether the host's `locked` / `approvalPending` come from an approvals
+     * read that ANSWERED (a 2xx) for this record (objectui#12220). When `true`,
+     * the host's pair is the whole answer and a renderer must not fall back to
+     * the record's `approval_status` column: `false` / `false` then means "no
+     * approval is running", not "this host has no opinion". Feed it to
+     * {@link resolveApprovalLock} as `readAnswered`.
+     *
+     * Omitted ⇒ `false` ⇒ unchanged: a renderer keeps the column as its
+     * fallback, so a host that never learns of this prop renders as before.
+     */
+    approvalReadAnswered?: boolean;
     /**
      * Quorum / per-group tally of the pending approval node, when it aggregates
      * more than one decision (objectstack#4478). Threaded verbatim from the
@@ -218,6 +281,13 @@ export interface InlineEditProviderProps {
      * only know about the lock rendering exactly as before.
      */
     approvalPending?: boolean;
+    /**
+     * Whether `locked` / `approvalPending` come from an approvals read that
+     * answered (objectui#12220; see `InlineEditContextValue`). Omitted ⇒ `false`,
+     * which keeps a renderer's `approval_status` column fallback exactly as
+     * before.
+     */
+    approvalReadAnswered?: boolean;
     /**
      * The pending node's server-computed decision tally (objectstack#4478).
      * Surfaced verbatim so the band can show "2 of 3" / per-group ticks. Omitted

package/dist/context/InlineEditContext.js

@@ -23,8 +23,35 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * context for the draft/editing flags and drives `saving`/`error`/`reset`.
  */
 import React from 'react';
+/**
+ * THE approval-lock rule of a record surface (objectui#12220). The record page
+ * host (`@object-ui/app-shell` `RecordDetailView`) and the detail body's
+ * approval band (`@object-ui/plugin-detail` `DetailView`) both call this, so
+ * the two cannot disagree about when a record is locked.
+ *
+ * 1. An open approval decides: it is pending, and it locks exactly when its
+ *    node's `lockRecord` policy says so (objectui#2902).
+ * 2. With none, an approvals read that ANSWERED means no approval is running:
+ *    not pending, not locked. The record's `approval_status` column is not a
+ *    second opinion there. A composition without the approvals service answers
+ *    the read `200 { data: [] }` and enforces no lock, so a `pending` left in
+ *    the column by any writer would otherwise lock the record with nothing to
+ *    recall and nothing the server refuses.
+ * 3. Only when no read answered does the column stand in: `pending` or
+ *    `in_approval` reads as pending AND locked. It carries no node granularity,
+ *    so it can only mean "locked", the conservative read for a backend that
+ *    mirrors the status but exposes no approvals API (objectui#2618).
+ */
+export function resolveApprovalLock({ readAnswered, openApproval, recordStatus, }) {
+    if (openApproval)
+        return { pending: true, locked: openApproval.locked };
+    if (readAnswered)
+        return { pending: false, locked: false };
+    const columnPending = recordStatus === 'pending' || recordStatus === 'in_approval';
+    return { pending: columnPending, locked: columnPending };
+}
 const InlineEditContext = React.createContext(null);
-export const InlineEditProvider = ({ canEdit = true, locked = false, approvalPending, approvalProgress, approvalIsSubmitter, lockedReason, children, }) => {
+export const InlineEditProvider = ({ canEdit = true, locked = false, approvalPending, approvalReadAnswered = false, approvalProgress, approvalIsSubmitter, lockedReason, children, }) => {
     // A locked record always has an approval running; the converse is what
     // #2902 added. Defaulting this way means an un-migrated host keeps its
     // previous behavior with no code change.
@@ -65,6 +92,7 @@ export const InlineEditProvider = ({ canEdit = true, locked = false, approvalPen
         canEdit,
         locked,
         approvalPending: pending,
+        approvalReadAnswered,
         approvalProgress,
         approvalIsSubmitter,
         lockedReason,
@@ -80,7 +108,7 @@ export const InlineEditProvider = ({ canEdit = true, locked = false, approvalPen
         setSaving,
         setError,
         setFieldErrors,
-    }), [editing, canEdit, locked, pending, approvalProgress, approvalIsSubmitter, lockedReason, draft, autoFocusField, saving, error, fieldErrors, enter, setField, teardown]);
+    }), [editing, canEdit, locked, pending, approvalReadAnswered, approvalProgress, approvalIsSubmitter, lockedReason, draft, autoFocusField, saving, error, fieldErrors, enter, setField, teardown]);
     return _jsx(InlineEditContext.Provider, { value: value, children: children });
 };
 /**