@ximatai/muyun-web-app 0.26.8 → 0.26.10

package/dist/types/dynamic-page-runtime/composables/useRecordEditingSession.d.ts

@@ -0,0 +1,23 @@
+import type { ModuleContext } from '../../web-core/index';
+import type { RecordDetailTransitionOptions } from '../recordDetailController';
+interface DetailController<TRecord> {
+    beginLoad(record: TRecord, mode: 'edit' | 'view', options?: RecordDetailTransitionOptions): void;
+    resolveLoad(record: TRecord): void;
+    failLoad(): void;
+    finishLoad(): void;
+}
+/**
+ * Serializes record-detail requests for one module-page session.
+ *
+ * Loading a second record (or closing the detail) invalidates all earlier
+ * completions. This is deliberately independent of the visual host so list,
+ * card and drawer surfaces cannot accidentally diverge on request races.
+ */
+export declare function useRecordEditingSession<TRecord extends {
+    id?: unknown;
+}>(context: ModuleContext<TRecord>, detail: DetailController<TRecord>, onLoaded: () => void): {
+    invalidatePendingRequests: () => void;
+    openRecord: (record: TRecord, mode: "edit" | "view", options?: RecordDetailTransitionOptions, skipLoad?: boolean) => Promise<void>;
+    openRecycleBinRecord: (record: TRecord) => Promise<void>;
+};
+export {};

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

@@ -1,12 +1,5 @@
-export interface DynamicModuleDetailRequestState {
-    activeRequestSequence: number;
-    requestSequence: number;
-}
-export interface DynamicModuleDetailMutationState {
-    hasRecord: boolean;
-    saving: boolean;
-    loading: boolean;
-    loadFailed: boolean;
-}
-export declare function shouldCommitDynamicModuleDetailRequest(state: DynamicModuleDetailRequestState): boolean;
-export declare function canMutateDynamicModuleDetail(state: DynamicModuleDetailMutationState): boolean;
+/**
+ * @deprecated Standard module pages use `moduleDetailStateModel`. Remove after
+ * extensions built before the rename have migrated their state-model imports.
+ */
+export { canMutateModuleDetail as canMutateDynamicModuleDetail, shouldCommitModuleDetailRequest as shouldCommitDynamicModuleDetailRequest, type ModuleDetailMutationState as DynamicModuleDetailMutationState, type ModuleDetailRequestState as DynamicModuleDetailRequestState, } from './moduleDetailStateModel';

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

@@ -0,0 +1,18 @@
+import { FormulaRuntime, type FormulaRecord } from '../formula/FormulaRuntime';
+import type { ResolvedFormComputeRuleDescriptor } from '../web-contracts/index';
+/**
+ * Applies server-issued main-form calculation rules to a draft after one or
+ * more user-originated field changes.
+ *
+ * The coordinator owns propagation, rather than the field component or the
+ * FormulaRuntime: fields remain plain inputs and FormulaRuntime remains a
+ * pure evaluator. A rule runs at most once in a pass, which makes malformed
+ * cyclic descriptor graphs fail closed instead of repeatedly overwriting a
+ * user's draft.
+ */
+export declare class FormComputeCoordinator {
+    private readonly runtime;
+    private readonly rules;
+    constructor(rules: readonly ResolvedFormComputeRuleDescriptor[] | undefined, runtime?: FormulaRuntime);
+    applyAfterChange<TDraft extends FormulaRecord>(draft: TDraft, changedFields: readonly string[]): TDraft;
+}

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

@@ -1,9 +1,11 @@
+export { default as ModulePageHost } from './ModulePageHost.vue';
 export { default as DynamicModuleHost } from './DynamicModuleHost.vue';
 export { default as DynamicModulePage } from './DynamicModulePage.vue';
 export { default as DynamicModuleWorkspaceDetailView } from './DynamicModuleWorkspaceDetailView.vue';
 export { customerDescriptor } from './mockDescriptor';
-export { configureModulePageEnhancements, createModulePageEnhancementRegistry, modulePageWorkspaceViews, resolveModulePageEnhancement, } from './modulePageEnhancements';
+export { configureModulePageEnhancementContributions, configureModulePageEnhancements, createModulePageEnhancementRegistry, createReadonlyCardRecordSnapshot, modulePageWorkspaceViews, resolveModulePageEnhancement, } from './modulePageEnhancements';
 export { provideModulePageNavigation, useModulePageNavigation } from './modulePageNavigation';
