@ximatai/muyun-web-app 0.26.14 → 0.26.16

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

@@ -16,8 +16,9 @@ export type { ResolvedWorkspaceView, WorkspaceViewRegistry } from './workspaceVi
 export type { WorkspaceViewDefinition, WorkspaceViewInput, WorkspaceViewPresentation, WorkspaceDrawerProfile, } from './workspaceViewContract';
 export type { WorkspaceViewHost } from './workspaceViewHost';
 export { createMenuTab, canonicalDynamicModulePath, dynamicModuleAliasFromPath, findFirstNavigationMenu, getMenuNavigationTarget, isTabMenuTarget, isWindowMenuTarget, pageDescriptorFromUrl, pageDescriptorToUrl, pageInstanceKeyOf, resolvePageDescriptor, tabIdentityKeyOf, tabKeyOf, tryPageDescriptorFromUrl, withPageInstanceKey, } from './menuNavigation';
-export type { PageDescriptorResolveOptions, PageDescriptorUrlParseOptions } from './menuNavigation';
+export type { ModuleNavigationTarget, PageDescriptorResolveOptions, PageDescriptorUrlParseOptions, } from './menuNavigation';
 export { buildWorkbenchMegaMenuModel, createWorkbenchMenuNodes, filterWorkbenchMenuNodes, findWorkbenchMenuNodeById, findWorkbenchMenuPath, firstDeepRootIdOf, } from './menuTreeModel';
 export type { WorkbenchMegaMenuModel, WorkbenchMenuNode } from './menuTreeModel';
 export { presentWorkbenchRealtimeStatus } from './realtimeStatus';
 export type { WorkbenchRealtimeStatus, WorkbenchRealtimeStatusPresentation } from './realtimeStatus';
+export { default as LanguageSelector } from './LanguageSelector.vue';

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

