@markuplint/language-server 0.0.0-stage → 5.1.0

package/lib/server/get-module.js

@@ -0,0 +1,257 @@
+import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { isFatalError } from 'markuplint/suppressions';
+const require = createRequire(import.meta.url);
+/**
+ * Reads and parses a `package.json`. `require()` is not used for this because it caches the
+ * parsed object and a server process outlives installs in the working directories it serves.
+ */
+function readJsonFile(filePath) {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+}
+/**
+ * Convert a module path into a specifier that Node's ESM `import()` accepts.
+ *
+ * On Windows, raw drive-letter paths like `c:\foo` are rejected by the ESM
+ * loader (`ERR_UNSUPPORTED_ESM_URL_SCHEME: Received protocol 'c:'`) because
+ * the drive letter is parsed as a URL scheme. They must be converted to
+ * `file://` URLs first.
+ *
+ * Detection is OS-independent so that POSIX CI can exercise the Windows
+ * code path.
+ *
+ * Mirrors `packages/@markuplint/file-resolver/src/general-import.ts` —
+ * keep the two in sync when adjusting Windows-path handling. Note:
+ * file-resolver currently still relies on `pathToFileURL()` and carries
+ * the same Windows / POSIX-absolute mismatch; tracked separately as
+ * #3840 (dev / v5).
+ *
+ * @param modPath - A module specifier — typically the result of `Files.resolve`
+ *   or `require.resolve`, which may be a bare module name (`markuplint`), a
+ *   relative path (`./foo`), or an absolute path (Windows or POSIX).
+ * @returns A specifier safe to pass to `import()`. Absolute paths are converted
+ *   to `file://` URLs with each segment percent-encoded; bare and relative
+ *   specifiers are returned unchanged. UNC paths (`\\server\share\...`) are
+ *   passed through unchanged as a known limitation.
+ * @see https://github.com/markuplint/markuplint/issues/3795
+ * @see https://github.com/markuplint/markuplint/issues/3836
+ * @see https://github.com/markuplint/markuplint/issues/3842
+ * @see https://nodejs.org/api/esm.html#urls
+ */
+export function toImportSpecifier(modPath) {
+    const isWindowsAbsolute = /^[a-z]:[/\\]/i.test(modPath);
+    const isPosixAbsolute = modPath.startsWith('/');
+    if (!isWindowsAbsolute && !isPosixAbsolute) {
+        return modPath;
+    }
+    // Build the `file://` URL explicitly for both branches. Node's
+    // `pathToFileURL()` is intentionally avoided: on Windows it resolves a
+    // POSIX-style absolute path against the *current drive* and emits
+    // `file:///D:/tmp/foo` instead of `file:///tmp/foo` (#3836); on POSIX
+    // it likewise mishandles Windows-style drive paths. Constructing the
+    // URL ourselves keeps the function OS-independent so POSIX CI exercises
+    // the Windows code path. Each segment is percent-encoded so that
+    // spaces (`Program Files`), non-ASCII characters (e.g. Japanese
+    // usernames), and URL-reserved characters like `#` / `?` do not get
+    // reinterpreted as fragment/query delimiters by Node's URL parser.
+    if (isWindowsAbsolute) {
+        // The drive-letter segment (`c:`) is kept as-is to match the
+        // `pathToFileURL` output shape on Windows (`file:///c:/...`).
+        const [drive, ...rest] = modPath.replaceAll('\\', '/').split('/');
+        const encoded = [drive, ...rest.map(segment => encodeURIComponent(segment))].join('/');
+        return `file:///${encoded}`;
+    }
+    // POSIX absolute path. Splitting `/tmp/foo` by `/` yields `['', 'tmp',
+    // 'foo']`; the leading empty element produces the `file:///` prefix
+    // after `join('/')`, so the round-trip is exactly `file:///tmp/foo`.
+    const segments = modPath.split('/').map(segment => encodeURIComponent(segment));
+    return `file://${segments.join('/')}`;
+}
+/**
+ * Resolve and load the markuplint module for a working directory.
+ *
+ * Attempts to load a markuplint installed upward from `workspace` first.
+ * If the local module fails to load (not installed, or import assertion incompatibility
+ * on Node.js 22+), falls back to the version installed with the language server.
+ *
+ * @param workspace - Absolute directory used as the resolution base
+ * @param log - Logger function for diagnostic output
+ * @param deps - Module system access; defaults to Node's own (injectable for tests)
+ * @returns The resolved module metadata including version, type, and optional fallback reason
+ */
+export async function loadModule(workspace, log, deps) {
+    const { resolveEntry, importModule, importBundledPackageJson, readPackageJson } = deps ?? nodeLoadDeps();
+    let markuplint;
+    let isLocalModule = false;
+    let pkg;
+    let fallbackReason;
+    try {
+        log(`Getting module for ${workspace}`, 'debug');
+        const modPath = resolveEntry(workspace, message => log(message));
+        log(`import("${modPath}")`, 'debug');
+        // IMPORTANT: modPath may be a Windows absolute path (c:\...).
+        // Always convert via toImportSpecifier() before passing to import() —
+        // raw drive-letter paths trigger ERR_UNSUPPORTED_ESM_URL_SCHEME.
+        markuplint = await importModule(toImportSpecifier(modPath));
+        log(`Found package: ${modPath}`, 'debug');
+        const packageJsonPath = path.resolve(path.dirname(modPath), '..', 'package.json');
+        pkg = readPackageJson(packageJsonPath);
+        pkg = pkg.default ?? pkg;
+        isLocalModule = true;
+    }
+    catch (error) {
+        // Deliberately guard-less: this is the boundary to a foreign module of unknown shape, and
+        // the fallback to the bundled copy must run whatever the local installation threw
+        // (the import assertion SyntaxError included).
+        if (isImportAssertionError(error)) {
+            log(`Local markuplint is incompatible with Node.js 22+ (import assertion syntax): ${error}`, 'warn');
+            fallbackReason = 'import-assertion-compat';
+        }
+        else {
+            log(`Failed to resolve local package: ${error}`, 'error');
+        }
+        try {
+            markuplint = await importModule('markuplint');
+            log('Found package: markuplint', 'debug');
+            pkg = await importBundledPackageJson().catch(() => {
+                log('Failed to resolve package: markuplint/package.json (ERR_PACKAGE_PATH_NOT_EXPORTED)', 'debug');
+                const ownPkg = readPackageJson(path.resolve(import.meta.dirname, '..', '..', 'package.json'));
+                return {
+                    version: ownPkg.dependencies.markuplint,
+                    type: 'module',
+                };
+            });
+            pkg = pkg.default ?? pkg;
+            log('Found package: markuplint/package.json', 'debug');
+        }
+        catch (error) {
+            log('Failed to resolve package: markuplint installed with the language server', 'debug');
+            throw error;
+        }
+    }
+    const version = pkg.version;
+    const moduleType = pkg.type ?? 'commonjs';
+    log(`Loaded package: markuplint@${version}(type:${moduleType})`, 'debug');
+    return {
+        isLocalModule,
+        version,
+        moduleType,
+        markuplint,
+        ariaRecommendedVersion: ARIA_RECOMMENDED_VERSION,
+        fallbackReason,
+        workspace,
+    };
+}
+function nodeLoadDeps() {
+    return {
+        resolveEntry: resolveWithRequire,
+        importModule: specifier => import(specifier),
+        importBundledPackageJson: () => import('markuplint/package.json', { with: { type: 'json' } }),
+        readPackageJson: readJsonFile,
+    };
+}
+/**
+ * Create a resolver that loads the markuplint module per working directory and caches it.
+ *
+ * Resolution must follow the working directory rather than the workspace root: the modules a
+ * config refers to (`parser` / `specs` / `plugins`) are imported by `@markuplint/file-resolver`
+ * relative to the loaded markuplint installation, so a parser installed only in a sub-package
+ * is reachable only when markuplint itself is loaded from that sub-package. Falling back to the
+ * bundled copy there leaves the parser unreachable and the document silently undiagnosed.
+ *
+ * `onFirstResolve` fires once per distinct directory — the place for one-shot notices such as
+ * the bundled-fallback warning — whereas callers may report per-document status freely.
+ * A failed load is not cached so the next document in that directory retries.
+ *
+ * @param options.log - Logger function for diagnostic output
+ * @param options.onFirstResolve - Called once per directory when its module is first loaded
+ * @param options.load - Module loader (injectable for tests)
+ * @returns A resolver keyed by the normalized absolute directory
+ * @see https://github.com/markuplint/markuplint/issues/4048
+ */
+export function createModuleResolver(options) {
+    const { log, onFirstResolve, load = loadModule } = options;
+    const cache = new Map();
+    return workspace => {
+        const key = path.resolve(workspace);
+        const cached = cache.get(key);
+        if (cached) {
+            return cached;
+        }
+        const loading = load(key, log);
+        cache.set(key, loading);
+        void loading.then(mod => {
+            try {
+                onFirstResolve?.(mod);
+            }
+            catch (error) {
+                if (isFatalError(error)) {
+                    throw error;
+                }
+                log(`Module notice failed for ${key}: ${error}`, 'error');
+            }
+        }, () => {
+            cache.delete(key);
+        });
+        return loading;
+    };
+}
+/**
+ * Check whether the error is a SyntaxError caused by the `assert { type: 'json' }`
+ * import assertion syntax that was removed in Node.js 22.
+ *
+ * @param error - The caught error to inspect
+ * @returns `true` if the error matches the import assertion SyntaxError pattern
+ */
+function isImportAssertionError(error) {
+    return error instanceof SyntaxError && /Unexpected identifier 'assert'/.test(error.message);
+}
+function nodeRequireDeps() {
+    return {
+        requireResolve: (name, options) => require.resolve(name, { paths: [...options.paths] }),
+        readPackageJson: readJsonFile,
+    };
+}
+/**
+ * Resolve the `markuplint` entry point with Node's CommonJS resolver, walking up from `dir`.
+ *
+ * Resolution stays in-process: `Files.resolve` from `vscode-languageserver` forks a Node process
+ * per call, which was acceptable for a single session-wide lookup but not for one lookup per
+ * working directory (every opened file's directory when `workingDirectories` is unset).
+ *
+ * `require.resolve` rejects a package whose `exports` map has no `require` condition (markuplint
+ * ships ESM only), so the entry point is then read from that `package.json` directly. The
+ * resolver functions are injectable because the server bundle is CommonJS while the test runner
+ * executes this file as ESM, where `require` is not defined.
+ *
+ * @param dir - Absolute directory to start the `node_modules` walk from
+ * @param log - Logger function for diagnostic output
+ * @param deps - `require.resolve` and `require` equivalents; defaults to Node's own
+ * @returns The absolute path of the markuplint entry point
+ */
+export function resolveWithRequire(dir, log, deps) {
+    const { requireResolve, readPackageJson } = deps ?? nodeRequireDeps();
+    try {
+        const modPath = requireResolve('markuplint', { paths: [dir] });
+        log(`require.resolve('markuplint', "${dir}"): ${modPath}`);
+        return modPath;
+    }
+    catch (error) {
+        log(`require.resolve('markuplint', "${dir}"): ${error}`);
+        if (error instanceof Error && 'code' in error && error.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+            const modPackageJsonPath = error.message.replace(/^No "exports" main defined in /, '');
+            const pkg = readPackageJson(modPackageJsonPath);
+            const main = pkg.main ?? pkg.exports?.['.']?.import ?? pkg.exports?.['.']?.require ?? pkg.exports?.['.'] ?? null;
+            if (!main) {
+                error.message = error.message + ' No main';
+                throw error;
+            }
+            log(`require("${modPackageJsonPath}") => package.json: ${main}`);
+            const modPath = path.resolve(path.dirname(modPackageJsonPath), main);
+            return modPath;
+        }
+        throw error;
+    }
+}

