@ximatai/muyun-web-app 0.26.14 → 0.26.16

package/dist/types/views/MetadataSourceTree.vue.d.ts

@@ -3,6 +3,7 @@ type __VLS_Props = {
     nodes: UiTreeNode[];
     title?: string;
     embedded?: boolean;
+    utilityPlacement?: 'header' | 'toolbar';
     searchKeyword?: string;
     showSystemFields?: boolean;
     searchable?: boolean;
@@ -11,9 +12,11 @@ type __VLS_Props = {
     unavailable?: boolean;
     unavailableDescription?: string;
 };
-declare var __VLS_34: {};
+declare var __VLS_12: {}, __VLS_37: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_34) => any;
+    title?: (props: typeof __VLS_12) => any;
+} & {
+    default?: (props: typeof __VLS_37) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     refresh: () => any;
@@ -24,15 +27,14 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     "onUpdate:searchKeyword"?: ((value: string) => any) | undefined;
     "onUpdate:showSystemFields"?: ((value: boolean) => any) | undefined;
 }>, {
-    title: string;
     loading: boolean;
     unavailable: boolean;
     embedded: boolean;
+    searchable: boolean;
     refreshDisabled: boolean;
     searchKeyword: string;
-    searchable: boolean;
+    utilityPlacement: "header" | "toolbar";
     showSystemFields: boolean;
-    unavailableDescription: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/views/ModuleRuntimeActivationStatus.vue.d.ts

@@ -0,0 +1,11 @@
+import { type ModuleActivationFeedback } from './moduleRuntimeActivation';
+type __VLS_Props = {
+    moduleAlias: string;
+    reloadKey?: number;
+};
+declare function load(): Promise<ModuleActivationFeedback | undefined>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    refresh: typeof load;
+}, {}, {}, {}, 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/views/PageCompositionDescriptorPreview.vue.d.ts

