@ximatai/muyun-web-app 0.26.14 → 0.26.16

package/dist/types/dynamic-page-runtime/formActionResult.d.ts

@@ -1,7 +1,8 @@
+import { type LanguageContext } from '../web-core/index';
 /** Distinguishes optional draft diagnostics from actions that declare the patch protocol. */
 export declare function hasFormActionRecordPatch(response: unknown): boolean;
 /** Only an explicit form result may update an unsaved draft. Ordinary action data is not a patch. */
-export declare function formActionResult(response: unknown): {
+export declare function formActionResult(response: unknown, language?: LanguageContext): {
     recordPatch: Record<string, unknown>;
     message?: string;
 };

package/dist/types/dynamic-page-runtime/formComputeCoordinator.d.ts

@@ -19,3 +19,5 @@ export declare class FormComputeCoordinator {
     applyOnCreate<TDraft extends FormulaRecord>(draft: TDraft, childAggregateRows?: FormulaRecord): TDraft;
     private evaluate;
 }
+/** Includes platform effects such as cleared dependent references in the calculation trigger set. */
+export declare function formComputeChangedFields(previous: FormulaRecord, current: FormulaRecord, explicitFields: readonly string[]): string[];

package/dist/types/dynamic-page-runtime/formValidationCoordinator.d.ts

@@ -13,5 +13,5 @@ export declare class FormValidationCoordinator {
     private readonly runtime;
     private readonly rules;
     constructor(rules: readonly ResolvedFormValidationRuleDescriptor[] | undefined, runtime?: FormulaRuntime);
-    validate(draft: FormulaRecord): FormValidationFailure | undefined;
+    validate(draft: FormulaRecord, displayRules?: readonly ResolvedFormValidationRuleDescriptor[]): FormValidationFailure | undefined;
 }

package/dist/types/dynamic-page-runtime/modulePageAssistantScope.d.ts

@@ -5,4 +5,16 @@ import type { TenantScopeController } from './useTenantScopeController';
 export type ModulePageAssistantTenantScope = Pick<TenantScopeController, 'blocked' | 'changeTenantScope' | 'selected' | 'tenantScopeContext' | 'tenantScopeExplorerVisible'> & {
     settleTenantScopeChange(record: QueryListRecord, signal: AbortSignal): Promise<void | AssistantInvocationToken>;
 };
-export declare function modulePageScopeCapabilities(view: ModulePageSessionView, tenantScope: ModulePageAssistantTenantScope | undefined): AssistantCapability[];
+export interface AssistantScopeCandidate {
+    scopeKey: string;
+    record: QueryListRecord;
+    revision: string;
+}
+/** Keep live, authorized search choices available across the user's clarification turn. */
+export declare function modulePageScopeCandidateFacts(view: ModulePageSessionView, tenantScope: ModulePageAssistantTenantScope | undefined, candidates: Map<string, AssistantScopeCandidate>): {
+    scopeKey: string;
+    selectionKey: string;
+    title: string | undefined;
+    label: string | undefined;
+}[];
+export declare function modulePageScopeCapabilities(view: ModulePageSessionView, tenantScope: ModulePageAssistantTenantScope | undefined, candidates: Map<string, AssistantScopeCandidate>): AssistantCapability[];

package/dist/types/dynamic-page-runtime/modulePageEnhancements.d.ts

@@ -1,6 +1,6 @@
 import type { Component } from 'vue';
-import type { CurrentUser, PageDescriptor, PageLayoutMode, RouteQueryValue, WebPageResponse, WebQueryCondition, WebQueryRequest } from '../web-contracts/index';
-import type { ModuleContext } from '../web-core/index';
+import type { CurrentUser, TextPresentation, PageDescriptor, PageLayoutMode, RouteQueryValue, WebPageResponse, WebQueryCondition, WebQueryRequest } from '../web-contracts/index';
+import type { LanguageContext, ModuleContext } from '../web-core/index';
 import type { DrawerWidth, RecordActionItem, RecordFormFieldState, RecordFormFieldValue, RecordQueryListColumn, QueryListRecord } from '../platform-components/index';
 import type { DrawerTitleAction } from '../platform-components/index';
 /**
@@ -79,6 +79,7 @@ export interface ModulePageNavigatorEnhancement {
 export interface ModulePageNavigatorTreeParentPolicy {
     canUseAsParent(record: Readonly<Record<string, unknown>>): boolean;
     rejectionMessage: string;
+    rejectionMessageKey?: string;
 }
 export interface ModulePageNavigatorExtension {
     key: string;
@@ -103,6 +104,7 @@ export interface ModulePageNavigatorSelection {
 }
 /** The only display facts a navigator extension may contribute to PAGE_TEXT. */
 export interface ModulePageSelectionPresentation {
+    labelText?: TextPresentation;
     label: string;
     secondaryLabel?: string;
 }
@@ -126,6 +128,7 @@ export interface ModulePageLockedNavigatorEntry {
     navigatorKey: string;
     /** Text shown if the addressed record cannot be resolved or authorized. */
     unavailableDescription: string;
+    unavailableDescriptionKey?: string;
 }
 export interface ModulePageEmptyNavigatorScopeContext {
     currentUser?: CurrentUser;
@@ -236,8 +239,8 @@ export interface ModulePageFormContributionState {
 export interface ModulePageFormFieldPolicy {
     fieldName: string;
     visible?(state: ModulePageFormContributionState): boolean;
-    imageUploadHint?(state: ModulePageFormContributionState): string | undefined;
-    imageUploadAdvisory?(state: ModulePageFormContributionState): ((file: File) => string | undefined | Promise<string | undefined>) | undefined;
+    imageUploadHint?(state: ModulePageFormContributionState, language?: LanguageContext): string | undefined;
+    imageUploadAdvisory?(state: ModulePageFormContributionState, language?: LanguageContext): ((file: File) => string | undefined | Promise<string | undefined>) | undefined;
 }
 /** Frontend-owned auxiliary UI adjacent to the descriptor-owned record card. */
 export interface ModuleCardEnhancement {
@@ -307,6 +310,8 @@ export interface ModulePageBatchActionContribution extends RecordActionItem {
     run(context: ModulePageBatchActionContext): void | Promise<void>;
 }
 export interface ModulePageDetailSection {
+    /** Optional CODE heading resource, resolved only at the display boundary. */
+    titleKey?: string;
     key: string;
     title: string;
     /** Optional heading copy owned by the business section but rendered by the platform shell. */
@@ -340,6 +345,8 @@ export interface ModulePageCellComponentContribution {
     cell: Component;
 }
 export interface ModulePageDrawer {
+    /** Optional CODE heading resource, resolved only at the display boundary. */
+    titleKey?: string;
     title: string;
     width?: DrawerWidth;
     /** The component receives only the documented ModulePageDrawerContext prop. */
@@ -362,6 +369,8 @@ export interface ModulePageWorkspaceView<TInput extends ModulePageWorkspaceViewI
     route?: string;
     component: Component;
     titleOf(input: TInput): string;
+    titleKey?: string;
+    titleArgsOf?(input: TInput): Record<string, unknown>;
     parse(query: Record<string, RouteQueryValue>): TInput | undefined;
     layout?: PageLayoutMode;
 }

package/dist/types/dynamic-page-runtime/modulePageUnsavedState.d.ts

@@ -1,10 +1,3 @@
-/**
- * Optional host bridge for a dynamic page rendered as an independent workspace
- * view. The dynamic runtime only reports its local draft fact; the workbench
- * owns registration, confirmation and tab destruction.
- */
-export interface ModulePageUnsavedStateHost {
-    registerUnsavedState(source: string, isDirty: () => boolean, isBusy?: () => boolean): () => void;
-}
-export declare function provideModulePageUnsavedStateHost(host: ModulePageUnsavedStateHost | undefined): void;
-export declare function useModulePageUnsavedState(source: string, isDirty: () => boolean, isBusy?: () => boolean): void;
+/** The module runtime and reusable record panels share the neutral draft-registration bridge. */
+export { provideWorkspaceUnsavedStateRegistrar as provideModulePageUnsavedStateHost, useWorkspaceViewUnsavedState as useModulePageUnsavedState, } from '../web-core/index';
+export type { WorkspaceUnsavedStateRegistrar as ModulePageUnsavedStateHost } from '../web-core/index';

package/dist/types/dynamic-page-runtime/pageActionInvocation.d.ts

@@ -1,7 +1,8 @@
+import { type LanguageContext } from '../web-core/index';
 import type { PageActionInvocation } from '../web-contracts/index';
 import type { HttpClient } from '../web-core/index';
 /** Execute only the server-issued transport; action identity is not an HTTP route. */
 export declare function invokePageAction(http: HttpClient, invocation: PageActionInvocation | undefined, context?: {
     recordId?: string;
     record?: Record<string, unknown>;
-}): Promise<unknown>;
+}, language?: LanguageContext): Promise<unknown>;

package/dist/types/dynamic-page-runtime/pageActionPlacement.d.ts

@@ -1,3 +1,4 @@
+import { type LanguageContext } from '../web-core/index';
 import type { RecordActionItem } from '../platform-components/index';
 import type { ResolvedPageActionDescriptor } from '../web-contracts/index';
 /** Placements choose presentation; execution must already have a platform workflow or issued action block. */
@@ -11,4 +12,4 @@ export declare function resolvePlacedPageActions(placements: ResolvedPageActionD
     bindingPending?: boolean;
 } | undefined, detailActions: RecordActionItem[], mode: 'create' | 'edit' | 'view', managed?: boolean, record?: {
     enabled?: unknown;
-}): RecordActionItem[];
+}, language?: LanguageContext): RecordActionItem[];

