@ximatai/muyun-web-app 0.26.8 → 0.26.9

package/dist/types/vue-ui-antdv/components/UiTree.vue.d.ts

@@ -5,12 +5,14 @@ type __VLS_Props = {
     expandedKeys?: string[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    select: (node: UiTreeNode) => any;
     action: (action: import("../../web-contracts/index.ts").RecordInlineAction, node: UiTreeNode) => any;
+    select: (node: UiTreeNode) => any;
+    deselect: () => any;
     "update:expandedKeys": (keys: string[]) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onSelect?: ((node: UiTreeNode) => any) | undefined;
     onAction?: ((action: import("../../web-contracts/index.ts").RecordInlineAction, node: UiTreeNode) => any) | undefined;
+    onSelect?: ((node: UiTreeNode) => any) | undefined;
+    onDeselect?: (() => any) | undefined;
     "onUpdate:expandedKeys"?: ((keys: string[]) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/types/vue-ui-antdv/index.d.ts

@@ -10,6 +10,8 @@ export { default as UiInput } from './components/UiInput.vue';
 export { default as UiSearchInput } from './components/UiSearchInput.vue';
 export { default as UiTextArea } from './components/UiTextArea.vue';
 export { default as UiSelect } from './components/UiSelect.vue';
+export { default as UiRadioGroup } from './components/UiRadioGroup.vue';
+export type { UiRadioOption } from './components/UiRadioGroup.vue';
 export { default as UiTreeSelect } from './components/UiTreeSelect.vue';
 export type { UiTreeSelectNode } from './components/UiTreeSelect.vue';
 export { default as UiTooltip } from './components/UiTooltip.vue';
@@ -20,9 +22,9 @@ export { default as UiTabs } from './components/UiTabs.vue';
 export { default as UiTree } from './components/UiTree.vue';
 export { default as UiDataTable } from './components/UiDataTable.vue';
 export { default as UiDropdown } from './components/UiDropdown.vue';
-export { default as UiModal } from './components/UiModal.vue';
 export { default as UiSidePanel } from './components/UiSidePanel.vue';
 export { default as UiSidePanelHost } from './components/UiSidePanelHost.vue';
+export { default as UiModal } from './components/UiModal.vue';
 export { default as UiRecordExplorerItem } from './components/UiRecordExplorerItem.vue';
 export { default as UiSpin } from './components/UiSpin.vue';
 export { default as UiEmpty } from './components/UiEmpty.vue';
@@ -36,8 +38,8 @@ export { showErrorMessage, showFeedback, showInfoMessage, showSuccessMessage, sh
 export type { UiFeedbackOptions, UiFeedbackTone } from './feedback';
 export { resolveFieldComponent } from './registry';
 export type { UiIconName } from './components/UiIcon.vue';
-export type { UiTagListItem } from './components/UiTagList.vue';
 export type { UiSidePanelScope } from './components/sidePanelHost';
+export type { UiTagListItem } from './components/UiTagList.vue';
 export { antDesignThemeOf, cssVariablesOf, defaultUiTheme, defaultUiThemeSkinId, uiThemeSkinById, uiThemeSkins, } from './theme';
 export type { UiSupportTheme, UiTheme, UiThemeSkin, UiThemeSkinId, UiThemeTone } from './theme';
 export type { UiConfirmOptions, UiDataTableColumn, UiDataTableKey, UiDataTablePagination, UiDataTableRecord, UiDataTableSelection, UiDropdownItem, UiMenuItem, UiRecordInlineAction, UiTabItem, UiTreeNode, UiTreeNodeAction, } from './types';

package/dist/types/web-contracts/index.d.ts

@@ -79,7 +79,7 @@ export interface WebBusinessNotification {
     dismissible: boolean;
     actions: WebBusinessNotificationAction[];
 }
-export type WebBusinessNotificationAction = WebBusinessNotificationNavigateAction | WebBusinessNotificationCommandAction;
+export type WebBusinessNotificationAction = WebBusinessNotificationNavigateAction | WebBusinessNotificationRecordAction;
 export interface WebBusinessNotificationNavigateAction {
     kind: 'navigate';
     key: string;
@@ -88,16 +88,21 @@ export interface WebBusinessNotificationNavigateAction {
     recordId?: string;
     pageMode?: 'LIST' | 'FORM' | 'DETAIL';
     query?: Record<string, string>;
+    placement?: 'leading' | 'trailing';
     dismissOnSuccess: boolean;
 }
-export interface WebBusinessNotificationCommandAction {
-    kind: 'command';
+/** A standard record action implemented by the owning business module. */
+export interface WebBusinessNotificationRecordAction {
+    kind: 'record';
     key: string;
     label: string;
-    command: string;
+    moduleAlias: string;
+    recordId: string;
+    actionCode: string;
     arguments?: Record<string, unknown>;
     danger?: boolean;
     confirmation?: string;
+    placement?: 'leading' | 'trailing';
     dismissOnSuccess: boolean;
 }
 export interface WebBusinessRealtimeEvent {
@@ -119,6 +124,8 @@ export interface WebTreeNode<T> {
  */
 export interface RecordInlineAction {
     key: string;
+    /** Standard record action whose availability is resolved for the rendered record. */
+    actionCode?: string;
     title: string;
     iconName?: RecordInlineActionIconName;
     showLabel?: boolean;
@@ -227,13 +234,166 @@ export interface PageBootstrap {
     resolvedConfig: {
         uiFields: unknown[];
         queryItems: unknown[];
+        /**
+         * Permission-scoped detail interaction blocks. The standard runner only
+         * executes the explicitly supported block kinds; it never resolves a
+         * backend block to an arbitrary client component or handler.
+         */
+        actionBlocks?: PageBootstrapActionBlock[];
+        /** Server-resolved detail relations. Only relation.queryContract is executable by a Web runner. */
+        associationBlocks?: PageBootstrapAssociationBlock[];
     };
     openApiPath: string;
 }
+/** A server-resolved action entry declared by a published detail UI config. */
+export interface PageBootstrapActionBlock {
+    uiConfigId?: string;
+    type: 'action' | 'dialog' | 'localEdit';
+    key?: string;
+    actionCode: string;
+    title?: string;
+    position?: string;
+    targetUiConfigId?: string;
+    submitPath?: string;
+    refreshStrategy?: {
+        list?: boolean;
+        detail?: boolean;
+    };
+    width?: number;
+    height?: number;
+    localEditForm?: PageBootstrapLocalEditForm;
+}
+export interface PageBootstrapLocalEditForm {
+    uiConfigId: string;
+    fields: PageBootstrapLocalEditField[];
+    /**
+     * Authoritative controls resolved from the published target FORM config.
+     * Local edit must consume these facts rather than falling back to the
+     * field's legacy alias, otherwise a control can drift from the page that
+     * was actually published.
+     */
+    fieldUiControls: ResolvedFieldControlDescriptor[];
+    submitContract: {
+        recordRequired: true;
+        recordVersionRequired: true;
+        fieldNamesRequired: true;
+        uiConfigIdPayloadKey: 'uiConfigId';
+    };
+}
+export interface PageBootstrapLocalEditField {
+    relationAlias?: string;
+    fieldName: string;
+    fieldTitle?: string;
+    fieldUiControlAlias?: string;
+    /** Authoritative storage type of this resolved field; editors use it for lossless codecs. */
+    valueType?: ViewFieldValueType;
+    visible?: boolean;
+    readOnly?: boolean;
+    requiredOverride?: boolean;
+    placeholder?: string;
+    columnSpan?: number;
+}
+export interface PageBootstrapAssociationBlock {
+    title?: string;
+    relation?: ResolvedDetailRelationDescriptor;
+}
+/** Source-neutral detail-relation descriptor. A declaration without queryContract is intentionally inert. */
+export interface ResolvedDetailRelationDescriptor {
+    code: string;
+    title?: string;
+    readOnly: boolean;
+    sourceModuleAlias: string;
+    sourceEntityAlias: string;
+    targetModuleAlias: string;
+    targetEntityAlias: string;
+    parentBinding: string;
+    queryContract?: ResolvedDetailRelationQueryContract;
+    /** Read access never implies these operations; the server must explicitly compile them. */
+    mutationContract?: ResolvedDetailRelationMutationContract;
+    /** Optional client-visible applicability fact; the server remains authoritative. */
+    parentConstraint?: ResolvedDetailRelationParentConstraint;
+    /** Parent entity field carrying the complete child collection for standard CRUD. */
+    embeddedField?: string;
+    /** Shared column projection for gateway-backed and embedded relations. */
+    listProjection?: ResolvedDetailRelationListProjection;
+    /** Immediate server-compiled calculations for rows in this embedded child relation. */
+    formComputeRules?: ResolvedDetailRelationFormComputeRuleDescriptor[];
+    /** Server-compiled visibility rule; clients execute only its FormulaProgram. */
+    visible?: UiRule<boolean>;
+    editing?: ResolvedDetailRelationEditing;
+    refreshOnDetailReload: boolean;
+}
+export interface ResolvedDetailRelationEditing {
+    mode: 'DIALOG' | 'INLINE';
+    saveMode: 'INDEPENDENT' | 'AGGREGATE_DRAFT';
+    recycleBinEnabled?: boolean;
+}
+export interface ResolvedDetailRelationFormComputeRuleDescriptor {
+    code: string;
+    program: FormulaProgram;
+    targetField: string;
+    targetValueType: ViewFieldValueType;
+    triggerFields: string[];
+}
+export interface ResolvedDetailRelationParentConstraint {
+    fieldName: string;
+    expectedValue: string;
+}
+export interface ResolvedDetailRelationMutationContract {
+    createAllowed: boolean;
+    updateAllowed: boolean;
+    deleteAllowed: boolean;
+    createActionCode?: string;
+    updateActionCode?: string;
+    deleteActionCode?: string;
+}
+export interface ResolvedDetailRelationQueryContract {
+    /** Dynamic/legacy relation route. Managed relations deliberately omit it. */
+    queryPath?: string;
+    /** Uses the platform parent-association gateway derived from module + relation facts. */
+    managedGateway?: boolean;
+    /** Compiled action identity in the source/parent module permission catalog. */
+    actionCode?: string;
+    targetUiConfigId?: string;
+    queryTemplateId?: string;
+    pageable: boolean;
+    /** Initial page size; absent when the relation explicitly loads its complete result. */
+    pageSize?: number;
+    /** Server-approved choices. Empty for a non-pageable relation. */
+    pageSizeOptions?: number[];
+    queryable: boolean;
+    listProjection?: ResolvedDetailRelationListProjection;
+    /** Source-owned query schema; the relation runner must not load target-module schema directly. */
+    querySchema?: QuerySchema;
+}
+/** Server-issued list columns, not a raw target UI config or a client-side inferred view. */
+export interface ResolvedDetailRelationListProjection {
+    uiConfigId?: string;
+    fields: ResolvedDetailRelationListField[];
+}
+export interface ResolvedDetailRelationListField {
+    fieldName: string;
+    title?: string;
+    fieldForm?: string;
+    fieldUiControlAlias?: string;
+    width?: number;
+    align?: 'left' | 'center' | 'right' | string;
+    maxDisplayLines?: number;
+}
+export declare function hasExecutableDetailRelationQueryContract(relation: ResolvedDetailRelationDescriptor | undefined): relation is ResolvedDetailRelationDescriptor & {
+    queryContract: ResolvedDetailRelationQueryContract & {
+        listProjection: ResolvedDetailRelationListProjection;
+    };
+};
+export declare function hasExecutableDetailRelationMutationContract(relation: ResolvedDetailRelationDescriptor | undefined): relation is ResolvedDetailRelationDescriptor & {
+    mutationContract: ResolvedDetailRelationMutationContract;
+};
+export type MenuEntryType = 'module' | 'route' | 'link';
 export interface MenuRecord extends StandardEnabledTreeEntity {
     id: string;
     title: string;
     schemeId: string;
+    entryType?: MenuEntryType;
     openMode?: MenuOpenMode;
     moduleAlias?: string;
     route?: string;
@@ -283,7 +443,11 @@ export type MenuNavigationTarget = ModuleMenuTarget | RouteMenuTarget | External
 export type MenuNavigationType = MenuNavigationTarget['menuType'];
 export type PageType = 'platform-route' | 'business-route' | 'dynamic-module' | 'remote-url' | 'external-link';
 export type OpenMode = 'workbench-route' | 'dynamic-runner' | 'iframe' | 'new-window';
-export type PageHostType = 'platform-route-host' | 'business-route-host' | 'dynamic-module-host' | 'external-page-host';
+export type PageHostType = 'platform-route-host' | 'business-route-host'
+/** Source-neutral standard CRUD page host. */
+ | 'module-page-host'
+/** Persisted compatibility identifier for the standard module page host. */
+ | 'dynamic-module-host' | 'external-page-host';
 export type TabIdentityStrategy = 'by-menu' | 'by-target' | 'by-params';
 /**
  * Declares which layer owns a page's vertical scroll boundary.
@@ -330,17 +494,25 @@ export interface DynamicModulePageTarget {
     defaultUiConfigId?: string;
     defaultQueryTemplateId?: string;
 }
+export type ModulePageDescriptor = PageDescriptorBase<'dynamic-module', 'dynamic-runner', 'module-page-host', DynamicModulePageTarget>;
+/** Compatibility descriptor accepted when restoring existing workbench state. */
 export type DynamicModulePageDescriptor = PageDescriptorBase<'dynamic-module', 'dynamic-runner', 'dynamic-module-host', DynamicModulePageTarget>;
+/** Source-neutral descriptor accepted by the standard module page runner. */
+export type StandardModulePageDescriptor = ModulePageDescriptor | DynamicModulePageDescriptor;
 export interface UrlPageTarget {
     url: string;
     moduleAlias?: string;
 }
 export type RemoteUrlPageDescriptor = PageDescriptorBase<'remote-url', 'iframe' | 'new-window', 'external-page-host', UrlPageTarget>;
 export type ExternalLinkPageDescriptor = PageDescriptorBase<'external-link', 'new-window', 'external-page-host', UrlPageTarget>;
-export type PageDescriptor = PlatformRoutePageDescriptor | BusinessRoutePageDescriptor | DynamicModulePageDescriptor | RemoteUrlPageDescriptor | ExternalLinkPageDescriptor;
+export type PageDescriptor = PlatformRoutePageDescriptor | BusinessRoutePageDescriptor | ModulePageDescriptor | DynamicModulePageDescriptor | RemoteUrlPageDescriptor | ExternalLinkPageDescriptor;
 export interface MenuTab {
+    /** Immutable page-instance key used by route restoration and cache isolation. */
+    instanceKey?: string;
     key: string;
     title: string;
+    /** Exact browser address used to restore this tab. */
+    fullPath?: string;
     target?: MenuNavigationTarget;
     pageDescriptor?: PageDescriptor;
     restoreState?: TabRestoreState;
@@ -379,6 +551,54 @@ export interface WebQueryRequest {
     quickSearchFields?: string[];
     externalQueryValues?: Record<string, unknown>;
 }
+/** Shared field-reference delivery contract for static and metadata-backed modules. */
+export type WebReferenceResolveMode = 'QUERY' | 'TREE' | 'TRANSLATE';
+export type WebReferenceMatchMode = 'KEY' | 'LABEL' | 'AUTO';
+export type WebReferenceResolveStatus = 'OK' | 'RESOLVED' | 'NOT_FOUND' | 'AMBIGUOUS' | 'PARTIAL';
+/** Persisted aggregate record owning a reference interaction; never use form values to provide its tenant. */
+export interface WebReferenceSource {
+    recordId?: string;
+}
+export interface WebReferenceResolveRequest {
+    mode?: WebReferenceResolveMode;
+    matchMode?: WebReferenceMatchMode;
+    fuzzy?: string;
+    values?: unknown[];
+    conditions?: WebQueryCondition[];
+    criteria?: unknown;
+    page?: WebPageRequest;
+    includeProjections?: boolean;
+    formValues?: Record<string, unknown>;
+    source?: WebReferenceSource;
+    sourceUiConfigId?: string;
+    uiConfigId?: string;
+    queryTemplateId?: string;
+    externalQueryValues?: Record<string, unknown>;
+}
+export interface WebReferenceResolveItem {
+    id: string;
+    title?: string;
+    matchedBy?: WebReferenceMatchMode;
+    projections?: Record<string, unknown>;
+    affectPatch?: Record<string, unknown>;
+}
+export interface WebReferenceResolveResult {
+    input: unknown;
+    status: WebReferenceResolveStatus;
+    matchedBy?: WebReferenceMatchMode;
+    item?: WebReferenceResolveItem;
+    candidates: WebReferenceResolveItem[];
+}
+export interface WebReferenceResolveResponse {
+    status: WebReferenceResolveStatus;
+    mode: WebReferenceResolveMode;
+    options: WebReferenceResolveItem[];
+    results: WebReferenceResolveResult[];
+    offset: number;
+    limit: number;
+    total: number;
+    tree?: WebTreeNode<WebReferenceResolveItem>[];
+}
 export type QueryValueType = 'STRING' | 'TEXT' | 'BOOLEAN' | 'INTEGER' | 'LONG' | 'DECIMAL' | 'INSTANT' | 'DATE' | 'JSON';
 export type QueryOperator = 'EQ' | 'NOT_EQUAL' | 'LIKE' | 'IN' | 'NOT_IN' | 'GT' | 'GTE' | 'LT' | 'LTE' | 'BETWEEN' | 'NULL' | 'NOT_NULL';
 export interface QuerySchemaField {
@@ -420,13 +640,25 @@ export interface UiRule<T> {
     formula?: UiFormula;
     disabledHint?: string;
 }
-/**
- * A platform-owned portable Boolean predicate evaluated against the current record draft.
- * The current grammar supports `PRESENT({fieldName})`, `!()` negation, and `&&` conjunction of PRESENT terms.
- * It is deliberately smaller than the server FormulaEngine because this contract must run in every Web client.
- */
+/** A FormulaEngine expression together with its server-issued WEB_UI AST. */
 export interface UiFormula {
     expression: string;
+    program?: FormulaProgram;
+}
+/** Versioned program compiled by FormulaEngine. The browser executes it locally and never parses expression. */
+export interface FormulaProgram {
+    schemaVersion: number;
+    profile: 'WEB_UI' | 'FORM_COMPUTE';
+    root: FormulaNode;
+    referencedFields: string[];
+}
+/** Source-neutral FormulaEngine AST node. Profiles decide which nodes can execute. */
+export interface FormulaNode {
+    kind: 'VALUE' | 'FIELD' | 'OTHERS' | 'UNARY' | 'BINARY' | 'FUNCTION' | 'ASSIGN';
+    operator?: string;
+    field?: string;
+    value?: string | number | boolean | null;
+    arguments: FormulaNode[];
 }
 export interface ViewFieldRef {
     relationCode?: string;
@@ -448,6 +680,8 @@ export interface ViewFieldDefinition {
     booleanStatus?: BooleanStatusPresentation;
     /** Maximum visible lines for text cells in standard list views. Omitted uses the platform default of one line. */
     maxDisplayLines?: number;
+    /** User-facing title for the standard tree root sentinel in a detail field. */
+    treeRootTitle?: string;
 }
 /** Semantic group that owns a contiguous set of standard-form fields. */
 export interface FormGroupDescriptor {
@@ -465,6 +699,21 @@ export interface BooleanStatusPresentation {
 export type BooleanStatusTone = 'SUCCESS' | 'NEUTRAL' | 'WARNING' | 'DANGER';
 export type FieldValuePresentation = 'FILE_SIZE';
 export type ViewFieldValueType = 'STRING' | 'TEXT' | 'INTEGER' | 'LONG' | 'BOOLEAN' | 'TIMESTAMP' | 'ZONED_TIMESTAMP' | 'DATE' | 'DECIMAL' | 'JSON';
+/**
+ * Source-neutral field-control fact compiled by the platform. `renderer` is a platform semantic
+ * renderer type, never a Vue component name or front-end module path.
+ */
+export interface ResolvedFieldControlDescriptor {
+    alias: string;
+    rendererType: string;
+    valueShape: 'SCALAR' | 'COLLECTION' | 'COMPOSITE';
+    properties?: Record<string, string>;
+    bindings?: ResolvedFieldControlBindingDescriptor[];
+}
+export interface ResolvedFieldControlBindingDescriptor {
+    key: string;
+    valueType: string;
+}
 export interface ResolvedViewFieldDescriptor {
     fieldRef: ViewFieldRef;
     label?: string;
@@ -472,6 +721,8 @@ export interface ResolvedViewFieldDescriptor {
     required?: UiRule<boolean>;
     readOnly?: UiRule<boolean>;
     uiType?: string;
+    /** Optional while older descriptors still publish only `uiType`. When present it is authoritative. */
+    fieldControl?: ResolvedFieldControlDescriptor;
     valueType?: ViewFieldValueType;
     valuePresentation?: FieldValuePresentation;
     width?: string;
@@ -479,6 +730,7 @@ export interface ResolvedViewFieldDescriptor {
     align?: 'left' | 'center' | 'right' | string;
     fixed?: boolean;
     booleanStatus?: BooleanStatusPresentation;
+    treeRootTitle?: string;
     option?: ResolvedOptionFieldDescriptor;
     reference?: ResolvedReferenceFieldDescriptor;
     referenceSummary?: ResolvedReferenceSummaryFieldDescriptor;
@@ -495,9 +747,22 @@ export interface ResolvedReferenceSummaryFieldDescriptor {
 export interface ResolvedReferenceFieldDescriptor {
     targetModuleAlias: string;
     cardinality: 'ONE' | 'MANY';
+    /** Server-resolved standard picker transport. AUTO exists only for descriptors issued before an explicit mode. */
+    pickerMode?: ReferencePickerMode;
+    /** Standardized candidate transport chosen by the compiled source-field contract. */
+    candidateDelivery?: 'TARGET_NAVIGATOR' | 'SOURCE_FIELD';
+    resolvePath?: string;
+    /** Server-enforced dependencies that constrain candidates from values of the current form row. */
+    candidateDependencies?: ReferenceCandidateDependency[];
     /** Read-side title projection for this scalar reference, when supplied by the server. */
     titleField?: string;
 }
+export interface ReferenceCandidateDependency {
+    sourceField: string;
+    targetField: string;
+    required: boolean;
+}
+export type ReferencePickerMode = 'LIST' | 'TREE' | 'AUTO';
 export interface OptionBindingDescriptor {
     sourceType: string;
     source: string;
@@ -506,6 +771,8 @@ export interface ResolvedOptionFieldDescriptor {
     binding: OptionBindingDescriptor;
     selectionMode: 'SINGLE' | 'MULTIPLE';
     titleField?: string;
+    /** Immutable option facts (currently CodeTitleEnum); scope-sensitive dictionaries stay runtime data. */
+    inlineItems?: OptionItemDescriptor[];
 }
 export interface OptionItemDescriptor {
     code: string;
@@ -522,6 +789,15 @@ export interface ViewDefinition {
     fields: ViewFieldDefinition[];
     formGroups?: FormGroupDescriptor[];
 }
+/** Server-issued deterministic main-form calculation. The coordinator is introduced separately. */
+export interface ResolvedFormComputeRuleDescriptor {
+    code: string;
+    program: FormulaProgram;
+    targetField: string;
+    targetValueType: ViewFieldValueType;
+    triggerFields: string[];
+    writePolicy: 'ALWAYS';
+}
 export interface ResolvedViewDescriptor {
     viewCode: string;
     viewKind: ModuleViewKind;
@@ -531,6 +807,7 @@ export interface ResolvedViewDescriptor {
     /** Dynamic-page provenance used to select the view configured by a menu entry. */
     sourceUiConfigId?: string;
     formGroups?: FormGroupDescriptor[];
+    formComputeRules?: ResolvedFormComputeRuleDescriptor[];
 }
 export type ModulePageTemplate = 'FLAT_MANAGEMENT' | 'LIST_DETAIL_CARD' | 'TREE_MANAGEMENT';
 export interface ResolvedPageExplorerDescriptor {
@@ -555,7 +832,12 @@ export interface ResolvedPageNavigatorLevelDescriptor {
     searchPlaceholder: string;
     /** Presentation policy applied after the source has authoritatively loaded. */
     singleResultPolicy?: 'NONE' | 'AUTO_SELECT' | 'AUTO_SELECT_AND_HIDE';
-    /** Session-derived source scope, enforced by the source reference transport. */
+    /** Explicit initial selection policy; omitted means the navigator starts unselected. */
+    initialSelectionPolicy?: 'NONE' | 'FIRST_RECORD';
+    /**
+     * Session-derived source scope, enforced by the source reference transport. A system user has
+     * no current tenant, so a CURRENT_TENANT tenant source resolves its REFERENCE-authorized choices.
+     */
     sourceScope?: 'NONE' | 'CURRENT_TENANT';
     /** When present, the navigator source exposes its own standard CRUD affordances in place. */
     management?: ResolvedPageNavigatorManagementDescriptor;
@@ -576,10 +858,18 @@ export interface ResolvedPageNavigatorManagementDescriptor {
 export interface ResolvedPageListDescriptor {
     searchPlaceholder: string;
     fields: ResolvedViewDescriptor;
+    /** Read-only placements of declared aggregate relations beneath an expanded list row. */
+    relationExpansions?: ResolvedPageListRelationExpansionDescriptor[];
+}
+export interface ResolvedPageListRelationExpansionDescriptor {
+    relationCode: string;
+    fields: string[];
 }
 export interface ResolvedPageDetailDescriptor {
     emptyDescription: string;
     createTitle: string;
+    /** Whether the standard immutable system metadata section is displayed. */
+    showSystemInfo?: boolean;
     display?: ResolvedViewDescriptor;
     /** Omitted by an editorless page; standard mutation actions remain governed by the runtime action contract. */
     editor?: ResolvedViewDescriptor;
@@ -627,6 +917,7 @@ export interface ResolvedModuleUiDescriptor {
     defaultEditor?: ResolvedViewDescriptor;
     editorSurfaces?: ResolvedEditorSurfaceDescriptor[];
     editorContributions?: ResolvedPageDetailEditorContribution[];
+    detailRelations?: ResolvedDetailRelationDescriptor[];
 }
 export interface ResolvedEditorSurfaceDescriptor {
     key: string;

package/dist/types/web-core/businessNotifications.d.ts

@@ -1,3 +1,4 @@
-import type { WebBusinessNotificationCommandAction } from '../web-contracts/index';
+import type { WebBusinessNotificationRecordAction } from '../web-contracts/index';
 import type { HttpClient } from './http';
-export declare function invokeBusinessNotificationCommand(http: HttpClient, notificationId: string, action: WebBusinessNotificationCommandAction): Promise<unknown>;
+/** Calls the standard record action declared by a notification. */
+export declare function invokeBusinessNotificationRecordAction(http: HttpClient, action: WebBusinessNotificationRecordAction): Promise<unknown>;

package/dist/types/web-core/index.d.ts

@@ -6,6 +6,7 @@ export * from './businessNotifications';
 export * from './dataChanges';
 export * from './realtime';
 export * from './clients';
+export * from './referenceResolveClient';
 export { userPreferences } from './userPreferences';
 export type { UserPreferenceOptions, UserPreferenceStore } from './userPreferences';
 export * from './module/index';

package/dist/types/web-core/module/abilities.d.ts

@@ -1,17 +1,17 @@
 import { type ModuleAbilityCode } from './abilityCodes';
 import { type ModuleRuntimeContextState } from './runtimeContext';
-import type { ModuleEnableClient, StaticModuleCrudClient, StaticModuleTreeClient } from './staticModuleClient';
+import type { ModuleEnableClient, ModuleCrudClient, ModuleTreeClient } from './staticModuleClient';
 export interface ModuleAbilityClients<TRecord> {
-    crud: StaticModuleCrudClient<TRecord>;
-    tree: StaticModuleTreeClient<TRecord>;
+    crud: ModuleCrudClient<TRecord>;
+    tree: ModuleTreeClient<TRecord>;
     enable: ModuleEnableClient;
 }
 export interface ModuleAbilities<TRecord> {
-    crud(): StaticModuleCrudClient<TRecord>;
-    tree(): StaticModuleTreeClient<TRecord>;
+    crud(): ModuleCrudClient<TRecord>;
+    tree(): ModuleTreeClient<TRecord>;
     enable(): ModuleEnableClient;
-    tryCrud(): StaticModuleCrudClient<TRecord> | undefined;
-    tryTree(): StaticModuleTreeClient<TRecord> | undefined;
+    tryCrud(): ModuleCrudClient<TRecord> | undefined;
+    tryTree(): ModuleTreeClient<TRecord> | undefined;
     tryEnable(): ModuleEnableClient | undefined;
     has(ability: ModuleAbilityCode | string): boolean | undefined;
     hasCrud(): boolean | undefined;

package/dist/types/web-core/module/moduleContext.d.ts

@@ -1,21 +1,23 @@
 import type { HttpClient } from '../http';
 import { type ModuleAbilities } from './abilities';
 import { type ModuleActionState, type ModuleRecordActionAvailability, type ModuleRuntimeAction, type ModuleRuntimeContextState } from './runtimeContext';
-import { type StaticModuleCrudClient, type StaticModuleTreeClient } from './staticModuleClient';
+import { type ModuleCrudClient, type ModuleTreeClient } from './staticModuleClient';
 export interface ModuleContext<TRecord> {
     moduleAlias: string;
     http: HttpClient;
-    crud: StaticModuleCrudClient<TRecord>;
+    crud: ModuleCrudClient<TRecord>;
     runtime: ModuleRuntimeContextState;
     abilities: ModuleAbilities<TRecord>;
     action(actionCode: string, recordId?: string): ModuleActionState | undefined;
     runtimeAction(actionCode: string): ModuleRuntimeAction | undefined;
     can(actionCode: string, recordId?: string): boolean | undefined;
     recordActions(recordId: string): Promise<ModuleRecordActionAvailability>;
+    recordActionsBatch?(recordIds: string[]): Promise<ModuleRecordActionAvailability[]>;
     recordActionsSnapshot(recordId: string): ModuleRecordActionAvailability | undefined;
+    invalidateRecordActions?(recordIds?: string[]): void;
 }
 export interface ModuleTreeContext<TRecord> extends ModuleContext<TRecord> {
-    tree: StaticModuleTreeClient<TRecord>;
+    tree: ModuleTreeClient<TRecord>;
 }
 export interface ModuleContextConfig {
     http?: HttpClient;

package/dist/types/web-core/module/runtimeContext.d.ts

@@ -61,7 +61,9 @@ export interface ModuleRuntimeContextState {
     runtimeAction(actionCode: string): ModuleRuntimeAction | undefined;
     can(actionCode: string, recordId?: string): boolean | undefined;
     recordActions(recordId: string): Promise<ModuleRecordActionAvailability>;
+    recordActionsBatch?(recordIds: string[]): Promise<ModuleRecordActionAvailability[]>;
     recordActionsSnapshot(recordId: string): ModuleRecordActionAvailability | undefined;
+    invalidateRecordActions?(recordIds?: string[]): void;
 }
 export declare function createModuleRuntimeContextState(http: HttpClient, moduleAlias: string, access?: 'MENU' | 'REFERENCE'): ModuleRuntimeContextState;
 export declare function isRuntimeAbilityAvailable(context: ModuleRuntimeContext | undefined, ability: ModuleAbilityCode): boolean;