@markuplint/language-server 0.0.0-stage → 5.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-2024 Yusuke Hirao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,75 @@
-# Temporary Holding Version
+# @markuplint/language-server
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[Language Server Protocol](https://microsoft.github.io/language-server-protocol/) server for [markuplint](https://markuplint.dev). It reports markuplint violations as diagnostics, offers quick fixes, and shows the accessibility properties of an element on hover. It is the server behind the [VS Code extension](https://marketplace.visualstudio.com/items?itemName=markuplint.markuplint-vscode), and runs with any other LSP client: AI coding agents such as Claude Code and OpenCode, Neovim, Helix, and so on.
+
+## Install
+
+```sh
+npm install --save-dev @markuplint/language-server
+```
+
+The server starts with `markuplint-language-server --stdio`. It needs no settings: it lints with the project's markuplint config file (`.markuplintrc` and its siblings), falls back to `markuplint:recommended` as the CLI does, and loads the markuplint installed in the project. The markuplint that ships with this package is used when the project has none.
+
+Which files the server receives is up to the client, so list the extensions you want linted in its configuration.
+
+## Claude Code
+
+Claude Code registers language servers through plugins. Create a directory with a `.lsp.json`, and load it with `claude --plugin-dir <directory>`:
+
+```json
+{
+  "markuplint": {
+    "command": "npx",
+    "args": ["markuplint-language-server", "--stdio"],
+    "extensionToLanguage": {
+      ".html": "html"
+    }
+  }
+}
+```
+
+After Claude edits a matching file, the violations appear as diagnostics in its context. Claude Code uses one server per extension, so leave out extensions that another language server already handles (such as `.tsx`).
+
+## OpenCode
+
+Add the server to `opencode.json`. OpenCode passes only diagnostics of the `error` severity to the model, so `severityMap` re-reports markuplint's warnings as errors:
+
+```json
+{
+  "lsp": {
+    "markuplint": {
+      "command": ["npx", "markuplint-language-server", "--stdio"],
+      "extensions": [".html"],
+      "initialization": {
+        "severityMap": { "warning": "error" }
+      }
+    }
+  }
+}
+```
+
+## Neovim
+
+Neovim 0.11 or later:
+
+```lua
+vim.lsp.config['markuplint'] = {
+	cmd = { 'npx', 'markuplint-language-server', '--stdio' },
+	filetypes = { 'html' },
+	root_markers = { '.markuplintrc', 'package.json', '.git' },
+}
+vim.lsp.enable('markuplint')
+```
+
+## Options
+
+A client passes them as `initializationOptions`. All of them are optional.
+
+| Option               | Description                                                                                                                              |
+| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `severityMap`        | Re-reports diagnostics with another severity: `{ "warning": "error" }`. Keys are `error`, `warning`, `info`; values add `hint`.          |
+| `workingDirectories` | Working directories for monorepos, as in the VS Code extension's `markuplint.workingDirectories` setting.                                |
+| `workspaceFolders`   | Absolute paths of the workspace folders. The `workspaceFolders` and `rootUri` of the `initialize` request are used when this is not set. |
+| `gitPath`            | Path to the `git` binary that bulk suppression uses.                                                                                     |
+| `langConfigs`        | Per-language settings. When set, only the languages listed with `enable: true` are linted.                                               |
+| `extendedProtocol`   | For the VS Code extension: sends the `markuplint/*` messages instead of `window/logMessage` and `window/showMessage`.                    |

package/bin/markuplint-language-server.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+await import('../lib/server/index.js');

package/lib/const.d.ts

@@ -0,0 +1,41 @@
+export declare const ID = "markuplint";
+export declare const NAME = "Markuplint";
+export declare const WEBSITE_URL = "https://markuplint.dev";
+export declare const WEBSITE_URL_RULE_PAGE: "https://markuplint.dev/docs/rules/";
+/**
+ * Warning message shown when markuplint is not found in the workspace's node_modules.
+ * Displayed in the status bar tooltip. Placeholder `{0}` is replaced with the bundled version number.
+ */
+export declare const NO_INSTALL_WARNING = "since markuplint could not be found in the node_modules of the workspace, this use the version (v{0}) installed with the language server";
+/**
+ * Warning message shown when the local markuplint (v4.0.0–4.9.x) fails to load on Node.js 22+
+ * due to the removed `assert { type: 'json' }` syntax (import assertions).
+ * Displayed as a popup via `warningToPopup`. Placeholder `{0}` is replaced with the bundled version number.
+ *
+ * @see https://github.com/markuplint/markuplint/issues/2837
+ */
+export declare const IMPORT_ASSERTION_COMPAT_WARNING = "your local markuplint is incompatible with Node.js 22+ due to import assertion syntax. The bundled version (v{0}) is used instead. To use your local version, upgrade to markuplint@4.10.0 or later. See: https://github.com/markuplint/markuplint/issues/2837";
+/**
+ * Error message shown when the parser a config requires cannot be loaded by a local markuplint.
+ * Displayed as a popup via `errorToPopup`. `{0*}` is the parser package name, `{1*}` the language identifier.
+ */
+export declare const PARSER_NOT_FOUND_ERROR = "Parser not found. You probably need to install {0*} for documents of language {1*}.";
+/**
+ * Error message shown when the bundled markuplint cannot load a parser that lives in the user's workspace.
+ * The bundled `@markuplint/file-resolver` imports parsers relative to itself, so a parser installed only in
+ * the working directory is unreachable until markuplint itself is installed there.
+ * The module cache is only cleared by a server restart, hence the restart instruction.
+ * Displayed as a popup via `errorToPopup`. `{0}` is the bundled version, `{1*}` the parser package name,
+ * `{2*}` the working directory.
+ *
+ * @see https://github.com/markuplint/markuplint/issues/4048
+ */
+export declare const BUNDLED_PARSER_LOAD_ERROR = "The markuplint bundled with the language server (v{0}) cannot load parsers installed in your workspace. Install markuplint and {1*} in {2*}, then restart the language server so that it can use the local installation.";
+/**
+ * Variant of {@link BUNDLED_PARSER_LOAD_ERROR} for when the local markuplint exists but was skipped
+ * for the import assertion incompatibility ({@link IMPORT_ASSERTION_COMPAT_WARNING}): installing is
+ * not the fix there, upgrading is.
+ * Displayed as a popup via `errorToPopup`. `{0}` is the bundled version, `{1*}` the parser package name,
+ * `{2*}` the working directory.
+ */
+export declare const BUNDLED_PARSER_LOAD_COMPAT_ERROR = "The markuplint bundled with the language server (v{0}) cannot load {1*} from {2*} because the markuplint installed there is incompatible with Node.js 22+. Upgrade it to markuplint@4.10.0 or later, then restart the language server.";

package/lib/const.js

@@ -0,0 +1,44 @@
+// Identifiers
+export const ID = 'markuplint';
+export const NAME = 'Markuplint';
+// URI
+export const WEBSITE_URL = 'https://markuplint.dev';
+export const WEBSITE_URL_RULE_PAGE = `${WEBSITE_URL}/docs/rules/`;
+// Messages
+/**
+ * Warning message shown when markuplint is not found in the workspace's node_modules.
+ * Displayed in the status bar tooltip. Placeholder `{0}` is replaced with the bundled version number.
+ */
+export const NO_INSTALL_WARNING = 'since markuplint could not be found in the node_modules of the workspace, this use the version (v{0}) installed with the language server';
+/**
+ * Warning message shown when the local markuplint (v4.0.0–4.9.x) fails to load on Node.js 22+
+ * due to the removed `assert { type: 'json' }` syntax (import assertions).
+ * Displayed as a popup via `warningToPopup`. Placeholder `{0}` is replaced with the bundled version number.
+ *
+ * @see https://github.com/markuplint/markuplint/issues/2837
+ */
+export const IMPORT_ASSERTION_COMPAT_WARNING = 'your local markuplint is incompatible with Node.js 22+ due to import assertion syntax. The bundled version (v{0}) is used instead. To use your local version, upgrade to markuplint@4.10.0 or later. See: https://github.com/markuplint/markuplint/issues/2837';
+/**
+ * Error message shown when the parser a config requires cannot be loaded by a local markuplint.
+ * Displayed as a popup via `errorToPopup`. `{0*}` is the parser package name, `{1*}` the language identifier.
+ */
+export const PARSER_NOT_FOUND_ERROR = 'Parser not found. You probably need to install {0*} for documents of language {1*}.';
+/**
+ * Error message shown when the bundled markuplint cannot load a parser that lives in the user's workspace.
+ * The bundled `@markuplint/file-resolver` imports parsers relative to itself, so a parser installed only in
+ * the working directory is unreachable until markuplint itself is installed there.
+ * The module cache is only cleared by a server restart, hence the restart instruction.
+ * Displayed as a popup via `errorToPopup`. `{0}` is the bundled version, `{1*}` the parser package name,
+ * `{2*}` the working directory.
+ *
+ * @see https://github.com/markuplint/markuplint/issues/4048
+ */
+export const BUNDLED_PARSER_LOAD_ERROR = 'The markuplint bundled with the language server (v{0}) cannot load parsers installed in your workspace. Install markuplint and {1*} in {2*}, then restart the language server so that it can use the local installation.';
+/**
+ * Variant of {@link BUNDLED_PARSER_LOAD_ERROR} for when the local markuplint exists but was skipped
+ * for the import assertion incompatibility ({@link IMPORT_ASSERTION_COMPAT_WARNING}): installing is
+ * not the fix there, upgrading is.
+ * Displayed as a popup via `errorToPopup`. `{0}` is the bundled version, `{1*}` the parser package name,
+ * `{2*}` the working directory.
+ */
+export const BUNDLED_PARSER_LOAD_COMPAT_ERROR = 'The markuplint bundled with the language server (v{0}) cannot load {1*} from {2*} because the markuplint installed there is incompatible with Node.js 22+. Upgrade it to markuplint@4.10.0 or later, then restart the language server.';

package/lib/i18n.d.ts

@@ -0,0 +1,19 @@
+import type { Translator } from '@markuplint/i18n';
+/**
+ * Sets the locale of the client, as sent in the `initialize` request.
+ *
+ * @param locale - A locale such as `en` or `ja-JP`
+ */
+export declare function setLocale(locale: string): void;
+/**
+ * Translates a message into the locale of the client.
+ *
+ * @param args - The arguments of the `@markuplint/i18n` translator: the message and its placeholder values
+ * @returns The translated message, or the message itself without a translation
+ */
+export declare function t(...args: Parameters<Translator>): string;
+/**
+ * The locale of the client. The `VSCODE_NLS_CONFIG` environment variable of the VS Code extension
+ * host is kept as the fallback for a client that does not send a locale.
+ */
+export declare function getLocale(): string;

package/lib/i18n.js

@@ -0,0 +1,63 @@
+import { readFileSync } from 'node:fs';
+import { translator } from '@markuplint/i18n';
+let clientLocale;
+/**
+ * Sets the locale of the client, as sent in the `initialize` request.
+ *
+ * @param locale - A locale such as `en` or `ja-JP`
+ */
+export function setLocale(locale) {
+    clientLocale = locale;
+}
+/**
+ * Translates a message into the locale of the client.
+ *
+ * @param args - The arguments of the `@markuplint/i18n` translator: the message and its placeholder values
+ * @returns The translated message, or the message itself without a translation
+ */
+export function t(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+...args) {
+    const locale = getLocale();
+    const localeSet = i18n(locale);
+    return translator(localeSet)(...args);
+}
+/**
+ * The locale of the client. The `VSCODE_NLS_CONFIG` environment variable of the VS Code extension
+ * host is kept as the fallback for a client that does not send a locale.
+ */
+export function getLocale() {
+    const locale = clientLocale ?? JSON.parse(process.env.VSCODE_NLS_CONFIG || '{}').locale ?? 'en';
+    return locale;
+}
+/**
+ * The language of a locale (`ja` for `ja-JP` or `ja_JP`).
+ *
+ * The locale arrives from the client, and the language names a file under `locales/`. Anything
+ * but a two or three letter language falls back to English so the name can never leave that
+ * directory.
+ */
+function toLanguage(locale) {
+    const language = (locale.split(/[-_]/)[0] ?? '').toLowerCase();
+    return /^[a-z]{2,3}$/.test(language) ? language : 'en';
+}
+function i18n(locale) {
+    const langCode = toLanguage(locale);
+    const localeSet = getLocaleSet(langCode);
+    return {
+        ...localeSet,
+        locale: langCode,
+    };
+}
+function readLocaleFile(langCode) {
+    return JSON.parse(readFileSync(new URL(`../locales/${langCode}.json`, import.meta.url), 'utf8'));
+}
+function getLocaleSet(langCode) {
+    try {
+        return readLocaleFile(langCode);
+    }
+    catch {
+        // Avoid
+    }
+    return readLocaleFile('en');
+}

package/lib/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Language Server Protocol server for markuplint.
+ *
+ * Run `markuplint-language-server --stdio` to start it. Any LSP client can use it: a client
+ * needs no markuplint-specific configuration, because the server lints with the project's own
+ * config file (`.markuplintrc` and its siblings), falls back to `markuplint:recommended` like the
+ * CLI, and loads the markuplint installed in the project, falling back to the one that installs
+ * with this package.
+ *
+ * The VS Code extension is a client of this package. What it sends beyond the LSP is in
+ * {@link InitializationOptions}, and the custom messages are in `@markuplint/language-server/protocol`.
+ *
+ * Contracts that the clients impose, and that the code keeps because of them:
+ *
+ * - **stdout carries the protocol only.** Claude Code treats any other output on stdout as a
+ *   crash of the server. `--stdio` makes `vscode-languageserver` redirect `console.*` away from
+ *   stdout, and `debug` writes to stderr; do not write to `process.stdout` directly.
+ * - **The `markuplint/*` messages are opt-in (`extendedProtocol`).** A client that has not
+ *   registered `markuplint/ready` answers the request with `MethodNotFound`, and the others
+ *   have no output channel or popup to show. Only the VS Code extension handles them; every
+ *   other client receives `window/logMessage` and `window/showMessage`.
+ * - **`window/showMessage` is sent as a notification.** `connection.window.showErrorMessage`
+ *   sends `window/showMessageRequest`, which a client must answer and many do not.
+ * - **`severityMap` exists because clients surface different severities.** OpenCode hands only
+ *   `error` diagnostics to the model, Claude Code hands errors and warnings. Re-reporting
+ *   markuplint's warnings as errors is the client's choice, not a server default.
+ * - **No `langConfigs` means no per-language gate.** Which documents reach the server is the
+ *   client's setting (`extensionToLanguage` of Claude Code, `extensions` of OpenCode,
+ *   `filetypes` of Neovim), so the server lints every document it is given.
+ *
+ * What the clients accept is theirs to change; check them when this package misbehaves in one:
+ *
+ * - Claude Code: https://code.claude.com/docs/en/plugins-reference#lspservers (a server is
+ *   registered only through a plugin, and one server serves an extension)
+ * - OpenCode: https://opencode.ai/docs/lsp/ (`lsp` of `opencode.json`)
+ * - Neovim: `:help vim.lsp.config()`
+ *
+ * @module
+ */
+export { bootServer } from './server/server.js';
+export type { InitializationOptions, SeverityMap } from './types.js';