package/dist/types/dynamic-page-runtime/pageNavigatorItemModel.d.ts

@@ -1,3 +1,4 @@
+import { type LanguageContext } from '../web-core/index';
 import type { RecordExplorerItemDescriptor } from '../platform-components/index';
 import type { RecordInlineAction } from '../web-contracts/index';
 export interface NavigatorItemRecord {
@@ -10,4 +11,4 @@ export interface NavigatorItemRecord {
 /** Page navigators expose only the actions explicitly declared by the page. */
 export declare function navigatorItemOf(record: NavigatorItemRecord, secondaryField: string | undefined, manageable: boolean, actionsOf: ((record: {
     id?: string;
-}) => RecordInlineAction[]) | undefined): RecordExplorerItemDescriptor;
+}) => RecordInlineAction[]) | undefined, language?: LanguageContext): RecordExplorerItemDescriptor;

package/dist/types/dynamic-page-runtime/recordCreationReadiness.d.ts

@@ -0,0 +1,18 @@
+import { type LanguageContext } from '../web-core/index';
+/** Shared page preconditions; absence of an executable tool is not evidence of missing permission. */
+export declare function recordCreationReadiness(state: {
+    tenantReady: boolean;
+    pageReady: boolean;
+    permitted: boolean;
+    editing: boolean;
+    busy: boolean;
+    scopeReady: boolean;
+}, language?: LanguageContext): {
+    ready: boolean;
+    reason: string;
+    message: string;
+} | {
+    ready: boolean;
+    reason?: undefined;
+    message?: undefined;
+};

