@ximatai/muyun-web-app 0.26.14 → 0.26.16

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

@@ -1,7 +1,17 @@
-import type { AssistantCapabilityCall, AssistantCapabilityDescriptor, AssistantSurfaceContext, AssistantTurnInput, AssistantTurnOutput } from '../web-contracts/index';
+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';
 export interface AssistantCapability<TInput = unknown, TOutput = unknown> {
     descriptor: AssistantCapabilityDescriptor;
+    /** Trusted adapter hint for a small current-surface schema set; never execution authority. */
+    schemaDiscovery?: 'eager';
+    /** Trusted implementation effect boundary; read capabilities cannot mutate the page. */
+    effect: 'read' | 'page' | 'draft' | 'configuration-draft';
+    /** Descriptive boundary for reads that replace selection/candidate state; never authority. */
+    changesReadState?: boolean;
+    present?(output: TOutput): AssistantResultPresentation;
+    propose?(output: TOutput): AssistantOperationProposal;
     parseInput(input: unknown): TInput;
     execute(input: TInput, context: AssistantCapabilityExecutionContext): Promise<TOutput>;
 }
@@ -15,18 +25,25 @@ export interface AssistantCapabilityExecutionContext {
     /** Commit invocation-local guarded state without claiming a user-visible page effect. */
     commitInternalState<T>(commit: () => T): T;
     /**
-     * Apply a page effect, retaining its execution scope while background work settles.
+     * Synchronously commit a page effect, retaining its scope while background work settles.
+     * Async preparation belongs before this call; background completion belongs in settle.
      * Navigation adapters may return the token of an explicitly validated replacement surface.
      */
-    applyEffect<T>(effect: () => T, settle?: () => Promise<void | AssistantInvocationToken>): T;
+    applyEffect<T>(effect: () => T extends PromiseLike<unknown> ? never : T, settle?: () => Promise<void | AssistantInvocationToken>): T;
 }
 export interface AssistantSurface {
     describe(): AssistantSurfaceContext;
+    /** Authorized display facts only: no extra queries, execution inputs, IDs or authority. */
+    observationSummary?(): string | undefined;
     capabilities(): AssistantCapability[];
     requestTurn(input: AssistantTurnInput, signal: AbortSignal, progress?: AssistantTurnProgress): Promise<AssistantTurnOutput>;
 }
 export interface AssistantSurfaceRegistration {
     pageInstanceKey: string;
+    /** Opaque execution-data boundary, never sent to the model. */
+    executionScopeKey?(): string;
+    /** A fallback awaiting its real page transport must not issue model requests. */
+    executionScopePending?: boolean;
     fallback?: boolean;
     /**
      * Waits for background page transitions to finish before the model receives a
@@ -42,8 +59,13 @@ export interface AssistantSurfaceRegistration {
     surface: AssistantSurface;
 }
 export interface AssistantInvocationToken {
+    identityScopeKey?: string;
+    executionScopePending?: boolean;
+    executionScopeKey?: string;
     pageInstanceKey: string;
     surfaceGeneration: number;
+    /** Invalidates observations when selection or candidate state changes without a page effect. */
+    readStateRevision?: number;
     contextRevision: string;
     interactionRevision?: string;
     fallback: boolean;
@@ -51,8 +73,21 @@ export interface AssistantInvocationToken {
 export interface AssistantSurfaceSnapshot {
     token: AssistantInvocationToken;
     context: AssistantSurfaceContext;
+    /** Historical display evidence; never an executable context or capability. */
+    observationSummary?: string;
     capabilities: AssistantCapabilityDescriptor[];
 }
+/** Per-request restriction selected by the caller, never by model output. */
+export interface AssistantExecutionPolicy {
+    readOnly?: boolean;
+}
+/** Conversation-local schema choices; never business observations, inputs or execution authority. */
+export interface AssistantCapabilitySelection {
+    forScope(token: AssistantInvocationToken | undefined): string[];
+    remember(token: AssistantInvocationToken, codes: string[]): void;
+    clear(): void;
+}
+export declare function createAssistantCapabilitySelection(): AssistantCapabilitySelection;
 export interface AssistantSurfaceRegistry {
     register(registration: AssistantSurfaceRegistration): () => void;
     activate(pageInstanceKey: string | undefined): void;
@@ -67,12 +102,38 @@ export interface AssistantSurfaceRegistry {
     }): Promise<AssistantSurfaceSnapshot>;
     /** Waits for the current page to settle and returns a fresh, execution-compatible snapshot. */
     settleActiveSurface(token: AssistantInvocationToken, signal?: AbortSignal): Promise<AssistantSurfaceSnapshot>;
-    requestTurn(input: Omit<AssistantTurnInput, 'context' | 'capabilities'>, token: AssistantInvocationToken, signal?: AbortSignal, progress?: AssistantTurnProgress): Promise<AssistantTurnOutput>;
-    invoke(call: AssistantCapabilityCall, token: AssistantInvocationToken, signal?: AbortSignal): Promise<{
+    requestTurn(input: Omit<AssistantTurnInput, 'context' | 'capabilities'> & {
+        capabilitySelection?: AssistantCapabilitySelection;
+        /** Missing declarations from a rejected decision; filtered through the current allowed catalog. */
+        declarationRecoveryCodes?: string[];
+    }, token: AssistantInvocationToken, signal?: AbortSignal, progress?: AssistantTurnProgress, policy?: AssistantExecutionPolicy): Promise<AssistantTurnOutput>;
+    invoke(call: AssistantCapabilityCall, token: AssistantInvocationToken, signal?: AbortSignal, policy?: AssistantExecutionPolicy): Promise<{
         value: unknown;
         contextChanged: boolean;
+        readStateChanged?: boolean;
+        presentation?: AssistantResultPresentation;
+        confirmation?: AssistantOperationConfirmation;
     }>;
 }
+/** Current live editor state; never restored from conversation history. */
+export interface AssistantConfigurationEditor {
+    kind?: 'metadata' | 'page' | 'rules';
+    openingCapability?: string;
+    moduleAlias?: string;
+    title: string;
+    hasUnsavedChanges: boolean;
+    visible: boolean;
+    open?(): void;
+}
+/** Workbench-owned context and capabilities contributed by a configuration editor or other domain. */
+export interface AssistantWorkspaceContribution {
+    editor?(): AssistantConfigurationEditor | undefined;
+    current(): {
+        revision: string;
+        facts: Record<string, unknown>;
+    };
+    capabilities(settleNavigation?: (signal?: AbortSignal, requireFormal?: boolean) => Promise<void | AssistantInvocationToken>): AssistantCapability[];
+}
 export interface AssistantSurfaceHost {
     registry: AssistantSurfaceRegistry;
     activePageInstanceKey(): string | undefined;
@@ -83,10 +144,20 @@ export declare function useAssistantSurfaceHost(): AssistantSurfaceHost | undefi
 export declare class StaleAssistantInvocationError extends Error {
     constructor();
 }
-/** Safe, bounded feedback that helps the model repair a rejected capability call. */
-export declare class AssistantCapabilityUsageError extends Error {
-    constructor(message: string);
+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 | OperationErrorMessage, code?: OperationUsageError['code']);
+}
+/** An effect started before interruption. Contains no business output from an obsolete scope. */
+export declare class AssistantEffectInterruptedError extends Error {
+    readonly token: AssistantInvocationToken;
+    readonly execution: 'effect-applied' | 'unknown';
+    constructor(token: AssistantInvocationToken, execution: 'effect-applied' | 'unknown', cause: unknown);
 }
-export declare function createAssistantSurfaceRegistry(): AssistantSurfaceRegistry;
+export declare function createAssistantSurfaceRegistry(identityScope?: () => string, workspaceContext?: () => {
+    revision: string;
+    facts: Record<string, unknown>;
+}, 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/assistantTurnClient.d.ts

@@ -1,7 +1,15 @@
-import type { AssistantTurnInput, AssistantTurnOutput } from '../web-contracts/index';
+import type { AssistantTurnInput, AssistantTurnOutput, AssistantTokenUsage } from '../web-contracts/index';
 import { type HttpClient } from './http';
 export interface AssistantTurnProgress {
     onTextDelta?(text: string): void;
+    /** Observed before stale response rejection; never a business receipt. */
+    onRequestCompleted?(observation: AssistantModelRequestObservation): void | Promise<void>;
+}
+export interface AssistantModelRequestObservation {
+    durationMs: number;
+    outcome: 'received' | 'failed';
+    usage?: AssistantTokenUsage;
+    toolCallCount?: number;
 }
 export type AssistantTurnRequester = (input: AssistantTurnInput, signal: AbortSignal, progress?: AssistantTurnProgress) => Promise<AssistantTurnOutput>;
 /** Uses the supplied transport as-is so page-owned tenant scope remains authoritative. */

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

@@ -0,0 +1,55 @@
+import type { ConstructionPlanContent, ReferenceTargetFieldCatalog, ConstructionTask, ConstructionAcceptancePreview, ConstructionAcceptanceReceipt, ConstructionDeliveryReceipt, ConstructionProgress, ConstructionFieldDescription, ConstructionFieldResult, ConstructionInitializationResult, ConstructionPlanSnapshot, ConstructionPlanSummary } from '../web-contracts/index';
+import type { HttpClient } from './http';
+export interface ConstructionPlanClient {
+    designContract(): Promise<{
+        recordName: {
+            fieldName: string;
+            columnName: string;
+            fieldType: string;
+        };
+        inheritedFields: string[];
+        declarableCapabilities: {
+            capabilities: string[];
+            metadataFields: {
+                fieldName: string;
+                columnName: string;
+                fieldSpecAlias: string;
+                defaultKind: string;
+                defaultDescription: string;
+            }[];
+        };
+    }>;
+    businessObjects(): Promise<{
+        alias: string;
+        title: string;
+        applicationAlias: string;
+        applicationTitle: string | null;
+        kind: string;
+        referenceReady: boolean;
+        explanation: string;
+    }[]>;
+    referenceTarget(moduleAlias: string): Promise<ReferenceTargetFieldCatalog>;
+    task(id: string): Promise<ConstructionTask>;
+    previewAcceptance(id: string, objectKey: string): Promise<ConstructionAcceptancePreview>;
+    confirmAcceptance(id: string, command: {
+        requestId: string;
+        objectKey: string;
+        fingerprint: string;
+    }): Promise<ConstructionAcceptanceReceipt>;
+    acceptance(id: string, requestId: string): Promise<ConstructionAcceptanceReceipt | undefined>;
+    delivery(id: string, requestId: string): Promise<ConstructionDeliveryReceipt | undefined>;
+    progress(id: string, objectKey: string): Promise<ConstructionProgress>;
+    describeFields(id: string, objectKey: string): Promise<ConstructionFieldDescription>;
+    fieldChange(id: string, requestId: string): Promise<ConstructionFieldResult | undefined>;
+    initialization(id: string, objectKey: string): Promise<ConstructionInitializationResult | undefined>;
+    list(): Promise<ConstructionPlanSummary[]>;
+    read(id: string): Promise<ConstructionPlanSnapshot>;
+    history(id: string): Promise<ConstructionPlanSnapshot[]>;
+    confirm(id: string, command: {
+        requestId: string;
+        expectedRevision: number;
+        content: ConstructionPlanContent;
+    }): Promise<ConstructionPlanSnapshot>;
+    confirmation(id: string, requestId: string): Promise<ConstructionPlanSnapshot | undefined>;
+}
+export declare function createConstructionPlanClient(http: HttpClient): ConstructionPlanClient;

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,9 +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, language?: LanguageContext): string | undefined;
 export declare function isUnexpectedPlatformError(error: AppError): boolean;

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

@@ -13,6 +13,7 @@ export interface HttpRequestOptions {
     path: string;
     query?: Record<string, RouteQueryValue>;
     body?: unknown;
+    responseType?: 'json' | 'blob';
     headers?: Record<string, string>;
     /** Cancels the underlying Fetch request, including a long-lived response stream. */
     signal?: AbortSignal;

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

@@ -4,6 +4,7 @@ export * from './sse';
 export * from './query';
 export * from './actionResult';
 export * from './assistantSurface';
+export * from './assistantCatalogPage';
 export * from './assistantRuntime';
 export * from './assistantTurnClient';
 export * from './businessNotifications';
@@ -14,3 +15,16 @@ export * from './referenceResolveClient';
 export { userPreferences } from './userPreferences';
 export type { UserPreferenceOptions, UserPreferenceStore } from './userPreferences';
 export * from './module/index';
+export * from './assistantConfirmation';
+export * from './constructionPlanClient';
+export * from './assistantConversationClient';
+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

@@ -0,0 +1,54 @@
+import type { HttpClient } from '../http';
+import type { TextPresentation, WebQueryRequest } from '../../web-contracts/index';
+export type ImportDuplicateStrategy = 'ERROR' | 'SKIP' | 'OVERWRITE';
+export interface ImportSheet {
+    sheetName: string;
+    entityAlias: string;
+    main: boolean;
+    rowCount: number;
+    fields: Array<{
+        fieldName: string;
+        title: string;
+        matchKeyCandidate: boolean;
+    }>;
+}
+export interface ImportParseResult {
+    sheets: ImportSheet[];
+}
+export interface ImportExecutionCommand {
+    mainSheet: {
+        matchFieldName: string;
+        duplicateStrategy: ImportDuplicateStrategy;
+    };
+    childSheets: Array<{
+        entityAlias: string;
+        matchFieldName: string;
+        duplicateStrategy: ImportDuplicateStrategy;
+    }>;
+}
+export interface ImportExecutionResult {
+    created: number;
+    updated: number;
+    skipped: number;
+    errorCount: number;
+    summaries?: Record<string, {
+        entityAlias: string;
+        created: number;
+        updated: number;
+        skipped: number;
+        errors: number;
+    }>;
+    partialSuccess: boolean;
+    message: string;
+    messageText?: TextPresentation;
+    errorFileName?: string;
+    errorFileToken?: string;
+}
+/** Dynamic EXCHANGE transport; domain execution remains behind the module's standard action scope. */
+export declare function createDataExchangeClient(http: HttpClient, moduleAlias: string): {
+    template: () => Promise<Blob>;
+    parse(file: File): Promise<ImportParseResult>;
+    execute(file: File, command: ImportExecutionCommand): Promise<ImportExecutionResult>;
+    errorFile: (token: string) => Promise<Blob>;
+    exportData(request: WebQueryRequest): Promise<Blob>;
+};

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

@@ -5,3 +5,5 @@ export type { ModuleActionState, ModuleRecordActionAvailability, ModuleRuntimeAc
 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/module/staticModuleClient.d.ts

@@ -11,13 +11,23 @@ export interface QuerySchemaRequestOptions {
     uiConfigId?: string;
     queryTemplateId?: string;
 }
+export interface RecordSaveRequestOptions {
+    requestId: string;
+}
+export interface RecordSaveReceipt {
+    committed: boolean;
+    recordId?: string;
+    recordVersion?: number;
+    actionCode?: string;
+}
 /** Source-neutral client for a platform module's standard CRUD contract. */
 export interface ModuleCrudClient<TRecord> {
     querySchema(options?: QuerySchemaRequestOptions): Promise<QuerySchema>;
     query(request?: WebQueryRequest): Promise<WebPageResponse<TRecord>>;
     view(id: string): Promise<TRecord>;
-    insert(record: TRecord): Promise<StaticRecordMutationResult<TRecord>>;
-    update(id: string, record: TRecord): Promise<StaticRecordMutationResult<TRecord>>;
+    insert(record: TRecord, options?: RecordSaveRequestOptions): Promise<StaticRecordMutationResult<TRecord>>;
+    update(id: string, record: TRecord, options?: RecordSaveRequestOptions): Promise<StaticRecordMutationResult<TRecord>>;
+    saveReceipt?(requestId: string): Promise<RecordSaveReceipt>;
     delete(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
     enable(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
     disable(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;

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

@@ -0,0 +1,32 @@
+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 {
+    receiptReference?: OperationReceiptReference;
+    presentation: OperationPresentation;
+    confirmLabel?: string;
+    expiresAt: number;
+    isCurrent(): boolean;
+    /** Submits the captured payload using the same durable request identity on every attempt. */
+    execute(): Promise<OperationPresentation>;
+    /** A missing receipt is not permission to automatically resubmit. */
+    lookup(): Promise<OperationPresentation | undefined>;
+}
+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;
+    readonly presentation: OperationPresentation;
+    readonly state: OperationConfirmationState;
+    readonly result: OperationPresentation | undefined;
+    confirm(): Promise<void>;
+    check(): Promise<void>;
+    cancel(): void;
+}
+/** Explicit confirmation, duplicate-click protection and read-only recovery of uncertain writes. */
+export declare function createOperationConfirmation(proposal: OperationProposal, scopeIsCurrent: () => boolean, now?: () => number, language?: LanguageContext): OperationConfirmation;

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

@@ -0,0 +1,23 @@
+import type { TextReference } from '../web-contracts/index';
+import { type LanguageContext } from './language';
+export interface OperationErrorMessage {
+    readonly message: string;
+    readonly source: TextReference;
+    readonly args: Readonly<Record<string, string | number | boolean | null>>;
+}
+/** Explicit CODE declaration; parameters are frozen display facts, never inferred from prose. */
+export declare function codeOperationErrorMessage(language: LanguageContext, key: string, original: string, args?: Record<string, unknown>): OperationErrorMessage;
+/** A rejected editor operation with safe, bounded feedback for callers. */
+export declare class OperationUsageError extends Error {
+    readonly code: 'CAPABILITY_USAGE_INVALID' | 'CANDIDATE_AMBIGUOUS' | 'CANDIDATE_EXPIRED' | 'PRECONDITION_FAILED';
+    readonly textMessage?: OperationErrorMessage;
+    constructor(message: string | OperationErrorMessage, code?: 'CAPABILITY_USAGE_INVALID' | 'CANDIDATE_AMBIGUOUS' | 'CANDIDATE_EXPIRED' | 'PRECONDITION_FAILED');
+}
+/** Resolves owned presentation facts without replaying validation or changing the error code. */
+export declare function resolveOperationErrorMessage(error: Error & {
+    readonly textMessage?: OperationErrorMessage;
+}, language?: LanguageContext): string;
+/** A staged draft was rejected before publication; no draft or display state was changed. */
+export declare class DraftUpdateRejectedError extends OperationUsageError {
+    constructor(failure: OperationUsageError);
+}

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

@@ -0,0 +1,10 @@
+import type { OperationPresentation, OperationReceiptReference } from '../web-contracts/index';
+import type { HttpClient } from './http';
+/** Only query identities survive a conversation. Payloads, permissions and confirmation are never restored. */
+export declare function parseOperationReceiptReference(value: unknown): OperationReceiptReference;
+export declare function pagePublicationDigest(revision: {
+    templateAlias?: string;
+    templateVersion?: number;
+    uiTreeJson?: string;
+}): Promise<string>;
+export declare function lookupOperationReceipt(http: HttpClient, input: OperationReceiptReference): Promise<OperationPresentation | undefined>;

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

@@ -0,0 +1,16 @@
+import type { TextReference, TextPresentation, TextPresentationDocument } from '../web-contracts/index';
+import type { LanguageContext, TextResolution } from './language';
+/** Snapshot a producer's concrete CODE original; arguments format deployed resources, never business values in the fallback. */
+export declare function createCodeTextPresentation(key: string, originalText: string, context: LanguageContext, args?: Record<string, unknown>): TextPresentation;
+export declare function resolvePresentationText(text: TextPresentation, context: LanguageContext): TextResolution;
+/** Typed labels outside module descriptors use the same immutable presentation resource. */
+export declare function presentationLabel(original: string, text: TextPresentation | undefined, context: LanguageContext): string;
+/** Restore source facts for execution/dirty checks; projections remain separate and disposable. */
+export declare function originalPresentation<T extends TextPresentationDocument>(document: T): T;
+export declare function translatedPresentation<T extends TextPresentationDocument>(document: T, context: LanguageContext): T;
+export declare function isTextReference(value: unknown): value is TextReference;
+/** A label is valid only while its explicitly declared source still matches the raw record value. */
+export declare function recordPresentationText(record: object | undefined, field: string): TextPresentation | undefined;
+export declare function recordPresentationLabel(record: object, field: string, context: LanguageContext): string | undefined;
+/** Removes only the record's read metadata; arbitrary nested JSON business values are preserved. */
+export declare function withoutRecordPresentation<T>(record: T): T;

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

@@ -0,0 +1,2 @@
+/** UTF-8 digest shared with server source versions; works without WebCrypto on LAN HTTP. */
+export declare function sha256Hex(text: string): string;

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

@@ -0,0 +1,2 @@
+/** Generate a random UUID, including on LAN HTTP where randomUUID is unavailable. */
+export declare function createUuid(): string;