@ximatai/muyun-web-app 0.26.11 → 0.26.13

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

@@ -15,6 +15,7 @@ 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';
+export { default as UiPopover } from './components/UiPopover.vue';
 export { default as UiThemeProvider } from './components/UiThemeProvider.vue';
 export { default as UiSwitch } from './components/UiSwitch.vue';
 export { default as UiMenu } from './components/UiMenu.vue';
@@ -34,12 +35,20 @@ export { default as DictionarySelect } from './components/DictionarySelect.vue';
 export { default as ReferenceSelect } from './components/ReferenceSelect.vue';
 export { default as UiTable } from './components/UiTable.vue';
 export { confirmAction } from './confirm';
+export { allowsUiDrawerOutsideDismissal, mayCloseUiDrawer, resolveUiDrawerDismissal, } from './drawerDismissal';
+export type { UiDrawerCloseGuard, UiDrawerCloseReason, UiDrawerDismissal, UiDrawerDismissalOptions, } from './drawerDismissal';
 export { showErrorMessage, showFeedback, showInfoMessage, showSuccessMessage, showWarningMessage, } from './feedback';
 export type { UiFeedbackOptions, UiFeedbackTone } from './feedback';
 export { resolveFieldComponent } from './registry';
 export type { UiIconName } from './components/UiIcon.vue';
 export type { UiSidePanelScope } from './components/sidePanelHost';
+export { isUiDrawerWidth, resolveUiDrawerWidth, uiDrawerWidths } from './drawerWidth';
+export type { UiDrawerWidth } from './drawerWidth';
 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';
+export type { UiConfirmOptions, UiDataTableColumn, UiDataTableKey, UiDataTablePagination, UiDataTableRecord, UiDataTableSelection, UiDropdownItem, UiMenuItem, UiRecordInlineAction, UiTabItem, UiTreeCheckEvent, UiTreeDisplayMode, UiTreeNodeEvent, UiDragSource, UiDropTarget, UiDropPosition, UiDropOperation, UiTreeBranchState, UiTreeLoadIntent, UiTreeChangeReason, UiTreeLoadReason, UiTreeLoadRequest, UiTreeLoadResult, UiTreeLoadStrategy, UiTreeNode, UiTreeNodeAction, UiTreeDropEvent, } from './types';
+export { useUiDropTarget, useUiDragSource } from './useUiTreeDrag';
+export { useTreeLoader as useTreeData } from './useTreeLoader';
+export { default as UiTokenInput } from './components/UiTokenInput.vue';
+export type { UiTokenInputToken } from './components/UiTokenInput.vue';

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

@@ -0,0 +1,18 @@
+import type { UiTreeNode } from './types';
+export interface TreeEntry {
+    node: UiTreeNode;
+    parent?: string;
+    index: number;
+}
+export declare function indexTree(nodes: readonly UiTreeNode[], flat?: boolean): Map<string, TreeEntry>;
+export declare function mergeTreePage(existing: UiTreeNode[], incoming: UiTreeNode[]): UiTreeNode[];
+export type TreeChange = {
+    key: string;
+    kind: 'enter' | 'leave' | 'move' | 'reparent' | 'update';
+};
+export declare function treeSnapshot(nodes: UiTreeNode[], flat?: boolean): Map<string, {
+    parent: string | undefined;
+    index: number;
+    content: string;
+}>;
+export declare function treeChanges(before: ReturnType<typeof treeSnapshot>, after: ReturnType<typeof treeSnapshot>): TreeChange[];

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

@@ -56,6 +56,70 @@ export interface UiTreeNode {
     actions?: UiRecordInlineAction[];
     children?: UiTreeNode[];
 }
