@ximatai/muyun-web-app 0.26.15 → 0.26.16

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

@@ -0,0 +1,346 @@
+import type { TextPresentation } from './index';
+/** Published workflow facts shared by static and metadata driven modules. */
+export interface WorkflowDefinition {
+    id: string;
+    version: number;
+    alias: string;
+    title?: string;
+    definitionStatus: string;
+    currentVersionNo?: number;
+    approvalEnabled: boolean;
+    organizationId?: string;
+    matchExpression?: string;
+    matchPriority?: number;
+    defaultDefinition?: boolean;
+}
+export interface WorkflowVersion {
+    id: string;
+    version: number;
+    versionNo: number;
+    publishStatus: string;
+}
+export interface WorkflowNode {
+    nodeTitleText?: TextPresentation;
+    id?: string;
+    version?: number;
+    nodeKey: string;
+    title?: string;
+    nodeTitle?: string;
+    nodeType: string;
+    nodeStatus?: string;
+    approvalMode?: string;
+    approvalRatio?: number;
+    participantPolicyText?: string;
+    milestoneType?: string;
+    routeMode?: string;
+    selectorNodeKey?: string;
+    convergeNodeKey?: string;
+    convergeMode?: string;
+    convergeRatio?: number;
+    requireManualSelectionReason?: boolean;
+    allowReject?: boolean;
+    autoApproveSameUser?: boolean;
+    requireRejectReason?: boolean;
+    allowRejectReturnToMe?: boolean;
+    allowRollback?: boolean;
+    requireRollbackReason?: boolean;
+    allowAddSign?: boolean;
+    warningDurationMinutes?: number;
+    overtimeDurationMinutes?: number;
+    taskDefinitionId?: string;
+    nodeConfigText?: string;
+}
+export interface WorkflowRoute {
+    id?: string;
+    routeKey: string;
+    sourceNodeKey: string;
+    targetNodeKey: string;
+    title?: string;
+    conditionExpression?: string;
+    defaultRoute?: boolean;
+    routeStatus?: string;
+    routeReason?: string;
+    selectedReason?: string;
+}
+export interface WorkflowAddSignExplanation {
+    dimension: 'NODE' | 'ROUTE';
+    nodeKey?: string;
+    nodeStatus?: string;
+    routeKey?: string;
+    routeSourceNodeKey?: string;
+    routeTargetNodeKey?: string;
+    addSignSourceNodeKey: string;
+}
+export interface WorkflowDesign {
+    nodes: WorkflowNode[];
+    links: WorkflowRoute[];
+    layoutJson?: string;
+}
+export interface WorkflowInstance {
+    id: string;
+    moduleAlias: string;
+    recordId: string;
+    definitionTitle?: string;
+    versionNo?: number;
+    instanceStatus: string;
+    approvalStatus?: string;
+    currentNodeKeys?: string;
+    startedAt?: string;
+    startedBy?: string;
+    completedAt?: string;
+    semanticJson?: string;
+    layoutJson?: string;
+}
+export interface WorkflowTask {
+    id: string;
+    nodeInstanceId?: string;
+    nodeKey?: string;
+    taskKind: string;
+    taskStatus: string;
+    assigneeId?: string;
+    assigneeTitle?: string;
+    originalAssigneeTitle?: string;
+    actualProcessUserTitle?: string;
+    processedByDelegation?: boolean;
+    originalAssigneeId?: string;
+    actualProcessorId?: string;
+    assignmentKind?: string;
+    decision?: string;
+    completedAt?: string;
+}
+export interface WorkflowEvent {
+    messageText?: TextPresentation;
+    id: string;
+    taskId?: string;
+    eventType: string;
+    actionCode?: string;
+    nodeKey?: string;
+    operatorId?: string;
+    operatorTitle?: string;
+    reason?: string;
+    message?: string;
+    nodeInstanceId?: string;
+    occurredAt?: string;
+    eventText?: string;
+    payloadText?: string;
+}
+export interface WorkflowAction {
+    actionCode: string;
+    title: string;
+    taskId?: string;
+    nodeKey?: string;
+    nodeTitle?: string;
+    reasonRequired: boolean;
+    targetAssigneeRequired?: boolean;
+    rejectReturnToMeSupported?: boolean;
+    rejectResubmitModes?: string[];
+    defaultRejectResubmitMode?: string;
+}
+export interface WorkflowStatus {
+    canSubmit?: boolean;
+    displayStatus: string;
+    instanceId?: string;
+    errorMessage?: string;
+    errorMessageText?: TextPresentation;
+    definition?: {
+        definitionTitle?: string;
+        definitionAlias?: string;
+    };
+}
+export interface WorkflowRenderBundle {
+    instance: WorkflowInstance;
+    nodes: WorkflowNode[];
+    routes: WorkflowRoute[];
+    semanticJson?: string;
+    layoutJson?: string;
+}
+export interface WorkflowSubmitPreview extends WorkflowRenderBundle {
+    definition?: WorkflowStatus['definition'];
+    tasks: WorkflowTask[];
+    taskViews?: WorkflowTask[];
+}
+export interface WorkflowBranch {
+    branchNodeKey: string;
+    branchTitle?: string;
+    selectionPending?: boolean;
+    selectorNodeKey?: string;
+    requireManualSelectionReason?: boolean;
+    candidates: Array<{
+        routeKey: string;
+        targetNodeKey: string;
+        routeStatus: string;
+        title?: string;
+        targetNodeTitle?: string;
+        defaultRoute?: boolean;
+        conditionMatched?: boolean;
+        recommended?: boolean;
+    }>;
+}
+export interface WorkflowWorkbenchCard {
+    nodeTitleText?: TextPresentation;
+    business?: {
+        title?: string;
+        moduleTitle?: string;
+        readable: boolean;
+        moduleTitleSource?: import('./index').TextReference;
+        moduleTitleText?: import('./index').TextPresentation;
+    };
+    instanceId: string;
+    moduleAlias: string;
+    recordId: string;
+    taskId?: string;
+    nodeTitle?: string;
+    taskStatus?: string;
+    approvalStatus?: string;
+    instanceStatus: string;
+    currentAssigneeTitles: string[];
+    submitterUserTitle?: string;
+    originalAssigneeTitle?: string;
+    assignmentKind?: string;
+    delegatedToUserTitle?: string;
+    overtimeStatus?: string;
+    startedAt?: string;
+    receivedAt?: string;
+    completedAt?: string;
+}
+export interface WorkflowHistoryInstance {
+    moduleAlias: string;
+    recordId: string;
+    startedByTitle?: string;
+    id: string;
+    versionNo: number;
+    instanceStatus: string;
+    approvalStatus: string;
+    startedAt?: string;
+    archivedAt?: string;
+    lastActionReason?: string;
+}
+export interface WorkflowWorkbenchFilters {
+    moduleAlias?: string;
+    submitterUserId?: string;
+    overtimeStatus?: string;
+    instanceStatus?: string;
+    taskStatus?: string;
+    receivedFrom?: string;
+    receivedTo?: string;
+    completedFrom?: string;
+    completedTo?: string;
+}
+export interface WorkflowTaskPreparation {
+    evaluation: {
+        passed: boolean;
+        failureMessage?: string;
+        failureCheckKey?: string;
+        failureMessageText?: TextPresentation;
+        /** Frozen configuration declarations remain available even when a check currently passes. */
+        checkTexts?: Array<{
+            checkKey: string;
+            title?: string;
+            titleText?: TextPresentation;
+            failureMessage?: string;
+            failureMessageText?: TextPresentation;
+        }>;
+        checkResults: Array<{
+            checkKey: string;
+            checkTitle?: string;
+            checkTitleText?: TextPresentation;
+            passed: boolean;
+            failureMessage?: string;
+            failureMessageText?: TextPresentation;
+        }>;
+        guides: Array<{
+            guideKey: string;
+            title?: string;
+            titleText?: TextPresentation;
+            instructionText?: TextPresentation;
+            guideKind: string;
+            guideConfigText?: string;
+            targetModuleAlias?: string;
+            targetActionCode?: string;
+        }>;
+    };
+}
+export interface WorkflowConfigurationCatalog {
+    tasks: {
+        id: string;
+        title: string;
+    }[];
+    queries: {
+        id: string;
+        title: string;
+    }[];
+    generations: {
+        id: string;
+        title: string;
+        targetModuleAlias: string;
+    }[];
+    associations: {
+        id: string;
+        title: string;
+    }[];
+}
+export interface WorkflowDefinitionSelection {
+    version: number;
+    title: string;
+    organizationId: string | null;
+    matchExpression: string | null;
+    matchPriority: number;
+    defaultDefinition: boolean;
+}
+export interface WorkflowDefinitionCreate extends Omit<WorkflowDefinitionSelection, 'version'> {
+    alias: string;
+    approvalEnabled: boolean;
+    enabled: boolean;
+}
+export interface WorkflowAdminInstance {
+    instanceId: string;
+    moduleAlias: string;
+    recordId: string;
+    versionNo: number;
+    instanceStatus: string;
+    approvalStatus: string;
+    startedByTitle?: string;
+    activeNodeTitles: string[];
+    workflowVersionId?: string;
+    activeNodeLabels?: {
+        nodeKey: string;
+        title: string;
+        addedByAddSign: boolean;
+        titleText?: TextPresentation;
+    }[];
+    currentAssigneeTitles: string[];
+    overtimeStatus?: string;
+}
+export interface WorkflowAdminTask {
+    taskId: string;
+    nodeKey?: string;
+    nodeInstanceId?: string;
+    workflowVersionId?: string;
+    nodeTitleText?: TextPresentation;
+    nodeTitle: string;
+    assigneeTitle?: string;
+    taskKind: string;
+    canForceApprove: boolean;
+}
+export interface WorkflowAdminInstanceQuery {
+    moduleAlias?: string;
+    recordId?: string;
+    starterId?: string;
+    instanceStatus?: string;
+    approvalStatus?: string;
+    currentAssigneeId?: string;
+    overtimeStatus?: string;
+    page: {
+        pageNum: number;
+        pageSize: number;
+    };
+}
+export interface WorkflowAdminHistoryQuery {
+    moduleAlias?: string;
+    recordId?: string;
+    startedBy?: string;
+    page: {
+        pageNum: number;
+        pageSize: number;
+    };
+}

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

