@ximatai/muyun-web-app 0.26.7 → 0.26.9

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

@@ -69,6 +69,42 @@ export interface WebUserNotification {
     logoutRequired?: boolean;
     targetSessionId?: string;
 }
+/** Ephemeral business reminder. It is not a persisted inbox or an acknowledgement record. */
+export interface WebBusinessNotification {
+    id: string;
+    code: string;
+    title: string;
+    subtitle?: string;
+    content: string;
+    dismissible: boolean;
+    actions: WebBusinessNotificationAction[];
+}
+export type WebBusinessNotificationAction = WebBusinessNotificationNavigateAction | WebBusinessNotificationRecordAction;
+export interface WebBusinessNotificationNavigateAction {
+    kind: 'navigate';
+    key: string;
+    label: string;
+    moduleAlias: string;
+    recordId?: string;
+    pageMode?: 'LIST' | 'FORM' | 'DETAIL';
+    query?: Record<string, string>;
+    placement?: 'leading' | 'trailing';
+    dismissOnSuccess: boolean;
+}
+/** A standard record action implemented by the owning business module. */
+export interface WebBusinessNotificationRecordAction {
+    kind: 'record';
+    key: string;
+    label: string;
+    moduleAlias: string;
+    recordId: string;
+    actionCode: string;
+    arguments?: Record<string, unknown>;
+    danger?: boolean;
+    confirmation?: string;
+    placement?: 'leading' | 'trailing';
+    dismissOnSuccess: boolean;
+}
 export interface WebBusinessRealtimeEvent {
     type: string;
     moduleAlias: string;
@@ -88,10 +124,14 @@ 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;
     disabled?: boolean;
+    /** Explains why a visible inline action is unavailable. */
+    disabledReason?: string;
     danger?: boolean;
 }
 export type RecordInlineActionIconName = 'app' | 'check' | 'close' | 'delete' | 'down' | 'edit' | 'export' | 'filter' | 'help' | 'lock' | 'notification' | 'plus' | 'power' | 'reload' | 'save' | 'search' | 'settings';