package/lib/server/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/server/index.js

@@ -0,0 +1,5 @@
+import { createConnection, ProposedFeatures } from 'vscode-languageserver/node.js';
+import { bootServer } from './server.js';
+// `createConnection` without streams reads the transport from argv: `--stdio`, `--node-ipc`,
+// `--socket=<port>` or `--pipe=<name>`.
+bootServer(createConnection(ProposedFeatures.all));

package/lib/server/initialize-params.d.ts

@@ -0,0 +1,32 @@
+import type { InitializationOptions } from '../types.js';
+import type { WorkspaceFolder } from 'vscode-languageserver/node.js';
+/**
+ * The part of the LSP `initialize` request the server reads.
+ */
+export type InitializeInput = {
+    readonly locale?: string | null;
+    readonly rootUri?: string | null;
+    readonly workspaceFolders?: readonly WorkspaceFolder[] | null;
+    readonly initializationOptions?: unknown;
+};
+/**
+ * What the server derives from the `initialize` request.
+ */
+export type Initialization = {
+    readonly locale: string;
+    readonly options: InitializationOptions;
+    /** Absolute paths of the workspace folders */
+    readonly workspaceFolders: readonly string[];
+};
+/**
+ * Reads the `initialize` request of any LSP client.
+ *
+ * Only the VS Code extension sends `initializationOptions`, so a missing or `null` value is the
+ * normal case rather than an error. Workspace folders come from the options when the client gave
+ * them, otherwise from the LSP-standard `workspaceFolders`, and last from the deprecated
+ * `rootUri` that older clients still send.
+ *
+ * @param params - The `initialize` request
+ * @returns The locale, the options, and the workspace folders as absolute paths
+ */
+export declare function resolveInitialization(params: InitializeInput): Initialization;

