@morlay/ui-conversation-message-actions 0.0.19-alpha.3 → 0.0.19-alpha.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morlay/ui-conversation-message-actions",
-  "version": "0.0.19-alpha.3",
+  "version": "0.0.19-alpha.4",
   "description": "Rewind / retry / fork orchestration (host) plus conversation.chat.node renderer replacement (browser) — message edit / retry actions on user bubbles.",
   "keywords": [
     "conversation-chat-node",
@@ -38,12 +38,12 @@
     }
   },
   "dependencies": {
-    "@morlay/session-branch": "0.0.10-alpha.3"
+    "@morlay/session-branch": "0.0.10-alpha.4"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-session-stats": "0.1.6-alpha.2",
-    "@morlay/dsh-client-ui-primitives": "0.0.2-alpha.3",
-    "@morlay/session-rdb": "0.0.21-alpha.3",
+    "@morlay/dsh-client-ui-primitives": "0.0.2-alpha.4",
+    "@morlay/session-rdb": "0.0.21-alpha.4",
     "@types/react": "~18.3.1",
     "@types/react-dom": "~18.3.0",
     "react": "^18.2.0",
@@ -67,8 +67,8 @@
     "@deepseek-ai/dsh-session-persistence": "0.1.6-alpha.2",
     "@deepseek-ai/dsh-session-projection": "0.1.6-alpha.2",
     "@deepseek-ai/dsh-token-meter": "0.1.6-alpha.2",
-    "@morlay/dsh-client-ui-conversation": "0.0.2-alpha.3",
-    "@morlay/dsh-client-ui-primitives": "0.0.2-alpha.3"
+    "@morlay/dsh-client-ui-conversation": "0.0.2-alpha.4",
+    "@morlay/dsh-client-ui-primitives": "0.0.2-alpha.4"
   },
   "dsh": {
     "bundle": {

package/src/client/chat-node/MessageItem.tsx

@@ -26,6 +26,7 @@ type UserImage = Extract<UserMessageNode["content"][number], { type: "image" }>;
 
 function contentParts(content: readonly unknown[]): {
   text: string;
+  texts: string[];
   images: { attachment: UserImage["attachment"] }[];
   rest: unknown[];
 } {
@@ -39,8 +40,8 @@ function contentParts(content: readonly unknown[]): {
       images.push({ attachment: (b as UserImage).attachment });
     } else rest.push(block);
   }
-  // 多块消息按空行拼回 raw markdown（新式提交就是单块原文）。
-  return { text: texts.join("\n\n"), images, rest };
+  // 多块消息按空行拼回 raw markdown（新式提交就是单块原文）；撤回回填用的是 texts（全部块）。
+  return { text: texts.join("\n\n"), texts, images, rest };
 }
 
 function UserStyleBubble({
@@ -100,6 +101,8 @@ export const UserMessageNodeView = memo(function UserMessageNodeView({
   openSkill: (name: string) => void;
 } & InjectFace<SessionEditorFace>) {
   const data = node.data;
+  // 撤回回填的文本：该消息的全部文本块（撤回截断整条消息，只回填首块会丢内容）。
+  const recallTexts = contentParts(data.content).texts;
   const [confirmingRecall, setConfirmingRecall] = useState<EditableMessageBlock | null>(null);
   const [confirmingRetry, setConfirmingRetry] = useState(false);
   const turnLocation =
@@ -155,7 +158,7 @@ export const UserMessageNodeView = memo(function UserMessageNodeView({
                 onClick={() => {
                   const target = confirmingRecall;
                   setConfirmingRecall(null);
-                  void recall(target);
+                  void recall(target, recallTexts);
                 }}
               >
                 撤回并编辑

package/src/client/controller.ts

@@ -1,282 +1,119 @@
 import type { Context as ClientContext } from "@deepseek-ai/cordis";
-import type {
-  ISessions,
-  SessionFace,
-  SessionSnapshot,
-} from "@deepseek-ai/dsh-api-session-controller/client";
-import type { ObservableSnapshot, SnapshotStore } from "@deepseek-ai/dsh-client-store";
-import type { UiWorkspace } from "@deepseek-ai/dsh-client-ui-workspace/client";
-import { createSnapshotStore } from "@deepseek-ai/dsh-client-store";
+import type { ISessions } from "@deepseek-ai/dsh-api-session-controller/client";
 import type { SessionId } from "@deepseek-ai/dsh-session";
 import {
   SESSION_EDITOR_PATH,
   type EditableMessageBlock,
   type SessionEditorOperation,
-  type SessionEditorOperationResult,
-  type SessionEditorTimeline,
   type VersionOperation,
 } from "../shared.ts";
 
-function editorApiPath(): string {
-  const transport = (globalThis as { __DSH_TRANSPORT__?: { ownsHost?: boolean } })
-    .__DSH_TRANSPORT__;
-  return transport?.ownsHost === true ? `/api${SESSION_EDITOR_PATH}` : SESSION_EDITOR_PATH;
-}
-
-export interface SessionEditorState {
-  status: "idle" | "loading" | "ready" | "error";
-  error: string | null;
-  pending: VersionOperation | "recall" | null;
-  timeline: SessionEditorTimeline | null;
-}
-
+/** 编辑器的 HTTP 路径：宿主（web 与桌面）在同一张路由表上服务它，页面不再按 ownsHost 加前缀。 */
+const EDITOR_API_PATH = SESSION_EDITOR_PATH;
+
+/**
+ * 会话编辑的浏览器半门面：只保留消息渲染面真正用到的两个动作。
+ *
+ * 曾经这里还有一条「订阅会话列表 / 快照 → 拉全量 timeline → 装进 store」的刷新管路，
+ * 它没有任何 UI 消费方，却把重放 / 流式期间的每一次快照抖动都换成一次全量 GET
+ * （编辑 / 重试 / 撤回后尤甚），订阅本身也从不释放。现在动作成功后只刷新会话列表元数据，
+ * 会话窗口交给上游的事件流收敛（不重建窗口、不整页重载）。
+ */
 export interface SessionEditorFace {
-  hooks: { sessionEditor: ObservableSnapshot<SessionEditorState> };
-  acquire(): () => void;
-  load(): void;
-  edit(
-    message: EditableMessageBlock,
-    text: string,
-    cascade: "truncate" | "preserve",
-  ): Promise<boolean>;
   retry(turn: number, cascade: "truncate" | "preserve"): Promise<boolean>;
-  reroll(): Promise<boolean>;
-  rewind(toBoundary: number): Promise<boolean>;
-  recall(message: EditableMessageBlock): Promise<boolean>;
-  openVersion(sessionId: string): Promise<void>;
-}
 
-function messageOf(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-function conversationRevision(snapshot: SessionSnapshot): string {
-  return [snapshot.openState, snapshot.removed, snapshot.hasMore].join("|");
+  // 撤回回填：文本由调用方（消息渲染面）给出**该消息的全部文本块**——不再靠 timeline 反查。
+  recall(message: EditableMessageBlock, texts: readonly string[]): Promise<boolean>;
 }
 
 export class SessionEditorController {
-  readonly store: SnapshotStore<SessionEditorState> = createSnapshotStore<SessionEditorState>({
-    status: "idle",
-    error: null,
-    pending: null,
-    timeline: null,
-  });
-
   readonly face: SessionEditorFace;
-  private readonly ctx: ClientContext;
+
   private readonly sessions: ISessions;
-  private readonly uiWorkspace: UiWorkspace;
-  private sessionSource: SessionFace | undefined;
-  private sessionSourceDispose: (() => void) | undefined;
-  private sessionRevision: string | undefined;
-  private disposed = false;
-  private users = 0;
+  private pending: VersionOperation | "recall" | null = null;
 
   constructor(
     ctx: ClientContext,
     private readonly sessionId: SessionId,
   ) {
-    this.ctx = ctx;
     this.sessions = ctx.get("sessions") as unknown as ISessions;
-    this.uiWorkspace = ctx.get("uiWorkspace") as unknown as UiWorkspace;
     this.face = {
-      hooks: { sessionEditor: this.store },
-      acquire: () => {
-        this.users += 1;
-        if (this.users === 1 && this.disposed) this.revive();
-        return () => this.release();
-      },
-      load: () => {
-        void this.load();
-      },
-      edit: (message, text, cascade) =>
-        this.mutate({
-          action: "edit",
-          sessionId: this.sessionId,
-          eventSeq: message.eventSeq,
-          blockIndex: message.blockIndex,
-          text,
-          cascade,
-        }),
       retry: (turn, cascade) =>
         this.mutate({ action: "retry", sessionId: this.sessionId, turn, cascade }),
-      reroll: () => this.mutate({ action: "reroll", sessionId: this.sessionId }),
-      rewind: (toBoundary) =>
-        this.mutate({ action: "rewind", sessionId: this.sessionId, toBoundary }),
-      recall: (message) =>
+      recall: (message, texts) =>
         this.mutate(
           { action: "recall", sessionId: this.sessionId, eventSeq: message.eventSeq },
-          () => this.setComposerDraft(this.messageTexts(message)),
+          () => this.setComposerDraft(texts.join("\n\n")),
         ),
-      openVersion: (sessionId) => {
-        this.uiWorkspace.openSession(sessionId as SessionId);
-        return Promise.resolve();
-      },
     };
-    this.observe();
-  }
-
-  private observe(): void {
-    this.sessionSource = undefined;
-    this.sessionSourceDispose?.();
-    this.bindSessionSource();
-    this.sessions.list.subscribe(() => this.invalidate());
-  }
-
-  private bindSessionSource(): void {
-    const source = this.sessions.binding(this.sessionId)?.session;
-    if (source === this.sessionSource) return;
-    this.sessionSourceDispose?.();
-    this.sessionSource = source;
-    this.sessionRevision =
-      source === undefined ? undefined : conversationRevision(source.getSnapshot());
-    this.sessionSourceDispose = source?.subscribe(() => {
-      this.invalidate();
-    });
-  }
-
-  private invalidate(): void {
-    if (this.disposed || this.store.getSnapshot().status === "idle") return;
-
-    void this.load();
-  }
-
-  private release(): void {
-    this.users -= 1;
-    if (this.users <= 0) this.dispose();
-  }
-
-  private dispose(): void {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.sessionSourceDispose?.();
-    this.sessionSourceDispose = undefined;
-    this.sessionSource = undefined;
-    this.sessionRevision = undefined;
-  }
-
-  private revive(): void {
-    this.disposed = false;
-    this.observe();
-    void this.load();
-  }
-
-  async load(): Promise<void> {
-    if (this.disposed) return;
-    this.store.update((state) => {
-      state.status = "loading";
-      state.error = null;
-    });
-    try {
-      const response = await fetch(
-        `${editorApiPath()}?sessionId=${encodeURIComponent(this.sessionId)}`,
-        {
-          method: "GET",
-          headers: { accept: "application/json" },
-          cache: "no-store",
-        },
-      );
-      const value = (await response.json()) as unknown;
-      if (this.disposed) return;
-      if (response.ok) {
-        this.store.update((state) => {
-          state.status = "ready";
-          state.error = null;
-          state.timeline = value as SessionEditorTimeline;
-        });
-      } else {
-        const error = (value as { error?: unknown })["error"];
-        this.store.update((state) => {
-          state.status = "error";
-          state.error =
-            typeof error === "string" ? error : `请求失败：HTTP ${String(response.status)}`;
-        });
-      }
-    } catch (error) {
-      if (this.disposed) return;
-      this.store.update((state) => {
-        state.status = "error";
-        state.error = messageOf(error);
-      });
-    }
   }
 
   private async mutate(
     operation: SessionEditorOperation,
     onApplied?: () => void,
   ): Promise<boolean> {
-    const current = this.store.getSnapshot();
-    if (current.pending !== null) return false;
-    this.store.update((state) => {
-      state.pending = operation.action;
-      state.error = null;
-    });
+    if (this.pending !== null) return false;
+    this.pending = operation.action;
     try {
-      const response = await fetch(editorApiPath(), {
+      const response = await fetch(EDITOR_API_PATH, {
         method: "POST",
         headers: { accept: "application/json", "content-type": "application/json" },
         body: JSON.stringify(operation),
       });
       const value = (await response.json()) as unknown;
-      if (this.disposed) return true;
       if (!response.ok) {
         const error = (value as { error?: unknown })["error"];
         throw new Error(
           typeof error === "string" ? error : `请求失败：HTTP ${String(response.status)}`,
         );
       }
-      this.store.update((state) => {
-        state.pending = null;
-      });
 
       onApplied?.();
-      const result = value as SessionEditorOperationResult;
-
-      if (String(result.sessionId) !== String(this.sessionId)) {
-        this.uiWorkspace.openSession(result.sessionId as SessionId);
-        return true;
-      }
-
-      const face = this.sessions.binding(this.sessionId)?.session;
-      const resync = (face as unknown as { resync?: () => Promise<void> }).resync;
-      if (resync !== undefined) {
-        try {
-          await resync.call(face);
 
-          const projections = (
-            face as unknown as { projections?: { truncate?(lastSeq: number): void } }
-          ).projections;
-          if (typeof projections?.truncate !== "function") {
-            location.reload();
-            return true;
-          }
-          projections.truncate(-1);
-          void this.load();
-          return true;
-        } catch {}
+      // 会话窗口必须重建：rewind 把日志 seq 回退了，窗口里已渲染的旧节点不会自己消失
+      // （实测：被裁剪的消息残留、新消息也追加不进去）。重建入口只在**运行时**对象上
+      // （ClientSession 的 `resync()`；类型面 `SessionFace` 并未暴露它），所以逐个探测；
+      // 都拿不到时记一条 warn 便于诊断，且不回退整页重载（刷新会打断用户）。
+      try {
+        await this.rebuildWindow();
+      } catch (error: unknown) {
+        console.warn("[session-editor] 操作已生效，但会话窗口重建失败：", error);
       }
-      location.reload();
       return true;
-    } catch (error) {
-      if (this.disposed) return false;
-      this.store.update((state) => {
-        state.pending = null;
-        state.error = messageOf(error);
-      });
+    } catch {
       return false;
+    } finally {
+      this.pending = null;
     }
   }
 
-  private messageTexts(message: EditableMessageBlock): readonly string[] {
-    const prefix = `${String(message.eventSeq)}:`;
-    const blocks = (this.store.getSnapshot().timeline?.messages ?? [])
-      .filter((row) => row.kind === "user" && row.key.startsWith(prefix))
-      .sort((left, right) => left.blockIndex - right.blockIndex)
-      .map((row) => row.text);
-    return blocks.length === 0 ? [message.text] : blocks;
+  /**
+   * 让上游重开该会话的历史窗口（rewind 之后客户端窗口的 seq 基线已经失效）。
+   *
+   * 探测顺序：`binding(id).session.resync()`（上游 ClientSession 的重建入口，类型面没暴露）
+   * → `sessions.refresh()`（只刷列表元数据，聊胜于无）→ 都没有就记一条 warn。
+   */
+  private async rebuildWindow(): Promise<void> {
+    const sessions = this.sessions as unknown as {
+      binding?: (id: SessionId) => { session?: { resync?: () => Promise<void> } } | undefined;
+      refresh?: () => Promise<void>;
+    };
+    const face = sessions.binding?.(this.sessionId)?.session;
+    const resync = face?.resync;
+    if (typeof resync === "function") {
+      await resync.call(face);
+      return;
+    }
+    if (typeof sessions.refresh === "function") {
+      await sessions.refresh();
+      return;
+    }
+    console.warn(
+      "[session-editor] 未找到会话窗口重建入口（binding.resync / refresh 都不可用），窗口可能停留在 rewind 之前的状态",
+    );
   }
 
-  private setComposerDraft(texts: readonly string[]): void {
+  private setComposerDraft(text: string): void {
     if (this.sessions.binding(this.sessionId) === undefined) return;
     const scoped = this.sessions.scope(this.sessionId);
     if (scoped === undefined) return;
@@ -287,6 +124,6 @@ export class SessionEditorController {
           };
         }
       | undefined;
-    conversation?.input?.for(scoped).restoreDraft(texts.join("\n\n"));
+    conversation?.input?.for(scoped).restoreDraft(text);
   }
 }

package/src/client/index.ts

@@ -24,10 +24,6 @@ export function apply(ctx: Context): void {
     return controller;
   };
 
-  ctx.on("connection/reset", () => {
-    for (const controller of controllers.values()) void controller.load();
-  });
-
   registerChatNodeRenderers(ctx, controllerFor);
 
   ctx.slots.inject("conversation.composer.dock", () => registerComposerStats(ctx.slots));

package/src/index.ts

@@ -13,35 +13,28 @@ import {
   SessionBranchError,
   balanceRewindPrefix,
   type BranchBoundary,
-  type BranchTimeline,
 } from "@morlay/session-branch";
 import type {
   EditOperation,
-  EditableMessageBlock,
   RecallOperation,
   RerollOperation,
   RetryOperation,
-  RetryableTurn,
   SessionEditorResult,
 } from "./types.ts";
 import {
   SESSION_EDITOR_PATH,
   type SessionEditorOperation,
   type SessionEditorOperationResult,
-  type SessionEditorTimeline,
-  toTimelinePayload,
 } from "./shared.ts";
 import {
   closedTurns,
   droppedCompactions,
-  editableMessages,
   editPlan,
   precedingContentIndex,
   recallBoundary,
   restoreCompactions,
   retryPlan,
   rerollPlan,
-  retryableTurns,
 } from "./plan.ts";
 
 export type { CascadePolicy, EditableBlockKind } from "@morlay/session-branch";
@@ -57,10 +50,7 @@ export type {
   SessionEditorResult,
 } from "./types.ts";
 
-export { closedTurns, editableMessages, retryableTurns };
-export { SESSION_BRANCH_VERSION_SCHEMA } from "@morlay/session-branch";
-
-export type { BranchTimeline, SessionBranchVersionEvent } from "@morlay/session-branch";
+export { closedTurns, editableMessages, retryableTurns } from "./plan.ts";
 
 declare module "@deepseek-ai/cordis" {
   interface Context {
@@ -102,18 +92,12 @@ export interface EditorAgentRegistry {
   }): Promise<EditorAgentHandle>;
 }
 
-function appendLogSeedEvent(
-  events: SessionEvent[],
-  type: string,
-  data: unknown,
-  ignorable = false,
-): void {
+function appendLogSeedEvent(events: SessionEvent[], type: string, data: unknown): void {
   events.push({
     type: type as SessionEvent["type"],
     seq: events.length,
     time: Date.now(),
     data: data as SessionEvent["data"],
-    ...(ignorable ? { ignorable: true as const } : {}),
   } as SessionEvent);
 }
 
@@ -165,22 +149,8 @@ function keepFromOf(events: readonly SessionEvent[], boundary: number): number {
 async function appendSeedSuffixLive(
   session: Session,
   seedSuffix: readonly SessionEvent[],
-  appendDirect: (events: readonly SessionEvent[]) => Promise<void>,
 ): Promise<void> {
   for (const event of seedSuffix) {
-    const ignorable = (event as { ignorable?: boolean }).ignorable === true;
-    if (ignorable) {
-      const s = session as unknown as {
-        log: SessionEvent[];
-        eventsSnapshot?: unknown;
-      };
-
-      const seq = s.log.length;
-      await appendDirect([{ ...event, seq } as SessionEvent]);
-      s.log.push({ ...event, seq } as SessionEvent);
-      s.eventsSnapshot = undefined;
-      continue;
-    }
     const s = session as unknown as {
       append(
         type: string,
@@ -244,10 +214,6 @@ export class SessionEditor extends Service {
     return this.ctx.sessionBranch.rewind(id, toBoundary, signal);
   }
 
-  timeline(sessionId: SessionId, signal?: AbortSignal): Promise<BranchTimeline> {
-    return this.ctx.sessionBranch.timeline(sessionId, signal);
-  }
-
   edit(operation: EditOperation, signal?: AbortSignal): Promise<SessionEditorResult> {
     return this.branchOperation(operation, signal);
   }
@@ -264,19 +230,6 @@ export class SessionEditor extends Service {
     return this.recallOperation(operation, signal);
   }
 
-  async editableMessages(
-    sessionId: SessionId,
-    signal?: AbortSignal,
-  ): Promise<EditableMessageBlock[]> {
-    const events = await this.readEvents(sessionId, signal);
-    return editableMessages(closedTurns(events));
-  }
-
-  async retryableTurns(sessionId: SessionId, signal?: AbortSignal): Promise<RetryableTurn[]> {
-    const events = await this.readEvents(sessionId, signal);
-    return retryableTurns(closedTurns(events));
-  }
-
   private async branchOperation(
     operation: EditOperation | RerollOperation | RetryOperation,
     signal?: AbortSignal,
@@ -309,8 +262,6 @@ export class SessionEditor extends Service {
 
     const replayTurn = preceding < 0 ? 1 : turns[preceding]!.turn + 1;
 
-    const versionSeed: SessionEvent[] = [];
-    appendLogSeedEvent(versionSeed, "session-branch/version", plan.version, true);
     const manualSeed: SessionEvent[] = [];
     if (plan.manualTurn !== undefined) {
       appendManualTurn(manualSeed, { ...plan.manualTurn, turn: replayTurn });
@@ -326,11 +277,10 @@ export class SessionEditor extends Service {
     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: SessionEvent[] = [
-      ...versionSeed,
-      ...restoreCompactions(compactions, keepFrom, seedStart + versionSeed.length),
+      ...restoreCompactions(compactions, keepFrom, seedStart),
       ...manualSeed,
     ];
     await this.appendSeedSuffix(operation.sessionId, live, seedSuffix, events, keepFrom);
@@ -402,22 +352,8 @@ export class SessionEditor extends Service {
   ): Promise<void> {
     if (seedSuffix.length === 0) return;
     if (live !== undefined) {
-      const persistence = this.ctx.sessionPersistence as unknown as {
-        tracker: {
-          writerOf(id: SessionId):
-            | {
-                append(events: readonly SessionEvent[]): Promise<void>;
-              }
-            | undefined;
-        };
-      };
-      const handle = persistence.tracker.writerOf(sessionId);
-      if (handle === undefined) {
-        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 appendSeedSuffixLive(live, seedSuffix);
       await this.ctx.sessions.flush(live);
       return;
     }
@@ -631,16 +567,6 @@ function respondJson(response: HttpResponseLike, status: number, value: unknown)
   response.end(JSON.stringify(value));
 }
 
-async function readTimeline(
-  editor: SessionEditor,
-  sessionId: SessionId,
-): Promise<SessionEditorTimeline> {
-  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: SessionEditor,
   operation: SessionEditorOperation,
@@ -699,12 +625,6 @@ async function handleRoute(
   response: HttpResponseLike,
 ): Promise<void> {
   try {
-    if (request.method === "GET") {
-      const url = new URL(request.url ?? SESSION_EDITOR_PATH, "http://session-editor.local");
-      const sessionId = sessionIdOf(url.searchParams.get("sessionId"));
-      respondJson(response, 200, await readTimeline(editor, sessionId));
-      return;
-    }
     if (request.method === "POST") {
       respondJson(
         response,
@@ -736,62 +656,4 @@ function registerHttpRoutes(ctx: Context): void {
       handler: (request, response) => handleRoute(editor, request, response),
     });
   }, "session-editor: HTTP route");
-
-  const registerConnectionRoute = (): void => {
-    const connection = ctx.get("connection", false) as
-      | {
-          fetch: {
-            register(route: {
-              path: string;
-              methods: readonly ("GET" | "HEAD" | "POST")[];
-              requestBody: "buffered" | "streaming";
-              fetch: (request: Request) => Promise<Response>;
-            }): () => Promise<void>;
-          };
-        }
-      | undefined;
-    if (connection === undefined) 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: SessionEditor, request: Request): Promise<Response> {
-  try {
-    if (request.method === "GET") {
-      const url = new URL(request.url);
-      const sessionId = sessionIdOf(url.searchParams.get("sessionId"));
-      return jsonResponse(200, await readTimeline(editor, sessionId));
-    }
-    if (request.method === "POST") {
-      return jsonResponse(200, await runOperation(editor, decodeOperation(await request.json())));
-    }
-    return new Response(null, { status: 405 });
-  } catch (error: unknown) {
-    const message = error instanceof Error ? error.message : String(error);
-    return jsonResponse(error instanceof TypeError ? 400 : 409, { error: message });
-  }
-}
-
-function jsonResponse(status: number, value: unknown): Response {
-  return new Response(JSON.stringify(value), {
-    status,
-    headers: {
-      "content-type": "application/json; charset=utf-8",
-      "cache-control": "no-store",
-    },
-  });
 }