+export { NAVIGATOR_ENTRY_MODULE_ALIAS_QUERY_KEY, NAVIGATOR_ENTRY_RECORD_ID_QUERY_KEY, } from './navigatorEntrySelection';
 export { createModulePageListRefreshRegistry, modulePageListRefreshRegistry, refreshModulePageList, } from './modulePageListRefresh';
 export type { ModulePageListRefreshRegistry } from './modulePageListRefresh';
-export type { ModuleListEnhancement, ModuleDetailEnhancement, ModulePageActionContext, ModulePageActionContribution, ModulePageActionStateContext, ModulePageBatchActionContext, ModulePageBatchActionContribution, ModulePageColumnContribution, ModulePageDetailDrawer, ModulePageDetailSection, ModulePageDetailSectionContext, ModulePageDrawer, ModulePageDrawerContext, ModulePageEnhancement, ModulePageEnhancementRegistry, ModulePageEnhancementTarget, ModulePageRecordActionContext, ModulePageRecordActionContribution, ModulePageScopeContext, ModulePageWorkspaceView, ModulePageWorkspaceViewInput, } from './modulePageEnhancements';
+export type { ModuleListEnhancement, ModulePageListRowExpansion, ModulePageListRowExpansionContext, ModuleDetailEnhancement, ModulePageFormEnhancement, ModulePageFormContribution, ModulePageFormContributionContext, ModulePageFormContributionState, ModulePageFormFieldPolicy, ModulePageFormContributionLocation, ModulePageFormContributionValidity, ModulePageFormSurface, ModuleCardEnhancement, ModulePageActionContext, ModulePageActionContribution, ModulePageActionStateContext, ModulePageBatchActionContext, ModulePageBatchActionContribution, ModulePageColumnContribution, ModulePageDetailDrawer, ModulePageDetailSection, ModulePageDetailSectionContext, ModulePageDrawer, ModulePageDrawerContext, ModulePageRecordViewContext, ModulePageEnhancement, ModulePageEnhancementActivationContext, ModulePageEnhancementRegistry, ModulePageEnhancementTarget, ModulePageLockedNavigatorEntry, ModulePageCardAssistant, ModulePageCardAssistantContext, ModulePageCardAssistantPlacement, ModulePageRecordActionContext, ModulePageRecordActionContribution, ModulePageScopeContext, ModulePageWorkspaceView, ModulePageWorkspaceViewInput, } from './modulePageEnhancements';

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

@@ -0,0 +1,10 @@
+import type { UserPreferenceStore } from '../web-core/index';
+export declare function listPageSizePreferenceKey(moduleAlias: string): string;
+export declare function normalizeListPageSize(value: unknown, fallback?: number): number;
+/**
+ * A module-list preference is presentation-only. It deliberately remains
+ * separate from the menu UI config and query template, which continue to own
+ * authorized page shape and server-side criteria.
+ */
+export declare function restoreListPageSize(store: UserPreferenceStore, moduleAlias: string, fallback?: number): Promise<number>;
+export declare function saveListPageSize(store: UserPreferenceStore, moduleAlias: string, pageSize: number): Promise<void>;

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

@@ -0,0 +1,12 @@
+export interface ModuleDetailRequestState {
+    activeRequestSequence: number;
+    requestSequence: number;
+}
+export interface ModuleDetailMutationState {
+    hasRecord: boolean;
+    saving: boolean;
+    loading: boolean;
+    loadFailed: boolean;
+}
+export declare function shouldCommitModuleDetailRequest(state: ModuleDetailRequestState): boolean;
+export declare function canMutateModuleDetail(state: ModuleDetailMutationState): boolean;

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

@@ -1,7 +1,8 @@
 import type { Component } from 'vue';
-import type { PageLayoutMode, RouteQueryValue } from '../web-contracts/index';
+import type { CurrentUser, PageDescriptor, PageLayoutMode, RouteQueryValue, WebQueryCondition } from '../web-contracts/index';
 import type { ModuleContext } from '../web-core/index';
-import type { RecordActionItem, RecordQueryListColumn, QueryListRecord } from '../platform-components/index';
+import type { RecordActionItem, RecordFormFieldState, RecordFormFieldValue, RecordQueryListColumn, QueryListRecord } from '../platform-components/index';
+import type { DrawerTitleAction } from '../platform-components/index';
 /**
  * Frontend-owned, constrained composition for a descriptor-driven module page.
  *
@@ -12,8 +13,21 @@ import type { RecordActionItem, RecordQueryListColumn, QueryListRecord } from '.
 export interface ModulePageEnhancement {
     id: string;
     target: ModulePageEnhancementTarget;
+    /**
+     * Optional frontend-owned activation hook for a descriptor page. It may load
+     * auxiliary, already-authorized platform facts used by the enhancement, but
+     * never receives a backend component name or executable descriptor payload.
+     */
+    activate?(context: ModulePageEnhancementActivationContext): void | (() => void);
     list?: ModuleListEnhancement;
     detail?: ModuleDetailEnhancement;
