@object-ui/react 17.6.0 → 18.0.0

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

@@ -0,0 +1,198 @@
+/**
+ * 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 renderer half of the spec's API binding of a page element (objectui#12197):
+ * `PageComponentSchema.dataSource` as `ElementApiDataSourceSchema`,
+ *
+ * ```json
+ * { "provider": "api", "read": { "url": "/api/v1/cloud/home" }, "path": "data" }
+ * ```
+ *
+ * The spec states what a renderer does with it: the element reads ONE
+ * same-origin endpoint with the console's signed-in fetch and binds the selected
+ * value, "which the element reads as `data` in its expression holes and its
+ * `visibleWhen`". `SchemaRenderer` is the one place both of those are evaluated,
+ * so it calls {@link useElementApiDataSource} for every node and binds the
+ * answer as the `data` root (see "The API binding" there). This module owns the
+ * read itself.
+ *
+ * ## The binding is judged by the spec's own schema
+ *
+ * A node's `dataSource` reaches the renderer as stored metadata, unparsed. The
+ * hook parses it with `ElementApiDataSourceSchema` before it reads anything,
+ * so a binding the spec refuses — an absolute or protocol-relative `url`, a
+ * credential key, a `method` other than `GET`, a malformed `path` — is
+ * `refused` here with the spec's own message, and no request is sent. There is
+ * no second, hand-kept same-origin rule in this repo to drift from the
+ * contract's.
+ *
+ * A `dataSource` that is not an API binding (absent, or the object binding
+ * `useElementDataSource` reads) is `absent` here: the two shapes are told apart
+ * by `provider: 'api'`, the spec's discriminator.
+ *
+ * ## The read
+ *
+ * Through `SchemaRendererContext.apiFetch`, the host's authenticated fetch the
+ * console hands every renderer (`ConsoleShell`), falling back to the global
+ * fetch only when no host supplies one — the rule every `apiFetch` reader in
+ * the tree follows. `GET`, `Accept: application/json`, `credentials: 'include'`.
+ * A non-2xx answer, a body that is not JSON, or a `path` that selects nothing
+ * is `error`, with a sentence naming which; the value is never guessed.
+ *
+ * Concurrent elements that bind the same URL share ONE request: {@link
+ * readElementApi} keeps a pending request per URL and forgets it the moment it
+ * settles, so it caches no answer (the shape `readStorageUsage` uses).
+ *
+ * @module
+ */
+import { useContext, useEffect, useMemo, useState } from 'react';
+import { ElementApiDataSourceSchema } from '@objectstack/spec/ui';
+import { SchemaRendererContext } from '../context/SchemaRendererContext.js';
+import { isConfigBag } from '../utils/configBag.js';
+/**
+ * Is this `dataSource` value the API binding — whatever it says beyond
+ * `provider`? `provider: 'api'` is the spec's discriminator between the two
+ * shapes of `PageComponentSchema.dataSource`; the object binding carries no
+ * `provider`.
+ */
+export function isElementApiDataSourceShape(value) {
+    return isConfigBag(value) && value.provider === 'api';
+}
+/**
+ * Judge a node's `dataSource` as an API binding: `absent` when it is not one,
+ * `refused` with the spec's message when the spec refuses it, otherwise the
+ * parsed binding.
+ */
+export function judgeElementApiDataSource(value) {
+    if (!isElementApiDataSourceShape(value))
+        return { status: 'absent' };
+    const parsed = ElementApiDataSourceSchema.safeParse(value);
+    if (!parsed.success) {
+        return {
+            status: 'refused',
+            error: parsed.error.issues.map((issue) => issue.message).join(' '),
+        };
+    }
+    return { status: 'parsed', config: parsed.data };
+}
+/**
+ * Select `path` (dotted segments; a numeric segment indexes an array) from a
+ * response body. `found: false` when any segment has nothing under it — an
+ * absent key, not a key whose value is `undefined`, is what "selects nothing"
+ * means.
+ */
+export function selectElementApiPath(body, path) {
+    if (!path)
+        return { found: true, value: body };
+    let current = body;
+    for (const segment of path.split('.')) {
+        if (Array.isArray(current) && /^\d+$/.test(segment)) {
+            const index = Number(segment);
+            if (index >= current.length)
+                return { found: false, segment };
+            current = current[index];
+            continue;
+        }
+        if (!isConfigBag(current) || !Object.prototype.hasOwnProperty.call(current, segment)) {
+            return { found: false, segment };
+        }
+        current = current[segment];
+    }
+    return { found: true, value: current };
+}
+/** Pending reads, keyed by URL. An entry lives exactly as long as its request. */
+const IN_FLIGHT = new Map();
+/**
+ * `GET url` through `doFetch`, resolving with the parsed JSON body. Rejects on
+ * a network failure, a non-2xx answer or a body that is not JSON. Callers that
+ * ask while a read of the same URL is pending share it.
+ */
+export function readElementApi(url, doFetch) {
+    const pending = IN_FLIGHT.get(url);
+    if (pending)
+        return pending;
+    const request = doFetch(url, {
+        method: 'GET',
+        headers: { Accept: 'application/json' },
+        credentials: 'include',
+    })
+        .then(async (res) => {
+        if (!res.ok)
+            throw new Error(`GET ${url} answered ${res.status}.`);
+        try {
+            return await res.json();
+        }
+        catch {
+            throw new Error(`GET ${url} did not answer JSON.`);
+        }
+    })
+        .finally(() => {
+        IN_FLIGHT.delete(url);
+    });
+    IN_FLIGHT.set(url, request);
+    return request;
+}
+/**
+ * Resolve a node's API binding: read its endpoint and select its `path`.
+ *
+ * Called unconditionally by `SchemaRenderer` for every node; a node without an
+ * API binding costs one `isPlainObject` test and issues no request.
+ */
+export function useElementApiDataSource(schema) {
+    const context = useContext(SchemaRendererContext);
+    const doFetch = context?.apiFetch ?? fetch;
+    const raw = isConfigBag(schema) ? schema.dataSource : undefined;
+    // Keyed on the binding's CONTENT, never on its identity (AGENTS.md #10): a
+    // re-render that hands over an equal binding is the same read.
+    const bindingKey = isElementApiDataSourceShape(raw) ? JSON.stringify(raw) : '';
+    const judged = useMemo(() => judgeElementApiDataSource(bindingKey ? JSON.parse(bindingKey) : undefined), [bindingKey]);
+    const url = judged.status === 'parsed' ? judged.config.read.url : '';
+    const path = judged.status === 'parsed' ? judged.config.path : undefined;
+    const requestKey = url ? JSON.stringify([url, path ?? null]) : '';
+    // The settled answer carries its own key instead of being cleared when the
+    // binding changes, so the effect never sets state synchronously; an answer
+    // whose key no longer matches reads as `loading` (useElementDataSource's rule).
+    const [settled, setSettled] = useState(null);
+    useEffect(() => {
+        if (!url)
+            return;
+        let cancelled = false;
+        readElementApi(url, doFetch).then((body) => {
+            if (cancelled)
+                return;
+            const selected = selectElementApiPath(body, path);
+            setSettled(selected.found
+                ? { key: requestKey, ok: true, data: selected.value }
+                : {
+                    key: requestKey,
+                    ok: false,
+                    error: `dataSource.path "${path}" selects nothing in the answer of GET ${url}: `
+                        + `it has no "${selected.segment}".`,
+                });
+        }, (error) => {
+            if (cancelled)
+                return;
+            setSettled({
+                key: requestKey,
+                ok: false,
+                error: error instanceof Error ? error.message : `GET ${url} failed.`,
+            });
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [url, path, requestKey, doFetch]);
+    if (judged.status === 'absent')
+        return { status: 'absent' };
+    if (judged.status === 'refused')
+        return { status: 'refused', error: judged.error };
+    if (settled?.key !== requestKey)
+        return { status: 'loading', config: judged.config };
+    if (!settled.ok)
+        return { status: 'error', config: judged.config, error: settled.error };
+    return { status: 'ready', config: judged.config, data: settled.data };
+}

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';

package/dist/hooks/useActionEngine.js

@@ -22,8 +22,9 @@
  * ```
  */
 import { useCallback, useContext, useMemo } from 'react';
-import { ActionEngine, } from '@object-ui/core';
+import { ActionEngine, subjectPermissionsOf, } from '@object-ui/core';
 import { ActionCtxReact } from '../context/ActionContext.js';
+import { usePredicateScope } from './useExpression.js';
 export function useActionEngine(options = {}) {
     const { actions = [], context = {} } = options;
     // When wrapped in an <ActionProvider>, reuse its ActionRunner so that:
@@ -39,7 +40,42 @@ export function useActionEngine(options = {}) {
     // fall back to a self-contained runner constructed from the `context` arg.
     const providerCtx = useContext(ActionCtxReact);
     const sharedRunner = providerCtx?.runner ?? null;
+    // The acting subject the host's predicate scope binds as `current_user`
+    // (objectui#11212): the ONE object `ExpressionProvider` publishes under
+    // `current_user` / `user` / `ctx.user` / `os.user`, carrying the caller's
+    // effective object permissions once they have loaded. The engine filters
+    // `visible` against the RUNNER's bag, which a host seeds with its own `user`
+    // and never with `current_user` — so `current_user.can(…)`, and any other
+    // `current_user.*` predicate, faulted on this path in every state and the
+    // action was hidden even for a grant holder, while the same predicate
+    // answered on every predicate-scope surface. Binding the scope's subject
+    // itself — the same object, not a copy, because the engine answers `can`
+    // only for a receiver IDENTICAL to the bound `current_user` — is what makes
+    // the two paths one bag (objectui#6493). With no host scope (`{}`) nothing
+    // is bound and the path behaves as it always did.
+    //
+    // Only `current_user` is added. The runner's `user` / `ctx.user` / `os.user`
+    // stay the host's own object: it carries what the runner itself reads (the
+    // `systemPermissions` capability set), which the scope's subject does not.
+    //
+    // Since objectui#11242 `<ActionProvider>` binds the same subject on its own
+    // runner, so under a provider mounted INSIDE the predicate scope this write
+    // re-binds the object that is already there. It stays for the two runners
+    // no provider binds: this hook's own standalone runner (no provider at
+    // all), and a shared runner whose provider sits ABOVE the scope — the
+    // console's global provider does (`GlobalActionRuntimeProvider` wraps the
+    // routes, and `ExpressionProvider` is mounted inside them) — where the
+    // provider has no scope to read.
+    const subject = usePredicateScope().current_user;
+    // Keyed on what the binding READS, never on the subject's identity (a
+    // memoised value upstream — AGENTS.md #10): its serialisable fields, and the
+    // permissions map it carries, which the upstream adapter caches per payload
+    // outside React. A discarded-and-recomputed subject with the same content
+    // keeps the engine; the permissions arriving (or leaving) rebuilds it.
+    const subjectKey = subject === undefined ? '' : JSON.stringify(subject);
+    const subjectPermissions = subjectPermissionsOf(subject);
     const engine = useMemo(() => {
+        const bound = subject !== undefined ? { current_user: subject } : {};
         // When standalone (no surrounding `<ActionProvider>`), normalize the
         // context so predicates can use both `record`/`user` and `ctx.*`.
         const normalizedStandalone = (context && Object.keys(context).length > 0)
@@ -48,8 +84,9 @@ export function useActionEngine(options = {}) {
                 ctx: (context.ctx && typeof context.ctx === 'object')
                     ? { ...context, ...context.ctx }
                     : { ...context },
+                ...bound,
             }
-            : context;
+            : { ...context, ...bound };
         const e = sharedRunner ? new ActionEngine(sharedRunner) : new ActionEngine(normalizedStandalone);
         // When sharing a provider runner, MERGE per-render flat keys into the
         // existing `ctx` instead of overwriting it. The provider seeds
@@ -67,13 +104,19 @@ export function useActionEngine(options = {}) {
             const merged = {
                 ...context,
                 ctx: { ...existingCtx, ...callerCtx },
+                ...bound,
             };
             runner.updateContext(merged);
         }
+        else if (sharedRunner && subject !== undefined) {
+            // A caller that passes no per-render keys: the subject is still bound,
+            // onto the same shared runner the location filter reads.
+            e.getRunner().updateContext(bound);
+        }
         e.registerActions(actions);
         return e;
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [sharedRunner, JSON.stringify(actions), JSON.stringify(context)]);
+    }, [sharedRunner, JSON.stringify(actions), JSON.stringify(context), subjectKey, subjectPermissions]);
     const getActionsForLocation = useCallback((location) => engine.getActionsForLocation(location), [engine]);
     const getBulkActions = useCallback(() => engine.getBulkActions(), [engine]);
     const executeAction = useCallback((name, contextOverride) => engine.executeAction(name, contextOverride), [engine]);

package/dist/hooks/useActionRunner.js

@@ -7,6 +7,7 @@
  */
 import { useState, useCallback, useMemo } from 'react';
 import { ActionRunner, } from '@object-ui/core';
+import { useActionRunnerTranslator } from '../context/actionRunnerTranslator.js';
 /**
  * Hook for executing actions with loading state, typed with ActionDef.
  *
@@ -35,8 +36,11 @@ export function useActionRunner(optionsOrContext = {}) {
     const [loading, setLoading] = useState(false);
     const [error, setError] = useState(null);
     const [result, setResult] = useState(null);
+    // The runner's own copy (the generic success toast) in the session's language.
+    const translate = useActionRunnerTranslator();
     const runner = useMemo(() => {
         const r = new ActionRunner(context);
+        r.setTranslator(translate);
         if (onConfirm)
             r.setConfirmHandler(onConfirm);
         if (onToast)

package/dist/hooks/useActionTextLocalizer.d.ts

@@ -40,18 +40,41 @@
  *   AUTHORED text. That is `useObjectLabel`'s own fallback contract; nothing
  *   here overrides it.
  * - **A nameless action is not translatable.** Without `action.name` there is
- *   no `_actions.<name>` key to look up, so the literals pass through.
+ *   no `_actions.<name>` key to look up, so the literals pass through —
+ *   collapsed to the active language like every other caller's (below), since
+ *   an inline action (`element:button`) is often nameless (objectui#12757).
+ * - **The entry is keyed on the action's own object** (objectui#11439): its
+ *   declared `objectName`, else the host object the caller draws it on — the
+ *   object `translateObject` in `@objectstack/spec` stamps on an embedded
+ *   action. Only an action with neither reads `globalActions.<name>`; a bound
+ *   action never does (see `actionSuffixes` in `@object-ui/i18n`). The
+ *   runtime-side resolvers (`useConsoleActionRuntime`, `RecordDetailView`)
+ *   already key the param / description / result-dialog copy the same way, so
+ *   one action reads one bundle node on every surface.
  * - **`confirmText` / `successMessage` are resolved only when the action
  *   DECLARES them.** A bundle must not be able to bolt a confirmation gate
  *   onto an action whose metadata never asked for one (nor a success toast).
  *   Translation localizes what exists; it does not add behaviour. This mirrors
  *   what the already-correct call sites (`RecordDetailView`, `ObjectView`,
  *   `DeclaredActionsBar`) each spelled out by hand.
- * - **`label` is reduced through `pickLocalized` first**, because since rc.6 an
- *   authored `label` may be an `I18nLabel` map rather than a string. The map is
- *   collapsed to the active language BEFORE it is offered to the bundle as the
- *   fallback, so a per-locale literal and a bundle entry cannot disagree about
- *   what "the authored label" is.
+ * - **`outcomeMessages` follows the same rule, entry by entry**
+ *   (`@objectstack/spec` 17.6.0, objectui#11344): each outcome the action
+ *   declares resolves `_actions.<name>.outcomeMessages.<outcome>`; a bundle
+ *   entry for an outcome the action does not declare is never read, so a
+ *   bundle cannot add copy for an answer the author never wrote one for.
+ * - **`label`, `confirmText`, `successMessage`, `errorMessage` and each
+ *   `outcomeMessages` entry are reduced through `pickLocalized` first**,
+ *   because each is an `I18nLabel` — a string or an inline per-locale map. The map is collapsed to the active language
+ *   BEFORE it is offered to the bundle as the fallback, so a per-locale
+ *   literal and a bundle entry cannot disagree about what "the authored text"
+ *   is, and the action runner, which has no language, only ever receives a
+ *   string. `errorMessage` has no bundle key (the spec's action translation
+ *   declares none), so the collapse is all it gets (objectui#12757).
+ * - **The success copy stays a template.** A `${result.*}` token, in a bundle
+ *   entry or in the authored text, passes through this hook untouched: the
+ *   action has not run yet, so there is no result to read. The runner fills
+ *   the token in after the action succeeds, through the same `${result.*}`
+ *   scope `onSuccess.navigate` reads — one interpolation, in one place.
  */
 export interface ActionTextLocalizerOptions {
     /**
@@ -61,9 +84,12 @@ export interface ActionTextLocalizerOptions {
     fallbackLabel?: string;
 }
 /**
- * Returns a copy of `action` with `label` — plus `confirmText` and
- * `successMessage` when the action declares them — resolved from the active
- * locale's bundle, falling back to the authored literals.
+ * Returns a copy of `action` with `label` — plus `confirmText`,
+ * `successMessage`, `errorMessage` and `outcomeMessages` when the action
+ * declares them —
+ * resolved from the active locale's bundle, falling back to the authored
+ * literals. `objectName` is the host object the action is drawn on; the
+ * action's own declared `objectName` wins over it when present.
  */
 export type ActionTextLocalizer = <T extends Record<string, any>>(objectName: string | undefined, action: T, options?: ActionTextLocalizerOptions) => T;
 export declare function useActionTextLocalizer(): ActionTextLocalizer;

package/dist/hooks/useActionTextLocalizer.js

@@ -40,23 +40,49 @@
  *   AUTHORED text. That is `useObjectLabel`'s own fallback contract; nothing
  *   here overrides it.
  * - **A nameless action is not translatable.** Without `action.name` there is
- *   no `_actions.<name>` key to look up, so the literals pass through.
+ *   no `_actions.<name>` key to look up, so the literals pass through —
+ *   collapsed to the active language like every other caller's (below), since
+ *   an inline action (`element:button`) is often nameless (objectui#12757).
+ * - **The entry is keyed on the action's own object** (objectui#11439): its
+ *   declared `objectName`, else the host object the caller draws it on — the
+ *   object `translateObject` in `@objectstack/spec` stamps on an embedded
+ *   action. Only an action with neither reads `globalActions.<name>`; a bound
+ *   action never does (see `actionSuffixes` in `@object-ui/i18n`). The
+ *   runtime-side resolvers (`useConsoleActionRuntime`, `RecordDetailView`)
+ *   already key the param / description / result-dialog copy the same way, so
+ *   one action reads one bundle node on every surface.
  * - **`confirmText` / `successMessage` are resolved only when the action
  *   DECLARES them.** A bundle must not be able to bolt a confirmation gate
  *   onto an action whose metadata never asked for one (nor a success toast).
  *   Translation localizes what exists; it does not add behaviour. This mirrors
  *   what the already-correct call sites (`RecordDetailView`, `ObjectView`,
  *   `DeclaredActionsBar`) each spelled out by hand.
- * - **`label` is reduced through `pickLocalized` first**, because since rc.6 an
- *   authored `label` may be an `I18nLabel` map rather than a string. The map is
- *   collapsed to the active language BEFORE it is offered to the bundle as the
- *   fallback, so a per-locale literal and a bundle entry cannot disagree about
- *   what "the authored label" is.
+ * - **`outcomeMessages` follows the same rule, entry by entry**
+ *   (`@objectstack/spec` 17.6.0, objectui#11344): each outcome the action
+ *   declares resolves `_actions.<name>.outcomeMessages.<outcome>`; a bundle
+ *   entry for an outcome the action does not declare is never read, so a
+ *   bundle cannot add copy for an answer the author never wrote one for.
+ * - **`label`, `confirmText`, `successMessage`, `errorMessage` and each
+ *   `outcomeMessages` entry are reduced through `pickLocalized` first**,
+ *   because each is an `I18nLabel` — a string or an inline per-locale map. The map is collapsed to the active language
+ *   BEFORE it is offered to the bundle as the fallback, so a per-locale
+ *   literal and a bundle entry cannot disagree about what "the authored text"
+ *   is, and the action runner, which has no language, only ever receives a
+ *   string. `errorMessage` has no bundle key (the spec's action translation
+ *   declares none), so the collapse is all it gets (objectui#12757).
+ * - **The success copy stays a template.** A `${result.*}` token, in a bundle
+ *   entry or in the authored text, passes through this hook untouched: the
+ *   action has not run yet, so there is no result to read. The runner fills
+ *   the token in after the action succeeds, through the same `${result.*}`
+ *   scope `onSuccess.navigate` reads — one interpolation, in one place.
  */
 import { useMemo } from 'react';
 import { useObjectLabel, useObjectTranslation, pickLocalized } from '@object-ui/i18n';
+import { isConfigBag } from '../utils/configBag.js';
+/** The declared `I18nLabel` copy, besides `label`, that reaches the runner. */
+const DECLARED_COPY_KEYS = ['confirmText', 'successMessage', 'errorMessage'];
 export function useActionTextLocalizer() {
-    const { actionLabel, actionConfirm, actionSuccess } = useObjectLabel();
+    const { actionLabel, actionConfirm, actionSuccess, actionOutcome } = useObjectLabel();
     const { language } = useObjectTranslation();
     return useMemo(() => {
         return ((objectName, action, options) => {
@@ -69,23 +95,53 @@ export function useActionTextLocalizer() {
                 ? action.name
                 : undefined;
             const displayLabel = authoredLabel || name || options?.fallbackLabel || '';
-            // No name, no translation key: the literals are the answer. The label is
+            // Every declared `I18nLabel` copy collapses the same way, so neither the
+            // bundle fallbacks below nor the nameless return hand the runner a map.
+            const collapsed = { ...action, label: displayLabel };
+            let changed = displayLabel !== action.label;
+            for (const key of DECLARED_COPY_KEYS) {
+                const declaredCopy = action[key];
+                if (declaredCopy === undefined)
+                    continue;
+                collapsed[key] = pickLocalized(declaredCopy, language);
+                if (collapsed[key] !== declaredCopy)
+                    changed = true;
+            }
+            // No name, no translation key: the literals are the answer. They are
             // still normalized (map to string, last-resort placeholder applied) so
             // every caller reads one shape.
             if (!name) {
-                return displayLabel === action.label ? action : { ...action, label: displayLabel };
+                return (changed ? collapsed : action);
             }
+            // The key object: the action's declared `objectName`, else the host the
+            // caller passes (objectui#11439). An action declared on `sales_order`
+            // drawn where the caller knows no object still reads `sales_order`'s
+            // `_actions` node, never `globalActions`.
+            const declared = action.objectName;
+            const keyObject = (typeof declared === 'string' && declared) || objectName;
             const out = {
-                ...action,
-                label: actionLabel(objectName, name, displayLabel),
+                ...collapsed,
+                label: actionLabel(keyObject, name, displayLabel),
             };
             if (action.confirmText !== undefined) {
-                out.confirmText = actionConfirm(objectName, name, action.confirmText);
+                out.confirmText = actionConfirm(keyObject, name, collapsed.confirmText);
             }
             if (action.successMessage !== undefined) {
-                out.successMessage = actionSuccess(objectName, name, action.successMessage);
+                out.successMessage = actionSuccess(keyObject, name, collapsed.successMessage);
+            }
+            // The map is an authored bag (outcome → copy), so the one "is this a
+            // real bag?" predicate in this package answers whether to read it.
+            const authoredOutcomes = action.outcomeMessages;
+            if (isConfigBag(authoredOutcomes)) {
+                const outcomeMessages = {};
+                for (const [outcome, copy] of Object.entries(authoredOutcomes)) {
+                    const text = actionOutcome(keyObject, name, outcome, pickLocalized(copy, language));
+                    if (text !== undefined)
+                        outcomeMessages[outcome] = text;
+                }
+                out.outcomeMessages = outcomeMessages;
             }
             return out;
         });
-    }, [actionLabel, actionConfirm, actionSuccess, language]);
+    }, [actionLabel, actionConfirm, actionSuccess, actionOutcome, language]);
 }

package/dist/hooks/useConfigBagEvaluator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 `properties` evaluation of the `SchemaRenderer` memo, for a node that is
+ * rendered WITHOUT `SchemaRenderer` (objectui#10290).
+ *
+ * `action:bar` (in `@object-ui/components`) mounts its member actions itself,
+ * so a member's `properties` never passes through the memo. Its static
+ * execution values ride `properties.params` (objectui#10289; an `action:group`
+ * / `action:menu` member carries no `properties` bag and its container reads
+ * none, objectui#11638), and those values are templates
+ * evaluated where `properties` are (objectui#7867). This hook is that
+ * evaluation: the memo's per-key rule, its `ExpressionEvaluator`, and its
+ * scope (the host's ambient roots, `current_user`, the page's bound row as
+ * `record`, and page variables as `page`), read from the same contexts the memo
+ * reads. It is not a second template engine. See `evaluateConfigBagInScope`.
+ *
+ * The returned function takes a config bag and returns a new, evaluated bag. A
+ * value that is not a config bag is returned unchanged. Call it once per
+ * authored bag: the result is already evaluated, and evaluating it again would
+ * interpolate text that came out of the row.
+ *
+ * A fresh function each render. Nothing may depend on its identity
+ * (AGENTS.md #10).
+ */
+export declare function useConfigBagEvaluator(): (bag: unknown) => unknown;

package/dist/hooks/useConfigBagEvaluator.js

@@ -0,0 +1,40 @@
+/**
+ * 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 { useRecordContext } from '../context/RecordContext.js';
+import { evaluateConfigBagInScope } from '../SchemaRenderer.js';
+import { usePredicateScope } from './useExpression.js';
+import { usePageVariables } from './usePageVariables.js';
+/**
+ * The `properties` evaluation of the `SchemaRenderer` memo, for a node that is
+ * rendered WITHOUT `SchemaRenderer` (objectui#10290).
+ *
+ * `action:bar` (in `@object-ui/components`) mounts its member actions itself,
+ * so a member's `properties` never passes through the memo. Its static
+ * execution values ride `properties.params` (objectui#10289; an `action:group`
+ * / `action:menu` member carries no `properties` bag and its container reads
+ * none, objectui#11638), and those values are templates
+ * evaluated where `properties` are (objectui#7867). This hook is that
+ * evaluation: the memo's per-key rule, its `ExpressionEvaluator`, and its
+ * scope (the host's ambient roots, `current_user`, the page's bound row as
+ * `record`, and page variables as `page`), read from the same contexts the memo
+ * reads. It is not a second template engine. See `evaluateConfigBagInScope`.
+ *
+ * The returned function takes a config bag and returns a new, evaluated bag. A
+ * value that is not a config bag is returned unchanged. Call it once per
+ * authored bag: the result is already evaluated, and evaluating it again would
+ * interpolate text that came out of the row.
+ *
+ * A fresh function each render. Nothing may depend on its identity
+ * (AGENTS.md #10).
+ */
+export function useConfigBagEvaluator() {
+    const predicateScope = usePredicateScope();
+    const boundRecord = useRecordContext()?.data;
+    const { variables: pageVariables } = usePageVariables();
+    return (bag) => evaluateConfigBagInScope(bag, predicateScope, boundRecord, pageVariables);
+}