package/dist/types/dynamic-page-runtime/recordDisplayProjection.d.ts

@@ -0,0 +1,63 @@
+import { type LanguageContext } from '../web-core/index';
+import type { ResolvedDetailRelationDescriptor, ResolvedModuleUiDescriptor, OptionItemDescriptor } from '../web-contracts/index';
+import { type RecordFormFieldState, type RecordFormRecord } from '../platform-components/index';
+/** Read the same authorized display facts as the form; never expose a reference ID as its label. */
+export declare function recordFieldDisplay(field: RecordFormFieldState, record: RecordFormRecord, optionItems?: OptionItemDescriptor[], draft?: boolean, language?: LanguageContext): string;
+/** A missing authorized name is a state, never a comparison with a translated placeholder. */
+export declare function recordReferenceDisplay(field: RecordFormFieldState, record: RecordFormRecord, draft?: boolean, language?: LanguageContext): string | undefined;
+/** Resolve display labels through the same authorized provider used by the picker. */
+export declare function resolvedRecordFieldDisplay(field: RecordFormFieldState, record: RecordFormRecord, optionItems?: OptionItemDescriptor[], language?: LanguageContext): Promise<string>;
+export declare function assistantReadableField(field: RecordFormFieldState): boolean;
+/** Embedded aggregate facts only; no additional queries or inferred independent-relation rows. */
+export declare function recordRelationProjection(descriptor: ResolvedModuleUiDescriptor | undefined, relations: ResolvedDetailRelationDescriptor[], record: RecordFormRecord, { language, baseline, purpose, draft, relationOptions, editableRelations, draftRowKeys, includeDescribedValues, includeBaseline, }?: {
+    language?: LanguageContext;
+    draft?: boolean;
+    editableRelations?: ReadonlySet<string>;
+    /** Keys issued by mounted editors; never inferred from row position or record IDs. */
+    draftRowKeys?: ReadonlyMap<string, ReadonlySet<string>>;
+    includeDescribedValues?: boolean;
+    includeBaseline?: boolean;
+    baseline?: RecordFormRecord;
+    purpose?: 'context' | 'confirmation' | 'observation';
+    relationOptions?: Record<string, Record<string, OptionItemDescriptor[]>>;
+}): {
+    savedCount?: number | null | undefined;
+    savedRows?: {
+        values: {
+            truncated?: boolean | undefined;
+            value: string;
+            assistantPolicy?: import("../web-contracts/index").AssistantFieldPolicy | undefined;
+            label: string;
+        }[];
+        rowKey?: string | undefined;
+        row: number;
+    }[] | undefined;
+    relationCode: string;
+    title: string;
+    editable: boolean;
+    source: string;
+    loaded: boolean;
+    count: number | null;
+    removedCount: number;
+    truncated: boolean;
+    rows: {
+        values: {
+            truncated?: boolean | undefined;
+            value: string;
+            assistantPolicy?: import("../web-contracts/index").AssistantFieldPolicy | undefined;
+            label: string;
+        }[];
+        rowKey?: string | undefined;
+        row: number;
+    }[];
+    removedRows: {
+        values: {
+            truncated?: boolean | undefined;
+            value: string;
+            assistantPolicy?: import("../web-contracts/index").AssistantFieldPolicy | undefined;
+            label: string;
+        }[];
+        rowKey?: string | undefined;
+        row: number;
+    }[];
+}[];

