@object-ui/react 17.6.0 → 18.0.0

package/dist/context/ActionContext.js

@@ -13,7 +13,9 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * Components can consume actions without creating their own runner instances.
  */
 import { createContext, useCallback, useContext, useMemo, useState } from 'react';
-import { ActionRunner, } from '@object-ui/core';
+import { ActionRunner, subjectPermissionsOf, } from '@object-ui/core';
+import { useActionRunnerTranslator } from './actionRunnerTranslator.js';
+import { usePredicateScope } from '../hooks/useExpression.js';
 export const ActionCtxReact = createContext(null);
 /**
  * ActionProvider — Provides a shared ActionRunner to the tree.
@@ -34,6 +36,8 @@ export const ActionProvider = ({ children, context = {}, onConfirm, onToast, onM
     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(() => {
         // Normalize the evaluator scope so predicates can use *either* flat
         // (`record`, `user`, `objectName`) *or* the canonical `ctx.*` namespace
@@ -49,6 +53,7 @@ export const ActionProvider = ({ children, context = {}, onConfirm, onToast, onM
                 : { ...context },
         };
         const r = new ActionRunner(normalizedContext);
+        r.setTranslator(translate);
         if (onConfirm)
             r.setConfirmHandler(onConfirm);
         if (onToast)
@@ -69,6 +74,40 @@ export const ActionProvider = ({ children, context = {}, onConfirm, onToast, onM
         return r;
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [JSON.stringify(context)]);
+    // The acting subject the surrounding predicate scope binds as `current_user`
+    // (objectui#11242): 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 runner evaluates
+    // its own gates — `execute`'s `disabled` re-check, `params[].visible`, the
+    // engine's `visible` filter — against ITS bag, which a host seeds with its
+    // own `user` and never with `current_user`. Bound here, every `execute` gate
+    // under this provider answers `current_user.can(…)` and every other
+    // `current_user.*` predicate, whatever else the page mounts. Before, only
+    // `useActionEngine` wrote it onto a shared runner, so the answer depended on
+    // whether the page happened to mount `record:quick_actions`, `record:alert`
+    // or a dashboard (the objectui#6493 "one bag" rule, broken per page).
+    //
+    // The same object, not a copy: the engine answers `can` only for a receiver
+    // IDENTICAL to the bound `current_user`. Only `current_user` is added — the
+    // runner's `user` / `ctx.user` / `os.user` stay the host's object, which
+    // carries the `systemPermissions` the capability gate reads — so on this bag
+    // `user.can(…)` still faults while `current_user.can(…)` answers. With no
+    // scope above this provider (`{}`) nothing is bound, and a host's own
+    // `context.current_user`, if it passed one, is left as it is.
+    //
+    // Bound during render, before any child renders or executes, and 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
+    // new runner (the host `context` changed) is bound again.
+    const subject = usePredicateScope().current_user;
+    const subjectKey = subject === undefined ? '' : JSON.stringify(subject);
+    const subjectPermissions = subjectPermissionsOf(subject);
+    useMemo(() => {
+        if (subject !== undefined)
+            runner.updateContext({ current_user: subject });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [runner, subjectKey, subjectPermissions]);
     const execute = useCallback(async (action) => {
         setLoading(true);
         setError(null);

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. */
@@ -50,6 +65,18 @@ export interface DiscussionContextValue {
     onUploadAttachments?: (files: FileList) => Promise<DiscussionAttachment[]>;
     loading?: boolean;
     error?: Error | null;
+    /**
+     * The host's `sys_activity` read was REFUSED: 401 / 403, or a permission
+     * envelope (objectui#11195). The feed renderers then show a no-permission
+     * state rather than claiming the record has no activity. Produced by the
+     * host that owns the fetch (app-shell `RecordDetailView`), which judges the
+     * rejection with plugin-detail's `isRefusedFeedRead`. A read that answered
+     * with zero rows, a 404, or any other failure is not a refusal and leaves
+     * this unset.
+     */
+    activityDenied?: boolean;
+    /** The same, for the host's `sys_comment` read. */
+    commentsDenied?: boolean;
 }
 export interface DiscussionContextProviderProps extends DiscussionContextValue {
     children: React.ReactNode;

package/dist/context/DiscussionContext.js

@@ -24,10 +24,14 @@ export const DiscussionContextProvider = ({ children, ...value }) => {
         value.onAddComment,
         value.onAddReply,
         value.onToggleReaction,
+        value.onEditComment,
+        value.onDeleteComment,
         value.mentionSuggestions,
         value.onUploadAttachments,
         value.loading,
         value.error,
+        value.activityDenied,
+        value.commentsDenied,
     ]);
     return (_jsx(DiscussionContext.Provider, { value: memo, children: children }));
 };

