@ximatai/muyun-web-app 0.26.13 → 0.26.15

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

@@ -0,0 +1,23 @@
+import type { OperationReceiptReference, OperationPresentation } from '../web-contracts/index';
+import { type OperationProposal, type OperationConfirmation } from './operationConfirmation';
+export { OperationRejectedError as AssistantOperationRejectedError } from './operationConfirmation';
+export type { OperationConfirmationState as AssistantConfirmationState } from './operationConfirmation';
+/** Assistant-only explanation and continuation decorate a platform command. */
+export interface AssistantOperationProposal extends OperationProposal {
+    modelSummary?: string;
+    continuation?: {
+        message: string;
+        readOnly?: boolean;
+        isCurrent(): boolean;
+    };
+}
+export interface AssistantOperationConfirmation extends OperationConfirmation {
+    readonly modelSummary: string;
+    readonly receiptReference?: OperationReceiptReference;
+    readonly continuationReadOnly?: boolean;
+    readonly continuationIsCurrent?: () => boolean;
+    takeContinuation(): string | undefined;
+}
+export declare function createAssistantOperationConfirmation(proposal: AssistantOperationProposal, scopeIsCurrent: () => boolean, now?: () => number): AssistantOperationConfirmation;
+/** Recovered results have no execute path, expiry renewal, or automatic continuation. */
+export declare function restoreAssistantOperationReceipt(reference: OperationReceiptReference, lookup: () => Promise<OperationPresentation | undefined>, scopeIsCurrent: () => boolean): AssistantOperationConfirmation;

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

@@ -0,0 +1,42 @@
+import type { OperationReceiptReference, OperationPresentation } from '../web-contracts/index';
+import type { HttpClient } from './http';
+import type { AssistantConversationMessage } from '../web-contracts/index';
+export interface AssistantConfigurationTask {
+    goal: string;
+    mode: 'conversation' | 'visual';
+}
+export interface AssistantConversationContent {
+    configurationTask?: AssistantConfigurationTask;
+    /** Scope of model history, not conversation ownership or permission. */
+    executionScopeKey?: string;
+    title: string;
+    messages: Array<{
+        role: 'user' | 'assistant' | 'status';
+        text: string;
+        operationReceipt?: {
+            reference: OperationReceiptReference;
+            executionScopeKey: string;
+        };
+    }>;
+    history: AssistantConversationMessage[];
+    planId?: string;
+    pendingRequest?: string;
+}
+export interface AssistantConversationSnapshot {
+    id: string;
+    revision: number;
+    updatedAt: string;
+    content: AssistantConversationContent;
+}
+export interface AssistantConversationSummary {
+    id: string;
+    title: string;
+    updatedAt: string;
+}
+export interface AssistantConversationClient {
+    lookupOperation?(reference: OperationReceiptReference): Promise<OperationPresentation | undefined>;
+    list(scopeKey: string, page: number): Promise<AssistantConversationSummary[]>;
+    read(id: string, scopeKey: string): Promise<AssistantConversationSnapshot>;
+    save(id: string, scopeKey: string, expectedRevision: number, content: AssistantConversationContent): Promise<AssistantConversationSnapshot>;
+}
+export declare function createAssistantConversationClient(http: HttpClient): AssistantConversationClient;

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

