@ximatai/muyun-web-app 0.26.7 → 0.26.9

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

@@ -0,0 +1,22 @@
+import type { ModuleContext } from '../../web-core/index';
+interface DetailController<TRecord> {
+    beginLoad(record: TRecord, mode: 'edit' | 'view'): 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", skipLoad?: boolean) => Promise<void>;
+    openRecycleBinRecord: (record: TRecord) => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,10 @@
+import type { UserPreferenceStore } from '../web-core/index';
+export type DetailSurfacePreference = 'drawer' | 'pinned';
+export declare function detailSurfacePreferenceKey(moduleAlias: string): string;
+export declare function normalizeDetailSurfacePreference(value: unknown): DetailSurfacePreference | undefined;
+/**
+ * Restores an account-scoped choice while retaining the device-local value as
+ * a resilient fallback when the preference service is temporarily unavailable.
+ */
+export declare function restoreDetailSurfacePreference(store: UserPreferenceStore, moduleAlias: string): Promise<DetailSurfacePreference | undefined>;
+export declare function saveDetailSurfacePreference(store: UserPreferenceStore, moduleAlias: string, preference: DetailSurfacePreference): Promise<void>;

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,8 +1,10 @@
+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 { createModulePageListRefreshRegistry, modulePageListRefreshRegistry, refreshModulePageList, } from './modulePageListRefresh';
 export type { ModulePageListRefreshRegistry } from './modulePageListRefresh';
-export type { ModuleListEnhancement, ModuleDetailEnhancement, ModulePageActionContext, ModulePageActionContribution, ModulePageActionStateContext, ModulePageBatchActionContext, ModulePageBatchActionContribution, ModulePageColumnContribution, 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, 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 { PageDescriptor, PageLayoutMode, RouteQueryValue } 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,30 +13,184 @@ 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;
-    workspaceViews?: ModulePageWorkspaceView[];
+    /**
+     * 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.
+     *
+     * Both the platform "查看" action and a list double-click enter the same record
+     * view flow. Applications may replace only the drawer body, while the runtime
+     * retains that flow's action checks, shell and lifecycle.
+     */
+    recordView?: ModulePageRecordView;
+    workspaceViews?: ModulePageWorkspaceView<ModulePageWorkspaceViewInput>[];
 }
 export interface ModulePageEnhancementTarget {
     moduleAlias: string;
     /** Omit to apply to every list view of the module. */
     viewCode?: 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 {
+    /**
+     * Replaces the descriptor-generated detail body while retaining the platform
+     * view drawer, its list entry points, and its lifecycle.
+     *
+     * A custom drawer body is intentionally read-only from the platform's point
+     * of view: generic edit and enable/disable controls are withheld so that the
+     * business module owns every operation it exposes in the view.
+     */
+    drawer: ModulePageDetailDrawer;
+    /**
+     * Optional record-level business grant required in addition to the standard
+     * view entry point. This protects business drawer data without turning its
+     * custom endpoints into a second "查看" UI action.
+     */
+    authorizationActionCode?: string;
+}
 export interface ModulePageActionContribution extends RecordActionItem {
     key: string;
     /** Authorizes this toolbar action against the selected scoped-list record instead of the page module. */
@@ -59,6 +214,18 @@ export interface ModulePageDetailSection {
     title: string;
     component: Component;
 }
+/** Business content rendered inside the platform-owned standard view drawer. */
+export interface ModulePageDetailDrawer {
+    /** 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;
+    /**
+     * Defaults to true. Set false when the business detail body has its own
+     * governed read endpoint and only needs the selected list record as context.
+     */
+    loadRecord?: boolean;
+}
 export interface ModulePageColumnContribution extends RecordQueryListColumn {
     key: string;
     /** Insert adjacent to a descriptor column. Omit to append after descriptor columns. */
@@ -77,7 +244,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;
@@ -96,6 +266,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;
 }
@@ -107,6 +300,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. */
@@ -131,14 +326,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[];
+    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 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/modulePageNavigation.d.ts

@@ -5,7 +5,7 @@ export interface ModulePageNavigation {
     openPage(descriptor: PageDescriptor): {
         created: boolean;
     };
-    openWorkspaceTab<TInput extends ModulePageWorkspaceViewInput>(view: ModulePageWorkspaceView<TInput>, input: TInput): void;
+    openWorkspaceTab<TInput extends ModulePageWorkspaceViewInput>(view: ModulePageWorkspaceView<TInput>, input: TInput, title?: string): void;
 }
 export declare function provideModulePageNavigation(navigation: ModulePageNavigation | undefined): void;
 export declare function useModulePageNavigation(): ModulePageNavigation | 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

@@ -0,0 +1,6 @@
+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: readonly ResolvedPageContextBindingDescriptor[], target: ResolvedPageContextBindingDescriptor['target'], targetNavigatorLevelKey?: string): string[];
+/** Resolves declared context flows without coupling a target to navigator UI state. */
+export declare function resolvePageContextTargetValues(bindings: readonly ResolvedPageContextBindingDescriptor[], target: ResolvedPageContextBindingDescriptor['target'], sourceValues: PageContextSourceValues, targetNavigatorLevelKey?: string): Record<string, unknown> | undefined;

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

@@ -0,0 +1,35 @@
+export type RecordDetailMode = 'create' | 'edit' | 'view';
+export interface RecordDetailCreateOptions<TRecord> {
+    /**
+     * The already selected detail to reinstate if the user abandons this new
+     * draft. It is deliberately held outside `record`: while creating, the
+     * detail surface must not accidentally expose actions for the prior record.
+     */
+    restoreRecord?: TRecord;
+}
+/**
+ * State transitions shared by descriptor-driven record detail surfaces.
+ * Containers own their layout; this controller owns only one record's
+ * lifecycle and deliberately contains no drawer, tab or list concerns.
+ */
+export declare function useRecordDetailController<TRecord extends Record<string, unknown>>(): {
+    record: import("vue").Ref<TRecord | undefined, TRecord | undefined>;
+    draft: import("vue").Ref<TRecord | undefined, TRecord | undefined>;
+    mode: import("vue").Ref<RecordDetailMode, RecordDetailMode>;
+    open: import("vue").Ref<boolean, boolean>;
+    loading: import("vue").Ref<boolean, boolean>;
+    loadFailed: import("vue").Ref<boolean, boolean>;
+    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;
+    resolveLoad: (next: TRecord) => void;
+    failLoad: () => void;
+    finishLoad: () => void;
+    beginCreate: (initial: TRecord, options?: RecordDetailCreateOptions<TRecord>) => void;
+    beginEdit: () => boolean;
+    cancelEdit: () => void;
+    applySaved: (next: TRecord) => void;
+    clearDeleted: () => void;
+    close: () => 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/EmployeeDetailWorkspaceView.vue.d.ts → platform-admin-runtime/employee/EmployeeAccountDrawer.vue.d.ts}

@@ -1,5 +1,6 @@
+import type { ModulePageDrawerContext } from '../../dynamic-page-runtime/index';
 type __VLS_Props = {
-    recordId: string;
+    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/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;

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

@@ -0,0 +1,9 @@
+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;

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

@@ -1,5 +1,5 @@
 import { type RealtimeConnectionState } from '../web-core/index';
-import type { WebBusinessRealtimeEvent, WebCommittedChangeSet, WebUserNotification } from '../web-contracts/index';
+import type { WebBusinessRealtimeEvent, WebBusinessNotification, WebCommittedChangeSet, WebUserNotification } from '../web-contracts/index';
 export declare const appDataChangeDispatcher: import("../web-core/index").DataChangeDispatcher;
 export interface AppRealtimeOptions {
     /** Backend origin supplied by the consuming App at runtime. */
@@ -8,6 +8,7 @@ export interface AppRealtimeOptions {
     token?: string;
     onUnauthorized?: () => void;
     onUserNotification?: (notification: WebUserNotification) => void;
+    onBusinessNotification?: (notification: WebBusinessNotification) => void;
     onStateChange?: (state: RealtimeConnectionState) => void;
 }
 export interface AppRealtimeConnection {

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

@@ -0,0 +1,7 @@
+import type { ModulePageDrawerContext } from '../../dynamic-page-runtime/index';
+type __VLS_Props = {
+    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;
+export default _default;

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

@@ -0,0 +1,7 @@
+import type { ModulePageDetailSectionContext } from '../../dynamic-page-runtime/index';
+type __VLS_Props = {
+    context: ModulePageDetailSectionContext;
+};
+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;
+export default _default;

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

@@ -0,0 +1,7 @@
+import type { ModulePageEnhancement } from '../dynamic-page-runtime/index';
+/**
+ * IAM-specific presentation around the descriptor-owned tenant CRUD surface.
+ * Standard records remain owned by ModulePageHost; this contribution only
+ * renders the tenant application's authorized child-resource capability.
+ */
+export declare const tenantModulePageEnhancement: ModulePageEnhancement;

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

@@ -0,0 +1,8 @@
+import type { QueryListRecord, RecordQueryListColumn } from '../../platform-components/index';
+type __VLS_Props = {
+    record: QueryListRecord;
+    column?: RecordQueryListColumn;
+};
+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;
+export default _default;