@declarion/react 0.38.1 → 0.39.0

package/dist-lib/api/params.d.ts

@@ -1,4 +1,4 @@
-import type { ParamLookup, PublicParamsResponse } from "../types/api";
+import type { ParamLookup, PublicParamsResponse, ResolvedParam } from "../types/api";
 /**
  * Fetches the full pre-login envelope from /api/params/public:
  * {parameters, accents, meta}. Used by AuthShell to theme
@@ -13,15 +13,16 @@ export declare function fetchPublicParams(): Promise<PublicParamsResponse>;
  */
 export declare function fetchParam(code: string): Promise<ParamLookup>;
 /**
- * Persist a parameter override at user scope. Writes via the platform-default
- * user.__update action endpoint (POST /api/actions/user.__update) with the
- * $params subresource block inside `fields`. Per plan 2026-06-01-write-api-final
- * §1.2 the wire envelope is FLAT: `object_ids` is the only reserved key, and
- * `entity` + `fields` sit at the top level (decoded into DataUpdateParams via
- * JSON tags). subresource.ExtractSubResources routes the $params array to
- * declarion.object_params at write time.
+ * Fetches the bulk effective-value view: every declared parameter the caller
+ * may see (disclosure-tiered server-side), each carrying its declaration facets
+ * (scopes / structure / choices) so the admin UIs are self-sufficient.
  *
- * Plan G5/T23 contract: ParameterDef.scopes gates the write server-side;
- * a 400 will surface back to the caller if the scope is not allowed.
+ * `resolution: "tenant"` returns the TENANT BASELINE (yaml/env/tenant sources
+ * only, no role/user overlays) - the lens the tenant Parameters screen edits.
+ * Omit it for the caller's full personal resolution (Profile / attachment).
+ *
+ * NOTE: there is deliberately NO partial-write helper. Parameter overrides are
+ * written through the carrier entity's `__update` action with a FULL `$params`
+ * set (see ParamsBlock); a single-code write would delete every other override.
  */
-export declare function setUserParam(userId: string, code: string, value: unknown): Promise<void>;
+export declare function fetchAllParams(resolution?: "tenant"): Promise<ResolvedParam[]>;

package/dist-lib/components/columns/ColumnPicker.d.ts

@@ -1,10 +1,20 @@
 interface ColumnPickerProps {
+    /** Full column pool for the screen (data columns; never `_select`/`_actions`). */
     availableColumns: string[];
+    /** Ordered visible columns (the `?columns` array). Order is meaningful. */
     visibleColumns: string[];
     onToggle: (col: string) => void;
+    /** Move a visible column one slot up/down in the order (the drag-free,
+     *  keyboard + touch reorder path - WCAG 2.2 SC 2.5.7). Optional: when
+     *  omitted, the reorder controls are not rendered (additive SDK evolution). */
+    onMove?: (col: string, dir: "up" | "down") => void;
     onReset: () => void;
     onShowAll: () => void;
+    /** Reset this device's column widths for the screen to the YAML defaults.
+     *  Widths are a separate, device-local lifecycle from order/visibility.
+     *  Optional: omitting it hides the width-reset item. */
+    onResetWidths?: () => void;
     columnLabel?: (code: string) => string;
 }
-export declare function ColumnPicker({ availableColumns, visibleColumns, onToggle, onReset, onShowAll, columnLabel, }: ColumnPickerProps): import("react").JSX.Element;
+export declare function ColumnPicker({ availableColumns, visibleColumns, onToggle, onMove, onReset, onShowAll, onResetWidths, columnLabel, }: ColumnPickerProps): import("react").JSX.Element;
 export {};

package/dist-lib/components/detail-layout/EvidenceBlock.d.ts

@@ -0,0 +1,6 @@
+import type { EvidenceVerdict } from "../../types/api";
+interface EvidenceBlockProps {
+    evidence: EvidenceVerdict | undefined;
+}
+export declare function EvidenceBlock({ evidence }: EvidenceBlockProps): import("react").JSX.Element;
+export {};

package/dist-lib/components/detail-layout/useManualColumnResize.d.ts

@@ -0,0 +1,25 @@
+import { type CSSProperties, type MouseEvent as ReactMouseEvent } from "react";
+/** Device-store scope key for a detail child table. Stable per (parent entity,
+ *  child entity, foreign key) so a widened child column sticks across reloads
+ *  and across every detail record of that parent. */
+export declare function childLayoutKey(parentEntity: string, childEntity: string, foreignKey: string): string;
+export interface ManualColumnResize {
+    /** Inline style for a resizable header cell (adds position + width). */
+    headerStyle: (colId: string, base: CSSProperties) => CSSProperties;
+    /** Inline style for a body cell (adds width + truncation once resized). */
+    cellStyle: (colId: string, base: CSSProperties) => CSSProperties;
+    /** Attach to a right-edge handle's `onMouseDown` to start a resize drag. */
+    onHandleMouseDown: (colId: string, e: ReactMouseEvent<HTMLElement>) => void;
+    /** True when this table has any stored width overrides (show the reset). */
+    hasWidths: boolean;
+    /** Clear all width overrides for this table (back to natural widths). */
+    resetWidths: () => void;
+}
+export declare function useManualColumnResize(scopeKey: string | null): ManualColumnResize;
+/** A right-edge resize handle for a manually-resized `<th>`. Rendered inside a
+ *  `position: relative` header cell; stops click propagation so it never fires
+ *  a header action. */
+export declare function ManualResizeHandle({ colId, onMouseDown, }: {
+    colId: string;
+    onMouseDown: (colId: string, e: ReactMouseEvent<HTMLElement>) => void;
+}): import("react").JSX.Element;

package/dist-lib/components/list/QuickPeek.d.ts

@@ -1,6 +1,7 @@
 import { type ReactNode } from "react";
 import { type Action, type Entity, type EntityField, type Screen } from "../../types/schema";
 import type { Refs } from "../../components/fields";
+import { type ResolvedActionLayoutNode } from "../../lib/actions";
 export interface QuickPeekRegularFieldSpec {
     key: string;
     label: string;
@@ -25,10 +26,18 @@ export interface QuickPeekProps<R extends Record<string, unknown> = Record<strin
     fields: QuickPeekFieldSpec[];
     /** $refs payload from the list/detail API; used by RefField-style renderers. */
     refs?: Refs;
-    /** Full screen YAML — honors `screen.quick_peek.width` and `quick_peek.primary_action`. */
+    /** Full screen YAML — honors `screen.quick_peek.width`. */
     screen?: Screen;
     /** All actions available on this record. */
     actions: Record<string, Action>;
+    /**
+     * Resolved action_layout (screen overrides entity). The peek footer renders
+     * the `quick_peek` slot through the SAME ResponsiveActionBar as the list
+     * toolbar and detail header: declared top-level actions are buttons, the rest
+     * collapse into the overflow menu. One mechanism everywhere.
+     */
+    screenActionLayout?: ResolvedActionLayoutNode[];
+    entityActionLayout?: ResolvedActionLayoutNode[];
     executeAction: (code: string, action: Action, params: Record<string, unknown>) => Promise<unknown>;
     /**
      * Close the peek.
@@ -42,7 +51,7 @@ export interface QuickPeekProps<R extends Record<string, unknown> = Record<strin
     /** Fires once per explicit user commit — never on keystroke. */
     onSave?: (next: R) => void;
 }