package/dist/context/DrillNavigationContext.d.ts

@@ -27,6 +27,19 @@ export interface DrillNavigationValue {
      * Open the full list page for `objectName`, scoped by `filter` (an object
      * FIELD name → raw stored value map). Implemented by the app shell as a
      * SPA navigation to the object's list route. Absent when no host wired it.
+     *
+     * ⚠️ `filter` is the widget's AUTHORED filter composed with the click
+     * context, so it may still carry unresolved placeholders — `{current_user_id}`,
+     * `{current_org_id}`, and the relative-date macros. **Resolving them is the
+     * host implementation's job**: call `resolveFilterPlaceholders(filter, scope)`
+     * from `@object-ui/core` with the session scope the host holds
+     * (`useFilterScope`), exactly once, before the value reaches a query or a URL.
+     *
+     * A host that skips it gives ONE drill TWO scopes: the in-place drawer arm is
+     * already scoped by the resolved value, because the `object-data-table` it
+     * renders resolves `schema.filter` in its own fetch, so only the navigate arm
+     * would carry the literal — and a literal placeholder matches no record
+     * (objectui#9022).
      */
     openRecordList?: (objectName: string, filter?: Record<string, unknown>) => void;
 }

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
@@ -95,6 +158,37 @@ export interface InlineEditContextValue {
      * doesn't resolve approvals at all.
      */
     approvalProgress?: ApprovalProgress;
+    /**
+     * Whether the viewer is the SUBMITTER of the pending approval request
+     * (`830ed5803`). Recall is the submitter's lever and the server enforces
+     * exactly that — a non-submitter's recall is refused — so a recall button
+     * lit for everyone who can read the record is a button whose click must
+     * fail. The host resolves the identity (server-resolved `viewer.is_submitter`
+     * on the pending request, with an id comparison as the pre-framework#3310
+     * fallback) for the same reason it resolves `locked`: the renderer stays
+     * DataSource-agnostic and never re-derives who submitted what.
+     *
+     * TRI-STATE, and the third state is the load-bearing one:
+     *   `true`      — the viewer submitted this approval; offer recall.
+     *   `false`     — the host consulted the pending request and this viewer is
+     *                 not its submitter; withdraw the recall affordance.
+     *   `undefined` — the host does not resolve submitter identity at all
+     *                 (no approvals API, band driven by the record's
+     *                 `approval_status` mirror alone). Behaviour is UNCHANGED
+     *                 from before this signal existed: recall stays offered.
+     *
+     * The `undefined` case defaults to *showing* on purpose, mirroring how
+     * `approvalPending` falls back to `locked`: omission preserves a host's
+     * previous behaviour. Defaulting it to "hide" would silently take the
+     * submitter's only unlock lever away from every host that never learns of
+     * this prop — trading a cosmetic defect for a functional loss.
+     *
+     * ⚠️ FEEDBACK ONLY. This decides who is SHOWN the entry, never who MAY
+     * recall: the server authorizes the recall itself and rejects a
+     * non-submitter regardless of what any client renders. Nothing may treat
+     * this as an authorization verdict.
+     */
+    approvalIsSubmitter?: boolean;
     /**
      * Human-readable reason for the approval lock, surfaced as the band's
      * tooltip. Optional — consumers fall back to their own localized default
@@ -104,7 +198,15 @@ export interface InlineEditContextValue {
     /**
      * Draft of user-edited values. Holds ONLY the keys the user actually
      * changed, so the save path never writes computed / read-only / untouched
-     * fields. Read a field's live value as `draft[name] ?? data[name]`.
+     * fields. Read a field's live value from the staged record
+     * `{ ...data, ...draft }`, where `data` is the saved record: an OWN draft
+     * key wins even when its value is empty (`null`, `undefined`, `''`), and
+     * `data[name]` is read only when the key is absent. An own key with an
+     * empty value is a field the user, or a cascade clear, emptied, not an
+     * untouched one. A read that falls back to the saved value there shows the
+     * value the user just removed, and hands an option widget that pruned it
+     * the same value to prune again on every render (objectui#7190,
+     * objectui#10466).
      */
     draft: Record<string, any>;
     /** Field to auto-focus when edit was entered from a specific field. */
@@ -113,6 +215,34 @@ export interface InlineEditContextValue {
     saving: boolean;
     /** Last save error message, or null (driven by the save bar). */
     error: string | null;
+    /**
+     * Per-field reasons from the last rejected save, keyed by field MACHINE NAME
+     * — or `null` when the refusal was not field-scoped (objectui#6868).
+     *
+     * The record-level companion to `error`, and driven by the same component:
+     * `<InlineEditSaveBar>` reads the server's `VALIDATION_FAILED` envelope
+     * through `extractFieldErrors` and publishes the result here, so the field
+     * renderers (`DetailSection`, `HeaderHighlight`) can draw the reason beside
+     * the input the server actually refused. Before this slot existed the save
+     * bar and the field rows had no channel between them — they are SIBLINGS
+     * under this provider in both persistence modes — so an attributed refusal
+     * could only be shown record-level, which is not the in-place hint the
+     * objectui#6868 ruling asked for.
+     *
+     * ⚠️ PRESENTATION ONLY. These are the SERVER's verdicts, transported. The
+     * ruling makes the server the validation authority on the inline-edit
+     * surface: nothing may populate this slot from a client-side rule check, and
+     * nothing may read it as an authorization or acceptance decision. It is text
+     * to render beside an input, nothing more.
+     *
+     * Keyed by machine name because that is what both ends already use — the
+     * draft key the field renderers set, and the `field` the server names — so
+     * no spelling translation sits between the refusal and the input.
+     *
+     * Cleared by `enter()` and by teardown, exactly like `error`, so an
+     * attribution can never outlive the session that produced it.
+     */
+    fieldErrors: Record<string, string> | null;
     /** Enter inline-edit mode, optionally focused on `field`. No-op when `!canEdit`. */
     enter: (field?: string) => void;
     /** Stage a single field edit into the draft. */
@@ -125,6 +255,11 @@ export interface InlineEditContextValue {
     setSaving: (saving: boolean) => void;
     /** Set or clear the save error message (used by the save bar). */
     setError: (error: string | null) => void;
+    /**
+     * Publish or clear the per-field reasons for a rejected save (used by the
+     * save bar). Pass `null` when the refusal was not field-scoped.
+     */
+    setFieldErrors: (errors: Record<string, string> | null) => void;
 }
 export interface InlineEditProviderProps {
     /**
@@ -146,12 +281,27 @@ 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
      * for `first_response` nodes and for hosts that don't read approvals.
      */
     approvalProgress?: ApprovalProgress;
+    /**
+     * Whether the viewer submitted the pending approval request
+     * (`830ed5803`). Surfaced verbatim so the recall affordance is offered to
+     * the submitter only. Omitted ⇒ `undefined` ⇒ recall is offered exactly as
+     * it was before this prop existed (see `InlineEditContextValue`), so a host
+     * that resolves no approval identity is unchanged.
+     */
+    approvalIsSubmitter?: boolean;
     /** Optional human-readable lock reason, surfaced as the band tooltip. */
     lockedReason?: string;
     children: React.ReactNode;

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, 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.
@@ -34,6 +61,7 @@ export const InlineEditProvider = ({ canEdit = true, locked = false, approvalPen
     const [autoFocusField, setAutoFocusField] = React.useState(null);
     const [saving, setSaving] = React.useState(false);
     const [error, setError] = React.useState(null);
+    const [fieldErrors, setFieldErrors] = React.useState(null);
     const enter = React.useCallback((field) => {
         // Object-lifecycle / permission gate: never enter edit on a record the
         // host has marked non-editable, even if a stray affordance fires.
@@ -42,6 +70,7 @@ export const InlineEditProvider = ({ canEdit = true, locked = false, approvalPen
         setAutoFocusField(field ?? null);
         setEditing(true);
         setError(null);
+        setFieldErrors(null);
     }, [canEdit]);
     const setField = React.useCallback((field, value) => {
         setDraft((prev) => ({ ...prev, [field]: value }));
@@ -56,25 +85,30 @@ export const InlineEditProvider = ({ canEdit = true, locked = false, approvalPen
         setAutoFocusField(null);
         setSaving(false);
         setError(null);
+        setFieldErrors(null);
     }, []);
     const value = React.useMemo(() => ({
         editing,
         canEdit,
         locked,
         approvalPending: pending,
+        approvalReadAnswered,
         approvalProgress,
+        approvalIsSubmitter,
         lockedReason,
         draft,
         autoFocusField,
         saving,
         error,
+        fieldErrors,
         enter,
         setField,
         cancel: teardown,
         reset: teardown,
         setSaving,
         setError,
-    }), [editing, canEdit, locked, pending, approvalProgress, lockedReason, draft, autoFocusField, saving, error, enter, setField, teardown]);
+        setFieldErrors,
+    }), [editing, canEdit, locked, pending, approvalReadAnswered, approvalProgress, approvalIsSubmitter, lockedReason, draft, autoFocusField, saving, error, fieldErrors, enter, setField, teardown]);
     return _jsx(InlineEditContext.Provider, { value: value, children: children });
 };
 /**

package/dist/context/PrintPageContext.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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 type { PagePrint } from '@objectstack/spec/ui';
+/**
+ * PrintPageContext — the `print` declaration of the page this subtree renders
+ * in, or `null` outside a print page (objectui#11958, card ② of the ruling of
+ * record on objectstack#8346).
+ *
+ * A page that declares `print` is a document: its blocks come from the spec's
+ * printable block subset (`PRINTABLE_PAGE_COMPONENT_TYPES` in
+ * `@objectstack/spec/ui`), and each of those blocks has to reach paper WHOLE.
+ * Most of them already do. The ones that draw a window of their data on screen
+ * read this context to stop doing so silently: `record:line_items` names its
+ * row cap when the cap cut lines off, and a collapsible `record:details`
+ * section draws open, because a closed section never reaches paper.
+ *
+ * Published by `PageRenderer` (`@object-ui/components`) for a page whose
+ * `print` is an object. The value is the declaration itself, so a block that
+ * ever needs one of its keys reads it from here rather than from a second
+ * channel. Defaults to `null`, so every page that does not declare `print` is
+ * untouched.
+ */
+declare const PrintPageContext: import("react").Context<{
+    paperSize?: "A4" | "A5" | "Letter" | "Legal" | undefined;
+    orientation?: "portrait" | "landscape" | undefined;
+    margins?: {
+        top?: number | undefined;
+        right?: number | undefined;
+        bottom?: number | undefined;
+        left?: number | undefined;
+    } | undefined;
+    repeatHeader?: boolean | undefined;
+    repeatFooter?: boolean | undefined;
+    pageNumbers?: boolean | undefined;
+    repeatTableHeaders?: boolean | undefined;
+    avoidBreakInside?: boolean | undefined;
+} | null>;
+export declare const PrintPageProvider: import("react").Provider<{
+    paperSize?: "A4" | "A5" | "Letter" | "Legal" | undefined;
+    orientation?: "portrait" | "landscape" | undefined;
+    margins?: {
+        top?: number | undefined;
+        right?: number | undefined;
+        bottom?: number | undefined;
+        left?: number | undefined;
+    } | undefined;
+    repeatHeader?: boolean | undefined;
+    repeatFooter?: boolean | undefined;
+    pageNumbers?: boolean | undefined;
+    repeatTableHeaders?: boolean | undefined;
+    avoidBreakInside?: boolean | undefined;
+} | null>;
+/** The enclosing page's `print` declaration, or `null` outside a print page. Safe outside a provider. */
+export declare const usePrintPage: () => PagePrint | null;
+export { PrintPageContext };

package/dist/context/PrintPageContext.js

@@ -0,0 +1,32 @@
+/**
+ * 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 { createContext, useContext } from 'react';
+/**
+ * PrintPageContext — the `print` declaration of the page this subtree renders
+ * in, or `null` outside a print page (objectui#11958, card ② of the ruling of
+ * record on objectstack#8346).
+ *
+ * A page that declares `print` is a document: its blocks come from the spec's
+ * printable block subset (`PRINTABLE_PAGE_COMPONENT_TYPES` in
+ * `@objectstack/spec/ui`), and each of those blocks has to reach paper WHOLE.
+ * Most of them already do. The ones that draw a window of their data on screen
+ * read this context to stop doing so silently: `record:line_items` names its
+ * row cap when the cap cut lines off, and a collapsible `record:details`
+ * section draws open, because a closed section never reaches paper.
+ *
+ * Published by `PageRenderer` (`@object-ui/components`) for a page whose
+ * `print` is an object. The value is the declaration itself, so a block that
+ * ever needs one of its keys reads it from here rather than from a second
+ * channel. Defaults to `null`, so every page that does not declare `print` is
+ * untouched.
+ */
+const PrintPageContext = createContext(null);
+export const PrintPageProvider = PrintPageContext.Provider;
+/** The enclosing page's `print` declaration, or `null` outside a print page. Safe outside a provider. */
+export const usePrintPage = () => useContext(PrintPageContext);
+export { PrintPageContext };

package/dist/context/RecordContext.d.ts

@@ -13,6 +13,7 @@
  * receive props from the schema tree.
  */
 import React from 'react';
+import type { DataSource } from '@object-ui/types';
 export declare const HighlightFieldsProvider: React.FC<{
     children: React.ReactNode;
 }>;
@@ -27,10 +28,42 @@ export declare function useRegisterHighlightFields(instanceId: string, names: st
 export interface RecordContextValue<TData = any, TObjectSchema = any> {
     /** Object machine name, e.g. "crm_opportunity". */
     objectName: string;
-    /** Primary key value of the record being displayed. */
-    recordId: string | number | null | undefined;
-    /** Optional datasource id; mirrors the page-level datasource override. */
-    dataSource?: string;
+    /**
+     * Primary key value of the record being displayed, as a `string` -- the one
+     * spelling `@objectstack/spec` declares on every record door (get, update,
+     * delete and the batch operation are all `z.string()`), so this consumer
+     * type is no longer wider than the protocol (objectui#9333).
+     *
+     * A host whose primary keys are numeric does NOT stringify at its call
+     * sites: `RecordContextProviderProps` still accepts `string | number`, and
+     * the provider pays the conversion once, below.
+     *
+     * `LineItemsPanel` reads this member as a `string` and hands it to a
+     * `string` parameter with no assertion in between, which is what
+     * objectui#9304 had to leave behind. That is a statement about that one
+     * reader, not about every reader: three `record:*` renderers in
+     * `@object-ui/plugin-detail` -- `record-details`, `record-quick-actions` and
+     * `record-alert` -- still read it through an `as any`. Those casts are
+     * redundant now rather than load-bearing, and removing them was left outside
+     * objectui#9333 deliberately.
+     */
+    recordId: string | null | undefined;
+    /**
+     * The data adapter the page is bound to, as the host resolved it — the same
+     * object the host hands `SchemaRendererProvider`, forwarded so that
+     * `record:*` renderers can self-fetch (related lists, activity, the
+     * reference rail) without re-plumbing it through the schema tree.
+     *
+     * Typed `DataSource`, not an id: every producer has always passed the
+     * adapter, and every reader has always called adapter methods on it
+     * (objectui#9197). `getObjectSchema` is a REQUIRED member of `DataSource`,
+     * so a reader gets the compiler's answer about it instead of a cast.
+     *
+     * Optional: hosts that render a record with no adapter bound (the Studio
+     * designer and palette previews) leave it undefined, and renderers treat
+     * that as "cannot self-fetch" rather than throwing.
+     */
+    dataSource?: DataSource;
     /** Loaded record data (flat record map). Undefined while loading. */
     data?: TData;
     /** Resolved object metadata schema (fields, label, etc.). */
@@ -68,7 +101,17 @@ export interface RecordContextValue<TData = any, TObjectSchema = any> {
      */
     embedded?: boolean;
 }
-export interface RecordContextProviderProps extends RecordContextValue {
+/**
+ * Props of `RecordContextProvider` -- THE injection boundary (objectui#9333).
+ *
+ * Identical to `RecordContextValue` except for `recordId`, the one member a
+ * host may still hand over in the wider shape its backend actually holds. The
+ * provider narrows it to the protocol's `string` exactly once, here, so no
+ * consumer downstream carries a `String(...)` or a cast.
+ */
+export interface RecordContextProviderProps extends Omit<RecordContextValue, 'recordId'> {
+    /** Primary key as the host holds it; narrowed to `string` on the way in. */
+    recordId: string | number | null | undefined;
     children: React.ReactNode;
 }
 export declare const RecordContextProvider: React.FC<RecordContextProviderProps>;

package/dist/context/RecordContext.js

@@ -87,7 +87,16 @@ const NOOP_SUBSCRIBE = (_) => () => { };
 const GET_EMPTY = () => EMPTY_SET;
 const EMPTY_SET = new Set();
 const RecordContext = React.createContext(null);
-export const RecordContextProvider = ({ children, ...value }) => {
+export const RecordContextProvider = ({ children, recordId, ...rest }) => {
+    // The whole conversion for this contract, in one typed place. Gated on
+    // `typeof` rather than written as an unconditional `String(...)`: `null` and
+    // `undefined` mean "no record bound", and stringifying them would hand
+    // consumers the literal ids "null" / "undefined". A falsiness gate would be
+    // wrong in the other direction -- a numeric `0` is a real primary key.
+    const value = {
+        ...rest,
+        recordId: typeof recordId === 'number' ? String(recordId) : recordId,
+    };
     // Memoize so consumers that rely on referential equality don't re-render
     // on unrelated parent renders.
     const memo = React.useMemo(() => value, [