@ximatai/muyun-web-app 0.26.4 → 0.26.6

package/dist/types/platform-components/RecordPanelButton.vue.d.ts

@@ -0,0 +1,33 @@
+import { type UiIconName } from '../vue-ui-antdv/index';
+type __VLS_Props = {
+    type?: 'default' | 'primary' | 'dashed' | 'link' | 'text';
+    disabled?: boolean;
+    loading?: boolean;
+    danger?: boolean;
+    title?: string;
+    iconName?: UiIconName;
+};
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    type: "default" | "primary" | "dashed" | "link" | "text";
+    title: string;
+    danger: boolean;
+    disabled: boolean;
+    loading: boolean;
+    iconName: UiIconName;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/platform-components/RecordPanelState.vue.d.ts

@@ -0,0 +1,11 @@
+type __VLS_Props = {
+    loading?: boolean;
+    description: string;
+    loadingTip?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    loading: boolean;
+    loadingTip: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/platform-components/RecordPicker.vue.d.ts

@@ -22,9 +22,9 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
 }>, {
     disabled: boolean;
     value: string;
-    mode: "list" | "tree";
     placeholder: string;
     allowClear: boolean;
+    mode: "list" | "tree";
     filterOption: (record: RecordPickerRecord, keyword: string) => boolean;
     titleOf: (record: RecordPickerRecord) => string;
     reloadKey: number;

package/dist/types/platform-components/RecordQueryListPanel.vue.d.ts

@@ -1,3 +1,5 @@
+import { type Component } from 'vue';
+import type { ResolvedViewFieldDescriptor } from '../web-contracts/index';
 import { type ModuleContext } from '../web-core/index';
 import { type RecordActionItem, type ResolvedRecordActionItem } from './recordActionBarModel';
 export type QueryListRecord = Record<string, unknown> & {
@@ -8,23 +10,41 @@ export type RecordQueryListMode = 'normal' | 'recycleBin';
 export interface RecordQueryListColumn {
     key: string;
     title: string;
-    type?: 'text' | 'enabledStatus' | 'datetime';
+    type?: 'text' | 'enabledStatus' | 'booleanStatus' | 'tagList' | 'datetime' | 'fileSize' | 'colorPicker';
+    booleanStatus?: ResolvedViewFieldDescriptor['booleanStatus'];
     width?: string;
     align?: 'left' | 'center' | 'right';
     titleField?: string;
+    /** Maximum visible lines for text cells. Defaults to one line. */
+    maxDisplayLines?: number;
     render?: (record: QueryListRecord) => string;
 }
+export interface RecordQueryListCellComponent {
+    key: string;
+    component: Component;
+}
 type __VLS_Props = {
     context: ModuleContext<QueryListRecord>;
     title: string;
     columns?: RecordQueryListColumn[];
+    /** Columns appended to, or anchored around, the descriptor-owned list fields. */
+    additionalColumns?: Array<RecordQueryListColumn & {
+        before?: string;
+        after?: string;
+    }>;
+    /** Vue cell components are deliberately constrained to cells; they do not own the table shell. */
+    cellComponents?: RecordQueryListCellComponent[];
     actions?: RecordActionItem[];
+    extraActions?: RecordActionItem[];
+    batchActions?: RecordActionItem[];
     standardCrudActions?: boolean;
     standardCrudRowActions?: boolean;
     rowActionsOf?: (record: QueryListRecord) => RecordActionItem[];
     extraRowActionsOf?: (record: QueryListRecord) => RecordActionItem[];
     rowActionStateOf?: (record: QueryListRecord, action: RecordActionItem) => Partial<RecordActionItem> | undefined;
     rowActionsTitle?: string;
+    /** Width of the fixed right-side action column. Defaults to the platform compact width. */
+    actionColumnWidth?: string | number;
     cellRenderers?: Record<string, (record: QueryListRecord) => string>;
     rowKey?: string;
     selectedKey?: string;
@@ -36,19 +56,33 @@ type __VLS_Props = {
     queryTemplateId?: string;
     ready?: boolean;
     externalQueryValues?: Record<string, unknown>;
+    /** Descriptor-owned external criteria that must be exposed by the query schema. */
+    requiredExternalCriteriaKeys?: string[];
     quickSearchPlaceholder?: string;
     emptyDescription?: string;
     waitingDescription?: string;
     mode?: RecordQueryListMode;
 };
 type __VLS_Slots = {
+    toolbarActions?: (props: {
+        refresh: () => void;
+    }) => unknown;
+    cell?: (props: {
+        column: RecordQueryListColumn;
+        record: QueryListRecord;
+    }) => unknown;
+    rowActions?: (props: {
+        record: QueryListRecord;
+    }) => unknown;
     expandedRow?: (props: {
         record: QueryListRecord;
         rowKey: string;
     }) => unknown;
 };
 declare function refresh(): void;
+declare function clearSelection(): void;
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    clearSelection: typeof clearSelection;
     refresh: typeof refresh;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     select: (record: QueryListRecord) => any;
@@ -57,6 +91,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     rowExpand: (record: QueryListRecord, expanded: boolean) => any;
     loaded: (records: QueryListRecord[]) => any;
     restored: () => any;
+    batchAction: (action: RecordActionItem, records: QueryListRecord[], event: MouseEvent, clearSelection: () => void) => any;
     rowAction: (action: ResolvedRecordActionItem, record: QueryListRecord, event?: MouseEvent | undefined) => any;
     modeChange: (mode: RecordQueryListMode) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
@@ -66,6 +101,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     onRowExpand?: ((record: QueryListRecord, expanded: boolean) => any) | undefined;
     onLoaded?: ((records: QueryListRecord[]) => any) | undefined;
     onRestored?: (() => any) | undefined;
+    onBatchAction?: ((action: RecordActionItem, records: QueryListRecord[], event: MouseEvent, clearSelection: () => void) => any) | undefined;
     onRowAction?: ((action: ResolvedRecordActionItem, record: QueryListRecord, event?: MouseEvent | undefined) => any) | undefined;
     onModeChange?: ((mode: RecordQueryListMode) => any) | undefined;
 }>, {
@@ -75,12 +111,21 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     columns: RecordQueryListColumn[];
     rowKey: string;
     expandedRowKeys: string[];
+    actionColumnWidth: string | number;
     emptyDescription: string;
     pageSize: number;
     uiConfigId: string;
     queryTemplateId: string;
     reloadKey: number;
+    ready: boolean;
     refreshTitle: string;
+    additionalColumns: Array<RecordQueryListColumn & {
+        before?: string;
+        after?: string;
+    }>;
+    cellComponents: RecordQueryListCellComponent[];
+    extraActions: RecordActionItem[];
+    batchActions: RecordActionItem[];
     standardCrudActions: boolean;
     standardCrudRowActions: boolean;
     rowActionsOf: (record: QueryListRecord) => RecordActionItem[];
@@ -88,8 +133,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     rowActionStateOf: (record: QueryListRecord, action: RecordActionItem) => Partial<RecordActionItem> | undefined;
     rowActionsTitle: string;
     cellRenderers: Record<string, (record: QueryListRecord) => string>;
-    ready: boolean;
     externalQueryValues: Record<string, unknown>;
+    requiredExternalCriteriaKeys: string[];
     quickSearchPlaceholder: string;
     waitingDescription: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/types/platform-components/RecordStatusTag.vue.d.ts

@@ -1,5 +1,10 @@
 type __VLS_Props = {
-    enabled?: boolean;
+    enabled?: boolean | null;
+    enabledLabel?: string;
+    disabledLabel?: string;
+    unknownLabel?: string;
+    enabledTone?: 'SUCCESS' | 'NEUTRAL' | 'WARNING' | 'DANGER';
+    disabledTone?: 'SUCCESS' | 'NEUTRAL' | 'WARNING' | 'DANGER';
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/types/platform-components/RecordTagList.vue.d.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    items: unknown;
+    maxVisible?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/platform-components/TreeRecordExplorer.vue.d.ts

@@ -29,11 +29,11 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     toggleSearch: typeof toggleSearch;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     select: (record: TreeRecordBase) => any;
-    action: (action: UiRecordInlineAction, record: TreeRecordBase) => any;
+    action: (action: import("../web-contracts/index").RecordInlineAction, record: TreeRecordBase) => any;
     loaded: (records: TreeRecordBase[]) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onSelect?: ((record: TreeRecordBase) => any) | undefined;
-    onAction?: ((action: UiRecordInlineAction, record: TreeRecordBase) => any) | undefined;
+    onAction?: ((action: import("../web-contracts/index").RecordInlineAction, record: TreeRecordBase) => any) | undefined;
     onLoaded?: ((records: TreeRecordBase[]) => any) | undefined;
 }>, {
     filterOption: (record: TreeRecordBase, normalizedKeyword: string) => boolean;

package/dist/types/platform-components/fileReferenceTransfer.d.ts

@@ -0,0 +1,17 @@
+import type { HttpClient } from '../web-core/index';
+import type { ResolvedFileReferenceFieldDescriptor } from '../web-contracts/index';
+import type { FileTransferUploadAccess } from './fileTransferUpload';
+/** Issues the module-owned short-lived upload ticket for a declared file-reference field. */
+export declare function issueFileReferenceUploadAccess(http: HttpClient, moduleAlias: string, definition: ResolvedFileReferenceFieldDescriptor, draft: Record<string, unknown>, file: File, intent: FileReferenceUploadIntent): Promise<FileTransferUploadAccess>;
+/** A policy-visible upload fact, derived from the field cardinality and its current binding. */
+export type FileReferenceUploadIntent = 'CREATE' | 'APPEND' | 'REPLACE';
+export declare function fileReferenceUploadIntent(value: unknown, definition: ResolvedFileReferenceFieldDescriptor): FileReferenceUploadIntent;
+/** Returns the physical file that a successful single-file replacement makes eligible for deletion. */
+export declare function replacedFileReferenceId(value: unknown, fileId: string, definition: ResolvedFileReferenceFieldDescriptor): string | undefined;
+/** Extracts the one uploaded file identifier from MuYunFileServer's conventional upload payload. */
+export declare function uploadedFileId(payload: unknown): string;
+/** Applies one successful upload to the draft value without inventing a deletion protocol. */
+export declare function appendUploadedFileReference(value: unknown, fileId: string, definition: ResolvedFileReferenceFieldDescriptor): string | string[];
+export declare function acceptedMediaTypes(definition: ResolvedFileReferenceFieldDescriptor): string | undefined;
+/** Normalizes persisted draft values so callers can account for already bound files. */
+export declare function fileReferenceIds(value: unknown): string[];

package/dist/types/platform-components/fileTransferUpload.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The platform owns the browser-to-storage transfer mechanics, while an
+ * application owns the authorization request. A caller may additionally run a
+ * business confirmation step, while standard file-reference fields only bind
+ * the returned fileId during their later record save.
+ * MuYunFileServer owns the multipart transport; this module deliberately has
+ * no knowledge of a particular business record type.
+ */
+export interface FileTransferUploadAccess {
+    /** A short-lived MuYunFileServer multipart upload URL supplied by the business API. */
+    uploadUrl: string;
+    formFieldName?: string;
+}
+export interface FileTransferUploadReceipt {
+    file: File;
+    /** Storage service response after unwrapping the conventional { data } envelope. */
+    payload: unknown;
+    response: unknown;
+}
+export interface FileTransferUploadTask {
+    promise: Promise<FileTransferUploadReceipt>;
+    cancel: () => void;
+}
+/** Browser-visible phases shared by upload controls. */
+export type FileTransferUploadState = 'requesting' | 'uploading' | 'confirming' | 'completed';
+export interface FileTransferUploadLifecycleCallbacks {
+    stateChanged: (state: FileTransferUploadState) => void;
+    progressChanged?: (percent: number) => void;
+    taskCreated?: (task: FileTransferUploadTask) => void;
+    taskFinished?: () => void;
+}
+/**
+ * Runs the common browser upload lifecycle without knowing the business record being edited.
+ *
+ * State is reported through callbacks so the consuming control can update its own reactive item. When supplied,
+ * business confirmation completes before the completed transition; otherwise the raw storage payload is returned.
+ */
+export declare function performBrowserFileTransferUpload(file: File, requestUploadAccess: (file: File) => Promise<FileTransferUploadAccess>, confirmUpload: ((receipt: FileTransferUploadReceipt) => Promise<unknown>) | undefined, callbacks: FileTransferUploadLifecycleCallbacks): Promise<{
+    receipt: FileTransferUploadReceipt;
+    result: unknown;
+}>;
+export declare function createBrowserFileTransferUpload(file: File, access: FileTransferUploadAccess, onProgress?: (percent: number) => void): FileTransferUploadTask;
+export declare function unwrapResponsePayload(response: unknown): unknown;

package/dist/types/platform-components/index.d.ts

@@ -4,6 +4,10 @@ export { confirmAction } from '../vue-ui-antdv/index';
 export { default as CrudRecordListExplorer } from './CrudRecordListExplorer.vue';
 export { default as DrawerOperationBar } from './DrawerOperationBar.vue';
 export { default as DateTimeText } from './DateTimeText.vue';
+export { default as FileSizeText } from './FileSizeText.vue';
+export { default as FileTransferUploader } from './FileTransferUploader.vue';
+export { createBrowserFileTransferUpload, unwrapResponsePayload } from './fileTransferUpload';
+export type { FileTransferUploadAccess, FileTransferUploadReceipt, FileTransferUploadTask, } from './fileTransferUpload';
 export { default as EnabledSelect } from './EnabledSelect.vue';
 export { default as ModuleActionButton } from './ModuleActionButton.vue';
 export { default as ManagementWorkspace } from './ManagementWorkspace.vue';
@@ -14,23 +18,29 @@ export { default as RecordDetailDrawer } from './RecordDetailDrawer.vue';
 export type { DrawerPromotion } from './drawerPromotion';
 export { default as RecordExternalChangeNotice } from './RecordExternalChangeNotice.vue';
 export { default as RecordDetailFields } from './RecordDetailFields.vue';
+export { default as RecordDetailExtensionSection } from './RecordDetailExtensionSection.vue';
 export { default as RecordDetailPanel } from './RecordDetailPanel.vue';
+export { default as RecordPanelButton } from './RecordPanelButton.vue';
+export { default as RecordPanelState } from './RecordPanelState.vue';
 export { default as RecordExpandedSubtable } from './RecordExpandedSubtable.vue';
 export { default as UserSessionExpandedSubtable } from './UserSessionExpandedSubtable.vue';
 export { userSessionBrowserTitle, userSessionPresenceDescription, userSessionPresenceTitle, userSessionTerminalTitle, } from './userSessionPresentation';
 export { default as RecordExplorerPanel } from './RecordExplorerPanel.vue';
 export type { RecordExplorerItemDescriptor } from './recordExplorerItemModel';
 export { default as RecordFormFields } from './RecordFormFields.vue';
+export { default as RecordFileReferenceTransfer } from './RecordFileReferenceTransfer.vue';
 export { default as RecordListExplorer } from './RecordListExplorer.vue';
 export { default as RecordMetaSection } from './RecordMetaSection.vue';
 export { default as RecordModeDrawer } from './RecordModeDrawer.vue';
 export { default as RecordPicker } from './RecordPicker.vue';
+export { default as RecordMultiPicker } from './RecordMultiPicker.vue';
 export { default as RecordQueryListPanel } from './RecordQueryListPanel.vue';
 export { default as RecycleBinModeButton } from './RecycleBinModeButton.vue';
 export { useRecycleBinExplorerMode, type RecycleBinExplorerMode, type RecycleBinExplorerModeOptions, } from './useRecycleBinExplorerMode';
 export { default as RecordStatusSwitch } from './RecordStatusSwitch.vue';
 export { default as RecordTreeSelector } from './RecordTreeSelector.vue';
 export { default as RecordStatusTag } from './RecordStatusTag.vue';
+export { default as RecordTagList } from './RecordTagList.vue';
 export { useRecycleBinState } from './recycleBinState';
 export type { RecycleBinStateOptions } from './recycleBinState';
 export { createSoftDeletedConflictErrorHandler, extractSoftDeletedConflict, useSoftDeletedConflictHandler, } from './softDeletedConflictHandler';
@@ -45,14 +55,17 @@ export type { RecordPickerMode } from './recordPickerModel';
 export type { RecordActionItem, ResolvedRecordActionItem } from './recordActionBarModel';
 export type { RecordDetailDisplayResolver, RecordDetailDisplayValue } from './recordDetailFieldModel';
 export type { RecordListExplorerRecord } from './RecordListExplorer.vue';
-export type { QueryListRecord, RecordQueryListColumn, RecordQueryListMode } from './RecordQueryListPanel.vue';
+export type { QueryListRecord, RecordQueryListCellComponent, RecordQueryListColumn, RecordQueryListMode, } from './RecordQueryListPanel.vue';
 export type { RecordFormFieldDescriptor, RecordFormFieldFallback, RecordFormFieldPickerConfig, RecordFormFieldState, RecordFormFieldValue, RecordFormRecord, } from './recordFormFieldModel';
 export type { CrudRecordListBase } from './crudRecordListModel';
 export { defaultCrudRecordListMatches, defaultCrudRecordListSubtitle, defaultCrudRecordListTitle, } from './crudRecordListModel';
 export { resolveRecordActions } from './recordActionBarModel';
 export { normalizeRecordDraft } from './recordDraftNormalizer';
+export { acceptedMediaTypes, appendUploadedFileReference, fileReferenceIds, issueFileReferenceUploadAccess, uploadedFileId, } from './fileReferenceTransfer';
 export { resolveRecordDetailDisplayValue } from './recordDetailFieldModel';
 export { formatPlatformDateTime, resolveBrowserTimeZone } from './platformDateTime';
+export { formatPlatformFileSize } from './platformFileSize';
+export type { PlatformFileSizeDisplay, PlatformFileSizeOptions } from './platformFileSize';
 export { providePlatformTimeZoneContext, usePlatformTimeZoneContext } from './platformTimeZoneContext';
 export type { PlatformDateTimeDisplay, PlatformDateTimeOptions, PlatformDateTimePrecision, } from './platformDateTime';
 export { childResourceDefaultFormViewCode, resolveRecordFormFieldNames, resolveRecordFormFieldState, resolveRecordFormFields, } from './recordFormFieldModel';

package/dist/types/platform-components/platformErrorFeedback.d.ts

@@ -7,6 +7,8 @@ export interface PlatformErrorFeedbackContext {
 export declare function presentPlatformError(cause: unknown, context?: PlatformErrorFeedbackContext): AppError;
 export declare function presentPlatformMessage(message: string, context?: PlatformErrorFeedbackContext): void;
 export declare function presentPlatformSuccess(message: string, context?: PlatformErrorFeedbackContext): void;
+/** Presents a non-blocking progress update without treating it as an action result. */
+export declare function presentPlatformInfo(message: string): void;
 export type PlatformActionErrorHandler<TContext> = {
     code?: string;
     marker?: string;

package/dist/types/platform-components/platformFileSize.d.ts

@@ -0,0 +1,10 @@
+export interface PlatformFileSizeDisplay {
+    text: string;
+    title: string;
+    valid: boolean;
+}
+export interface PlatformFileSizeOptions {
+    emptyText?: string;
+    locale?: string;
+}
+export declare function formatPlatformFileSize(value: number | string | bigint | null | undefined, options?: PlatformFileSizeOptions): PlatformFileSizeDisplay;

package/dist/types/platform-components/recordActionBarModel.d.ts

@@ -23,5 +23,10 @@ export interface ResolvedRecordActionItem extends RecordActionItem {
     disabled: boolean;
     loading: boolean;
 }
-export declare function resolveRecordActions(context: Pick<ModuleContext<unknown>, 'action'>, actions: RecordActionItem[], defaultLoading?: boolean, recordId?: string): ResolvedRecordActionItem[];
+type RecordActionContext = Pick<ModuleContext<unknown>, 'action'> & {
+    runtime?: Pick<ModuleContext<unknown>['runtime'], 'snapshot'>;
+    recordActionsSnapshot?: ModuleContext<unknown>['recordActionsSnapshot'];
+};
+export declare function resolveRecordActions(context: RecordActionContext, actions: RecordActionItem[], defaultLoading?: boolean, recordId?: string): ResolvedRecordActionItem[];
 export declare function mergeRecordActions(baseActions: RecordActionItem[], extraActions: RecordActionItem[]): RecordActionItem[];
+export {};

package/dist/types/platform-components/recordFormFieldModel.d.ts

@@ -1,12 +1,16 @@
-import type { Option, OptionValueList, ResolvedOptionFieldDescriptor, ResolvedModuleUiDescriptor, ResolvedViewFieldDescriptor, ViewFieldDefinition } from '../web-contracts/index';
+import type { Option, OptionValueList, ResolvedReferenceFieldDescriptor, BooleanStatusPresentation, ResolvedOptionFieldDescriptor, ResolvedFileReferenceFieldDescriptor, ResolvedModuleUiDescriptor, ResolvedViewFieldDescriptor, FieldValuePresentation, UiFormula, ViewFieldDefinition } from '../web-contracts/index';
 import type { ModuleContext } from '../web-core/index';
 import type { PickerConstraint, RecordPickerRecord } from './recordPickerConstraints';
 export type RecordFormFieldDescriptor = (ViewFieldDefinition | ResolvedViewFieldDescriptor) & {
     option?: ResolvedOptionFieldDescriptor;
+    reference?: ResolvedReferenceFieldDescriptor;
+    fileReference?: ResolvedFileReferenceFieldDescriptor;
 };
 export type RecordFormRecord = Record<string, unknown>;
-export type RecordFormFieldValue = string | number | boolean | OptionValueList | undefined;
-export type RecordFormFieldControlType = 'input' | 'select' | 'enabledStatus' | 'recordPicker';
+export type RecordFormFieldValue = string | number | boolean | OptionValueList | string[] | undefined;
+/** A business boolean does not inherit the lifecycle field's implicit enabled default. */
+export type RecordBooleanStatusValue = boolean | undefined;
+export type RecordFormFieldControlType = 'input' | 'textarea' | 'colorPicker' | 'select' | 'enabledStatus' | 'booleanStatus' | 'switch' | 'recordPicker' | 'recordMultiPicker' | 'fileTransfer';
 export interface RecordFormFieldFallback {
     label: string;
     required?: boolean;
@@ -14,6 +18,7 @@ export interface RecordFormFieldFallback {
     visible?: boolean;
     controlType?: RecordFormFieldControlType;
     placeholder?: string;
+    disabledHint?: string;
     options?: Option[];
     optionSelectionMode?: 'SINGLE' | 'MULTIPLE';
 }
@@ -35,10 +40,16 @@ export interface RecordFormFieldState {
     readOnly: boolean;
     visible: boolean;
     controlType: RecordFormFieldControlType;
+    columnSpan: number;
     hasOption: boolean;
     optionSelectionMode?: 'SINGLE' | 'MULTIPLE';
     optionTitleField?: string;
+    referenceTitleField?: string;
+    fileReference?: ResolvedFileReferenceFieldDescriptor;
     pickerConfig?: RecordFormFieldPickerConfig;
+    booleanStatus?: BooleanStatusPresentation;
+    valuePresentation?: FieldValuePresentation;
+    disabledHint?: string;
     placeholder?: string;
     options?: Option[];
 }
@@ -54,4 +65,11 @@ export declare function resolveRecordFormFieldState(fieldName: string, options?:
     fallback?: Record<string, RecordFormFieldFallback>;
     pickerConfigs?: Record<string, RecordFormFieldPickerConfig>;
     placeholderOf?: (fieldName: string, field: RecordFormFieldState) => string | undefined;
+    record?: RecordFormRecord;
 }): RecordFormFieldState;
+export declare function evaluateUiFormula(formula: UiFormula, record: RecordFormRecord): boolean;
+/**
+ * Preserves an absent business value as unknown instead of treating it as true.
+ * `enabledStatus` deliberately retains its separate lifecycle default semantics.
+ */
+export declare function resolveRecordBooleanStatusValue(value: unknown): RecordBooleanStatusValue;

package/dist/types/platform-workbench/Workbench.vue.d.ts

@@ -7,13 +7,13 @@ type __VLS_Props = {
     activeTabKey?: string;
     realtimeStatus?: WorkbenchRealtimeStatus;
 };
-declare var __VLS_66: {
+declare var __VLS_92: {
     activeTab: MenuTab;
     target: MenuNavigationTarget | undefined;
     pageDescriptor: PageDescriptor | undefined;
 };
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_66) => any;
+    default?: (props: typeof __VLS_92) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     selectMenu: (menu: MenuRecord, target: MenuNavigationTarget) => any;

package/dist/types/platform-workbench/WorkbenchBrandControl.vue.d.ts

@@ -0,0 +1,21 @@
+type __VLS_Props = {
+    presentation: 'compact' | 'expanded';
+    compactOpen?: boolean;
+    tenantLabel?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    openCompactMenu: (source: "click" | "focus" | "pointer") => any;
+    scheduleCompactMenuClose: () => any;
+    closeCompactMenu: () => any;
+    changePresentation: (presentation: "compact" | "expanded") => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onOpenCompactMenu?: ((source: "click" | "focus" | "pointer") => any) | undefined;
+    onScheduleCompactMenuClose?: (() => any) | undefined;
+    onCloseCompactMenu?: (() => any) | undefined;
+    onChangePresentation?: ((presentation: "compact" | "expanded") => any) | undefined;
+}>, {
+    compactOpen: boolean;
+    tenantLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/platform-workbench/WorkbenchMenu.vue.d.ts

@@ -6,18 +6,32 @@ type __VLS_Props = {
     tenantLabel?: string;
     searchPlaceholder?: string;
     realtimeStatus?: WorkbenchRealtimeStatus;
+    presentation?: 'compact' | 'expanded';
+    compactOpen?: boolean;
+    compactTop?: number;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    changePresentation: (presentation: "compact" | "expanded") => any;
     selectMenu: (menu: MenuRecord, target: MenuNavigationTarget) => any;
     invalidMenu: (menu: MenuRecord) => any;
+    compactMenuEnter: () => any;
+    compactMenuLeave: () => any;
+    compactMenuClose: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChangePresentation?: ((presentation: "compact" | "expanded") => any) | undefined;
     onSelectMenu?: ((menu: MenuRecord, target: MenuNavigationTarget) => any) | undefined;
     onInvalidMenu?: ((menu: MenuRecord) => any) | undefined;
+    onCompactMenuEnter?: (() => any) | undefined;
+    onCompactMenuLeave?: (() => any) | undefined;
+    onCompactMenuClose?: (() => any) | undefined;
 }>, {
-    selectedMenuId: string;
+    presentation: "compact" | "expanded";
+    compactOpen: boolean;
     tenantLabel: string;
+    selectedMenuId: string;
     searchPlaceholder: string;
     realtimeStatus: WorkbenchRealtimeStatus;
+    compactTop: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/platform-workbench/WorkbenchMenuTree.vue.d.ts

@@ -3,6 +3,8 @@ import type { WorkbenchMenuNode } from './menuTreeModel';
 type __VLS_Props = {
     node: WorkbenchMenuNode;
     level?: number;
+    selectedMenuId?: string;
+    selectedPathIds?: string[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     selectMenu: (menu: MenuRecord, target: MenuNavigationTarget) => any;

package/dist/types/platform-workbench/WorkspaceViewOutlet.vue.d.ts

@@ -0,0 +1,7 @@
+import type { BusinessRoutePageDescriptor } from '../web-contracts/index';
+type __VLS_Props = {
+    descriptor: BusinessRoutePageDescriptor;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/platform-workbench/index.d.ts

@@ -1,8 +1,15 @@
 export { default as Workbench } from './Workbench.vue';
 export { default as WorkbenchMenu } from './WorkbenchMenu.vue';
 export { default as WorkbenchOutlet } from './WorkbenchOutlet.vue';
+export { default as WorkspaceViewOutlet } from './WorkspaceViewOutlet.vue';
 export { provideWorkbenchNavigation, useWorkbenchNavigation } from './workbenchNavigation';
 export type { WorkbenchNavigation, WorkbenchPageOpenResult } from './workbenchNavigation';
+export { configureWorkspaceViewContributions, createWorkspaceViewDescriptor, createWorkspaceViewRegistry, dismissWorkspaceViewDescriptor, resolveWorkspaceView, } from './workspaceViews';
+export { provideWorkspaceViewHost, useWorkspaceViewHost } from './workspaceViewHost';
+export { defineWorkspaceView } from './workspaceViewContract';
+export type { ResolvedWorkspaceView, WorkspaceViewRegistry } from './workspaceViews';
+export type { WorkspaceViewDefinition, WorkspaceViewInput, WorkspaceViewPresentation, WorkspaceDrawerProfile, } from './workspaceViewContract';
+export type { WorkspaceViewHost } from './workspaceViewHost';
 export { createMenuTab, findFirstNavigationMenu, getMenuNavigationTarget, isTabMenuTarget, isWindowMenuTarget, pageDescriptorFromUrl, pageDescriptorToUrl, resolvePageDescriptor, tabKeyOf, tryPageDescriptorFromUrl, } from './menuNavigation';
 export type { PageDescriptorResolveOptions, PageDescriptorUrlParseOptions } from './menuNavigation';
 export { buildWorkbenchMegaMenuModel, createWorkbenchMenuNodes, filterWorkbenchMenuNodes, findWorkbenchMenuNodeById, findWorkbenchMenuPath, firstDeepRootIdOf, } from './menuTreeModel';

package/dist/types/platform-workbench/menuPointerAim.d.ts

@@ -0,0 +1,11 @@
+export interface MenuPointerPosition {
+    x: number;
+    y: number;
+}
+export interface MenuPanelEdge {
+    left: number;
+    top: number;
+    bottom: number;
+}
+/** Keeps an active root menu open while the pointer crosses towards its panel. */
+export declare function isPointerHeadingToMenuPanel(pointer: MenuPointerPosition, origin: MenuPointerPosition, panel: MenuPanelEdge): boolean;

package/dist/types/platform-workbench/workbenchLayout.d.ts

@@ -0,0 +1 @@
+export declare function compactMenuTopOf(topbarBottom: number, workbenchTop: number): number;

package/dist/types/platform-workbench/workspaceViewContract.d.ts

@@ -0,0 +1,20 @@
+import type { Component } from 'vue';
+import type { PageLayoutMode, RouteQueryValue } from '../web-contracts/index';
+export type WorkspaceViewInput = object;
+export type WorkspaceViewPresentation = 'drawer' | 'tab';
+export type WorkspaceDrawerProfile = 'detail' | 'wide-work';
+/** Stable, URL-restorable declaration shared by all workbench view hosts. */
+export interface WorkspaceViewDefinition<TInput extends WorkspaceViewInput> {
+    type: string;
+    route: string;
+    moduleAlias: string;
+    component: Component;
+    layout?: PageLayoutMode;
+    drawerProfile?: WorkspaceDrawerProfile;
+    routeTitle?: string;
+    titleOf(input: TInput): string;
+    parentRouteQueryOf?(input: TInput): Record<string, RouteQueryValue>;
+    parse(query: Record<string, RouteQueryValue>): TInput | undefined;
+    presentations: readonly WorkspaceViewPresentation[];
+}
+export declare function defineWorkspaceView<TInput extends WorkspaceViewInput>(definition: WorkspaceViewDefinition<TInput>): WorkspaceViewDefinition<TInput>;

package/dist/types/platform-workbench/workspaceViewHost.d.ts

@@ -0,0 +1,8 @@
+import type { WorkspaceViewPresentation } from './workspaceViewContract';
+export interface WorkspaceViewHost {
+    presentation: WorkspaceViewPresentation;
+    setTitle(title: string): void;
+    dismiss(): void;
+}
+export declare function provideWorkspaceViewHost(host: WorkspaceViewHost): void;
+export declare function useWorkspaceViewHost(): WorkspaceViewHost | undefined;

package/dist/types/platform-workbench/workspaceViews.d.ts

@@ -0,0 +1,21 @@
+import type { BusinessRoutePageDescriptor } from '../web-contracts/index';
+import type { WorkspaceViewDefinition, WorkspaceViewInput, WorkspaceViewPresentation } from './workspaceViewContract';
+export { defineWorkspaceView, type WorkspaceDrawerProfile, type WorkspaceViewDefinition, type WorkspaceViewInput, type WorkspaceViewPresentation, } from './workspaceViewContract';
+export interface ResolvedWorkspaceView {
+    view: WorkspaceViewDefinition<WorkspaceViewInput>;
+    input: WorkspaceViewInput;
+    presentation: WorkspaceViewPresentation;
+}
+export interface WorkspaceViewRegistry {
+    definitions: readonly WorkspaceViewDefinition<WorkspaceViewInput>[];
+    resolve(descriptor: BusinessRoutePageDescriptor): ResolvedWorkspaceView | undefined;
+}
+/**
+ * Replaces one application contribution set.  Owners keep their registrations
+ * isolated while every workbench host resolves one shared global view catalog.
+ */
+export declare function configureWorkspaceViewContributions(owner: string, definitions: readonly WorkspaceViewDefinition<WorkspaceViewInput>[]): void;
+export declare function createWorkspaceViewRegistry(definitions: readonly WorkspaceViewDefinition<WorkspaceViewInput>[]): WorkspaceViewRegistry;
+export declare function createWorkspaceViewDescriptor<TInput extends WorkspaceViewInput>(view: WorkspaceViewDefinition<TInput>, input: TInput, presentation?: WorkspaceViewPresentation, title?: string): BusinessRoutePageDescriptor;
+export declare function dismissWorkspaceViewDescriptor(descriptor: BusinessRoutePageDescriptor, view: WorkspaceViewDefinition<WorkspaceViewInput>): BusinessRoutePageDescriptor;
+export declare function resolveWorkspaceView(descriptor: BusinessRoutePageDescriptor): ResolvedWorkspaceView | undefined;

package/dist/types/views/employeeDetailWorkspaceView.d.ts

@@ -1,4 +1,4 @@
 export interface EmployeeDetailWorkspaceViewInput {
     recordId: string;
 }
-export declare const employeeDetailWorkspaceView: import("../platform-admin-runtime/workspaceViewContract").WorkspaceViewDefinition<EmployeeDetailWorkspaceViewInput>;
+export declare const employeeDetailWorkspaceView: import("../platform-workbench/workspaceViewContract.ts").WorkspaceViewDefinition<EmployeeDetailWorkspaceViewInput>;