package/lib/server/initialize-params.js

@@ -0,0 +1,28 @@
+import { fileURLToPath } from 'node:url';
+/**
+ * Reads the `initialize` request of any LSP client.
+ *
+ * Only the VS Code extension sends `initializationOptions`, so a missing or `null` value is the
+ * normal case rather than an error. Workspace folders come from the options when the client gave
+ * them, otherwise from the LSP-standard `workspaceFolders`, and last from the deprecated
+ * `rootUri` that older clients still send.
+ *
+ * @param params - The `initialize` request
+ * @returns The locale, the options, and the workspace folders as absolute paths
+ */
+export function resolveInitialization(params) {
+    // The shape is the client's promise; nothing here validates it, as with any LSP initialization option.
+    const options = (isRecord(params.initializationOptions) ? params.initializationOptions : {});
+    return {
+        locale: params.locale ?? 'en',
+        options,
+        workspaceFolders: options.workspaceFolders ?? workspaceFoldersFromProtocol(params),
+    };
+}
+function workspaceFoldersFromProtocol(params) {
+    const uris = params.workspaceFolders ? params.workspaceFolders.map(folder => folder.uri) : [params.rootUri];
+    return uris.filter((uri) => !!uri?.startsWith('file:')).map(uri => fileURLToPath(uri));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/lib/server/module-notices.d.ts

@@ -0,0 +1,28 @@
+import type { Module } from './get-module.js';
+import type { Log, Status } from '../types.js';
+/**
+ * Client-facing channels the notices are delivered through.
+ */
+export type ModuleNoticeChannels = {
+    /** Primary output channel */
+    readonly log: Log;
+    /** Warning popup */
+    readonly popup: (message: string) => void;
+    /** Status bar update */
+    readonly sendStatus: (status: Status) => void;
+};
+/**
+ * Creates the user-facing notices about which markuplint module a document is linted with.
+ *
+ * `reportStatus` runs on every document open, so the status bar follows the most recently
+ * opened document. `onFirstResolve` runs once per working directory; without
+ * `workingDirectories` that is once per opened file's directory, so the import assertion
+ * popup is additionally capped to once per session while its log line stays per directory.
+ *
+ * @param channels - Where to deliver the notices
+ * @returns Handlers for `createModuleResolver` and `createEventHandlers`
+ */
+export declare function createModuleNotices(channels: ModuleNoticeChannels): {
+    onFirstResolve(mod: Module): void;
+    reportStatus(mod: Module): void;
+};

package/lib/server/module-notices.js

@@ -0,0 +1,41 @@
+import { IMPORT_ASSERTION_COMPAT_WARNING, NO_INSTALL_WARNING } from '../const.js';
+import { t } from '../i18n.js';
+/**
+ * Creates the user-facing notices about which markuplint module a document is linted with.
+ *
+ * `reportStatus` runs on every document open, so the status bar follows the most recently
+ * opened document. `onFirstResolve` runs once per working directory; without
+ * `workingDirectories` that is once per opened file's directory, so the import assertion
+ * popup is additionally capped to once per session while its log line stays per directory.
+ *
+ * @param channels - Where to deliver the notices
+ * @returns Handlers for `createModuleResolver` and `createEventHandlers`
+ */
+export function createModuleNotices(channels) {
+    let compatPopupShown = false;
+    const noInstallMessage = (mod) => (mod.isLocalModule ? null : t(NO_INSTALL_WARNING, mod.version) + t('. '));
+    return {
+        onFirstResolve(mod) {
+            channels.log(`Found version: ${mod.version} (isLocalModule: ${mod.isLocalModule}) for ${mod.workspace}`, 'info');
+            const message = noInstallMessage(mod);
+            if (message) {
+                channels.log(message, 'warn');
+            }
+            if (mod.fallbackReason === 'import-assertion-compat') {
+                const compatMessage = t(IMPORT_ASSERTION_COMPAT_WARNING, mod.version);
+                channels.log(compatMessage, 'warn');
+                if (!compatPopupShown) {
+                    compatPopupShown = true;
+                    channels.popup(compatMessage);
+                }
+            }
+        },
+        reportStatus(mod) {
+            channels.sendStatus({
+                version: mod.version,
+                isLocalModule: mod.isLocalModule,
+                message: noInstallMessage(mod),
+            });
+        },
+    };
+}

package/lib/server/parser-load-failure.d.ts

@@ -0,0 +1,36 @@
+import type { Module } from './get-module.js';
+import type { Log } from '../types.js';
+/**
+ * What the document was linted with, needed to tell the user where the missing parser must be installed.
+ */
+export type ParserLoadFailureContext = {
+    readonly languageId: string;
+    readonly isLocalModule: boolean;
+    readonly version: string;
+    /** The working directory the module was resolved for */
+    readonly workspace: string;
+    readonly fallbackReason?: Module['fallbackReason'];
+};
+/**
+ * Extracts the package name of the parser that failed to load from an error message.
+ *
+ * @param message - The error message from `MLEngine#exec()`
+ * @returns The package name (scoped when applicable), or `null` if the message is not a parser load failure
+ */
+export declare function extractMissingParserName(message: string): string | null;
+/**
+ * Builds the user-facing explanation for a parser load failure.
+ *
+ * @param error - The rejection from `MLEngine#exec()`
+ * @param context - Which markuplint module linted the document
+ * @returns The message to show, or `null` if the error is not a parser load failure
+ */
+export declare function describeParserLoadFailure(error: unknown, context: ParserLoadFailureContext): string | null;
+/**
+ * Creates the `MLEngine#exec()` rejection handler for a document.
+ *
+ * @param context - Which markuplint module linted the document
+ * @param errorLog - Popup logger
+ * @returns A handler that reports parser load failures (and any other recoverable `Error`) and rethrows fatal errors
+ */
+export declare function createParserErrorHandler(context: ParserLoadFailureContext, errorLog: Log): (error: unknown) => void;

package/lib/server/parser-load-failure.js

@@ -0,0 +1,85 @@
+import { isFatalError } from 'markuplint/suppressions';
+import { BUNDLED_PARSER_LOAD_COMPAT_ERROR, BUNDLED_PARSER_LOAD_ERROR, PARSER_NOT_FOUND_ERROR } from '../const.js';
+import { t } from '../i18n.js';
+// `@markuplint/file-resolver` (v3+) rewrites a bare parser specifier that is not importable into an
+// absolute path under the config's directory before giving up, so the reported specifier is
+// usually `<configDir>/@markuplint/xxx-parser`, not the name the user wrote.
+const PARSER_MODULE_NOT_FOUND = /Parser module "(?<spec>[^"]+)" is not found\./;
+// Node's own messages: CommonJS `Cannot find module 'x'`, ESM `Cannot find package 'x' imported from …`.
+// Only a bare package specifier counts here: a path means some file of an installed package is
+// missing (a broken installation), not that a parser package is absent.
+const CANNOT_FIND_PACKAGE = /Cannot find (?:module|package) '(?<spec>(?:@[\w.-]+\/)?[\w.-]+)'/;
+/**
+ * Extracts the package name of the parser that failed to load from an error message.
+ *
+ * @param message - The error message from `MLEngine#exec()`
+ * @returns The package name (scoped when applicable), or `null` if the message is not a parser load failure
+ */
+export function extractMissingParserName(message) {
+    const rewritten = PARSER_MODULE_NOT_FOUND.exec(message)?.groups?.spec;
+    if (rewritten) {
+        return packageNameOf(rewritten);
+    }
+    return CANNOT_FIND_PACKAGE.exec(message)?.groups?.spec ?? null;
+}
+/**
+ * Recovers the package name from a specifier the config resolver may have turned into a path.
+ * A path ending in an unscoped segment is ambiguous (a package name or a parser file such as
+ * `./parsers/custom.js`), so only scoped names are recovered from paths.
+ */
+function packageNameOf(spec) {
+    const segments = spec.replaceAll('\\', '/').replace(/\/+$/, '').split('/');
+    const name = segments.at(-1);
+    const scope = segments.at(-2);
+    if (!name) {
+        return null;
+    }
+    if (scope?.startsWith('@')) {
+        return `${scope}/${name}`;
+    }
+    return segments.length === 1 ? name : null;
+}
+/**
+ * Builds the user-facing explanation for a parser load failure.
+ *
+ * @param error - The rejection from `MLEngine#exec()`
+ * @param context - Which markuplint module linted the document
+ * @returns The message to show, or `null` if the error is not a parser load failure
+ */
+export function describeParserLoadFailure(error, context) {
+    if (!(error instanceof Error)) {
+        return null;
+    }
+    const parser = extractMissingParserName(error.message);
+    if (!parser) {
+        return null;
+    }
+    if (context.isLocalModule) {
+        return t(PARSER_NOT_FOUND_ERROR, parser, context.languageId);
+    }
+    if (context.fallbackReason === 'import-assertion-compat') {
+        return t(BUNDLED_PARSER_LOAD_COMPAT_ERROR, context.version, parser, context.workspace);
+    }
+    return t(BUNDLED_PARSER_LOAD_ERROR, context.version, parser, context.workspace);
+}
+/**
+ * Creates the `MLEngine#exec()` rejection handler for a document.
+ *
+ * @param context - Which markuplint module linted the document
+ * @param errorLog - Popup logger
+ * @returns A handler that reports parser load failures (and any other recoverable `Error`) and rethrows fatal errors
+ */
+export function createParserErrorHandler(context, errorLog) {
+    return (error) => {
+        if (isFatalError(error)) {
+            throw error;
+        }
+        const message = describeParserLoadFailure(error, context);
+        if (message) {
+            errorLog(message);
+            return;
+        }
+        // Non-Error values are fatal per isFatalError() and were rethrown above.
+        errorLog(error.message);
+    };
+}