@@ -0,0 +1,123 @@
+import type { AssistantModelRequestObservation } from './assistantTurnClient';
+import type { AssistantOperationConfirmation } from './assistantConfirmation';
+import type { AssistantCapabilityResult, AssistantConversationMessage, AssistantSelectionResponse, AssistantTurnOutput } from '../web-contracts/index';
+import { type AssistantInvocationToken, type AssistantCapabilitySelection, type AssistantExecutionPolicy, type AssistantSurfaceRegistry } from './assistantSurface';
+/** Shared transport limits: newest dialogue and display observations fit the existing history contract. */
+export declare function boundedAssistantConversationHistory(history: AssistantConversationMessage[]): AssistantConversationMessage[];
+/** Ephemeral, display-only evidence within the existing conversation budget. Never archived or executable. */
+export declare function createAssistantDisplayObservations(): {
+    clear: () => void;
+    forScope: (token: AssistantInvocationToken | undefined) => {
+        role: "status";
+        text: string;
+    }[];
+    record(token: AssistantInvocationToken, observation: {
+        pageInstanceKey: string;
+        text: string;
+    }): void;
+};
+export type AssistantDisplayObservations = ReturnType<typeof createAssistantDisplayObservations>;
+export interface AssistantRuntimeStepResult {
+    output: AssistantTurnOutput;
+    confirmations?: AssistantOperationConfirmation[];
+    results: AssistantCapabilityResult[];
+    contextChanged: boolean;
+    /** Successful capability invocations that committed an effect through applyEffect in this step. */
+    appliedEffectCount: number;
+}
+export interface AssistantConversationOptions {
+    /** Bounded schema names owned by the current conversation, never persisted or replayed. */
+    capabilitySelection?: AssistantCapabilitySelection;
+    displayObservations?: AssistantDisplayObservations;
+    executionPolicy?: AssistantExecutionPolicy;
+    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>;
+    /** A validated navigation crossed execution scopes; previous model observations were discarded. */
+    onExecutionScopeChange?(): 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: 'model.request.completed';
+    phase: 'work' | 'summary';
+    stepIndex: number;
+} & AssistantModelRequestObservation) | {
+    type: 'capability.elapsed';
+    stepIndex: number;
+    capabilityCode: string;
+    durationMs: number;
+} | {
+    type: 'decision.started';
+    stepIndex: number;
+    surface: AssistantDiagnosticSurface;
+    backgroundContextRefreshed: boolean;
+} | {
+    type: 'decision.completed';
+    usage?: AssistantTurnOutput['usage'];
+    stepIndex: number;
+    finishReason?: AssistantDiagnosticFinishReason;
+    toolCallCount: number;
+    hasText: boolean;
+} | {
+    type: 'decision.restarted';
+    stepIndex: number;
+    attempt: number;
+    reason: 'background-context-refresh' | 'formal-surface-ready' | 'undeclared-tool';
+} | {
+    type: 'decision.failed';
+    stepIndex: number;
+    reason: 'context-changed' | 'cancelled' | 'surface-unavailable' | 'surface-settlement-failed' | 'model-request-failed';
+} | {
+    type: 'capability.completed';
+    stepIndex: number;
+    capabilityCode: string;
+    outcome: 'succeeded' | 'failed' | 'replayed';
+    pageEffectApplied: boolean;
+} | {
+    type: 'budget.progress';
+    stepIndex: number;
+    newObservations: number;
+    appliedEffects: number;
+    extended: boolean;
+} | {
+    type: 'summary.completed';
+    usage?: AssistantTurnOutput['usage'];
+    succeeded: boolean;
+    reason?: 'truncated' | 'undeclared-tool' | 'provider-rejected' | 'invalid-summary' | 'request-failed';
+} | {
+    type: 'conversation.completed';
+    stepCount: number;
+    bounded: boolean;
+};
+export interface AssistantConversationResult {
+    steps: AssistantRuntimeStepResult[];
+    termination: 'stopped' | 'waiting-for-user' | 'repeated-call' | 'step-limit';
+}
+export declare class AssistantConversationInterruptedError extends Error {
+    readonly steps: readonly AssistantRuntimeStepResult[];
+    readonly termination: 'cancelled' | 'context-changed' | 'execution-interrupted' | 'model-failed';
+    constructor(steps: readonly AssistantRuntimeStepResult[], cause: unknown, termination?: 'cancelled' | 'context-changed' | 'execution-interrupted' | 'model-failed');
+}
+/**
+ * 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,162 @@
+import { type AssistantOperationProposal, type AssistantOperationConfirmation } from './assistantConfirmation';
+import type { AssistantCapabilityCall, AssistantResultPresentation, AssistantCapabilityDescriptor, AssistantSurfaceContext, AssistantTurnInput, AssistantTurnOutput } from '../web-contracts/index';
+import type { AssistantTurnProgress } from './assistantTurnClient';
+export interface AssistantCapability<TInput = unknown, TOutput = unknown> {
+    descriptor: AssistantCapabilityDescriptor;
+    /** Trusted adapter hint for a small current-surface schema set; never execution authority. */
+    schemaDiscovery?: 'eager';
+    /** Trusted implementation effect boundary; read capabilities cannot mutate the page. */
+    effect: 'read' | 'page' | 'draft' | 'configuration-draft';
+    /** Descriptive boundary for reads that replace selection/candidate state; never authority. */
+    changesReadState?: boolean;
+    present?(output: TOutput): AssistantResultPresentation;
+    propose?(output: TOutput): AssistantOperationProposal;
+    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;
+    /**
+     * Synchronously commit a page effect, retaining its scope while background work settles.
+     * Async preparation belongs before this call; background completion belongs in settle.
+     * Navigation adapters may return the token of an explicitly validated replacement surface.
+     */
+    applyEffect<T>(effect: () => T extends PromiseLike<unknown> ? never : T, settle?: () => Promise<void | AssistantInvocationToken>): T;
+}
+export interface AssistantSurface {
+    describe(): AssistantSurfaceContext;
+    /** Authorized display facts only: no extra queries, execution inputs, IDs or authority. */
+    observationSummary?(): string | undefined;
+    capabilities(): AssistantCapability[];
+    requestTurn(input: AssistantTurnInput, signal: AbortSignal, progress?: AssistantTurnProgress): Promise<AssistantTurnOutput>;
+}
+export interface AssistantSurfaceRegistration {
+    pageInstanceKey: string;
+    /** Opaque execution-data boundary, never sent to the model. */
+    executionScopeKey?(): string;
+    /** A fallback awaiting its real page transport must not issue model requests. */
+    executionScopePending?: boolean;
+    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 {
+    identityScopeKey?: string;
+    executionScopePending?: boolean;
+    executionScopeKey?: string;
+    pageInstanceKey: string;
+    surfaceGeneration: number;
+    /** Invalidates observations when selection or candidate state changes without a page effect. */
+    readStateRevision?: number;
+    contextRevision: string;
+    interactionRevision?: string;
+    fallback: boolean;
+}
+export interface AssistantSurfaceSnapshot {
+    token: AssistantInvocationToken;
+    context: AssistantSurfaceContext;
+    /** Historical display evidence; never an executable context or capability. */
+    observationSummary?: string;
+    capabilities: AssistantCapabilityDescriptor[];
+}
+/** Per-request restriction selected by the caller, never by model output. */
+export interface AssistantExecutionPolicy {
+    readOnly?: boolean;
+}
+/** Conversation-local schema choices; never business observations, inputs or execution authority. */
+export interface AssistantCapabilitySelection {
+    forScope(token: AssistantInvocationToken | undefined): string[];
+    remember(token: AssistantInvocationToken, codes: string[]): void;
+    clear(): void;
+}
+export declare function createAssistantCapabilitySelection(): AssistantCapabilitySelection;
+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'> & {
+        capabilitySelection?: AssistantCapabilitySelection;
+        /** Missing declarations from a rejected decision; filtered through the current allowed catalog. */
+        declarationRecoveryCodes?: string[];
+    }, token: AssistantInvocationToken, signal?: AbortSignal, progress?: AssistantTurnProgress, policy?: AssistantExecutionPolicy): Promise<AssistantTurnOutput>;
+    invoke(call: AssistantCapabilityCall, token: AssistantInvocationToken, signal?: AbortSignal, policy?: AssistantExecutionPolicy): Promise<{
+        value: unknown;
+        contextChanged: boolean;
+        readStateChanged?: boolean;
+        presentation?: AssistantResultPresentation;
+        confirmation?: AssistantOperationConfirmation;
+    }>;
+}
+/** Current live editor state; never restored from conversation history. */
+export interface AssistantConfigurationEditor {
+    kind?: 'metadata' | 'page' | 'rules';
+    openingCapability?: string;
+    moduleAlias?: string;
+    title: string;
+    hasUnsavedChanges: boolean;
+    visible: boolean;
+    open?(): void;
+}
+/** Workbench-owned context and capabilities contributed by a configuration editor or other domain. */
+export interface AssistantWorkspaceContribution {
+    editor?(): AssistantConfigurationEditor | undefined;
+    current(): {
+        revision: string;
+        facts: Record<string, unknown>;
+    };
+    capabilities(settleNavigation?: (signal?: AbortSignal, requireFormal?: boolean) => Promise<void | AssistantInvocationToken>): AssistantCapability[];
+}
+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();
+}
+import { OperationUsageError } from './operationErrors';
+/** Preserves the public assistant error contract at the adapter boundary. */
+export declare class AssistantCapabilityUsageError extends OperationUsageError {
+    constructor(message: string, code?: OperationUsageError['code']);
+}
+/** An effect started before interruption. Contains no business output from an obsolete scope. */
+export declare class AssistantEffectInterruptedError extends Error {
+    readonly token: AssistantInvocationToken;
+    readonly execution: 'effect-applied' | 'unknown';
+    constructor(token: AssistantInvocationToken, execution: 'effect-applied' | 'unknown', cause: unknown);
+}
+export declare function createAssistantSurfaceRegistry(identityScope?: () => string, workspaceContext?: () => {
+    revision: string;
+    facts: Record<string, unknown>;
+}): 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,16 @@
+import type { AssistantTurnInput, AssistantTurnOutput, AssistantTokenUsage } from '../web-contracts/index';
+import { type HttpClient } from './http';
+export interface AssistantTurnProgress {
+    onTextDelta?(text: string): void;
+    /** Observed before stale response rejection; never a business receipt. */
+    onRequestCompleted?(observation: AssistantModelRequestObservation): void | Promise<void>;
+}
+export interface AssistantModelRequestObservation {
+    durationMs: number;
+    outcome: 'received' | 'failed';
+    usage?: AssistantTokenUsage;
+    toolCallCount?: number;
+}
+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/constructionPlanClient.d.ts