@@ -24,10 +24,6 @@ type __VLS_Props = {
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     selectField: (slot: PreviewSlot, fieldName: string) => any;
     configureField: (slot: PreviewSlot, fieldName: string) => any;
-    configureRelationField: (relationCode: string, fieldName: string) => any;
-    configureAction: (anchor: "page" | "form" | "detail", actionCode: string) => any;
-    configureSummaries: () => any;
-    "placement-drop": (source: CompositionPlacementSource, target: CompositionPlacementTarget) => any;
     "action-drop": (source: {
         actionCode: string;
         sourceAnchor?: "page" | "detail" | "form";
@@ -35,13 +31,13 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
         anchor: "page" | "detail" | "form";
         index: number;
     }) => any;
+    configureRelationField: (relationCode: string, fieldName: string) => any;
+    configureAction: (anchor: "form" | "page" | "detail", actionCode: string) => any;
+    configureSummaries: () => any;
+    "placement-drop": (source: CompositionPlacementSource, target: CompositionPlacementTarget) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onSelectField?: ((slot: PreviewSlot, fieldName: string) => any) | undefined;
     onConfigureField?: ((slot: PreviewSlot, fieldName: string) => any) | undefined;
-    onConfigureRelationField?: ((relationCode: string, fieldName: string) => any) | undefined;
-    onConfigureAction?: ((anchor: "page" | "form" | "detail", actionCode: string) => any) | undefined;
-    onConfigureSummaries?: (() => any) | undefined;
-    "onPlacement-drop"?: ((source: CompositionPlacementSource, target: CompositionPlacementTarget) => any) | undefined;
     "onAction-drop"?: ((source: {
         actionCode: string;
         sourceAnchor?: "page" | "detail" | "form";
@@ -49,6 +45,10 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
         anchor: "page" | "detail" | "form";
         index: number;
     }) => any) | undefined;
+    onConfigureRelationField?: ((relationCode: string, fieldName: string) => any) | undefined;
+    onConfigureAction?: ((anchor: "form" | "page" | "detail", actionCode: string) => any) | undefined;
+    onConfigureSummaries?: (() => any) | undefined;
+    "onPlacement-drop"?: ((source: CompositionPlacementSource, target: CompositionPlacementTarget) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/views/PageCompositionEditor.vue.d.ts

@@ -0,0 +1,10 @@
+import type { PageCompositionSession } from './pageCompositionSession';
+type __VLS_Props = {
+    session: PageCompositionSession;
+    retained?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    retained: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/views/PageCompositionTree.vue.d.ts

@@ -2,6 +2,9 @@ import { type CompositionSkeleton, type PageCompositionActionPlacement } from '.
 import { type PageComposerFormItem, type PageComposerField, type PageComposerGroup, type PageComposerRelation, type PageQuerySummary } from './pageCompositionDraftState';
 import { type PageCompositionDragPayload } from './pageCompositionDragPayload';
 type __VLS_Props = {
+    layoutTitle?: string;
+    hideList?: boolean;
+    separateDetail?: boolean;
     skeleton?: CompositionSkeleton;
     explorerTitle?: string;
     searchableFieldIds?: string[];
@@ -32,7 +35,7 @@ type __VLS_Props = {
     selectedKey?: string;
     disabled?: boolean;
 };
-type ComposerNodeAction = 'configure' | 'remove' | 'add-group' | 'toggle-visibility';
+type ComposerNodeAction = 'configure' | 'remove' | 'add-group' | 'toggle-visibility' | 'split-layout' | 'merge-layout';
 export type ComposerDropTarget = ({
     kind: 'explorer-title' | 'explorer-secondary' | 'quick-search';
 } | {
@@ -54,13 +57,6 @@ export type ComposerDropTarget = ({
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     select: (key: string) => any;
     "double-click": (key: string) => any;
-    "action-drop": (source: {
-        actionCode: string;
-        sourceAnchor?: PageCompositionActionPlacement["anchor"];
-    }, target: {
-        anchor: PageCompositionActionPlacement["anchor"];
-        index: number;
-    }) => any;
     "node-action": (action: ComposerNodeAction, key: string) => any;
     "reorder-list-field": (fieldId: string, targetIndex: number) => any;
     "reorder-form-field": (fieldId: string, targetIndex: number) => any;
@@ -72,16 +68,16 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     "reorder-relation-field": (relationId: string, fieldId: string, targetIndex: number) => any;
     "reorder-query-summary": (summaryKey: string, targetIndex: number) => any;
     "source-drop": (target: ComposerDropTarget, payload: PageCompositionDragPayload) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onSelect?: ((key: string) => any) | undefined;
-    "onDouble-click"?: ((key: string) => any) | undefined;
-    "onAction-drop"?: ((source: {
+    "action-drop": (source: {
         actionCode: string;
         sourceAnchor?: PageCompositionActionPlacement["anchor"];
     }, target: {
         anchor: PageCompositionActionPlacement["anchor"];
         index: number;
-    }) => any) | undefined;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((key: string) => any) | undefined;
+    "onDouble-click"?: ((key: string) => any) | undefined;
     "onNode-action"?: ((action: ComposerNodeAction, key: string) => any) | undefined;
     "onReorder-list-field"?: ((fieldId: string, targetIndex: number) => any) | undefined;
     "onReorder-form-field"?: ((fieldId: string, targetIndex: number) => any) | undefined;
@@ -93,10 +89,20 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     "onReorder-relation-field"?: ((relationId: string, fieldId: string, targetIndex: number) => any) | undefined;
     "onReorder-query-summary"?: ((summaryKey: string, targetIndex: number) => any) | undefined;
     "onSource-drop"?: ((target: ComposerDropTarget, payload: PageCompositionDragPayload) => any) | undefined;
+    "onAction-drop"?: ((source: {
+        actionCode: string;
+        sourceAnchor?: PageCompositionActionPlacement["anchor"];
+    }, target: {
+        anchor: PageCompositionActionPlacement["anchor"];
+        index: number;
+    }) => any) | undefined;
 }>, {
     disabled: boolean;
     selectedKey: string;
     editorMode: "fields" | "actions";
+    layoutTitle: string;
+    hideList: boolean;
+    separateDetail: boolean;
     formOrder: PageComposerFormItem[];
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/types/views/PageQuerySummaryEditor.vue.d.ts

@@ -32,17 +32,17 @@ type __VLS_Props = {
     descriptions?: Record<string, string>;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    retry: () => any;
     move: (index: number, offset: number) => any;
     add: (source: PageQuerySummarySource) => any;
     remove: (index: number) => any;
     update: (index: number, patch: Partial<PageQuerySummary>) => any;
-    retry: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRetry?: (() => any) | undefined;
     onMove?: ((index: number, offset: number) => any) | undefined;
     onAdd?: ((source: PageQuerySummarySource) => any) | undefined;
     onRemove?: ((index: number) => any) | undefined;
     onUpdate?: ((index: number, patch: Partial<PageQuerySummary>) => any) | undefined;
-    onRetry?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/views/RoleAuthorizationView.vue.d.ts

@@ -1,5 +1,5 @@
-import type { Role } from '../web-contracts/index';
 import { type ModuleContext } from '../web-core/index';
+import type { Role } from '../web-contracts/index';
 import type { ModulePageDrawerContext } from '../dynamic-page-runtime/index';
 type __VLS_Props = {
     roleId?: string;

package/dist/types/views/WorkflowAdministrationView.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/views/WorkflowConfigurationView.vue.d.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    moduleAlias: string;
+    moduleTitle?: string;
+};
+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/views/WorkflowWorkbenchView.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/views/businessLogClient.d.ts

@@ -1,5 +1,5 @@
-import type { HttpClient } from '../web-core/index';
-import type { WebQueryRequest } from '../web-contracts/index';
+import { type HttpClient, type LanguageContext } from '../web-core/index';
+import type { TextReference, WebQueryRequest } from '../web-contracts/index';
 export type BusinessLogSurface = 'activity' | 'request-error' | 'login';
 export interface BusinessLogOperatorIdentity {
     employeeName?: string;
@@ -34,6 +34,7 @@ export interface BusinessLogEventView {
 export interface BusinessLogStatisticItem {
     key: string;
     title: string;
+    titleSource?: TextReference;
     count: number;
     [key: string]: unknown;
 }
@@ -86,3 +87,5 @@ export interface BusinessLogClient {
     diagnostic?(eventId: string): Promise<Record<string, unknown>>;
 }
 export declare function createBusinessLogClient(http: HttpClient, surface: BusinessLogSurface): BusinessLogClient;
+/** Only labels explicitly produced by the statistics adapter are platform text. */
+export declare function businessLogStatisticTitle(item: BusinessLogStatisticItem, language: LanguageContext): string;

package/dist/types/views/businessRuleAssistantSurface.d.ts

@@ -0,0 +1,7 @@
+import { type LanguageContext, type AssistantCapability, type AssistantSurface, type AssistantTurnRequester } from '../web-core/index';
+import type { BusinessRuleProposal } from './businessRuleGovernance';
+import type { BusinessRuleTrialInput, BusinessRuleEditor as BusinessRuleAssistantAdapter } from './businessRuleEditor';
+export type { BusinessRuleTrialInput, BusinessRuleEditor as BusinessRuleAssistantAdapter, } from './businessRuleEditor';
+export declare function parseBusinessRuleProposal(input: unknown, language?: LanguageContext): BusinessRuleProposal;
+export declare function parseBusinessRuleTrial(input: unknown, language?: LanguageContext): BusinessRuleTrialInput;
+export declare function createBusinessRuleAssistantSurface(adapter: BusinessRuleAssistantAdapter, requestTurn: AssistantTurnRequester, contributed?: () => AssistantCapability[]): AssistantSurface;

package/dist/types/views/businessRuleEditor.d.ts

@@ -0,0 +1,23 @@
+import type { LanguageContext, OperationProposal } from '../web-core/index';
+import type { BusinessRuleProposal, BusinessRulePreview, BusinessRuleTrialResult } from './businessRuleGovernance';
+export interface BusinessRuleTrialInput {
+    sampleValues: Record<string, unknown>;
+    sampleChildren: Record<string, Record<string, unknown>[]>;
+}
+export interface BusinessRuleEditor {
+    readonly language?: LanguageContext;
+    summary(): {
+        moduleAlias: string;
+        title?: string;
+        editable: boolean;
+        factsAvailable?: boolean;
+        hasUnappliedChanges?: boolean;
+        submissionStatus?: 'idle' | 'unknown' | 'current-read';
+    };
+    readCurrent?(signal?: AbortSignal, commit?: (accept: () => void) => void): Promise<void>;
+    catalog(section: string): unknown[];
+    revise(rule: BusinessRuleProposal): void;
+    preview(signal: AbortSignal): Promise<BusinessRulePreview>;
+    trial(input: BusinessRuleTrialInput, signal: AbortSignal): Promise<BusinessRuleTrialResult>;
+    prepareConfirmation(signal: AbortSignal): Promise<OperationProposal>;
+}

package/dist/types/views/businessRuleGovernance.d.ts

@@ -1,4 +1,9 @@
+import { type LanguageContext, type OperationErrorMessage } from '../web-core/index';
+import type { TextPresentation } from '../web-contracts/index';
 export type BusinessRuleKind = 'CALCULATION' | 'VALIDATION' | 'UI_CONTROL';
+/** Save-validation behavior shared by manual editing and assistant rule inputs. */
+export declare const businessRuleValidationHelp = "\u516C\u5F0F\u4E3A\u771F\u65F6\u5141\u8BB8\u4FDD\u5B58\uFF0C\u4E3A\u5047\u65F6\u963B\u6B62\u4FDD\u5B58\u5E76\u663E\u793A\u5931\u8D25\u63D0\u793A\uFF1B\u5F53\u524D\u7F16\u8F91\u5668\u4E0D\u652F\u6301\u53EA\u63D0\u9192\u800C\u4ECD\u5141\u8BB8\u4FDD\u5B58\u7684\u89C4\u5219\u3002";
+export declare function businessRuleValidationHelpText(language?: LanguageContext): string;
 export interface BusinessRuleEditableField {
     fieldName: string;
     title: string;
@@ -31,6 +36,7 @@ export interface BusinessRuleReferenceField {
 export interface BusinessRuleFormulaParameter {
     name: string;
     description: string;
+    descriptionText?: TextPresentation;
 }
 /** A portable formula capability. A server catalogue can replace this list without changing the surface. */
 export interface BusinessRuleFormulaCapability {
@@ -55,22 +61,26 @@ export interface BusinessRuleFormulaCatalogEntry {
     name: string;
     category?: string;
     title?: string;
+    titleText?: TextPresentation;
     description?: string;
+    descriptionText?: TextPresentation;
+    categoryText?: TextPresentation;
     parameters?: BusinessRuleFormulaParameter[];
     returnType?: string;
     example?: string;
 }
+export declare function localizedPortableFormulaCapabilities(language?: LanguageContext): readonly BusinessRuleFormulaCapability[];
 export declare const portableFormulaCapabilities: readonly BusinessRuleFormulaCapability[];
-export declare function normalizeFormulaCapabilities(entries: readonly (BusinessRuleFormulaCapability | BusinessRuleFormulaCatalogEntry)[] | undefined): BusinessRuleFormulaCapability[];
+export declare function normalizeFormulaCapabilities(entries: readonly (BusinessRuleFormulaCapability | BusinessRuleFormulaCatalogEntry)[] | undefined, language?: LanguageContext): BusinessRuleFormulaCapability[];
 export declare function searchableFormulaCapabilities(capabilities: readonly BusinessRuleFormulaCapability[], keyword: string): BusinessRuleFormulaCapability[];
 /** Root fields that cannot safely become scalar formula input have a visible, deterministic reason. */
-export declare function formulaFieldUnusableReason(field: BusinessRuleReferenceField): string | undefined;
+export declare function formulaFieldUnusableReason(field: BusinessRuleReferenceField, language?: LanguageContext): string | undefined;
 /**
  * Prevents a child field from being inserted as a scalar or into an aggregate whose value type
  * cannot consume it. The server remains authoritative; this only keeps authoring feedback close
  * to the attempted insertion.
  */
-export declare function aggregateFieldInsertionReason(field: BusinessRuleReferenceField, expression: string, selectionStart: number): string | undefined;
+export declare function aggregateFieldInsertionReason(field: BusinessRuleReferenceField, expression: string, selectionStart: number, childTargets?: readonly string[], language?: LanguageContext): string | undefined;
 export interface UiControlTarget {
     elementKey: string;
     hide: boolean;
@@ -122,6 +132,8 @@ export interface BusinessRuleSnapshot {
     }>;
     /** Direct child fields, which may only appear within a child aggregation function. */
     aggregateFields?: BusinessRuleEditableField[];
+    /** Writable direct-child targets; never reference target fields. */
+    childFields?: BusinessRuleEditableField[];
     /** Additive portable function directory emitted by the server. */
     functions?: BusinessRuleFormulaCatalogEntry[];
     rules: BusinessRuleSnapshotRule[];
@@ -137,11 +149,13 @@ export interface BusinessRuleProposal {
     messageTemplate?: string;
 }
 export interface BusinessRuleIssue {
+    readonly messageSources?: readonly OperationErrorMessage[];
     code: string;
     ruleCode?: string;
     field?: string;
     message: string;
 }
+export declare function businessRuleIssueMessage(issue: BusinessRuleIssue, language?: LanguageContext): string;
 export interface BusinessRulePreview {
     snapshot: BusinessRuleSnapshot;
     proposalFingerprint: string;
@@ -152,8 +166,10 @@ export interface BusinessRuleTrialResult {
     preview: BusinessRulePreview;
     values: Record<string, unknown>;
     changedFields: string[];
+    children?: Record<string, Record<string, unknown>[]>;
     errors: BusinessRuleIssue[];
 }
+export declare function businessRuleTrialValue(result: Pick<BusinessRuleTrialResult, 'values' | 'children'>, field: string): unknown;
 export interface BusinessRuleApplyResult {
     snapshot: BusinessRuleSnapshot;
     preview: BusinessRulePreview;
@@ -197,5 +213,5 @@ export declare function presentableFormulaExpression(expression: string, fields:
  */
 export declare function externalTrialInputFields(fields: readonly BusinessRuleEditableField[], rules: readonly BusinessRuleProposal[]): BusinessRuleEditableField[];
 export declare function filterBusinessRuleFields(fields: readonly BusinessRuleEditableField[], keyword: string): BusinessRuleEditableField[];
-export declare function formulaTemplates(kind: BusinessRuleKind, fields: readonly BusinessRuleEditableField[], targetField?: string): BusinessRuleFormulaTemplate[];
+export declare function formulaTemplates(kind: BusinessRuleKind, fields: readonly BusinessRuleEditableField[], targetField?: string, language?: LanguageContext): BusinessRuleFormulaTemplate[];
 export declare function businessRuleChangeImpact(snapshot: BusinessRuleSnapshot, proposals: readonly BusinessRuleProposal[]): BusinessRuleChangeImpact;

package/dist/types/views/businessRuleSession.d.ts

@@ -0,0 +1,64 @@
+import { type LanguageContext, OperationUsageError, type HttpClient } from '../web-core/index';
+import { type BusinessRuleSnapshot, type UiControlSnapshot, type BusinessRuleProposal, type BusinessRuleTrialResult, type BusinessRuleIssue } from './businessRuleGovernance';
+import type { BusinessRuleEditor, BusinessRuleTrialInput } from './businessRuleEditor';
+export declare class BusinessRulePrecheckError extends OperationUsageError {
+    readonly issues: BusinessRuleIssue[];
+    constructor(issues: BusinessRuleIssue[], language?: LanguageContext);
+}
+/** One in-memory candidate shared by manual editing and conversation; server baselines remain authoritative. */
+export declare function createBusinessRuleSession(http: HttpClient, moduleAlias: string, ownerValid?: () => boolean, confirmationScope?: () => boolean, language?: LanguageContext): {
+    language: LanguageContext;
+    moduleAlias: string;
+    dispose(): void;
+    invalidateConfirmations: () => number;
+    snapshot: import("vue").Ref<BusinessRuleSnapshot | undefined, BusinessRuleSnapshot | undefined>;
+    ready: import("vue").ComputedRef<boolean>;
+    ui: import("vue").Ref<UiControlSnapshot | undefined, UiControlSnapshot | undefined>;
+    rules: import("vue").Ref<{
+        formKey?: string | undefined;
+        targets?: {
+            elementKey: string;
+            hide: boolean;
+            readOnly: boolean;
+        }[] | undefined;
+        code: string;
+        kind: import("./businessRuleGovernance").BusinessRuleKind;
+        targetField?: string | undefined;
+        expression: string;
+        enabled: boolean;
+        messageTemplate?: string | undefined;
+    }[], BusinessRuleProposal[] | {
+        formKey?: string | undefined;
+        targets?: {
+            elementKey: string;
+            hide: boolean;
+            readOnly: boolean;
+        }[] | undefined;
+        code: string;
+        kind: import("./businessRuleGovernance").BusinessRuleKind;
+        targetField?: string | undefined;
+        expression: string;
+        enabled: boolean;
+        messageTemplate?: string | undefined;
+    }[]>;
+    loading: import("vue").Ref<boolean, boolean>;
+    loadFailed: import("vue").Ref<boolean, boolean>;
+    committedNeedsReload: import("vue").Ref<boolean, boolean>;
+    submissionStatus: import("vue").Ref<"unknown" | "idle" | "current-read", "unknown" | "idle" | "current-read">;
+    applying: import("vue").Ref<boolean, boolean>;
+    tenantId: import("vue").Ref<string, string>;
+    revision: import("vue").Ref<number, number>;
+    dirty: import("vue").ComputedRef<boolean>;
+    editing: import("vue").Ref<boolean, boolean>;
+    adapter: BusinessRuleEditor;
+    load: (force?: boolean, commit?: (accept: () => void) => void) => Promise<void>;
+    replace: (next: BusinessRuleProposal[]) => void;
+    discard: () => void;
+    apply: (stillCurrent?: () => boolean) => Promise<{
+        synchronized: boolean;
+    } | undefined>;
+    readCurrent: (signal?: AbortSignal, commit?: (accept: () => void) => void) => Promise<void>;
+    trial: (input: BusinessRuleTrialInput, signal?: AbortSignal) => Promise<BusinessRuleTrialResult>;
+    setEditing(owner: symbol, value: boolean): void;
+};
+export type BusinessRuleSession = ReturnType<typeof createBusinessRuleSession>;

package/dist/types/views/businessRuleWorkspace.d.ts

@@ -0,0 +1,148 @@
+import { type LanguageContext, type AssistantInvocationToken, type AssistantCapability, type AssistantConfigurationEditor, type HttpClient } from '../web-core/index';
+import { type BusinessRuleSession } from './businessRuleSession';
+export declare function createBusinessRuleWorkspace(http: HttpClient, identity: () => string, enabled: () => boolean, openRules?: (moduleAlias: string) => void, onFocus?: () => void, language?: LanguageContext): {
+    language: LanguageContext;
+    session: (moduleAlias: string) => {
+        language: LanguageContext;
+        moduleAlias: string;
+        dispose(): void;
+        invalidateConfirmations: () => number;
+        snapshot: import("vue").Ref<import("./businessRuleGovernance").BusinessRuleSnapshot | undefined, import("./businessRuleGovernance").BusinessRuleSnapshot | undefined>;
+        ready: import("vue").ComputedRef<boolean>;
+        ui: import("vue").Ref<import("./businessRuleGovernance").UiControlSnapshot | undefined, import("./businessRuleGovernance").UiControlSnapshot | undefined>;
+        rules: import("vue").Ref<{
+            formKey?: string | undefined;
+            targets?: {
+                elementKey: string;
+                hide: boolean;
+                readOnly: boolean;
+            }[] | undefined;
+            code: string;
+            kind: import("./businessRuleGovernance").BusinessRuleKind;
+            targetField?: string | undefined;
+            expression: string;
+            enabled: boolean;
+            messageTemplate?: string | undefined;
+        }[], import("./businessRuleGovernance").BusinessRuleProposal[] | {
+            formKey?: string | undefined;
+            targets?: {
+                elementKey: string;
+                hide: boolean;
+                readOnly: boolean;
+            }[] | undefined;
+            code: string;
+            kind: import("./businessRuleGovernance").BusinessRuleKind;
+            targetField?: string | undefined;
+            expression: string;
+            enabled: boolean;
+            messageTemplate?: string | undefined;
+        }[]>;
+        loading: import("vue").Ref<boolean, boolean>;
+        loadFailed: import("vue").Ref<boolean, boolean>;
+        committedNeedsReload: import("vue").Ref<boolean, boolean>;
+        submissionStatus: import("vue").Ref<"unknown" | "idle" | "current-read", "unknown" | "idle" | "current-read">;
+        applying: import("vue").Ref<boolean, boolean>;
+        tenantId: import("vue").Ref<string, string>;
+        revision: import("vue").Ref<number, number>;
+        dirty: import("vue").ComputedRef<boolean>;
+        editing: import("vue").Ref<boolean, boolean>;
+        adapter: import("./businessRuleEditor").BusinessRuleEditor;
+        load: (force?: boolean, commit?: (accept: () => void) => void) => Promise<void>;
+        replace: (next: import("./businessRuleGovernance").BusinessRuleProposal[]) => void;
+        discard: () => void;
+        apply: (stillCurrent?: () => boolean) => Promise<{
+            synchronized: boolean;
+        } | undefined>;
+        readCurrent: (signal?: AbortSignal, commit?: (accept: () => void) => void) => Promise<void>;
+        trial: (input: import("./businessRuleEditor").BusinessRuleTrialInput, signal?: AbortSignal) => Promise<import("./businessRuleGovernance").BusinessRuleTrialResult>;
+        setEditing(owner: symbol, value: boolean): void;
+    };
+    focus: (value: BusinessRuleSession) => void;
+    dispose(): void;
+    showEditor(value: BusinessRuleSession): void;
+    hideEditor(value: BusinessRuleSession): void;
+    editor(): AssistantConfigurationEditor | undefined;
+    clearFocus(): void;
+    current(): {
+        revision: string;
+        facts: {
+            ruleConfiguration: import("../web-contracts").AssistantSurfaceContext | undefined;
+            draftLifetime: string;
+        };
+    };
+    capabilities(settleNavigation?: (signal?: AbortSignal) => Promise<void | AssistantInvocationToken>): AssistantCapability[];
+};
+export type BusinessRuleWorkspace = ReturnType<typeof createBusinessRuleWorkspace>;
+export declare function provideBusinessRuleWorkspace(workspace: BusinessRuleWorkspace): void;
+export declare function useBusinessRuleWorkspace(): {
+    language: LanguageContext;
+    session: (moduleAlias: string) => {
+        language: LanguageContext;
+        moduleAlias: string;
+        dispose(): void;
+        invalidateConfirmations: () => number;
+        snapshot: import("vue").Ref<import("./businessRuleGovernance").BusinessRuleSnapshot | undefined, import("./businessRuleGovernance").BusinessRuleSnapshot | undefined>;
+        ready: import("vue").ComputedRef<boolean>;
+        ui: import("vue").Ref<import("./businessRuleGovernance").UiControlSnapshot | undefined, import("./businessRuleGovernance").UiControlSnapshot | undefined>;
+        rules: import("vue").Ref<{
+            formKey?: string | undefined;
+            targets?: {
+                elementKey: string;
+                hide: boolean;
+                readOnly: boolean;
+            }[] | undefined;
+            code: string;
+            kind: import("./businessRuleGovernance").BusinessRuleKind;
+            targetField?: string | undefined;
+            expression: string;
+            enabled: boolean;
+            messageTemplate?: string | undefined;
+        }[], import("./businessRuleGovernance").BusinessRuleProposal[] | {
+            formKey?: string | undefined;
+            targets?: {
+                elementKey: string;
+                hide: boolean;
+                readOnly: boolean;
+            }[] | undefined;
+            code: string;
+            kind: import("./businessRuleGovernance").BusinessRuleKind;
+            targetField?: string | undefined;
+            expression: string;
+            enabled: boolean;
+            messageTemplate?: string | undefined;
+        }[]>;
+        loading: import("vue").Ref<boolean, boolean>;
+        loadFailed: import("vue").Ref<boolean, boolean>;
+        committedNeedsReload: import("vue").Ref<boolean, boolean>;
+        submissionStatus: import("vue").Ref<"unknown" | "idle" | "current-read", "unknown" | "idle" | "current-read">;
+        applying: import("vue").Ref<boolean, boolean>;
+        tenantId: import("vue").Ref<string, string>;
+        revision: import("vue").Ref<number, number>;
+        dirty: import("vue").ComputedRef<boolean>;
+        editing: import("vue").Ref<boolean, boolean>;
+        adapter: import("./businessRuleEditor").BusinessRuleEditor;
+        load: (force?: boolean, commit?: (accept: () => void) => void) => Promise<void>;
+        replace: (next: import("./businessRuleGovernance").BusinessRuleProposal[]) => void;
+        discard: () => void;
+        apply: (stillCurrent?: () => boolean) => Promise<{
+            synchronized: boolean;
+        } | undefined>;
+        readCurrent: (signal?: AbortSignal, commit?: (accept: () => void) => void) => Promise<void>;
+        trial: (input: import("./businessRuleEditor").BusinessRuleTrialInput, signal?: AbortSignal) => Promise<import("./businessRuleGovernance").BusinessRuleTrialResult>;
+        setEditing(owner: symbol, value: boolean): void;
+    };
+    focus: (value: BusinessRuleSession) => void;
+    dispose(): void;
+    showEditor(value: BusinessRuleSession): void;
+    hideEditor(value: BusinessRuleSession): void;
+    editor(): AssistantConfigurationEditor | undefined;
+    clearFocus(): void;
+    current(): {
+        revision: string;
+        facts: {
+            ruleConfiguration: import("../web-contracts").AssistantSurfaceContext | undefined;
+            draftLifetime: string;
+        };
+    };
+    capabilities(settleNavigation?: (signal?: AbortSignal) => Promise<void | AssistantInvocationToken>): AssistantCapability[];
+} | undefined;

package/dist/types/views/configurationEditorNavigation.d.ts

@@ -0,0 +1,3 @@
+import { type LanguageContext } from '../web-core/index';
+/** Lazy page loading may finish after the router commits; resume only once the shared editor is mounted. */
+export declare function waitForConfigurationEditor(visible: () => boolean, signal?: AbortSignal, language?: LanguageContext): Promise<void>;