@lapis-notes/language-service 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# @lapis-notes/language-service
+
+## 0.1.0
+
+### Minor Changes
+
+- First public npm release of the provider-neutral Markdown language-service
+  and native Markdownlint runtime contracts.

package/LICENSE.md

@@ -0,0 +1,4 @@
+AGPL-3.0-or-later
+
+This package is licensed under the GNU Affero General Public License v3.0 or later.
+See <https://www.gnu.org/licenses/agpl-3.0.en.html>.

package/README.md

@@ -0,0 +1,28 @@
+# @lapis-notes/language-service
+
+Provider-neutral Markdown language services for Lapis applications.
+
+The package exposes browser-worker and native-host adapters without owning
+workspace presentation, vault navigation, or application policy.
+
+## Public surface
+
+- `@lapis-notes/language-service`
+- `@lapis-notes/language-service/markdown`
+- `@lapis-notes/language-service/markdownlint/runtime`
+
+## Usage
+
+```ts
+import { createMarkdownLanguageServiceProvider } from "@lapis-notes/language-service/markdown";
+```
+
+Install `@lapis-notes/api` from npm with a compatible version.
+
+## Common scripts
+
+```sh
+pnpm --filter @lapis-notes/language-service build
+pnpm --filter @lapis-notes/language-service check
+pnpm --filter @lapis-notes/language-service test
+```

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createMarkdownLanguageServiceProvider, createMarkdownLanguageServiceProvider as createMarkdownLintProvider, createNativeMarkdownLanguageServiceProvider, probeNativeMarkdownLanguageService, } from "./markdown";
+export type { MarkdownLanguageServiceProviderOptions } from "./markdown";
+export { createMarkdownlintLintOptions } from "./markdownlint/options";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { createMarkdownLanguageServiceProvider, createMarkdownLanguageServiceProvider as createMarkdownLintProvider, createNativeMarkdownLanguageServiceProvider, probeNativeMarkdownLanguageService, } from "./markdown";
+export { createMarkdownlintLintOptions } from "./markdownlint/options";

package/dist/markdown.d.ts

@@ -0,0 +1,8 @@
+import { type LanguageServiceProvider } from "@lapis-notes/api/language-service";
+export interface MarkdownLanguageServiceProviderOptions {
+    rules?: Record<string, unknown>;
+    getRules?: () => Record<string, unknown> | undefined;
+}
+export declare function createMarkdownLanguageServiceProvider(options?: MarkdownLanguageServiceProviderOptions): LanguageServiceProvider;
+export declare function createNativeMarkdownLanguageServiceProvider(invoke: (command: string, payload?: Record<string, unknown>) => Promise<unknown>, options?: MarkdownLanguageServiceProviderOptions): LanguageServiceProvider;
+export declare function probeNativeMarkdownLanguageService(invoke: (command: string, payload?: Record<string, unknown>) => Promise<unknown>): Promise<boolean>;

package/dist/markdown.js

