@morlay/ui-conversation-message-actions 0.0.17 → 0.0.19-alpha.0

package/dist/client.d.cts

@@ -0,0 +1,6 @@
+import { Context } from "@deepseek-ai/cordis";
+//#region src/client/index.d.ts
+declare const inject: string[];
+declare function apply(ctx: Context): void;
+//#endregion
+export { apply, inject };

package/dist/client.d.mts

@@ -0,0 +1,6 @@
+import { Context } from "@deepseek-ai/cordis";
+//#region src/client/index.d.ts
+declare const inject: string[];
+declare function apply(ctx: Context): void;
+//#endregion
+export { apply, inject };

package/dist/index.d.cts

@@ -0,0 +1,98 @@
+import { C as SessionEditorResult, S as SessionEditorOperation, _ as RecallOperation, b as RetryableTurn, c as editableMessages, g as EditableMessageBlock, h as EditOperation, i as closedTurns, m as retryableTurns, v as RerollOperation, x as RewindOperation, y as RetryOperation } from "./plan-CT_6Y1fD.cjs";
+import { Context, Service } from "@deepseek-ai/cordis";
+import { UserMessage } from "@deepseek-ai/dsh-llm";
+import { AgentCancelCause, Session, SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
+import { BranchBoundary, BranchTimeline, BranchTimeline as BranchTimeline$1, CascadePolicy, EditableBlockKind, SESSION_BRANCH_VERSION_SCHEMA, SessionBranchVersionEvent } from "@morlay/session-branch";
+//#region src/index.d.ts
+declare module "@deepseek-ai/cordis" {
+  interface Context {
+    sessionEditor: SessionEditor;
+  }
+}
+interface EditorAgent {
+  readonly session: Session;
+  followup(message: UserMessage): void;
+  whenIdle(): Promise<void>;
+  cancel?(cause: AgentCancelCause, options?: {
+    keepInbox?: boolean;
+  }): void;
+}
+interface EditorAgentHandle {
+  readonly agent: EditorAgent;
+  dispose(): Promise<void>;
+}
+interface EditorAgentRegistry {
+  get(sessionId: SessionId): EditorAgent | undefined;
+  create(options: {
+    sessionId?: SessionId;
+    seed?: readonly SessionEvent[];
+    meta?: {
+      cwd?: string;
+      parentSession?: SessionId;
+      seedLength?: number;
+      agentPreset?: string;
+    };
+    agentOptions?: {
+      provider: string;
+      model: string;
+      maxTokens?: number;
+    };
+  }): Promise<EditorAgentHandle>;
+  resume(options: {
+    resumeSessionId: SessionId;
+    agentOptions?: {
+      provider: string;
+      model: string;
+      maxTokens?: number;
+    };
+  }): Promise<EditorAgentHandle>;
+}
+declare class SessionEditor extends Service {
+  static inject: string[];
+  constructor(ctx: Context);
+  readBranchPrefix(id: SessionId, atSeq?: number, mode?: "after" | "before", signal?: AbortSignal): Promise<BranchBoundary>;
+  fork(sourceId: SessionId, atSeq?: number, childSessionId?: SessionId, meta?: {
+    cwd?: string;
+    agentPreset?: string;
+  }, signal?: AbortSignal): Promise<SessionId>;
+  rewind(id: SessionId, toBoundary: number, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionPersistenceSnapshot>;
+  timeline(sessionId: SessionId, signal?: AbortSignal): Promise<BranchTimeline$1>;
+  edit(operation: EditOperation, signal?: AbortSignal): Promise<SessionEditorResult>;
+  reroll(operation: RerollOperation, signal?: AbortSignal): Promise<SessionEditorResult>;
+  retry(operation: RetryOperation, signal?: AbortSignal): Promise<SessionEditorResult>;
+  recall(operation: RecallOperation, signal?: AbortSignal): Promise<SessionEditorResult>;
+  editableMessages(sessionId: SessionId, signal?: AbortSignal): Promise<EditableMessageBlock[]>;
+  retryableTurns(sessionId: SessionId, signal?: AbortSignal): Promise<RetryableTurn[]>;
+  private branchOperation;
+  private recallOperation;
+  private seedStart;
+  private appendSeedSuffix;
+  private stopLoop;
+  private readEvents;
+  private prepareReplay;
+}
+interface HttpRequestLike {
+  method?: string;
+  url?: string;
+  on(event: "data", listener: (chunk: Uint8Array | string) => void): this;
+  on(event: "end", listener: () => void): this;
+  on(event: "error", listener: (error: unknown) => void): this;
+}
+interface HttpResponseLike {
+  writeHead(status: number, headers?: Record<string, string>): unknown;
+  end(body?: string): void;
+}
+interface HttpServerLike {
+  register(route: {
+    kind: "exact";
+    path: string;
+    handler: (request: HttpRequestLike, response: HttpResponseLike) => void | Promise<void>;
+  }): () => void;
+}
+declare module "@deepseek-ai/cordis" {
+  interface Context {
+    webServer: HttpServerLike;
+  }
+}
+//#endregion
+export { type BranchTimeline, type CascadePolicy, type EditOperation, type EditableBlockKind, type EditableMessageBlock, EditorAgent, EditorAgentHandle, EditorAgentRegistry, type RecallOperation, type RerollOperation, type RetryOperation, type RetryableTurn, type RewindOperation, SESSION_BRANCH_VERSION_SCHEMA, type SessionBranchVersionEvent, SessionEditor, SessionEditor as default, type SessionEditorOperation, type SessionEditorResult, closedTurns, editableMessages, retryableTurns };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { _ as RetryableTurn, b as SessionEditorResult, d as retryableTurns, f as EditOperation, g as RetryOperation, h as RerollOperation, m as RecallOperation, o as editableMessages, p as EditableMessageBlock, r as closedTurns, v as RewindOperation, y as SessionEditorOperation } from "./plan-BSa7k9HO.mjs";
+import { C as SessionEditorResult, S as SessionEditorOperation, _ as RecallOperation, b as RetryableTurn, c as editableMessages, g as EditableMessageBlock, h as EditOperation, i as closedTurns, m as retryableTurns, v as RerollOperation, x as RewindOperation, y as RetryOperation } from "./plan-Cm9hCord.mjs";
 import { Context, Service } from "@deepseek-ai/cordis";
 import { AgentCancelCause, Session, SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
 import { BranchBoundary, BranchTimeline, BranchTimeline as BranchTimeline$1, CascadePolicy, EditableBlockKind, SESSION_BRANCH_VERSION_SCHEMA, SessionBranchVersionEvent } from "@morlay/session-branch";
@@ -12,7 +12,6 @@ declare module "@deepseek-ai/cordis" {
 interface EditorAgent {
   readonly session: Session;
   followup(message: UserMessage): void;
-  /** 等待 agent 到达 quiescence（当前 turn/任务结束后 resolve）。 */
   whenIdle(): Promise<void>;
   cancel?(cause: AgentCancelCause, options?: {
     keepInbox?: boolean;
@@ -65,15 +64,9 @@ declare class SessionEditor extends Service {
   editableMessages(sessionId: SessionId, signal?: AbortSignal): Promise<EditableMessageBlock[]>;
   retryableTurns(sessionId: SessionId, signal?: AbortSignal): Promise<RetryableTurn[]>;
   private branchOperation;
-  /**
-   * 撤回（recall）：只 rewind 截断，不重写、不重放——被撤回的 user 消息文本
-   * 由客户端回填到输入框，交给用户修改后重新发送。
-   *
-   * 边界见 {@link recallBoundary}：轮首消息整轮截断到前一轮 `turn/end`
-   * （无前轮则 -1），轮内 followup 与轮外 user 消息只截断到该消息本身
-   * （exclusive drop），避免留下悬空 `turn/start` 让下一次发送开到错误轮号。
-   */
   private recallOperation;
+  private seedStart;
+  private appendSeedSuffix;
   private stopLoop;
   private readEvents;
   private prepareReplay;

package/dist/index.mjs

@@ -1,3 +1,461 @@
-import { n as SessionEditor, t as SESSION_BRANCH_VERSION_SCHEMA } from "./src-B4HwXsob.mjs";
-import { closedTurns, editableMessages, retryableTurns } from "./plan.mjs";
+import { n as toTimelinePayload, t as SESSION_EDITOR_PATH } from "./shared-LK3nImWW.mjs";
+import { closedTurns, droppedCompactions, editPlan, editableMessages, precedingContentIndex, recallBoundary, rerollPlan, restoreCompactions, retryPlan, retryableTurns } from "./plan.mjs";
+import { Service } from "@deepseek-ai/cordis";
+import { SessionSeq } from "@deepseek-ai/dsh-session";
+import { SESSION_BRANCH_VERSION_SCHEMA, SessionBranchError, balanceRewindPrefix } from "@morlay/session-branch";
+//#region src/index.ts
+function appendLogSeedEvent(events, type, data, ignorable = false) {
+	events.push({
+		type,
+		seq: events.length,
+		time: Date.now(),
+		data,
+		...ignorable ? { ignorable: true } : {}
+	});
+}
+function appendSurfaceSeedEvent(events, type, data, intent) {
+	events.push({
+		type,
+		seq: SessionSeq(events.length),
+		time: Date.now(),
+		data,
+		surfaceOp: intent.surfaceOp,
+		...intent.sourceEventSeqs === void 0 ? {} : { sourceEventSeqs: intent.sourceEventSeqs }
+	});
+}
+function appendManualTurn(events, manual) {
+	const { turn, user, assistant } = manual;
+	appendLogSeedEvent(events, "turn/start", { turn });
+	appendSurfaceSeedEvent(events, "user/message", user, { surfaceOp: "append" });
+	appendLogSeedEvent(events, "step/start", {
+		turn,
+		step: 1
+	});
+	appendSurfaceSeedEvent(events, "assistant/message", {
+		turn,
+		step: 1,
+		message: assistant,
+		stream: []
+	}, { surfaceOp: "append" });
+	appendLogSeedEvent(events, "step/end", {
+		turn,
+		step: 1
+	});
+	appendLogSeedEvent(events, "turn/end", {
+		turn,
+		reason: { kind: "completed" }
+	});
+}
+function keepFromOf(events, boundary) {
+	if (boundary < 0) return 0;
+	return events[boundary]?.type === "turn/end" ? boundary + 1 : boundary;
+}
+async function appendSeedSuffixLive(session, seedSuffix, appendDirect) {
+	for (const event of seedSuffix) {
+		if (event.ignorable === true) {
+			const s = session;
+			const seq = s.log.length;
+			await appendDirect([{
+				...event,
+				seq
+			}]);
+			s.log.push({
+				...event,
+				seq
+			});
+			s.eventsSnapshot = void 0;
+			continue;
+		}
+		const s = session;
+		const raw = event;
+		if (raw.surfaceOp !== void 0) s.append(event.type, event.data, {
+			surfaceOp: raw.surfaceOp,
+			...raw.sourceEventSeqs === void 0 ? {} : { sourceEventSeqs: raw.sourceEventSeqs }
+		});
+		else s.append(event.type, event.data);
+	}
+}
+var SessionEditor = class extends Service {
+	static inject = [
+		"sessionBranch",
+		"sessionPersistence",
+		"sessions"
+	];
+	constructor(ctx) {
+		super(ctx, "sessionEditor");
+		registerHttpRoutes(ctx);
+	}
+	readBranchPrefix(id, atSeq, mode, signal) {
+		return this.ctx.sessionBranch.readBranchPrefix(id, atSeq, mode, signal);
+	}
+	fork(sourceId, atSeq, childSessionId, meta, signal) {
+		return this.ctx.sessionBranch.forkFrom(sourceId, {
+			...atSeq === void 0 ? {} : { atSeq },
+			...childSessionId === void 0 ? {} : { childSessionId },
+			...meta === void 0 ? {} : { meta }
+		}, signal);
+	}
+	async rewind(id, toBoundary, signal) {
+		await this.stopLoop(id, signal);
+		return this.ctx.sessionBranch.rewind(id, toBoundary, signal);
+	}
+	timeline(sessionId, signal) {
+		return this.ctx.sessionBranch.timeline(sessionId, signal);
+	}
+	edit(operation, signal) {
+		return this.branchOperation(operation, signal);
+	}
+	reroll(operation, signal) {
+		return this.branchOperation(operation, signal);
+	}
+	retry(operation, signal) {
+		return this.branchOperation(operation, signal);
+	}
+	recall(operation, signal) {
+		return this.recallOperation(operation, signal);
+	}
+	async editableMessages(sessionId, signal) {
+		const events = await this.readEvents(sessionId, signal);
+		return editableMessages(closedTurns(events));
+	}
+	async retryableTurns(sessionId, signal) {
+		const events = await this.readEvents(sessionId, signal);
+		return retryableTurns(closedTurns(events));
+	}
+	async branchOperation(operation, signal) {
+		signal?.throwIfAborted();
+		const events = await this.readEvents(operation.sessionId, signal);
+		const turns = closedTurns(events);
+		const plan = operation.action === "edit" ? editPlan(operation, turns) : operation.action === "retry" ? retryPlan(operation, turns) : rerollPlan(operation, turns);
+		const headerConfig = events.findLast((event) => event.type === "request/header")?.data.header.config;
+		const turnIndex = turns.findIndex((turn) => turn.startSeq === plan.anchorSeq);
+		const preceding = precedingContentIndex(turns, turnIndex);
+		const boundary = plan.rewindBoundary !== void 0 ? plan.rewindBoundary : preceding < 0 ? -1 : turns[preceding].endSeq;
+		const keepFrom = keepFromOf(events, boundary);
+		const compactions = droppedCompactions(events, keepFrom, plan.targetSeq);
+		const replayTurn = preceding < 0 ? 1 : turns[preceding].turn + 1;
+		const versionSeed = [];
+		appendLogSeedEvent(versionSeed, "session-branch/version", plan.version, true);
+		const manualSeed = [];
+		if (plan.manualTurn !== void 0) appendManualTurn(manualSeed, {
+			...plan.manualTurn,
+			turn: replayTurn
+		});
+		const replay = await this.prepareReplay(operation.sessionId, plan.queuedUsers, signal, headerConfig);
+		await this.stopLoop(operation.sessionId, signal);
+		const live = this.ctx.sessions.get(operation.sessionId);
+		await this.ctx.sessionBranch.rewind(operation.sessionId, boundary, signal);
+		const seedStart = this.seedStart(live, events, keepFrom);
+		const seedSuffix = [
+			...versionSeed,
+			...restoreCompactions(compactions, keepFrom, seedStart + versionSeed.length),
+			...manualSeed
+		];
+		await this.appendSeedSuffix(operation.sessionId, live, seedSuffix, events, keepFrom);
+		let queuedTurns = 0;
+		if (replay.agent !== void 0 && plan.queuedUsers.length > 0) {
+			const lastSeedTurn = seedSuffix.findLast((event) => event.type === "turn/start")?.data.turn;
+			if (lastSeedTurn !== void 0) {
+				const phase = replay.agent.phase;
+				if (phase !== void 0) phase.lastTurn = lastSeedTurn;
+			}
+			for (const message of plan.queuedUsers) replay.agent.followup(message);
+			await this.ctx.sessions.flush(replay.agent.session);
+			queuedTurns = plan.queuedUsers.length;
+		}
+		return {
+			sessionId: operation.sessionId,
+			queuedTurns,
+			live: this.ctx.sessions.get(operation.sessionId) !== void 0
+		};
+	}
+	async recallOperation(operation, signal) {
+		signal?.throwIfAborted();
+		const events = await this.readEvents(operation.sessionId, signal);
+		const boundary = recallBoundary(events, closedTurns(events), operation.eventSeq);
+		const keepFrom = keepFromOf(events, boundary);
+		const compactions = droppedCompactions(events, keepFrom, operation.eventSeq);
+		await this.stopLoop(operation.sessionId, signal);
+		const live = this.ctx.sessions.get(operation.sessionId);
+		await this.ctx.sessionBranch.rewind(operation.sessionId, boundary, signal);
+		await this.appendSeedSuffix(operation.sessionId, live, restoreCompactions(compactions, keepFrom, this.seedStart(live, events, keepFrom)), events, keepFrom);
+		return {
+			sessionId: operation.sessionId,
+			queuedTurns: 0,
+			live: this.ctx.sessions.get(operation.sessionId) !== void 0
+		};
+	}
+	seedStart(live, events, keepFrom) {
+		return live === void 0 ? balanceRewindPrefix(events.slice(0, keepFrom)).length : Number(live.seq);
+	}
+	async appendSeedSuffix(sessionId, live, seedSuffix, events, keepFrom) {
+		if (seedSuffix.length === 0) return;
+		if (live !== void 0) {
+			const handle = this.ctx.sessionPersistence.tracker.writerOf(sessionId);
+			if (handle === void 0) throw new Error(`session "${sessionId}" has no live write handle for the version effect`);
+			await this.ctx.sessions.flush(live);
+			await appendSeedSuffixLive(live, seedSuffix, (batch) => handle.append(batch));
+			await this.ctx.sessions.flush(live);
+			return;
+		}
+		const keepLength = balanceRewindPrefix(events.slice(0, keepFrom)).length;
+		const renumbered = seedSuffix.map((event, index) => ({
+			...event,
+			seq: keepLength + index
+		}));
+		const handle = await this.ctx.sessionPersistence.open(sessionId, "write");
+		try {
+			await handle.append(renumbered);
+		} finally {
+			await handle.close();
+		}
+	}
+	async stopLoop(sessionId, signal) {
+		signal?.throwIfAborted();
+		const existing = this.ctx.get("agents")?.get(sessionId);
+		if (existing === void 0) return;
+		existing.cancel?.({ kind: "user" }, { keepInbox: true });
+		await existing.whenIdle();
+		signal?.throwIfAborted();
+	}
+	async readEvents(sessionId, signal) {
+		const live = this.ctx.sessions.get(sessionId);
+		if (live !== void 0) return live.snapshotEvents();
+		return (await this.ctx.sessionBranch.readRawEvents(sessionId, signal)).events;
+	}
+	async prepareReplay(sessionId, queuedUsers, signal, headerConfig) {
+		if (queuedUsers.length === 0) return { agent: void 0 };
+		signal?.throwIfAborted();
+		const agents = this.ctx.get("agents");
+		if (agents === void 0) return { agent: void 0 };
+		const existing = agents.get(sessionId);
+		if (existing !== void 0) return { agent: existing };
+		const provider = headerConfig?.provider ?? "";
+		const model = headerConfig?.model ?? "";
+		if (provider.length === 0 || model.length === 0) {
+			const config = (await this.readEvents(sessionId, signal)).findLast((event) => event.type === "request/header")?.data.header.config;
+			const fallbackProvider = config?.provider ?? "";
+			const fallbackModel = config?.model ?? "";
+			if (fallbackProvider.length === 0 || fallbackModel.length === 0) throw new SessionBranchError("无法重放：会话没有可解析的模型配置。", "INVALID_BOUNDARY");
+			const handle = await agents.resume({
+				resumeSessionId: sessionId,
+				agentOptions: {
+					provider: fallbackProvider,
+					model: fallbackModel
+				}
+			});
+			signal?.throwIfAborted();
+			return { agent: handle.agent };
+		}
+		const handle = await agents.resume({
+			resumeSessionId: sessionId,
+			agentOptions: {
+				provider,
+				model
+			}
+		});
+		signal?.throwIfAborted();
+		return { agent: handle.agent };
+	}
+};
+function objectValue(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("请求体必须是 JSON 对象。");
+	return value;
+}
+function sessionIdOf(value) {
+	if (typeof value !== "string" || value.length === 0) throw new TypeError("sessionId 必须是非空字符串。");
+	return value;
+}
+function integerOf(value, name) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${name} 必须是非负安全整数。`);
+	return value;
+}
+function cascadeOf(value) {
+	if (value !== "truncate" && value !== "preserve") throw new TypeError("cascade 必须是 truncate 或 preserve。");
+	return value;
+}
+function decodeOperation(value) {
+	const record = objectValue(value);
+	const sessionId = sessionIdOf(record["sessionId"]);
+	switch (record["action"]) {
+		case "edit":
+			if (typeof record["text"] !== "string") throw new TypeError("text 必须是字符串。");
+			return {
+				action: "edit",
+				sessionId,
+				eventSeq: integerOf(record["eventSeq"], "eventSeq"),
+				blockIndex: integerOf(record["blockIndex"], "blockIndex"),
+				text: record["text"],
+				cascade: cascadeOf(record["cascade"])
+			};
+		case "reroll": return {
+			action: "reroll",
+			sessionId
+		};
+		case "retry": return {
+			action: "retry",
+			sessionId,
+			turn: integerOf(record["turn"], "turn"),
+			cascade: cascadeOf(record["cascade"])
+		};
+		case "rewind": return {
+			action: "rewind",
+			sessionId,
+			toBoundary: integerOf(record["toBoundary"], "toBoundary")
+		};
+		case "recall": return {
+			action: "recall",
+			sessionId,
+			eventSeq: integerOf(record["eventSeq"], "eventSeq")
+		};
+		case "fork": return {
+			action: "fork",
+			sessionId,
+			...record["atSeq"] === void 0 ? {} : { atSeq: integerOf(record["atSeq"], "atSeq") },
+			...record["childSessionId"] === void 0 ? {} : { childSessionId: sessionIdOf(record["childSessionId"]) }
+		};
+		default: throw new TypeError("action 必须是 edit、reroll、retry、rewind、recall 或 fork。");
+	}
+}
+function requestJson(request) {
+	return new Promise((resolve, reject) => {
+		const decoder = new TextDecoder();
+		let text = "";
+		request.on("data", (chunk) => {
+			text += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+		});
+		request.on("end", () => {
+			try {
+				text += decoder.decode();
+				resolve(JSON.parse(text));
+			} catch (error) {
+				reject(error);
+			}
+		});
+		request.on("error", reject);
+	});
+}
+function respondJson(response, status, value) {
+	response.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": "no-store"
+	});
+	response.end(JSON.stringify(value));
+}
+async function readTimeline(editor, sessionId) {
+	const timeline = await editor.timeline(sessionId);
+	const messages = await editor.editableMessages(sessionId);
+	const retryable = await editor.retryableTurns(sessionId);
+	return toTimelinePayload(sessionId, timeline, messages, retryable);
+}
+async function runOperation(editor, operation) {
+	switch (operation.action) {
+		case "edit": {
+			const result = await editor.edit(operation);
+			return {
+				sessionId: result.sessionId,
+				queuedTurns: result.queuedTurns,
+				...result.live === void 0 ? {} : { live: result.live }
+			};
+		}
+		case "reroll": {
+			const result = await editor.reroll(operation);
+			return {
+				sessionId: result.sessionId,
+				queuedTurns: result.queuedTurns,
+				...result.live === void 0 ? {} : { live: result.live }
+			};
+		}
+		case "retry": {
+			const result = await editor.retry(operation);
+			return {
+				sessionId: result.sessionId,
+				queuedTurns: result.queuedTurns,
+				...result.live === void 0 ? {} : { live: result.live }
+			};
+		}
+		case "rewind":
+			await editor.rewind(operation.sessionId, operation.toBoundary);
+			return {
+				sessionId: operation.sessionId,
+				queuedTurns: 0
+			};
+		case "recall": {
+			const result = await editor.recall(operation);
+			return {
+				sessionId: result.sessionId,
+				queuedTurns: result.queuedTurns,
+				...result.live === void 0 ? {} : { live: result.live }
+			};
+		}
+		case "fork": return {
+			sessionId: await editor.fork(operation.sessionId, operation.atSeq, operation.childSessionId),
+			queuedTurns: 0
+		};
+	}
+}
+async function handleRoute(editor, request, response) {
+	try {
+		if (request.method === "GET") {
+			respondJson(response, 200, await readTimeline(editor, sessionIdOf(new URL(request.url ?? "/session-editor", "http://session-editor.local").searchParams.get("sessionId"))));
+			return;
+		}
+		if (request.method === "POST") {
+			respondJson(response, 200, await runOperation(editor, decodeOperation(await requestJson(request))));
+			return;
+		}
+		response.writeHead(405);
+		response.end();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		respondJson(response, error instanceof TypeError ? 400 : 409, { error: message });
+	}
+}
+function registerHttpRoutes(ctx) {
+	ctx.effect(() => {
+		const webServer = ctx.get("webServer");
+		if (webServer === void 0) return () => {};
+		const editor = ctx.sessionEditor;
+		return webServer.register({
+			kind: "exact",
+			path: SESSION_EDITOR_PATH,
+			handler: (request, response) => handleRoute(editor, request, response)
+		});
+	}, "session-editor: HTTP route");
+	const registerConnectionRoute = () => {
+		const connection = ctx.get("connection", false);
+		if (connection === void 0) return;
+		const editor = ctx.sessionEditor;
+		ctx.effect(() => connection.fetch.register({
+			path: `/api${SESSION_EDITOR_PATH}`,
+			methods: ["GET", "POST"],
+			requestBody: "buffered",
+			fetch: (request) => handleFetchRoute(editor, request)
+		}), "session-editor: connection fetch route");
+	};
+	ctx.on("internal/service", (name) => {
+		if (name === "connection") registerConnectionRoute();
+	});
+	registerConnectionRoute();
+}
+async function handleFetchRoute(editor, request) {
+	try {
+		if (request.method === "GET") return jsonResponse(200, await readTimeline(editor, sessionIdOf(new URL(request.url).searchParams.get("sessionId"))));
+		if (request.method === "POST") return jsonResponse(200, await runOperation(editor, decodeOperation(await request.json())));
+		return new Response(null, { status: 405 });
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return jsonResponse(error instanceof TypeError ? 400 : 409, { error: message });
+	}
+}
+function jsonResponse(status, value) {
+	return new Response(JSON.stringify(value), {
+		status,
+		headers: {
+			"content-type": "application/json; charset=utf-8",
+			"cache-control": "no-store"
+		}
+	});
+}
+//#endregion
 export { SESSION_BRANCH_VERSION_SCHEMA, SessionEditor, SessionEditor as default, closedTurns, editableMessages, retryableTurns };

package/dist/invariant.d.cts

@@ -0,0 +1,7 @@
+import { Context } from "@deepseek-ai/cordis";
+//#region src/invariant.d.ts
+declare const name = "ui-conversation-message-actions-invariant";
+declare const inject: string[];
+declare const apply: (ctx: Context) => Promise<() => void>;
+//#endregion
+export { apply, inject, name };

package/dist/{plan-BSa7k9HO.d.mts → plan-CT_6Y1fD.d.cts}

@@ -1,6 +1,6 @@
+import { AssistantMessage, UserMessage } from "@deepseek-ai/dsh-llm";
 import { SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
 import { BranchTimeline, CascadePolicy, SessionBranchVersionEvent } from "@morlay/session-branch";
-import { AssistantMessage, UserMessage } from "@deepseek-ai/dsh-llm";
 //#region src/types.d.ts
 interface EditOperation {
   action: "edit";
@@ -65,7 +65,6 @@ interface ClosedTurn {
   endSeq?: number;
   closed: boolean;
   user?: SessionEvent<"user/message">;
-  /** 轮内全部 user/message（agent 运行中 followup 追加的输入也计入）。 */
   users: SessionEvent<"user/message">[];
   assistants: SessionEvent<"assistant/message">[];
 }
@@ -79,21 +78,24 @@ interface OperationPlan {
     assistant: AssistantMessage;
   };
   queuedUsers: UserMessage[];
+  targetSeq: number;
 }
 declare function closedTurns(events: readonly SessionEvent[]): ClosedTurn[];
 declare function editableMessages(turns: readonly ClosedTurn[]): EditableMessageBlock[];
 declare function retryableTurns(turns: readonly ClosedTurn[]): RetryableTurn[];
-/**
- * 目标轮之前最后一个「有内容」轮次的下标：跳过既无用户输入也无助手回复的
- * 空轮。空轮是早期重放缺陷的遗留（turn/start 后直接 turn/end），在轨迹 /
- * 轮次导航里表现为点不开的空项，并让后续轮号出现空洞。rewind 把它们随
- * 目标轮一起截断，重放按保留前缀续号即可自愈。
- */
 declare function precedingContentIndex(turns: readonly ClosedTurn[], turnIndex: number): number;
 declare function downstreamUsers(turns: readonly ClosedTurn[], start: number): UserMessage[];
 declare function recallBoundary(events: readonly SessionEvent[], turns: readonly ClosedTurn[], eventSeq: number): number;
 declare function editPlan(operation: EditOperation, turns: readonly ClosedTurn[]): OperationPlan;
 declare function retryPlan(operation: RetryOperation, turns: readonly ClosedTurn[]): OperationPlan;
 declare function rerollPlan(operation: RerollOperation, turns: readonly ClosedTurn[]): OperationPlan;
+interface CompactionBracket {
+  start: SessionEvent;
+  summary?: SessionEvent;
+  checkpoint: SessionEvent;
+  end: SessionEvent;
+}
+declare function droppedCompactions(events: readonly SessionEvent[], keepFrom: number, targetSeq: number): CompactionBracket[];
+declare function restoreCompactions(brackets: readonly CompactionBracket[], keepFrom: number, base: number): SessionEvent[];
 //#endregion
-export { RetryableTurn as _, editPlan as a, SessionEditorResult as b, recallBoundary as c, retryableTurns as d, EditOperation as f, RetryOperation as g, RerollOperation as h, downstreamUsers as i, rerollPlan as l, RecallOperation as m, OperationPlan as n, editableMessages as o, EditableMessageBlock as p, closedTurns as r, precedingContentIndex as s, ClosedTurn as t, retryPlan as u, RewindOperation as v, SessionEditorOperation as y };
+export { SessionEditorResult as C, SessionEditorOperation as S, RecallOperation as _, downstreamUsers as a, RetryableTurn as b, editableMessages as c, rerollPlan as d, restoreCompactions as f, EditableMessageBlock as g, EditOperation as h, closedTurns as i, precedingContentIndex as l, retryableTurns as m, CompactionBracket as n, droppedCompactions as o, retryPlan as p, OperationPlan as r, editPlan as s, ClosedTurn as t, recallBoundary as u, RerollOperation as v, RewindOperation as x, RetryOperation as y };