+    /**
+     * Frontend-owned editor content mounted at a typed standard-form boundary.
+     * The backend descriptor never selects a component or supplies executable UI.
+     */
+    form?: ModulePageFormEnhancement;
+    /** Frontend-owned assistant persistently mounted in the standard record card. */
+    card?: ModuleCardEnhancement;
     /**
      * The presentation selected when a user invokes the standard record-view intent.
      *
@@ -22,28 +36,175 @@ export interface ModulePageEnhancement {
      * retains that flow's action checks, shell and lifecycle.
      */
     recordView?: ModulePageRecordView;
-    workspaceViews?: ModulePageWorkspaceView[];
+    /** Restricts standard runner actions for one business-owned entry without replacing the runner. */
+    standardActions?: ModulePageStandardActionsEnhancement;
+    /** Entry-owned adjustments to descriptor-provided navigator presentation and list readiness. */
+    navigator?: ModulePageNavigatorEnhancement;
+    workspaceViews?: ModulePageWorkspaceView<ModulePageWorkspaceViewInput>[];
+}
+export interface ModulePageStandardActionsEnhancement {
+    disabled?: readonly string[];
+}
+export interface ModulePageNavigatorEnhancement {
+    /** Hides descriptor navigators when this entry is not navigated by their business scope. */
+    hidden?: boolean;
+    /** Declares one navigator as an entry-owned, immutable page context. */
+    lockedEntry?: ModulePageLockedNavigatorEntry;
+    /** Allows the standard list to load without navigator-derived list criteria. */
+    bypassListScope?: boolean;
+    /**
+     * Optional business-owned fallback when no navigator item is selected. The platform still owns
+     * navigator rendering and request lifecycle; this hook contributes only typed list conditions.
+     */
+    emptyListScope?(context: ModulePageEmptyNavigatorScopeContext): readonly WebQueryCondition[] | undefined;
+}
+export interface ModulePageLockedNavigatorEntry {
+    /** Descriptor navigator key whose selection is supplied by the page address. */
+    navigatorKey: string;
+    /** Text shown if the addressed record cannot be resolved or authorized. */
+    unavailableDescription: string;
+}
+export interface ModulePageEmptyNavigatorScopeContext {
+    currentUser?: CurrentUser;
+    selectedNavigatorRecords: Readonly<Record<string, QueryListRecord | undefined>>;
 }
 export interface ModulePageEnhancementTarget {
     moduleAlias: string;
     /** Omit to apply to every list view of the module. */
     viewCode?: string;
+    /** Omit to apply to every visible menu entry of the module. */
+    menuId?: string;
+}
+export interface ModulePageEnhancementActivationContext {
+    module: ModuleContext<QueryListRecord>;
 }
 export interface ModuleListEnhancement {
     actions?: ModulePageActionContribution[];
     columns?: ModulePageColumnContribution[];
     /** Replaces the visual renderer of a descriptor-owned column without adding a duplicate column. */
     cellComponents?: ModulePageCellComponentContribution[];
+    /**
+     * Application-owned content for the platform list's expanded-row boundary.
+     *
+     * This is deliberately separate from descriptor relation expansions: use it
+     * for authorized business projections that are not a standard child relation.
+     * The runtime owns expansion state and table rendering; the application owns
+     * only the trusted Vue component and its auxiliary reads/actions.
+     */
+    rowExpansion?: ModulePageListRowExpansion;
     /** Width of the list's fixed operation column; defaults to the platform compact width. */
     actionColumnWidth?: string | number;
     rowActions?: ModulePageRecordActionContribution[];
     batchActions?: ModulePageBatchActionContribution[];
 }
+export interface ModulePageListRowExpansion {
+    key: string;
+    component: Component;
+}
+export interface ModulePageListRowExpansionContext {
+    module: ModuleContext<QueryListRecord>;
+    /** Detached snapshot of the record being expanded. */
+    record: Readonly<QueryListRecord>;
+    expanded: boolean;
+    /** Reloads the standard list without giving the extension ownership of its query state. */
+    refreshList(): void;
+}
 /** Actions appended to the standard record-detail operation area in view mode. */
 export interface ModuleDetailEnhancement {
     actions?: ModulePageRecordActionContribution[];
     sections?: ModulePageDetailSection[];
 }
