@ximatai/muyun-web-app 0.26.13 → 0.26.15

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

@@ -12,6 +12,6 @@ export interface RoleAuthorizationWorkspaceSession {
         snapshot: string;
     }>;
 }
-export declare function handOffRoleAuthorizationWorkspaceSession(input: RoleAuthorizationWorkspaceViewInput, session: RoleAuthorizationWorkspaceSession): Promise<"accepted" | "rejected">;
+export declare function handOffRoleAuthorizationWorkspaceSession(input: RoleAuthorizationWorkspaceViewInput, session: RoleAuthorizationWorkspaceSession): Promise<"rejected" | "accepted">;
 export declare function registerRoleAuthorizationWorkspaceHandoffRecipient(input: RoleAuthorizationWorkspaceViewInput, recipient: (session: RoleAuthorizationWorkspaceSession) => boolean): () => void;
 export declare function takeRoleAuthorizationWorkspaceSession(input: RoleAuthorizationWorkspaceViewInput): RoleAuthorizationWorkspaceSession | undefined;

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

@@ -15,6 +15,6 @@ export interface RoleDetailWorkspaceSession {
     scope: RoleDetailWorkspaceScope;
     mode: 'view' | 'edit';
 }
-export declare function handOffRoleDetailWorkspaceSession(input: RoleDetailWorkspaceViewInput, session: RoleDetailWorkspaceSession): Promise<"accepted" | "rejected">;
+export declare function handOffRoleDetailWorkspaceSession(input: RoleDetailWorkspaceViewInput, session: RoleDetailWorkspaceSession): Promise<"rejected" | "accepted">;
 export declare function registerRoleDetailWorkspaceHandoffRecipient(input: RoleDetailWorkspaceViewInput, recipient: (session: RoleDetailWorkspaceSession) => boolean): () => void;
 export declare function takeRoleDetailWorkspaceSession(input: RoleDetailWorkspaceViewInput): RoleDetailWorkspaceSession | undefined;

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

@@ -1,13 +1,3 @@
-export interface RuntimeLogSseEvent {
-    event: string;
-    data: string;
-}
-/**
- * Incrementally decodes an SSE response body. Keeping this small parser beside
- * the log surface avoids coupling a one-way operational stream to the broader
- * realtime messaging runtime.
- */
-export declare function createRuntimeLogSseParser(emit: (event: RuntimeLogSseEvent) => void): {
-    push(chunk: string): void;
-    finish(): void;
-};
+import { createSseParser, type SseEvent } from '../web-core/index';
+export type RuntimeLogSseEvent = SseEvent;
+export declare const createRuntimeLogSseParser: typeof createSseParser;

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

@@ -0,0 +1,68 @@
+import type { createPageCompositionDraftState } from './pageCompositionDraftState';
+import { type PendingComponentField } from './pageCompositionComponents';
+/** Session definitions survive removal so undo can restore identity; only referenced items are saved. */
+export declare function usePageCompositionComponents(state: ReturnType<typeof createPageCompositionDraftState>, treeJson: () => string): {
+    fieldUsageIndex: import("vue").ComputedRef<Map<string, string[]>>;
+    pendingComponents: import("vue").Ref<{
+        key: string;
+        component: import("./pageCompositionDragPayload").ComponentDragPayload["component"];
+        title: string;
+        required?: boolean | undefined;
+        fieldSpecAlias: string;
+    }[], PendingComponentField[] | {
+        key: string;
+        component: import("./pageCompositionDragPayload").ComponentDragPayload["component"];
+        title: string;
+        required?: boolean | undefined;
+        fieldSpecAlias: string;
+    }[]>;
+    pendingChildren: import("vue").Ref<{
+        key: string;
+        title: string;
+        fields: {
+            key: string;
+            component: import("./pageCompositionDragPayload").ComponentDragPayload["component"];
+            title: string;
+            required?: boolean | undefined;
+            fieldSpecAlias: string;
+        }[];
+    }[], {
+        key: string;
+        title: string;
+        fields: PendingComponentField[];
+    }[] | {
+        key: string;
+        title: string;
+        fields: {
+            key: string;
+            component: import("./pageCompositionDragPayload").ComponentDragPayload["component"];
+            title: string;
+            required?: boolean | undefined;
+            fieldSpecAlias: string;
+        }[];
+    }[]>;
+    pendingFieldSources: import("vue").ComputedRef<import("./pageCompositionDraftState").PageComposerField[]>;
+    activeComponents: import("vue").ComputedRef<{
+        key: string;
+        component: import("./pageCompositionDragPayload").ComponentDragPayload["component"];
+        title: string;
+        required?: boolean | undefined;
+        fieldSpecAlias: string;
+    }[]>;
+    activeChildren: import("vue").ComputedRef<{
+        title: string;
+        fields: {
+            key: string;
+            component: import("./pageCompositionDragPayload").ComponentDragPayload["component"];
+            title: string;
+            required?: boolean | undefined;
+            fieldSpecAlias: string;
+        }[];
+        key: string;
+    }[]>;
+    componentNameInvalid: import("vue").ComputedRef<boolean>;
+    childInvalid: import("vue").ComputedRef<boolean>;
+    pendingSearchableFields: import("vue").ComputedRef<string[]>;
+    updateField: (key: string, changes: Partial<Pick<PendingComponentField, "title" | "required">>) => void;
+    reset: () => void;
+};