@@ -0,0 +1,55 @@
+import type { ConstructionPlanContent, ReferenceTargetFieldCatalog, ConstructionTask, ConstructionAcceptancePreview, ConstructionAcceptanceReceipt, ConstructionDeliveryReceipt, ConstructionProgress, ConstructionFieldDescription, ConstructionFieldResult, ConstructionInitializationResult, ConstructionPlanSnapshot, ConstructionPlanSummary } from '../web-contracts/index';
+import type { HttpClient } from './http';
+export interface ConstructionPlanClient {
+    designContract(): Promise<{
+        recordName: {
+            fieldName: string;
+            columnName: string;
+            fieldType: string;
+        };
+        inheritedFields: string[];
+        declarableCapabilities: {
+            capabilities: string[];
+            metadataFields: {
+                fieldName: string;
+                columnName: string;
+                fieldSpecAlias: string;
+                defaultKind: string;
+                defaultDescription: string;
+            }[];
+        };
+    }>;
+    businessObjects(): Promise<{
+        alias: string;
+        title: string;
+        applicationAlias: string;
+        applicationTitle: string | null;
+        kind: string;
+        referenceReady: boolean;
+        explanation: string;
+    }[]>;
+    referenceTarget(moduleAlias: string): Promise<ReferenceTargetFieldCatalog>;
+    task(id: string): Promise<ConstructionTask>;
+    previewAcceptance(id: string, objectKey: string): Promise<ConstructionAcceptancePreview>;
+    confirmAcceptance(id: string, command: {
+        requestId: string;
+        objectKey: string;
+        fingerprint: string;
+    }): Promise<ConstructionAcceptanceReceipt>;
+    acceptance(id: string, requestId: string): Promise<ConstructionAcceptanceReceipt | undefined>;
+    delivery(id: string, requestId: string): Promise<ConstructionDeliveryReceipt | undefined>;
+    progress(id: string, objectKey: string): Promise<ConstructionProgress>;
+    describeFields(id: string, objectKey: string): Promise<ConstructionFieldDescription>;
+    fieldChange(id: string, requestId: string): Promise<ConstructionFieldResult | undefined>;
+    initialization(id: string, objectKey: string): Promise<ConstructionInitializationResult | undefined>;
+    list(): Promise<ConstructionPlanSummary[]>;
+    read(id: string): Promise<ConstructionPlanSnapshot>;
+    history(id: string): Promise<ConstructionPlanSnapshot[]>;
+    confirm(id: string, command: {
+        requestId: string;
+        expectedRevision: number;
+        content: ConstructionPlanContent;
+    }): Promise<ConstructionPlanSnapshot>;
+    confirmation(id: string, requestId: string): Promise<ConstructionPlanSnapshot | undefined>;
+}
+export declare function createConstructionPlanClient(http: HttpClient): ConstructionPlanClient;

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