package/lib/index.js

@@ -0,0 +1,40 @@
+/**
+ * Language Server Protocol server for markuplint.
+ *
+ * Run `markuplint-language-server --stdio` to start it. Any LSP client can use it: a client
+ * needs no markuplint-specific configuration, because the server lints with the project's own
+ * config file (`.markuplintrc` and its siblings), falls back to `markuplint:recommended` like the
+ * CLI, and loads the markuplint installed in the project, falling back to the one that installs
+ * with this package.
+ *
+ * The VS Code extension is a client of this package. What it sends beyond the LSP is in
+ * {@link InitializationOptions}, and the custom messages are in `@markuplint/language-server/protocol`.
+ *
+ * Contracts that the clients impose, and that the code keeps because of them:
+ *
+ * - **stdout carries the protocol only.** Claude Code treats any other output on stdout as a
+ *   crash of the server. `--stdio` makes `vscode-languageserver` redirect `console.*` away from
+ *   stdout, and `debug` writes to stderr; do not write to `process.stdout` directly.
+ * - **The `markuplint/*` messages are opt-in (`extendedProtocol`).** A client that has not
+ *   registered `markuplint/ready` answers the request with `MethodNotFound`, and the others
+ *   have no output channel or popup to show. Only the VS Code extension handles them; every
+ *   other client receives `window/logMessage` and `window/showMessage`.
+ * - **`window/showMessage` is sent as a notification.** `connection.window.showErrorMessage`
+ *   sends `window/showMessageRequest`, which a client must answer and many do not.
+ * - **`severityMap` exists because clients surface different severities.** OpenCode hands only
+ *   `error` diagnostics to the model, Claude Code hands errors and warnings. Re-reporting
+ *   markuplint's warnings as errors is the client's choice, not a server default.
+ * - **No `langConfigs` means no per-language gate.** Which documents reach the server is the
+ *   client's setting (`extensionToLanguage` of Claude Code, `extensions` of OpenCode,
+ *   `filetypes` of Neovim), so the server lints every document it is given.
+ *
+ * What the clients accept is theirs to change; check them when this package misbehaves in one:
+ *
+ * - Claude Code: https://code.claude.com/docs/en/plugins-reference#lspservers (a server is
+ *   registered only through a plugin, and one server serves an extension)
+ * - OpenCode: https://opencode.ai/docs/lsp/ (`lsp` of `opencode.json`)
+ * - Neovim: `:help vim.lsp.config()`
+ *
+ * @module
+ */
+export { bootServer } from './server/server.js';

package/lib/lsp.d.ts

@@ -0,0 +1,8 @@
+import type { LogArg, Status } from './types.js';
+import { NotificationType, RequestType } from 'vscode-languageserver';
+export declare const status: RequestType<Status, void, void>;
+export declare const logToPrimaryChannel: NotificationType<LogArg>;
+export declare const logToDiagnosticsChannel: NotificationType<LogArg>;
+export declare const errorToPopup: NotificationType<string>;
+export declare const warningToPopup: NotificationType<string>;
+export declare const infoToPopup: NotificationType<string>;

package/lib/lsp.js

@@ -0,0 +1,8 @@
+import { NotificationType, RequestType } from 'vscode-languageserver';
+import { ID } from './const.js';
+export const status = new RequestType(`${ID}/ready`);
+export const logToPrimaryChannel = new NotificationType(`${ID}/log-primary-channel`);
+export const logToDiagnosticsChannel = new NotificationType(`${ID}/log-diagnostics-channel`);
+export const errorToPopup = new NotificationType(`${ID}/error-popup`);
+export const warningToPopup = new NotificationType(`${ID}/warning-popup`);
+export const infoToPopup = new NotificationType(`${ID}/info-popup`);

package/lib/protocol.d.ts

@@ -0,0 +1,10 @@
+/**
+ * What a client that opts in to `extendedProtocol` shares with the server: the identifiers, the
+ * custom `markuplint/*` messages, and the types of what they carry. The VS Code extension
+ * imports this to handle the messages; the server imports the same definitions to send them.
+ *
+ * @module
+ */
+export { ID, NAME } from './const.js';
+export * from './lsp.js';
+export type { Config, InitializationOptions, LangConfigs, Log, LogArg, LogType, ReportedSeverity, SeverityMap, Status, } from './types.js';

package/lib/protocol.js

@@ -0,0 +1,9 @@
+/**
+ * What a client that opts in to `extendedProtocol` shares with the server: the identifiers, the
+ * custom `markuplint/*` messages, and the types of what they carry. The VS Code extension
+ * imports this to handle the messages; the server imports the same definitions to send them.
+ *
+ * @module
+ */
+export { ID, NAME } from './const.js';
+export * from './lsp.js';

package/lib/server/client-channel.d.ts

@@ -0,0 +1,38 @@
+import type { Log, Status } from '../types.js';
+import type { Connection } from 'vscode-languageserver/node.js';
+/**
+ * How the server talks to its client apart from diagnostics.
+ */
+export type ClientChannel = {
+    /**
+     * Selects the protocol. Called once, from the `initialize` request.
+     *
+     * @param extendedProtocol - `true` when the client understands the `markuplint/*` messages
+     */
+    configure(extendedProtocol: boolean): void;
+    /** Primary log: the extension's output channel, otherwise `window/logMessage` */
+    readonly log: Log;
+    /** Diagnostics log: the extension's second output channel, otherwise `window/logMessage` */
+    readonly diagnosticsLog: Log;
+    /** An error the user should see: the extension's popup, otherwise `window/showMessage` */
+    readonly errorLog: Log;
+    /** A warning the user should see: the extension's popup, otherwise `window/showMessage` */
+    warningPopup(message: string): void;
+    /** Tells the client which markuplint lints the documents. Only the extension has a status bar for it. */
+    reportStatus(current: Status): void;
+};
+/**
+ * Creates the channel between the server and its client.
+ *
+ * The `markuplint/*` messages are custom: a client that has not registered them rejects the
+ * `markuplint/ready` request with `MethodNotFound`, and it has no output channel or popup to
+ * show the notifications in. Only the VS Code extension, which handles all of them, opts in.
+ * Every other client gets `window/logMessage` and `window/showMessage`, which the LSP requires
+ * a client to support. `window/showMessage` is the notification, never the
+ * `window/showMessageRequest` that `connection.window.showErrorMessage` sends and a client must
+ * answer.
+ *
+ * @param connection - The connection to the client; only what it sends is used
+ * @returns The channel, which uses the standard messages until `configure(true)` is called
+ */
+export declare function createClientChannel(connection: Pick<Connection, 'sendNotification' | 'sendRequest'>): ClientChannel;

package/lib/server/client-channel.js

@@ -0,0 +1,89 @@
+import { isFatalError } from 'markuplint/suppressions';
+import { LogMessageNotification, MessageType, ShowMessageNotification } from 'vscode-languageserver/node.js';
+import { errorToPopup, logToDiagnosticsChannel, logToPrimaryChannel, status, warningToPopup } from '../lsp.js';
+const MESSAGE_TYPES = {
+    error: MessageType.Error,
+    warn: MessageType.Warning,
+    info: MessageType.Info,
+    debug: MessageType.Log,
+};
+/**
+ * Creates the channel between the server and its client.
+ *
+ * The `markuplint/*` messages are custom: a client that has not registered them rejects the
+ * `markuplint/ready` request with `MethodNotFound`, and it has no output channel or popup to
+ * show the notifications in. Only the VS Code extension, which handles all of them, opts in.
+ * Every other client gets `window/logMessage` and `window/showMessage`, which the LSP requires
+ * a client to support. `window/showMessage` is the notification, never the
+ * `window/showMessageRequest` that `connection.window.showErrorMessage` sends and a client must
+ * answer.
+ *
+ * @param connection - The connection to the client; only what it sends is used
+ * @returns The channel, which uses the standard messages until `configure(true)` is called
+ */
+export function createClientChannel(connection) {
+    let extended = false;
+    // `trace` is one line per engine phase for every document, which is what the extension's
+    // output channel is for. A client that does not opt in has no such channel to put it in.
+    function standardLog(message, type) {
+        if (type === 'clear' || type === 'trace') {
+            return;
+        }
+        void connection.sendNotification(LogMessageNotification.type, {
+            type: MESSAGE_TYPES[type ?? 'debug'],
+            message,
+        });
+    }
+    function standardShow(message, type) {
+        void connection.sendNotification(ShowMessageNotification.type, { type, message });
+    }
+    const log = (message, type) => {
+        if (extended) {
+            void connection.sendNotification(logToPrimaryChannel, [message, type]);
+        }
+        else {
+            standardLog(message, type);
+        }
+    };
+    return {
+        configure(extendedProtocol) {
+            extended = extendedProtocol;
+        },
+        log,
+        diagnosticsLog(message, type) {
+            if (extended) {
+                void connection.sendNotification(logToDiagnosticsChannel, [message, type]);
+            }
+            else {
+                standardLog(message, type ?? 'info');
+            }
+        },
+        errorLog(message) {
+            if (extended) {
+                void connection.sendNotification(errorToPopup, message);
+            }
+            else {
+                standardShow(message, MessageType.Error);
+            }
+        },
+        warningPopup(message) {
+            if (extended) {
+                void connection.sendNotification(warningToPopup, message);
+            }
+            else {
+                standardShow(message, MessageType.Warning);
+            }
+        },
+        reportStatus(current) {
+            if (!extended) {
+                return;
+            }
+            connection.sendRequest(status, current).catch((error) => {
+                if (isFatalError(error)) {
+                    throw error;
+                }
+                log(`The client rejected the status: ${error}`, 'warn');
+            });
+        },
+    };
+}