package/dist/types/vue-ui-antdv/components/UiInput.vue.d.ts

@@ -4,6 +4,7 @@ type __VLS_Props = {
     type?: 'text' | 'password' | 'email' | 'search' | 'number' | 'url' | 'date' | 'datetime-local';
     placeholder?: string;
     disabled?: boolean;
+    invalid?: boolean;
     autofocus?: boolean;
     allowClear?: boolean;
     autocomplete?: string;

package/dist/types/vue-ui-antdv/components/UiSearchInput.vue.d.ts

@@ -8,6 +8,7 @@ type __VLS_Props = {
     searchIconOnly?: boolean;
     /** The displayed text represents an associated record rather than a search draft. */
     linked?: boolean;
+    invalid?: boolean;
     unmatched?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
@@ -27,6 +28,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     loading: boolean;
     value: string;
     placeholder: string;
+    invalid: boolean;
     unmatched: boolean;
     searchText: string;
     searchIconOnly: boolean;

package/dist/types/vue-ui-antdv/components/UiSelect.vue.d.ts

@@ -12,6 +12,7 @@ type __VLS_Props = {
     filterOption?: boolean;
     loading?: boolean;
     /** Marks an unresolved free-text draft without changing the selected option value. */
+    invalid?: boolean;
     unmatched?: boolean;
     id?: string;
     ariaLabel?: string;
@@ -44,6 +45,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     showSearch: boolean;
     searchValue: string;
     filterOption: boolean;
+    invalid: boolean;
     unmatched: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/types/vue-ui-antdv/components/UiTextArea.vue.d.ts

@@ -3,6 +3,7 @@ type __VLS_Props = {
     value?: string;
     placeholder?: string;
     disabled?: boolean;
+    invalid?: boolean;
     rows?: number;
     maxlength?: number;
     /** Enables adapter-owned, selection-aware drops without exposing the underlying textarea DOM. */
@@ -19,6 +20,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     focusSelection: typeof focusSelection;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:value": (value: string) => any;
+    keydown: (event: KeyboardEvent) => any;
     drop: (event: {
         source: UiDragSource;
         selection: {
@@ -33,6 +35,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     }) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:value"?: ((value: string) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
     onDrop?: ((event: {
         source: UiDragSource;
         selection: {
@@ -50,6 +53,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     value: string;
     placeholder: string;
     maxlength: number;
+    invalid: boolean;
     rows: number;
     acceptDrop: (source: UiDragSource) => boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/types/vue-ui-antdv/components/UiTreeSelect.vue.d.ts

@@ -18,6 +18,7 @@ type __VLS_Props = {
     filterTreeNode?: boolean;
     loading?: boolean;
     /** Marks an unresolved free-text draft without changing the selected option value. */
+    invalid?: boolean;
     unmatched?: boolean;
 };
 declare var __VLS_11: {};
@@ -45,6 +46,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     allowClear: boolean;
     showSearch: boolean;
     searchValue: string;
+    invalid: boolean;
     unmatched: boolean;
     filterTreeNode: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/types/vue-ui-antdv/types.d.ts

@@ -123,6 +123,10 @@ export type UiTreeChangeReason = 'interaction' | 'filter' | 'reset';
 export interface UiConfirmOptions {
     title: string;
     content?: string;
+    details?: {
+        title: string;
+        lines: readonly string[];
+    };
     okText?: string;
     cancelText?: string;
     danger?: boolean;

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

@@ -0,0 +1,87 @@
+export interface AssistantCapabilityDescriptor {
+    code: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface AssistantSurfaceContext {
+    surface: string;
+    title?: string;
+    facts: Record<string, unknown>;
+}
+export interface AssistantCapabilityCall {
+    id: string;
+    code: string;
+    input: unknown;
+}
+export interface AssistantCapabilityResult {
+    callId: string;
+    capabilityCode: string;
+    input: Record<string, unknown>;
+    /** Execution facts, independent of model completion. */
+    execution: 'read' | 'effect-applied' | 'not-applied' | 'unknown';
+    presentation?: AssistantResultPresentation;
+    output?: unknown;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface AssistantConversationMessage {
+    /** Historical display observations remain data, never assistant claims or authorization. */
+    role: 'user' | 'assistant' | 'status';
+    text: string;
+}
+export interface AssistantSelectionOption {
+    id: string;
+    label: string;
+}
+export interface AssistantSelectionInteraction {
+    interactionId: string;
+    prompt: string;
+    inputPolicy: 'free_text_allowed' | 'selection_required';
+    presentation: 'options' | 'confirmation';
+    options: AssistantSelectionOption[];
+}
+export interface AssistantSelectionResponse {
+    interactionId: string;
+    optionId: string;
+    label: string;
+}
+/** Execution budget is informational; it never grants permission to invoke a capability. */
+export interface AssistantExecutionBudget {
+    phase: 'work' | 'summary';
+    step: number;
+    normalLimit: number;
+    hardLimit: number;
+}
+export interface AssistantTurnInput {
+    executionBudget?: AssistantExecutionBudget;
+    /** Runtime-only batch remainder, projected as facts; not tool receipts or authorization. */
+    unexecutedCapabilities?: string[];
+    /** Rejected planning output; never an execution receipt or authorization. */
+    decisionFeedback?: 'undeclared-tool';
+    message: string;
+    history?: AssistantConversationMessage[];
+    context: AssistantSurfaceContext;
+    capabilities: AssistantCapabilityDescriptor[];
+    results?: AssistantCapabilityResult[];
+    selectionResponse?: AssistantSelectionResponse;
+}
+/** Provider-reported counts only. Missing counts are unknown, never estimated as zero. */
+export interface AssistantTokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+export interface AssistantTurnOutput {
+    /** Native model tool requests before interaction adaptation; includes unexecuted mixed calls. */
+    modelToolCallCount?: number;
+    usage?: AssistantTokenUsage;
+    text?: string;
+    toolCalls: AssistantCapabilityCall[];
+    selection?: AssistantSelectionInteraction;
+    finishReason?: string;
+    requestId?: string;
+}
+export type { OperationPresentation as AssistantResultPresentation } from './operation';
+import type { OperationPresentation as AssistantResultPresentation } from './operation';

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

@@ -0,0 +1,212 @@
+/** Bounded business clauses; grouping must not force the loss of explicit requirements. */
+export declare const constructionPlanLimits: {
+    readonly textItems: 64;
+    readonly structuredItems: 16;
+    readonly contentBytes: number;
+};
+/** Requirements consensus; never an executable schema or publication approval. */
+export interface ConstructionPlanContent {
+    title: string;
+    goal: string;
+    inScope: string[];
+    outOfScope: string[];
+    objects: {
+        key: string;
+        name: string;
+        purpose: string;
+        moduleAlias?: string | null;
+    }[];
+    relationships: string[];
+    rules: string[];
+    questions: string[];
+    assumptions: string[];
+    decisions: {
+        statement: string;
+        source: 'USER_REQUIREMENT' | 'RECOMMENDATION';
+    }[];
+    acceptanceExamples: string[];
+    requirements?: ConstructionRequirement[];
+}
+export interface ConstructionPlanSnapshot {
+    planId: string;
+    revision: number;
+    content: ConstructionPlanContent;
+    confirmedAt: string;
+    constructionStatus: 'NOT_STARTED' | 'LINKED' | 'INITIALIZED' | 'PARTIALLY_DELIVERED' | 'DELIVERED';
+    deliveredObjectKeys: string[];
+    /** Current explicit associations; old snapshots may only carry historical initialization receipts. */
+    moduleBindings?: {
+        objectKey: string;
+        moduleAlias: string;
+    }[];
+    initializations: ConstructionInitialization[];
+    fieldChanges: ConstructionFieldReceipt[];
+    deliveries: ConstructionDeliveryReceipt[];
+}
+export interface ConstructionPlanSummary {
+    planId: string;
+    title: string;
+    revision: number;
+    updatedAt: string;
+}
+export interface ConstructionInitialization {
+    objectKey: string;
+    planRevision: number;
+    moduleAlias: string;
+    metadataId: string;
+    relationId: string;
+    requestId: string;
+}
+export interface ConstructionInitializationResult {
+    receipt: ConstructionInitialization;
+    runtime: import('./index').DynamicRuntimeActivationStatus | null;
+}
+export interface ConstructionField {
+    name: string;
+    title: string;
+    specAlias: string;
+    required: boolean;
+    unique: boolean;
+    indexed: boolean;
+    titleField?: boolean;
+    reference?: {
+        targetModuleAlias: string;
+        targetMetadataId: string | null;
+        targetKeyField: string;
+        targetLabelField: string;
+        cardinality: 'ONE';
+        targetUnavailablePolicy: 'PRESERVE_HISTORY';
+        requireEnabled: boolean;
+        projectionMappings: string[];
+    } | null;
+}
+export interface ConstructionFieldDescription {
+    children?: Record<string, {
+        relation: import('./index').ModuleMetadataRelation;
+        metadataVersion: number;
+        fields: import('./index').MetadataField[];
+        references: Record<string, NonNullable<ConstructionField['reference']>>;
+    }>;
+    calculationRules?: {
+        alias: string;
+        targetField?: string | null;
+        expression: string;
+        version?: number;
+    }[];
+    moduleAlias: string;
+    planRevision: number;
+    metadataVersion: number;
+    references?: Record<string, NonNullable<ConstructionField['reference']>>;
+    fields: import('./index').MetadataField[];
+    specs: {
+        alias: string;
+        title: string;
+        type: string;
+        length: number | null;
+        precision: number | null;
+        scale: number | null;
+    }[];
+}
+export interface ConstructionFieldReceipt {
+    requestId: string;
+    objectKey: string;
+    planRevision: number;
+    moduleAlias: string;
+    fields: ConstructionField[];
+}
+export interface ConstructionFieldResult {
+    receipt: ConstructionFieldReceipt;
+    runtime: import('./index').DynamicRuntimeActivationStatus | null;
+}
+export interface ConstructionDeliveryProposal {
+    childFields?: Record<string, string[]>;
+    planRevision: number;
+    objectKey: string;
+    kind: 'PAGE' | 'ENTRY';
+    title: string;
+    listFields: string[];
+    formFields: string[];
+    searchFields: string[];
+}
+export interface ConstructionDeliveryPreview {
+    proposal: ConstructionDeliveryProposal;
+    moduleAlias: string;
+    lines: string[];
+    fingerprint: string;
+}
+export interface ConstructionDeliveryReceipt {
+    requestId: string;
+    objectKey: string;
+    planRevision: number;
+    kind: 'PAGE' | 'ENTRY';
+    moduleAlias: string;
+    pageId: string;
+    variantId: string;
+    revisionId: string;
+    menuId: string | null;
+    metadataVersion: number;
+}
+export interface ConstructionProgress {
+    objectKey: string;
+    moduleAlias: string;
+    runtimeStatus: string;
+    pagePublished: boolean;
+    entryVisible: boolean;
+    menuId: string | null;
+    needsReview: boolean;
+    acceptanceConfirmed: boolean;
+    /** Configuration progress is not an observation of tenant business records. */
+    businessDataStatus: 'NOT_QUERIED';
+    remainingWork: string[];
+    receipts: ConstructionDeliveryReceipt[];
+    requirements?: ConstructionRequirementEvidence[];
+}
+export interface ConstructionAcceptancePreview {
+    objectKey: string;
+    planRevision: number;
+    checks: string[];
+    fingerprint: string;
+}
+export interface ConstructionAcceptanceReceipt {
+    requestId: string;
+    objectKey: string;
+    planRevision: number;
+    baseline: string;
+}
+export interface ConstructionRequirement {
+    section: 'SCOPE' | 'RULE' | 'RELATION';
+    index: number;
+    objectKey: string;
+    mode: 'FIELD' | 'REQUIRED' | 'UNIQUE' | 'REFERENCE' | 'CHILD' | 'CALCULATION' | 'MANUAL' | 'UNSUPPORTED';
+    fieldName: string;
+    explanation: string;
+    reference?: {
+        objectKey: string;
+        moduleAlias: string;
+    } | null;
+}
+export interface ConstructionRequirementEvidence {
+    section: ConstructionRequirement['section'];
+    index: number;
+    statement: string;
+    objectKey: string;
+    fieldName: string;
+    status: 'UNMAPPED' | 'UNSUPPORTED' | 'CONFIGURATION_MISSING' | 'CONFIGURATION_MATCHED' | 'MANUAL_RESPONSIBILITY';
+    explanation: string;
+}
+export interface ConstructionTask {
+    planRevision: number;
+    /** Requirements whose object ownership has not been confirmed, reported once for the plan. */
+    unmappedRequirements: ConstructionRequirementEvidence[];
+    objects: {
+        objectKey: string;
+        title: string;
+        complete: boolean;
+        options: {
+            action: 'REVIEW_CURRENT_CONFIGURATION' | 'REVIEW_REQUIREMENTS' | 'INITIALIZE' | 'VERIFY_RUNTIME' | 'CONFIGURE_FIELDS' | 'REVIEW_CONFIGURATION' | 'PUBLISH_PAGE' | 'CREATE_ENTRY' | 'VERIFY_BUSINESS';
+            explanation: string;
+        }[];
+        requirements: ConstructionRequirementEvidence[];
+        progress?: Pick<ConstructionProgress, 'moduleAlias' | 'runtimeStatus' | 'pagePublished' | 'entryVisible' | 'menuId' | 'needsReview' | 'acceptanceConfirmed' | 'businessDataStatus' | 'remainingWork'> | null;
+    }[];
+}

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 {
@@ -409,6 +410,8 @@ export declare function hasExecutableDetailRelationMutationContract(relation: Re
 };
 export type MenuEntryType = 'module' | 'route' | 'link';
 export interface MenuRecord extends StandardEnabledTreeEntity {
+    /** Read-only hint from the target module; never maintained on menus. */
+    moduleDescription?: string;
     id: string;
     title: string;
     schemeId: string;
@@ -632,6 +635,8 @@ export interface WebReferenceResolveRequest {
 export interface WebReferenceResolveItem {
     id: string;
     title?: string;
+    /** Public, source-declared candidate context; never an arbitrary projection dump. */
+    subtitle?: string;
     matchedBy?: WebReferenceMatchMode;
     projections?: Record<string, unknown>;
     affectPatch?: Record<string, unknown>;
@@ -742,7 +747,9 @@ export interface ViewFieldRef {
     fieldName: string;
     fieldId?: string;
 }
+export type AssistantFieldPolicy = 'HIDDEN' | 'DESCRIBE' | 'READ' | 'READ_WRITE';
 export interface ViewFieldDefinition {
+    assistantPolicy?: AssistantFieldPolicy;
     fieldRef: ViewFieldRef;
     label?: string;
     visible?: UiRule<boolean>;
@@ -794,6 +801,18 @@ export interface ResolvedFieldControlBindingDescriptor {
     valueType: string;
 }
 export interface ResolvedViewFieldDescriptor {
+    /** Computed values are previews or are unavailable until the next successful save. */
+    calculationTiming?: 'IMMEDIATE' | 'ON_SAVE' | null;
+    inputRequirements?: {
+        requiredOnInsert: boolean;
+        requiredOnUpdate: boolean;
+        maxLength?: number | null;
+        validationRegex?: string | null;
+        textNormalization?: 'NONE' | 'TRIM' | 'TRIM_TO_NULL' | null;
+        precision?: number | null;
+        scale?: number | null;
+    };
+    assistantPolicy?: AssistantFieldPolicy;
     fieldRef: ViewFieldRef;
     label?: string;
     visible?: UiRule<boolean>;
@@ -1609,3 +1628,17 @@ export interface PurgeReport {
     purgeOperationId: string;
     entries: PurgeEntryResult[];
 }
+/** Committed configuration and the projections installed in the node serving this response. */
+export interface DynamicRuntimeActivationStatus {
+    moduleAlias: string;
+    desiredRevision: number | null;
+    lastSuccessfulRevision: number | null;
+    installedRevision: number | null;
+    status: 'UNTRACKED' | 'PENDING' | 'ACTIVE' | 'INACTIVE' | 'FAILED';
+    failureMessage: string | null;
+    attemptedAt: string | null;
+}
+export * from './constructionPlan';
+export type { ConstructionRequirement, ConstructionRequirementEvidence, ConstructionTask, } from './constructionPlan';
+export type { ReferenceTargetFieldCatalog, ReferenceTargetFieldCandidate } from './referenceTarget';
+export * from './operation';

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

@@ -0,0 +1,33 @@
+/** Platform operation presentation; never interpreted from model prose. */
+export interface OperationPresentation {
+    title: string;
+    lines: string[];
+    /** Secondary, fully reviewable details; never used as an execution payload. */
+    details?: {
+        title: string;
+        lines: string[];
+    };
+}
+/** A bounded read-only pointer, never an executable command or authority. */
+export type OperationReceiptReference = {
+    kind: 'record-save';
+    moduleAlias: string;
+    requestId: string;
+    tenantId?: string;
+    menuId?: string;
+    pageContext?: Record<string, string>;
+    pageSelection?: {
+        kind: string;
+        key: string;
+    };
+} | {
+    kind: 'child-metadata';
+    moduleAlias: string;
+    relationId: string;
+    requestId: string;
+} | {
+    kind: 'page-publication';
+    variantId: string;
+    revisionId: string;
+    contentDigest: string;
+};

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

@@ -0,0 +1,13 @@
+/** Configuration directory shared by standard editors and application construction. */
+export interface ReferenceTargetFieldCandidate {
+    fieldName: string;
+    title: string;
+    defaultField: boolean;
+    selectable: boolean;
+}
+export interface ReferenceTargetFieldCatalog {
+    targetModuleAlias: string;
+    targetMetadataId: string | null;
+    keyFields: ReferenceTargetFieldCandidate[];
+    labelFields: ReferenceTargetFieldCandidate[];
+}

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

@@ -0,0 +1,22 @@
+import type { AssistantCapabilityResult } from '../web-contracts/index';
+import type { AssistantCapability } from './assistantSurface';
+export declare const ASSISTANT_CAPABILITY_LOAD_CODE = "assistant.load-capabilities";
+export declare const ASSISTANT_CAPABILITY_SELECTION_LIMIT = 8;
+/** Discovery changes request context only. The live registry still owns execution and permission. */
+export declare function assistantCapabilityCatalog(capabilities: AssistantCapability[]): {
+    discovery: AssistantCapability<string[], unknown>;
+    project(results?: AssistantCapabilityResult[], selectedCodes?: string[], recoveryCodes?: string[]): {
+        descriptors: import("../web-contracts/index").AssistantCapabilityDescriptor[];
+        index: undefined;
+        selectedCodes: never[];
+        endDecisionAfter: string[];
+    } | {
+        endDecisionAfter: string[];
+        selectedCodes: string[];
+        descriptors: import("../web-contracts/index").AssistantCapabilityDescriptor[];
+        index: {
+            code: string;
+            description: string;
+        }[];
+    };
+};

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

@@ -0,0 +1,12 @@
+/** Model observation only; preparation still validates against the full authoritative catalog. */
+export declare function pageAssistantCatalog<T>(records: readonly T[], offset?: number, budget?: number): {
+    items: T[];
+    page: {
+        note?: string | undefined;
+        offset: number;
+        total: number;
+        nextOffset: number | null;
+        coverage: string;
+        oversizedIndexes: number[];
+    };
+};