@@ -1,7 +1,10 @@
+import type { TextReference } from '../web-contracts/index';
 import { webDataChangeTypes, type WebActionResultEnvelope, type WebDataChange } from '../web-contracts/index';
 export interface ResolvedWebActionResult {
     message: string;
     messageCode?: string;
+    messageArgs?: Record<string, unknown>;
+    messageSource?: TextReference;
     messageType?: string;
     resultType?: string;
     changeSetId?: string;

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

@@ -1,3 +1,4 @@
+import { type LanguageContext } from './language';
 import type { OperationReceiptReference, OperationPresentation } from '../web-contracts/index';
 import { type OperationProposal, type OperationConfirmation } from './operationConfirmation';
 export { OperationRejectedError as AssistantOperationRejectedError } from './operationConfirmation';
@@ -18,6 +19,6 @@ export interface AssistantOperationConfirmation extends OperationConfirmation {
     readonly continuationIsCurrent?: () => boolean;
     takeContinuation(): string | undefined;
 }
-export declare function createAssistantOperationConfirmation(proposal: AssistantOperationProposal, scopeIsCurrent: () => boolean, now?: () => number): AssistantOperationConfirmation;
+export declare function createAssistantOperationConfirmation(proposal: AssistantOperationProposal, scopeIsCurrent: () => boolean, now?: () => number, language?: LanguageContext): AssistantOperationConfirmation;
 /** Recovered results have no execute path, expiry renewal, or automatic continuation. */
-export declare function restoreAssistantOperationReceipt(reference: OperationReceiptReference, lookup: () => Promise<OperationPresentation | undefined>, scopeIsCurrent: () => boolean): AssistantOperationConfirmation;
+export declare function restoreAssistantOperationReceipt(reference: OperationReceiptReference, lookup: () => Promise<OperationPresentation | undefined>, scopeIsCurrent: () => boolean, language?: LanguageContext): AssistantOperationConfirmation;

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

@@ -1,6 +1,13 @@
 import type { OperationReceiptReference, OperationPresentation } from '../web-contracts/index';
 import type { HttpClient } from './http';
 import type { AssistantConversationMessage } from '../web-contracts/index';
+/** Display-only CODE text; never model history, command inputs or proof of execution. */
+export type AssistantControlText = {
+    source: import('../web-contracts/index').TextReference;
+    args?: Record<string, string | number | boolean | null | AssistantControlText>;
+} | {
+    parts: Array<string | AssistantControlText>;
+};
 export interface AssistantConfigurationTask {
     goal: string;
     mode: 'conversation' | 'visual';
@@ -13,6 +20,7 @@ export interface AssistantConversationContent {
     messages: Array<{
         role: 'user' | 'assistant' | 'status';
         text: string;
+        controlText?: AssistantControlText;
         operationReceipt?: {
             reference: OperationReceiptReference;
             executionScopeKey: string;

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

@@ -1,3 +1,4 @@
+import { type LanguageContext } from './language';
 import { type AssistantOperationProposal, type AssistantOperationConfirmation } from './assistantConfirmation';
 import type { AssistantCapabilityCall, AssistantResultPresentation, AssistantCapabilityDescriptor, AssistantSurfaceContext, AssistantTurnInput, AssistantTurnOutput } from '../web-contracts/index';
 import type { AssistantTurnProgress } from './assistantTurnClient';
@@ -143,10 +144,10 @@ export declare function useAssistantSurfaceHost(): AssistantSurfaceHost | undefi
 export declare class StaleAssistantInvocationError extends Error {
     constructor();
 }
-import { OperationUsageError } from './operationErrors';
+import { OperationUsageError, type OperationErrorMessage } from './operationErrors';
 /** Preserves the public assistant error contract at the adapter boundary. */
 export declare class AssistantCapabilityUsageError extends OperationUsageError {
-    constructor(message: string, code?: OperationUsageError['code']);
+    constructor(message: string | OperationErrorMessage, code?: OperationUsageError['code']);
 }
 /** An effect started before interruption. Contains no business output from an obsolete scope. */
 export declare class AssistantEffectInterruptedError extends Error {
@@ -157,6 +158,6 @@ export declare class AssistantEffectInterruptedError extends Error {
 export declare function createAssistantSurfaceRegistry(identityScope?: () => string, workspaceContext?: () => {
     revision: string;
     facts: Record<string, unknown>;
-}): AssistantSurfaceRegistry;
+}, language?: LanguageContext): AssistantSurfaceRegistry;
 /** Compares page identity and revisions, independently of object property order. */
 export declare function sameAssistantInvocationToken(left: AssistantInvocationToken | undefined, right: AssistantInvocationToken | undefined): boolean;

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

@@ -1,4 +1,5 @@
-import type { WebActionMessage } from '../web-contracts/index';
+import { type LanguageContext } from './language';
+import type { TextPresentation, WebActionMessage } from '../web-contracts/index';
 export interface ErrorTarget {
     kind?: string;
     moduleAlias?: string;
@@ -35,6 +36,7 @@ export declare const platformErrorCodes: {
     readonly resourceNotFound: "RESOURCE_NOT_FOUND";
     readonly resourceSoftDeletedConflict: "RESOURCE_SOFT_DELETED_CONFLICT";
     readonly configMissing: "CONFIG_MISSING";
+    readonly querySchemaUnsupported: "QUERY_SCHEMA_UNSUPPORTED";
     readonly internalError: "INTERNAL_ERROR";
 };
 export type PlatformErrorCode = (typeof platformErrorCodes)[keyof typeof platformErrorCodes] | (string & {});
@@ -47,6 +49,7 @@ export declare class AppError extends Error {
     readonly details?: Record<string, unknown>;
     readonly messageArgs?: Record<string, unknown>;
     readonly actionMessage?: WebActionMessage;
+    readonly messageText?: TextPresentation;
     globallyHandled: boolean;
     constructor(message: string, options?: {
         code?: PlatformErrorCode;
@@ -57,11 +60,12 @@ export declare class AppError extends Error {
         details?: Record<string, unknown>;
         messageArgs?: Record<string, unknown>;
         actionMessage?: WebActionMessage;
+        messageText?: TextPresentation;
     });
 }
 export declare function normalizeError(error: unknown): AppError;
-export declare function resolveGlobalErrorPresentation(error: AppError, context?: ErrorUiContext): GlobalErrorPresentation;
-export declare function userFacingErrorMessage(error: AppError): string;
+export declare function resolveGlobalErrorPresentation(error: AppError, context?: ErrorUiContext, language?: LanguageContext): GlobalErrorPresentation;
+export declare function userFacingErrorMessage(error: AppError, language?: LanguageContext): string;
 /** Fixed explanations for known model failures; never expose arbitrary upstream 5xx text. */
-export declare function modelFailureMessage(error: AppError): string | undefined;
+export declare function modelFailureMessage(error: AppError, language?: LanguageContext): string | undefined;
 export declare function isUnexpectedPlatformError(error: AppError): boolean;

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

@@ -22,3 +22,9 @@ export * from './operationConfirmation';
 export * from './operationErrors';
 export * from './operationReceipt';
 export * from './uuid';
+export { createWorkflowClient, createWorkflowDefinitionClient, createWorkflowAdminClient, refreshWorkflowRecordActions, } from './workflow';
+export { provideWorkspaceUnsavedStateRegistrar, useWorkspaceViewUnsavedState } from './workspaceUnsavedState';
+export type { WorkspaceUnsavedStateRegistrar } from './workspaceUnsavedState';
+export * from './language';
+export * from './languagePreference';
+export * from './presentationTexts';

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

@@ -0,0 +1,54 @@
+import type { TextReference } from '../web-contracts/index';
+import { type ComputedRef } from 'vue';
+import { type HttpClient, type StreamingHttpClient } from './http';
+export interface LanguageDefinition {
+    readonly tag: string;
+    readonly nativeName: string;
+    readonly fallbackTag?: string | null;
+    readonly direction: 'ltr' | 'rtl';
+    readonly enabled?: boolean;
+}
+export interface LanguageCatalog {
+    readonly defaultTag: string;
+    languages: readonly LanguageDefinition[];
+}
+export interface TextResolution {
+    text: string;
+    requestedTag: string;
+    resourceTag?: string;
+    missing: boolean;
+    fallback: boolean;
+}
+export interface LanguageContext {
+    readonly catalog: ComputedRef<LanguageCatalog>;
+    readonly languageTag: ComputedRef<string>;
+    readonly requestedLanguageTag: ComputedRef<string | undefined>;
+    readonly revision: ComputedRef<number>;
+    readonly selectionRevision: ComputedRef<number>;
+    readonly fallbackLanguageTags: ComputedRef<readonly string[]>;
+    readonly language: ComputedRef<LanguageDefinition>;
+    setLanguage(tag?: string): void;
+    setCatalog(catalog: LanguageCatalog): void;
+    registerResources(tag: string, messages: Record<string, string>): void;
+    resolve(key: string, defaultText?: string, args?: Record<string, unknown>): TextResolution;
+    /** Resolve registered resources without changing selection, including disabled fallback locales. */
+    resolveForLanguage(tag: string, key: string, defaultText?: string, args?: Record<string, unknown>): TextResolution;
+    t(key: string, defaultText?: string, args?: Record<string, unknown>): string;
+}
+/** Platform-owned CODE originals, independent of the selected or deployed default language. */
+export declare function platformCodeTextOriginal(key: string): string | undefined;
+/** Immutable CODE source facts belong to the platform resource producer, never to a consumer locale. */
+export declare function platformCodeTextReference(key: string): TextReference | undefined;
+/** Compare a declared source with the actual original, including its content version. */
+export declare function textReferenceMatchesOriginal(source: TextReference, original: string): boolean;
+export declare function createLanguageContext(options?: {
+    catalog?: LanguageCatalog;
+    languageTag?: string;
+    resources?: Record<string, Record<string, string>>;
+}): LanguageContext;
+export declare const platformLanguageContext: LanguageContext;
+export declare function provideLanguageContext(context: LanguageContext): void;
+export declare function useLanguageContext(): LanguageContext;
+export declare function withLanguageContext(client: StreamingHttpClient, context: LanguageContext): StreamingHttpClient;
+export declare function withLanguageContext(client: HttpClient, context: LanguageContext): HttpClient;
+export declare function loadLanguageCatalog(http: HttpClient, context: LanguageContext): Promise<void>;

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

@@ -0,0 +1,8 @@
+import type { LanguageContext } from './language';
+import { type UserPreferenceStore } from './userPreferences';
+/** Scope changes and user selection invalidate delayed restores; queued writes never cross accounts. */
+export declare function createLanguagePreferenceController(context: LanguageContext, store?: UserPreferenceStore): {
+    restore(identity?: string): Promise<void>;
+    save(tag: string): Promise<void>;
+    dispose(): void;
+};

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

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../http';
-import type { WebQueryRequest } from '../../web-contracts/index';
+import type { TextPresentation, WebQueryRequest } from '../../web-contracts/index';
 export type ImportDuplicateStrategy = 'ERROR' | 'SKIP' | 'OVERWRITE';
 export interface ImportSheet {
     sheetName: string;
@@ -40,6 +40,7 @@ export interface ImportExecutionResult {
     }>;
     partialSuccess: boolean;
     message: string;
+    messageText?: TextPresentation;
     errorFileName?: string;
     errorFileToken?: string;
 }

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

@@ -6,3 +6,4 @@ export type { ModuleAbilityClients, ModuleAbilities } from './abilities';
 export * from './moduleContext';
 export * from './pageActionEntries';
 export * from './dataExchangeClient';
+export { displayModuleRuntime } from './runtimeContext';

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

@@ -3,6 +3,7 @@ import type { HttpClient } from '../http';
 import { type ModuleAbilities } from './abilities';
 import { type ModuleActionState, type ModuleRecordActionAvailability, type ModuleRuntimeAction, type ModuleRuntimeContextState } from './runtimeContext';
 import { type NavigatorReferenceRequestContext, type ModuleCrudClient, type ModuleTreeClient } from './staticModuleClient';
+import { type LanguageContext } from '../language';
 export interface ModuleContext<TRecord> {
     moduleAlias: string;
     http: HttpClient;
@@ -21,6 +22,7 @@ export interface ModuleTreeContext<TRecord> extends ModuleContext<TRecord> {
     tree: ModuleTreeClient<TRecord>;
 }
 export interface ModuleContextConfig {
+    language?: LanguageContext;
     http?: HttpClient;
     httpFactory?: () => HttpClient;
 }
@@ -31,6 +33,8 @@ export interface ModuleContextOptions extends ModuleContextConfig {
 }
 export declare function configureModuleContext(config: ModuleContextConfig): void;
 export declare function provideModuleContextConfig(config: ModuleContextConfig): void;
+/** Auxiliary module APIs share the owner's transport without loading another module runtime. */
+export declare function useModuleHttpClient(): HttpClient;
 export declare function createModuleContext<TRecord>(options: ModuleContextOptions): ModuleContext<TRecord>;
 export declare function createModuleTreeContext<TRecord>(options: ModuleContextOptions): ModuleTreeContext<TRecord>;
 export declare function useModuleContext<TRecord>(options?: Partial<ModuleContextOptions>): ModuleContext<TRecord>;

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

@@ -1,3 +1,4 @@
+import { type LanguageContext } from '../language';
 /** Shared interaction vocabulary for page design and business rendering. */
 export declare function pageActionIntent(code: string, anchor: string): {
     operation: string;
@@ -8,7 +9,7 @@ export declare function pageActionEntryTitle(entry: {
     actionCode: string;
     anchor: string;
     title?: string;
-}): string;
+}, language?: LanguageContext): string;
 export declare function pageActionEntryVisible(entry: {
     actionCode: string;
     anchor: string;
@@ -18,4 +19,4 @@ export declare function pageActionEntryVisible(entry: {
 export declare function pageActionEntryDescription(entry: {
     actionCode: string;
     anchor: string;
-}): string;
+}, language?: LanguageContext): string;

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

@@ -1,3 +1,5 @@
+import { type LanguageContext } from '../language';
+import type { TextPresentationDocument } from '../../web-contracts/index';
 import type { PageActionInvocation, ResolvedModuleUiDescriptor } from '../../web-contracts/index';
 import { type AppError } from '../errors';
 import type { HttpClient } from '../http';
@@ -9,6 +11,7 @@ export interface ModuleRuntimeAction {
     actionCode: string;
     permissionActionCode?: string;
     title?: string;
+    titleSource?: import('../../web-contracts/index').TextReference;
     actionLevel?: 'DEFAULT' | 'LIST' | 'RECORD' | 'BATCH' | 'ANY';
     category?: string;
     accessMode?: 'AUTH_REQUIRED' | 'LOGIN_REQUIRED' | 'ANONYMOUS_ALLOWED';
@@ -38,11 +41,13 @@ export interface ModuleRecordActionDecision {
     actionCode: string;
     available: boolean;
     reason?: string;
+    reasonText?: import('../../web-contracts/index').TextPresentation;
 }
-export interface ModuleRuntimeContext {
+export interface ModuleRuntimeContext extends TextPresentationDocument {
     moduleAlias: string;
     tenantRequired?: boolean;
     title?: string;
+    titleSource?: import('../../web-contracts/index').TextReference;
     /** Stable wire code of the registered module kind. */
     moduleKind?: 'static' | 'dynamic';
     entryType?: 'module' | 'route' | 'link';
@@ -60,9 +65,13 @@ export interface ModuleRuntimeContextState {
     ready: Promise<ModuleRuntimeContext>;
     load(): Promise<ModuleRuntimeContext>;
     snapshot(): ModuleRuntimeContext | undefined;
+    presentationSnapshot?(): ModuleRuntimeContext | undefined;
+    /** Refresh only matching source translations; retain execution facts and active drafts. */
+    refreshTexts?(): Promise<void>;
     error(): AppError | undefined;
     hasAbility(ability: ModuleAbilityCode | string): boolean | undefined;
     action(actionCode: string, recordId?: string): ModuleActionState | undefined;
+    /** Action titles follow this display scope; snapshot() retains producer originals. */
     runtimeAction(actionCode: string): ModuleRuntimeAction | undefined;
     can(actionCode: string, recordId?: string): boolean | undefined;
     recordActions(recordId: string): Promise<ModuleRecordActionAvailability>;
@@ -70,5 +79,9 @@ export interface ModuleRuntimeContextState {
     recordActionsSnapshot(recordId: string): ModuleRecordActionAvailability | undefined;
     invalidateRecordActions?(recordIds?: string[]): void;
 }
-export declare function createModuleRuntimeContextState(http: HttpClient, moduleAlias: string, access?: 'MENU' | 'REFERENCE' | 'VIEW'): ModuleRuntimeContextState;
+export declare function createModuleRuntimeContextState(http: HttpClient, moduleAlias: string, access?: 'MENU' | 'REFERENCE' | 'VIEW', language?: LanguageContext): ModuleRuntimeContextState;
+/** A language view shares transport, authorization and retained record decisions with its owner. */
+export declare function scopeModuleRuntimeLanguage(context: ModuleRuntimeContextState, language: LanguageContext, access?: Pick<ModuleRuntimeContextState, 'action' | 'runtimeAction'>): ModuleRuntimeContextState;
 export declare function isRuntimeAbilityAvailable(context: ModuleRuntimeContext | undefined, ability: ModuleAbilityCode): boolean;
+/** UI consumers use a disposable display projection; execution and identity consumers keep snapshot(). */
+export declare function displayModuleRuntime(runtime: ModuleRuntimeContextState): ModuleRuntimeContext | undefined;

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

@@ -1,3 +1,5 @@
+import { type LanguageContext } from './language';
+import { type OperationErrorMessage } from './operationErrors';
 import type { OperationPresentation, OperationReceiptReference } from '../web-contracts/index';
 /** Captured platform command. The caller owns the candidate and execution scope. */
 export interface OperationProposal {
@@ -14,6 +16,8 @@ export interface OperationProposal {
 export type OperationConfirmationState = 'pending' | 'executing' | 'checking' | 'succeeded' | 'unknown' | 'cancelled' | 'expired' | 'rejected';
 /** Adapter proof that no persistent operation was accepted (validation or authorization rejection). */
 export declare class OperationRejectedError extends Error {
+    readonly textMessage?: OperationErrorMessage;
+    constructor(message?: string | OperationErrorMessage, options?: ErrorOptions);
 }
 export interface OperationConfirmation {
     readonly confirmLabel: string;
@@ -25,4 +29,4 @@ export interface OperationConfirmation {
     cancel(): void;
 }
 /** Explicit confirmation, duplicate-click protection and read-only recovery of uncertain writes. */
-export declare function createOperationConfirmation(proposal: OperationProposal, scopeIsCurrent: () => boolean, now?: () => number): OperationConfirmation;
+export declare function createOperationConfirmation(proposal: OperationProposal, scopeIsCurrent: () => boolean, now?: () => number, language?: LanguageContext): OperationConfirmation;