@ximatai/muyun-web-app 0.26.12 → 0.26.14

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

@@ -1,4 +1,5 @@
 export type Primitive = string | number | boolean | null | undefined;
+export * from './assistant';
 export type OptionValue = string | number;
 export type OptionValueList = OptionValue[];
 export interface Option {
@@ -396,6 +397,8 @@ export interface ResolvedDetailRelationListField {
     width?: number;
     align?: 'left' | 'center' | 'right' | string;
     maxDisplayLines?: number;
+    /** Read-side label companion for a reference ID column. */
+    referenceTitleField?: string;
 }
 export declare function hasExecutableDetailRelationQueryContract(relation: ResolvedDetailRelationDescriptor | undefined): relation is ResolvedDetailRelationDescriptor & {
     queryContract: ResolvedDetailRelationQueryContract & {
@@ -551,6 +554,28 @@ export interface WebQueryCondition {
     values?: unknown[];
     timeZone?: string;
 }
+/**
+ * One executable condition in a recursively composed query expression.
+ *
+ * This is intentionally separate from {@link WebQueryCondition}: `conditions`
+ * remains the legacy top-level AND shorthand, while `criteria` preserves the
+ * authored order and nesting needed by the advanced query editor.
+ */
+export interface QueryCriteriaCondition {
+    kind: 'CONDITION';
+    fieldName: string;
+    operator?: QueryOperator;
+    values?: unknown[];
+    timeZone?: string;
+}
+/** A parenthesized, ordered group of query criteria. */
+export interface QueryCriteriaGroup {
+    kind: 'GROUP';
+    operator: 'AND' | 'OR';
+    children: QueryCriteriaNode[];
+}
+/** An ordered query-expression node, either a condition or a nested group. */
+export type QueryCriteriaNode = QueryCriteriaCondition | QueryCriteriaGroup;
 export interface WebSort {
     field: string;
     desc?: boolean;
@@ -559,7 +584,7 @@ export interface WebQueryRequest {
     page?: WebPageRequest;
     unpaged?: boolean;
     conditions?: WebQueryCondition[];
-    criteria?: unknown;
+    criteria?: QueryCriteriaGroup;
     queryForm?: Record<string, unknown>;
     sorts?: WebSort[];
     uiConfigId?: string;
@@ -572,7 +597,7 @@ export interface WebQueryRequest {
     navigatorTargetLevelKey?: string;
 }
 /** Shared field-reference delivery contract for static and metadata-backed modules. */
-export type WebReferenceResolveMode = 'QUERY' | 'TREE' | 'TRANSLATE';
+export type WebReferenceResolveMode = 'QUERY' | 'TREE' | 'TREE_CHILDREN' | 'TRANSLATE';
 export type WebReferenceMatchMode = 'KEY' | 'LABEL' | 'AUTO';
 export type WebReferenceResolveStatus = 'OK' | 'RESOLVED' | 'NOT_FOUND' | 'AMBIGUOUS' | 'PARTIAL';
 /** Persisted aggregate record owning a reference interaction; never use form values to provide its tenant. */
@@ -585,7 +610,7 @@ export interface WebReferenceResolveRequest {
     fuzzy?: string;
     values?: unknown[];
     conditions?: WebQueryCondition[];
-    criteria?: unknown;
+    criteria?: QueryCriteriaGroup;
     page?: WebPageRequest;
     includeProjections?: boolean;
     formValues?: Record<string, unknown>;
@@ -594,6 +619,8 @@ export interface WebReferenceResolveRequest {
     uiConfigId?: string;
     queryTemplateId?: string;
     externalQueryValues?: Record<string, unknown>;
+    /** Parent identity for one-level lazy tree delivery. Omit it to read the tree root. */
+    parentId?: string;
     /**
      * Host page that owns this navigator reference request.  Reference transports
      * use it only to resolve the declared NAVIGATOR_QUERY bindings; ordinary
@@ -609,6 +636,8 @@ export interface WebReferenceResolveItem {
     matchedBy?: WebReferenceMatchMode;
     projections?: Record<string, unknown>;
     affectPatch?: Record<string, unknown>;
+    /** Present for TREE_CHILDREN: whether the same authorized candidate scope exposes a child. */
+    hasChildren?: boolean;
 }
 export interface WebReferenceResolveResult {
     input: unknown;
@@ -628,7 +657,7 @@ export interface WebReferenceResolveResponse {
     tree?: WebTreeNode<WebReferenceResolveItem>[];
 }
 export type QueryValueType = 'STRING' | 'TEXT' | 'BOOLEAN' | 'INTEGER' | 'LONG' | 'DECIMAL' | 'INSTANT' | 'DATE' | 'JSON';
-export type QueryOperator = 'EQ' | 'NOT_EQUAL' | 'LIKE' | 'IN' | 'NOT_IN' | 'GT' | 'GTE' | 'LT' | 'LTE' | 'BETWEEN' | 'NULL' | 'NOT_NULL';
+export type QueryOperator = 'EQ' | 'NOT_EQUAL' | 'LIKE' | 'IN' | 'NOT_IN' | 'GT' | 'GTE' | 'LT' | 'LTE' | 'BETWEEN' | 'NULL' | 'NOT_NULL' | 'CONTAINS' | 'CONTAINS_ANY' | 'CONTAINS_ALL' | 'EMPTY' | 'NOT_EMPTY';
 export interface QuerySchemaField {
     name: string;
     title?: string;
@@ -639,7 +668,24 @@ export interface QuerySchemaField {
     sortable?: boolean;
     /** Explicit field-domain binding; distinguishes options from reference title companions. */
     optionBinding?: OptionBindingDescriptor;
+    selectionMode?: 'SINGLE' | 'MULTIPLE';
     optionTitleField?: string;
+    /** A persisted record-id reference selectable through this source field's standard resolve contract. */
+    reference?: QuerySchemaReference;
+    /** A backend-owned default condition rendered by the standard list query surface. */
+    persistentControl?: QuerySchemaPersistentControl;
+}
+export interface QuerySchemaPersistentControl {
+    id: string;
+    title: string;
+    operator: QueryOperator;
+    defaultValues?: unknown[];
+}
+export interface QuerySchemaReference {
+    targetModuleAlias: string;
+    cardinality: 'ONE' | 'MANY';
+    /** Target candidate label field when the reference explicitly declares one. */
+    labelField?: string;
 }
 export interface QuerySchemaQuickSearch {
     enabled: boolean;
@@ -662,6 +708,8 @@ export interface QuerySchema {
     fields: QuerySchemaField[];
     externalCriteria: QuerySchemaExternalCriteria[];
     defaultSorts: QuerySchemaDefaultSort[];
+    /** Server-declared criteria structure supported by this query surface. */
+    criteriaComposition?: 'NONE' | 'FLAT_AND' | 'TREE';
 }
 export type ModuleViewKind = 'LIST' | 'FORM' | 'DETAIL';
 export type ModuleUiClientType = 'WEB';
@@ -950,13 +998,25 @@ export interface ResolvedPageListQuerySummaryDescriptor {
     groupByTitle?: string;
     sumFieldTitle?: string;
 }
-/** A persistent boolean query control rendered before search; advanced filtering follows search. */
-export interface ResolvedPageListPersistentQueryControlDescriptor {
+/** A module-owned boolean condition rendered before search. */
+export interface ResolvedPageListExternalPersistentQueryControlDescriptor {
+    source: 'EXTERNAL';
+    id: string;
     externalCriteriaKey: string;
     title: string;
     uiType: 'SWITCH';
     defaultValue: boolean;
 }
+/** A field condition rendered before search and composed into the root AND query group. */
+export interface ResolvedPageListFieldPersistentQueryControlDescriptor {
+    source: 'FIELD';
+    id: string;
+    title: string;
+    fieldName: string;
+    operator: QueryOperator;
+    defaultValues: unknown[];
+}
+export type ResolvedPageListPersistentQueryControlDescriptor = ResolvedPageListExternalPersistentQueryControlDescriptor | ResolvedPageListFieldPersistentQueryControlDescriptor;
 export interface ResolvedPageListRelationExpansionDescriptor {
     relationCode: string;
     fields: string[];
@@ -1002,6 +1062,7 @@ export interface ResolvedPageActionDescriptor {
     actionCode: string;
     anchor: 'PAGE' | 'DETAIL' | 'FORM';
     invocation?: PageActionInvocation;
+    statusMode?: 'NONE' | 'INPUT_VALIDATION';
 }
 export interface ResolvedPageTreeResourceDescriptor {
     resource: string;

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

@@ -0,0 +1,77 @@
+import type { AssistantCapabilityResult, AssistantConversationMessage, AssistantSelectionResponse, AssistantTurnOutput } from '../web-contracts/index';
+import { type AssistantSurfaceRegistry } from './assistantSurface';
+export interface AssistantRuntimeStepResult {
+    output: AssistantTurnOutput;
+    results: AssistantCapabilityResult[];
+    contextChanged: boolean;
+    /** Successful capability invocations that committed an effect through applyEffect in this step. */
+    appliedEffectCount: number;
+}
+export interface AssistantConversationOptions {
+    signal?: AbortSignal;
+    maxSteps?: number;
+    /** Completed dialogue before the current user message. */
+    history?: AssistantConversationMessage[];
+    /** Structured answer to a selection shown by the immediately preceding assistant message. */
+    selectionResponse?: AssistantSelectionResponse;
+    onStep?(step: AssistantRuntimeStepResult): void | Promise<void>;
+    onTextDelta?(text: string, stepIndex: number): void;
+    onTextDiscard?(stepIndex: number): void;
+    onActivity?(phase: AssistantActivityPhase, stepIndex: number): void;
+    /** Receives content-free execution facts for local diagnostics or a governed telemetry adapter. */
+    onDiagnostic?(event: AssistantRuntimeDiagnosticEvent): void | Promise<void>;
+}
+export type AssistantActivityPhase = 'understanding' | 'executing' | 'responding';
+type AssistantDiagnosticSurface = 'workbench' | 'module-page' | 'metadata-governance' | 'other';
+type AssistantDiagnosticFinishReason = 'stop' | 'tool_calls' | 'length' | 'content_filter' | 'other';
+export type AssistantRuntimeDiagnosticEvent = {
+    type: 'decision.started';
+    stepIndex: number;
+    surface: AssistantDiagnosticSurface;
+    backgroundContextRefreshed: boolean;
+} | {
+    type: 'decision.completed';
+    stepIndex: number;
+    finishReason?: AssistantDiagnosticFinishReason;
+    toolCallCount: number;
+    hasText: boolean;
+} | {
+    type: 'decision.restarted';
+    stepIndex: number;
+    attempt: number;
+    reason: 'background-context-refresh' | 'formal-surface-ready';
+} | {
+    type: 'decision.failed';
+    stepIndex: number;
+    reason: 'context-changed' | 'cancelled' | 'surface-settlement-failed' | 'model-request-failed';
+} | {
+    type: 'capability.completed';
+    stepIndex: number;
+    capabilityCode: string;
+    outcome: 'succeeded' | 'failed' | 'replayed';
+    pageEffectApplied: boolean;
+} | {
+    type: 'conversation.completed';
+    stepCount: number;
+    bounded: boolean;
+};
+export interface AssistantConversationResult {
+    steps: AssistantRuntimeStepResult[];
+    completed: boolean;
+}
+export declare class AssistantConversationFollowUpError extends Error {
+    readonly steps: readonly AssistantRuntimeStepResult[];
+    constructor(steps: readonly AssistantRuntimeStepResult[], cause: unknown);
+}
+/**
+ * Runs the bounded tool loop for one user message. Every step takes a fresh
+ * Surface snapshot so navigation and draft changes are observed before the
+ * model decides its next action.
+ */
+export declare function runAssistantConversation(registry: AssistantSurfaceRegistry, message: string, options?: AssistantConversationOptions): Promise<AssistantConversationResult>;
+/**
+ * Executes one bounded model step. A context-changing capability ends the step;
+ * the caller starts the next turn from a fresh Surface snapshot.
+ */
+export declare function runAssistantStep(registry: AssistantSurfaceRegistry, message: string, previousResults?: AssistantCapabilityResult[], signal?: AbortSignal): Promise<AssistantRuntimeStepResult>;
+export {};

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

@@ -0,0 +1,92 @@
+import type { AssistantCapabilityCall, AssistantCapabilityDescriptor, AssistantSurfaceContext, AssistantTurnInput, AssistantTurnOutput } from '../web-contracts/index';
+import type { AssistantTurnProgress } from './assistantTurnClient';
+export interface AssistantCapability<TInput = unknown, TOutput = unknown> {
+    descriptor: AssistantCapabilityDescriptor;
+    parseInput(input: unknown): TInput;
+    execute(input: TInput, context: AssistantCapabilityExecutionContext): Promise<TOutput>;
+}
+export declare function emptyAssistantCapabilityInputSchema(): Record<string, unknown>;
+export declare function parseEmptyAssistantCapabilityInput(input: unknown): Record<string, never>;
+export interface AssistantCapabilityExecutionContext {
+    signal: AbortSignal;
+    /** Explicit caller cancellation; unlike signal, it is not aborted by an expected Surface replacement. */
+    cancellationSignal?: AbortSignal;
+    isCurrent(): boolean;
+    /** Commit invocation-local guarded state without claiming a user-visible page effect. */
+    commitInternalState<T>(commit: () => T): T;
+    /**
+     * Apply a page effect, retaining its execution scope while background work settles.
+     * Navigation adapters may return the token of an explicitly validated replacement surface.
+     */
+    applyEffect<T>(effect: () => T, settle?: () => Promise<void | AssistantInvocationToken>): T;
+}
+export interface AssistantSurface {
+    describe(): AssistantSurfaceContext;
+    capabilities(): AssistantCapability[];
+    requestTurn(input: AssistantTurnInput, signal: AbortSignal, progress?: AssistantTurnProgress): Promise<AssistantTurnOutput>;
+}
+export interface AssistantSurfaceRegistration {
+    pageInstanceKey: string;
+    fallback?: boolean;
+    /**
+     * Waits for background page transitions to finish before the model receives a
+     * context snapshot. It must not wait for missing user input or mutate page state.
+     */
+    settle?(signal: AbortSignal): Promise<void>;
+    contextRevision(): string;
+    /**
+     * User-controlled execution scope. Background refreshes must leave this stable
+     * so the runtime can safely refresh context without discarding the user's goal.
+     */
+    interactionRevision?(): string;
+    surface: AssistantSurface;
+}
+export interface AssistantInvocationToken {
+    pageInstanceKey: string;
+    surfaceGeneration: number;
+    contextRevision: string;
+    interactionRevision?: string;
+    fallback: boolean;
+}
+export interface AssistantSurfaceSnapshot {
+    token: AssistantInvocationToken;
+    context: AssistantSurfaceContext;
+    capabilities: AssistantCapabilityDescriptor[];
+}
+export interface AssistantSurfaceRegistry {
+    register(registration: AssistantSurfaceRegistration): () => void;
+    activate(pageInstanceKey: string | undefined): void;
+    snapshot(): AssistantSurfaceSnapshot | undefined;
+    /** Observe registration and active-page changes; read the current snapshot when notified. */
+    subscribe(listener: () => void): () => void;
+    waitForActiveSurface(options?: {
+        pageInstanceKey?: string;
+        requireFormal?: boolean;
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<AssistantSurfaceSnapshot>;
+    /** Waits for the current page to settle and returns a fresh, execution-compatible snapshot. */
+    settleActiveSurface(token: AssistantInvocationToken, signal?: AbortSignal): Promise<AssistantSurfaceSnapshot>;
+    requestTurn(input: Omit<AssistantTurnInput, 'context' | 'capabilities'>, token: AssistantInvocationToken, signal?: AbortSignal, progress?: AssistantTurnProgress): Promise<AssistantTurnOutput>;
+    invoke(call: AssistantCapabilityCall, token: AssistantInvocationToken, signal?: AbortSignal): Promise<{
+        value: unknown;
+        contextChanged: boolean;
+    }>;
+}
+export interface AssistantSurfaceHost {
+    registry: AssistantSurfaceRegistry;
+    activePageInstanceKey(): string | undefined;
+    capabilities?(): AssistantCapability[];
+}
+export declare function provideAssistantSurfaceHost(host: AssistantSurfaceHost): void;
+export declare function useAssistantSurfaceHost(): AssistantSurfaceHost | undefined;
+export declare class StaleAssistantInvocationError extends Error {
+    constructor();
+}
+/** Safe, bounded feedback that helps the model repair a rejected capability call. */
+export declare class AssistantCapabilityUsageError extends Error {
+    constructor(message: string);
+}
+export declare function createAssistantSurfaceRegistry(): AssistantSurfaceRegistry;
+/** Compares page identity and revisions, independently of object property order. */
+export declare function sameAssistantInvocationToken(left: AssistantInvocationToken | undefined, right: AssistantInvocationToken | undefined): boolean;

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

@@ -0,0 +1,8 @@
+import type { AssistantTurnInput, AssistantTurnOutput } from '../web-contracts/index';
+import { type HttpClient } from './http';
+export interface AssistantTurnProgress {
+    onTextDelta?(text: string): void;
+}
+export type AssistantTurnRequester = (input: AssistantTurnInput, signal: AbortSignal, progress?: AssistantTurnProgress) => Promise<AssistantTurnOutput>;
+/** Uses the supplied transport as-is so page-owned tenant scope remains authoritative. */
+export declare function createAssistantTurnRequester(http: HttpClient): AssistantTurnRequester;

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

@@ -14,6 +14,8 @@ export interface HttpRequestOptions {
     query?: Record<string, RouteQueryValue>;
     body?: unknown;
     headers?: Record<string, string>;
+    /** Cancels the underlying Fetch request, including a long-lived response stream. */
+    signal?: AbortSignal;
 }
 export interface HttpClient {
     request<T>(options: HttpRequestOptions): Promise<T>;

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

@@ -1,7 +1,11 @@
 export * from './errors';
 export * from './http';
+export * from './sse';
 export * from './query';
 export * from './actionResult';
+export * from './assistantSurface';
+export * from './assistantRuntime';
+export * from './assistantTurnClient';
 export * from './businessNotifications';
 export * from './dataChanges';
 export * from './realtime';

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

@@ -26,7 +26,7 @@ export interface ModuleContextConfig {
 }
 export interface ModuleContextOptions extends ModuleContextConfig {
     moduleAlias: string;
-    runtimeAccess?: 'MENU' | 'REFERENCE';
+    runtimeAccess?: 'MENU' | 'REFERENCE' | 'VIEW';
     navigatorReference?: NavigatorReferenceRequestContext;
 }
 export declare function configureModuleContext(config: ModuleContextConfig): void;
@@ -35,7 +35,7 @@ export declare function createModuleContext<TRecord>(options: ModuleContextOptio
 export declare function createModuleTreeContext<TRecord>(options: ModuleContextOptions): ModuleTreeContext<TRecord>;
 export declare function useModuleContext<TRecord>(options?: Partial<ModuleContextOptions>): ModuleContext<TRecord>;
 export declare function useModuleTreeContext<TRecord>(options?: Partial<ModuleContextOptions>): ModuleTreeContext<TRecord>;
-/** An immutable transport boundary; remount it to begin a separate business data session. */
+/** New consumers capture the current immutable transport; existing contexts keep their original client. */
 export declare const ModuleHttpProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     http: {
         type: PropType<HttpClient>;
@@ -55,6 +55,12 @@ export declare const ModuleContextProvider: import("vue").DefineComponent<import
         required: false;
         default: undefined;
     };
+    /** Reuse an already-authorized module session without recreating a MENU runtime. */
+    context: {
+        type: PropType<ModuleContext<unknown>>;
+        required: false;
+        default: undefined;
+    };
 }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
 }>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
@@ -63,6 +69,13 @@ export declare const ModuleContextProvider: import("vue").DefineComponent<import
         required: false;
         default: undefined;
     };
+    /** Reuse an already-authorized module session without recreating a MENU runtime. */
+    context: {
+        type: PropType<ModuleContext<unknown>>;
+        required: false;
+        default: undefined;
+    };
 }>> & Readonly<{}>, {
     moduleAlias: string;
+    context: ModuleContext<unknown>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -43,7 +43,8 @@ export interface ModuleRuntimeContext {
     moduleAlias: string;
     tenantRequired?: boolean;
     title?: string;
-    moduleKind?: 'STATIC' | 'DYNAMIC';
+    /** Stable wire code of the registered module kind. */
+    moduleKind?: 'static' | 'dynamic';
     entryType?: 'module' | 'route' | 'link';
     entryRoute?: string;
     entryExternalUrl?: string;
@@ -69,5 +70,5 @@ export interface ModuleRuntimeContextState {
     recordActionsSnapshot(recordId: string): ModuleRecordActionAvailability | undefined;
     invalidateRecordActions?(recordIds?: string[]): void;
 }
-export declare function createModuleRuntimeContextState(http: HttpClient, moduleAlias: string, access?: 'MENU' | 'REFERENCE'): ModuleRuntimeContextState;
+export declare function createModuleRuntimeContextState(http: HttpClient, moduleAlias: string, access?: 'MENU' | 'REFERENCE' | 'VIEW'): ModuleRuntimeContextState;
 export declare function isRuntimeAbilityAvailable(context: ModuleRuntimeContext | undefined, ability: ModuleAbilityCode): boolean;

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

@@ -64,11 +64,15 @@ export declare function createManagedDetailRelationClient<TRecord>(http: HttpCli
 export declare function createModuleCrudClient<TRecord>(http: HttpClient, options: {
     moduleAlias: string;
 }): ModuleCrudClient<TRecord>;
+/** Persisted selection recovery shares the module wire normalization used by candidate queries. */
+export interface NavigatorReferenceCrudClient<TRecord> extends ModuleCrudClient<TRecord> {
+    translate(ids: readonly string[]): Promise<WebPageResponse<TRecord>>;
+}
 /** The navigation-only read surface deliberately does not reuse the module query endpoint. */
 export declare function createNavigatorReferenceCrudClient<TRecord>(http: HttpClient, options: {
     moduleAlias: string;
     navigatorReference?: NavigatorReferenceRequestContext;
-}): ModuleCrudClient<TRecord>;
+}): NavigatorReferenceCrudClient<TRecord>;
 export declare function createStaticResourceCrudClient<TRecord>(http: HttpClient, resourcePath: string): ModuleCrudClient<TRecord>;
 export declare function createModuleTreeClient<TRecord>(http: HttpClient, options: {
     moduleAlias: string;

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

@@ -0,0 +1,9 @@
+export interface SseEvent {
+    event: string;
+    data: string;
+}
+/** Incrementally decodes the SSE framing shared by authenticated platform streams. */
+export declare function createSseParser(emit: (event: SseEvent) => void): {
+    push(chunk: string): void;
+    finish(): void;
+};