@ian-pascoe/pi-lsp 0.1.0

package/src/pi-lsp-extension.ts

@@ -0,0 +1,379 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
+  getAgentDir,
+  SettingsManager,
+  truncateHead,
+  type ExtensionAPI,
+  type ExtensionContext,
+  type ExtensionFactory,
+  type SessionEntry,
+  type ToolResultEvent,
+} from "@earendil-works/pi-coding-agent";
+import { type Static, Type } from "typebox";
+import { Value } from "typebox/value";
+import { PositionEncodingKind, type Diagnostic } from "vscode-languageserver-protocol/node";
+import {
+  appendPiPostEditDiagnostics,
+  type PostEditDiagnosticOutcome,
+  type PostEditDiagnosticPath,
+  type PostEditDiagnosticsResultPatch,
+  type PostEditDiagnosticsRunner,
+} from "./lsp-post-edit-diagnostics.js";
+import {
+  createPostEditDiagnosticsEntryData,
+  POST_EDIT_DIAGNOSTICS_ENTRY_TYPE,
+  PostEditDiagnosticsEntryDataSchema,
+  renderPostEditDiagnosticsEntry,
+} from "./lsp-post-edit-diagnostics-rendering.js";
+import {
+  convertLspProtocolPosition,
+  normalizeLspPositionEncoding,
+  type LspPositionEncoding,
+} from "./lsp-position-encoding.js";
+import { LspServerClient } from "./lsp-server-client.js";
+import { LspServerManager, normalizeLspFilePath } from "./lsp-server-manager.js";
+import { createLspSessionFiles, type LspSessionFiles } from "./lsp-session-files.js";
+import {
+  LspToolResultDetailsSchema,
+  type LspWorkspaceEditPreviewRecord,
+} from "./lsp-tool-contract.js";
+import { registerLspTool } from "./lsp-tool.js";
+import { LspWorkspaceEditStore } from "./lsp-workspace-edit.js";
+import { resolveLspSettings } from "./pi-lsp-settings.js";
+
+/** Runtime construction effects kept narrow so lifecycle tests can select an isolated Pi agent directory. */
+export interface PiLspLifecycleEffects {
+  /** Return Pi's trust-aware global settings directory. */
+  getAgentDirectory(): string;
+}
+
+interface ActivePiLspSession {
+  readonly cwd: string;
+  readonly manager: LspServerManager<LspServerClient>;
+  readonly sessionFiles: LspSessionFiles;
+}
+
+const productionPiLspLifecycleEffects: PiLspLifecycleEffects = {
+  getAgentDirectory: getAgentDir,
+};
+const DiagnosticMarkupContentSchema = Type.Object(
+  {
+    kind: Type.String(),
+    value: Type.String(),
+  },
+  { additionalProperties: false },
+);
+const AppendedTextContentSchema = Type.Object(
+  {
+    type: Type.Literal("text"),
+    text: Type.String(),
+  },
+  { additionalProperties: false },
+);
+function branchLspToolResultDetails(
+  entries: readonly SessionEntry[],
+): readonly LspWorkspaceEditPreviewRecord[] {
+  const records = new Map<string, LspWorkspaceEditPreviewRecord>();
+  for (const entry of entries) {
+    if (entry.type !== "message") continue;
+    const message = entry.message;
+    if (message.role !== "toolResult" || message.toolName !== "lsp") continue;
+    if (!Value.Check(LspToolResultDetailsSchema, message.details)) continue;
+    const details = message.details;
+    for (const record of details.preview_records ?? []) {
+      records.set(record.preview_id, record);
+    }
+    if (details.kind === "workspace_edit_preview") {
+      records.set(details.preview_record.preview_id, details.preview_record);
+      continue;
+    }
+    if (details.kind === "operation") continue;
+    const applied = records.get(details.preview_id);
+    if (applied !== undefined) {
+      records.set(details.preview_id, { ...applied, state: "applied" });
+    }
+  }
+  return [...records.values()];
+}
+
+function normalizedDiagnosticOutcome(
+  diagnostic: Diagnostic,
+  serverId: string,
+  filePath: string,
+  documentText: string,
+  positionEncoding: LspPositionEncoding,
+): PostEditDiagnosticOutcome {
+  const position = convertLspProtocolPosition(
+    documentText,
+    diagnostic.range.start,
+    positionEncoding,
+  );
+  return {
+    kind: "diagnostic",
+    diagnostic: {
+      serverId,
+      path: filePath,
+      line: position.line,
+      character: position.character,
+      severity: diagnostic.severity ?? 4,
+      message: Value.Check(Type.String(), diagnostic.message)
+        ? diagnostic.message
+        : Value.Parse(DiagnosticMarkupContentSchema, diagnostic.message).value,
+    },
+  };
+}
+
+function failureDiagnosticOutcome(
+  path: string,
+  failure: { readonly code: string; readonly message: string; readonly serverId: string },
+): PostEditDiagnosticOutcome {
+  if (failure.code === "no-matching-server") {
+    return { kind: "no_configured_server", path };
+  }
+  if (failure.message.toLowerCase().includes("timed out")) {
+    return { kind: "timeout", path, serverId: failure.serverId };
+  }
+  return { kind: "unavailable_server", path, serverId: failure.serverId };
+}
+
+class ManagerPostEditDiagnosticsRunner implements PostEditDiagnosticsRunner {
+  constructor(
+    private readonly session: ActivePiLspSession,
+    private readonly signal: AbortSignal | undefined,
+  ) {}
+
+  async runPostEditDiagnostics(
+    paths: readonly PostEditDiagnosticPath[],
+  ): Promise<readonly PostEditDiagnosticOutcome[]> {
+    const outcomes: PostEditDiagnosticOutcome[] = [];
+    for (const { path } of paths) {
+      const filePath = resolve(this.session.cwd, normalizeLspFilePath(path));
+      const result = await this.session.manager.runRead(
+        filePath,
+        undefined,
+        () => true,
+        async (client, route): Promise<readonly PostEditDiagnosticOutcome[]> => {
+          const diagnostics = await client.documentDiagnostics(
+            filePath,
+            route.language.languageId,
+            this.signal,
+          );
+          if (diagnostics.status === "timeout") {
+            return [{ kind: "timeout", path: filePath, serverId: route.serverId }];
+          }
+          if (diagnostics.diagnostics.length === 0) {
+            return [{ kind: "no_diagnostics", path: filePath }];
+          }
+          const documentText = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(
+            await readFile(filePath),
+          );
+          const encoding = normalizeLspPositionEncoding(client.positionEncoding);
+          return diagnostics.diagnostics.map((diagnostic) =>
+            normalizedDiagnosticOutcome(
+              diagnostic,
+              route.serverId,
+              filePath,
+              documentText,
+              encoding,
+            ),
+          );
+        },
+      );
+      const successfulOutcomes = result.successes.flatMap(({ value }) => value);
+      outcomes.push(...successfulOutcomes);
+      outcomes.push(
+        ...result.failures.map((failure) => failureDiagnosticOutcome(filePath, failure)),
+      );
+    }
+    return outcomes;
+  }
+}
+
+async function appendSessionPostEditDiagnostics(
+  event: ToolResultEvent,
+  session: ActivePiLspSession,
+  context: ExtensionContext,
+): Promise<PostEditDiagnosticsResultPatch | undefined> {
+  const patch = await appendPiPostEditDiagnostics(
+    event,
+    new ManagerPostEditDiagnosticsRunner(session, context.signal),
+  );
+  if (patch === undefined) return undefined;
+  const appendedValue = patch.content.at(-1);
+  if (!Value.Check(AppendedTextContentSchema, appendedValue)) return undefined;
+  let appended: Static<typeof AppendedTextContentSchema> = appendedValue;
+  const truncation = truncateHead(appended.text, {
+    maxBytes: DEFAULT_MAX_BYTES,
+    maxLines: DEFAULT_MAX_LINES,
+  });
+  if (truncation.truncated) {
+    const spillPath = await session.sessionFiles.writeResultSpill(appended.text);
+    appended = {
+      type: "text",
+      text: `${truncation.content}\n\n[Pi LSP: diagnostics truncated; complete Result Spill: ${spillPath}]`,
+    };
+  }
+  const partialApplyFailure =
+    event.toolName === "lsp" &&
+    Value.Check(LspToolResultDetailsSchema, event.details) &&
+    event.details.kind === "workspace_edit_apply" &&
+    event.details.state === "partial_failure";
+  return {
+    ...patch,
+    content: [...event.content, appended],
+    isError: partialApplyFailure || patch.isError,
+  };
+}
+
+/** Own settings, tool registration, replay, diagnostics middleware, and resource shutdown for one extension instance. */
+export class PiLspLifecycleController {
+  private readonly pendingPostEditDiagnosticOutcomes: PostEditDiagnosticOutcome[] = [];
+  private session: ActivePiLspSession | undefined;
+  private shutdownPromise: Promise<void> | undefined;
+  private toolRegistered = false;
+
+  /** Bind one lifecycle controller to Pi and production or test construction effects. */
+  constructor(
+    private readonly pi: ExtensionAPI,
+    private readonly effects: PiLspLifecycleEffects,
+  ) {}
+
+  /** Register Pi LSP lifecycle handlers and model-invisible diagnostics entry rendering. */
+  register(): void {
+    this.pi.registerEntryRenderer(POST_EDIT_DIAGNOSTICS_ENTRY_TYPE, (entry, { expanded }, theme) =>
+      Value.Check(PostEditDiagnosticsEntryDataSchema, entry.data)
+        ? renderPostEditDiagnosticsEntry(entry.data, expanded, theme)
+        : undefined,
+    );
+    this.pi.on("session_start", (_event, context) => this.startSession(context));
+    this.pi.on("tool_result", (event, context) => this.handleToolResult(event, context));
+    this.pi.on("turn_end", () => this.flushPostEditDiagnosticsEntry());
+    this.pi.on("session_shutdown", () => this.shutdownSession());
+  }
+
+  private async startSession(context: ExtensionContext): Promise<void> {
+    await this.shutdownSession();
+    this.pendingPostEditDiagnosticOutcomes.length = 0;
+    const settingsManager = SettingsManager.create(context.cwd, this.effects.getAgentDirectory(), {
+      projectTrusted: context.isProjectTrusted(),
+    });
+    const settings = resolveLspSettings(settingsManager);
+    if (settings.warnings.length > 0) {
+      context.ui.notify(`Pi LSP settings:\n- ${settings.warnings.join("\n- ")}`, "warning");
+    }
+
+    const sessionFiles = await createLspSessionFiles(context.sessionManager.getSessionDir());
+    const workspaceEdits = new LspWorkspaceEditStore();
+    const replay = workspaceEdits.replayPreviewRecords(
+      branchLspToolResultDetails(context.sessionManager.getBranch()),
+    );
+    if (replay.rejected > 0) {
+      context.ui.notify(
+        `Pi LSP ignored ${replay.rejected} invalid Workspace Edit Preview record${replay.rejected === 1 ? "" : "s"} on the active session branch.`,
+        "warning",
+      );
+    }
+
+    const manager = new LspServerManager<LspServerClient>({
+      cwd: context.cwd,
+      settings,
+      startClient: async ({ definition, onUnavailable, rootPath, timeouts }) => {
+        let client: LspServerClient | undefined;
+        client = await LspServerClient.start({
+          serverId: definition.id,
+          rootPath,
+          command: definition.command,
+          args: definition.args,
+          environment: { ...definition.environment },
+          initializationOptions: definition.initializationOptions ?? null,
+          settings: definition.settings ?? null,
+          timeouts,
+          stderrPath: await sessionFiles.getServerStderrPath(`${definition.id}\u0000${rootPath}`),
+          onUnavailable,
+          onWorkspaceEdit: async (edit) =>
+            (
+              await workspaceEdits.createPreview({
+                edit,
+                serverId: definition.id,
+                positionEncoding: client?.positionEncoding ?? PositionEncodingKind.UTF16,
+              })
+            ).preview_id,
+        });
+        return client;
+      },
+    });
+    this.session = { cwd: context.cwd, manager, sessionFiles };
+
+    if (!this.toolRegistered) {
+      registerLspTool(this.pi, { manager, workspaceEdits, sessionFiles });
+      this.toolRegistered = true;
+    }
+  }
+
+  private handleToolResult(
+    event: ToolResultEvent,
+    context: ExtensionContext,
+  ):
+    | Promise<
+        | {
+            readonly content: ToolResultEvent["content"];
+            readonly details: ToolResultEvent["details"];
+            readonly isError: boolean;
+          }
+        | undefined
+      >
+    | undefined {
+    const session = this.session;
+    if (session === undefined) return undefined;
+    return appendSessionPostEditDiagnostics(event, session, context).then((patch) => {
+      if (patch === undefined) return undefined;
+      this.pendingPostEditDiagnosticOutcomes.push(...patch.outcomes);
+      return { content: patch.content, details: patch.details, isError: patch.isError };
+    });
+  }
+
+  private flushPostEditDiagnosticsEntry(): void {
+    const session = this.session;
+    const outcomes = this.pendingPostEditDiagnosticOutcomes.splice(0);
+    if (session === undefined) return;
+    const entry = createPostEditDiagnosticsEntryData(session.cwd, outcomes);
+    if (entry !== undefined) this.pi.appendEntry(POST_EDIT_DIAGNOSTICS_ENTRY_TYPE, entry);
+  }
+
+  private async shutdownSession(): Promise<void> {
+    if (this.session === undefined) {
+      await this.shutdownPromise;
+      return;
+    }
+    const session = this.session;
+    this.session = undefined;
+    this.pendingPostEditDiagnosticOutcomes.length = 0;
+    const shutdown = (async () => {
+      try {
+        await session.manager.shutdown();
+      } finally {
+        await session.sessionFiles.close();
+      }
+    })();
+    this.shutdownPromise = shutdown;
+    try {
+      await shutdown;
+    } finally {
+      if (this.shutdownPromise === shutdown) this.shutdownPromise = undefined;
+    }
+  }
+}
+
+/** Compose the source-TypeScript Pi LSP extension without starting a language server at load time. */
+export function createPiLspExtension(
+  effects: PiLspLifecycleEffects = productionPiLspLifecycleEffects,
+): ExtensionFactory {
+  return (pi) => new PiLspLifecycleController(pi, effects).register();
+}
+
+const piLspExtension = createPiLspExtension();
+
+export default piLspExtension;

