@morlay/ui-conversation-message-actions 0.0.9

package/lib/index.mjs

@@ -0,0 +1,675 @@
+import { Service } from "@deepseek-ai/cordis";
+import { randomUUID } from "node:crypto";
+import { SESSION_BRANCH_VERSION_SCHEMA, SESSION_BRANCH_VERSION_SCHEMA as SESSION_BRANCH_VERSION_SCHEMA$1, SessionBranchError } from "@morlay/session-branch";
+//#region src/shared.ts
+/** 同源 HTTP 端点（host 注册、client fetch）。 */
+const SESSION_EDITOR_PATH = "/session-editor";
+/** 把 {@link BranchTimeline} 投影成 client 用的 {@link SessionEditorTimeline}。 */
+function toTimelinePayload(sessionId, timeline, messages, retryableTurns) {
+	const currentPath = /* @__PURE__ */ new Set();
+	for (const node of timeline.nodes) currentPath.add(String(node.sessionId));
+	const versions = timeline.nodes.map((node) => ({
+		sessionId: String(node.sessionId),
+		...node.parentSessionId === void 0 ? {} : { parentSessionId: String(node.parentSessionId) },
+		...node.effect === void 0 ? {} : {
+			effectId: node.effect.id,
+			inverseSessionId: String(node.inverseSessionId),
+			operation: node.effect.operation,
+			cascade: node.effect.cascade,
+			targetTurn: node.effect.targetTurn,
+			...node.effect.blockKind === void 0 ? {} : { blockKind: node.effect.blockKind },
+			...node.effect.before === void 0 ? {} : { before: node.effect.before },
+			...node.effect.after === void 0 ? {} : { after: node.effect.after }
+		},
+		createdAt: node.createdAt,
+		depth: depthOf(timeline, node.sessionId),
+		current: String(node.sessionId) === String(sessionId),
+		onCurrentEffectPath: currentPath.has(String(node.sessionId))
+	}));
+	const versionsById = new Map(versions.map((version) => [version.sessionId, version]));
+	const undoStack = [];
+	let cursor = versionsById.get(String(sessionId));
+	while (cursor?.inverseSessionId !== void 0) {
+		if (undoStack.includes(cursor.inverseSessionId)) break;
+		undoStack.push(cursor.inverseSessionId);
+		cursor = versionsById.get(cursor.inverseSessionId);
+	}
+	const redoSessionIds = versions.filter((version) => version.inverseSessionId === String(sessionId)).map((version) => version.sessionId);
+	return {
+		sessionId: String(sessionId),
+		messages,
+		retryableTurns,
+		versions,
+		undoStack,
+		redoSessionIds
+	};
+}
+/** 计算节点到根的深度。 */
+function depthOf(timeline, sessionId) {
+	const byId = new Map(timeline.nodes.map((node) => [String(node.sessionId), node]));
+	let depth = 0;
+	let cursor = byId.get(String(sessionId));
+	const seen = /* @__PURE__ */ new Set();
+	while (cursor?.parentSessionId !== void 0 && !seen.has(String(cursor.sessionId))) {
+		seen.add(String(cursor.sessionId));
+		depth += 1;
+		cursor = byId.get(String(cursor.parentSessionId));
+	}
+	return depth;
+}
+//#endregion
+//#region src/index.ts
+/**
+* 编排层 `SessionEditor`：在 `@morlay/session-branch` 的 provider 抽象之上
+* 组装 rewind / retry / fork 的**完整功能**（参考 `dsh-message-edit` 的
+* 产品语义：edit / reroll / retry + 级联策略 + 版本树）。
+*
+* 分层边界：
+* - 数据层（forkFrom / rewind / readBranchPrefix）由 `ctx.sessionBranch`
+*   （provider 实现，如 `@morlay/session-rdb`）提供；
+* - 本服务只做**编排**：闭合轮次扫描、版本效果事件构造、派生 seed 组装、
+*   rewind 命令透传、版本树投影；
+* - agent 驱动（重放用户输入 / 创建子 agent）是**可选增强**：`agents`
+*   服务以 duck-typed 接口使用（不硬依赖 `@deepseek-ai/dsh-agent`），
+*   缺失时退化为「创建持久化版本」——版本已 durable，之后可随时 resume。
+*
+* @module @morlay/ui-conversation-message-actions
+*/
+function closedTurns(events) {
+	const result = [];
+	let current;
+	for (const event of events) {
+		if (event.type === "turn/start") {
+			current = {
+				turn: event.data.turn,
+				startSeq: event.seq,
+				assistants: []
+			};
+			continue;
+		}
+		if (current === void 0) continue;
+		if (event.type === "user/message" && current.user === void 0 && event.data.source.kind === "user") {
+			current.user = event;
+			continue;
+		}
+		if (event.type === "assistant/message" && event.data.turn === current.turn) {
+			current.assistants.push(event);
+			continue;
+		}
+		if (event.type === "turn/end" && event.data.turn === current.turn) {
+			result.push({
+				...current,
+				endSeq: event.seq
+			});
+			current = void 0;
+		}
+	}
+	return result;
+}
+function isTextualBlock(block) {
+	return block?.type === "text" || block?.type === "reasoning";
+}
+function userText(message) {
+	return message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+}
+function cloneUser(message, content = structuredClone(message.content)) {
+	return Object.freeze({
+		id: randomUUID(),
+		role: "user",
+		content: Object.freeze(content),
+		source: Object.freeze({ kind: "user" })
+	});
+}
+function replaceTextBlock(content, blockIndex, text) {
+	const block = content[blockIndex];
+	if (!isTextualBlock(block)) throw new SessionBranchError("所选内容块不是可编辑文本。", "INVALID_BOUNDARY");
+	return content.map((candidate, index) => index === blockIndex ? {
+		...candidate,
+		text
+	} : structuredClone(candidate));
+}
+function editableMessages(turns) {
+	const result = [];
+	for (const turn of turns) {
+		if (turn.user !== void 0) for (const [blockIndex, block] of turn.user.data.content.entries()) {
+			if (block.type !== "text") continue;
+			result.push({
+				key: `${String(turn.user.seq)}:${String(blockIndex)}`,
+				turn: turn.turn,
+				eventSeq: turn.user.seq,
+				blockIndex,
+				kind: "user",
+				text: block.text,
+				time: turn.user.time
+			});
+		}
+		for (const event of turn.assistants) for (const [blockIndex, block] of event.data.message.content.entries()) {
+			if (!isTextualBlock(block)) continue;
+			result.push({
+				key: `${String(event.seq)}:${String(blockIndex)}`,
+				turn: turn.turn,
+				eventSeq: event.seq,
+				blockIndex,
+				kind: block.type === "reasoning" ? "assistant.reasoning" : "assistant.response",
+				text: block.text,
+				time: event.time
+			});
+		}
+	}
+	return result;
+}
+function retryableTurns(turns) {
+	return turns.flatMap((turn) => turn.user === void 0 ? [] : [{
+		turn: turn.turn,
+		userEventSeq: turn.user.seq,
+		preview: userText(turn.user.data),
+		time: turn.user.time
+	}]);
+}
+function downstreamUsers(turns, start) {
+	return turns.slice(start).flatMap((turn) => turn.user === void 0 ? [] : [cloneUser(turn.user.data)]);
+}
+function assistantReplacement(event, blockIndex, text) {
+	const replaced = replaceTextBlock(event.data.message.content, blockIndex, text).filter((block) => block.type === "text" || block.type === "reasoning");
+	return Object.freeze({
+		id: randomUUID(),
+		role: "assistant",
+		content: Object.freeze(replaced),
+		source: Object.freeze({
+			kind: "model",
+			provider: event.data.message.source.provider,
+			model: event.data.message.source.model
+		})
+	});
+}
+function pairVersionEffect(sourceSessionId, effect) {
+	return {
+		schemaVersion: SESSION_BRANCH_VERSION_SCHEMA$1,
+		effect: {
+			...effect,
+			id: randomUUID()
+		},
+		inverse: {
+			kind: "restore-version",
+			sessionId: sourceSessionId
+		}
+	};
+}
+function editPlan(operation, turns) {
+	const turnIndex = turns.findIndex((turn) => operation.eventSeq > turn.startSeq && operation.eventSeq < turn.endSeq);
+	const turn = turns[turnIndex];
+	if (turn === void 0) throw new SessionBranchError("所选消息不属于已落定回合。", "INVALID_BOUNDARY");
+	const event = turn.user?.seq === operation.eventSeq ? turn.user : turn.assistants.find((candidate) => candidate.seq === operation.eventSeq);
+	if (event === void 0) throw new SessionBranchError("所选消息不存在或不可编辑。", "INVALID_BOUNDARY");
+	if (event.type === "user/message") {
+		const before = event.data.content[operation.blockIndex];
+		if (before?.type !== "text") throw new SessionBranchError("所选用户消息块不是文本。", "INVALID_BOUNDARY");
+		const edited = cloneUser(event.data, replaceTextBlock(event.data.content, operation.blockIndex, operation.text));
+		const later = operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex + 1) : [];
+		return {
+			anchorSeq: turn.startSeq,
+			version: pairVersionEffect(operation.sessionId, {
+				operation: "edit",
+				cascade: operation.cascade,
+				targetTurn: turn.turn,
+				targetEventSeq: event.seq,
+				targetBlockIndex: operation.blockIndex,
+				blockKind: "user",
+				before: before.text,
+				after: operation.text
+			}),
+			queuedUsers: [edited, ...later]
+		};
+	}
+	const before = event.data.message.content[operation.blockIndex];
+	if (!isTextualBlock(before)) throw new SessionBranchError("所选助手消息块不是文本或思考。", "INVALID_BOUNDARY");
+	const blockKind = before.type === "reasoning" ? "assistant.reasoning" : "assistant.response";
+	if (turn.user === void 0) throw new SessionBranchError("所选助手消息没有可重建的用户输入。", "INVALID_BOUNDARY");
+	return {
+		anchorSeq: turn.startSeq,
+		version: pairVersionEffect(operation.sessionId, {
+			operation: "edit",
+			cascade: operation.cascade,
+			targetTurn: turn.turn,
+			targetEventSeq: event.seq,
+			targetBlockIndex: operation.blockIndex,
+			blockKind,
+			before: before.text,
+			after: operation.text
+		}),
+		manualTurn: {
+			turn: turn.turn,
+			user: cloneUser(turn.user.data),
+			assistant: assistantReplacement(event, operation.blockIndex, operation.text)
+		},
+		queuedUsers: operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex + 1) : []
+	};
+}
+function retryPlan(operation, turns) {
+	const turnIndex = turns.findIndex((turn) => turn.turn === operation.turn);
+	const turn = turns[turnIndex];
+	if (turn?.user === void 0) throw new SessionBranchError("所选回合没有可重放的用户输入。", "INVALID_BOUNDARY");
+	return {
+		anchorSeq: turn.startSeq,
+		version: pairVersionEffect(operation.sessionId, {
+			operation: "retry",
+			cascade: operation.cascade,
+			targetTurn: turn.turn,
+			targetEventSeq: turn.user.seq
+		}),
+		queuedUsers: operation.cascade === "preserve" ? downstreamUsers(turns, turnIndex) : [cloneUser(turn.user.data)]
+	};
+}
+function rerollPlan(operation, turns) {
+	for (let index = turns.length - 1; index >= 0; index -= 1) {
+		const turn = turns[index];
+		if (turn?.user === void 0) continue;
+		const target = turn.assistants.findLast((event) => event.data.message.content.some(isTextualBlock));
+		if (target === void 0) continue;
+		return {
+			anchorSeq: turn.startSeq,
+			version: pairVersionEffect(operation.sessionId, {
+				operation: "reroll",
+				cascade: "truncate",
+				targetTurn: turn.turn,
+				targetEventSeq: target.seq
+			}),
+			queuedUsers: [cloneUser(turn.user.data)]
+		};
+	}
+	throw new SessionBranchError("当前会话没有可重生成的已落定助手回复。", "INVALID_BOUNDARY");
+}
+/** —— 种子事件构造（本地纯事件构造器；Session 构造时统一验证） —— */
+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: 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
+	}, {
+		surfaceOp: "append",
+		sourceEventSeqs: []
+	});
+	appendLogSeedEvent(events, "step/end", {
+		turn,
+		step: 1
+	});
+	appendLogSeedEvent(events, "turn/end", {
+		turn,
+		reason: { kind: "completed" }
+	});
+}
+/**
+* 把派生 seed 后缀落地到 **live** 会话。上游 `Session.append` 不保留
+* `ignorable` 标记（只保留 type/data/surface 元数据），而版本效果事件必须
+* 保持 ignorable（live log 保留、不落 canonical log），因此：
+* - ignorable 事件（版本效果）直接 push 内存 log（不发布 `session/event`；
+*   服务端语义事件，客户端无需感知；surfaceManager 对非 surface 事件 fold
+*   无副作用）；
+* - 其余事件（手工回合 manualTurn）走 `append`（surface 校验 + 发布）。
+* 后续统一由 write-behind flush 落盘（RDB 稠密化时过滤 ignorable）。
+*/
+function appendSeedSuffixLive(session, seedSuffix) {
+	for (const event of seedSuffix) {
+		if (event.ignorable === true) {
+			const s = session;
+			s.log.push({
+				...event,
+				seq: s.log.length
+			});
+			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);
+	}
+}
+/** —— 编排服务 —— */
+/**
+* `ctx.sessionEditor`：rewind / retry / fork 的完整功能编排。
+* 组合 `ctx.sessionBranch`（provider 抽象）与可选的 `agents` 服务。
+*/
+var SessionEditor = class extends Service {
+	static inject = [
+		"sessionBranch",
+		"sessionPersistence",
+		"sessions"
+	];
+	constructor(ctx) {
+		super(ctx, "sessionEditor");
+		registerHttpRoutes(ctx);
+	}
+	/** 定位 `atSeq` 锚定的闭合边界（透传 provider）。 */
+	readBranchPrefix(id, atSeq, mode, signal) {
+		return this.ctx.sessionBranch.readBranchPrefix(id, atSeq, mode, signal);
+	}
+	/** 从持久化源派生新会话（透传 provider；不驱动 agent）。 */
+	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);
+	}
+	/** 截断式回退：原会话回退到闭合边界（透传 provider）。 */
+	rewind(id, toBoundary, signal) {
+		return this.ctx.sessionBranch.rewind(id, toBoundary, signal);
+	}
+	/**
+	* 清洗一个会话的 surface/provenance 坐标为稠密空间（透传 sessionBranch）。
+	* 历史加载失败（坐标混叠导致 seed 校验失败）时调用,清洗后重新加载即可。
+	* `cleanseSession` 是 rdb 实现层新增的服务面（契约层 `SessionBranch`
+	* 没有此方法）,经运行时访问。
+	*/
+	cleanseSession(sessionId, signal) {
+		return this.ctx.sessionBranch.cleanseSession(sessionId, signal);
+	}
+	/** 完整版本树投影（透传 provider 组合）。 */
+	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);
+	}
+	/** 可编辑消息块枚举（Timeline 编辑面）。 */
+	async editableMessages(sessionId, signal) {
+		return editableMessages(closedTurns(await this.readEvents(sessionId, signal)));
+	}
+	/** 可重试回合枚举（Timeline 重试面）。 */
+	async retryableTurns(sessionId, signal) {
+		return retryableTurns(closedTurns(await this.readEvents(sessionId, signal)));
+	}
+	/** 执行一个分支式操作（edit / reroll / retry）。 */
+	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 seedSuffix = [];
+		appendLogSeedEvent(seedSuffix, "session-branch/version", plan.version, true);
+		if (plan.manualTurn !== void 0) appendManualTurn(seedSuffix, plan.manualTurn);
+		const turnIndex = turns.findIndex((turn) => turn.startSeq === plan.anchorSeq);
+		const boundary = turnIndex <= 0 ? -1 : turns[turnIndex - 1].endSeq;
+		const live = this.ctx.sessions.get(operation.sessionId);
+		await this.ctx.sessionBranch.rewind(operation.sessionId, boundary, signal);
+		if (seedSuffix.length > 0) {
+			if (live !== void 0) {
+				appendSeedSuffixLive(live, seedSuffix);
+				this.ctx.sessionBranch.syncLiveCursor(operation.sessionId);
+				await this.ctx.sessions.flush(live);
+			} else {
+				const renumbered = seedSuffix.map((event, index) => ({
+					...event,
+					seq: boundary + 1 + index
+				}));
+				await this.ctx.sessionPersistence.append(operation.sessionId, renumbered);
+			}
+		}
+		const queuedTurns = await this.driveAgent(operation.sessionId, plan.queuedUsers, signal, headerConfig);
+		return {
+			sessionId: operation.sessionId,
+			queuedTurns,
+			live: this.ctx.sessions.get(operation.sessionId) !== void 0
+		};
+	}
+	/** 读取会话事件：live 优先，否则走持久化 inspect。 */
+	async readEvents(sessionId, signal) {
+		const live = this.ctx.sessions.get(sessionId);
+		if (live !== void 0) return live.events;
+		return (await this.ctx.sessionPersistence.inspect(sessionId, signal)).events;
+	}
+	/**
+	* 可选 agent 驱动：优先复用现有 live agent（用户会话驻留——rewind 已截断
+	* 其 session 内存，followup 会基于截断后历史重放），否则 `resume` 已持久化
+	* 会话。模型配置来自 branchOperation 在 rewind 前解析的 `headerConfig`
+	* （rewind 可能截断 request/header）；缺失时回退到当前 events。无 agents
+	* 服务、无可用模型路由或恢复失败时退化为持久化版本（已 durable）。
+	* 返回实际排队的输入数。
+	*/
+	async driveAgent(sessionId, queuedUsers, signal, headerConfig) {
+		if (queuedUsers.length === 0) return 0;
+		signal?.throwIfAborted();
+		if (this.ctx.get("agents") === void 0) return 0;
+		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) return 0;
+			return this.queueThroughAgent(sessionId, queuedUsers, signal, fallbackProvider, fallbackModel);
+		}
+		return this.queueThroughAgent(sessionId, queuedUsers, signal, provider, model);
+	}
+	/** 经 live agent（复用）或 resume（重建）排队重放输入；返回排队数。 */
+	async queueThroughAgent(sessionId, queuedUsers, signal, provider, model) {
+		const agents = this.ctx.get("agents");
+		if (agents === void 0) return 0;
+		const existing = agents.get(sessionId);
+		if (existing !== void 0) {
+			for (const message of queuedUsers) existing.followup(message);
+			await this.ctx.sessions.flush(existing.session);
+			return queuedUsers.length;
+		}
+		const handle = await agents.resume({
+			resumeSessionId: sessionId,
+			agentOptions: {
+				provider,
+				model
+			}
+		}).catch((error) => {
+			this.ctx.logger.warn("session-editor: agent resume failed (%s); version remains durable", String(error));
+		});
+		if (handle === void 0) return 0;
+		for (const message of queuedUsers) handle.agent.followup(message);
+		await this.ctx.sessions.flush(handle.agent.session);
+		return queuedUsers.length;
+	}
+};
+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 "fork": return {
+			action: "fork",
+			sessionId,
+			...record["atSeq"] === void 0 ? {} : { atSeq: integerOf(record["atSeq"], "atSeq") },
+			...record["childSessionId"] === void 0 ? {} : { childSessionId: sessionIdOf(record["childSessionId"]) }
+		};
+		case "cleanse": return {
+			action: "cleanse",
+			sessionId
+		};
+		default: throw new TypeError("action 必须是 edit、reroll、retry、rewind、fork 或 cleanse。");
+	}
+}
+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));
+}
+/** GET 投影：timeline + 编辑/重试面。 */
+async function readTimeline(editor, sessionId) {
+	return toTimelinePayload(sessionId, await editor.timeline(sessionId), await editor.editableMessages(sessionId), await editor.retryableTurns(sessionId));
+}
+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 "fork": return {
+			sessionId: await editor.fork(operation.sessionId, operation.atSeq, operation.childSessionId),
+			queuedTurns: 0
+		};
+		case "cleanse": {
+			const { changed } = await editor.cleanseSession(operation.sessionId);
+			return {
+				sessionId: operation.sessionId,
+				queuedTurns: 0,
+				changed
+			};
+		}
+	}
+}
+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 });
+	}
+}
+/** 注册同源 HTTP 路由（`ctx.webServer` 由 dsh web 的 webserver 包提供；缺失时跳过）。 */
+function registerHttpRoutes(ctx) {
+	const webServer = ctx.get("webServer");
+	if (webServer === void 0) return;
+	ctx.effect(() => {
+		const editor = ctx.sessionEditor;
+		return webServer.register({
+			kind: "exact",
+			path: SESSION_EDITOR_PATH,
+			handler: (request, response) => handleRoute(editor, request, response)
+		});
+	}, "session-editor: HTTP route");
+}
+//#endregion
+export { SESSION_BRANCH_VERSION_SCHEMA, SessionEditor, SessionEditor as default, closedTurns, editableMessages, retryableTurns };
+
+//# sourceMappingURL=index.mjs.map