@mrclrchtr/supi-code-intelligence 6.1.0 → 6.3.0

package/node_modules/@mrclrchtr/supi-lsp/node_modules/ignore/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ignore",
-  "version": "7.0.6",
+  "version": "7.0.8",
   "description": "Ignore is a manager and filter for .gitignore rules, the one used by eslint, gitbook and many others.",
   "types": "index.d.ts",
   "files": [
@@ -25,9 +25,15 @@
     "test:mjs:16": "ts-node --compilerOptions '{\"moduleResolution\": \"Node16\", \"module\": \"Node16\"}' ./test/import/simple.mjs && babel -o ./test/import/simple-mjs.js ./test/import/simple.mjs && node ./test/import/simple-mjs.js",
 
     "===================== cases =======================": "",
-    "test:cases": "npm run tap test/*.test.js -- --coverage",
+    "test:cases": "npm run tap test/*.test.js -- --coverage --100",
     "tap": "tap --reporter classic",
 
+    "=================== benchmark =====================": "",
+    "benchmark": "node benchmark",
+
+    "==================== compat =======================": "",
+    "compat": "node compat && node compat --win32",
+
     "===================== debug =======================": "",
     "test:git": "npm run tap test/git-check-ignore.test.js",
     "test:ignore": "npm run tap test/ignore.test.js",
@@ -35,13 +41,13 @@
     "test:others": "npm run tap test/others.test.js",
     "test:no-coverage": "npm run tap test/*.test.js -- --no-check-coverage",
 
-    "test": "npm run lint && npm run ts && npm run build && npm run test:cases",
+    "test": "npm run lint && npm run ts && npm run build && npm run test:cases && npm run compat",
     "test:win32": "IGNORE_TEST_WIN32=1 npm run test",
     "report": "tap --coverage-report=html"
   },
   "repository": {
     "type": "git",
-    "url": "git@github.com:kaelzhang/node-ignore.git"
+    "url": "https://github.com/kaelzhang/node-ignore.git"
   },
   "keywords": [
     "ignore",

package/node_modules/@mrclrchtr/supi-lsp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "6.1.0",
+  "version": "6.3.0",
   "description": "Language Server Protocol runtime for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -37,8 +37,8 @@
     "vscode-jsonrpc": "^9.0.0",
     "vscode-languageserver-protocol": "^3.18.0",
     "vscode-languageserver-types": "^3.18.0",
-    "@mrclrchtr/supi-code-runtime": "6.1.0",
-    "@mrclrchtr/supi-core": "6.1.0"
+    "@mrclrchtr/supi-code-runtime": "6.3.0",
+    "@mrclrchtr/supi-core": "6.3.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",
@@ -53,7 +53,6 @@
   "exports": {
     "./api": "./src/api.ts",
     "./package.json": "./package.json",
-    "./provider/lsp-semantic-provider": "./src/provider/lsp-semantic-provider.ts",
-    "./debug-telemetry": "./src/debug-telemetry.ts"
+    "./provider/lsp-semantic-provider": "./src/provider/lsp-semantic-provider.ts"
   }
 }

package/node_modules/@mrclrchtr/supi-lsp/src/api.ts

@@ -1,13 +1,8 @@
 // Public API surface for the LSP session-scoped service.
 
 export { type LoadConfigOptions, loadConfig } from "./config/config.ts";
