@mrclrchtr/supi-lsp 10.0.0 → 11.0.0

package/src/provider/semantic-edit-normalizer.ts

@@ -1,9 +1,17 @@
-import { fileURLToPath } from "node:url";
 import type {
   DocumentEditPrecondition,
   FileEdit,
   RefactorResult,
 } from "@mrclrchtr/supi-code-runtime/api";
+import {
+  asRecord,
+  getResourceOperationKind,
+  hasNoInheritedAllowedKeys,
+  hasOnlyKeys,
+  normalizeTextEdits,
+  parseTextDocumentEdit,
+  toFilePath,
+} from "./semantic-edit-protocol.ts";
 
 /** A complete semantic server response that can contain precise text edits. */
 export type SemanticEditResponse =
@@ -11,8 +19,15 @@ export type SemanticEditResponse =
   | { readonly kind: "code-action"; readonly action: unknown };
 
 /** Provider route and client document state used to establish mutation preconditions. */
+export interface SemanticDocumentSnapshotEvidence {
+  readonly version: number;
+  readonly contentFingerprint: string;
+  readonly diskContentFingerprint: string;
+}
+
 export interface SemanticEditNormalizationContext {
   getOpenDocumentVersion(file: string): number | null;
+  getSynchronizedDocumentSnapshot?(file: string): SemanticDocumentSnapshotEvidence | null;
   authorizedMutationRoots: readonly string[];
 }
 
@@ -133,20 +148,46 @@ function normalizeChanges(
   }
 
   const edits: FileEdit[] = [];