+/** Adapter-neutral node activation event. The node remains a UI contract, not an Ant Tree node. */
+export interface UiTreeNodeEvent {
+    node: UiTreeNode;
+    nativeEvent?: Event;
+}
+export type UiTreeDisplayMode = 'tree' | 'flat';
+export interface UiTreeCheckEvent {
+    node: UiTreeNode;
+    checked: boolean;
+    checkedKeys: string[];
+    halfCheckedKeys: string[];
+    nativeEvent?: Event;
+}
+export type UiTreeLoadStrategy = 'managed' | 'controlled';
+export type UiTreeLoadReason = 'expand' | 'refresh' | 'load-more';
+export interface UiTreeLoadIntent {
+    node: UiTreeNode;
+    reason: UiTreeLoadReason;
+    cursor?: string;
+}
+/** Only the owner of the request creates and releases its cancellation signal. */
+export interface UiTreeLoadRequest extends UiTreeLoadIntent {
+    requestId: string;
+    signal: AbortSignal;
+}
+export interface UiTreeLoadResult {
+    mode: 'replace' | 'append';
+    nodes: UiTreeNode[];
+    nextCursor?: string;
+    hasMore: boolean;
+}
+export interface UiTreeBranchState {
+    status: 'idle' | 'loading' | 'loaded' | 'error';
+    hasMore?: boolean;
+    cursor?: string;
+    error?: string;
+    failedRequest?: UiTreeLoadIntent;
+}
+export type UiDropPosition = 'before' | 'after' | 'inside';
+export type UiDropOperation = 'copy' | 'move';
+export interface UiDragSource {
+    instanceId: string;
+    node: UiTreeNode;
+    operations: readonly UiDropOperation[];
+    payload?: unknown;
+    payloadType?: string;
+}
+export type UiDropTarget = {
+    instanceId: string;
+} & ({
+    kind: 'node';
+    node: UiTreeNode;
+    position: UiDropPosition;
+} | {
+    kind: 'root';
+    position: 'inside';
+});
+export interface UiTreeDropEvent {
+    source: UiDragSource;
+    target: UiDropTarget;
+    operation: UiDropOperation;
+    nativeEvent?: Event;
+}
+export type UiTreeChangeReason = 'interaction' | 'filter' | 'reset';
 export interface UiConfirmOptions {
     title: string;
     content?: string;

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

@@ -0,0 +1,21 @@
+import type { UiTreeNode, UiTreeLoadRequest, UiTreeLoadResult, UiTreeBranchState, UiTreeLoadIntent, UiTreeLoadReason } from './types';
+interface Options {
+    nodes: () => UiTreeNode[];
+    controlled: () => boolean;
+    states: () => Readonly<Record<string, UiTreeBranchState>>;
+    loader: () => ((node: UiTreeNode, request: UiTreeLoadRequest) => Promise<UiTreeLoadResult>) | undefined;
+    version: () => unknown;
+    minimumDuration: () => number;
+    emit: (request: UiTreeLoadIntent) => void;
+}
+/** Managed requests and controlled intents never share cancellation or loaded bookkeeping. */
+export declare function useTreeLoader(input: Pick<Options, 'nodes'> & Partial<Omit<Options, 'nodes'>>): {
+    nodes: import("vue").ComputedRef<UiTreeNode[]>;
+    states: import("vue").ComputedRef<Record<string, UiTreeBranchState>>;
+    stateOf: (key: string) => UiTreeBranchState;
+    request: (key: string, reason: UiTreeLoadReason, retry?: boolean) => Promise<void>;
+    release: (key: string) => void;
+    reset: () => void;
+    retry: (key: string) => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,9 @@
+import { type Ref } from 'vue';
+import type { UiTreeNode, UiTreeChangeReason } from './types';
+export declare function useTreeMotion(root: Ref<HTMLElement | undefined>, options: {
+    nodes: () => UiTreeNode[];
+    flat: () => boolean;
+    enabled: () => boolean;
+    duration: () => number;
+    reason: () => UiTreeChangeReason;
+}): Ref<boolean, boolean>;

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

@@ -0,0 +1,32 @@
+import { type Ref } from 'vue';
+import type { UiDragSource, UiDropPosition, UiDropTarget, UiTreeDropEvent, UiDropOperation } from './types';
+interface Surface {
+    root: HTMLElement;
+    resolve: (origin: Element, y: number, position?: UiDropPosition, source?: UiDragSource, x?: number) => UiDropTarget | undefined;
+    allow: (event: UiTreeDropEvent) => boolean;
+    operation?: (source: UiDragSource) => UiDropOperation;
+    drop: (event: UiTreeDropEvent) => void;
+    feedback: (target?: UiDropTarget, rejected?: boolean) => void;
+    /**
+     * A canvas-like editor can opt into an intentional drag boundary: after the pointer has entered
+     * this surface, leaving it abandons the transient placement instead of carrying a stale drop
+     * candidate across unrelated controls.
+     */
+    cancelWhenPointerLeaves?: boolean;
+}
+export declare const createUiTreeInstanceId: () => string;
+/** Shared by trees, flat lists and non-tree drop surfaces. No browser payload leaks to consumers. */
+export declare function useUiDropTarget(root: Ref<HTMLElement | undefined>, options: Omit<Surface, 'root' | 'feedback'>): {
+    hovered: import("vue").ShallowRef<UiDropTarget | undefined, UiDropTarget | undefined>;
+    rejected: Ref<boolean, boolean>;
+    draggingSource: import("vue").ComputedRef<UiDragSource | undefined>;
+    clear: () => void;
+};
+export declare function useUiDragSource(root: Ref<HTMLElement | undefined>, instanceId: string, source: (key: string) => UiDragSource | undefined, callbacks: {
+    start: (source: UiDragSource) => void;
+    end: (cancelled: boolean) => void;
+}): {
+    begin: (key: string, event: MouseEvent | KeyboardEvent) => void;
+    draggingKey: import("vue").ComputedRef<string | undefined>;
+};
+export {};

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

@@ -84,7 +84,12 @@ export interface WebBusinessNotification {
     content: string;
     dismissible: boolean;
     actions: WebBusinessNotificationAction[];
+    /** Optional standard card accent. Omit it to use the neutral platform presentation. */
+    tone?: WebBusinessNotificationTone;
+    /** The business fact's occurrence time, displayed in the workbench time zone when supplied. */
+    occurredAt?: string;
 }
+export type WebBusinessNotificationTone = 'default' | 'success' | 'danger';
 export type WebBusinessNotificationAction = WebBusinessNotificationNavigateAction | WebBusinessNotificationRecordAction;
 export interface WebBusinessNotificationNavigateAction {
     kind: 'navigate';
@@ -129,6 +134,8 @@ export interface WebTreeNode<T> {
  * them to their own icon implementations.
  */
 export interface RecordInlineAction {
+    /** Optional single-level menu, rendered in the same stable inline action slot. */
+    items?: Array<Pick<RecordInlineAction, 'key' | 'title' | 'disabled' | 'danger'>>;
     key: string;
     /** Standard record action whose availability is resolved for the rendered record. */
     actionCode?: string;
@@ -140,7 +147,7 @@ export interface RecordInlineAction {
     disabledReason?: string;
     danger?: boolean;
 }
-export type RecordInlineActionIconName = 'app' | 'check' | 'close' | 'delete' | 'down' | 'edit' | 'export' | 'filter' | 'help' | 'lock' | 'notification' | 'plus' | 'power' | 'reload' | 'save' | 'search' | 'settings';
+export type RecordInlineActionIconName = 'app' | 'check' | 'close' | 'delete' | 'down' | 'edit' | 'export' | 'eye' | 'eye-off' | 'filter' | 'help' | 'lock' | 'notification' | 'plus' | 'power' | 'reload' | 'save' | 'search' | 'settings';
 export interface CurrentUser {
     userId: string;
     username?: string;
@@ -258,6 +265,8 @@ export interface PageBootstrapActionBlock {
     key?: string;
     actionCode: string;
     title?: string;
+    /** Business importance only; card shells decide direct display or “更多”. */
+    importance?: 'PRIMARY' | 'STANDARD' | 'SECONDARY';
     position?: string;
     targetUiConfigId?: string;
     submitPath?: string;
@@ -382,9 +391,13 @@ export interface ResolvedDetailRelationListField {
     title?: string;
     fieldForm?: string;
     fieldUiControlAlias?: string;
+    /** Source-neutral scalar value fact used by relation previews and portable list renderers. */
+    valueType?: ViewFieldValueType | string;
     width?: number;
     align?: 'left' | 'center' | 'right' | string;
     maxDisplayLines?: number;
+    /** Read-side label companion for a reference ID column. */
+    referenceTitleField?: string;
 }
 export declare function hasExecutableDetailRelationQueryContract(relation: ResolvedDetailRelationDescriptor | undefined): relation is ResolvedDetailRelationDescriptor & {
     queryContract: ResolvedDetailRelationQueryContract & {
@@ -540,6 +553,28 @@ export interface WebQueryCondition {
     values?: unknown[];
     timeZone?: string;
 }
+/**
+ * One executable condition in a recursively composed query expression.
+ *
+ * This is intentionally separate from {@link WebQueryCondition}: `conditions`
+ * remains the legacy top-level AND shorthand, while `criteria` preserves the
+ * authored order and nesting needed by the advanced query editor.
+ */
+export interface QueryCriteriaCondition {
+    kind: 'CONDITION';
+    fieldName: string;
+    operator?: QueryOperator;
+    values?: unknown[];
+    timeZone?: string;
+}
+/** A parenthesized, ordered group of query criteria. */
+export interface QueryCriteriaGroup {
+    kind: 'GROUP';
+    operator: 'AND' | 'OR';
+    children: QueryCriteriaNode[];
+}
+/** An ordered query-expression node, either a condition or a nested group. */
+export type QueryCriteriaNode = QueryCriteriaCondition | QueryCriteriaGroup;
 export interface WebSort {
     field: string;
     desc?: boolean;
@@ -548,7 +583,7 @@ export interface WebQueryRequest {
     page?: WebPageRequest;
     unpaged?: boolean;
     conditions?: WebQueryCondition[];
-    criteria?: unknown;
+    criteria?: QueryCriteriaGroup;
     queryForm?: Record<string, unknown>;
     sorts?: WebSort[];
     uiConfigId?: string;
@@ -561,7 +596,7 @@ export interface WebQueryRequest {
     navigatorTargetLevelKey?: string;
 }
 /** Shared field-reference delivery contract for static and metadata-backed modules. */
-export type WebReferenceResolveMode = 'QUERY' | 'TREE' | 'TRANSLATE';
+export type WebReferenceResolveMode = 'QUERY' | 'TREE' | 'TREE_CHILDREN' | '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. */
@@ -574,7 +609,7 @@ export interface WebReferenceResolveRequest {
     fuzzy?: string;
     values?: unknown[];
     conditions?: WebQueryCondition[];
-    criteria?: unknown;
+    criteria?: QueryCriteriaGroup;
     page?: WebPageRequest;
     includeProjections?: boolean;
     formValues?: Record<string, unknown>;
@@ -583,6 +618,8 @@ export interface WebReferenceResolveRequest {
     uiConfigId?: string;
     queryTemplateId?: string;
     externalQueryValues?: Record<string, unknown>;
+    /** Parent identity for one-level lazy tree delivery. Omit it to read the tree root. */
+    parentId?: string;
     /**
      * Host page that owns this navigator reference request.  Reference transports
      * use it only to resolve the declared NAVIGATOR_QUERY bindings; ordinary
@@ -598,6 +635,8 @@ export interface WebReferenceResolveItem {
     matchedBy?: WebReferenceMatchMode;
     projections?: Record<string, unknown>;
     affectPatch?: Record<string, unknown>;
+    /** Present for TREE_CHILDREN: whether the same authorized candidate scope exposes a child. */
+    hasChildren?: boolean;
 }
 export interface WebReferenceResolveResult {
     input: unknown;
@@ -617,7 +656,7 @@ export interface WebReferenceResolveResponse {
     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 type QueryOperator = 'EQ' | 'NOT_EQUAL' | 'LIKE' | 'IN' | 'NOT_IN' | 'GT' | 'GTE' | 'LT' | 'LTE' | 'BETWEEN' | 'NULL' | 'NOT_NULL' | 'CONTAINS' | 'CONTAINS_ANY' | 'CONTAINS_ALL' | 'EMPTY' | 'NOT_EMPTY';
 export interface QuerySchemaField {
     name: string;
     title?: string;
@@ -626,7 +665,26 @@ export interface QuerySchemaField {
     defaultOperator?: QueryOperator;
     quickSearch?: boolean;
     sortable?: boolean;
+    /** Explicit field-domain binding; distinguishes options from reference title companions. */
+    optionBinding?: OptionBindingDescriptor;
+    selectionMode?: 'SINGLE' | 'MULTIPLE';
     optionTitleField?: string;
+    /** A persisted record-id reference selectable through this source field's standard resolve contract. */
+    reference?: QuerySchemaReference;
+    /** A backend-owned default condition rendered by the standard list query surface. */
+    persistentControl?: QuerySchemaPersistentControl;
+}
+export interface QuerySchemaPersistentControl {
+    id: string;
+    title: string;
+    operator: QueryOperator;
+    defaultValues?: unknown[];
+}
+export interface QuerySchemaReference {
+    targetModuleAlias: string;
+    cardinality: 'ONE' | 'MANY';
+    /** Target candidate label field when the reference explicitly declares one. */
+    labelField?: string;
 }
 export interface QuerySchemaQuickSearch {
     enabled: boolean;
@@ -649,6 +707,8 @@ export interface QuerySchema {
     fields: QuerySchemaField[];
     externalCriteria: QuerySchemaExternalCriteria[];
     defaultSorts: QuerySchemaDefaultSort[];
+    /** Server-declared criteria structure supported by this query surface. */
+    criteriaComposition?: 'NONE' | 'FLAT_AND' | 'TREE';
 }
 export type ModuleViewKind = 'LIST' | 'FORM' | 'DETAIL';
 export type ModuleUiClientType = 'WEB';
@@ -665,7 +725,7 @@ export interface UiFormula {
 /** Versioned program compiled by FormulaEngine. The browser executes it locally and never parses expression. */
 export interface FormulaProgram {
     schemaVersion: number;
-    profile: 'WEB_UI' | 'PAGE_TEXT' | 'FORM_COMPUTE';
+    profile: 'WEB_UI' | 'PAGE_TEXT' | 'FORM_COMPUTE' | 'FORM_VALIDATION';
     root: FormulaNode;
     referencedFields: string[];
 }
@@ -777,6 +837,8 @@ export interface ResolvedReferenceFieldDescriptor {
     candidateDependencies?: ReferenceCandidateDependency[];
     /** Read-side title projection for this scalar reference, when supplied by the server. */
     titleField?: string;
+    /** Target fields mapped by metadata to read-only source-record display projections. */
+    displayProjections?: ResolvedReferenceDisplayProjectionDescriptor[];
     /**
      * Explicitly authorized target-field paths available after choosing this ONE reference.
      * Paths are relative to this reference field; the form runtime prefixes them with the
@@ -791,6 +853,10 @@ export interface ResolvedReferenceFieldDescriptor {
 export interface ResolvedReferenceSelectionProjectionDescriptor {
     path: string[];
 }
+export interface ResolvedReferenceDisplayProjectionDescriptor {
+    targetField: string;
+    outputField: string;
+}
 export interface ReferenceCandidateDependency {
     sourceField: string;
     targetField: string;
@@ -832,6 +898,14 @@ export interface ResolvedFormComputeRuleDescriptor {
     triggerFields: string[];
     writePolicy: 'ALWAYS';
 }
+/** Server-issued browser pre-save validation; the server enforces the same rule on mutation. */
+export interface ResolvedFormValidationRuleDescriptor {
+    code: string;
+    program: FormulaProgram;
+    inputFields: string[];
+    targetField?: string;
+    message: string;
+}
 export interface ResolvedViewDescriptor {
     viewCode: string;
     viewKind: ModuleViewKind;
@@ -842,6 +916,7 @@ export interface ResolvedViewDescriptor {
     sourceUiConfigId?: string;
     formGroups?: FormGroupDescriptor[];
     formComputeRules?: ResolvedFormComputeRuleDescriptor[];
+    formValidationRules?: ResolvedFormValidationRuleDescriptor[];
 }
 export type ModulePageTemplate = 'FLAT_MANAGEMENT' | 'LIST_DETAIL_CARD' | 'TREE_MANAGEMENT';
 export interface ResolvedPageExplorerDescriptor {
@@ -877,7 +952,7 @@ export interface ResolvedPageNavigatorLevelDescriptor {
      */
     sourceScope?: 'NONE' | 'CURRENT_TENANT';
     /** When present, the navigator source exposes its own standard CRUD affordances in place. */
-    management?: ResolvedPageNavigatorManagementDescriptor;
+    management?: ResolvedPageNavigatorManagementDescriptor | null;
 }
 export interface ResolvedPageContextBindingDescriptor {
     source: 'SESSION' | 'NAVIGATOR' | 'RESOLVED_SELECTION';
@@ -915,16 +990,32 @@ export interface ResolvedPageTextDescriptor {
 export interface ResolvedPageListQuerySummaryDescriptor {
     key: string;
     title: string;
-    source: 'MATCHED_COUNT' | 'CONTRIBUTOR';
+    source: 'MATCHED_COUNT' | 'SUM' | 'CONTRIBUTOR' | 'GROUPED';
+    fieldName?: string;
     contributorKey?: string;
+    groupByField?: string;
+    groupByTitle?: string;
+    sumFieldTitle?: string;
 }
-/** A persistent boolean query control rendered after search and before advanced filtering. */
-export interface ResolvedPageListPersistentQueryControlDescriptor {
+/** A module-owned boolean condition rendered before search. */
+export interface ResolvedPageListExternalPersistentQueryControlDescriptor {
+    source: 'EXTERNAL';
+    id: string;
     externalCriteriaKey: string;
     title: string;
     uiType: 'SWITCH';
     defaultValue: boolean;
 }
+/** A field condition rendered before search and composed into the root AND query group. */
+export interface ResolvedPageListFieldPersistentQueryControlDescriptor {
+    source: 'FIELD';
+    id: string;
+    title: string;
+    fieldName: string;
+    operator: QueryOperator;
+    defaultValues: unknown[];
+}
+export type ResolvedPageListPersistentQueryControlDescriptor = ResolvedPageListExternalPersistentQueryControlDescriptor | ResolvedPageListFieldPersistentQueryControlDescriptor;
 export interface ResolvedPageListRelationExpansionDescriptor {
     relationCode: string;
     fields: string[];
@@ -944,6 +1035,8 @@ export interface ResolvedPageDetailWorkspaceViewDescriptor {
     type: string;
 }
 export interface ResolvedModulePageDescriptor {
+    /** Omitted uses the module default; empty disables page quick search. */
+    quickSearchFields?: string[];
     template: ModulePageTemplate;
     explorer?: ResolvedPageExplorerDescriptor;
     navigator?: ResolvedPageNavigatorDescriptor;
@@ -951,8 +1044,25 @@ export interface ResolvedModulePageDescriptor {
     /** Declared action-contribution tree rendered as the main TREE_MANAGEMENT resource. */
     treeResource?: ResolvedPageTreeResourceDescriptor;
     detail: ResolvedPageDetailDescriptor;
+    /** Actions placed only into platform-owned page regions. */
+    actions?: ResolvedPageActionDescriptor[];
+    managedActions?: boolean;
     traits: ('STANDARD_CRUD' | 'ENABLED_STATUS' | 'RECYCLE_BIN' | 'RESPONSIVE_DETAIL_SURFACE')[];
 }
+/** Compiled transport for an action that explicitly supports a standard page surface. */
+export interface PageActionInvocation {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    input: 'NONE' | 'FORM_RECORD';
+}
+export interface ResolvedPageActionDescriptor {
+    title?: string;
+    operation?: string;
+    actionCode: string;
+    anchor: 'PAGE' | 'DETAIL' | 'FORM';
+    invocation?: PageActionInvocation;
+    statusMode?: 'NONE' | 'INPUT_VALIDATION';
+}
 export interface ResolvedPageTreeResourceDescriptor {
     resource: string;
     scopeNavigatorKey: string;
@@ -963,6 +1073,8 @@ export interface ResolvedPageTreeResourceDescriptor {
     title: string;
     emptyDescription: string;
     createTitle: string;
+    /** Persisted fields that define the resource's own server-authoritative sort partition. */
+    sortPartitionFields: string[];
 }
 export interface ResolvedUiActionConfirmationDescriptor {
     mode: 'typedText';
@@ -1268,6 +1380,8 @@ export interface PlatformModule extends StandardEnabledTreeEntity {
 }
 /** A governed operation exposed by one platform module. */
 export interface PlatformModuleAction extends StandardEnabledSortableEntity {
+    bindingPending?: boolean;
+    formSupported?: boolean;
     moduleAlias?: string;
     actionCode?: string;
     entityAlias?: string;
@@ -1323,7 +1437,8 @@ export interface ModuleMetadataRelation extends StandardSortableEntity {
     moduleAlias?: string;
     metadataId?: string;
     relationAlias?: string;
-    relationRole?: 'MAIN' | 'CHILD';
+    /** Runtime APIs serialize Java code enums using their lower-case code; upper-case remains accepted for fixtures. */
+    relationRole?: 'main' | 'child' | 'MAIN' | 'CHILD';
     parentMetadataId?: string;
     foreignKey?: string;
     autoPopulate?: boolean;
@@ -1346,6 +1461,7 @@ export interface FieldSpec extends StandardEnabledSortableEntity {
     queryOperators?: string[];
     defaultUiControlAlias?: string;
     uiControlAliases?: string[];
+    safeTargetFieldSpecAliases?: string[];
 }
 export interface FieldUiControl extends StandardEnabledSortableEntity {
     alias?: string;
@@ -1391,9 +1507,13 @@ export interface DictionaryItem extends StandardEnabledTreeEntity {
     categoryAlias?: string;
     code?: string;
 }
-export interface TreeSortRequest {
+/** Relative placement for a sortable flat record collection. */
+export interface SortRequest {
     previousId?: string | null;
     nextId?: string | null;
+}
+/** Relative placement for a sortable tree record collection. */
+export interface TreeSortRequest extends SortRequest {
     parentId?: string | null;
 }
 export type FieldKind = 'input' | 'select' | 'dictionary-select' | 'reference-select';

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

@@ -14,6 +14,8 @@ export interface HttpRequestOptions {
     query?: Record<string, RouteQueryValue>;
     body?: unknown;
     headers?: Record<string, string>;
+    /** Cancels the underlying Fetch request, including a long-lived response stream. */
+    signal?: AbortSignal;
 }
 export interface HttpClient {
     request<T>(options: HttpRequestOptions): Promise<T>;

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

@@ -4,3 +4,4 @@ export * from './staticModuleClient';
 export type { ModuleActionState, ModuleRecordActionAvailability, ModuleRuntimeAction, ModuleRuntimeContext, ModuleRuntimeContextState, } from './runtimeContext';
 export type { ModuleAbilityClients, ModuleAbilities } from './abilities';
 export * from './moduleContext';
+export * from './pageActionEntries';

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

@@ -1,3 +1,4 @@
+import { type PropType } from 'vue';
 import type { HttpClient } from '../http';
 import { type ModuleAbilities } from './abilities';
 import { type ModuleActionState, type ModuleRecordActionAvailability, type ModuleRuntimeAction, type ModuleRuntimeContextState } from './runtimeContext';
@@ -25,7 +26,7 @@ export interface ModuleContextConfig {
 }
 export interface ModuleContextOptions extends ModuleContextConfig {
     moduleAlias: string;
-    runtimeAccess?: 'MENU' | 'REFERENCE';
+    runtimeAccess?: 'MENU' | 'REFERENCE' | 'VIEW';
     navigatorReference?: NavigatorReferenceRequestContext;
 }
 export declare function configureModuleContext(config: ModuleContextConfig): void;
@@ -34,12 +35,32 @@ export declare function createModuleContext<TRecord>(options: ModuleContextOptio
 export declare function createModuleTreeContext<TRecord>(options: ModuleContextOptions): ModuleTreeContext<TRecord>;
 export declare function useModuleContext<TRecord>(options?: Partial<ModuleContextOptions>): ModuleContext<TRecord>;
 export declare function useModuleTreeContext<TRecord>(options?: Partial<ModuleContextOptions>): ModuleTreeContext<TRecord>;
+/** New consumers capture the current immutable transport; existing contexts keep their original client. */
+export declare const ModuleHttpProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    http: {
+        type: PropType<HttpClient>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    http: {
+        type: PropType<HttpClient>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export declare const ModuleContextProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     moduleAlias: {
         type: StringConstructor;
         required: false;
         default: undefined;
     };
+    /** Reuse an already-authorized module session without recreating a MENU runtime. */
+    context: {
+        type: PropType<ModuleContext<unknown>>;
+        required: false;
+        default: undefined;
+    };
 }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
 }>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
@@ -48,6 +69,13 @@ export declare const ModuleContextProvider: import("vue").DefineComponent<import
         required: false;
         default: undefined;
     };
+    /** Reuse an already-authorized module session without recreating a MENU runtime. */
+    context: {
+        type: PropType<ModuleContext<unknown>>;
+        required: false;
+        default: undefined;
+    };
 }>> & Readonly<{}>, {
     moduleAlias: string;
+    context: ModuleContext<unknown>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,21 @@
+/** Shared interaction vocabulary for page design and business rendering. */
+export declare function pageActionIntent(code: string, anchor: string): {
+    operation: string;
+    title: string;
+    mode?: "create" | "edit";
+};
+export declare function pageActionEntryTitle(entry: {
+    actionCode: string;
+    anchor: string;
+    title?: string;
+}): string;
+export declare function pageActionEntryVisible(entry: {
+    actionCode: string;
+    anchor: string;
+    hidden?: boolean;
+    operation?: string;
+}, mode: 'view' | 'create' | 'edit'): boolean;
+export declare function pageActionEntryDescription(entry: {
+    actionCode: string;
+    anchor: string;
+}): string;