@lmzhen/dsh-evolution-merge-ui 0.30.18 → 0.30.19

package/lib/types/client/MergeStore.d.ts

@@ -0,0 +1,74 @@
+/** Keyed read store for the merge panel. It never writes and keeps DOM state out. */
+import type { MergeBody, MergeFailure, MergeHistoryItem, MergeOutcome, MergeQueue, MergeRowView, MergeViewPayload, QueuePage } from './api.ts';
+export interface MergeSource {
+    view(): Promise<MergeOutcome<MergeViewPayload>>;
+    rows(queue: MergeQueue, cursor?: string, expiredOnly?: boolean): Promise<MergeOutcome<QueuePage>>;
+    body(name: string, side: 'live' | 'archive'): Promise<MergeOutcome<MergeBody>>;
+    history(): Promise<MergeOutcome<{
+        items: MergeHistoryItem[];
+    }>>;
+}
+export type QueueStatus = 'idle' | 'loading' | 'ready' | 'empty' | 'error';
+export interface QueueState {
+    status: QueueStatus;
+    rows: MergeRowView[];
+    nextCursor?: string | undefined;
+    failure?: MergeFailure | undefined;
+}
+export type OverlayState = {
+    kind: 'body';
+    name: string;
+    side: 'live' | 'archive';
+    status: 'loading' | 'ready' | 'error';
+    body?: MergeBody;
+    failure?: MergeFailure;
+} | {
+    kind: 'history';
+    status: 'loading' | 'ready' | 'error';
+    items?: MergeHistoryItem[];
+    failure?: MergeFailure;
+};
+export interface StoreSnapshot {
+    view: MergeViewPayload;
+    viewState: 'loading' | 'ready' | 'error' | 'blocked';
+    viewFailure?: MergeFailure | undefined;
+    queue: MergeQueue;
+    expiredOnly: boolean;
+    current: QueueState;
+    overlay?: OverlayState | undefined;
+}
+export interface MergeStoreInitial {
+    view?: MergeViewPayload;
+    rows?: MergeRowView[];
+    queue?: MergeQueue;
+    expiredOnly?: boolean;
+}
+export declare class MergeStore {
+    private readonly source;
+    private readonly listeners;
+    private readonly cache;
+    private readonly tokens;
+    private viewToken;
+    private overlayToken;
+    private snapshot;
+    private started;
+    private disposed;
+    constructor(source: MergeSource, initial?: MergeStoreInitial);
+    readonly read: () => StoreSnapshot;
+    readonly subscribe: (listener: () => void) => (() => void);
+    private emit;
+    private set;
+    private isCurrent;
+    start(): void;
+    loadView(showLoading?: boolean): Promise<void>;
+    loadQueue(queue: MergeQueue, expiredOnly: boolean, cursor?: string): Promise<void>;
+    select(queue: MergeQueue): void;
+    toggleExpired(): void;
+    refresh(): void;
+    loadMore(): void;
+    openBody(name: string, side: 'live' | 'archive'): Promise<void>;
+    openHistory(): Promise<void>;
+    closeOverlay(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=MergeStore.d.ts.map

package/lib/types/client/Panel.d.ts

@@ -1,19 +1,15 @@
-/**
- * The merge panel body: three queues, counts, and a read-only row list. Actions are
- * intentionally copied commands, not buttons that write from the browser.
- */
+/** Batch 4 merge panel: keyed read store, four tabs, local overlays, localized errors. */
 import { type ReactNode } from 'react';
-import type { MergeBody, MergeHistoryItem, MergeOutcome, MergeQueue, MergeRowView, MergeViewPayload, QueuePage } from './api.ts';
+import type { MergeStore } from './MergeStore.ts';
+import type { ConfigFormLike, SettingsFace } from './seam.ts';
+export type Translate = (key: string, values?: Readonly<Record<string, string | number>>) => string;
 export interface MergeFace {
-    view: MergeViewPayload;
-    rows: MergeRowView[];
-    loadView?: () => Promise<MergeOutcome<MergeViewPayload>>;
-    loadRows?: (queue: MergeQueue, cursor?: string, expiredOnly?: boolean) => Promise<MergeOutcome<QueuePage>>;
-    loadBody?: (id: string, side: 'a' | 'b') => Promise<MergeOutcome<MergeBody>>;
-    loadHistory?: () => Promise<MergeOutcome<{
-        items: MergeHistoryItem[];
-    }>>;
-    t: (key: string) => string;
+    store: MergeStore;
+    t: Translate;
+    doctorCommand?: string;
+    settings?: SettingsFace;
+    workspaceId?: string;
 }
+export declare function saveSetting(form: ConfigFormLike, field: string, value: boolean): Promise<boolean>;
 export declare function MergePanel(face: MergeFace): ReactNode;
 //# sourceMappingURL=Panel.d.ts.map

package/lib/types/client/api.d.ts

@@ -1,4 +1,3 @@
-import type { RouteFailure } from './route-client.generated.ts';
 export declare const HOST_ROUTES: {
     readonly view: "/api/dsh-evolution/merge/view";
     readonly rows: "/api/dsh-evolution/merge/rows";
@@ -8,12 +7,28 @@ export declare const HOST_ROUTES: {
     readonly history: "/api/dsh-evolution/merge/history";
 };
 export type MergeQueue = 'verify' | 'pending' | 'fuse' | 'skipped';
+export type StageState = 'reserved' | 'present' | 'expired' | 'lost' | 'absent';
 export interface MergeCounts {
     verify: number;
     pending: number;
     fuse: number;
     skipped: number;
 }
+export interface PlatformWrite {
+    enabled: boolean;
+    capability: boolean;
+}
+export interface MergeApproval {
+    mergeApproval: boolean;
+    platformWrite?: PlatformWrite;
+}
+export interface MergeRunAction {
+    id: string;
+    command: string;
+    confirm: boolean;
+    enabled: boolean;
+    disabledReason?: string;
+}
 export interface MergeRunView {
     id: string;
     state: string;
@@ -22,8 +37,19 @@ export interface MergeRunView {
     progress?: {
         done: number;
         total: number;
-    };
+    } | null;
     startedAt: number;
+    endedAt?: number;
+    failure?: {
+        stage: string;
+        code: string;
+        retryable: boolean;
+        detail?: string;
+    };
+    parentRunId?: string;
+    currentPairKey?: string;
+    resultRef?: string;
+    actions: MergeRunAction[];
 }
 export interface MergeViewPayload {
     counts: MergeCounts;
@@ -40,7 +66,7 @@ export interface MergeViewPayload {
     notes: string[];
     degraded: boolean;
     latestRun?: MergeRunView;
-    approval?: boolean;
+    approval: MergeApproval;
 }
 export interface RowActionView {
     id: string;
@@ -49,6 +75,15 @@ export interface RowActionView {
     enabled: boolean;
     disabledReason?: string;
 }
+export interface MergeStageView {
+    state: StageState;
+    expiresAt?: number;
+}
+export interface MergeSummarySlots {
+    a: string | null;
+    b: string | null;
+    rationale: string | null;
+}
 export interface MergeRowView {
     id: string;
     pairKey: string;
@@ -61,61 +96,86 @@ export interface MergeRowView {
     updatedAt: string;
     createdAt?: string;
     target?: string;
+    targetActual?: string;
+    targetCreated?: boolean;
     confidence?: number;
-    aSummary?: string;
-    bSummary?: string;
-    rationale?: string;
+    summary?: MergeSummarySlots;
+    reason?: string;
+    reasonCode?: string;
+    origin?: 'agent' | 'human' | 'system';
+    attempts?: number;
+    stagingExpiresAt?: number;
+    expired?: 'target-taken' | 'source-changed' | 'source-gone' | 'skipped-ttl';
+    stageView?: MergeStageView;
     failure?: {
         stage: string;
         code: string;
         message: string;
         retryable: boolean;
     };
-    attempts?: number;
-    origin?: 'agent' | 'human';
-    stagingExpiresAt?: number;
-    expired?: 'target-taken' | 'source-changed' | 'skipped-ttl';
-    reason?: string;
-    summary?: string[];
-    actions: RowActionView[];
-    targetActual?: string;
-    targetCreated?: boolean;
-    stagingState?: 'none' | 'kept' | 'cleared-source-ok' | 'cleared-source-gone';
     verifySubState?: 'queued' | 'running' | 'failed' | 'cancelled';
     skipKind?: 'agent-keep' | 'human-reject' | 'over-limit' | 'forced';
     bodies?: {
         name: string;
         side: 'live' | 'archive';
     }[];
+    actions: RowActionView[];
 }
 export interface QueuePage {
     queue: MergeQueue;
     items: MergeRowView[];
     nextCursor?: string;
+    counts: MergeCounts;
+    expiredOnly: boolean;
 }
 export interface MergeBody {
-    content: string;
+    name: string;
+    side: 'live' | 'archive';
+    text: string;
     markdown: boolean;
-    html: string;
+    truncated: boolean;
+    totalBytes: number;
 }
 export interface MergeHistoryItem {
     name: string;
     kind: 'merged' | 'deleted' | 'split' | 'other';
     reason: string;
+    reasonCode?: string;
     lastVersion: number;
     archivedAt: string;
     sourceRunId?: string;
 }
+export interface MergeStateReadiness {
+    readonly ok?: boolean;
+    readonly code?: string;
+    readonly message?: string;
+    readonly steps?: readonly string[];
+}
+export type MergeProblemKind = 'unauthenticated' | 'forbidden' | 'unmounted' | 'capability' | 'wire-version' | 'body-missing' | 'body-ambiguous' | 'bad-query' | 'refused' | 'server';
+export interface MergeProblem {
+    readonly kind: 'problem';
+    readonly code: MergeProblemKind;
+    readonly status: number;
+    readonly wireCode?: string;
+    readonly message?: string;
+}
+export interface MergeBlocked {
+    readonly kind: 'blocked';
+    readonly code: string;
+    readonly readiness: MergeStateReadiness;
+}
+export type MergeFailure = MergeProblem | MergeBlocked;
 export type MergeOutcome<T> = {
     ok: true;
     payload: T;
 } | {
     ok: false;
-    failure: RouteFailure;
+    failure: MergeFailure;
 };
+export declare const isBlocked: (failure: MergeFailure) => failure is MergeBlocked;
 export declare function view(): Promise<MergeOutcome<MergeViewPayload>>;
 export declare function rows(queue: MergeQueue, cursor?: string, expiredOnly?: boolean): Promise<MergeOutcome<QueuePage>>;
-export declare function body(id: string, side: 'a' | 'b'): Promise<MergeOutcome<MergeBody>>;
+export declare function body(name: string, side: 'live' | 'archive'): Promise<MergeOutcome<MergeBody>>;
 export declare function history(): Promise<MergeOutcome<{
     items: MergeHistoryItem[];
 }>>;

package/lib/types/client/fallbacks.d.ts

@@ -0,0 +1,3 @@
+/** Static command-face fallback for a Facts read failure; the API fallback is unavailable then. */
+export declare const FALLBACK_COMMANDS: readonly string[];
+//# sourceMappingURL=fallbacks.d.ts.map

package/lib/types/client/index.d.ts

@@ -1,7 +1,4 @@
-/**
- * Browser half: one sidebar row ("技能合并") and the read-only main body it opens.
- * All facts arrive through the generated routes; the bundle holds no service and writes nothing.
- */
+/** Browser half: one sidebar row and the read-only Batch 4 panel. */
 import type { Context as ClientContext } from '@deepseek-ai/cordis';
 export declare const inject: string[];
 export declare function apply(ctx: ClientContext): void;

package/lib/types/client/seam.d.ts

@@ -31,4 +31,24 @@ export interface ClientSeam {
     slots: SlotsSeat;
     locale: LocaleSeat;
 }
+/** One client settings row's readable/writable face (platform configForms). */
+export interface ConfigFormSnapshotLike {
+    status: 'loading' | 'ready' | 'unavailable';
+    value: Record<string, unknown> | undefined;
+    writable: boolean;
+    revision?: number;
+}
+export interface ConfigFormLike {
+    getSnapshot(): ConfigFormSnapshotLike;
+    subscribe(listener: () => void): () => void;
+    set(field: string, value: unknown): Promise<boolean>;
+    unset(field: string): Promise<boolean>;
+}
+export interface ConfigFormsSeat {
+    get(entryId: string): ConfigFormLike;
+}
+export interface SettingsFace {
+    merge?: ConfigFormLike;
+    platform?: ConfigFormLike;
+}
 //# sourceMappingURL=seam.d.ts.map

package/lib/types/client/sorting.d.ts

@@ -0,0 +1,25 @@
+/** Display-only row ordering for merge tabs; never part of the wire read. */
+import type { MergeQueue } from './api.ts';
+export interface StorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+export type RowOrderEdge = 'top' | 'bottom';
+/** Workspace scope for one tab. A missing panel workspace is the local scope. */
+export declare function resolveWorkspaceId(workspaceId: string | null | undefined): string;
+/** Stable localStorage key for one workspace and queue. */
+export declare function rowOrderKey(workspaceId: string | null | undefined, queue: MergeQueue): string;
+/** One tab's persisted order; failures degrade to an empty (wire) order. */
+export declare function createRowOrderStore(storage?: StorageLike | undefined): {
+    read(workspaceId: string | null | undefined, queue: MergeQueue): readonly string[];
+    write(workspaceId: string | null | undefined, queue: MergeQueue, ids: readonly string[]): void;
+};
+/** Apply persisted ids first, then append unknown rows in their wire order. */
+export declare function orderRows<T extends {
+    readonly id: string;
+}>(rows: readonly T[], order: readonly string[]): readonly T[];
+/** Move one visible row before another; unknown ids leave the order unchanged. */
+export declare function moveRow(order: readonly string[], fromId: string, beforeId: string | undefined): readonly string[];
+/** Pin one visible row to the top or bottom of the full visible order. */
+export declare function pinRow(order: readonly string[], id: string, edge: RowOrderEdge): readonly string[];
+//# sourceMappingURL=sorting.d.ts.map

package/package.json

@@ -11,7 +11,7 @@
       ]
     }
   },
-  "version": "0.30.18",
+  "version": "0.30.19",
   "publishConfig": {
     "access": "public"
   },