+  const documentPreconditions: DocumentEditPrecondition[] = [];
   for (const uri of Object.keys(changes).sort((left, right) => left.localeCompare(right))) {
-    const file = toFilePath(uri);
-    const textEdits = changes[uri];
-    if (!file) {
-      return { kind: "unavailable", reason: `Workspace edit URI "${uri}" is not a file URI.` };
-    }
-    if (!Array.isArray(textEdits)) {
-      return { kind: "unavailable", reason: "Workspace edit contains malformed changes." };
-    }
-    const normalized = normalizeTextEdits(file, textEdits);
-    if (normalized.kind === "unavailable") return normalized;
-    edits.push(...normalized.edits);
+    const result = normalizeChangesEntry(uri, changes[uri], context);
+    if (result.kind === "unavailable") return result;
+    edits.push(...result.edits);
+    if (result.precondition) documentPreconditions.push(result.precondition);
+  }
+  return preciseOrEmpty(
+    edits,
+    context,
+    documentPreconditions.length > 0 ? documentPreconditions : undefined,
+  );
+}
+
+function normalizeChangesEntry(
+  uri: string,
+  value: unknown,
+  context: SemanticEditNormalizationContext,
+):
+  | { kind: "precise"; edits: FileEdit[]; precondition?: DocumentEditPrecondition }
+  | { kind: "unavailable"; reason: string } {
+  const file = toFilePath(uri);
+  if (!file) {
+    return { kind: "unavailable", reason: `Workspace edit URI "${uri}" is not a file URI.` };
   }
-  return preciseOrEmpty(edits, context);
+  if (!Array.isArray(value)) {
+    return { kind: "unavailable", reason: "Workspace edit contains malformed changes." };
+  }
+  const normalized = normalizeTextEdits(file, value);
+  if (normalized.kind === "unavailable") return normalized;
+  if (!context.getSynchronizedDocumentSnapshot) {
+    return { kind: "precise", edits: normalized.edits };
+  }
+  const precondition = establishSynchronizedContentPrecondition(file, context, false);
+  if (typeof precondition === "string") return { kind: "unavailable", reason: precondition };
+  return {
+    kind: "precise",
+    edits: normalized.edits,
+    ...(precondition ? { precondition } : {}),
+  };
 }
 
 function normalizeDocumentChanges(
@@ -204,37 +245,6 @@ function normalizeDocumentChange(
     : { kind: "precise", edits: normalized.edits, precondition };
 }
 
-function parseTextDocumentEdit(edit: Record<string, unknown> | null): {
-  edit: Record<"textDocument" | "edits", unknown> & { edits: unknown[] };
-  textDocument: Record<string, unknown>;
-} | null {
-  const textDocument = asRecord(edit?.textDocument);
-  if (
-    !edit ||
-    !Object.hasOwn(edit, "textDocument") ||
-    !Object.hasOwn(edit, "edits") ||
-    !hasOnlyKeys(edit, ["textDocument", "edits"]) ||
-    !hasNoInheritedAllowedKeys(edit, ["textDocument", "edits"]) ||
-    !textDocument ||
-    !Object.hasOwn(textDocument, "uri") ||
-    !hasOnlyKeys(textDocument, ["uri", "version"]) ||
-    !hasNoInheritedAllowedKeys(textDocument, ["uri", "version"]) ||
-    !Array.isArray(edit.edits)
-  ) {
-    return null;
-  }
-  return {
-    edit: edit as Record<"textDocument" | "edits", unknown> & { edits: unknown[] },
-    textDocument,
-  };
-}
-
-function getResourceOperationKind(value: Record<string, unknown> | null): string | null {
-  return value && (value.kind === "create" || value.kind === "rename" || value.kind === "delete")
-    ? value.kind
-    : null;
-}
-
 function establishPrecondition(
   file: string,
   version: unknown,
@@ -242,9 +252,13 @@ function establishPrecondition(
 ): DocumentEditPrecondition | string {
   const openVersion = context.getOpenDocumentVersion(file);
   if (version === null) {
-    return openVersion === null
-      ? { file, kind: "disk-content" }
-      : `Document change for "${file}" requires disk content, but the document is open.`;
+    if (openVersion === null) {
+      return context.getSynchronizedDocumentSnapshot?.(file)
+        ? `Document change for "${file}" is no longer open after its synchronized snapshot.`
+        : { file, kind: "disk-content" };
+    }
+    const precondition = establishSynchronizedContentPrecondition(file, context, true, openVersion);
+    return precondition ?? `Document change for "${file}" has no verified content precondition.`;
   }
   if (!Number.isInteger(version) || (version as number) < 0) {
     return `Document change for "${file}" has an invalid version.`;
@@ -255,46 +269,48 @@ function establishPrecondition(
   if (openVersion !== version) {
     return `Document change version for "${file}" does not match the open document.`;
   }
+  if (context.getSynchronizedDocumentSnapshot?.(file)) {
+    return (
+      establishSynchronizedContentPrecondition(file, context, true, version as number) ??
+      `Document change for "${file}" has no verified content precondition.`
+    );
+  }
   return { file, kind: "open-document-version", version: version as number };
 }
 
-function normalizeTextEdits(
+function establishSynchronizedContentPrecondition(
   file: string,
-  values: unknown[],
-): { kind: "precise"; edits: FileEdit[] } | { kind: "unavailable"; reason: string } {
-  const edits: FileEdit[] = [];
-  for (const value of values) {
-    const textEdit = asRecord(value);
-    if (textEdit && Object.hasOwn(textEdit, "snippet")) {
-      return { kind: "unavailable", reason: "Workspace edit contains a snippet text edit." };
-    }
-    if (textEdit && Object.hasOwn(textEdit, "annotationId")) {
-      return { kind: "unavailable", reason: "Workspace edit contains a text edit annotation." };
-    }
-    const range = asRecord(textEdit?.range);
-    const start = asPosition(range?.start);
-    const end = asPosition(range?.end);
-    if (
-      !textEdit ||
-      !Object.hasOwn(textEdit, "range") ||
-      !Object.hasOwn(textEdit, "newText") ||
-      !hasOnlyKeys(textEdit, ["range", "newText"]) ||
-      !hasNoInheritedAllowedKeys(textEdit, ["range", "newText", "snippet", "annotationId"]) ||
-      !range ||
-      !Object.hasOwn(range, "start") ||
-      !Object.hasOwn(range, "end") ||
-      !hasOnlyKeys(range, ["start", "end"]) ||
-      !hasNoInheritedAllowedKeys(range, ["start", "end"]) ||
-      !start ||
-      !end ||
-      isBefore(end, start) ||
-      typeof textEdit.newText !== "string"
-    ) {
-      return { kind: "unavailable", reason: "Workspace edit contains a malformed text edit." };
+  context: SemanticEditNormalizationContext,
+  required: boolean,
+  expectedVersion?: number,
+): DocumentEditPrecondition | null | string {
+  const openVersion = context.getOpenDocumentVersion(file);
+  const snapshot = context.getSynchronizedDocumentSnapshot?.(file);
+  if (openVersion === null) {
+    if (required || snapshot) {
+      return `Document change for "${file}" requires verified synchronized content, but the document is closed.`;
     }
-    edits.push({ file, range: { start, end }, newText: textEdit.newText });
+    return null;
+  }
+  if (!snapshot) {
+    return required
+      ? `Document change for "${file}" requires a verified synchronized content snapshot, but the document is open without one.`
+      : `Open document "${file}" has no verified synchronized content snapshot.`;
   }
-  return { kind: "precise", edits };
+  if (
+    snapshot.version !== openVersion ||
+    (expectedVersion !== undefined && snapshot.version !== expectedVersion) ||
+    snapshot.contentFingerprint.length === 0 ||
+    snapshot.contentFingerprint !== snapshot.diskContentFingerprint
+  ) {
+    return `Document change for "${file}" does not match its synchronized content snapshot.`;
+  }
+  return {
+    file,
+    kind: "open-document-content",
+    version: snapshot.version,
+    fingerprint: snapshot.contentFingerprint,
+  };
 }
 
 function preciseOrEmpty(
@@ -316,51 +332,3 @@ function preciseOrEmpty(
     ? { kind: "precise", edits: { edits, documentPreconditions }, authorizedMutationRoots }
     : { kind: "precise", edits: { edits }, authorizedMutationRoots };
 }
-
-function hasOnlyKeys(value: Record<string, unknown>, allowed: readonly string[]): boolean {
-  const allowedKeys = new Set(allowed);
-  return Object.keys(value).every((key) => allowedKeys.has(key));
-}
-
-function hasNoInheritedAllowedKeys(
-  value: Record<string, unknown>,
-  allowed: readonly string[],
-): boolean {
-  return allowed.every((key) => !(key in value) || Object.hasOwn(value, key));
-}
-
-function asRecord(value: unknown): Record<string, unknown> | null {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : null;
-}
-
-function asPosition(value: unknown): { line: number; character: number } | null {
-  const position = asRecord(value);
-  return position &&
-    Object.hasOwn(position, "line") &&
-    Object.hasOwn(position, "character") &&
-    hasOnlyKeys(position, ["line", "character"]) &&
-    Number.isInteger(position.line) &&
-    (position.line as number) >= 0 &&
-    Number.isInteger(position.character) &&
-    (position.character as number) >= 0
-    ? { line: position.line as number, character: position.character as number }
-    : null;
-}
-
-function isBefore(
-  left: { line: number; character: number },
-  right: { line: number; character: number },
-): boolean {
-  return left.line < right.line || (left.line === right.line && left.character < right.character);
-}
-
-function toFilePath(uri: string): string | null {
-  try {
-    const parsed = new URL(uri);
-    return parsed.protocol === "file:" ? fileURLToPath(parsed) : null;
-  } catch {
-    return null;
-  }
-}

package/src/provider/semantic-edit-protocol.ts

@@ -0,0 +1,132 @@
+import { fileURLToPath } from "node:url";
+import type { FileEdit } from "@mrclrchtr/supi-code-runtime/api";
+
+export interface ParsedTextDocumentEdit {
+  readonly edit: Record<"textDocument" | "edits", unknown> & { edits: unknown[] };
+  readonly textDocument: Record<string, unknown>;
+}
+
+export type NormalizedTextEdits =
+  | { readonly kind: "precise"; readonly edits: FileEdit[] }
+  | { readonly kind: "unavailable"; readonly reason: string };
+
+/** Convert an object-shaped protocol value to a record. */
+export function asRecord(value: unknown): Record<string, unknown> | null {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+/** Check that a protocol record has no unknown own keys. */
+export function hasOnlyKeys(value: Record<string, unknown>, allowed: readonly string[]): boolean {
+  const allowedKeys = new Set(allowed);
+  return Object.keys(value).every((key) => allowedKeys.has(key));
+}
+
+/** Reject inherited values for keys that the protocol record may use. */
+export function hasNoInheritedAllowedKeys(
+  value: Record<string, unknown>,
+  allowed: readonly string[],
+): boolean {
+  return allowed.every((key) => !(key in value) || Object.hasOwn(value, key));
+}
+
+/** Return the resource-operation kind when a document change is not a text edit. */
+export function getResourceOperationKind(value: Record<string, unknown> | null): string | null {
+  return value && (value.kind === "create" || value.kind === "rename" || value.kind === "delete")
+    ? value.kind
+    : null;
+}
+
+/** Parse the strict text-document edit shape without establishing its version. */
+export function parseTextDocumentEdit(
+  edit: Record<string, unknown> | null,
+): ParsedTextDocumentEdit | null {
+  const textDocument = asRecord(edit?.textDocument);
+  if (
+    !edit ||
+    !Object.hasOwn(edit, "textDocument") ||
+    !Object.hasOwn(edit, "edits") ||
+    !hasOnlyKeys(edit, ["textDocument", "edits"]) ||
+    !hasNoInheritedAllowedKeys(edit, ["textDocument", "edits"]) ||
+    !textDocument ||
+    !Object.hasOwn(textDocument, "uri") ||
+    !hasOnlyKeys(textDocument, ["uri", "version"]) ||
+    !hasNoInheritedAllowedKeys(textDocument, ["uri", "version"]) ||
+    !Array.isArray(edit.edits)
+  ) {
+    return null;
+  }
+  return {
+    edit: edit as Record<"textDocument" | "edits", unknown> & { edits: unknown[] },
+    textDocument,
+  };
+}
+
+/** Validate and normalize a complete text-edit collection. */
+export function normalizeTextEdits(file: string, values: unknown[]): NormalizedTextEdits {
+  const edits: FileEdit[] = [];
+  for (const value of values) {
+    const textEdit = asRecord(value);
+    if (textEdit && Object.hasOwn(textEdit, "snippet")) {
+      return { kind: "unavailable", reason: "Workspace edit contains a snippet text edit." };
+    }
+    if (textEdit && Object.hasOwn(textEdit, "annotationId")) {
+      return { kind: "unavailable", reason: "Workspace edit contains a text edit annotation." };
+    }
+    const range = asRecord(textEdit?.range);
+    const start = asPosition(range?.start);
+    const end = asPosition(range?.end);
+    if (
+      !textEdit ||
+      !Object.hasOwn(textEdit, "range") ||
+      !Object.hasOwn(textEdit, "newText") ||
+      !hasOnlyKeys(textEdit, ["range", "newText"]) ||
+      !hasNoInheritedAllowedKeys(textEdit, ["range", "newText", "snippet", "annotationId"]) ||
+      !range ||
+      !Object.hasOwn(range, "start") ||
+      !Object.hasOwn(range, "end") ||
+      !hasOnlyKeys(range, ["start", "end"]) ||
+      !hasNoInheritedAllowedKeys(range, ["start", "end"]) ||
+      !start ||
+      !end ||
+      isBefore(end, start) ||
+      typeof textEdit.newText !== "string"
+    ) {
+      return { kind: "unavailable", reason: "Workspace edit contains a malformed text edit." };
+    }
+    edits.push({ file, range: { start, end }, newText: textEdit.newText });
+  }
+  return { kind: "precise", edits };
+}
+
+/** Convert an LSP file URI to its local path. */
+export function toFilePath(uri: string): string | null {
+  try {
+    const parsed = new URL(uri);
+    return parsed.protocol === "file:" ? fileURLToPath(parsed) : null;
+  } catch {
+    return null;
+  }
+}
+
+function asPosition(value: unknown): { line: number; character: number } | null {
+  const position = asRecord(value);
+  return position &&
+    Object.hasOwn(position, "line") &&
+    Object.hasOwn(position, "character") &&
+    hasOnlyKeys(position, ["line", "character"]) &&
+    Number.isInteger(position.line) &&
+    (position.line as number) >= 0 &&
+    Number.isInteger(position.character) &&
+    (position.character as number) >= 0
+    ? { line: position.line as number, character: position.character as number }
+    : null;
+}
+
+function isBefore(
+  left: { line: number; character: number },
+  right: { line: number; character: number },
+): boolean {
+  return left.line < right.line || (left.line === right.line && left.character < right.character);
+}

package/src/session/runtime-controller.ts

@@ -8,7 +8,10 @@
 // It does NOT import pi event types or ExtensionAPI.
 
 // biome-ignore lint/style/noExcessiveLinesPerFile: session lifecycle, capability projection, and telemetry stay in one controller.
-import type { WorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
+import type {
+  CFamilyFileAssociationResolver,
+  WorkspaceRuntime,
+} from "@mrclrchtr/supi-code-runtime/api";
 import {
   recordDebugEvent,
   truncateDebugIdentity as truncateIdentity,
@@ -83,6 +86,8 @@ export interface LspRuntimeControllerOptions {
   readonly homeDir?: string;
   /** A policy captured by the owning workspace host. */
   readonly automaticPathPolicy?: AutomaticLspPathPolicy;
+  /** The same immutable C-family association snapshot used by Tree-sitter. */
+  readonly fileAssociations?: CFamilyFileAssociationResolver;
 }
 
 /** Result type from {@link LspRuntimeController.start}. */
@@ -97,6 +102,7 @@ export type LspRuntimeTransitionKind =
   | "readiness"
   | "crash"
   | "recovery"
+  | "retirement"
   | "shutdown"
   | "tracked-files";
 
@@ -340,6 +346,7 @@ export class LspRuntimeController {
         this.handleManagerLifecycle(manager, generation, transition);
       },
       automaticPathPolicy,
+      this.#options.fileAssociations,
     );
     this.#activeManager = manager;
     this.#latestManagerTransition = null;

package/src/session/runtime-registry.ts

@@ -44,6 +44,7 @@ import type {
   RecoverDiagnosticsResult,
   StartupRetryReport,
 } from "./runtime-diagnostics.ts";
+import { runRoutedRename } from "./runtime-rename.ts";
 import type {
   BulkTrackFilesResult,
   RoutedMutationResponse,
@@ -81,6 +82,7 @@ export {
 export type {
   BulkTrackFileOutcome,
   BulkTrackFilesResult,
+  RoutedMutationDocumentSnapshot,
   RoutedMutationResponse,
   SemanticReadinessResult,
   WorkspaceCodeActionRequestOptions,
@@ -236,28 +238,13 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
     newName: string,
     control?: CodeRequestControl,
   ): Promise<RoutedMutationResponse<WorkspaceEdit | null> | null> {
-    const resolvedPath = this.resolveFilePath(filePath);
-    const client = await this.manager.ensureFileOpen(resolvedPath, {
-      recoverProcessCrash: true,
+    return runRoutedRename({
+      manager: this.manager,
+      file: this.resolveFilePath(filePath),
+      position,
+      newName,
       control,
     });
-    if (!client) return null;
-    if (typeof client.renameDetailed === "function") {
-      const result = await client.renameDetailed(resolvedPath, position, newName, control);
-      return {
-        value: result.kind === "completed" ? result.data : null,
-        authorizedMutationRoots: [client.root],
-        ...(result.kind === "unavailable"
-          ? { reason: result.reason }
-          : result.data === null
-            ? { reason: "LSP server returned no workspace edit." }
-            : {}),
-      };
-    }
-    return {
-      value: await client.rename(resolvedPath, position, newName, control),
-      authorizedMutationRoots: [client.root],
-    };
   }
 
   getOpenDocumentVersion(filePath: string): number | null {

package/src/session/runtime-rename.ts

@@ -0,0 +1,172 @@
+import * as path from "node:path";
+import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
+import type { LspClient } from "../client/client.ts";
+import type { SemanticInputDocumentSnapshot } from "../client/client-semantic-input-barrier.ts";
+import type { Position, WorkspaceEdit } from "../config/types.ts";
+import type { LspManager } from "../manager/manager.ts";
+import { discoverSemanticEditFiles } from "../provider/semantic-edit-discovery.ts";
+import type {
+  RoutedMutationDocumentSnapshot,
+  RoutedMutationResponse,
+} from "./workspace-lsp-runtime.ts";
+
+/** Route one rename and retain request-scoped evidence for every affected file. */
+export async function runRoutedRename(options: {
+  readonly manager: LspManager;
+  readonly file: string;
+  readonly position: Position;
+  readonly newName: string;
+  readonly control?: CodeRequestControl;
+}): Promise<RoutedMutationResponse<WorkspaceEdit | null> | null> {
+  const { manager, file, position, newName, control } = options;
+  const client = await manager.ensureFileOpen(file, {
+    recoverProcessCrash: true,
+    control,
+  });
+  if (!client) return null;
+  const authorizedMutationRoots = [client.root];
+
+  if (typeof client.renameDetailedWithSnapshots === "function") {
+    return renameWithSnapshots({
+      client,
+      manager,
+      file,
+      position,
+      newName,
+      control,
+      authorizedMutationRoots,
+    });
+  }
+  if (typeof client.renameDetailed === "function") {
+    const result = await client.renameDetailed(file, position, newName, control);
+    return {
+      value: result.kind === "completed" ? result.data : null,
+      authorizedMutationRoots,
+      ...(result.kind === "unavailable"
+        ? { reason: result.reason }
+        : result.data === null
+          ? { reason: "LSP server returned no workspace edit." }
+          : {}),
+    };
+  }
+  return {
+    value: await client.rename(file, position, newName, control),
+    authorizedMutationRoots,
+  };
+}
+
+async function renameWithSnapshots(options: {
+  readonly client: LspClient;
+  readonly manager: LspManager;
+  readonly file: string;
+  readonly position: Position;
+  readonly newName: string;
+  readonly control?: CodeRequestControl;
+  readonly authorizedMutationRoots: readonly string[];
+}): Promise<RoutedMutationResponse<WorkspaceEdit | null>> {
+  const { client, manager, file, position, newName, control, authorizedMutationRoots } = options;
+  const first = await client.renameDetailedWithSnapshots(file, position, newName, {
+    control,
+    snapshotFiles: [file],
+  });
+  if (first.result.kind === "unavailable" || first.result.data === null) {
+    return {
+      value: null,
+      authorizedMutationRoots,
+      ...(first.result.kind === "unavailable"
+        ? { reason: first.result.reason }
+        : { reason: "LSP server returned no workspace edit." }),
+    };
+  }
+
+  const discovery = discoverSemanticEditFiles(first.result.data);
+  if (discovery.kind === "unavailable") {
+    return { value: null, authorizedMutationRoots, reason: discovery.reason };
+  }
+  if (hasRenameDocumentSnapshots(discovery.files, first.documentSnapshots)) {
+    return {
+      value: first.result.data,
+      authorizedMutationRoots,
+      documentSnapshots: mapRenameDocumentSnapshots(first.documentSnapshots),
+    };
+  }
+
+  if (first.inputRevision === undefined) {
+    return {
+      value: null,
+      authorizedMutationRoots,
+      reason: "Rename has no verified input revision for document enrollment.",
+    };
+  }
+  const enrollment = await manager.enrollRenameDocuments(client, discovery.files, control);
+  if (enrollment.kind === "unavailable") {
+    return { value: null, authorizedMutationRoots, reason: enrollment.reason };
+  }
+  const snapshotFiles = [...new Set([file, ...discovery.files])].sort((left, right) =>
+    left.localeCompare(right),
+  );
+  const followup = await client.renameDetailedWithSnapshots(file, position, newName, {
+    control,
+    snapshotFiles,
+    inputRevision: first.inputRevision,
+  });
+  if (followup.result.kind === "unavailable" || followup.result.data === null) {
+    return {
+      value: null,
+      authorizedMutationRoots,
+      ...(followup.result.kind === "unavailable"
+        ? { reason: followup.result.reason }
+        : { reason: "LSP server returned no workspace edit after document enrollment." }),
+    };
+  }
+
+  const verified = discoverSemanticEditFiles(followup.result.data);
+  if (
+    verified.kind === "unavailable" ||
+    !isSubset(verified.files, discovery.files) ||
+    !hasRenameDocumentSnapshots(snapshotFiles, followup.documentSnapshots)
+  ) {
+    return {
+      value: null,
+      authorizedMutationRoots,
+      reason: "Rename response changed its edit targets after synchronized enrollment.",
+    };
+  }
+  return {
+    value: followup.result.data,
+    authorizedMutationRoots,
+    documentSnapshots: mapRenameDocumentSnapshots(followup.documentSnapshots),
+  };
+}
+
+function hasRenameDocumentSnapshots(
+  files: readonly string[],
+  snapshots: readonly SemanticInputDocumentSnapshot[],
+): boolean {
+  const byFile = new Map(snapshots.map((snapshot) => [path.resolve(snapshot.filePath), snapshot]));
+  return files.every((file) => {
+    const snapshot = byFile.get(path.resolve(file));
+    return Boolean(
+      snapshot &&
+        snapshot.version >= 0 &&
+        snapshot.contentFingerprint.length > 0 &&
+        snapshot.contentFingerprint === snapshot.diskContentFingerprint,
+    );
+  });
+}
+
+function mapRenameDocumentSnapshots(
+  snapshots: readonly SemanticInputDocumentSnapshot[],
+): RoutedMutationDocumentSnapshot[] {
+  return snapshots.map((snapshot) => ({
+    file: snapshot.filePath,
+    version: snapshot.version,
+    contentFingerprint: snapshot.contentFingerprint,
+    diskContentFingerprint: snapshot.diskContentFingerprint,
+  }));
+}
+
+function isSubset(values: readonly string[], allowed: readonly string[]): boolean {
+  const accepted = new Set(allowed.map((file) => path.resolve(file)));
+  return values.every((file) => accepted.has(path.resolve(file)));
+}