package/dist/types/dynamic-page-runtime/recordFormAssistantCapabilities.d.ts

@@ -0,0 +1,60 @@
+import type { RecordFormDraftAccess } from './recordFormDraftAccess';
+import { type LanguageContext, type AssistantCapability } from '../web-core/index';
+import { type RecordFormFieldState } from '../platform-components/index';
+export declare function createRecordFormAssistantCapabilities(view: RecordFormDraftAccess, { language, resolveReferenceNames, canReadDetail, schemaDiscovery, }?: {
+    language?: LanguageContext;
+    resolveReferenceNames?: boolean;
+    canReadDetail?: () => boolean;
+    schemaDiscovery?: AssistantCapability['schemaDiscovery'];
+}): () => {
+    schemaDiscovery?: "eager";
+    descriptor: import("../web-contracts").AssistantCapabilityDescriptor;
+    effect: "read" | "page" | "draft" | "configuration-draft";
+    changesReadState?: boolean;
+    present?(output: unknown): import("../web-contracts").AssistantResultPresentation;
+    propose?(output: unknown): import("../web-core/index").AssistantOperationProposal;
+    parseInput(input: unknown): unknown;
+    execute(input: unknown, context: import("../web-core/index").AssistantCapabilityExecutionContext): Promise<unknown>;
+}[];
+/** Same field projection for live context and explicit reads; never queries reference sources. */
+export declare function recordFormAssistantFacts(view: RecordFormDraftAccess, resolved?: Map<string, {
+    display: string;
+    unavailable?: boolean;
+}>, referencesTruncated?: boolean, language?: LanguageContext): {
+    editorMode: "edit" | "create" | "view";
+    editable: boolean;
+    currentValuesTruncated: boolean;
+    fields: {
+        options: {
+            value: import("../web-contracts").OptionValue;
+            label: string;
+        }[];
+        currentValueUnavailable?: boolean | undefined;
+        currentValueTruncated?: boolean | undefined;
+        currentValue?: string | number | boolean | (string | number | boolean)[] | null | undefined;
+        referenceCardinality?: "ONE" | "MANY" | undefined;
+        referenceTargetModuleAlias?: string | undefined;
+        assistantWriteMode?: "value" | "referenceSelection" | undefined;
+        controlType: import("../platform-components/recordFormFieldModel").RecordFormFieldControlType;
+        assistantWritable: boolean;
+        valueHint?: string | undefined;
+        inputRequirements?: {
+            requiredOnInsert: boolean;
+            requiredOnUpdate: boolean;
+            maxLength?: number | null;
+            validationRegex?: string | null;
+            textNormalization?: "NONE" | "TRIM" | "TRIM_TO_NULL" | null;
+            precision?: number | null;
+            scale?: number | null;
+        } | undefined;
+        valueType: import("../web-contracts").ViewFieldValueType | undefined;
+        calculationPending?: boolean | undefined;
+        fieldName: string;
+        label: string;
+        required: boolean;
+        readOnly: boolean;
+    }[];
+};
+export declare function isSensitiveField(field: RecordFormFieldState): boolean;
+export declare function formFieldState(view: Pick<RecordFormDraftAccess, 'formFields' | 'referencePickerConfigs' | 'editingRecord' | 'selectedRecord' | 'editorMode'>, fieldName: string): RecordFormFieldState | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/types/dynamic-page-runtime/recordFormDraftAccess.d.ts