@@ -194,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;
@@ -250,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.
@@ -297,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;
@@ -346,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 {
@@ -387,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;
@@ -415,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 {
@@ -432,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;
@@ -439,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;
@@ -446,6 +730,7 @@ export interface ResolvedViewFieldDescriptor {
     align?: 'left' | 'center' | 'right' | string;
     fixed?: boolean;
     booleanStatus?: BooleanStatusPresentation;
+    treeRootTitle?: string;
     option?: ResolvedOptionFieldDescriptor;
     reference?: ResolvedReferenceFieldDescriptor;
     referenceSummary?: ResolvedReferenceSummaryFieldDescriptor;
@@ -462,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;
@@ -473,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;
@@ -489,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;
@@ -497,8 +806,86 @@ export interface ResolvedViewDescriptor {
     fields: ResolvedViewFieldDescriptor[];
     /** Dynamic-page provenance used to select the view configured by a menu entry. */
     sourceUiConfigId?: string;
-    scopedListWorkspace?: ResolvedScopedListWorkspaceDescriptor;
     formGroups?: FormGroupDescriptor[];
+    formComputeRules?: ResolvedFormComputeRuleDescriptor[];
+}
+export type ModulePageTemplate = 'FLAT_MANAGEMENT' | 'LIST_DETAIL_CARD' | 'TREE_MANAGEMENT';
+export interface ResolvedPageExplorerDescriptor {
+    title: string;
+    searchPlaceholder: string;
+    emptyDescription: string;
+    recordLabel: string;
+    fallbackTitle: string;
+    titleField: string;
+    secondaryField?: string;
+    mutedWhenDisabled: boolean;
+}
+export interface ResolvedPageNavigatorDescriptor {
+    levels: ResolvedPageNavigatorLevelDescriptor[];
+    contextBindings: ResolvedPageContextBindingDescriptor[];
+}
+export interface ResolvedPageNavigatorLevelDescriptor {
+    key: string;
+    kind: 'TREE' | 'MICRO_LIST';
+    sourceModuleAlias: string;
+    title: string;
+    searchPlaceholder: string;
+    /** Presentation policy applied after the source has authoritatively loaded. */
+    singleResultPolicy?: 'NONE' | 'AUTO_SELECT' | 'AUTO_SELECT_AND_HIDE';
+    /** 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;
+}
+export interface ResolvedPageContextBindingDescriptor {
+    source: 'SESSION' | 'NAVIGATOR';
+    sourceKey: string;
+    target: 'LIST_QUERY' | 'NAVIGATOR_QUERY' | 'FORM_DEFAULT' | 'PICKER_QUERY' | 'MUTATION_CONSTRAINT';
+    targetKey: string;
+    targetNavigatorLevelKey?: string;
+    /** Field name of the record picker which receives this query context. */
+    targetPickerFieldKey?: string;
+}
+export interface ResolvedPageNavigatorManagementDescriptor {
+    /** Optional named source-module form; the default editor is used when omitted. */
+    editorSurface?: string;
+}
+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;
+    /** Stable client registration key for an independently restorable detail workbench view. */
+    workspaceView?: ResolvedPageDetailWorkspaceViewDescriptor;
+}
+export interface ResolvedPageDetailWorkspaceViewDescriptor {
+    type: string;
+}
+export interface ResolvedModulePageDescriptor {
+    template: ModulePageTemplate;
+    explorer?: ResolvedPageExplorerDescriptor;
+    navigator?: ResolvedPageNavigatorDescriptor;
+    list?: ResolvedPageListDescriptor;
+    detail: ResolvedPageDetailDescriptor;
+    traits: ('STANDARD_CRUD' | 'ENABLED_STATUS' | 'RECYCLE_BIN' | 'RESPONSIVE_DETAIL_SURFACE')[];
 }
 export interface ResolvedUiActionConfirmationDescriptor {
     mode: 'typedText';
@@ -508,17 +895,6 @@ export interface ResolvedUiActionDescriptor {
     actionCode: string;
     confirmation?: ResolvedUiActionConfirmationDescriptor;
 }
-export interface ResolvedScopedListWorkspaceDescriptor {
-    scopeModuleAlias: string;
-    scopeField: string;
-    queryCriteriaKey: string;
-    scopeTitle: string;
-    scopeSearchPlaceholder: string;
-    /** Scope list items only show a secondary label when the descriptor explicitly enables it. */
-    showScopeItemSubtitle: boolean;
-    createPolicy: 'REQUIRE_SCOPE' | 'ALLOW_UNSCOPED';
-    manageScopeTree?: boolean;
-}
 /** Source-neutral runtime fact for one persisted MuYunFileServer field. */
 export interface ResolvedFileReferenceFieldDescriptor {
     fieldRef: ViewFieldRef;
@@ -529,19 +905,27 @@ export interface ResolvedFileReferenceFieldDescriptor {
     uploadAvailable: boolean;
     readAvailable: boolean;
 }
-export interface ModuleUiDefinition {
-    moduleAlias: string;
-    views: ViewDefinition[];
-}
 export interface ResolvedModuleUiDescriptor {
     schemaVersion: string;
     moduleAlias: string;
     moduleKind?: 'STATIC' | 'DYNAMIC';
     title?: string;
-    views: ResolvedViewDescriptor[];
     actions?: ResolvedUiActionDescriptor[];
     recordLabelField?: string;
     fileReferences?: ResolvedFileReferenceFieldDescriptor[];
+    page?: ResolvedModulePageDescriptor;
+    defaultEditor?: ResolvedViewDescriptor;
+    editorSurfaces?: ResolvedEditorSurfaceDescriptor[];
+    editorContributions?: ResolvedPageDetailEditorContribution[];
+    detailRelations?: ResolvedDetailRelationDescriptor[];
+}
+export interface ResolvedEditorSurfaceDescriptor {
+    key: string;
+    editor: ResolvedViewDescriptor;
+}
+export interface ResolvedPageDetailEditorContribution {
+    resource: string;
+    editor: ResolvedViewDescriptor;
 }
 export interface StandardEntity {
     id?: string;

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

@@ -0,0 +1,4 @@
+import type { WebBusinessNotificationRecordAction } from '../web-contracts/index';
+import type { HttpClient } from './http';
+/** 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

@@ -2,9 +2,11 @@ export * from './errors';
 export * from './http';
 export * from './query';
 export * from './actionResult';
+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;
@@ -23,6 +25,7 @@ export interface ModuleContextConfig {
 }
 export interface ModuleContextOptions extends ModuleContextConfig {
     moduleAlias: string;
+    runtimeAccess?: 'MENU' | 'REFERENCE';
 }
 export declare function configureModuleContext(config: ModuleContextConfig): void;
 export declare function provideModuleContextConfig(config: ModuleContextConfig): void;

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

@@ -47,6 +47,8 @@ export interface ModuleRuntimeContext {
     capabilities: string[];
     abilities?: string[];
     actions: ModuleRuntimeAction[];
+    /** Read-only projections this module deliberately exposes for page navigation. */
+    navigatorSourceCapabilities?: Array<'REFERENCE_QUERY' | 'REFERENCE_TREE'>;
     uiDescriptor?: ResolvedModuleUiDescriptor;
 }
 export interface ModuleRuntimeContextState {
@@ -59,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): ModuleRuntimeContextState;
+export declare function createModuleRuntimeContextState(http: HttpClient, moduleAlias: string, access?: 'MENU' | 'REFERENCE'): ModuleRuntimeContextState;
 export declare function isRuntimeAbilityAvailable(context: ModuleRuntimeContext | undefined, ability: ModuleAbilityCode): boolean;