@ximatai/muyun-web-app 0.26.12 → 0.26.13

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

@@ -1,4 +1,11 @@
+import { type Ref } from 'vue';
 import { type WebDataChange } from '../web-contracts/index';
+/**
+ * Produces a stable value snapshot for a record draft. Editor sessions use it
+ * as a local baseline: returning every edited field to its starting value is
+ * not an unsaved change.
+ */
+export declare function recordDraftFingerprint(value: unknown): string;
 export interface RecordEditorSessionOptions<TRecord, TMode extends string> {
     viewMode: TMode;
     createMode: TMode;
@@ -18,12 +25,12 @@ export interface RecordExternalChangeOptions {
     changeTypes?: string[];
 }
 export declare function createRecordEditorSessionState<TRecord, TMode extends string>(options: RecordEditorSessionOptions<TRecord, TMode>): {
-    selected: import("vue").Ref<TRecord | undefined, TRecord | undefined>;
-    draft: [TRecord] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<TRecord, import("vue").Ref<TRecord, TRecord>, TRecord> : import("vue").Ref<import("vue").UnwrapRef<TRecord>, TRecord | import("vue").UnwrapRef<TRecord>>;
-    mode: [TMode] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<TMode, import("vue").Ref<TMode, TMode>, TMode> : import("vue").Ref<import("vue").UnwrapRef<TMode>, TMode | import("vue").UnwrapRef<TMode>>;
+    selected: Ref<TRecord | undefined, TRecord | undefined>;
+    draft: Ref<TRecord, TRecord>;
+    mode: Ref<TMode, TMode>;
     readonly: import("vue").ComputedRef<boolean>;
     externallyChanged: import("vue").ComputedRef<boolean>;
-    externalChangedRecordId: import("vue").Ref<string | undefined, string | undefined>;
+    externalChangedRecordId: Ref<string | undefined, string | undefined>;
     select: (record: TRecord) => void;
     replaceSelected: (record: TRecord | undefined) => void;
     clearSelection: () => void;

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

@@ -3,6 +3,8 @@ import type { ModuleContext } from '../web-core/index';
 import type { PickerConstraint, RecordPickerRecord } from './recordPickerConstraints';
 import type { WebTreeNode } from '../web-contracts/index';
 import type { RecordPickerMode } from './recordPickerModel';
+import type { ScopedTreePickerProvider } from './scopedTreePickerModel';
+import type { ReferencePickerColumn, ReferencePickerProvider } from './referencePickerModel';
 export type RecordFormFieldDescriptor = (ViewFieldDefinition | ResolvedViewFieldDescriptor) & {
     /** Optional during the protocol migration; resolved descriptors take precedence over legacy uiType. */
     fieldControl?: ResolvedFieldControlDescriptor;
@@ -36,7 +38,9 @@ export type JsonValue = null | boolean | number | string | JsonValue[] | {
 };
 /** A business boolean does not inherit the lifecycle field's implicit enabled default. */
 export type RecordBooleanStatusValue = boolean | undefined;
-export type RecordFormFieldControlType = 'input' | 'numberInput' | 'dateInput' | 'dateTimeInput' | 'textarea' | 'colorPicker' | 'select' | 'enabledStatus' | 'booleanStatus' | 'switch' | 'recordPicker' | 'recordMultiPicker' | 'fileTransfer' | 'imageFileTransfer' | 'unsupported';
+export type RecordFormFieldControlType = 'input' | 'numberInput' | 'dateInput' | 'dateTimeInput' | 'textarea' | 'colorPicker' | 'select' | 'enabledStatus' | 'booleanStatus' | 'switch' | 'recordPicker' | 'recordMultiPicker' | 'dictionaryPicker' | 'dictionaryRadioGroup' | 'fileTransfer' | 'imageFileTransfer' | 'unsupported';
+/** The only source-field reference presentations implemented by the common picker. */
+export type RecordFormReferencePickerPresentation = 'dropdown' | 'dialog';
 export interface RecordFieldRenderer {
     rendererType: string;
     controlType: Exclude<RecordFormFieldControlType, 'unsupported'>;
@@ -60,10 +64,14 @@ export interface RecordFormFieldFallback {
 }
 export interface RecordFormFieldPickerConfig {
     context: ModuleContext<RecordPickerRecord>;
+    /** Source-authorized, paged reference delivery for the common picker. */
+    provider?: ReferencePickerProvider;
+    /** Candidate columns are presentation only; identity and authorization stay with the provider. */
+    columns?: readonly ReferencePickerColumn[];
     loadOptions?: (keyword: string) => Promise<RecordPickerRecord[]>;
     loadTree?: () => Promise<WebTreeNode<RecordPickerRecord>[]>;
     resolveOptions?: (values: string[]) => Promise<RecordPickerRecord[]>;
-    reloadKey?: number;
+    reloadKey?: string | number;
     mode?: RecordPickerMode;
     placeholder?: string;
     allowClear?: boolean;
@@ -71,6 +79,17 @@ export interface RecordFormFieldPickerConfig {
     titleOf?: (record: RecordPickerRecord) => string;
     descriptionOf?: (record: RecordPickerRecord) => string | undefined;
     filterOption?: (record: RecordPickerRecord, keyword: string) => boolean;
+    /**
+     * Optional expanded tree navigation for a reference that keeps its ordinary compact picker.
+     * The host owns whether its declared effective scope is ready; this generic form model does
+     * not infer tenant or organization rules from field names.
+     */
+    scopedTree?: {
+        title?: string;
+        disabled?: boolean;
+        unavailableMessage?: string;
+        provider: ScopedTreePickerProvider;
+    };
 }
 export interface RecordFormFieldState {
     fieldName: string;
@@ -93,6 +112,13 @@ export interface RecordFormFieldState {
     optionTitleField?: string;
     optionItems?: import('../web-contracts/index').OptionItemDescriptor[];
     referenceTitleField?: string;
+    /** The compiled reference contract remains available to read-only detail and list renderers. */
+    reference?: ResolvedReferenceFieldDescriptor;
+    /**
+     * Source-neutral presentation resolved from the field control. It is intentionally separate
+     * from the provider: the descriptor chooses presentation while the host owns transport.
+     */
+    referencePickerPresentation?: RecordFormReferencePickerPresentation;
     /** Title for the standard TreeAbility root sentinel when this field is a tree parent reference. */
     treeRootTitle?: string;
     fileReference?: ResolvedFileReferenceFieldDescriptor;

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

@@ -1,4 +1,4 @@
-import type { OptionItemDescriptor, QuerySchemaField, ResolvedViewDescriptor, ResolvedViewFieldDescriptor } from '../web-contracts/index';
+import type { OptionItemDescriptor, QuerySchemaField, ResolvedViewDescriptor, ResolvedViewFieldDescriptor, ResolvedReferenceFieldDescriptor } from '../web-contracts/index';
 import type { Component } from 'vue';
 export type QueryListRecord = Record<string, unknown> & {
     id?: string;
@@ -18,6 +18,8 @@ export interface RecordQueryListColumn {
     width?: string;
     align?: 'left' | 'center' | 'right';
     titleField?: string;
+    /** Compiled reference facts for pure read-side title/summary rendering. */
+    reference?: ResolvedReferenceFieldDescriptor;
     /** Only descriptor-declared option fields load a runtime option catalog. */
     optionBinding?: boolean;
     /** Dynamic child entity whose declared option binding owns this field. */

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

@@ -0,0 +1,103 @@
+/**
+ * Source-neutral candidate contract for records selected through an authorized
+ * reference source. IDs are the only persisted value; projections are display
+ * data and affectPatch remains an explicit, host-owned extension.
+ */
+export type ReferencePickerId = string;
+/** Whether the compact entry still represents the persisted reference selection. */
+export interface ReferencePickerValidity {
+    valid: boolean;
+    status: 'ready' | 'editing' | 'resolving' | 'unmatched' | 'error';
+    message?: string;
+}
+export interface ReferencePickerSourceIdentity {
+    targetModuleAlias: string;
+    source: {
+        kind: 'sourceField' | 'businessPurpose' | 'targetReference';
+        id: string;
+    };
+    /** A source-controlled authorization/range revision when it is available. */
+    authorizationScope?: string;
+}
+export interface ReferencePickerCandidate {
+    id: ReferencePickerId;
+    title: string;
+    subtitle?: string;
+    disabled?: boolean;
+    unavailable?: boolean;
+    projections?: Readonly<Record<string, unknown>>;
+    affectPatch?: Readonly<Record<string, unknown>>;
+}
+export interface ReferencePickerAxisSelection {
+    axisId: string;
+    itemId: string;
+}
+export interface ReferencePickerBrowseScope {
+    selections: readonly ReferencePickerAxisSelection[];
+}
+export interface ReferencePickerNavigationItem {
+    id: string;
+    title: string;
+    disabled?: boolean;
+}
+/** A declared browse axis. The picker clears dependent selections on an upstream change. */
+export interface ReferencePickerNavigationAxis {
+    id: string;
+    title: string;
+    dependsOn?: readonly string[];
+    items: readonly ReferencePickerNavigationItem[];
+}
+export interface ReferencePickerPageRequest {
+    keyword: string;
+    pageNum: number;
+    pageSize: number;
+    scope: ReferencePickerBrowseScope;
+}
+export interface ReferencePickerPage<TCandidate extends ReferencePickerCandidate = ReferencePickerCandidate> {
+    records: TCandidate[];
+    total: number;
+    navigation?: readonly ReferencePickerNavigationAxis[];
+}
+/** A complete, source-authorized browse tree. It is never synthesized from paged query results. */
+export interface ReferencePickerTreeNode<TCandidate extends ReferencePickerCandidate = ReferencePickerCandidate> {
+    record: TCandidate;
+    children?: ReferencePickerTreeNode<TCandidate>[];
+}
+export interface ReferencePickerProvider<TCandidate extends ReferencePickerCandidate = ReferencePickerCandidate> {
+    identity: ReferencePickerSourceIdentity;
+    searchPage(request: ReferencePickerPageRequest): Promise<ReferencePickerPage<TCandidate>>;
+    /**
+     * Reads the complete tree under the source's authorization scope. Dialog browse uses this only
+     * without a keyword; keyword search remains server-paged through searchPage.
+     */
+    loadTree?: (request: {
+        scope: ReferencePickerBrowseScope;
+    }) => Promise<ReferencePickerTreeNode<TCandidate>[]>;
+    /** Resolves persisted IDs under the source's authorized historical-display scope. */
+    resolve(ids: ReferencePickerId[]): Promise<TCandidate[]>;
+}
+export interface ReferencePickerColumn {
+    key: string;
+    title: string;
+    width?: number;
+}
+/** Compiled page/query configuration for a standard reference interaction. */
+export interface ReferencePickerConfig {
+    provider: ReferencePickerProvider;
+    mode?: 'dialog' | 'dropdown';
+    columns?: readonly ReferencePickerColumn[];
+    title?: string;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    maxSelection?: number;
+    reloadKey?: string | number;
+}
+export interface ReferencePickerSelectionSummary {
+    id: ReferencePickerId;
+    title: string;
+    subtitle?: string;
+    unavailable?: boolean;
+}
+export declare function normalizeReferencePickerIds(value: ReferencePickerId | readonly ReferencePickerId[] | undefined, multiple: boolean): ReferencePickerId[];
+export declare function referencePickerValue(ids: readonly ReferencePickerId[], multiple: boolean): ReferencePickerId | ReferencePickerId[] | undefined;
+export declare function referencePickerSummary(candidate: ReferencePickerCandidate): ReferencePickerSelectionSummary;

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

@@ -0,0 +1,24 @@
+import { AppError } from '../web-core/index';
+export type ReferencePickerReadErrorKind = 'accessDenied' | 'missingDependencies' | 'unsupportedConfiguration' | 'temporaryFailure';
+/**
+ * The picker only classifies facts carried by AppError or facts its source can
+ * prove locally. It deliberately never derives a category from an error message.
+ */
+export declare class ReferencePickerReadError extends AppError {
+    readonly kind: ReferencePickerReadErrorKind;
+    readonly retryable: boolean;
+    readonly missingDependencyFields: readonly string[];
+    readonly original: AppError;
+    constructor(kind: ReferencePickerReadErrorKind, message: string, options: {
+        retryable: boolean;
+        missingDependencyFields?: readonly string[];
+        original?: AppError;
+    });
+}
+/**
+ * Returns undefined for 401 so the request client's authentication lifecycle
+ * remains the sole owner of login recovery and redirect behavior.
+ */
+export declare function referencePickerReadErrorOf(cause: unknown, fallbackMessage: string): ReferencePickerReadError | undefined;
+export declare function missingReferencePickerDependencies(sourceFields: readonly string[]): ReferencePickerReadError;
+export declare function unsupportedReferencePickerConfiguration(message: string): ReferencePickerReadError;

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

@@ -0,0 +1,48 @@
+import { type InjectionKey } from 'vue';
+import { type HttpClient, type ModuleContext } from '../web-core/index';
+import type { QueryListRecord } from './recordQueryListColumnModel';
+import { type RecordFormFieldDescriptor } from './recordFormFieldModel';
+export type ActiveReferenceRecord = {
+    targetModuleAlias: string;
+    recordId: string;
+    record?: QueryListRecord;
+    loading: boolean;
+    /** A record-only editor owns an in-flight target mutation. */
+    busy?: boolean;
+    failed: boolean;
+    failureKind?: 'notFound' | 'temporary';
+};
+export type ReferenceRecordDetailMutation = {
+    targetModuleAlias: string;
+    recordId: string;
+    type: 'saved' | 'deleted' | 'unavailable';
+    record?: QueryListRecord;
+};
+export interface ReferenceRecordDetailBrowser {
+    revision: {
+        value: number;
+    };
+    active: {
+        value: ActiveReferenceRecord | undefined;
+    };
+    activeContext: {
+        value: ModuleContext<QueryListRecord> | undefined;
+    };
+    fields: {
+        value: Map<string, RecordFormFieldDescriptor>;
+    };
+    title: {
+        value: string;
+    };
+    canBrowse(targetModuleAlias: string, recordId: string): boolean;
+    open(targetModuleAlias: string, recordId: string): void;
+    setBusy(targetModuleAlias: string, recordId: string, busy: boolean): void;
+    reportMutation(mutation: ReferenceRecordDetailMutation): void;
+    close(): void;
+    /** Component teardown bypasses the user-facing busy close gate. */
+    dispose(): void;
+}
+export declare const referenceRecordDetailBrowserKey: InjectionKey<ReferenceRecordDetailBrowser | undefined>;
+export declare function createReferenceRecordDetailBrowser(http: HttpClient): ReferenceRecordDetailBrowser;
+export declare function provideReferenceRecordDetailBrowser(browser: ReferenceRecordDetailBrowser): void;
+export declare function useReferenceRecordDetailBrowser(): ReferenceRecordDetailBrowser | undefined;

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

@@ -0,0 +1,46 @@
+/**
+ * An authorized, source-owned record projection for a lazily loaded tree selector.
+ * The component deliberately does not infer a parent, tenant, or module from this shape.
+ */
+export interface ScopedTreePickerCandidate {
+    id: string;
+    title: string;
+    /** A provider may return a path, code, or scope summary to disambiguate equal titles. */
+    subtitle?: string;
+    /** False keeps the item expandable and asks the provider for children when it is expanded. */
+    isLeaf?: boolean;
+    disabled?: boolean;
+    unavailable?: boolean;
+}
+export interface ScopedTreePickerRootRequest {
+    /** Provider-defined search text. An empty string requests the current scope roots. */
+    keyword: string;
+    signal: AbortSignal;
+}
+export interface ScopedTreePickerChildrenRequest extends ScopedTreePickerRootRequest {
+    parent: ScopedTreePickerCandidate;
+    /** Opaque continuation supplied by an earlier child response when the provider supports paging. */
+    cursor?: string;
+}
+export interface ScopedTreePickerPage {
+    records: ScopedTreePickerCandidate[];
+    hasMore?: boolean;
+    nextCursor?: string;
+}
+/**
+ * A source-owned delivery boundary. The caller may use a static reference resolver, a dedicated
+ * candidate endpoint, or another authorized source; this component has no module-path knowledge.
+ */
+export interface ScopedTreePickerProvider {
+    loadRoot: (request: ScopedTreePickerRootRequest) => Promise<ScopedTreePickerPage>;
+    loadChildren: (request: ScopedTreePickerChildrenRequest) => Promise<ScopedTreePickerPage>;
+    /** Resolves persisted IDs through the same authorization and effective-scope rule. */
+    resolve: (ids: string[]) => Promise<ScopedTreePickerCandidate[]>;
+}
+export interface ScopedTreePickerConfig {
+    title?: string;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    provider: ScopedTreePickerProvider;
+}
+export declare function scopedTreePickerValue(value: string | undefined): string | undefined;

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

@@ -0,0 +1,26 @@
+import type { ResolvedReferenceFieldDescriptor } from '../web-contracts/index';
+import type { ReferenceResolveClient } from '../web-core/index';
+import type { ReferencePickerProvider } from './referencePickerModel';
+export interface SourceReferencePickerProviderOptions {
+    sourceModuleAlias: string;
+    fieldName: string;
+    reference: ResolvedReferenceFieldDescriptor;
+    /** Obtained at request time so a retained provider does not capture a replaced module context. */
+    resolver: () => ReferenceResolveClient;
+    /** Read at request time so a stable provider always uses the current draft. */
+    formValues: () => Record<string, unknown>;
+    source: () => {
+        recordId: string;
+    } | undefined;
+}
+/**
+ * Adapts the source-field resolver to the neutral picker contract.  It deliberately carries no
+ * target-module query fallback: the declaring source field remains the authority for candidate
+ * eligibility, projections and patches.
+ */
+export declare function createSourceReferencePickerProvider({ sourceModuleAlias, fieldName, reference, resolver, formValues, source, }: SourceReferencePickerProviderOptions): ReferencePickerProvider;
+/**
+ * Only source identity, persisted record scope and declared candidate dependencies invalidate a
+ * picker.  This avoids resetting pagination or re-querying for unrelated form edits.
+ */
+export declare function sourceReferencePickerReloadKey(sourceModuleAlias: string, fieldName: string, reference: ResolvedReferenceFieldDescriptor, record: Record<string, unknown> | undefined): string;

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

@@ -1,3 +1,4 @@
+import { type Ref } from 'vue';
 import { type ModuleContext } from '../web-core/index';
 import type { UiConfirmOptions } from '../vue-ui-antdv/index';
 import { type PlatformActionResultReactionHandler } from './platformActionResultFeedback';
@@ -41,12 +42,12 @@ export interface StaticCrudManagementOptions<TRecord extends StaticCrudRecord> {
     actionResultReactionHandlers?: Record<string, PlatformActionResultReactionHandler | undefined>;
 }
 export declare function useFlatCrudManagementState<TRecord extends StaticCrudRecord>(options: StaticCrudManagementOptions<TRecord>): {
-    selected: import("vue").Ref<TRecord | undefined, TRecord | undefined>;
-    draft: [TRecord] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<TRecord, import("vue").Ref<TRecord, TRecord>, TRecord> : import("vue").Ref<import("vue").UnwrapRef<TRecord>, TRecord | import("vue").UnwrapRef<TRecord>>;
-    mode: import("vue").Ref<StaticCrudCardMode, StaticCrudCardMode>;
-    reloadKey: import("vue").Ref<number, number>;
-    saving: import("vue").Ref<boolean, boolean>;
-    actionError: import("vue").Ref<string | undefined, string | undefined>;
+    selected: Ref<TRecord | undefined, TRecord | undefined>;
+    draft: Ref<TRecord, TRecord>;
+    mode: Ref<StaticCrudCardMode, StaticCrudCardMode>;
+    reloadKey: Ref<number, number>;
+    saving: Ref<boolean, boolean>;
+    actionError: Ref<string | undefined, string | undefined>;
     cardTitle: import("vue").ComputedRef<string>;
     readonly: import("vue").ComputedRef<boolean>;
     canCreate: import("vue").ComputedRef<boolean>;

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

@@ -0,0 +1,45 @@
+import type { IdentityPickerCandidate, IdentityPickerResolver } from './identityPickerModel';
+/** A user selection always persists an IAM user account ID, never an employee ID. */
+export type UserAccountId = string;
+/** An authorized user-account projection returned by the selection provider. */
+export interface UserPickerCandidate extends IdentityPickerCandidate<UserAccountId> {
+    /** Account snapshot or current account, as defined by the source. */
+    account?: string;
+    employeeName?: string;
+    organizationId?: string;
+    organizationName?: string;
+    departmentId?: string;
+    departmentName?: string;
+}
+export interface UserPickerNavigationScope {
+    tenantId?: string;
+    organizationId?: string;
+    departmentId?: string;
+}
+/** A source-provided progressive browse axis. IDs remain source-owned and are never inferred by the picker. */
+export interface UserPickerNavigationItem {
+    id: string;
+    title: string;
+    tenantId?: string;
+    /** Parent organization for a department item, when the source has that hierarchy. */
+    organizationId?: string;
+}
+export interface UserPickerNavigation {
+    showTenantNavigation: boolean;
+    tenants: UserPickerNavigationItem[];
+    organizations: UserPickerNavigationItem[];
+    departments: UserPickerNavigationItem[];
+}
+export interface UserPickerPage {
+    records: UserPickerCandidate[];
+    total: number;
+    navigation?: UserPickerNavigation;
+}
+export interface UserPickerPageRequest {
+    keyword: string;
+    pageNum: number;
+    pageSize: number;
+    scope?: UserPickerNavigationScope;
+}
+export type UserPickerPageSearch = (request: UserPickerPageRequest) => Promise<UserPickerPage>;
+export type UserPickerResolver = IdentityPickerResolver<UserAccountId>;

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

@@ -0,0 +1,17 @@
+import type { ReferencePickerCandidate, ReferencePickerColumn, ReferencePickerProvider, ReferencePickerSourceIdentity } from './referencePickerModel';
+import type { UserPickerCandidate, UserPickerPageSearch, UserPickerResolver } from './userPickerModel';
+/** Identity-specific presentation stays here; the common picker only consumes projections. */
+export declare const userReferencePickerColumns: readonly ReferencePickerColumn[];
+export interface UserReferencePickerConfig {
+    sourceIdentity: ReferencePickerSourceIdentity;
+    searchPage: UserPickerPageSearch;
+    resolveUsers: UserPickerResolver;
+}
+/**
+ * Maps the authorized IAM delivery into the source-neutral picker contract.
+ * It does not infer any tenant/organization/department relationship: old
+ * source-owned IDs are simply returned to the same source as typed axes.
+ */
+export declare function createUserReferencePickerProvider(config: UserReferencePickerConfig): ReferencePickerProvider;
+export declare function toReferenceCandidate(candidate: UserPickerCandidate): ReferencePickerCandidate;
+export declare function toUserPickerCandidate(candidate: ReferencePickerCandidate): UserPickerCandidate;

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

@@ -2,4 +2,4 @@
  * Lets a workspace panel declare unsaved local state without exposing or
  * duplicating its draft in the workbench shell.
  */
-export declare function useWorkspaceViewUnsavedState(source: string, isDirty: () => boolean): void;
+export declare function useWorkspaceViewUnsavedState(source: string, isDirty: () => boolean, isBusy?: () => boolean): void;

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

@@ -6,7 +6,7 @@ export interface WorkspaceViewHost {
     /** Replaces URL-restorable state without creating another workbench tab. */
     replaceQuery(query: Record<string, RouteQueryValue | undefined>): void;
     /** Registers a local draft signal used only when the owning workbench tab closes. */
-    registerUnsavedState(source: string, isDirty: () => boolean): () => void;
+    registerUnsavedState(source: string, isDirty: () => boolean, isBusy?: () => boolean): () => void;
     dismiss(): void;
     /** Closes the current independent workbench view. */
     close(): void;

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

@@ -1,3 +1,5 @@
-export declare function registerWorkspaceViewUnsavedState(pageKey: string, source: string, isDirty: () => boolean): () => void;
+export declare function registerWorkspaceViewUnsavedState(pageKey: string, source: string, isDirty: () => boolean, isBusy?: () => boolean): () => void;
 export declare function workspaceViewUnsavedStateSources(pageKey: string): string[];
+/** Sources with an in-flight mutation cannot be destroyed until their work completes. */
+export declare function workspaceViewBusyStateSources(pageKey: string): string[];
 export declare function clearWorkspaceViewUnsavedState(pageKey: string): void;

package/dist/types/views/BusinessActivityLogView.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/views/BusinessLogListDrawer.vue.d.ts

@@ -0,0 +1,9 @@
+import { type BusinessLogSurface } from './businessLogClient';
+type __VLS_Props = {
+    surface: BusinessLogSurface;
+    moduleAlias: string;
+    title: string;
+};
+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/views/LoginAuditLogView.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/views/RequestErrorLogView.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/views/RuntimeLogView.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,85 @@
+import type { HttpClient } from '../web-core/index';
+import type { WebQueryRequest } from '../web-contracts/index';
+export type BusinessLogSurface = 'activity' | 'request-error' | 'login';
+export interface BusinessLogOperatorIdentity {
+    employeeName?: string;
+    username?: string;
+    organizationId?: string;
+    organizationName?: string;
+    departmentId?: string;
+    departmentName?: string;
+}
+export interface BusinessLogEventView {
+    eventId: string;
+    eventType: string;
+    occurredAt?: string;
+    capturedAt?: string;
+    traceId?: string;
+    tenantId?: string;
+    operatorId?: string;
+    operatorOrganizationId?: string;
+    operatorIdentity?: BusinessLogOperatorIdentity;
+    moduleAlias?: string;
+    actionCode?: string;
+    outcome?: string;
+    /** The authentication account, independent from the event's authenticated operator identity. */
+    loginAccount?: string;
+    summary?: string;
+    details?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface BusinessLogStatisticItem {
+    key: string;
+    title: string;
+    count: number;
+    [key: string]: unknown;
+}
+export interface BusinessLogStatistics {
+    items: BusinessLogStatisticItem[];
+    complete?: boolean;
+}
+export interface BusinessLogOperatorCandidate {
+    id: string;
+    title: string;
+    account?: string;
+    employeeName?: string;
+    organizationId?: string;
+    organizationName?: string;
+    departmentId?: string;
+    departmentName?: string;
+}
+export interface BusinessLogOperatorNavigationItem {
+    id: string;
+    title: string;
+    tenantId?: string;
+    organizationId?: string;
+}
+export interface BusinessLogOperatorNavigation {
+    showTenantNavigation: boolean;
+    tenants: BusinessLogOperatorNavigationItem[];
+    organizations: BusinessLogOperatorNavigationItem[];
+    departments: BusinessLogOperatorNavigationItem[];
+}
+export interface BusinessLogOperatorCandidateQuery {
+    keyword?: string;
+    pageNum?: number;
+    pageSize?: number;
+    selectedIds?: string[];
+    tenantId?: string;
+    organizationId?: string;
+    departmentId?: string;
+}
+export interface BusinessLogOperatorCandidatePage {
+    records: BusinessLogOperatorCandidate[];
+    selectedRecords: BusinessLogOperatorCandidate[];
+    total: number;
+    navigation?: BusinessLogOperatorNavigation;
+}
+export interface BusinessLogClient {
+    detail(eventId: string): Promise<BusinessLogEventView>;
+    operatorCandidates(input: BusinessLogOperatorCandidateQuery): Promise<BusinessLogOperatorCandidatePage>;
+    actionStatistics?(request: WebQueryRequest): Promise<BusinessLogStatistics>;
+    pageAccessStatistics?(request: WebQueryRequest): Promise<BusinessLogStatistics>;
+    diagnostic?(eventId: string): Promise<Record<string, unknown>>;
+}
+export declare function createBusinessLogClient(http: HttpClient, surface: BusinessLogSurface): BusinessLogClient;

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

@@ -0,0 +1,18 @@
+/** Facts loaded from the dictionary candidate endpoint for radio presentation preflight. */
+export interface DictionaryRadioCandidateFacts {
+    enabledCandidateCount: number;
+    hasHierarchy: boolean;
+}
+export interface DictionaryRadioEligibilityInput {
+    optionSourceType?: string;
+    optionSelectionMode?: 'SINGLE' | 'MULTIPLE';
+    facts?: DictionaryRadioCandidateFacts;
+    loadError?: string;
+    maxOptions: number;
+}
+/**
+ * Radio is a presentation choice over a single, flat and small dictionary. Keep this decision
+ * independent from the composer view so selected-field hints, preview guards and publish guards
+ * all enforce the same rule.
+ */
+export declare function dictionaryRadioEligibilityIssue(input: DictionaryRadioEligibilityInput): string | undefined;

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

@@ -0,0 +1,10 @@
+/**
+ * Guards asynchronous candidate reads while a kept-alive composer reloads its metadata directory.
+ * A field name is stable across a dictionary rebind, so the directory generation—not the name—is
+ * the authority for whether an in-flight response may still update radio eligibility.
+ */
+export declare function createDictionaryRadioFactRequestEpoch(): {
+    invalidate(): void;
+    capture(): number;
+    isCurrent(capturedGeneration: number): boolean;
+};

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

@@ -9,7 +9,16 @@ export interface MetadataFieldChangeSetDraft {
     /** JSON-facing command contract; projection mappings remain an ordered string array. */
     property?: MetadataFieldPropertyChangeSetPayload;
 }
-export type MetadataFieldPropertyChangeSetPayload = MetadataFieldPropertyDraft;
+/**
+ * The editor uses stable upper-case cardinality labels, while the public HTTP contract for
+ * CodeTitleEnum writes their lower-case codes. Keep that translation at the change-set boundary
+ * rather than leaking transport values into the editor and form renderer.
+ */
+export type MetadataFieldPropertyChangeSetPayload = Omit<MetadataFieldPropertyDraft, 'dictionaryConfig'> & {
+    dictionaryConfig?: Omit<NonNullable<MetadataFieldPropertyDraft['dictionaryConfig']>, 'selectionMode'> & {
+        selectionMode?: 'single' | 'multiple';
+    };
+};
 export declare function toFieldPropertyChangeSetPayload(property: MetadataFieldPropertyDraft): MetadataFieldPropertyChangeSetPayload;
 export interface MetadataRelationChangeSetProposal {
     expectedMetadataVersion: number;