package/lib/server/server.d.ts

@@ -0,0 +1,20 @@
+import type { Connection } from 'vscode-languageserver/node.js';
+/**
+ * Bootstrap the LSP language server on a connection and start listening.
+ *
+ * Any LSP client can use the server, so nothing the client sends beyond the LSP itself is
+ * required: `initializationOptions` is optional (see {@link InitializationOptions}), and the
+ * `markuplint/*` custom messages are sent only to a client that opts in with `extendedProtocol`
+ * (see {@link createClientChannel}). Only the VS Code extension relies on both.
+ *
+ * The markuplint module is resolved lazily per working directory as documents open; the
+ * bundled-fallback notice is logged once per directory and the import assertion popup is shown
+ * once per session (see `createModuleNotices`).
+ *
+ * Diagnostics must not write to stdout: over `--stdio` it carries the protocol, and a client
+ * such as Claude Code disconnects the server on any other output. Logs go through the channel,
+ * and `debug` writes to stderr.
+ *
+ * @param connection - The connection to the client, from `createConnection`
+ */
+export declare function bootServer(connection: Connection): void;

package/lib/server/server.js

@@ -0,0 +1,96 @@
+import { CodeActionKind, TextDocuments, TextDocumentSyncKind } from 'vscode-languageserver/node.js';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { setLocale } from '../i18n.js';
+import { createClientChannel } from './client-channel.js';
+import { SOURCE_FIX_ALL_MARKUPLINT } from './code-actions.js';
+import { applySeverityMap } from './convert-diagnostics.js';
+import { verbosely } from './debug.js';
+import { createEventHandlers } from './document-events.js';
+import { createModuleResolver } from './get-module.js';
+import { resolveInitialization } from './initialize-params.js';
+import { createModuleNotices } from './module-notices.js';
+import { configureGitPath } from './suppression-support.js';
+const DEBUG = false;
+/**
+ * Bootstrap the LSP language server on a connection and start listening.
+ *
+ * Any LSP client can use the server, so nothing the client sends beyond the LSP itself is
+ * required: `initializationOptions` is optional (see {@link InitializationOptions}), and the
+ * `markuplint/*` custom messages are sent only to a client that opts in with `extendedProtocol`
+ * (see {@link createClientChannel}). Only the VS Code extension relies on both.
+ *
+ * The markuplint module is resolved lazily per working directory as documents open; the
+ * bundled-fallback notice is logged once per directory and the import assertion popup is shown
+ * once per session (see `createModuleNotices`).
+ *
+ * Diagnostics must not write to stdout: over `--stdio` it carries the protocol, and a client
+ * such as Claude Code disconnects the server on any other output. Logs go through the channel,
+ * and `debug` writes to stderr.
+ *
+ * @param connection - The connection to the client, from `createConnection`
+ */
+export function bootServer(connection) {
+    const channel = createClientChannel(connection);
+    const documents = new TextDocuments(TextDocument);
+    documents.listen(connection);
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    let codeActionHandler = () => [];
+    connection.onCodeAction(params => codeActionHandler(params));
+    connection.onInitialize((params) => {
+        const { locale, options, workspaceFolders } = resolveInitialization(params);
+        channel.configure(options.extendedProtocol === true);
+        setLocale(locale);
+        const log = channel.log;
+        log('onInitialize');
+        const { langConfigs, workingDirectories, gitPath, severityMap } = options;
+        configureGitPath(gitPath);
+        const sendDiagnostics = ({ diagnostics, ...rest }) => {
+            void connection.sendDiagnostics({ ...rest, diagnostics: applySeverityMap(diagnostics, severityMap) });
+        };
+        connection.onInitialized(() => {
+            log('onInitialized');
+            if (DEBUG) {
+                verbosely();
+            }
+            log(`Locale: ${locale}`, 'info');
+            if (workingDirectories) {
+                log(`Working directories: ${JSON.stringify(workingDirectories)}`, 'info');
+            }
+            const notices = createModuleNotices({
+                log,
+                popup: channel.warningPopup,
+                sendStatus: channel.reportStatus,
+            });
+            const resolveModule = createModuleResolver({ log, onFirstResolve: notices.onFirstResolve });
+            const { onDidOpen, onDidChangeContent, onDidClose, onHover, onCodeAction } = createEventHandlers({
+                resolveModule,
+                locale,
+                langConfigs,
+                workingDirectories,
+                workspaceFolders,
+                log,
+                diagnosticsLog: channel.diagnosticsLog,
+                errorLog: channel.errorLog,
+                sendDiagnostics,
+                reportStatus: notices.reportStatus,
+            });
+            documents.onDidOpen(e => onDidOpen(e.document));
+            // eslint-disable-next-line unicorn/no-array-for-each
+            documents.all().forEach(onDidOpen);
+            documents.onDidChangeContent(e => onDidChangeContent(e.document));
+            documents.onDidClose(e => onDidClose(e.document));
+            connection.onHover(onHover);
+            codeActionHandler = onCodeAction;
+        });
+        return {
+            capabilities: {
+                textDocumentSync: TextDocumentSyncKind.Incremental,
+                hoverProvider: true,
+                codeActionProvider: {
+                    codeActionKinds: [CodeActionKind.QuickFix, SOURCE_FIX_ALL_MARKUPLINT],
+                },
+            },
+        };
+    });
+    connection.listen();
+}