package/lib/server/code-actions.d.ts

@@ -0,0 +1,36 @@
+import type { FixState } from './v4.js';
+import type { CodeAction, Diagnostic, Position } from 'vscode-languageserver';
+/**
+ * Code Action kind for "Fix all markuplint issues".
+ * Follows the `source.fixAll.<provider>` convention used by ESLint and others.
+ */
+export declare const SOURCE_FIX_ALL_MARKUPLINT: string;
+/**
+ * Converts a 0-based character offset to an LSP Position using the source code.
+ *
+ * @param sourceCode - The full raw source text
+ * @param offset - A zero-based character offset into the source
+ * @returns A 0-based LSP Position (line and character)
+ */
+export declare function offsetToPosition(sourceCode: string, offset: number): Position;
+/**
+ * Creates per-violation QuickFix Code Actions.
+ *
+ * @param uri - The document URI to associate edits with
+ * @param diagnostics - The diagnostics from the Code Action request context
+ * @param fixState - The latest lint result containing violations and fix data
+ * @returns An array of QuickFix Code Actions, one per fixable violation
+ */
+export declare function createQuickFixActions(uri: string, diagnostics: readonly Diagnostic[], fixState: FixState): CodeAction[];
+/**
+ * Creates a SourceFixAll Code Action (`source.fixAll.markuplint`).
+ *
+ * Uses firstPassEdits from FixSummary for cursor-safe individual edits.
+ * Falls back to full-document replacement when firstPassEdits is unavailable.
+ *
+ * @param uri - The document URI to associate edits with
+ * @param diagnostics - The diagnostics to attach to the Code Action
+ * @param fixState - The latest lint result containing violations and fix data
+ * @returns A SourceFixAll Code Action, or `null` if nothing to fix
+ */
+export declare function createFixAllAction(uri: string, diagnostics: readonly Diagnostic[], fixState: FixState): CodeAction | null;