-export declare function QuickPeek<R extends Record<string, unknown>>({ entity, entityCode, record, title, recordId, avatarName, fields, refs, screen, actions, executeAction, onClose, onOpen, onSave, }: QuickPeekProps<R>): import("react").JSX.Element;
+export declare function QuickPeek<R extends Record<string, unknown>>({ entity, entityCode, record, title, recordId, avatarName, fields, refs, screen, actions, screenActionLayout, entityActionLayout, executeAction, onClose, onOpen, onSave, }: QuickPeekProps<R>): import("react").JSX.Element;
 export interface QEFieldProps {
     label: string;
     children: ReactNode;

package/dist-lib/components/pages/list/{ListBulkBar.d.ts → ListFloatbar.d.ts}

@@ -1,9 +1,9 @@
 import { type ResolvedActionLayoutNode } from "../../../lib/actions";
 import { type WidgetContext } from "../../../components/shared/ResponsiveActionBar";
 import type { Action } from "../../../types/schema";
-export interface ListBulkBarProps {
+export interface ListFloatbarProps {
     selectedIds: string[];
-    /** Actions whose visibility includes `list_floatbar` - the bulk pill slot.
+    /** Actions whose visibility includes `list_floatbar` - the floatbar slot.
      *  Reason: the parent owns slot filtering via `getScreenActions(...)`;
      *  passing `toolbarActions` (list_toolbar slice) here silently dropped
      *  __delete (which is list_floatbar/list_row/detail, NOT list_toolbar)
@@ -24,4 +24,4 @@ export interface ListBulkBarProps {
     /** Dispatch surface threaded into ResponsiveActionBar (plan §8 Task 10). */
     widgetContext: WidgetContext;
 }
-export declare function ListBulkBar({ selectedIds, floatbarActions, screenActionLayout, entityActionLayout, data, rowKey, entityCode, onClear, onActionSuccess, widgetContext, }: ListBulkBarProps): import("react").JSX.Element | null;
+export declare function ListFloatbar({ selectedIds, floatbarActions, screenActionLayout, entityActionLayout, data, rowKey, entityCode, onClear, onActionSuccess, widgetContext, }: ListFloatbarProps): import("react").JSX.Element | null;

package/dist-lib/components/pages/list/RowActionsCell.d.ts

@@ -14,14 +14,6 @@ export interface RowActionsCellProps {
     fullScreen: Screen;
     entity: Entity;
     entityCode?: string;
-    /** Gate flags that determine whether the kebab column renders at all.
-     *  After the unified-toolbar Phase 1 cleanup the kebab's Edit/Delete
-     *  affordances come from the __edit / __delete platform-default actions
-     *  (injected server-side at load), so these flags now only control
-     *  column visibility - the legacy trailing-item content they once
-     *  feed has been removed. */
-    hasDefaultEditAction: boolean;
-    hasDefaultDeleteAction: boolean;
     rowActions: {
         code: string;
         action: Action;
@@ -31,8 +23,14 @@ export interface RowActionsCellProps {
         icon?: string;
         search?: string;
     }) => void;
-    onPeek?: () => void;
+    /** Peek availability for this surface (screen quick_peek + not phone). */
+    peekAllowed: boolean;
+    /** Whether the entity has a detail route (drives __open availability). */
+    hasDetailTarget: boolean;
+    /** Opens the Quick peek drawer for the row (used by both the __peek menu
+     *  item and the hover eye button). */
+    onPeek: (row: Record<string, unknown>) => void;
     /** Active UI locale, forwarded into the row-scoped WidgetContext. */
     locale: string;
 }
-export declare function RowActionsCell({ row, rowId, screen, fullScreen, entity, entityCode, hasDefaultEditAction, hasDefaultDeleteAction, rowActions, tabNavigate, onPeek, locale, }: RowActionsCellProps): import("react").JSX.Element;
+export declare function RowActionsCell({ row, rowId, screen, fullScreen, entity, entityCode, rowActions, tabNavigate, peekAllowed, hasDetailTarget, onPeek, locale, }: RowActionsCellProps): import("react").JSX.Element;

package/dist-lib/components/pages/list/RowContextMenu.d.ts

@@ -0,0 +1,29 @@
+import type { Action, Entity, Screen } from "../../../types/schema";
+export interface RowContextMenuProps {
+    /** Cursor coordinates from the contextmenu event. */
+    x: number;
+    y: number;
+    row: Record<string, unknown>;
+    rowId: string;
+    screen: {
+        detail_screen?: string;
+    };
+    fullScreen: Screen;
+    entity: Entity;
+    entityCode?: string;
+    rowActions: {
+        code: string;
+        action: Action;
+    }[];
+    tabNavigate: (href: string, opts?: {
+        title?: string;
+        icon?: string;
+        search?: string;
+    }) => void;
+    locale: string;
+    peekAllowed: boolean;
+    hasDetailTarget: boolean;
+    onPeek: (row: Record<string, unknown>) => void;
+    onClose: () => void;
+}
+export declare function RowContextMenu({ x, y, row, rowId, screen, fullScreen, entity, entityCode, rowActions, tabNavigate, locale, peekAllowed, hasDetailTarget, onPeek, onClose, }: RowContextMenuProps): import("react").JSX.Element | null;

package/dist-lib/components/pages/list/SaveViewDialog.d.ts

@@ -1,6 +1,10 @@
-export declare function SaveViewDialog({ open, pending, onClose, onSave, }: {
+export declare function SaveViewDialog({ open, pending, onClose, onSave, overwriteViewName, onOverwrite, }: {
     open: boolean;
     pending: boolean;
     onClose: () => void;
     onSave: (name: string) => Promise<void>;
+    /** Name of the currently-active OWNED view, when an overwrite is offered. */
+    overwriteViewName?: string | null;
+    /** Overwrite the active owned view with the current layout (widths excluded). */
+    onOverwrite?: () => Promise<void>;
 }): import("react").JSX.Element | null;

package/dist-lib/components/pages/list/cardProjection.d.ts

@@ -28,7 +28,7 @@ export interface ResolveCardArgs {
     screen: Screen | undefined;
     savedViewColumns?: readonly string[];
 }
-export type ProjectionReason = "render" | "display" | "display_template" | "condition" | "identity" | "sort" | "detail_handoff" | "quick_peek" | "ref_expand" | "status_expand" | "property_expand" | "file_metadata";
+export type ProjectionReason = "render" | "display" | "display_template" | "condition" | "identity" | "sort" | "detail_handoff" | "quick_peek" | "ref_expand" | "status_expand" | "property_expand" | "evidence_expand" | "file_metadata";
 export interface ProjectionReasons {
     fields: Record<string, ProjectionReason[]>;
     expand: Record<string, ProjectionReason[]>;

package/dist-lib/components/pages/list/column-sizing.d.ts

@@ -0,0 +1,15 @@
+import type { Table } from "@tanstack/react-table";
+import type { RowData } from "../../../types/api";
+/** CSS custom-property name for a header's width. */
+export declare function headerSizeVar(headerId: string): string;
+/** CSS custom-property name for a column's (cell) width. */
+export declare function colSizeVar(columnId: string): string;
+/** `width` value that reads a size variable, e.g. for a `<th>`/`<td>` style. */
+export declare function sizeFromVar(varName: string): string;
+/**
+ * Compute the full set of `--header-*-size` / `--col-*-size` variables from the
+ * table's current sizing. Reading `columnSizingInfo` + `columnSizing` here
+ * establishes the reactivity so the object recomputes on every resize frame;
+ * memoize it on those two state slices in the component.
+ */
+export declare function buildColumnSizeVars(table: Table<RowData>): Record<string, number>;

package/dist-lib/components/pages/list/columns.d.ts

@@ -25,6 +25,9 @@ export interface BuildListColumnsArgs {
     canUpdate: boolean;
     canDelete: boolean;
     peekEnabled: boolean;
+    /** True when the entity has a detail route; drives __open availability in the
+     *  row menu (composite-PK entities have no detail page). */
+    hasDetailTarget: boolean;
     userLocale: string;
     tabNavigate: (href: string, opts?: {
         title?: string;

package/dist-lib/components/pages/list/useHeaderReorder.d.ts

@@ -0,0 +1,26 @@
+import { type MouseEvent as ReactMouseEvent, type RefObject } from "react";
+export interface HeaderReorder {
+    /** The column currently being dragged, or null. */
+    dragColId: string | null;
+    /** Insertion index among `visibleCols` where a drop would land, or null. */
+    dropIndex: number | null;
+    /** True while an actual drag is in progress (threshold crossed). */
+    isDragging: boolean;
+    /** Attach to a data `<th>`'s `onMouseDown` to arm a potential drag. */
+    onHeaderMouseDown: (colId: string, e: ReactMouseEvent) => void;
+    /** Call at the top of the header's `onClick`; returns true (and resets) when
+     *  the click concludes a drag, so the caller skips the sort. */
+    consumeDragSuppression: () => boolean;
+}
+interface UseHeaderReorderArgs {
+    /** Ordered visible data columns (the `?columns` array). */
+    visibleCols: string[];
+    /** Commit a new order (writes URL + working layout). */
+    onReorder: (nextCols: string[]) => void;
+    /** The horizontal scroll container (for edge auto-scroll). */
+    scrollElRef: RefObject<HTMLElement | null>;
+    /** The `<thead>` element, to measure data-column boundaries at drag start. */
+    theadRef: RefObject<HTMLElement | null>;
+}
+export declare function useHeaderReorder({ visibleCols, onReorder, scrollElRef, theadRef, }: UseHeaderReorderArgs): HeaderReorder;
+export {};

package/dist-lib/components/pages/list/useRowMenu.d.ts

@@ -0,0 +1,47 @@
+import { type ResolvedActionLayoutNode } from "../../../lib/actions";
+import type { ActionRunHandler, WidgetContext } from "../../../components/shared/ResponsiveActionBar";
+import type { Action, Entity, Screen } from "../../../types/schema";
+export interface UseRowMenuArgs {
+    row: Record<string, unknown>;
+    rowId: string;
+    /** detail_screen for row navigation; also carries the server-resolved
+     *  action_layout wire tree (read via cast, per RowActionsCell's note). */
+    screen: {
+        detail_screen?: string;
+    };
+    /** Full Screen for the row-scoped WidgetContext (href/widget dispatch). */
+    fullScreen: Screen;
+    entity: Entity;
+    entityCode?: string;
+    /** list_row-slot actions resolved by getScreenActions (includes the injected
+     *  __peek/__open/__edit/__delete defaults). */
+    rowActions: {
+        code: string;
+        action: Action;
+    }[];
+    tabNavigate: (href: string, opts?: {
+        title?: string;
+        icon?: string;
+        search?: string;
+    }) => void;
+    locale: string;
+    /** Peek availability for THIS surface (screen quick_peek enabled + not phone).
+     *  Drives __peek suppression and the openPeek client verb. */
+    peekAllowed: boolean;
+    /** Whether the entity has a detail route. Drives __open suppression
+     *  (composite-PK entities have no detail page). */
+    hasDetailTarget: boolean;
+    /** Opens the Quick peek drawer for the given row. */
+    onPeek: (row: Record<string, unknown>) => void;
+}
+export interface RowMenu {
+    /** Row-stated + nav-suppressed layout, ready for RowMenuContent. */
+    layout: ResolvedActionLayoutNode[];
+    entityActions: Record<string, Action>;
+    runRowAction: ActionRunHandler;
+    widgetContext: WidgetContext;
+    /** True when a __peek leaf survives resolution + suppression - the single
+     *  source of truth for whether the hover eye button renders (Invariant 7). */
+    hasPeek: boolean;
+}
+export declare function useRowMenu({ row, rowId, screen, fullScreen, entity, entityCode, rowActions, tabNavigate, locale, peekAllowed, hasDetailTarget, onPeek, }: UseRowMenuArgs): RowMenu;

package/dist-lib/components/pages/profile/Profile.d.ts

@@ -1 +1,4 @@
 export declare function Profile(): import("react").JSX.Element;
+export declare function ProfileParamsBlock({ userId }: {
+    userId: string;
+}): import("react").JSX.Element;

package/dist-lib/components/pages/tenant-params/TenantParamsPage.d.ts

@@ -0,0 +1,2 @@
+import type { CustomScreenProps } from "../../../stores/screen-registry";
+export declare function TenantParamsPage(_props: CustomScreenProps): import("react").JSX.Element;

package/dist-lib/components/params/ParamsBlock.d.ts

@@ -0,0 +1,25 @@
+import { type ReactNode } from "react";
+/**
+ * ParamsBlock is the GENERIC, reusable parameter-editing block attached to a
+ * carrier row (a user's Profile, a tenant, or a business entity row). It is
+ * declaration-driven: it renders exactly the parameters whose `scopes:` include
+ * the carrier's scope, and nothing when that attachable set is empty (so an
+ * unrelated entity gets no block - the platform's anti-pollution rule).
+ *
+ * The single dangerous trap it defends: `$params` is a FULL-SET write. The
+ * current override set is ALWAYS sourced from the carrier's PK-detail response
+ * (`$params`); a missing `$params` key is a HARD ERROR here, never treated as an
+ * empty set (which would delete every override). Every save/reset composes the
+ * complete new set client-side and writes it through `<carrier>.__update`.
+ */
+export interface ParamsBlockProps {
+    /** Carrier entity code (the write target, e.g. "profile", "my_tenant"). */
+    carrierEntityCode: string;
+    /** Carrier scope for attachment = entity.params_scope ?? entity.code. */
+    carrierScope: string;
+    /** Carrier row id ($params writes ride object_ids: [rowId]). */
+    rowId: string;
+    title?: string;
+    icon?: ReactNode;
+}
+export declare function ParamsBlock({ carrierEntityCode, carrierScope, rowId, title, icon }: ParamsBlockProps): import("react").JSX.Element | null;

package/dist-lib/components/params/param-editors.d.ts

@@ -0,0 +1,28 @@
+import type { ResolvedParam } from "../../types/api";
+export declare function ErrorLine({ text }: {
+    text: string;
+}): import("react").JSX.Element;
+/** Compact one-line preview: scalars inline; json/structure as a summary chip. */
+export declare function ValuePreview({ type, value, structure }: {
+    type: string;
+    value: unknown;
+    structure?: string;
+}): import("react").JSX.Element;
+/**
+ * EditParamDialog renders the typed editor for one parameter and calls onSave
+ * with the parsed, typed value (throwing invalid input inline before onSave).
+ * The caller composes the full `$params` set and performs the write.
+ */
+export declare function EditParamDialog({ param, current, error, onCancel, onSave }: {
+    param: ResolvedParam;
+    current: unknown;
+    error: string | null;
+    onCancel: () => void;
+    onSave: (value: unknown) => Promise<void> | void;
+}): import("react").JSX.Element;
+/**
+ * paramTenantEditable reports whether a param is editable at TENANT scope:
+ * empty scopes AND non-server category, OR scopes explicitly admits `tenant`
+ * (the server-category waiver case, e.g. mailer_backend). Others are read-only.
+ */
+export declare function paramTenantEditable(param: ResolvedParam): boolean;

package/dist-lib/components/primitives/Dropdown.d.ts

@@ -3,9 +3,18 @@ export type DropdownProps = {
     open: boolean;
     onClose?: () => void;
     anchor: HTMLElement | null;
+    /**
+     * Cursor-point anchoring for context menus: when set (and `anchor` is null),
+     * the menu opens at the point and gets the same viewport clamping / above-
+     * flip as element anchoring. One positioning engine for every popover.
+     */
+    anchorPoint?: {
+        x: number;
+        y: number;
+    };
     align?: "start" | "end";
     width?: number;
     style?: CSSProperties;
     children?: ReactNode;
 };
-export declare function Dropdown({ open, onClose, anchor, children, align, width, style }: DropdownProps): import("react").ReactPortal | null;
+export declare function Dropdown({ open, onClose, anchor, anchorPoint, children, align, width, style }: DropdownProps): import("react").ReactPortal | null;

package/dist-lib/components/shared/ActionDialog.d.ts

@@ -8,10 +8,10 @@ interface ActionDialogProps {
     isPending: boolean;
     row?: Record<string, unknown>;
     /**
-     * Bulk selection when invoked from a list bulk bar. Used by two
+     * Bulk selection when invoked from a list floatbar. Used by two
      * param renderings: (1) `id_array` typed params are auto-filled with
      * the selection's PKs and hidden from the form, matching the
-     * BulkBar auto-fill contract; (2) `entity_patch` params feed the
+     * floatbar auto-fill contract; (2) `entity_patch` params feed the
      * selection into PropertyGridEditor for same-value pre-fill.
      */
     bulkSelection?: ReadonlyArray<Record<string, unknown>>;

package/dist-lib/components/shared/ActionRunner.d.ts

@@ -28,6 +28,21 @@ export interface RunActionOptions {
      * action invocations.
      */
     bulkSelection?: ReadonlyArray<Record<string, unknown>>;
+    /**
+     * The record the action is bound to, for single-row invocations
+     * (detail header/toolbar, list row, quick peek). Forwarded to
+     * ActionDialog so `$row.*` param defaults resolve against it -
+     * without it every schema-declared prefill silently renders the
+     * param's empty state. Omit for global and bulk invocations.
+     */
+    row?: Record<string, unknown>;
+    /**
+     * Acted-entity override for the post-outcome query invalidation. Normally
+     * the runner reads `action.entity`; pass this when the dispatched action
+     * may lack its binding (e.g. a platform-default bulk action resolved from
+     * screen context).
+     */
+    entity?: string;
 }
 interface ActionRunnerContextValue {
     /**

package/dist-lib/components/shared/ResponsiveActionBar.d.ts

@@ -23,7 +23,6 @@
  *   Renders as a single kebab "⋮" dropdown. No inline measurement.
  *   Destructive items land at the bottom of the dropdown with a separator.
  */
-import type { ReactNode } from "react";
 import type { Action, Entity, Screen } from "../../types/schema";
 import type { ResolvedActionLayoutNode, ResolvedActionLeaf } from "../../lib/actions";
 /**
@@ -75,6 +74,14 @@ export interface WidgetContext {
     tabNavigate: (url: string, meta?: TabMeta) => void;
     /** Invokes a server action and returns its response envelope. */
     runActionApi: (code: string, params: unknown) => Promise<unknown>;
+    /**
+     * Opens the Quick peek drawer for `row`. Present only where peek is available
+     * (list surfaces that pass it); the `__peek` platform default dispatches
+     * through here as a pure client verb - the mode-less counterpart of `__open`'s
+     * href navigation. Absent surfaces never receive a `__peek` leaf, so a missing
+     * callback is never invoked.
+     */
+    openPeek?: (row: Record<string, unknown> | undefined) => void;
 }
 /**
  * Telemetry payload emitted on every action click. Stays scalar by design -
@@ -86,8 +93,9 @@ export interface WidgetContext {
 export interface ActionClickPayload {
     code: string;
     entity: string;
-    /** Dispatch mode chosen by ResponsiveActionBar based on which field was set. */
-    mode: "handler" | "association" | "widget" | "href" | "ui_steps" | "unknown";
+    /** Dispatch mode chosen by ResponsiveActionBar based on which field was set.
+     *  "peek" is the mode-less `__peek` client verb (opens the Quick peek drawer). */
+    mode: "handler" | "association" | "widget" | "href" | "ui_steps" | "peek" | "unknown";
     /** PK of the row the click was bound to, when row-scoped. Empty otherwise. */
     rowId: string;
 }
@@ -151,25 +159,6 @@ export interface ResponsiveActionBarProps {
     globalActions?: Record<string, Action>;
     /** aria-label for the toolbar root. Defaults to "Actions". */
     ariaLabel?: string;
-    /**
-     * Platform-default kebab affordances appended to row mode after schema items.
-     * Used by SmartListPage's row kebab to surface Edit (navigation) and Delete
-     * (mutation) without rendering a second kebab next to the schema-defined one.
-     * Plan §11: each row exposes ONE kebab "⋮"; schema actions own the rendering,
-     * platform defaults integrate as trailing items.
-     *
-     * - normal: rendered after schema-normal items, before any separator. Used
-     *   for Edit (or schema-declared type=edit actions).
-     * - destructive: rendered in the destructive trailing section, after any
-     *   schema-destructive items. Used for Delete (or schema-declared
-     *   type=delete actions). Triggers the destructive separator just like
-     *   schema-destructive leaves do.
-     *
-     * Only honored when kind="row". Other kinds ignore these (detail/toolbar
-     * place edit/delete in their own dedicated UI slots).
-     */
-    trailingNormalItems?: ReactNode;
-    trailingDestructiveItems?: ReactNode;
     /**
      * Dispatch surface for client-side action modes (`href` today, `widget` in
      * Phase 2). When omitted, every action falls through to `onRun`.
@@ -187,6 +176,39 @@ export interface ResponsiveActionBarProps {
      */
     onActionClick?: (payload: ActionClickPayload) => void;
 }
+export interface RowMenuContentProps {
+    /**
+     * Row-stated + nav-suppressed layout. BOTH triggers pass the identical shape:
+     * the kebab (anchored) and the right-click menu (at the cursor) compose the
+     * same leaves so their menus are structurally identical (Invariant 1).
+     */
+    layout: ResolvedActionLayoutNode[];
+    entityActions: Record<string, Action> | undefined;
+    globalActions?: Record<string, Action> | undefined;
+    /**
+     * Action runner, already wrapped by the caller to close its own popover on
+     * click. Kept caller-owned so the kebab and the right-click site each dismiss
+     * their own surface while sharing this one dispatch path.
+     */
+    onRun: ActionRunHandler;
+    /** Controlled loading code so a trigger (the kebab button) can spin too. */
+    loading: string | null;
+    onLoadingChange: (code: string | null) => void;
+    row?: Record<string, unknown>;
+    widgetContext?: WidgetContext;
+    onActionClick?: (payload: ActionClickPayload) => void;
+    ariaLabel?: string;
+}
+/**
+ * RowMenuContent is the ONE renderer of Row Menu body content, shared by the
+ * kebab and the right-click menu (plan 2026-07-19-unified-row-menu, Invariant
+ * 1). It partitions destructive-last, draws a divider after the leading
+ * navigation run (__peek / __open), and renders every leaf through the same
+ * DropdownLeafItem / DropdownGroupSection path used everywhere else - so the two
+ * triggers cannot structurally diverge. It renders no chrome and owns no
+ * open/close state; the caller wraps it (anchored Dropdown or cursor container).
+ */
+export declare function RowMenuContent({ layout, entityActions, globalActions, onRun, loading, onLoadingChange, row, widgetContext, onActionClick, ariaLabel, }: RowMenuContentProps): import("react").JSX.Element;
 /**
  * Layout decision computed by the measurement pass. Three pinned groups
  * (primary / inline / destructive) plus the overflow bucket that lives
@@ -213,5 +235,5 @@ export declare function computeLayout(nodes: ResolvedActionLayoutNode[], contain
  * kind="row": single kebab "⋮" with all actions in dropdown.
  * kind default: "toolbar".
  */
-export declare function ResponsiveActionBar({ layout, row, rowSelection, onRun, reservedRightWidth, kind, align, constrain, measurementOverride, entityActions, globalActions, ariaLabel, trailingNormalItems, trailingDestructiveItems, widgetContext, onActionClick, }: ResponsiveActionBarProps): import("react").JSX.Element | null;
+export declare function ResponsiveActionBar({ layout, row, rowSelection, onRun, reservedRightWidth, kind, align, constrain, measurementOverride, entityActions, globalActions, ariaLabel, widgetContext, onActionClick, }: ResponsiveActionBarProps): import("react").JSX.Element | null;
 export {};