@@ -1,9 +1,13 @@
-import type { MenuNavigationTarget, MenuRecord, MenuTab, MenuTreeNode, PageDescriptor, PageLayoutMode } from '../web-contracts/index';
+import type { MenuNavigationTarget, ModuleMenuTarget, MenuRecord, MenuTab, MenuTreeNode, PageDescriptor, PageLayoutMode } from '../web-contracts/index';
+/** Direct module actions resolve through the same route catalog without a persisted menu. */
+export type ModuleNavigationTarget = Omit<ModuleMenuTarget, 'menuId'> & {
+    menuId?: string;
+};
 export interface PageDescriptorResolveOptions {
     title?: string;
     platformRoutePrefixes?: string[];
     businessRoutePrefixes?: string[];
-    /** Optional legacy mapping for framework-owned static business pages. */
+    /** Registered module routes for framework-owned static business pages. */
     businessModuleRoutes?: Record<string, string>;
     /** Semantic overrides in the canonical dynamic module route catalog. */
     dynamicModuleRoutes?: Record<string, string>;
@@ -22,7 +26,7 @@ export interface PageDescriptorUrlParseOptions {
 export declare function getMenuNavigationTarget(menu: MenuRecord): MenuNavigationTarget | undefined;
 export declare function isTabMenuTarget(target: MenuNavigationTarget): boolean;
 export declare function isWindowMenuTarget(target: MenuNavigationTarget): boolean;
-export declare function resolvePageDescriptor(target: MenuNavigationTarget, options?: PageDescriptorResolveOptions): PageDescriptor;
+export declare function resolvePageDescriptor(target: MenuNavigationTarget | ModuleNavigationTarget, options?: PageDescriptorResolveOptions): PageDescriptor;
 export declare function createMenuTab(menu: MenuRecord, target: MenuNavigationTarget, options?: PageDescriptorResolveOptions): MenuTab;
 /** Adds a page-instance key once and preserves it on address replacement or restoration. */
 export declare function withPageInstanceKey(descriptor: PageDescriptor, instanceKey?: string): PageDescriptor;

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

@@ -1,4 +1,5 @@
 import type { MenuNavigationTarget, MenuRecord, MenuTreeNode } from '../web-contracts/index';
+import { type LanguageContext } from '../web-core/index';
 export interface WorkbenchMenuNode {
     record: MenuRecord;
     children: WorkbenchMenuNode[];
@@ -12,7 +13,7 @@ export interface WorkbenchMegaMenuModel {
     columns: WorkbenchMenuNode[][];
     activeDeepRoot?: WorkbenchMenuNode;
 }
-export declare function createWorkbenchMenuNodes(nodes: MenuTreeNode[]): WorkbenchMenuNode[];
+export declare function createWorkbenchMenuNodes(nodes: MenuTreeNode[], language?: LanguageContext): WorkbenchMenuNode[];
 export declare function filterWorkbenchMenuNodes(nodes: WorkbenchMenuNode[], keyword: string): WorkbenchMenuNode[];
 export declare function findWorkbenchMenuPath(nodes: WorkbenchMenuNode[], menuId: string, path?: WorkbenchMenuNode[]): WorkbenchMenuNode[];
 export declare function findWorkbenchMenuNodeById(nodes: WorkbenchMenuNode[], menuId: string): WorkbenchMenuNode | undefined;

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

@@ -1,7 +1,8 @@
+import { type LanguageContext } from '../web-core/index';
 export type WorkbenchRealtimeStatus = 'unavailable' | 'connecting' | 'connected' | 'disconnected';
 export interface WorkbenchRealtimeStatusPresentation {
     label: string;
     title: string;
     tone: Exclude<WorkbenchRealtimeStatus, 'unavailable'>;
 }
-export declare function presentWorkbenchRealtimeStatus(status: WorkbenchRealtimeStatus): WorkbenchRealtimeStatusPresentation | undefined;
+export declare function presentWorkbenchRealtimeStatus(status: WorkbenchRealtimeStatus, language?: LanguageContext): WorkbenchRealtimeStatusPresentation | undefined;

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

@@ -0,0 +1,452 @@
+import { type ControlText } from './assistantControlText';
+import { type LanguageContext } from '../web-core/index';
+import type { AssistantConversationClient } from '../web-core/index';
+import type { ConfigurationCollaboration } from './configurationCollaboration';
+import type { ConstructionPlanSession } from './constructionPlanSession';
+import type { AssistantSelectionInteraction, AssistantSelectionOption, AssistantResultPresentation } from '../web-contracts/index';
+import { type AssistantSurfaceRegistry, type AssistantOperationConfirmation, type AssistantConfirmationState, type AssistantInvocationToken } from '../web-core/index';
+interface ConversationItem {
+    id: number;
+    role: 'user' | 'assistant' | 'status';
+    text: string;
+    controlText?: ControlText;
+    archivedControlText?: import('../web-core/index').AssistantControlText;
+    selection?: ConversationSelection;
+    confirmation?: AssistantOperationConfirmation;
+    confirmationState?: AssistantConfirmationState;
+    confirmationScope?: string;
+    confirmationUserGoal?: string;
+    diagnostic?: string;
+    details?: AssistantResultPresentation['details'];
+}
+interface ConversationSelection {
+    value: AssistantSelectionInteraction;
+    request: string;
+    token?: AssistantInvocationToken;
+    state: 'open' | 'submitting' | 'answered' | 'superseded';
+    selectedOptionId?: string;
+    retryable?: boolean;
+}
+export declare function useAssistantConversation(props: {
+    open: boolean;
+    language?: LanguageContext;
+    registry: AssistantSurfaceRegistry;
+    conversationClient?: AssistantConversationClient;
+    constructionPlan?: ConstructionPlanSession;
+    configurationCollaboration?: ConfigurationCollaboration;
+}): {
+    archive: {
+        enabled: boolean;
+        id: import("vue").Ref<string | undefined, string | undefined>;
+        title: import("vue").ComputedRef<string>;
+        status: import("vue").Ref<"idle" | "saving" | "saved" | "unsaved" | "restored", "idle" | "saving" | "saved" | "unsaved" | "restored">;
+        saveError: import("vue").ComputedRef<string>;
+        readError: import("vue").ComputedRef<{
+            message: string;
+            kind: "list";
+            more: boolean;
+        } | {
+            message: string;
+            kind: "open";
+            id: string;
+        } | undefined>;
+        retryRead(): Promise<void> | undefined;
+        loading: import("vue").ComputedRef<boolean>;
+        ready: import("vue").Ref<boolean, boolean>;
+        historyOpen: import("vue").Ref<boolean, boolean>;
+        entries: import("vue").Ref<{
+            id: string;
+            title: string;
+            updatedAt: string;
+        }[], import("../web-core/index").AssistantConversationSummary[] | {
+            id: string;
+            title: string;
+            updatedAt: string;
+        }[]>;
+        hasMore: import("vue").Ref<boolean, boolean>;
+        changeScope: (value: string | undefined) => void;
+        save: () => Promise<boolean>;
+        list: (more?: boolean) => Promise<void>;
+        open: (conversationId: string) => Promise<void>;
+        startNew: () => Promise<void>;
+        saveCopy: () => Promise<void>;
+        discardAndStartNew: () => void;
+    };
+    restored: import("vue").Ref<boolean, boolean>;
+    linkedPlanId: import("vue").Ref<string | undefined, string | undefined>;
+    draft: import("vue").Ref<string, string>;
+    restoredThroughId: import("vue").Ref<number, number>;
+    restoredRequest: import("vue").Ref<string, string>;
+    recoveryRequest: import("vue").ComputedRef<string>;
+    recoveryReadOnly: import("vue").ComputedRef<boolean>;
+    adjustRequest: () => void;
+    continueConversation: () => void;
+    items: import("vue").Ref<{
+        id: number;
+        role: "user" | "assistant" | "status";
+        text: string;
+        controlText?: {
+            code: string;
+            original: string;
+            args?: Record<string, string | number | boolean | ControlText | null> | undefined;
+        } | {
+            parts: (string | {
+                code: string;
+                original: string;
+                args?: Record<string, string | number | boolean | ControlText | null> | undefined;
+            } | /*elided*/ any)[];
+        } | undefined;
+        archivedControlText?: {
+            source: {
+                sourceKind: "CODE" | "CONFIG";
+                sourceId: string;
+                sourceVersion: string;
+                originalText: string;
+            };
+            args?: Record<string, string | number | boolean | null | import("../web-core/index").AssistantControlText> | undefined;
+        } | {
+            parts: (string | {
+                source: {
+                    sourceKind: "CODE" | "CONFIG";
+                    sourceId: string;
+                    sourceVersion: string;
+                    originalText: string;
+                };
+                args?: Record<string, string | number | boolean | null | import("../web-core/index").AssistantControlText> | undefined;
+            } | /*elided*/ any)[];
+        } | undefined;
+        selection?: {
+            value: {
+                interactionId: string;
+                prompt: string;
+                inputPolicy: "free_text_allowed" | "selection_required";
+                presentation: "options" | "confirmation";
+                options: {
+                    id: string;
+                    label: string;
+                }[];
+            };
+            request: string;
+            token?: {
+                identityScopeKey?: string | undefined;
+                executionScopePending?: boolean | undefined;
+                executionScopeKey?: string | undefined;
+                pageInstanceKey: string;
+                surfaceGeneration: number;
+                readStateRevision?: number | undefined;
+                contextRevision: string;
+                interactionRevision?: string | undefined;
+                fallback: boolean;
+            } | undefined;
+            state: "open" | "submitting" | "answered" | "superseded";
+            selectedOptionId?: string | undefined;
+            retryable?: boolean | undefined;
+        } | undefined;
+        confirmation?: {
+            readonly modelSummary: string;
+            readonly receiptReference?: {
+                kind: "record-save";
+                moduleAlias: string;
+                requestId: string;
+                tenantId?: string | undefined;
+                menuId?: string | undefined;
+                pageContext?: Record<string, string> | undefined;
+                pageSelection?: {
+                    kind: string;
+                    key: string;
+                } | undefined;
+            } | {
+                kind: "child-metadata";
+                moduleAlias: string;
+                relationId: string;
+                requestId: string;
+            } | {
+                kind: "page-publication";
+                variantId: string;
+                revisionId: string;
+                contentDigest: string;
+            } | undefined;
+            readonly continuationReadOnly?: boolean | undefined;
+            readonly continuationIsCurrent?: (() => boolean) | undefined;
+            takeContinuation: () => string | undefined;
+            readonly confirmLabel: string;
+            readonly presentation: {
+                title: string;
+                lines: string[];
+                details?: {
+                    title: string;
+                    lines: string[];
+                } | undefined;
+            };
+            readonly state: AssistantConfirmationState;
+            readonly result: {
+                title: string;
+                lines: string[];
+                details?: {
+                    title: string;
+                    lines: string[];
+                } | undefined;
+            } | undefined;
+            confirm: () => Promise<void>;
+            check: () => Promise<void>;
+            cancel: () => void;
+        } | undefined;
+        confirmationState?: AssistantConfirmationState | undefined;
+        confirmationScope?: string | undefined;
+        confirmationUserGoal?: string | undefined;
+        diagnostic?: string | undefined;
+        details?: {
+            title: string;
+            lines: string[];
+        } | undefined;
+    }[], ConversationItem[] | {
+        id: number;
+        role: "user" | "assistant" | "status";
+        text: string;
+        controlText?: {
+            code: string;
+            original: string;
+            args?: Record<string, string | number | boolean | ControlText | null> | undefined;
+        } | {
+            parts: (string | {
+                code: string;
+                original: string;
+                args?: Record<string, string | number | boolean | ControlText | null> | undefined;
+            } | /*elided*/ any)[];
+        } | undefined;
+        archivedControlText?: {
+            source: {
+                sourceKind: "CODE" | "CONFIG";
+                sourceId: string;
+                sourceVersion: string;
+                originalText: string;
+            };
+            args?: Record<string, string | number | boolean | null | import("../web-core/index").AssistantControlText> | undefined;
+        } | {
+            parts: (string | {
+                source: {
+                    sourceKind: "CODE" | "CONFIG";
+                    sourceId: string;
+                    sourceVersion: string;
+                    originalText: string;
+                };
+                args?: Record<string, string | number | boolean | null | import("../web-core/index").AssistantControlText> | undefined;
+            } | /*elided*/ any)[];
+        } | undefined;
+        selection?: {
+            value: {
+                interactionId: string;
+                prompt: string;
+                inputPolicy: "free_text_allowed" | "selection_required";
+                presentation: "options" | "confirmation";
+                options: {
+                    id: string;
+                    label: string;
+                }[];
+            };
+            request: string;
+            token?: {
+                identityScopeKey?: string | undefined;
+                executionScopePending?: boolean | undefined;
+                executionScopeKey?: string | undefined;
+                pageInstanceKey: string;
+                surfaceGeneration: number;
+                readStateRevision?: number | undefined;
+                contextRevision: string;
+                interactionRevision?: string | undefined;
+                fallback: boolean;
+            } | undefined;
+            state: "open" | "submitting" | "answered" | "superseded";
+            selectedOptionId?: string | undefined;
+            retryable?: boolean | undefined;
+        } | undefined;
+        confirmation?: {
+            readonly modelSummary: string;
+            readonly receiptReference?: {
+                kind: "record-save";
+                moduleAlias: string;
+                requestId: string;
+                tenantId?: string | undefined;
+                menuId?: string | undefined;
+                pageContext?: Record<string, string> | undefined;
+                pageSelection?: {
+                    kind: string;
+                    key: string;
+                } | undefined;
+            } | {
+                kind: "child-metadata";
+                moduleAlias: string;
+                relationId: string;
+                requestId: string;
+            } | {
+                kind: "page-publication";
+                variantId: string;
+                revisionId: string;
+                contentDigest: string;
+            } | undefined;
+            readonly continuationReadOnly?: boolean | undefined;
+            readonly continuationIsCurrent?: (() => boolean) | undefined;
+            takeContinuation: () => string | undefined;
+            readonly confirmLabel: string;
+            readonly presentation: {
+                title: string;
+                lines: string[];
+                details?: {
+                    title: string;
+                    lines: string[];
+                } | undefined;
+            };
+            readonly state: AssistantConfirmationState;
+            readonly result: {
+                title: string;
+                lines: string[];
+                details?: {
+                    title: string;
+                    lines: string[];
+                } | undefined;
+            } | undefined;
+            confirm: () => Promise<void>;
+            check: () => Promise<void>;
+            cancel: () => void;
+        } | undefined;
+        confirmationState?: AssistantConfirmationState | undefined;
+        confirmationScope?: string | undefined;
+        confirmationUserGoal?: string | undefined;
+        diagnostic?: string | undefined;
+        details?: {
+            title: string;
+            lines: string[];
+        } | undefined;
+    }[]>;
+    itemText: (item: ConversationItem) => string;
+    busy: import("vue").Ref<boolean, boolean>;
+    activityText: import("vue").ComputedRef<string>;
+    operationPending: import("vue").Ref<boolean, boolean>;
+    activeRequiredSelection: import("vue").ComputedRef<{
+        id: number;
+        role: "user" | "assistant" | "status";
+        text: string;
+        controlText?: {
+            code: string;
+            original: string;
+            args?: Record<string, string | number | boolean | ControlText | null> | undefined;
+        } | {
+            parts: (string | {
+                code: string;
+                original: string;
+                args?: Record<string, string | number | boolean | ControlText | null> | undefined;
+            } | /*elided*/ any)[];
+        } | undefined;
+        archivedControlText?: {
+            source: {
+                sourceKind: "CODE" | "CONFIG";
+                sourceId: string;
+                sourceVersion: string;
+                originalText: string;
+            };
+            args?: Record<string, string | number | boolean | null | import("../web-core/index").AssistantControlText> | undefined;
+        } | {
+            parts: (string | {
+                source: {
+                    sourceKind: "CODE" | "CONFIG";
+                    sourceId: string;
+                    sourceVersion: string;
+                    originalText: string;
+                };
+                args?: Record<string, string | number | boolean | null | import("../web-core/index").AssistantControlText> | undefined;
+            } | /*elided*/ any)[];
+        } | undefined;
+        selection?: {
+            value: {
+                interactionId: string;
+                prompt: string;
+                inputPolicy: "free_text_allowed" | "selection_required";
+                presentation: "options" | "confirmation";
+                options: {
+                    id: string;
+                    label: string;
+                }[];
+            };
+            request: string;
+            token?: {
+                identityScopeKey?: string | undefined;
+                executionScopePending?: boolean | undefined;
+                executionScopeKey?: string | undefined;
+                pageInstanceKey: string;
+                surfaceGeneration: number;
+                readStateRevision?: number | undefined;
+                contextRevision: string;
+                interactionRevision?: string | undefined;
+                fallback: boolean;
+            } | undefined;
+            state: "open" | "submitting" | "answered" | "superseded";
+            selectedOptionId?: string | undefined;
+            retryable?: boolean | undefined;
+        } | undefined;
+        confirmation?: {
+            readonly modelSummary: string;
+            readonly receiptReference?: {
+                kind: "record-save";
+                moduleAlias: string;
+                requestId: string;
+                tenantId?: string | undefined;
+                menuId?: string | undefined;
+                pageContext?: Record<string, string> | undefined;
+                pageSelection?: {
+                    kind: string;
+                    key: string;
+                } | undefined;
+            } | {
+                kind: "child-metadata";
+                moduleAlias: string;
+                relationId: string;
+                requestId: string;
+            } | {
+                kind: "page-publication";
+                variantId: string;
+                revisionId: string;
+                contentDigest: string;
+            } | undefined;
+            readonly continuationReadOnly?: boolean | undefined;
+            readonly continuationIsCurrent?: (() => boolean) | undefined;
+            takeContinuation: () => string | undefined;
+            readonly confirmLabel: string;
+            readonly presentation: {
+                title: string;
+                lines: string[];
+                details?: {
+                    title: string;
+                    lines: string[];
+                } | undefined;
+            };
+            readonly state: AssistantConfirmationState;
+            readonly result: {
+                title: string;
+                lines: string[];
+                details?: {
+                    title: string;
+                    lines: string[];
+                } | undefined;
+            } | undefined;
+            confirm: () => Promise<void>;
+            check: () => Promise<void>;
+            cancel: () => void;
+        } | undefined;
+        confirmationState?: AssistantConfirmationState | undefined;
+        confirmationScope?: string | undefined;
+        confirmationUserGoal?: string | undefined;
+        diagnostic?: string | undefined;
+        details?: {
+            title: string;
+            lines: string[];
+        } | undefined;
+    } | undefined>;
+    submit: () => void;
+    cancel: () => void;
+    abandonSelection: (item: ConversationItem) => void;
+    selectOption: (item: ConversationItem, option: AssistantSelectionOption) => void;
+    handleKeydown: (event: KeyboardEvent) => void;
+    confirmOperation: (item: ConversationItem, check?: boolean) => Promise<void>;
+    cancelOperation: (item: ConversationItem) => void;
+};
+export {};

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

@@ -0,0 +1,40 @@
+import { type LanguageContext } from '../web-core/index';
+import type { AssistantConversationClient, AssistantConversationContent, AssistantConversationSummary } from '../web-core/index';
+/** Serializes checkpoints; scope generations prevent late reads/writes from replacing another conversation. */
+export declare function useAssistantConversationArchive(client: AssistantConversationClient | undefined, content: () => AssistantConversationContent | Promise<AssistantConversationContent>, restore: (content: AssistantConversationContent) => void | Promise<void>, clear: () => void, leaveBlockedReason?: () => string | undefined, language?: LanguageContext): {
+    enabled: boolean;
+    id: import("vue").Ref<string | undefined, string | undefined>;
+    title: import("vue").ComputedRef<string>;
+    status: import("vue").Ref<"idle" | "saving" | "saved" | "unsaved" | "restored", "idle" | "saving" | "saved" | "unsaved" | "restored">;
+    saveError: import("vue").ComputedRef<string>;
+    readError: import("vue").ComputedRef<{
+        message: string;
+        kind: "list";
+        more: boolean;
+    } | {
+        message: string;
+        kind: "open";
+        id: string;
+    } | undefined>;
+    retryRead(): Promise<void> | undefined;
+    loading: import("vue").ComputedRef<boolean>;
+    ready: import("vue").Ref<boolean, boolean>;
+    historyOpen: import("vue").Ref<boolean, boolean>;
+    entries: import("vue").Ref<{
+        id: string;
+        title: string;
+        updatedAt: string;
+    }[], AssistantConversationSummary[] | {
+        id: string;
+        title: string;
+        updatedAt: string;
+    }[]>;
+    hasMore: import("vue").Ref<boolean, boolean>;
+    changeScope: (value: string | undefined) => void;
+    save: () => Promise<boolean>;
+    list: (more?: boolean) => Promise<void>;
+    open: (conversationId: string) => Promise<void>;
+    startNew: () => Promise<void>;
+    saveCopy: () => Promise<void>;
+    discardAndStartNew: () => void;
+};

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

@@ -1,5 +1 @@
-/**
- * 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, isBusy?: () => boolean): void;
+export { useWorkspaceViewUnsavedState } from '../web-core/index';

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

@@ -1,3 +1,23 @@
+import { type LanguageContext } from '../web-core/index';
 import type { MenuRecord, MenuTreeNode } from '../web-contracts/index';
 import type { AssistantCapability, AssistantInvocationToken } from '../web-core/index';
-export declare function createWorkbenchAssistantCapabilities(menus: () => MenuTreeNode[], openMenu: (menu: MenuRecord) => boolean, settleNavigation?: (signal?: AbortSignal) => Promise<void | AssistantInvocationToken>): AssistantCapability[];
+export declare function createWorkbenchAssistantCapabilities(menus: () => MenuTreeNode[], openMenu: (menu: MenuRecord) => boolean, settleNavigation?: (signal?: AbortSignal) => Promise<void | AssistantInvocationToken>, language?: LanguageContext): AssistantCapability[];
+/** Current visible navigation, projected on demand; no cross-page permission cache. */
+export declare function workbenchAssistantMenuCatalog(menus: readonly MenuTreeNode[], language?: LanguageContext): {
+    items: {
+        menuId: string;
+        schemeId: string;
+        title: string;
+        moduleAlias: string | undefined;
+        description: string | undefined;
+        path: string[];
+    }[];
+    page: {
+        note?: string | undefined;
+        offset: number;
+        total: number;
+        nextOffset: number | null;
+        coverage: string;
+        oversizedIndexes: number[];
+    };
+};

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

@@ -12,6 +12,7 @@ export interface WorkbenchNavigation {
     openMenu?(menu: MenuRecord): void;
     openRoute(path: string, options?: OpenRouteOptions): WorkbenchPageOpenResult;
     replaceRoute(path: string, options?: OpenRouteOptions): WorkbenchPageOpenResult;
+    /** Reports immediate execution only; protected closing finishes asynchronously after confirmation and does not report final fallback creation. */
     closeCurrentTab(fallbackPath: string): WorkbenchPageOpenResult;
     /** Opens a page and reports whether the target host was newly created. */
     openPage(descriptor: PageDescriptor): WorkbenchPageOpenResult;

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

@@ -12,6 +12,10 @@ export interface WorkspaceViewDefinition<TInput extends WorkspaceViewInput> {
     layout?: PageLayoutMode;
     drawerProfile?: WorkspaceDrawerProfile;
     routeTitle?: string;
+    routeTitleKey?: string;
+    /** CODE display resources; titleOf keeps the original and never depends on user language. */
+    titleKey?: string;
+    titleArgsOf?(input: TInput): Record<string, unknown>;
     titleOf(input: TInput): string;
     /**
      * Returns the input fields that identify one workbench tab. Other parsed

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

@@ -0,0 +1,5 @@
+import { type LanguageContext } from '../web-core/index';
+/** Clean pages need no asynchronous confirmation and retain immediate navigation semantics. */
+export declare function hasWorkspaceViewDiscardProtection(keys: readonly string[]): boolean;
+/** Every host must consult the same draft facts before destroying a workspace page. */
+export declare function confirmDiscardWorkspaceViewState(keys: readonly string[], operation?: 'close' | 'refresh', language?: LanguageContext): Promise<boolean>;

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, isBusy?: () => boolean): () => void;
+    registerUnsavedState(source: string, isDirty: () => boolean, isBusy?: () => boolean, sourceTitle?: () => string): () => void;
     dismiss(): void;
     /** Closes the current independent workbench view. */
     close(): void;

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

@@ -1,4 +1,4 @@
-export declare function registerWorkspaceViewUnsavedState(pageKey: string, source: string, isDirty: () => boolean, isBusy?: () => boolean): () => void;
+export declare function registerWorkspaceViewUnsavedState(pageKey: string, source: string, isDirty: () => boolean, isBusy?: () => boolean, sourceTitle?: () => string): () => 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[];

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

@@ -1,4 +1,5 @@
 import type { BusinessRoutePageDescriptor } from '../web-contracts/index';
+import { type LanguageContext } from '../web-core/index';
 import type { WorkspaceViewDefinition, WorkspaceViewInput, WorkspaceViewPresentation } from './workspaceViewContract';
 export { defineWorkspaceView, type WorkspaceDrawerProfile, type WorkspaceViewDefinition, type WorkspaceViewInput, type WorkspaceViewPresentation, } from './workspaceViewContract';
 export interface ResolvedWorkspaceView {
@@ -16,6 +17,6 @@ export interface WorkspaceViewRegistry {
  */
 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 createWorkspaceViewDescriptor<TInput extends WorkspaceViewInput>(view: WorkspaceViewDefinition<TInput>, input: TInput, presentation?: WorkspaceViewPresentation, title?: string, language?: LanguageContext): BusinessRoutePageDescriptor;
+export declare function dismissWorkspaceViewDescriptor(descriptor: BusinessRoutePageDescriptor, view: WorkspaceViewDefinition<WorkspaceViewInput>, language?: LanguageContext): BusinessRoutePageDescriptor;
 export declare function resolveWorkspaceView(descriptor: BusinessRoutePageDescriptor): ResolvedWorkspaceView | undefined;

package/dist/types/views/ConfigurationTranslationView.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;