package/src/pi-lsp-settings.ts

@@ -0,0 +1,263 @@
+import type { SettingsManager } from "@earendil-works/pi-coding-agent";
+import { type Static, Type } from "typebox";
+import { Value } from "typebox/value";
+
+const DEFAULT_LSP_TIMEOUTS = {
+  diagnosticsMs: 3000,
+  initializeMs: 45000,
+  requestMs: 3000,
+  shutdownMs: 5000,
+} as const;
+
+const NonEmptyStringSchema = Type.String({ minLength: 1 });
+const PositiveMillisecondsSchema = Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER });
+const JsonValueSchema = Type.Any();
+const LspLanguageMappingSchema = Type.Object(
+  {
+    extensions: Type.Optional(Type.Array(NonEmptyStringSchema, { minItems: 1 })),
+    fileNames: Type.Optional(Type.Array(NonEmptyStringSchema, { minItems: 1 })),
+    languageId: NonEmptyStringSchema,
+  },
+  { additionalProperties: false },
+);
+const LspServerDefinitionSchema = Type.Object(
+  {
+    args: Type.Optional(Type.Array(Type.String())),
+    command: Type.Optional(NonEmptyStringSchema),
+    environment: Type.Optional(
+      Type.Record(Type.String(), Type.Union([Type.String(), Type.Null()])),
+    ),
+    initializationOptions: Type.Optional(JsonValueSchema),
+    languages: Type.Optional(Type.Array(LspLanguageMappingSchema, { minItems: 1 })),
+    rootMarkers: Type.Optional(Type.Array(NonEmptyStringSchema)),
+    settings: Type.Optional(JsonValueSchema),
+  },
+  { additionalProperties: false },
+);
+const LspTimeoutsSchema = Type.Object(
+  {
+    diagnosticsMs: Type.Optional(PositiveMillisecondsSchema),
+    initializeMs: Type.Optional(PositiveMillisecondsSchema),
+    requestMs: Type.Optional(PositiveMillisecondsSchema),
+    shutdownMs: Type.Optional(PositiveMillisecondsSchema),
+  },
+  { additionalProperties: false },
+);
+const LspLayerSchema = Type.Object(
+  {
+    servers: Type.Optional(
+      Type.Record(
+        Type.String({ minLength: 1 }),
+        Type.Union([LspServerDefinitionSchema, Type.Null()]),
+      ),
+    ),
+    timeouts: Type.Optional(LspTimeoutsSchema),
+  },
+  { additionalProperties: false },
+);
+const SettingsDocumentSchema = Type.Object({ lsp: Type.Optional(JsonValueSchema) });
+
+interface JsonObject {
+  readonly [key: string]: JsonValue;
+}
+
+type JsonValue = null | boolean | number | string | readonly JsonValue[] | JsonObject;
+type LspServerDefinitionWire = Static<typeof LspServerDefinitionSchema>;
+type LspTimeoutsWire = Static<typeof LspTimeoutsSchema>;
+type LspLayerWire = Static<typeof LspLayerSchema>;
+
+/** Describes one configured filename or extension mapping to an LSP language identifier. */
+export interface LspLanguageMapping {
+  readonly extensions: readonly string[];
+  readonly fileNames: readonly string[];
+  readonly languageId: string;
+}
+
+/** Contains the parsed command and protocol values for one enabled language server. */
+export interface LspServerDefinition {
+  readonly args: readonly string[];
+  readonly command: string;
+  readonly environment: Readonly<Record<string, string>>;
+  readonly id: string;
+  readonly initializationOptions?: JsonValue;
+  readonly languages: readonly LspLanguageMapping[];
+  readonly rootMarkers: readonly string[];
+  readonly settings?: JsonValue;
+}
+
+/** Contains bounded timeout values used for all requests made to an LSP server. */
+export interface LspTimeouts {
+  readonly diagnosticsMs: number;
+  readonly initializeMs: number;
+  readonly requestMs: number;
+  readonly shutdownMs: number;
+}
+
+/** Reports resolved trusted configuration, or disabled startup when either layer is malformed. */
+export interface ResolvedLspSettings {
+  readonly enabled: boolean;
+  readonly servers: ReadonlyMap<string, LspServerDefinition>;
+  readonly timeouts: LspTimeouts;
+  readonly warnings: readonly string[];
+}
+
+/** Reads Pi's already trust-filtered global and project settings documents. */
+export interface LspSettingsReader {
+  getGlobalSettings(): LspSettingsDocumentInput;
+  getProjectSettings(): LspSettingsDocumentInput;
+}
+
+/** Minimal Pi settings document shape containing the extension-owned optional `lsp` value. */
+type PiSettingsDocument = ReturnType<SettingsManager["getGlobalSettings"]>;
+
+/** Pi's core Settings type or a test/boundary document carrying the extension-owned `lsp` value. */
+export type LspSettingsDocumentInput = PiSettingsDocument | { readonly lsp?: JsonValue };
+
+type ParsedLspLayer =
+  | { readonly kind: "absent" }
+  | { readonly kind: "invalid"; readonly warning: string }
+  | { readonly kind: "valid"; readonly value: LspLayerWire };
+
+function lspValidationWarning(value: JsonValue, scope: "global" | "project"): string {
+  const error = Value.Errors(LspLayerSchema, value)[0];
+  const path = error?.instancePath.replaceAll("/", ".") ?? "";
+  const unknownField =
+    error?.keyword === "additionalProperties" ? error.params.additionalProperties[0] : undefined;
+  return `${scope} lsp${path}${unknownField === undefined ? "" : `.${unknownField}`}: ${error?.message ?? "invalid settings"}`;
+}
+
+function readLspLayer(
+  settings: LspSettingsDocumentInput,
+  scope: "global" | "project",
+): ParsedLspLayer {
+  if (!Value.Check(SettingsDocumentSchema, settings)) {
+    return { kind: "invalid", warning: `${scope} settings: expected a JSON object` };
+  }
+  if (settings.lsp === undefined) return { kind: "absent" };
+  if (!Value.Check(LspLayerSchema, settings.lsp)) {
+    return { kind: "invalid", warning: lspValidationWarning(settings.lsp, scope) };
+  }
+  for (const [serverId, server] of Object.entries(settings.lsp.servers ?? {})) {
+    if (server === null) continue;
+    if (server.command === undefined || server.languages === undefined) {
+      return {
+        kind: "invalid",
+        warning: `${scope} lsp.servers.${serverId}: command and languages are required`,
+      };
+    }
+    if (
+      server.languages.some(
+        (language) => language.extensions === undefined && language.fileNames === undefined,
+      )
+    ) {
+      return {
+        kind: "invalid",
+        warning: `${scope} lsp.servers.${serverId}.languages: each language needs extensions or fileNames`,
+      };
+    }
+  }
+  return { kind: "valid", value: settings.lsp };
+}
+
+function mergeLspTimeouts(globalLayer: ParsedLspLayer, projectLayer: ParsedLspLayer): LspTimeouts {
+  const timeoutValues: readonly (LspTimeoutsWire | undefined)[] = [
+    globalLayer.kind === "valid" ? globalLayer.value.timeouts : undefined,
+    projectLayer.kind === "valid" ? projectLayer.value.timeouts : undefined,
+  ];
+  return Object.assign({}, DEFAULT_LSP_TIMEOUTS, ...timeoutValues);
+}
+
+function resolveLspEnvironment(
+  configuredEnvironment: Readonly<Record<string, string | null>> | undefined,
+) {
+  const environment: Record<string, string> = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== undefined) environment[key] = value;
+  }
+  for (const [key, value] of Object.entries(configuredEnvironment ?? {})) {
+    if (value === null) {
+      delete environment[key];
+    } else {
+      environment[key] = value;
+    }
+  }
+  return environment;
+}
+
+function resolveLspServerDefinition(
+  id: string,
+  server: LspServerDefinitionWire,
+): LspServerDefinition {
+  const languages: LspLanguageMapping[] = (server.languages ?? []).map((language) => ({
+    extensions: language.extensions ?? [],
+    fileNames: language.fileNames ?? [],
+    languageId: language.languageId,
+  }));
+  const resolved = {
+    args: server.args ?? [],
+    command: server.command ?? "",
+    environment: resolveLspEnvironment(server.environment),
+    id,
+    languages,
+    rootMarkers: server.rootMarkers ?? [],
+  };
+  const initializationOptions = server.initializationOptions;
+  const settings = server.settings;
+  if (initializationOptions !== undefined && settings !== undefined) {
+    return {
+      ...resolved,
+      initializationOptions: structuredClone(initializationOptions),
+      settings: structuredClone(settings),
+    };
+  }
+  if (initializationOptions !== undefined) {
+    return { ...resolved, initializationOptions: structuredClone(initializationOptions) };
+  }
+  if (settings !== undefined) {
+    return { ...resolved, settings: structuredClone(settings) };
+  }
+  return resolved;
+}
+
+function mergeLspServers(
+  globalLayer: ParsedLspLayer,
+  projectLayer: ParsedLspLayer,
+): ReadonlyMap<string, LspServerDefinition> {
+  const serverDefinitions = new Map<string, LspServerDefinitionWire>();
+  const addServers = (layer: ParsedLspLayer, projectLayerValue: boolean): void => {
+    if (layer.kind !== "valid") return;
+    for (const [id, server] of Object.entries(layer.value.servers ?? {})) {
+      if (server === null) {
+        if (projectLayerValue) serverDefinitions.delete(id);
+        continue;
+      }
+      serverDefinitions.set(id, server);
+    }
+  };
+  addServers(globalLayer, false);
+  addServers(projectLayer, true);
+  return new Map(
+    [...serverDefinitions]
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([id, server]) => [id, resolveLspServerDefinition(id, server)]),
+  );
+}
+
+/** Resolve global and trusted-project LSP settings without adding an `lsp` field to Pi's Settings type. */
+export function resolveLspSettings(reader: LspSettingsReader): ResolvedLspSettings {
+  const globalLayer = readLspLayer(reader.getGlobalSettings(), "global");
+  const projectLayer = readLspLayer(reader.getProjectSettings(), "project");
+  const warnings = [globalLayer, projectLayer]
+    .filter(
+      (layer): layer is Extract<ParsedLspLayer, { readonly kind: "invalid" }> =>
+        layer.kind === "invalid",
+    )
+    .map((layer) => layer.warning);
+  const enabled = warnings.length === 0;
+  return {
+    enabled,
+    servers: enabled ? mergeLspServers(globalLayer, projectLayer) : new Map(),
+    timeouts: mergeLspTimeouts(globalLayer, projectLayer),
+    warnings,
+  };
+}