@@ -62,4 +62,6 @@ export declare class AppError extends Error {
 export declare function normalizeError(error: unknown): AppError;
 export declare function resolveGlobalErrorPresentation(error: AppError, context?: ErrorUiContext): GlobalErrorPresentation;
 export declare function userFacingErrorMessage(error: AppError): string;
+/** Fixed explanations for known model failures; never expose arbitrary upstream 5xx text. */
+export declare function modelFailureMessage(error: AppError): string | undefined;
 export declare function isUnexpectedPlatformError(error: AppError): boolean;

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

@@ -13,6 +13,7 @@ export interface HttpRequestOptions {
     path: string;
     query?: Record<string, RouteQueryValue>;
     body?: unknown;
+    responseType?: 'json' | 'blob';
     headers?: Record<string, string>;
     /** Cancels the underlying Fetch request, including a long-lived response stream. */
     signal?: AbortSignal;

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

@@ -1,7 +1,12 @@
 export * from './errors';
 export * from './http';
+export * from './sse';
 export * from './query';
 export * from './actionResult';
+export * from './assistantSurface';
+export * from './assistantCatalogPage';
+export * from './assistantRuntime';
+export * from './assistantTurnClient';
 export * from './businessNotifications';
 export * from './dataChanges';
 export * from './realtime';
@@ -10,3 +15,10 @@ export * from './referenceResolveClient';
 export { userPreferences } from './userPreferences';
 export type { UserPreferenceOptions, UserPreferenceStore } from './userPreferences';
 export * from './module/index';
+export * from './assistantConfirmation';
+export * from './constructionPlanClient';
+export * from './assistantConversationClient';
+export * from './operationConfirmation';
+export * from './operationErrors';
+export * from './operationReceipt';
+export * from './uuid';

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

@@ -0,0 +1,53 @@
+import type { HttpClient } from '../http';
+import type { WebQueryRequest } from '../../web-contracts/index';
+export type ImportDuplicateStrategy = 'ERROR' | 'SKIP' | 'OVERWRITE';
+export interface ImportSheet {
+    sheetName: string;
+    entityAlias: string;
+    main: boolean;
+    rowCount: number;
+    fields: Array<{
+        fieldName: string;
+        title: string;
+        matchKeyCandidate: boolean;
+    }>;
+}
+export interface ImportParseResult {
+    sheets: ImportSheet[];
+}
+export interface ImportExecutionCommand {
+    mainSheet: {
+        matchFieldName: string;
+        duplicateStrategy: ImportDuplicateStrategy;
+    };
+    childSheets: Array<{
+        entityAlias: string;
+        matchFieldName: string;
+        duplicateStrategy: ImportDuplicateStrategy;
+    }>;
+}
+export interface ImportExecutionResult {
+    created: number;
+    updated: number;
+    skipped: number;
+    errorCount: number;
+    summaries?: Record<string, {
+        entityAlias: string;
+        created: number;
+        updated: number;
+        skipped: number;
+        errors: number;
+    }>;
+    partialSuccess: boolean;
+    message: string;
+    errorFileName?: string;
+    errorFileToken?: string;
+}
+/** Dynamic EXCHANGE transport; domain execution remains behind the module's standard action scope. */
+export declare function createDataExchangeClient(http: HttpClient, moduleAlias: string): {
+    template: () => Promise<Blob>;
+    parse(file: File): Promise<ImportParseResult>;
+    execute(file: File, command: ImportExecutionCommand): Promise<ImportExecutionResult>;
+    errorFile: (token: string) => Promise<Blob>;
+    exportData(request: WebQueryRequest): Promise<Blob>;
+};

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

@@ -5,3 +5,4 @@ export type { ModuleActionState, ModuleRecordActionAvailability, ModuleRuntimeAc
 export type { ModuleAbilityClients, ModuleAbilities } from './abilities';
 export * from './moduleContext';
 export * from './pageActionEntries';
+export * from './dataExchangeClient';

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

@@ -11,13 +11,23 @@ export interface QuerySchemaRequestOptions {
     uiConfigId?: string;
     queryTemplateId?: string;
 }
+export interface RecordSaveRequestOptions {
+    requestId: string;
+}
+export interface RecordSaveReceipt {
+    committed: boolean;
+    recordId?: string;
+    recordVersion?: number;
+    actionCode?: string;
+}
 /** Source-neutral client for a platform module's standard CRUD contract. */
 export interface ModuleCrudClient<TRecord> {
     querySchema(options?: QuerySchemaRequestOptions): Promise<QuerySchema>;
     query(request?: WebQueryRequest): Promise<WebPageResponse<TRecord>>;
     view(id: string): Promise<TRecord>;
-    insert(record: TRecord): Promise<StaticRecordMutationResult<TRecord>>;
-    update(id: string, record: TRecord): Promise<StaticRecordMutationResult<TRecord>>;
+    insert(record: TRecord, options?: RecordSaveRequestOptions): Promise<StaticRecordMutationResult<TRecord>>;
+    update(id: string, record: TRecord, options?: RecordSaveRequestOptions): Promise<StaticRecordMutationResult<TRecord>>;
+    saveReceipt?(requestId: string): Promise<RecordSaveReceipt>;
     delete(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
     enable(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
     disable(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;

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

@@ -0,0 +1,28 @@
+import type { OperationPresentation, OperationReceiptReference } from '../web-contracts/index';
+/** Captured platform command. The caller owns the candidate and execution scope. */
+export interface OperationProposal {
+    receiptReference?: OperationReceiptReference;
+    presentation: OperationPresentation;
+    confirmLabel?: string;
+    expiresAt: number;
+    isCurrent(): boolean;
+    /** Submits the captured payload using the same durable request identity on every attempt. */
+    execute(): Promise<OperationPresentation>;
+    /** A missing receipt is not permission to automatically resubmit. */
+    lookup(): Promise<OperationPresentation | undefined>;
+}
+export type OperationConfirmationState = 'pending' | 'executing' | 'checking' | 'succeeded' | 'unknown' | 'cancelled' | 'expired' | 'rejected';
+/** Adapter proof that no persistent operation was accepted (validation or authorization rejection). */
+export declare class OperationRejectedError extends Error {
+}
+export interface OperationConfirmation {
+    readonly confirmLabel: string;
+    readonly presentation: OperationPresentation;
+    readonly state: OperationConfirmationState;
+    readonly result: OperationPresentation | undefined;
+    confirm(): Promise<void>;
+    check(): Promise<void>;
+    cancel(): void;
+}
+/** Explicit confirmation, duplicate-click protection and read-only recovery of uncertain writes. */
+export declare function createOperationConfirmation(proposal: OperationProposal, scopeIsCurrent: () => boolean, now?: () => number): OperationConfirmation;

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

@@ -0,0 +1,9 @@
+/** A rejected editor operation with safe, bounded feedback for callers. */
+export declare class OperationUsageError extends Error {
+    readonly code: 'CAPABILITY_USAGE_INVALID' | 'CANDIDATE_AMBIGUOUS' | 'CANDIDATE_EXPIRED' | 'PRECONDITION_FAILED';
+    constructor(message: string, code?: 'CAPABILITY_USAGE_INVALID' | 'CANDIDATE_AMBIGUOUS' | 'CANDIDATE_EXPIRED' | 'PRECONDITION_FAILED');
+}
+/** A staged draft was rejected before publication; no draft or display state was changed. */
+export declare class DraftUpdateRejectedError extends OperationUsageError {
+    constructor(failure: OperationUsageError);
+}

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

@@ -0,0 +1,10 @@
+import type { OperationPresentation, OperationReceiptReference } from '../web-contracts/index';
+import type { HttpClient } from './http';
+/** Only query identities survive a conversation. Payloads, permissions and confirmation are never restored. */
+export declare function parseOperationReceiptReference(value: unknown): OperationReceiptReference;
+export declare function pagePublicationDigest(revision: {
+    templateAlias?: string;
+    templateVersion?: number;
+    uiTreeJson?: string;
+}): Promise<string>;
+export declare function lookupOperationReceipt(http: HttpClient, input: OperationReceiptReference): Promise<OperationPresentation | undefined>;

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;
+};

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

@@ -0,0 +1,2 @@
+/** Generate a random UUID, including on LAN HTTP where randomUUID is unavailable. */
+export declare function createUuid(): string;