-export type { DeprecatedLspKeys, LspSettings } from "./config/lsp-settings.ts";
-export {
-  getDeprecatedLspKeys,
-  getLspDisabledMessage,
-  hasDeprecatedLspKeys,
-  loadLspSettings,
-} from "./config/lsp-settings.ts";
+export type { LspSettings } from "./config/lsp-settings.ts";
+export { loadLspSettings } from "./config/lsp-settings.ts";
 export {
   clearTsconfigCache,
   type FileScopeDecision,
@@ -43,6 +38,8 @@ export { isLikelyStaleDiagnostic } from "./diagnostics/stale-diagnostics.ts";
 export {
   scanWorkspaceSentinels,
   syncWorkspaceSentinelSnapshot,
+  type WorkspaceSentinelScanOptions,
+  type WorkspaceSentinelSyncResult,
 } from "./diagnostics/workspace-sentinels.ts";
 export { raceReadinessValue, raceRequestControl } from "./session/readiness.ts";
 export type {
@@ -59,6 +56,10 @@ export type {
   DiagnosticEvidenceSummary,
   OutstandingDiagnosticSummaryEntry,
   ProcessCrashDiagnosticDemand,
+  ProcessCrashRecoveryEntry,
+  ProcessCrashRecoveryNextAction,
+  ProcessCrashRecoveryOutcome,
+  ProcessCrashRecoveryReport,
   RecoverDiagnosticsResult,
   RoutedMutationResponse,
   SemanticReadinessResult,
@@ -71,8 +72,16 @@ export type {
 } from "./session/runtime-registry.ts";
 export {
   clearWorkspaceLspRuntime,
+  emptyProcessCrashRecoveryReport,
   getWorkspaceLspRuntime,
+  MAX_PROCESS_CRASH_RECOVERY_ENTRIES,
   setWorkspaceLspRuntimeState,
   waitForWorkspaceLspRuntime,
 } from "./session/runtime-registry.ts";
 export { scanMissingServers } from "./session/scanner.ts";
+export {
+  AUTOMATIC_LSP_EXCLUDED_DIRECTORIES,
+  type AutomaticLspPathPolicy,
+  createAutomaticLspPathPolicy,
+  createDefaultAutomaticLspPathPolicy,
+} from "./workspace-path-policy.ts";

package/node_modules/@mrclrchtr/supi-lsp/src/client/client-diagnostic-cache.ts

@@ -1,5 +1,5 @@
+import { uriToFile } from "@mrclrchtr/supi-core/path";
 import type { PublishDiagnosticsParams } from "../config/types.ts";
-import { uriToFile } from "../utils.ts";
 import {
   type DiagnosticCacheEntry,
   isTentativePushEntry,

package/node_modules/@mrclrchtr/supi-lsp/src/client/client-diagnostic-capabilities.ts

@@ -66,11 +66,6 @@ export class ClientDynamicRegistrations {
     return (this.idsByMethod.get(method)?.size ?? 0) > 0;
   }
 
-  /** Snapshot of the active registration ids for a method. */
-  ids(method: string): readonly string[] {
-    return [...(this.idsByMethod.get(method) ?? [])];
-  }
-
   /** Drop all registrations — capability loss on shutdown, crash, or disposal. */
   clear(): void {
     this.idsByMethod.clear();

package/node_modules/@mrclrchtr/supi-lsp/src/client/client-diagnostic-publication.ts

@@ -9,9 +9,12 @@
 // and timing data. They never carry diagnostic payloads or source text.
 
 import * as path from "node:path";
-import { recordDebugEvent } from "@mrclrchtr/supi-core/debug";
-import { boundCwd, truncateIdentity } from "../debug-telemetry.ts";
-import { uriToFile } from "../utils.ts";
+import {
+  recordDebugEvent,
+  truncateDebugIdentity as truncateIdentity,
+} from "@mrclrchtr/supi-core/debug";
+import { uriToFile } from "@mrclrchtr/supi-core/path";
+import { boundCwd } from "../debug-telemetry.ts";
 
 /** Maximum tracked synchronizations before the oldest entry is evicted. */
 export const MAX_TRACKED_SYNCHRONIZATIONS = 64;

package/node_modules/@mrclrchtr/supi-lsp/src/client/client-diagnostic-refresh.ts

@@ -5,12 +5,13 @@ import {
   isCodeRequestInterruption,
   throwIfCodeRequestInterrupted,
 } from "@mrclrchtr/supi-code-runtime/api";
+import { fileToUri, uriToFile } from "@mrclrchtr/supi-core/path";
 import type { TextDocumentIdentifier } from "../config/types.ts";
 import {
   type DiagnosticEvidenceSummary,
   summarizeDiagnosticEvidence,
 } from "../diagnostics/evidence.ts";
-import { detectLanguageId, fileToUri, uriToFile } from "../utils.ts";
+import { detectLanguageId } from "../utils.ts";
 import {
   type DiagnosticCacheEntry,
   type DiagnosticSynchronization,

package/node_modules/@mrclrchtr/supi-lsp/src/client/client-diagnostic-timing.ts

@@ -1,6 +1,9 @@
 import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
-import { startDebugTimer } from "@mrclrchtr/supi-core/debug";
-import { boundCwd, truncateIdentity } from "../debug-telemetry.ts";
+import {
+  startDebugTimer,
+  truncateDebugIdentity as truncateIdentity,
+} from "@mrclrchtr/supi-core/debug";
+import { boundCwd } from "../debug-telemetry.ts";
 
 type DiagnosticCollection = "cache" | "fallback" | "none" | "pull" | "push";
 type DiagnosticFreshness = "not-observed" | "observed";

package/node_modules/@mrclrchtr/supi-lsp/src/client/client-diagnostics.ts

@@ -7,9 +7,10 @@ import {
   throwIfCodeRequestInterrupted,
   unavailableCodeQuery,
 } from "@mrclrchtr/supi-code-runtime/api";
+import { fileToUri, uriToFile } from "@mrclrchtr/supi-core/path";
 import type { Diagnostic, TextDocumentItem } from "../config/types.ts";
 import type { DiagnosticEvidenceSummary } from "../diagnostics/evidence.ts";
-import { detectLanguageId, fileToUri, uriToFile } from "../utils.ts";
+import { detectLanguageId } from "../utils.ts";
 import { applyPushDiagnostics, buildClientDiagnosticSnapshot } from "./client-diagnostic-cache.ts";
 import { collectSynchronizedFileDiagnostics } from "./client-diagnostic-collection.ts";
 import {

package/node_modules/@mrclrchtr/supi-lsp/src/client/client.ts

@@ -12,7 +12,11 @@ import {
   throwIfCodeRequestInterrupted,
   unavailableCodeQuery,
 } from "@mrclrchtr/supi-code-runtime/api";
-import { recordDebugEvent } from "@mrclrchtr/supi-core/debug";
+import {
+  recordDebugEvent,
+  truncateDebugIdentity as truncateIdentity,
+} from "@mrclrchtr/supi-core/debug";
+import { fileToUri } from "@mrclrchtr/supi-core/path";
 import { type ProgressToken, TextDocumentSyncKind } from "vscode-languageserver-protocol";
 import { CLIENT_CAPABILITIES } from "../config/capabilities.ts";
 import type {
@@ -35,10 +39,9 @@ import type {
   WorkspaceEdit,
   WorkspaceSymbol,
 } from "../config/types.ts";
-import { boundCwd, truncateIdentity } from "../debug-telemetry.ts";
+import { boundCwd } from "../debug-telemetry.ts";
 import type { DiagnosticEvidenceSummary } from "../diagnostics/evidence.ts";
 import { raceRequestControl } from "../session/readiness.ts";
-import { fileToUri } from "../utils.ts";
 import {
   ClientDynamicRegistrations,
   DOCUMENT_DIAGNOSTIC_METHOD,
@@ -141,6 +144,15 @@ function killProcessTree(pid: number): void {
   }
 }
 
+/** Terminate a failed startup without leaving server descendants running. */
+function killFailedStartupProcess(child: ChildProcess): void {
+  if (child.pid) {
+    killProcessTree(child.pid);
+    return;
+  }
+  child.kill();
+}
+
 // ── Types ─────────────────────────────────────────────────────────────
 export type ClientStatus = "initializing" | "running" | "error" | "shutdown";
 
@@ -285,7 +297,7 @@ export class LspClient {
     if (!this.process.stdin || !this.process.stdout) {
       const failure = new Error(`${cmd}: missing stdin/stdout`);
       this.handleProcessFailure(failure);
-      this.process.kill();
+      killFailedStartupProcess(this.process);
       throw failure;
     }
 
@@ -350,7 +362,7 @@ export class LspClient {
     } catch (err) {
       const failure = new Error(`${this.name}: initialize failed: ${err}`, { cause: err });
       this.handleProcessFailure(failure);
-      this.process.kill();
+      killFailedStartupProcess(this.process);
       throw failure;
     }
   }

package/node_modules/@mrclrchtr/supi-lsp/src/client/transport.ts

@@ -7,7 +7,10 @@ import {
   type CodeRequestControl,
   CodeRequestDeadlineError,
 } from "@mrclrchtr/supi-code-runtime/api";
-import { startDebugTimer } from "@mrclrchtr/supi-core/debug";
+import {
+  startDebugTimer,
+  truncateDebugIdentity as truncateIdentity,
+} from "@mrclrchtr/supi-core/debug";
 import {
   CancellationTokenSource,
   createMessageConnection,
@@ -18,7 +21,7 @@ import {
   StreamMessageReader,
   StreamMessageWriter,
 } from "vscode-jsonrpc/node";
-import { boundCwd, LSP_REQUEST_TIMEOUT_ERROR_CODE, truncateIdentity } from "../debug-telemetry.ts";
+import { boundCwd, LSP_REQUEST_TIMEOUT_ERROR_CODE } from "../debug-telemetry.ts";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
 
@@ -112,34 +115,40 @@ export class JsonRpcClient {
     const methodClass = classifyRequestMethod(method);
     const boundedMethod = truncateIdentity(method);
     const timer = startDebugTimer();
+    // A request cancelled before dispatch must not produce protocol traffic.
+    if (signal?.aborted) {
+      return rejectUndispatchedRequest(
+        signal.reason ?? new Error(`Request ${method} was cancelled`),
+        {
+          timer,
+          operationId: options?.operationId,
+          observation: { method: boundedMethod, methodClass, outcome: "cancelled" },
+          identity: { server: this.server, cwd: this.cwd },
+        },
+      );
+    }
     // An expired absolute deadline must not even send the request: the caller
     // no longer awaits a result, so no protocol traffic may start.
     if (deadlineMs !== undefined && deadlineMs <= 0) {
-      recordRequestTiming(
+      return rejectUndispatchedRequest(new CodeRequestDeadlineError(), {
         timer,
-        options?.operationId,
-        {
+        operationId: options?.operationId,
+        observation: {
           method: boundedMethod,
           methodClass,
           outcome: "timed-out",
           errorCode: LSP_REQUEST_TIMEOUT_ERROR_CODE,
         },
-        { server: this.server, cwd: this.cwd },
-      );
-      return Promise.reject(new CodeRequestDeadlineError());
+        identity: { server: this.server, cwd: this.cwd },
+      });
     }
     if (this.closed || !this.connection) {
-      recordRequestTiming(
+      return rejectUndispatchedRequest(new Error("JSON-RPC client is closed"), {
         timer,
-        options?.operationId,
-        {
-          method: boundedMethod,
-          methodClass,
-          outcome: "cancelled",
-        },
-        { server: this.server, cwd: this.cwd },
-      );
-      return Promise.reject(new Error("JSON-RPC client is closed"));
+        operationId: options?.operationId,
+        observation: { method: boundedMethod, methodClass, outcome: "cancelled" },
+        identity: { server: this.server, cwd: this.cwd },
+      });
     }
     const tokenSource = new CancellationTokenSource();
     let timeout: ReturnType<typeof setTimeout> | undefined;
@@ -344,6 +353,19 @@ function jsonRpcErrorCode(error: unknown): number | undefined {
   return typeof code === "number" && Number.isInteger(code) ? code : undefined;
 }
 
+function rejectUndispatchedRequest(
+  error: unknown,
+  timing: {
+    timer: ReturnType<typeof startDebugTimer>;
+    operationId: string | undefined;
+    observation: RequestTimingObservation;
+    identity: { server?: string; cwd?: string };
+  },
+): Promise<never> {
+  recordRequestTiming(timing.timer, timing.operationId, timing.observation, timing.identity);
+  return Promise.reject(error);
+}
+
 function recordRequestTiming(
   timer: ReturnType<typeof startDebugTimer>,
   operationId: string | undefined,

package/node_modules/@mrclrchtr/supi-lsp/src/config/config.ts

@@ -4,6 +4,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadSupiConfigForScope } from "@mrclrchtr/supi-core/config";
+import { truncateDebugIdentity } from "@mrclrchtr/supi-core/debug";
 import type { LspConfig, ServerConfig } from "./types.ts";
 
 const CONFIG_DIR = path.dirname(fileURLToPath(import.meta.url));
@@ -24,17 +25,16 @@ export const LANGUAGE_ALIASES: Record<string, string> = {
   cpp: "c",
 };
 
-/** Resolve a language name through aliases. */
-export function resolveLanguageAlias(name: string): string {
-  return LANGUAGE_ALIASES[name] ?? name;
-}
-
-function resolveAliasesInOverrides(servers: Record<string, Partial<ServerConfig>>): void {
+function resolveAliasesInOverrides(servers: Record<string, unknown>): void {
   for (const [alias, target] of Object.entries(LANGUAGE_ALIASES)) {
-    if (servers[alias]) {
-      servers[target] = { ...(servers[target] ?? {}), ...servers[alias] };
-      delete servers[alias];
-    }
+    if (!Object.hasOwn(servers, alias)) continue;
+    const aliasOverride = servers[alias];
+    const targetOverride = servers[target];
+    servers[target] =
+      isRecord(aliasOverride) && isRecord(targetOverride)
+        ? { ...targetOverride, ...aliasOverride }
+        : aliasOverride;
+    delete servers[alias];
   }
 }
 
@@ -49,13 +49,13 @@ export function loadConfig(cwd: string, options?: LoadConfigOptions): LspConfig
   const globalLsp = loadSupiConfigForScope(
     "lsp",
     cwd,
-    { enabled: true, active: [], servers: {} as Record<string, ServerConfig> },
+    { servers: {} as Record<string, ServerConfig> },
     { scope: "global", homeDir: options?.homeDir },
   );
   const projectLsp = loadSupiConfigForScope(
     "lsp",
     cwd,
-    { enabled: true, active: [], servers: {} as Record<string, ServerConfig> },
+    { servers: {} as Record<string, ServerConfig> },
     { scope: "project" },
   );
 
@@ -91,6 +91,13 @@ function mergeServerConfigs(
   projectOverrides: unknown,
 ): Record<string, ServerConfig> {
   const merged: Record<string, ServerConfig> = { ...defaults };
+  const warnings = new Map<string, { fields: Set<string>; skipped: boolean }>();
+  const reportWarning: ServerConfigWarningReporter = (name, fields, skipped) => {
+    const warning = warnings.get(name) ?? { fields: new Set<string>(), skipped: false };
+    for (const field of fields) warning.fields.add(field);
+    warning.skipped ||= skipped;
+    warnings.set(name, warning);
+  };
 
   const globalServers = isServerRecord(globalOverrides) ? globalOverrides : {};
   const projectServers = isServerRecord(projectOverrides) ? projectOverrides : {};
@@ -100,14 +107,29 @@ function mergeServerConfigs(
 
   // Apply global per-key overrides against defaults
   for (const [lang, override] of Object.entries(globalServers)) {
-    const result = mergeSingleServer(defaults[lang], override);
+    const builtIn = defaults[lang] !== undefined;
+    const result = mergeSingleServer({
+      name: lang,
+      base: defaults[lang],
+      value: override,
+      builtIn,
+      reportWarning,
+    });
     if (result) merged[lang] = result;
   }
 
   // Apply project per-key overrides against the result so far
   for (const [lang, override] of Object.entries(projectServers)) {
-    const result = mergeSingleServer(merged[lang] ?? defaults[lang], override);
+    const builtIn = defaults[lang] !== undefined;
+    const result = mergeSingleServer({
+      name: lang,
+      base: merged[lang] ?? defaults[lang],
+      value: override,
+      builtIn,
+      reportWarning,
+    });
     if (result) merged[lang] = result;
+    else if (!builtIn) delete merged[lang];
   }
 
   // Remove servers whose final merged config has enabled === false
@@ -117,29 +139,141 @@ function mergeServerConfigs(
     }
   }
 
+  for (const [name, warning] of warnings) {
+    warnInvalidServerConfig(name, [...warning.fields], warning.skipped);
+  }
   return merged;
 }
 
-function mergeSingleServer(
-  base: ServerConfig | undefined,
-  override: Partial<ServerConfig>,
-): ServerConfig | null {
-  if (!base) {
-    // A custom server needs a command and at least one file extension.
-    if (
-      typeof override.command === "string" &&
-      override.command.length > 0 &&
-      Array.isArray(override.fileTypes) &&
-      override.fileTypes.length > 0 &&
-      (override.rootMarkers === undefined || Array.isArray(override.rootMarkers))
-    ) {
-      return { ...override, rootMarkers: override.rootMarkers ?? [] } as ServerConfig;
-    }
+type ServerConfigWarningReporter = (
+  name: string,
+  fields: readonly string[],
+  skipped: boolean,
+) => void;
+
+function mergeSingleServer(options: {
+  name: string;
+  base: ServerConfig | undefined;
+  value: unknown;
+  builtIn: boolean;
+  reportWarning: ServerConfigWarningReporter;
+}): ServerConfig | null {
+  const { name, base, value, builtIn, reportWarning } = options;
+  const { override, invalidFields } = validateServerOverride(value);
+  const missingFields = base
+    ? []
+    : [
+        ...(typeof override.command === "string" ? [] : ["command"]),
+        ...(override.fileTypes && override.fileTypes.length > 0 ? [] : ["fileTypes"]),
+      ];
+  const issues = [...new Set([...invalidFields, ...missingFields])];
+  if ((!builtIn && invalidFields.length > 0) || (!base && issues.length > 0)) {
+    reportWarning(name, issues, true);
     return null;
   }
+  if (!base) {
+    return {
+      ...override,
+      command: override.command as string,
+      fileTypes: override.fileTypes as string[],
+      rootMarkers: override.rootMarkers ?? [],
+    };
+  }
+
+  if (invalidFields.length > 0) reportWarning(name, invalidFields, false);
   return { ...base, ...override };
 }
 
-function isServerRecord(value: unknown): value is Record<string, Partial<ServerConfig>> {
+type ServerOverrideSetter = (override: Partial<ServerConfig>, candidate: unknown) => boolean;
+
+const SERVER_OVERRIDE_SETTERS: Record<string, ServerOverrideSetter> = {
+  command(override, candidate) {
+    if (typeof candidate !== "string" || candidate.trim().length === 0) return false;
+    override.command = candidate;
+    return true;
+  },
+  args(override, candidate) {
+    if (!isStringArray(candidate)) return false;
+    override.args = candidate;
+    return true;
+  },
+  fileTypes(override, candidate) {
+    if (!isNonEmptyStringArray(candidate)) return false;
+    override.fileTypes = candidate;
+    return true;
+  },
+  rootMarkers(override, candidate) {
+    if (!isStringArray(candidate)) return false;
+    override.rootMarkers = candidate;
+    return true;
+  },
+  enabled(override, candidate) {
+    if (typeof candidate !== "boolean") return false;
+    override.enabled = candidate;
+    return true;
+  },
+  env(override, candidate) {
+    if (!isStringRecord(candidate)) return false;
+    override.env = candidate;
+    return true;
+  },
+  initializationOptions(override, candidate) {
+    override.initializationOptions = candidate;
+    return true;
+  },
+  readinessTimeoutMs(override, candidate) {
+    if (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate <= 0) {
+      return false;
+    }
+    override.readinessTimeoutMs = candidate;
+    return true;
+  },
+};
+
+function validateServerOverride(value: unknown): {
+  override: Partial<ServerConfig>;
+  invalidFields: string[];
+} {
+  if (!isRecord(value)) return { override: {}, invalidFields: ["definition"] };
+  const override: Partial<ServerConfig> = {};
+  const invalidFields: string[] = [];
+
+  for (const [field, candidate] of Object.entries(value)) {
+    const setter = SERVER_OVERRIDE_SETTERS[field];
+    if (!setter?.(override, candidate)) invalidFields.push(field);
+  }
+
+  return { override, invalidFields };
+}
+
+function isStringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+
+function isNonEmptyStringArray(value: unknown): value is string[] {
+  return (
+    Array.isArray(value) &&
+    value.length > 0 &&
+    value.every((entry) => typeof entry === "string" && entry.length > 0)
+  );
+}
+
+function isStringRecord(value: unknown): value is Record<string, string> {
+  return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+
+function warnInvalidServerConfig(name: string, fields: readonly string[], skipped: boolean): void {
+  const boundedName = truncateDebugIdentity(name);
+  const boundedFields = truncateDebugIdentity(fields.join(", "));
+  const action = skipped ? "Skipped invalid" : "Ignored invalid fields in";
+  // biome-ignore lint/suspicious/noConsole: malformed user configuration must be visible.
+  console.warn(`[supi-lsp] ${action} LSP server configuration "${boundedName}": ${boundedFields}`);
+}
+
+function isServerRecord(value: unknown): value is Record<string, unknown> {
+  return isRecord(value);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }