@ximatai/muyun-web-app 0.26.10 → 0.26.12

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';
@@ -42,4 +43,8 @@ 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';
+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

@@ -11,7 +11,11 @@ export interface UiDataTableColumn {
 }
 export interface UiDataTablePagination {
     pageSize: number;
+    current?: number;
+    total?: number;
     showSizeChanger?: boolean;
+    showQuickJumper?: boolean;
+    onChange?: (page: number, pageSize: number) => void;
 }
 export interface UiDataTableSelection {
     selectedRowKeys: UiDataTableKey[];
@@ -43,6 +47,8 @@ export type UiTreeNodeAction = UiRecordInlineAction;
 export interface UiTreeNode {
     key: string;
     title: string;
+    /** False keeps the node expandable before its children are loaded. */
+    isLeaf?: boolean;
     disabled?: boolean;
     secondary?: string;
     tag?: string;
@@ -50,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,6 +391,8 @@ 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;
@@ -626,6 +637,8 @@ export interface QuerySchemaField {
     defaultOperator?: QueryOperator;
     quickSearch?: boolean;
     sortable?: boolean;
+    /** Explicit field-domain binding; distinguishes options from reference title companions. */
+    optionBinding?: OptionBindingDescriptor;
     optionTitleField?: string;
 }
 export interface QuerySchemaQuickSearch {
@@ -665,7 +678,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' | 'FORM_COMPUTE';
+    profile: 'WEB_UI' | 'PAGE_TEXT' | 'FORM_COMPUTE' | 'FORM_VALIDATION';
     root: FormulaNode;
     referencedFields: string[];
 }
@@ -777,6 +790,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 +806,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 +851,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 +869,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,10 +905,10 @@ 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';
+    source: 'SESSION' | 'NAVIGATOR' | 'RESOLVED_SELECTION';
     sourceKey: string;
     target: 'LIST_QUERY' | 'NAVIGATOR_QUERY' | 'FORM_DEFAULT' | 'PICKER_QUERY' | 'MUTATION_CONSTRAINT';
     targetKey: string;
@@ -900,18 +928,29 @@ export interface ResolvedPageNavigatorManagementDescriptor {
 export interface ResolvedPageListDescriptor {
     searchPlaceholder: string;
     fields: ResolvedViewDescriptor;
+    /** Main-content header copy; PAGE_TEXT programs run only against the host display context. */
+    title?: ResolvedPageTextDescriptor;
+    subtitle?: ResolvedPageTextDescriptor;
     /** Read-only placements of declared aggregate relations beneath an expanded list row. */
     relationExpansions?: ResolvedPageListRelationExpansionDescriptor[];
     persistentQueryControls?: ResolvedPageListPersistentQueryControlDescriptor[];
     querySummaries?: ResolvedPageListQuerySummaryDescriptor[];
 }
+export interface ResolvedPageTextDescriptor {
+    text?: string;
+    program?: FormulaProgram;
+}
 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. */
+/** A persistent boolean query control rendered before search; advanced filtering follows search. */
 export interface ResolvedPageListPersistentQueryControlDescriptor {
     externalCriteriaKey: string;
     title: string;
@@ -937,6 +976,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;
@@ -944,8 +985,24 @@ 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;
+}
 export interface ResolvedPageTreeResourceDescriptor {
     resource: string;
     scopeNavigatorKey: string;
@@ -956,6 +1013,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';
@@ -1261,6 +1320,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;
@@ -1316,7 +1377,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;
@@ -1339,6 +1401,7 @@ export interface FieldSpec extends StandardEnabledSortableEntity {
     queryOperators?: string[];
     defaultUiControlAlias?: string;
     uiControlAliases?: string[];
+    safeTargetFieldSpecAliases?: string[];
 }
 export interface FieldUiControl extends StandardEnabledSortableEntity {
     alias?: string;
@@ -1384,9 +1447,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/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';
@@ -34,6 +35,20 @@ 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>;
+/** An immutable transport boundary; remount it to begin a separate business data session. */
+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;

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;

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

@@ -1,8 +1,11 @@
-import type { ResolvedModuleUiDescriptor } from '../../web-contracts/index';
+import type { PageActionInvocation, ResolvedModuleUiDescriptor } from '../../web-contracts/index';
 import { type AppError } from '../errors';
 import type { HttpClient } from '../http';
 import type { ModuleAbilityCode } from './abilityCodes';
 export interface ModuleRuntimeAction {
+    bindingPending?: boolean;
+    formSupported?: boolean;
+    invocations?: Partial<Record<'PAGE' | 'DETAIL' | 'FORM', PageActionInvocation>>;
     actionCode: string;
     permissionActionCode?: string;
     title?: string;
@@ -38,6 +41,7 @@ export interface ModuleRecordActionDecision {
 }
 export interface ModuleRuntimeContext {
     moduleAlias: string;
+    tenantRequired?: boolean;
     title?: string;
     moduleKind?: 'STATIC' | 'DYNAMIC';
     entryType?: 'module' | 'route' | 'link';
@@ -45,10 +49,10 @@ export interface ModuleRuntimeContext {
     entryExternalUrl?: string;
     mainEntityAlias?: string;
     capabilities: string[];
+    /** Persisted fields that define the server-authoritative sort partition. */
+    sortPartitionFields?: 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 {

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

@@ -1,4 +1,4 @@
-import type { TreeSortRequest, WebActionResultFacts, WebActionResultEnvelope, QuerySchema, WebListResponse, WebPageResponse, WebQueryRequest, WebTreeNode } from '../../web-contracts/index';
+import type { SortRequest, TreeSortRequest, WebActionResultFacts, WebActionResultEnvelope, QuerySchema, WebListResponse, WebPageResponse, WebQueryRequest, WebTreeNode } from '../../web-contracts/index';
 import type { HttpClient } from '../http';
 export interface StaticRecordMutationResult<TRecord> extends WebActionResultFacts {
     record: TRecord;
@@ -21,6 +21,8 @@ export interface ModuleCrudClient<TRecord> {
     delete(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
     enable(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
     disable(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
+    /** Optional capability: plain CRUD consumers must not be forced to implement sorting. */
+    sort?(id: string, request: SortRequest): Promise<StaticCountMutationResult>;
 }
 /** Source-neutral tree extension for a platform module. */
 export interface ModuleTreeClient<TRecord> extends ModuleCrudClient<TRecord> {
@@ -32,7 +34,12 @@ export interface ModuleTreeClient<TRecord> extends ModuleCrudClient<TRecord> {
     subtree(id: string, options?: {
         includeSelf?: boolean;
     }): Promise<WebListResponse<WebTreeNode<TRecord>>>;
-    sort(id: string, request: TreeSortRequest): Promise<StaticCountMutationResult>;
+    sort(id: string, request: TreeSortRequest, options?: TreeSortOptions): Promise<StaticCountMutationResult>;
+}
+export interface TreeSortOptions {
+    externalQueryValues?: Record<string, unknown>;
+    navigatorHostModuleAlias?: string;
+    navigatorTargetLevelKey?: string;
 }
 export interface ModuleEnableClient {
     enable(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
@@ -75,11 +82,27 @@ export interface NavigatorReferenceRequestContext {
     targetLevelKey: string;
 }
 export declare function createStaticResourceTreeClient<TRecord>(http: HttpClient, resourcePath: string): ModuleTreeClient<TRecord>;
-/** @deprecated Use ModuleCrudClient. Remove after static-prefixed consumer imports migrate. */
+/** @deprecated Use ModuleCrudClient. Retained for published consumer compatibility. */
 export type StaticModuleCrudClient<TRecord> = ModuleCrudClient<TRecord>;
-/** @deprecated Use ModuleTreeClient. Remove after static-prefixed consumer imports migrate. */
+/** @deprecated Use ModuleTreeClient. Retained for published consumer compatibility. */
 export type StaticModuleTreeClient<TRecord> = ModuleTreeClient<TRecord>;
-/** @deprecated Use createModuleCrudClient. Remove after static-prefixed consumer imports migrate. */
+/** @deprecated Use createModuleCrudClient. Retained for published consumer compatibility. */
 export declare const createStaticModuleCrudClient: typeof createModuleCrudClient;
-/** @deprecated Use createModuleTreeClient. Remove after static-prefixed consumer imports migrate. */
+/** @deprecated Use createModuleTreeClient. Retained for published consumer compatibility. */
 export declare const createStaticModuleTreeClient: typeof createModuleTreeClient;
+/**
+ * Dynamic records use a typed `{ id, version, values, children }` wire envelope while static
+ * records already publish their fields at the root. The shared module client is the only place
+ * that should bridge this transport difference: every page surface then consumes one flat record
+ * contract, including aggregate children, and submits that same accepted shape back to the
+ * dynamic deserializer.
+ */
+export declare function normalizeModuleRecord<TRecord>(record: TRecord): TRecord;
+/**
+ * Normalizes a page response at the source-neutral module transport boundary.
+ *
+ * <p>Association query contracts use their server-issued route directly instead of the standard
+ * module CRUD path, but they still return the same dynamic record envelope.  Keeping this helper
+ * public lets those descriptor-driven surfaces reuse the one normalization rule.</p>
+ */
+export declare function normalizeModulePageResponse<TRecord>(response: WebPageResponse<TRecord>): WebPageResponse<TRecord>;