@@ -0,0 +1,36 @@
+import type { RecordFormFieldDescriptor, RecordFormFieldPickerConfig, RecordFormFieldValue, RecordFormRecord, ReferencePickerCandidate } from '../platform-components/index';
+import { type LanguageContext } from '../web-core/index';
+/** Controlled access to an existing editor, including a row of an aggregate draft. */
+export interface RecordFormDraftAccess {
+    /** Display scope of the owning editor; never used as a business execution scope. */
+    readonly language?: LanguageContext;
+    readonly editorMode: 'view' | 'create' | 'edit';
+    readonly editingRecord?: RecordFormRecord;
+    readonly selectedRecord?: RecordFormRecord;
+    readonly formFields: Map<string, RecordFormFieldDescriptor>;
+    readonly referencePickerConfigs: Record<string, RecordFormFieldPickerConfig>;
+    /** Current source-resolved display, separate from mutation data. */
+    referenceDisplay?(fieldName: string): string | undefined;
+    contextRevision(): string;
+    relations?(): unknown[];
+    updateDraftFields(changes: Array<{
+        fieldName: string;
+        value: RecordFormFieldValue;
+    }>, source?: 'user' | 'assistant'): void;
+    updateDraftReference(fieldName: string, candidate: ReferencePickerCandidate, source?: 'user' | 'assistant', changes?: Array<{
+        fieldName: string;
+        value: RecordFormFieldValue;
+    }>, 
+    /** Pure check of the staged record, before publishing draft or display changes. */
+    validate?: (record: RecordFormRecord) => void): void;
+}
+/** Called only by the standard editor while its complete update is still staged. */
+export declare function validateStagedDraft(record: RecordFormRecord, validate?: (record: RecordFormRecord) => void): void;
+/** One standard draft update: reference mappings, then explicit ordinary values. */
+export declare function referenceDraftChanges(fieldName: string, candidate: ReferencePickerCandidate, changes?: Array<{
+    fieldName: string;
+    value: RecordFormFieldValue;
+}>): {
+    fieldName: string;
+    value: RecordFormFieldValue;
+}[];

package/dist/types/dynamic-page-runtime/recordMutationPayload.d.ts

@@ -1,4 +1,4 @@
 import type { RecordFormRecord } from '../platform-components/index';
 import type { ResolvedViewFieldDescriptor } from '../web-contracts/index';
-/** Read projections never become business writes, including explicitly named flat outputs. */
-export declare function recordMutationPayload(record: RecordFormRecord, fields?: Iterable<Pick<ResolvedViewFieldDescriptor, 'fieldRef' | 'reference' | 'referenceSummary'>>): RecordFormRecord;
+/** Read projections and constant read-only fields never become business writes. */
+export declare function recordMutationPayload(record: RecordFormRecord, fields?: Iterable<Pick<ResolvedViewFieldDescriptor, 'fieldRef' | 'reference' | 'referenceSummary' | 'readOnly'>>, capabilities?: Iterable<string>): RecordFormRecord;