+/** A controlled addition to the descriptor-owned standard form, not a replacement editor. */
+export interface ModulePageFormEnhancement {
+    contributions: ModulePageFormContribution[];
+    fieldPolicies?: ModulePageFormFieldPolicy[];
+}
+/** The platform-owned record-card form surface, regardless of its outer page shell. */
+export type ModulePageFormSurface = 'record-card';
+/**
+ * A contribution can target an entire semantic form section or the immediate
+ * boundary before/after one descriptor-owned field. The host owns all other
+ * rendering, codecs, permissions, requests and save lifecycle.
+ */
+export interface ModulePageFormContribution {
+    key: string;
+    component: Component;
+    location: ModulePageFormContributionLocation;
+}
+export type ModulePageFormContributionLocation = {
+    surface: ModulePageFormSurface;
+    section: 'before-fields' | 'after-fields';
+} | {
+    surface: ModulePageFormSurface;
+    fieldName: string;
+    placement: 'before' | 'after';
+};
+/** The only form state exposed to application-owned editor contributions. */
+export interface ModulePageFormContributionContext {
+    mode: 'create' | 'edit' | 'view';
+    /** A detached, deeply frozen draft snapshot. */
+    draft: Readonly<Record<string, unknown>>;
+    /** Descriptor-resolved field states; never a mutable draft or HTTP client. */
+    fields: readonly Readonly<RecordFormFieldState>[];
+    /** The field at a field-boundary location, otherwise undefined. */
+    field?: Readonly<RecordFormFieldState>;
+    setField(fieldName: string, value: RecordFormFieldValue): void;
+    formSessionKey: number;
+    /** Reports only this contribution's validation fact to the standard save boundary. */
+    reportValidity(validity: ModulePageFormContributionValidity): void;
+}
+export interface ModulePageFormContributionValidity {
+    valid: boolean;
+    errors?: Record<string, string>;
+}
+/** Read-only facts consumable by a descriptor-field presentation policy. */
+export interface ModulePageFormContributionState {
+    mode: 'create' | 'edit' | 'view';
+    draft: Readonly<Record<string, unknown>>;
+    fields: readonly Readonly<RecordFormFieldState>[];
+    formSessionKey: number;
+}
+/**
+ * A typed visual policy around one descriptor-owned field. The platform keeps
+ * transport, file upload and field codecs inside the standard renderer.
+ */
+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;
+}
+/** Frontend-owned auxiliary UI adjacent to the descriptor-owned record card. */
+export interface ModuleCardEnhancement {
+    assistant: ModulePageCardAssistant;
+}
+export interface ModulePageCardAssistant {
+    /** A source component; backend descriptors never select or name it. */
+    component: Component;
+    /** Explicitly anchors the component to the standard record-card boundary. */
+    placement: ModulePageCardAssistantPlacement;
+}
+export interface ModulePageCardAssistantPlacement {
+    /** `inside` shares the record-card content scrollbar; `outside` remains a sibling surface. */
+    boundary: 'inside' | 'outside';
+    /** Position relative to that boundary; never inserted between descriptor-owned fields. */
+    position: 'top' | 'bottom';
+}
+export interface ModulePageCardAssistantContext {
+    module: ModuleContext<QueryListRecord>;
+    mode: 'view' | 'create' | 'edit';
+    /** Detached and deeply frozen current record or form draft. It may be absent before selection. */
+    record?: Readonly<Record<string, unknown>>;
+    /**
+     * Detached snapshot of records already loaded by the standard explorer.
+     * This never triggers an auxiliary request and may be bounded by the explorer.
+     */
+    loadedRecords: readonly Readonly<Record<string, unknown>>[];
+    formSessionKey: number;
+    saving: boolean;
+    loading: boolean;
+    loadFailed: boolean;
+}
 /** Application-owned presentation of the platform's standard record-view intent. */
 export interface ModulePageRecordView {
     /**
@@ -87,7 +248,7 @@ export interface ModulePageDetailSection {
 }
 /** Business content rendered inside the platform-owned standard view drawer. */
 export interface ModulePageDetailDrawer {
-    /** The component receives only the documented ModulePageDrawerContext prop. */
+    /** The component receives only the documented read-only ModulePageRecordViewContext prop. */
     component: Component;
     /** Keeps the platform drawer shell while allowing dense business views more room. */
     width?: number | string;
@@ -115,7 +276,10 @@ export interface ModulePageDrawer {
     /** The component receives only the documented ModulePageDrawerContext prop. */
     component: Component;
 }
-export type ModulePageWorkspaceViewInput = Record<string, RouteQueryValue>;
+/** A business-owned action rendered by the platform in a semantic drawer region. */
+export type ModulePageDrawerAction = DrawerTitleAction;
+/** Matches the Workbench input boundary; `parse` remains responsible for route-value validation. */
+export type ModulePageWorkspaceViewInput = object;
 /** A business-owned view with stable, serializable identity. */
 export interface ModulePageWorkspaceView<TInput extends ModulePageWorkspaceViewInput = ModulePageWorkspaceViewInput> {
     type: string;
@@ -134,6 +298,29 @@ export interface ModulePageDrawerContext {
     scope?: ModulePageScopeContext;
     /** Reloads only the current list query and preserves its query and editor state. */
     refreshList(): void;
+    /** Invalidates frontend-owned detail sections for the current record. */
+    refreshDetailExtensions(): void;
+    /** Blocks the drawer shell's close affordances while a contributed operation is in flight. */
+    setCloseBlocked(blocked: boolean): void;
+    close(): void;
+    reload(): void;
+    /** Replaces contextual actions beside the drawer title; actions are cleared with the drawer. */
+    setTitleActions(actions: ModulePageDrawerAction[]): void;
+}
+/**
+ * Context for a custom body inside the platform-owned record-view shell.
+ *
+ * A record-view body does not own the drawer chrome. In particular it cannot
+ * replace title actions or block the shell from closing; those facilities are
+ * reserved for an action-opened ModulePageDrawer, whose operation lifecycle is
+ * explicitly governed by the platform drawer runtime.
+ */
+export interface ModulePageRecordViewContext {
+    module: ModuleContext<QueryListRecord>;
+    record: QueryListRecord;
+    scope?: ModulePageScopeContext;
+    refreshList(): void;
+    refreshDetailExtensions(): void;
     close(): void;
     reload(): void;
 }
@@ -145,6 +332,8 @@ export interface ModulePageActionContext {
     refreshList(): void;
     openDrawer(drawer: ModulePageDrawer): void;
     openWorkspaceTab<TInput extends ModulePageWorkspaceViewInput>(view: ModulePageWorkspaceView<TInput>, input: TInput): void;
+    /** Opens an existing, platform-owned page descriptor through the Workbench. */
+    openPage(descriptor: PageDescriptor): void;
     reload(): void;
 }
 /** Read-only scope state supplied by a descriptor-owned scoped list workspace. */
@@ -169,14 +358,31 @@ export interface ModulePageDetailSectionContext {
     record: QueryListRecord;
     /** Reloads only the current list query and preserves its query and editor state. */
     refreshList(): void;
+    /** Monotonic invalidation fact for frontend-owned detail data. */
+    refreshKey: number;
     reload(): void;
 }
 export interface ModulePageEnhancementRegistry {
-    resolve(moduleAlias: string, viewCode?: string): ModulePageEnhancement | undefined;
-    workspaceViews(): readonly ModulePageWorkspaceView[];
+    resolve(moduleAlias: string, viewCode?: string, menuId?: string): ModulePageEnhancement | undefined;
+    workspaceViews(): readonly ModulePageWorkspaceView<ModulePageWorkspaceViewInput>[];
 }
 export declare function createModulePageEnhancementRegistry(enhancements: readonly ModulePageEnhancement[]): ModulePageEnhancementRegistry;
-/** Configure once from the consuming application's composition root. */
+/**
+ * Replaces one owner's contribution set while retaining every other owner.
+ *
+ * This is the composition API for first-party defaults and consuming
+ * applications. Multiple owners may contribute to the same module target;
+ * their independent regions are merged and conflicting regions fail fast.
+ */
+export declare function configureModulePageEnhancementContributions(owner: string, enhancements: readonly ModulePageEnhancement[]): void;
+/**
+ * Legacy application composition API. It replaces only the legacy
+ * application's contribution set; first-party and named-owner defaults remain
+ * registered. New composition roots should use
+ * configureModulePageEnhancementContributions(owner, enhancements).
+ */
 export declare function configureModulePageEnhancements(enhancements: readonly ModulePageEnhancement[]): void;
-export declare function resolveModulePageEnhancement(moduleAlias: string, viewCode?: string): ModulePageEnhancement | undefined;
+export declare function resolveModulePageEnhancement(moduleAlias: string, viewCode?: string, menuId?: string): ModulePageEnhancement | undefined;
 export declare function modulePageWorkspaceViews(): readonly ModulePageWorkspaceView<ModulePageWorkspaceViewInput>[];
+/** Creates the only record shape that a card assistant may receive. */
+export declare function createReadonlyCardRecordSnapshot(record: Record<string, unknown>): Readonly<Record<string, unknown>>;

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

@@ -0,0 +1,18 @@
+import type { RouteQueryValue } from '../web-contracts/index';
+/**
+ * Controlled module-page entries may nominate one navigator source record.
+ * These are framework query keys, deliberately separate from a module's
+ * business query fields and from the navigator REFERENCE transport.
+ */
+export declare const NAVIGATOR_ENTRY_MODULE_ALIAS_QUERY_KEY = "_muyunNavigatorModuleAlias";
+export declare const NAVIGATOR_ENTRY_RECORD_ID_QUERY_KEY = "_muyunNavigatorRecordId";
+export interface NavigatorEntrySelection {
+    moduleAlias: string;
+    recordId: string;
+    identity: string;
+}
+/**
+ * Accept only the complete scalar pair. A malformed public address must leave
+ * the page in its normal, unselected state rather than guessing a scope.
+ */
+export declare function navigatorEntrySelectionOf(params: Record<string, RouteQueryValue> | undefined): NavigatorEntrySelection | undefined;

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

@@ -0,0 +1,6 @@
+import type { ResolvedPageNavigatorLevelDescriptor } from '../web-contracts/index';
+/**
+ * A tenant user's sole tenant is a fixed request scope, while a system user has no session
+ * tenant and may choose from the tenant records allowed by the source REFERENCE action.
+ */
+export declare function shouldHideSingleResultNavigator(level: ResolvedPageNavigatorLevelDescriptor, singleResult: boolean, sessionTenantId: string | undefined): boolean;

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

@@ -1,6 +1,14 @@
 import type { ResolvedPageContextBindingDescriptor } from '../web-contracts/index';
 export type PageContextSourceValues = Partial<Record<ResolvedPageContextBindingDescriptor['source'], Record<string, unknown>>>;
 /** Returns context fields that must be supplied by the browser for a query target. */
-export declare function externalPageContextCriteriaKeys(bindings: ResolvedPageContextBindingDescriptor[], target: ResolvedPageContextBindingDescriptor['target']): string[];
+export declare function externalPageContextCriteriaKeys(bindings: readonly ResolvedPageContextBindingDescriptor[], target: ResolvedPageContextBindingDescriptor['target'], targetNavigatorLevelKey?: string): string[];
+/** Browser-provided navigator keys that must be selected before a page list may query. */
+export declare function requiredNavigatorListScopeCriteriaKeys(bindings: readonly ResolvedPageContextBindingDescriptor[]): string[];
 /** Resolves declared context flows without coupling a target to navigator UI state. */
-export declare function resolvePageContextTargetValues(bindings: ResolvedPageContextBindingDescriptor[], target: ResolvedPageContextBindingDescriptor['target'], sourceValues: PageContextSourceValues, targetNavigatorLevelKey?: string): Record<string, unknown> | undefined;
+export declare function resolvePageContextTargetValues(bindings: readonly ResolvedPageContextBindingDescriptor[], target: ResolvedPageContextBindingDescriptor['target'], sourceValues: PageContextSourceValues, targetNavigatorLevelKey?: string): Record<string, unknown> | undefined;
+/**
+ * Query scopes are values, not refresh signals. Preserve the prior object when
+ * a render reconstructs the same flat criteria so consumers do not reload just
+ * because their parent component rendered for an unrelated state transition.
+ */
+export declare function reuseEquivalentQueryValues(previous: Record<string, unknown> | undefined, next: Record<string, unknown> | undefined): Record<string, unknown> | undefined;

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

@@ -0,0 +1,13 @@
+import type { RecordExplorerItemDescriptor } from '../platform-components/index';
+import type { RecordInlineAction } from '../web-contracts/index';
+export interface NavigatorItemRecord {
+    id?: string;
+    title?: string;
+    name?: string;
+    code?: string;
+    alias?: string;
+}
+/** 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;

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

@@ -1,4 +1,13 @@
 export type RecordDetailMode = 'create' | 'edit' | 'view';
+export type RecordDetailCancelDestination = 'close' | 'restore-view';
+export interface RecordDetailTransitionOptions {
+    /**
+     * The detail surface to return to when the user cancels the operation.
+     * A row action starts an independent task and closes; an edit launched from
+     * an open detail returns to that detail view.
+     */
+    cancelDestination?: RecordDetailCancelDestination;
+}
 /**
  * State transitions shared by descriptor-driven record detail surfaces.
  * Containers own their layout; this controller owns only one record's
@@ -14,12 +23,12 @@ export declare function useRecordDetailController<TRecord extends Record<string,
     saving: import("vue").Ref<boolean, boolean>;
     togglingEnabled: import("vue").Ref<boolean, boolean>;
     formSessionKey: import("vue").Ref<number, number>;
-    beginLoad: (next: TRecord, nextMode: Extract<RecordDetailMode, "edit" | "view">) => void;
+    beginLoad: (next: TRecord, nextMode: Extract<RecordDetailMode, "edit" | "view">, options?: RecordDetailTransitionOptions) => void;
     resolveLoad: (next: TRecord) => void;
     failLoad: () => void;
     finishLoad: () => void;
-    beginCreate: (initial: TRecord) => void;
-    beginEdit: () => boolean;
+    beginCreate: (initial: TRecord, options?: RecordDetailTransitionOptions) => void;
+    beginEdit: (options?: RecordDetailTransitionOptions) => boolean;
     cancelEdit: () => void;
     applySaved: (next: TRecord) => void;
     clearDeleted: () => void;

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

@@ -0,0 +1,9 @@
+import { FormulaRuntime, type FormulaRecord } from '../formula/FormulaRuntime';
+import type { ResolvedDetailRelationFormComputeRuleDescriptor } from '../web-contracts/index';
+/** Propagates server-compiled calculations after a user changes one embedded child row. */
+export declare class RelationFormComputeCoordinator {
+    private readonly rules;
+    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[];
+}

package/dist/types/formula/FormulaRuntime.d.ts

@@ -0,0 +1,29 @@
+import type { FormulaProgram, ViewFieldValueType } from '../web-contracts/index';
+export type FormulaRecord = Record<string, unknown>;
+export type FormulaComputePatch = Readonly<Record<string, FormulaValue>>;
+export interface FormulaComputeResult {
+    readonly patch: FormulaComputePatch;
+    readonly changedFields: readonly string[];
+}
+/**
+ * Browser-local executor for server-issued FormulaProgram values.
+ *
+ * It deliberately accepts no source expression. Unknown program versions, profiles and node shapes fail closed.
+ */
+export declare class FormulaRuntime {
+    evaluateWebUi(program: FormulaProgram | undefined, record: FormulaRecord): boolean;
+    /**
+     * Evaluates one server-issued FORM_COMPUTE assignment against a draft without mutating it.
+     * Applying the returned patch, ordering rules, and user-value ownership remain form-runtime concerns.
+     */
+    evaluateFormCompute(program: FormulaProgram | undefined, draft: FormulaRecord, targetValueType?: ViewFieldValueType): FormulaComputeResult;
+    /** Evaluates a row-to-row assignment in the changed row's scope without mutating any drafts. */
+    evaluateRelationFormCompute(program: FormulaProgram | undefined, draft: FormulaRecord, targetField: string, targetValueType?: ViewFieldValueType): FormulaComputeResult;
+    private evaluateNode;
+    private toBoolean;
+    private evaluateComputeNode;
+}
+type FormulaValue = string | number | boolean | null | undefined;
+/** Mirrors FormulaEngine.equalsLoose for the primitive values admitted by the WEB_UI profile. */
+export declare function equalsFormulaLoose(left: unknown, right: unknown): boolean;
+export {};

package/dist/types/platform-admin-runtime/WorkspaceViewDrawer.vue.d.ts

@@ -3,6 +3,7 @@ import type { WorkspaceDrawerProfile } from './workspaceViewContract';
 type __VLS_Props = {
     open: boolean;
     title: string;
+    container: HTMLElement | null;
     subtitle?: string;
     profile?: WorkspaceDrawerProfile;
     promotion?: DrawerPromotion;

package/dist/types/{views/SystemUserManagementView.vue.d.ts → platform-admin-runtime/employee/EmployeeAccountDrawer.vue.d.ts}

@@ -1,6 +1,6 @@
+import type { ModulePageDrawerContext } from '../../dynamic-page-runtime/index';
 type __VLS_Props = {
-    recordId?: string;
-    mode?: 'view' | 'edit';
+    context: ModulePageDrawerContext;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/types/platform-admin-runtime/employeeModulePageEnhancement.d.ts

@@ -0,0 +1,3 @@
+import type { ModulePageEnhancement } from '../dynamic-page-runtime/index';
+/** The employee page remains platform-owned; only account provisioning needs a domain drawer. */
+export declare const employeeModulePageEnhancement: ModulePageEnhancement;

package/dist/types/platform-admin-runtime/index.d.ts

@@ -6,7 +6,7 @@
  * directory: an App supplies its startup state, navigation and HTTP factory.
  */
 export { default as PlatformAdminRouteOutlet } from './PlatformAdminOutlet.vue';
-export { isPlatformAdminRoutePage, platformAdminDynamicModuleRoutes, platformAdminModuleRoutes, platformAdminRouteLayouts, platformAdminRoutePrefixes, platformAdminRoutes, resolvePlatformAdminRoute, } from './platformAdminRoutes';
+export { isPlatformAdminRoutePage, platformAdminModuleRoutes, platformAdminRouteLayouts, platformAdminRoutePrefixes, platformAdminRoutes, resolvePlatformAdminRoute, } from './platformAdminRoutes';
 export type { PlatformAdminRoute } from './platformAdminRoutes';
 export { provideCurrentUserContext, useCurrentUserContext } from './currentUserContext';
 export { createBackendHttpClient } from './backendHttp';

package/dist/types/platform-admin-runtime/moduleOpenApi.d.ts

@@ -14,6 +14,8 @@ export interface ModuleOpenApiDocument {
 export declare function moduleAliasFromOpenApiPath(pathname: string): string | undefined;
 /** Creates the workbench page contract for one module's authenticated API document. */
 export declare function createModuleOpenApiPageDescriptor(moduleAlias: string, moduleTitle?: string): PageDescriptor;
+/** Creates the authenticated OpenAPI directory as an ordinary workbench page. */
+export declare function createOpenApiCatalogPageDescriptor(): PageDescriptor;
 /** Recognizes the app-owned OpenAPI tab without teaching the shared route resolver about this feature. */
 export declare function isModuleOpenApiPage(descriptor?: PageDescriptor): boolean;
 export declare function isOpenApiCatalogPath(pathname: string): boolean;

package/dist/types/platform-admin-runtime/passwordPolicyPageEnhancement.d.ts

@@ -0,0 +1,6 @@
+import type { ModulePageEnhancement } from '../dynamic-page-runtime/index';
+/**
+ * IAM-owned card assistance for the standard password-policy module page.
+ * The component is selected by frontend source composition; no backend DSL can inject executable UI.
+ */
+export declare const passwordPolicyPageEnhancement: ModulePageEnhancement;

package/dist/types/platform-admin-runtime/platformAdminRoutes.d.ts

@@ -1,4 +1,4 @@
-import type { Component } from 'vue';
+import { type Component } from 'vue';
 import type { BusinessRoutePageDescriptor, PageDescriptor, PageLayoutMode } from '../web-contracts/index';
 export interface PlatformAdminRoute {
     route: string;
@@ -11,11 +11,6 @@ export interface PlatformAdminRoute {
 }
 export declare const platformAdminRoutes: PlatformAdminRoute[];
 export declare const platformAdminRoutePrefixes: string[];
-/**
- * Retains readable legacy menu URLs while delegating their content to the standard module runner.
- * These are deliberately separate from `platformAdminRoutes`: no business-owned Vue page exists.
- */
-export declare const platformAdminDynamicModuleRoutes: Record<string, string>;
 export declare const platformAdminModuleRoutes: {
     [k: string]: string;
 };

package/dist/types/platform-admin-runtime/platformModulePageEnhancement.d.ts

@@ -0,0 +1,15 @@
+import type { ModulePageEnhancement } from '../dynamic-page-runtime/index';
+/**
+ * Frontend composition for the platform-module descriptor page.
+ *
+ * These actions deliberately reuse ordinary workspace/page descriptors. The
+ * backend UI descriptor only describes the module record; it never chooses a
+ * Vue component or arbitrary client-side behavior.
+ */
+export declare const platformModulePageEnhancement: ModulePageEnhancement;
+/**
+ * Action management has no menu identity of its own. Its standard CRUD page is
+ * entered from exactly one governed platform module, which is the hidden and
+ * immutable navigator scope.
+ */
+export declare const platformModuleActionPageEnhancement: ModulePageEnhancement;

package/dist/types/{views/EmployeeManagementView.vue.d.ts → platform-admin-runtime/tenant/TenantApplicationConfigurationDrawer.vue.d.ts}

@@ -1,6 +1,6 @@
+import type { ModulePageDrawerContext } from '../../dynamic-page-runtime/index';
 type __VLS_Props = {
-    recordId?: string;
-    mode?: 'view' | 'edit';
+    context: ModulePageDrawerContext;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;