@@ -0,0 +1,120 @@
+/// <reference path="./vite-env.d.ts" />
+import { LanguageServiceWorkerClient } from "@lapis-notes/api/language-service/worker";
+import MarkdownLintWorker from "./workers/markdownlint.worker.js?worker&inline";
+const DESKTOP_LANGUAGE_SERVICE_PROTOCOL_VERSION = 1;
+function resolveMarkdownRules(options) {
+    return options.getRules?.() ?? options.rules;
+}
+export function createMarkdownLanguageServiceProvider(options = {}) {
+    const client = new LanguageServiceWorkerClient(new MarkdownLintWorker());
+    return {
+        metadata: {
+            id: "markdownlint-worker",
+            languages: ["markdown"],
+            runtime: "worker",
+            priority: 0,
+            capabilities: { diagnostics: true, codeActions: true },
+        },
+        async updateDocument(update) {
+            await client.request({
+                type: "document/update",
+                document: update.document,
+            });
+        },
+        async provideDiagnostics(context) {
+            const response = await client.request({
+                type: "diagnostics",
+                document: context.document,
+                globals: context.globals,
+                rules: resolveMarkdownRules(options),
+            });
+            if (response.type !== "diagnostics")
+                return [];
+            return response.diagnostics.map((diagnostic) => ({
+                ...diagnostic,
+                source: diagnostic.source ?? "markdownlint",
+            }));
+        },
+        async provideCodeActions(context, range) {
+            const response = await client.request({
+                type: "code-actions",
+                document: context.document,
+                range,
+                globals: context.globals,
+                rules: resolveMarkdownRules(options),
+            });
+            if (response.type !== "code-actions") {
+                return [];
+            }
+            return response.actions;
+        },
+        dispose() {
+            client.dispose();
+        },
+    };
+}
+export function createNativeMarkdownLanguageServiceProvider(invoke, options = {}) {
+    return {
+        metadata: {
+            id: "markdownlint-native-sidecar",
+            languages: ["markdown"],
+            runtime: "native",
+            priority: 100,
+            capabilities: { diagnostics: true, codeActions: true },
+        },
+        async updateDocument(update) {
+            await invoke("desktop_ls_update_document", {
+                protocolVersion: DESKTOP_LANGUAGE_SERVICE_PROTOCOL_VERSION,
+                document: update.document,
+                globals: [],
+            });
+        },
+        async provideDiagnostics(context) {
+            const raw = await invoke("desktop_ls_diagnostics", {
+                protocolVersion: DESKTOP_LANGUAGE_SERVICE_PROTOCOL_VERSION,
+                document: context.document,
+                rules: resolveMarkdownRules(options),
+                globals: context.globals.map((declaration) => ({
+                    uri: declaration.uri,
+                    text: declaration.text,
+                    version: declaration.version,
+                })),
+            });
+            if (!Array.isArray(raw)) {
+                return [];
+            }
+            return raw;
+        },
+        async provideCodeActions(context, range) {
+            const raw = await invoke("desktop_ls_code_actions", {
+                protocolVersion: DESKTOP_LANGUAGE_SERVICE_PROTOCOL_VERSION,
+                document: context.document,
+                range,
+                rules: resolveMarkdownRules(options),
+                globals: context.globals.map((declaration) => ({
+                    uri: declaration.uri,
+                    text: declaration.text,
+                    version: declaration.version,
+                })),
+            });
+            if (!Array.isArray(raw)) {
+                return [];
+            }
+            return raw;
+        },
+        dispose() {
+            //
+        },
+    };
+}
+export async function probeNativeMarkdownLanguageService(invoke) {
+    try {
+        await invoke("desktop_ls_capabilities", {
+            protocolVersion: DESKTOP_LANGUAGE_SERVICE_PROTOCOL_VERSION,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/markdownlint/options.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Lowercase-first Lapis tag at line start (whole line or prefix before
+ * whitespace).
+ */
+export declare const TAG_PREFIX_PATTERN: RegExp;
+/** ATX heading missing a space after the hash run (same shape as stock MD018). */
+export declare const BAD_ATX_HEADING_PATTERN: RegExp;
+export declare const MD018_RULE_ALIASES: string[];
+declare const md018AllowTagsRule: {
+    names: string[];
+    description: string;
+    tags: string[];
+    parser: "none";
+    function: (params: {
+        lines: readonly string[];
+    }, onError: (error: {
+        lineNumber: number;
+        detail?: string;
+        context?: string;
+        fixInfo?: {
+            editColumn?: number;
+            insertText?: string;
+        };
+    }) => void) => void;
+};
+export declare const LAPIS_MARKDOWNLINT_DEFAULT_CONFIG: {
+    readonly default: true;
+    readonly MD018: false;
+};
+export declare function createMarkdownlintLintOptions(rules?: Record<string, unknown>): {
+    config: Record<string, unknown>;
+    customRules: [typeof md018AllowTagsRule];
+};
+export {};

package/dist/markdownlint/options.js

@@ -0,0 +1,57 @@
+/**
+ * Lowercase-first Lapis tag at line start (whole line or prefix before
+ * whitespace).
+ */
+export const TAG_PREFIX_PATTERN = /^( {0,3})#([a-z][a-z0-9_/-]*)(?:$|\s)/u;
+/** ATX heading missing a space after the hash run (same shape as stock MD018). */
+export const BAD_ATX_HEADING_PATTERN = /^( {0,3})(#{1,6})([^#\s].*)$/u;
+export const MD018_RULE_ALIASES = [
+    "MD018-lapis",
+    "no-missing-space-atx-except-tags",
+];
+const md018AllowTagsRule = {
+    names: MD018_RULE_ALIASES,
+    description: "No space after hash on atx style heading, except lowercase Lapis tag lines",
+    tags: ["atx", "headings", "spaces"],
+    parser: "none",
+    function: (params, onError) => {
+        params.lines.forEach((line, index) => {
+            if (TAG_PREFIX_PATTERN.test(line)) {
+                return;
+            }
+            const match = BAD_ATX_HEADING_PATTERN.exec(line);
+            if (!match) {
+                return;
+            }
+            const indent = match[1] ?? "";
+            const hashes = match[2] ?? "";
+            onError({
+                lineNumber: index + 1,
+                detail: "Expected: space; Actual: no space",
+                context: line,
+                fixInfo: {
+                    editColumn: indent.length + hashes.length + 1,
+                    insertText: " ",
+                },
+            });
+        });
+    },
+};
+export const LAPIS_MARKDOWNLINT_DEFAULT_CONFIG = {
+    default: true,
+    MD018: false,
+};
+export function createMarkdownlintLintOptions(rules) {
+    const config = {
+        ...LAPIS_MARKDOWNLINT_DEFAULT_CONFIG,
+        ...(rules ?? {}),
+    };
+    if (rules?.MD018 === false) {
+        config["MD018-lapis"] = false;
+        config["no-missing-space-atx-except-tags"] = false;
+    }
+    return {
+        config,
+        customRules: [md018AllowTagsRule],
+    };
+}

package/dist/markdownlint/runtime-core.d.ts

@@ -0,0 +1,32 @@
+import type { LanguageServiceCodeAction, LanguageServiceDiagnostic, LanguageServiceRange, VirtualDocument } from "@lapis-notes/api/language-service";
+type MarkdownLintIssue = {
+    lineNumber?: number;
+    errorRange?: [number, number] | null;
+    ruleNames?: string[];
+    ruleName?: string;
+    ruleDescription?: string;
+    errorDetail?: string | null;
+    errorContext?: string | null;
+    fixInfo?: {
+        lineNumber?: number;
+        editColumn?: number;
+        deleteCount?: number;
+        insertText?: string;
+    } | null;
+};
+export declare const MARKDOWN_LINT_DISABLE_RULE_COMMAND = "markdown-lint:disable-rule";
+export declare function markdownlintActionTitle(kind: "fixThis" | "fixAll" | "disableLine" | "disableFile" | "disableVault", rulePath: string): string;
+export declare function markdownCodeActionsFromIssues(document: VirtualDocument, requestedRange: LanguageServiceRange, issues: MarkdownLintIssue[], applyFixesForIssues: (issues: MarkdownLintIssue[]) => string, md018RuleAliases?: string[]): LanguageServiceCodeAction[];
+export declare function markdownDiagnosticsFromIssues(issues: MarkdownLintIssue[]): LanguageServiceDiagnostic[];
+export declare function markdownlintDiagnosticCode(ruleNames: string[] | undefined, ruleName: string | undefined): string | undefined;
+export declare function formatMarkdownlintMessage(issue: MarkdownLintIssue): string;
+export declare function isLineInsideLeadingYamlFrontmatter(text: string, lineIndex: number): boolean;
+export declare function firstContentLineIndex(text: string): number | null;
+export declare function leadingYamlFrontmatterEndLine(text: string): number | null;
+export declare function normalizeMarkdownlintDirectiveAliases(text: string, md018RuleAliases?: string[]): string;
+export declare function toSingleReplacement(before: string, after: string): {
+    from: number;
+    to: number;
+    insert: string;
+} | null;
+export {};

package/dist/markdownlint/runtime-core.js

@@ -0,0 +1,312 @@
+export const MARKDOWN_LINT_DISABLE_RULE_COMMAND = "markdown-lint:disable-rule";
+export function markdownlintActionTitle(kind, rulePath) {
+    switch (kind) {
+        case "fixThis":
+            return `Fix this violation of \`${rulePath}\``;
+        case "fixAll":
+            return `Fix all violations of \`${rulePath}\` in the document`;
+        case "disableLine":
+            return `Disable ${rulePath} for this line`;
+        case "disableFile":
+            return `Disable ${rulePath} for this file`;
+        case "disableVault":
+            return `Disable ${rulePath} in this vault`;
+    }
+}
+export function markdownCodeActionsFromIssues(document, requestedRange, issues, applyFixesForIssues, md018RuleAliases = []) {
+    const intersecting = [];
+    for (const issue of issues) {
+        const diagnostic = toDiagnostic(issue);
+        if (!rangesIntersect(diagnostic.range, requestedRange)) {
+            continue;
+        }
+        intersecting.push({
+            issue,
+            diagnostic,
+            code: diagnostic.code != null ? String(diagnostic.code) : "issue",
+        });
+    }
+    const groups = new Map();
+    for (const entry of intersecting) {
+        const group = groups.get(entry.code) ?? [];
+        group.push(entry);
+        groups.set(entry.code, group);
+    }
+    const actions = [];
+    for (const [code, group] of groups) {
+        const diagnostics = group.map((entry) => entry.diagnostic);
+        const rulePath = markdownlintRulePath(group[0].issue);
+        for (const entry of group) {
+            if (!entry.issue.fixInfo)
+                continue;
+            const updatedText = applyFixesForIssues([entry.issue]);
+            const change = toSingleReplacement(document.text, updatedText);
+            if (change) {
+                actions.push({
+                    title: markdownlintActionTitle("fixThis", rulePath),
+                    kind: "quickfix",
+                    diagnostics: [entry.diagnostic],
+                    edit: { changes: [change] },
+                });
+            }
+        }
+        const documentFixable = issues.filter((issue) => (markdownlintDiagnosticCode(issue.ruleNames, issue.ruleName) ??
+            "issue") === code && issue.fixInfo);
+        if (documentFixable.length > 1) {
+            const updatedText = applyFixesForIssues(documentFixable);
+            const change = toSingleReplacement(document.text, updatedText);
+            if (change) {
+                actions.push({
+                    title: markdownlintActionTitle("fixAll", rulePath),
+                    kind: "quickfix",
+                    diagnostics,
+                    edit: { changes: [change] },
+                });
+            }
+        }
+        if (code === "issue") {
+            continue;
+        }
+        const ignoreNextLineChange = createIgnoreNextLineChange(document.text, group[0].diagnostic.range.start.line, code);
+        if (ignoreNextLineChange) {
+            actions.push({
+                title: markdownlintActionTitle("disableLine", rulePath),
+                kind: "quickfix",
+                diagnostics,
+                edit: { changes: [ignoreNextLineChange] },
+            });
+        }
+        const ignoreFileChange = createIgnoreFileChange(document.text, code, md018RuleAliases);
+        if (ignoreFileChange) {
+            actions.push({
+                title: markdownlintActionTitle("disableFile", rulePath),
+                kind: "quickfix",
+                diagnostics,
+                edit: { changes: [ignoreFileChange] },
+            });
+        }
+        actions.push({
+            title: markdownlintActionTitle("disableVault", rulePath),
+            kind: "quickfix",
+            diagnostics,
+            command: {
+                id: MARKDOWN_LINT_DISABLE_RULE_COMMAND,
+                arguments: [code],
+            },
+        });
+    }
+    return actions;
+}
+export function markdownDiagnosticsFromIssues(issues) {
+    return issues.map((issue) => toDiagnostic(issue));
+}
+export function markdownlintDiagnosticCode(ruleNames, ruleName) {
+    const code = ruleNames?.[0] ?? ruleName;
+    if (code === "MD018-lapis" || code === "no-missing-space-atx-except-tags") {
+        return "MD018";
+    }
+    return code;
+}
+function toDiagnostic(issue) {
+    const startLine = Math.max(0, (issue.lineNumber ?? 1) - 1);
+    const range = issue.errorRange;
+    const startColumn = Math.max(0, range ? range[0] - 1 : 0);
+    const length = Math.max(1, range ? range[1] : 1);
+    return {
+        range: {
+            start: { line: startLine, character: startColumn },
+            end: { line: startLine, character: startColumn + length },
+        },
+        source: "markdownlint",
+        code: markdownlintDiagnosticCode(issue.ruleNames, issue.ruleName),
+        severity: "warning",
+        message: formatMarkdownlintMessage(issue),
+    };
+}
+function markdownlintRulePath(issue) {
+    const names = (issue.ruleNames ?? (issue.ruleName ? [issue.ruleName] : [])).map((name) => (name === "MD018-lapis" ? "MD018" : name));
+    const unique = [...new Set(names)];
+    if (unique.length === 0) {
+        return (markdownlintDiagnosticCode(issue.ruleNames, issue.ruleName) ?? "issue");
+    }
+    return unique.join("/");
+}
+export function formatMarkdownlintMessage(issue) {
+    const description = issue.ruleDescription?.trim();
+    if (!description) {
+        return issue.errorDetail ?? "Markdown lint issue";
+    }
+    const path = markdownlintRulePath(issue);
+    const detail = issue.errorDetail?.trim();
+    return detail
+        ? `${path}: ${description} [${detail}]`
+        : `${path}: ${description}`;
+}
+function createIgnoreNextLineChange(text, targetLine, code) {
+    const lines = parseLines(text);
+    if (targetLine < 0 ||
+        targetLine >= lines.length ||
+        isLineInsideLeadingYamlFrontmatter(text, targetLine)) {
+        return null;
+    }
+    const lineBreak = detectLineBreak(lines);
+    const disableCodes = [code];
+    if (firstContentLineIndex(text) === targetLine &&
+        !disableCodes.includes("MD041")) {
+        disableCodes.push("MD041");
+    }
+    return {
+        from: lines[targetLine].start,
+        to: lines[targetLine].start,
+        insert: `<!-- markdownlint-disable-next-line ${disableCodes.join(" ")} -->${lineBreak}`,
+    };
+}
+function createIgnoreFileChange(text, code, md018RuleAliases = []) {
+    const lines = parseLines(text);
+    const lineBreak = detectLineBreak(lines);
+    const targetLine = firstContentLineIndex(text);
+    const disableCodes = [code];
+    if (targetLine === 0 && !disableCodes.includes("MD041")) {
+        disableCodes.push("MD041");
+    }
+    if (code === "MD018") {
+        for (const alias of md018RuleAliases) {
+            if (!disableCodes.includes(alias)) {
+                disableCodes.push(alias);
+            }
+        }
+    }
+    if (targetLine === null) {
+        const prefix = text.length === 0 || hasTrailingLineBreak(text) ? "" : lineBreak;
+        return {
+            from: text.length,
+            to: text.length,
+            insert: `${prefix}<!-- markdownlint-disable-file ${disableCodes.join(" ")} -->`,
+        };
+    }
+    return {
+        from: lines[targetLine].start,
+        to: lines[targetLine].start,
+        insert: `<!-- markdownlint-disable-file ${disableCodes.join(" ")} -->${lineBreak}`,
+    };
+}
+export function isLineInsideLeadingYamlFrontmatter(text, lineIndex) {
+    const endLine = leadingYamlFrontmatterEndLine(text);
+    return endLine !== null && lineIndex <= endLine;
+}
+export function firstContentLineIndex(text) {
+    const lines = parseLines(text);
+    const frontmatterEndLine = leadingYamlFrontmatterEndLine(text);
+    let index = frontmatterEndLine === null ? 0 : frontmatterEndLine + 1;
+    while (index < lines.length && lines[index].text.trim().length === 0) {
+        index += 1;
+    }
+    return index < lines.length ? index : null;
+}
+export function leadingYamlFrontmatterEndLine(text) {
+    const lines = parseLines(text);
+    if (!lines.length || lines[0].text.trim() !== "---") {
+        return null;
+    }
+    for (let index = 1; index < lines.length; index += 1) {
+        const trimmed = lines[index].text.trim();
+        if (trimmed === "---" || trimmed === "...") {
+            return index;
+        }
+    }
+    return lines.length - 1;
+}
+function parseLines(text) {
+    if (text.length === 0) {
+        return [{ text: "", start: 0, end: 0, fullEnd: 0, newline: "" }];
+    }
+    const lines = [];
+    let start = 0;
+    while (start <= text.length) {
+        let end = start;
+        while (end < text.length && text[end] !== "\n" && text[end] !== "\r") {
+            end += 1;
+        }
+        let fullEnd = end;
+        if (fullEnd < text.length) {
+            if (text[fullEnd] === "\r" && text[fullEnd + 1] === "\n") {
+                fullEnd += 2;
+            }
+            else {
+                fullEnd += 1;
+            }
+        }
+        lines.push({
+            text: text.slice(start, end),
+            start,
+            end,
+            fullEnd,
+            newline: text.slice(end, fullEnd),
+        });
+        if (fullEnd >= text.length) {
+            break;
+        }
+        start = fullEnd;
+    }
+    return lines;
+}
+function detectLineBreak(lines) {
+    for (const line of lines) {
+        if (line.newline) {
+            return line.newline;
+        }
+    }
+    return "\n";
+}
+function hasTrailingLineBreak(text) {
+    return /(?:\r\n|\n|\r)$/u.test(text);
+}
+export function normalizeMarkdownlintDirectiveAliases(text, md018RuleAliases = []) {
+    return text.replace(/<!--\s*(markdownlint-[a-z-]+)(\s+[^>]*)?-->/gu, (match, directive, rawRules = "") => {
+        const rules = rawRules.trim().split(/\s+/u).filter(Boolean);
+        if (!rules.includes("MD018")) {
+            return match;
+        }
+        const expandedRules = [...rules];
+        for (const alias of md018RuleAliases) {
+            if (!expandedRules.includes(alias)) {
+                expandedRules.push(alias);
+            }
+        }
+        return `<!-- ${directive} ${expandedRules.join(" ")} -->`;
+    });
+}
+function rangesIntersect(left, right) {
+    return (comparePositions(left.start, right.end) <= 0 &&
+        comparePositions(right.start, left.end) <= 0);
+}
+function comparePositions(left, right) {
+    if (left.line !== right.line) {
+        return left.line - right.line;
+    }
+    return left.character - right.character;
+}
+export function toSingleReplacement(before, after) {
+    if (before === after) {
+        return null;
+    }
+    let start = 0;
+    while (start < before.length &&
+        start < after.length &&
+        before[start] === after[start]) {
+        start += 1;
+    }
+    let beforeEnd = before.length;
+    let afterEnd = after.length;
+    while (beforeEnd > start &&
+        afterEnd > start &&
+        before[beforeEnd - 1] === after[afterEnd - 1]) {
+        beforeEnd -= 1;
+        afterEnd -= 1;
+    }
+    return {
+        from: start,
+        to: beforeEnd,
+        insert: after.slice(start, afterEnd),
+    };
+}

package/dist/markdownlint/runtime.d.ts

@@ -0,0 +1,5 @@
+import type { LanguageServiceCodeAction, LanguageServiceDiagnostic, LanguageServiceRange, VirtualDocument } from "@lapis-notes/api/language-service";
+import { markdownlintActionTitle, MARKDOWN_LINT_DISABLE_RULE_COMMAND } from "./runtime-core";
+export { markdownlintActionTitle, MARKDOWN_LINT_DISABLE_RULE_COMMAND, };
+export declare function markdownDiagnosticsForDocument(document: VirtualDocument, rules?: Record<string, unknown>): LanguageServiceDiagnostic[];
+export declare function markdownCodeActionsForDocument(document: VirtualDocument, requestedRange: LanguageServiceRange, rules?: Record<string, unknown>): LanguageServiceCodeAction[];

package/dist/markdownlint/runtime.js

@@ -0,0 +1,20 @@
+import { applyFixes } from "markdownlint";
+import { lint } from "markdownlint/sync";
+import { createMarkdownlintLintOptions, MD018_RULE_ALIASES } from "./options";
+import { markdownCodeActionsFromIssues, markdownDiagnosticsFromIssues, markdownlintActionTitle, MARKDOWN_LINT_DISABLE_RULE_COMMAND, normalizeMarkdownlintDirectiveAliases, } from "./runtime-core";
+export { markdownlintActionTitle, MARKDOWN_LINT_DISABLE_RULE_COMMAND, };
+function getMarkdownLintIssues(document, rules) {
+    const text = normalizeMarkdownlintDirectiveAliases(document.text, MD018_RULE_ALIASES);
+    const result = lint({
+        strings: { [document.uri]: text },
+        ...createMarkdownlintLintOptions(rules),
+    });
+    return (result[document.uri] ?? []);
+}
+export function markdownDiagnosticsForDocument(document, rules) {
+    return markdownDiagnosticsFromIssues(getMarkdownLintIssues(document, rules));
+}
+export function markdownCodeActionsForDocument(document, requestedRange, rules) {
+    const issues = getMarkdownLintIssues(document, rules);
+    return markdownCodeActionsFromIssues(document, requestedRange, issues, (fixable) => applyFixes(document.text, fixable), MD018_RULE_ALIASES);
+}

package/dist/workers/markdownlint.worker.d.ts

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

package/dist/workers/markdownlint.worker.js

@@ -0,0 +1,33 @@
+import { registerLanguageServiceWorker } from "./protocol";
+import { installWorkerEntityDecoderDocumentShim } from "./worker-entity-decoder";
+installWorkerEntityDecoderDocumentShim();
+const markdownlintRuntime = import("../markdownlint/runtime");
+const documents = new Map();
+registerLanguageServiceWorker({
+    "document/update"(request) {
+        documents.set(request.document.uri, request.document);
+        return { type: "document/update", ok: true };
+    },
+    async diagnostics(request) {
+        documents.set(request.document.uri, request.document);
+        return {
+            type: "diagnostics",
+            diagnostics: await lintMarkdown(request.document, request.rules),
+        };
+    },
+    async "code-actions"(request) {
+        documents.set(request.document.uri, request.document);
+        return {
+            type: "code-actions",
+            actions: await codeActionsForMarkdown(request.document, request.range, request.rules),
+        };
+    },
+});
+async function lintMarkdown(document, rules) {
+    const { markdownDiagnosticsForDocument } = await markdownlintRuntime;
+    return markdownDiagnosticsForDocument(document, rules);
+}
+async function codeActionsForMarkdown(document, requestedRange, rules) {
+    const { markdownCodeActionsForDocument } = await markdownlintRuntime;
+    return markdownCodeActionsForDocument(document, requestedRange, rules);
+}

package/dist/workers/protocol.d.ts

@@ -0,0 +1,12 @@
+import type { LanguageServiceWorkerRequest, LanguageServiceWorkerResponse } from "@lapis-notes/api/language-service";
+type WorkerHandlers = {
+    [K in LanguageServiceWorkerRequest["type"]]: (request: Extract<LanguageServiceWorkerRequest, {
+        type: K;
+    }>) => Promise<Extract<LanguageServiceWorkerResponse, {
+        type: K;
+    }>> | Extract<LanguageServiceWorkerResponse, {
+        type: K;
+    }>;
+};
+export declare function registerLanguageServiceWorker(handlers: Partial<WorkerHandlers>): void;
+export {};

package/dist/workers/protocol.js

@@ -0,0 +1,23 @@
+export function registerLanguageServiceWorker(handlers) {
+    self.onmessage = async (event) => {
+        const { id, payload } = event.data;
+        try {
+            const handler = handlers[payload.type];
+            if (!handler)
+                throw new Error(`Unknown language service worker request: ${payload.type}`);
+            const workerHandler = handler;
+            postMessage({
+                id,
+                ok: true,
+                payload: await workerHandler(payload),
+            });
+        }
+        catch (error) {
+            postMessage({
+                id,
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    };
+}

package/dist/workers/worker-entity-decoder.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Unified's entity decoder selects its DOM implementation under a browser
+ * export condition, even when Vite is compiling a Web Worker. Provide the
+ * single element contract that implementation needs before markdownlint is
+ * loaded, without introducing a real DOM dependency into the worker.
+ */
+export declare function installWorkerEntityDecoderDocumentShim(): void;

package/dist/workers/worker-entity-decoder.js

@@ -0,0 +1,37 @@
+import { characterEntities } from "character-entities";
+/**
+ * Unified's entity decoder selects its DOM implementation under a browser
+ * export condition, even when Vite is compiling a Web Worker. Provide the
+ * single element contract that implementation needs before markdownlint is
+ * loaded, without introducing a real DOM dependency into the worker.
+ */
+export function installWorkerEntityDecoderDocumentShim() {
+    const workerGlobal = globalThis;
+    if (workerGlobal.document)
+        return;
+    const documentShim = {
+        compatMode: "CSS1Compat",
+        createElement() {
+            let decodedText = "";
+            return {
+                set innerHTML(value) {
+                    const match = /^&([^;]+);$/u.exec(value);
+                    decodedText = match
+                        ? (characterEntities[match[1]] ??
+                            value)
+                        : value;
+                },
+                get innerHTML() {
+                    return decodedText;
+                },
+                get textContent() {
+                    return decodedText;
+                },
+            };
+        },
+    };
+    Object.defineProperty(workerGlobal, "document", {
+        configurable: true,
+        value: documentShim,
+    });
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@lapis-notes/language-service",
+  "version": "0.1.0",
+  "description": "Provider-neutral Markdown language services for Lapis applications",
+  "license": "AGPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lapismd/lapis-notes.git",
+    "directory": "packages/language-service"
+  },
+  "homepage": "https://github.com/lapismd/lapis-notes/tree/main/packages/language-service#readme",
+  "bugs": {
+    "url": "https://github.com/lapismd/lapis-notes/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "files": [
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE.md",
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./markdown": {
+      "types": "./dist/markdown.d.ts",
+      "import": "./dist/markdown.js",
+      "default": "./dist/markdown.js"
+    },
+    "./markdownlint/runtime": {
+      "types": "./dist/markdownlint/runtime.d.ts",
+      "import": "./dist/markdownlint/runtime.js",
+      "default": "./dist/markdownlint/runtime.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "markdownlint/runtime": [
+        "dist/markdownlint/runtime.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@lapis-notes/api": "^0.1.0",
+    "character-entities": "^2.0.2",
+    "markdownlint": "^0.40.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "publint": "^0.3.12",
+    "typescript": "~5.9.3",
+    "vite": "^6.4.2",
+    "vitest": "^4.1.8"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "pnpm check:types",
+    "check:types": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}