package/dist/types/dynamic-page-runtime/recordReferenceDisplay.d.ts

@@ -0,0 +1,8 @@
+import type { RecordFormDraftAccess } from './recordFormDraftAccess';
+import type { ReferencePickerCandidate } from '../platform-components/index';
+/** Editor-owned display observations; never candidates, write inputs or permission. */
+export declare function createRecordReferenceDisplay(form: Pick<RecordFormDraftAccess, 'editingRecord' | 'referencePickerConfigs' | 'language'>, sessionKey: () => unknown): {
+    clear(fieldNames: Iterable<string>): void;
+    observe(fieldName: string, candidates: readonly ReferencePickerCandidate[]): void;
+    current(fieldName: string): string | undefined;
+};

package/dist/types/dynamic-page-runtime/recordSaveRecovery.d.ts

@@ -0,0 +1,13 @@
+import { type LanguageContext } from '../web-core/index';
+import type { OperationReceiptReference } from '../web-contracts/index';
+type RecordSaveReference = Extract<OperationReceiptReference, {
+    kind: 'record-save';
+}>;
+type ReceiptStorage = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
+/** One browser tab retains only a query reference, never a draft or authorization. */
+export declare function createRecordSaveRecovery(scope: string, storage: ReceiptStorage, language?: LanguageContext): {
+    restore(): RecordSaveReference | undefined;
+    save(reference: RecordSaveReference): void;
+    clear(requestId: string): void;
+};
+export {};

package/dist/types/dynamic-page-runtime/relationDraftAssistantCapabilities.d.ts

@@ -0,0 +1,9 @@
+import { type LanguageContext, type AssistantCapability } from '../web-core/index';
+import type { RelationDraftRegistry } from './relationDraftController';
+export declare function createRelationDraftAssistantCapabilities(registry: RelationDraftRegistry, contextRevision: () => string, language?: LanguageContext): (() => AssistantCapability[]) & {
+    form: () => import("./recordFormDraftAccess").RecordFormDraftAccess | undefined;
+    selection: () => {
+        relationCode: string;
+        rowKey: string;
+    } | undefined;
+};

package/dist/types/dynamic-page-runtime/relationDraftController.d.ts

@@ -0,0 +1,23 @@
+import type { RecordFormDraftAccess } from './recordFormDraftAccess';
+/** Commands target the mounted aggregate editor; they never persist child records. */
+export interface RelationDraftController {
+    readonly code: string;
+    readonly title: string;
+    revision(): string;
+    settle(): Promise<void>;
+    rowKeys(): string[];
+    form(rowKey: string): RecordFormDraftAccess | undefined;
+    add(): string;
+    remove(rowKey: string): void;
+}
+export declare function createRelationDraftRegistry(): {
+    register(controller: RelationDraftController): () => boolean;
+    list(): RelationDraftController[];
+    revision: () => string;
+    settle: () => Promise<void[]>;
+    interactionRevision: () => number;
+    userChanged: () => void;
+};
+export type RelationDraftRegistry = ReturnType<typeof createRelationDraftRegistry>;
+export declare function provideRelationDraftRegistry(current: () => RelationDraftRegistry): void;
+export declare const useRelationDraftRegistry: () => () => RelationDraftRegistry | undefined;

package/dist/types/dynamic-page-runtime/relationFormComputeCoordinator.d.ts

@@ -6,4 +6,5 @@ export declare class RelationFormComputeCoordinator {
     private readonly runtime;
     constructor(rules: readonly ResolvedDetailRelationFormComputeRuleDescriptor[] | undefined, runtime?: FormulaRuntime);
     applyAfterChange<TRow extends FormulaRecord>(rows: readonly TRow[], changedRowKey: string, keyOf: (row: TRow) => string, changedField: string): TRow[];
+    applyAfterChanges<TRow extends FormulaRecord>(rows: readonly TRow[], changedRowKey: string, keyOf: (row: TRow) => string, changedFields: readonly string[]): TRow[];
 }