@lincyaw/language-server 0.0.0-stage → 1.0.0-rc.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,21 @@
-# Temporary Holding Version
+# @lincyaw/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.
+The language server of Presmium documents: diagnostics, anchor definitions and hovers, completion of directives, options and anchors, and the preview that follows the cursor.
+
+Part of [Presmium](https://github.com/Lincyaw/presmium), which turns lectures written in MyST Markdown into web pages, slides, Jupyter notebooks and narrated lectures.
+
+## Usage
+
+```sh
+pnpm exec presmium-language-server --stdio
+```
+
+It also takes `--node-ipc` and `--socket=<port>`. The VS Code extension starts it; other editors start it as a language server for Markdown files.
+
+## Documentation
+
+- [Author guide](https://github.com/Lincyaw/presmium/blob/main/site/guide/lecture.en.md)
+
+## License
+
+Apache-2.0

package/bin/presmium-language-server.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { createJiti } from 'jiti'
+
+console.log = console.info = console.debug = console.error
+
+const emitWarning = process.emitWarning
+process.emitWarning = (warning, ...args) => {
+  const code = typeof args[0] === 'object' ? args[0]?.code : args[1]
+  if (code !== 'DEP0040') emitWarning.call(process, warning, ...args)
+}
+
+const jiti = createJiti(import.meta.url)
+const { startServer } = await jiti.import('../src/node/server.ts')
+startServer()

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@lincyaw/language-server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0-rc.0",
+  "description": "Language server for Presmium documents: diagnostics, anchor definitions and hovers, completion and preview sync",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lincyaw/presmium.git",
+    "directory": "packages/language-server"
+  },
+  "homepage": "https://github.com/Lincyaw/presmium/tree/main/packages/language-server#readme",
+  "bugs": "https://github.com/Lincyaw/presmium/issues",
+  "keywords": [
+    "presmium",
+    "lsp",
+    "language-server"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=22.19"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "presmium-language-server": "./bin/presmium-language-server.mjs"
+  },
+  "exports": {
+    "./domain": "./src/domain/index.ts",
+    "./protocol": "./src/domain/protocol.ts",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "dependencies": {
+    "jiti": "^2.7.0",
+    "vscode-languageserver": "10.1.2",
+    "vscode-languageserver-textdocument": "1.0.15",
+    "@lincyaw/cli": "1.0.0-rc.0",
+    "@lincyaw/kernel": "1.0.0-rc.0",
+    "@lincyaw/compiler": "1.0.0-rc.0",
+    "@lincyaw/web": "1.0.0-rc.0",
+    "@lincyaw/host": "1.0.0-rc.0",
+    "@lincyaw/viewer": "1.0.0-rc.0"
+  },
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.json"
+  }
 }

package/src/domain/directives.ts

@@ -0,0 +1,35 @@
+import type { DirectiveOptionType, DirectiveSpec } from '@lincyaw/kernel'
+
+export interface OptionInfo {
+  type?: DirectiveOptionType
+  doc?: string
+  values?: string[]
+}
+
+export interface DirectiveInfo {
+  name: string
+  source: string
+  doc?: string
+  options: Record<string, OptionInfo>
+  anchor?: boolean
+}
+
+export function directiveInfos(builtin: readonly DirectiveInfo[], plugins: { plugin: string, directives: readonly DirectiveSpec[] }[], run?: OptionInfo): Map<string, DirectiveInfo> {
+  const infos = new Map(builtin.map(info => [info.name, info]))
+  for (const { plugin, directives } of plugins) {
+    for (const spec of directives) {
+      if (infos.has(spec.name)) continue
+      const options = Object.fromEntries(Object.entries(spec.options ?? {}).map(([name, type]): [string, OptionInfo] => [name, name === 'run' && run ? { ...run, type } : { type }]))
+      infos.set(spec.name, { name: spec.name, source: plugin, options, ...spec.arg === 'anchor' ? { anchor: true } : {} })
+    }
+  }
+  return infos
+}
+
+export function optionsOf(info: DirectiveInfo, common: Record<string, OptionInfo>): Record<string, OptionInfo> {
+  return { ...common, ...info.options }
+}
+
+export function anchorDirectives(infos: Map<string, DirectiveInfo>): Set<string> {
+  return new Set([...infos.values()].filter(info => info.anchor).map(info => info.name))
+}

package/src/domain/index.ts

@@ -0,0 +1,11 @@
+export { anchorDirectives, directiveInfos, optionsOf } from './directives.ts'
+export type { DirectiveInfo, OptionInfo } from './directives.ts'
+export { LS_MESSAGES } from './messages.ts'
+export type { LsMessages } from './messages.ts'
+export { declarationNames, regionNames } from './names.ts'
+export { previewUrl } from './preview.ts'
+export { PREVIEW_REQUEST, SECTION_REQUEST } from './protocol.ts'
+export type { DocumentParams, PositionParams, Preview, SectionAt } from './protocol.ts'
+export { blockAt, sectionAt } from './sections.ts'
+export { anchorAt, directiveAt, fenceAt, typingAt, writtenOptions } from './syntax.ts'
+export type { AnchorRef, Fence, Typing } from './syntax.ts'

package/src/domain/messages.ts

@@ -0,0 +1,38 @@
+import type { Locale } from '@lincyaw/kernel'
+
+export const LS_MESSAGES = {
+  'zh-CN': {
+    status: { exact: '已解析', moved: '已移动', fuzzy: '待确认', lost: '已失效' } as Record<string, string>,
+    pinnedAt: (commit: string) => `锁定在 ${commit}`,
+    drifted: '锁定之后已漂移',
+    recordedOutput: '录制的输出',
+    timedOut: '超时',
+    exitCode: (code: number | null) => `退出码 ${code}`,
+    noOutput: '（没有输出）',
+    runsLive: '*在浏览器中执行（`:run: live`），没有录制的输出。*',
+    notRecorded: '*还没有录制的输出。*',
+    moreLines: (count: number) => `…… 另有 ${count} 行`,
+    anchorScheme: '锚点类型',
+    options: '选项',
+    suggest: '提示',
+    builtIn: '内置',
+  },
+  'en': {
+    status: { exact: 'exact', moved: 'moved', fuzzy: 'to confirm', lost: 'lost' } as Record<string, string>,
+    pinnedAt: (commit: string) => `pinned at ${commit}`,
+    drifted: 'drifted since the pin',
+    recordedOutput: 'Recorded output',
+    timedOut: 'timed out',
+    exitCode: (code: number | null) => `exit code ${code}`,
+    noOutput: '(no output)',
+    runsLive: '*Runs in the browser (`:run: live`); no recorded output.*',
+    notRecorded: '*No recorded output yet.*',
+    moreLines: (count: number) => `… ${count} more lines`,
+    anchorScheme: 'anchor scheme',
+    options: 'Options',
+    suggest: 'Suggest',
+    builtIn: 'built-in',
+  },
+} satisfies Record<Locale, unknown>
+
+export type LsMessages = (typeof LS_MESSAGES)[Locale]

package/src/domain/names.ts

@@ -0,0 +1,27 @@
+const REGION = /(?<![A-Za-z])#?region\b[ \t]*(.*?)[ \t]*(?:-->|\*\/|\*\))?[ \t]*$/i
+
+export function regionNames(text: string): string[] {
+  const names = text.split(/\r?\n/).map(line => REGION.exec(line)?.[1] ?? '').filter(Boolean)
+  return [...new Set(names)]
+}
+
+const DECLARATION = /\b(class|def|function\*?|interface|type|enum|namespace|const|let|var)\s+([A-Za-z_$][\w$]*)/
+const MEMBER = /^\s+(?:(?:export|public|private|protected|static|readonly|async|abstract|override|declare|get|set|def)\s+)*\*?([A-Za-z_$][\w$]*)\s*[(<:=?!]/
+const ASSIGNMENT = /^([A-Za-z_]\w*)\s*(?::[^=]*)?=(?!=)/
+const KEYWORDS = new Set(['if', 'for', 'while', 'switch', 'catch', 'return', 'else', 'elif', 'with', 'try', 'new', 'await', 'yield', 'throw', 'print', 'self', 'this', 'super'])
+
+export function declarationNames(text: string): string[] {
+  const names = new Set<string>()
+  const classes: { name: string, indent: number }[] = []
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue
+    const indent = /^[ \t]*/.exec(line)![0].length
+    while (classes.length > 0 && indent <= classes.at(-1)!.indent) classes.pop()
+    const declared = DECLARATION.exec(line)
+    const name = declared?.[2] ?? (classes.length > 0 ? MEMBER.exec(line)?.[1] : ASSIGNMENT.exec(line)?.[1])
+    if (!name || KEYWORDS.has(name)) continue
+    names.add([...classes.map(c => c.name), name].join('.'))
+    if (declared?.[1] === 'class') classes.push({ name, indent })
+  }
+  return [...names]
+}

package/src/domain/preview.ts

@@ -0,0 +1,11 @@
+import type { SectionAt } from './protocol.ts'
+
+const page = (link: string) => link.split('#')[0]!
+
+export function previewUrl(base: string, section: SectionAt | null | undefined, shown?: SectionAt): string {
+  const root = base.replace(/\/?$/, '/')
+  if (!section) return root
+  const id = encodeURIComponent(section.id)
+  const target = shown && page(shown.link) === page(section.link) ? `${page(section.link)}#${id}` : `${page(section.link)}?section=${id}`
+  return new URL(target.replace(/^\//, ''), root).href
+}

package/src/domain/protocol.ts

@@ -0,0 +1,24 @@
+export interface DocumentParams {
+  textDocument: { uri: string }
+}
+
+export interface PositionParams extends DocumentParams {
+  position: { line: number, character: number }
+}
+
+export const PREVIEW_REQUEST = 'presmium/preview'
+
+export interface Preview {
+  entry: string
+  url: string
+}
+
+export const SECTION_REQUEST = 'presmium/section'
+
+export interface SectionAt {
+  entry: string
+  id: string
+  index: number
+  title: string
+  link: string
+}

package/src/domain/sections.ts

@@ -0,0 +1,26 @@
+import { irBlocks } from '@lincyaw/kernel'
+import type { IRBlock, IRDocument, IRSection } from '@lincyaw/kernel'
+
+export function sectionAt(doc: IRDocument, file: string, line: number): IRSection | undefined {
+  const headed = doc.sections.filter(s => s.source.file === file && s.source.line <= line).at(-1)
+  if (headed) return headed
+  let first: IRSection | undefined
+  let last: { section: IRSection, line: number } | undefined
+  for (const section of doc.sections) {
+    for (const block of irBlocks(section.blocks)) {
+      if (block.source.file !== file) continue
+      first ??= section
+      if (block.source.line <= line && block.source.line >= (last?.line ?? 0)) last = { section, line: block.source.line }
+    }
+  }
+  return last?.section ?? first ?? (file === doc.meta.entry ? doc.sections[0] : undefined)
+}
+
+export function blockAt(doc: IRDocument, file: string, line: number): IRBlock | undefined {
+  for (const section of doc.sections) {
+    for (const block of irBlocks(section.blocks)) {
+      if (block.source.file === file && block.source.line === line) return block
+    }
+  }
+  return undefined
+}

package/src/domain/syntax.ts

@@ -0,0 +1,84 @@
+export interface Fence {
+  line: number
+  name: string
+  nameStart: number
+  arg: string
+  argStart: number
+}
+
+const FENCE = /^([ \t]*(?:`{3,}|~{3,}|:{3,})\{)([^{}\s]*)\}(.*)$/
+const OPTION = /^[ \t]*:[\w-]*(?::.*)?$/
+
+export function fenceAt(lines: readonly string[], line: number): Fence | undefined {
+  const match = FENCE.exec(lines[line] ?? '')
+  if (!match) return undefined
+  const [, open, name, rest] = match as unknown as [string, string, string, string]
+  const after = open.length + name.length + 1
+  return { line, name, nameStart: open.length, arg: rest.trim(), argStart: after + rest.length - rest.trimStart().length }
+}
+
+export function directiveAt(lines: readonly string[], line: number): Fence | undefined {
+  for (let i = line; i >= 0; i--) {
+    const fence = fenceAt(lines, i)
+    if (fence) return fence
+    if (!OPTION.test(lines[i] ?? '')) return undefined
+  }
+  return undefined
+}
+
+export function writtenOptions(lines: readonly string[], fence: Fence): string[] {
+  const names: string[] = []
+  for (let i = fence.line + 1; i < lines.length && OPTION.test(lines[i]!); i++) {
+    const name = /^[ \t]*:([\w-]+):/.exec(lines[i]!)?.[1]
+    if (name) names.push(name)
+  }
+  return names
+}
+
+export interface AnchorRef {
+  anchor: `${string}:${string}`
+  scheme: string
+  line: number
+  start: number
+  end: number
+}
+
+export function anchorAt(lines: readonly string[], line: number, schemes: readonly string[] = [], anchors: ReadonlySet<string> = new Set()): AnchorRef | undefined {
+  const fence = fenceAt(lines, line)
+  const word = (fence && anchors.has(fence.name) ? fence.arg : fence?.arg.split(/\s/)[0]) ?? ''
+  const colon = word.indexOf(':')
+  if (!fence || colon <= 0) return undefined
+  const scheme = word.slice(0, colon)
+  if (!anchors.has(fence.name) && !schemes.includes(scheme)) return undefined
+  return { anchor: word as AnchorRef['anchor'], scheme, line, start: fence.argStart, end: fence.argStart + word.length }
+}
+
+export type Typing =
+  | { kind: 'directive', prefix: string, start: number, closed: boolean }
+  | { kind: 'argument', fence: Fence, prefix: string, start: number }
+  | { kind: 'option', fence: Fence, prefix: string, start: number, written: string[] }
+  | { kind: 'value', fence: Fence, option: string, prefix: string, start: number }
+
+export function typingAt(lines: readonly string[], line: number, character: number): Typing | undefined {
+  const text = lines[line] ?? ''
+  const before = text.slice(0, character)
+  const opening = /^[ \t]*(?:`{3,}|~{3,}|:{3,})\{([\w-]*)$/.exec(before)
+  if (opening) return { kind: 'directive', prefix: opening[1]!, start: character - opening[1]!.length, closed: text[character] === '}' }
+
+  const fence = fenceAt(lines, line)
+  if (fence) {
+    const brace = fence.nameStart + fence.name.length
+    if (character <= brace) return undefined
+    const prefix = before.slice(brace + 1).trimStart()
+    return { kind: 'argument', fence, prefix, start: character - prefix.length }
+  }
+
+  const directive = directiveAt(lines, line)
+  if (!directive) return undefined
+  const option = /^[ \t]*:([\w-]*)$/.exec(before)
+  if (option) return { kind: 'option', fence: directive, prefix: option[1]!, start: character - option[1]!.length, written: writtenOptions(lines, directive) }
+  const value = /^[ \t]*:([\w-]+):[ \t]*(.*)$/.exec(before)
+  if (!value) return undefined
+  const prefix = value[2]!.split(',').at(-1)!.trimStart()
+  return { kind: 'value', fence: directive, option: value[1]!, prefix, start: character - prefix.length }
+}

package/src/node/anchors.ts

@@ -0,0 +1,121 @@
+import { readdir } from 'node:fs/promises'
+import { isAbsolute, relative, resolve, sep } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import type { Compilation } from '@lincyaw/compiler'
+import { isRenderable } from '@lincyaw/kernel'
+import type { AnchorString, CodeNode, Resolution, ResolvedLocation } from '@lincyaw/kernel'
+import { CompletionItemKind, MarkupKind } from 'vscode-languageserver/node'
+import type { CompletionItem, Hover, Location, Range } from 'vscode-languageserver/node'
+import { blockAt, declarationNames, regionNames } from '../domain/index.ts'
+import type { AnchorRef, LsMessages } from '../domain/index.ts'
+
+const MAX_NAMES = 200
+const MAX_LINES = 60
+
+const suggest = (t: LsMessages) => ({ title: t.suggest, command: 'editor.action.triggerSuggest' })
+
+function resolveAnchor(compilation: Compilation, anchor: AnchorString): Promise<Resolution> {
+  return compilation.resolvers.resolve(anchor, compilation.src, compilation.lock.get(anchor))
+}
+
+function locationOf(compilation: Compilation, location: ResolvedLocation): Location {
+  const last = location.text.split(/\r?\n/).at(-1) ?? ''
+  return {
+    uri: pathToFileURL(resolve(compilation.workspaceRoot, location.file)).href,
+    range: { start: { line: location.startLine - 1, character: 0 }, end: { line: location.endLine - 1, character: last.length } },
+  }
+}
+
+export async function anchorDefinition(compilation: Compilation, ref: AnchorRef): Promise<Location[]> {
+  const resolution = await resolveAnchor(compilation, ref.anchor)
+  const found = resolution.location ? [resolution.location] : resolution.candidates ?? []
+  return found.map(location => locationOf(compilation, location))
+}
+
+function fenced(t: LsMessages, text: string, lang = ''): string {
+  const lines = text.replace(/\n+$/, '').split('\n')
+  const shown = lines.length > MAX_LINES ? [...lines.slice(0, MAX_LINES), t.moreLines(lines.length - MAX_LINES)] : lines
+  const fence = '`'.repeat(Math.max(3, ...[...text.matchAll(/`+/g)].map(m => m[0].length + 1)))
+  return `${fence}${lang}\n${shown.join('\n')}\n${fence}`
+}
+
+function where(file: string, startLine: number, endLine: number): string {
+  return `\`${file}:${startLine}-${endLine}\``
+}
+
+export async function anchorHover(compilation: Compilation, file: string, ref: AnchorRef, t: LsMessages): Promise<Hover> {
+  const range: Range = { start: { line: ref.line, character: ref.start }, end: { line: ref.line, character: ref.end } }
+  const block = blockAt(compilation.doc, file, ref.line + 1)
+  const node = block?.node.type === 'code' && block.node.origin?.anchor === ref.anchor ? block.node : undefined
+  const parts = node?.origin && node.origin.startLine > 0 ? codeNodeHover(node, t) : await resolvedHover(compilation, ref, t)
+  return { contents: { kind: MarkupKind.Markdown, value: parts.join('\n\n') }, range }
+}
+
+function codeNodeHover(node: CodeNode, t: LsMessages): string[] {
+  const origin = node.origin!
+  const notes = [t.status[origin.status] ?? origin.status, origin.pin && t.pinnedAt(origin.pin.slice(0, 7)), origin.drift === 'drifted' && t.drifted].filter(Boolean)
+  const parts = [`**${origin.anchor}** ${where(origin.file, origin.startLine, origin.endLine)} (${notes.join(', ')})`, fenced(t, node.value, node.lang)]
+  const run = node.outputs?.[0]
+  if (run) {
+    const status = run.timedOut ? t.timedOut : run.ok ? `${run.durationMs} ms` : t.exitCode(run.exitCode)
+    parts.push(`**${t.recordedOutput}** (${run.executorId}, ${status})`, fenced(t, [run.stdout, run.stderr].filter(Boolean).join('\n') || t.noOutput))
+  } else if (node.run) {
+    parts.push(node.run.when === 'live' ? t.runsLive : t.notRecorded)
+  }
+  return parts
+}
+
+async function resolvedHover(compilation: Compilation, ref: AnchorRef, t: LsMessages): Promise<string[]> {
+  const resolution = await resolveAnchor(compilation, ref.anchor)
+  const { location } = resolution
+  const parts = [[`**${ref.anchor}**`, location && where(location.file, location.startLine, location.endLine), `(${t.status[resolution.status] ?? resolution.status})`].filter(Boolean).join(' ')]
+  if (resolution.message) parts.push(resolution.message)
+  if (location && isRenderable(resolution)) parts.push(fenced(t, location.text, /\.([\w-]+)$/.exec(location.file)?.[1] ?? ''))
+  return parts
+}
+
+export async function anchorCompletion(compilation: Compilation, prefix: string, line: number, start: number, end: number, t: LsMessages): Promise<CompletionItem[]> {
+  const edit = (from: number, newText: string) => ({ range: { start: { line, character: from }, end: { line, character: end } }, newText })
+  const colon = prefix.indexOf(':')
+  if (colon < 0) {
+    return compilation.resolvers.schemes().map(scheme => ({ label: `${scheme}:`, kind: CompletionItemKind.Keyword, detail: t.anchorScheme, textEdit: edit(start, `${scheme}:`), command: suggest(t) }))
+  }
+  const scheme = prefix.slice(0, colon)
+  const target = prefix.slice(colon + 1)
+  const hash = target.lastIndexOf('#')
+
+  if (hash < 0) {
+    const dir = target.slice(0, target.lastIndexOf('/') + 1)
+    const path = resolve(compilation.workspaceRoot, dir)
+    const inside = relative(compilation.workspaceRoot, path)
+    if (inside === '..' || inside.startsWith(`..${sep}`) || isAbsolute(inside)) return []
+    const entries = await readdir(path, { withFileTypes: true }).catch(() => [])
+    return entries.filter(entry => !entry.name.startsWith('.') && entry.name !== 'node_modules').map((entry) => {
+      const name = entry.isDirectory() ? `${entry.name}/` : `${entry.name}#`
+      return { label: name, kind: entry.isDirectory() ? CompletionItemKind.Folder : CompletionItemKind.File, textEdit: edit(start + colon + 1 + dir.length, name), command: suggest(t) }
+    })
+  }
+
+  const file = target.slice(0, hash)
+  const text = await compilation.src.read(file)
+  if (text === undefined) return []
+  const typed = target.slice(hash + 1).toLowerCase()
+  const harvested = (scheme === 'region' ? regionNames(text) : scheme === 'symbol' ? declarationNames(text) : [...regionNames(text), ...declarationNames(text)])
+    .filter(name => name.toLowerCase().includes(typed))
+  const resolved = await Promise.all(harvested.slice(0, MAX_NAMES).map(async (name) => {
+    const resolution = await compilation.resolvers.resolve(`${scheme}:${file}#${name}`, compilation.src)
+    return isRenderable(resolution) ? { name, location: resolution.location! } : undefined
+  }))
+  return resolved.filter(found => found !== undefined).map(({ name, location }) => ({
+    label: name,
+    kind: scheme === 'region' ? CompletionItemKind.Reference : CompletionItemKind.Function,
+    detail: `${location.file}:${location.startLine}-${location.endLine}`,
+    documentation: { kind: MarkupKind.Markdown, value: fenced(t, location.text) },
+    textEdit: edit(start + colon + 1 + hash + 1, name),
+  }))
+}
+
+export async function unitNames(compilation: Compilation, anchor: AnchorString): Promise<string[]> {
+  const resolution = await resolveAnchor(compilation, anchor)
+  return resolution.location ? regionNames(resolution.location.text) : []
+}

package/src/node/completion.ts

@@ -0,0 +1,66 @@
+import type { Compilation } from '@lincyaw/compiler'
+import { CompletionItemKind, MarkupKind } from 'vscode-languageserver/node'
+import type { CompletionItem, Position } from 'vscode-languageserver/node'
+import { anchorAt, optionsOf, typingAt } from '../domain/index.ts'
+import type { DirectiveInfo, Fence } from '../domain/index.ts'
+import { anchorCompletion, unitNames } from './anchors.ts'
+import { deckSyntax } from './syntax.ts'
+import type { DeckSyntax } from './syntax.ts'
+
+function describe(info: DirectiveInfo, syntax: DeckSyntax): string {
+  const options = Object.keys(optionsOf(info, syntax.common)).map(name => `\`:${name}:\``).join(', ')
+  return [info.doc, `${syntax.t.options}: ${options}`].filter(Boolean).join('\n\n')
+}
+
+function isAnchorArgument(fence: Fence, prefix: string, compilation: Compilation, syntax: DeckSyntax): boolean {
+  return syntax.anchors.has(fence.name) || compilation.resolvers.schemes().some(scheme => prefix.startsWith(`${scheme}:`))
+}
+
+export async function complete(compilation: Compilation, lines: string[], position: Position): Promise<CompletionItem[]> {
+  const typing = typingAt(lines, position.line, position.character)
+  if (!typing) return []
+  const { line, character } = position
+  const edit = (newText: string) => ({ range: { start: { line, character: typing.start }, end: { line, character } }, newText })
+  const syntax = deckSyntax(compilation)
+  const infos = syntax.directives
+
+  switch (typing.kind) {
+    case 'directive':
+      return [...infos.values()].map(info => ({
+        label: info.name,
+        kind: CompletionItemKind.Keyword,
+        detail: info.source,
+        documentation: { kind: MarkupKind.Markdown, value: describe(info, syntax) },
+        textEdit: edit(typing.closed ? info.name : `${info.name}}`),
+      }))
+
+    case 'argument': {
+      if (typing.fence.name === 'component') {
+        return [...compilation.components].map(([name, plugin]) => ({ label: name, kind: CompletionItemKind.Class, detail: plugin, textEdit: edit(name) }))
+      }
+      if (!isAnchorArgument(typing.fence, typing.prefix, compilation, syntax)) return []
+      return anchorCompletion(compilation, typing.prefix, line, typing.start, character, syntax.t)
+    }
+
+    case 'option': {
+      const info = infos.get(typing.fence.name)
+      if (!info) return []
+      return Object.entries(optionsOf(info, syntax.common)).filter(([name]) => !typing.written.includes(name)).map(([name, option]) => ({
+        label: name,
+        kind: CompletionItemKind.Property,
+        detail: option.type,
+        documentation: option.doc,
+        textEdit: edit(`${name}: `),
+      }))
+    }
+
+    case 'value': {
+      const info = infos.get(typing.fence.name)
+      const values = [...(info && optionsOf(info, syntax.common)[typing.option]?.values) ?? []]
+      if (typing.option === 'executor') values.push(...compilation.plugins.flatMap(({ plugin }) => plugin?.executors?.map(e => e.id) ?? []))
+      const anchor = typing.option === 'steps' ? anchorAt(lines, typing.fence.line, compilation.resolvers.schemes(), syntax.anchors) : undefined
+      if (anchor) values.push(...await unitNames(compilation, anchor.anchor), 'all', 'none')
+      return [...new Set(values)].map(value => ({ label: value, kind: CompletionItemKind.Value, textEdit: edit(value) }))
+    }
+  }
+}

package/src/node/decks.ts

@@ -0,0 +1,121 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+import { Compiler, DECK_ENTRY, readFrontmatter } from '@lincyaw/compiler'
+import type { Compilation } from '@lincyaw/compiler'
+import { ANCHOR_LOCK_PATH, errorMessage } from '@lincyaw/kernel'
+import type { Finding } from '@lincyaw/kernel'
+
+export class Deck {
+  readonly entry: string
+  readonly #compiler: Compiler
+  readonly #compiled: (deck: Deck) => void
+  compilation?: Compilation
+  findings: Finding[] = []
+  #running?: Promise<void>
+  #again = false
+
+  constructor(entry: string, compiled: (deck: Deck) => void) {
+    this.entry = entry
+    this.#compiler = new Compiler(entry)
+    this.#compiled = compiled
+  }
+
+  compile(): Promise<void> {
+    if (this.#running) {
+      this.#again = true
+      return this.#running
+    }
+    this.#running = (async () => {
+      do {
+        this.#again = false
+        await this.#compileOnce()
+      } while (this.#again)
+      this.#running = undefined
+    })()
+    return this.#running
+  }
+
+  ready(): Promise<void> {
+    return this.#running ?? Promise.resolve()
+  }
+
+  owns(file: string): boolean {
+    return this.compilation ? this.compilation.files.includes(file) : file === this.entry
+  }
+
+  reads(file: string): boolean {
+    const { compilation } = this
+    if (!compilation) return file === this.entry
+    return compilation.files.includes(file) || compilation.dependencies.files.includes(file) || file === join(compilation.deckDir, ANCHOR_LOCK_PATH)
+  }
+
+  async #compileOnce(): Promise<void> {
+    try {
+      const compilation = await this.#compiler.compile()
+      this.findings = [...compilation.doc.diagnostics, ...await compilation.check()]
+      this.compilation = compilation
+    } catch (error) {
+      this.findings = [{ checkId: 'presmium.compile', severity: 'error', message: errorMessage(error), source: { file: this.entry, line: 1 } }]
+    }
+    this.#compiled(this)
+  }
+}
+
+function declaresPlugins(file: string): boolean {
+  try {
+    return 'plugins' in readFrontmatter(readFileSync(file, 'utf8'))
+  } catch {
+    return false
+  }
+}
+
+function candidateEntries(file: string): string[] {
+  const entries = basename(file) === DECK_ENTRY ? [file] : []
+  for (let dir = dirname(file); ; dir = dirname(dir)) {
+    const entry = join(dir, DECK_ENTRY)
+    if (entry !== file && existsSync(entry)) entries.push(entry)
+    if (dirname(dir) === dir) break
+  }
+  if (basename(file) !== DECK_ENTRY && declaresPlugins(file)) entries.push(file)
+  return entries
+}
+
+export class Decks {
+  readonly #decks = new Map<string, Deck>()
+  readonly #compiled: (deck: Deck) => void
+
+  constructor(compiled: (deck: Deck) => void) {
+    this.#compiled = compiled
+  }
+
+  all(): Deck[] {
+    return [...this.#decks.values()]
+  }
+
+  open(entry: string): Deck {
+    let deck = this.#decks.get(entry)
+    if (!deck) {
+      deck = new Deck(entry, this.#compiled)
+      this.#decks.set(entry, deck)
+      void deck.compile()
+    }
+    return deck
+  }
+
+  async of(file: string): Promise<Deck | undefined> {
+    const known = this.all()
+    const owner = known.find(deck => deck.compilation?.files.includes(file))
+    if (owner) return owner
+    for (const deck of known) {
+      await deck.ready()
+      if (deck.owns(file)) return deck
+    }
+    for (const entry of candidateEntries(file)) {
+      if (known.some(deck => deck.entry === entry)) continue
+      const deck = this.open(entry)
+      await deck.ready()
+      if (deck.owns(file)) return deck
+    }
+    return undefined
+  }
+}

package/src/node/diagnostics.ts

@@ -0,0 +1,39 @@
+import type { Finding, Severity } from '@lincyaw/kernel'
+import { DiagnosticSeverity } from 'vscode-languageserver/node'
+import type { Diagnostic, Range } from 'vscode-languageserver/node'
+import { fenceAt } from '../domain/index.ts'
+
+const SEVERITY: Record<Severity, DiagnosticSeverity> = {
+  error: DiagnosticSeverity.Error,
+  warning: DiagnosticSeverity.Warning,
+  info: DiagnosticSeverity.Information,
+}
+
+function rangeOf(text: string, line: number, message: string): Range {
+  const fence = fenceAt([text], 0)
+  const word = fence?.arg.split(/\s/)[0]
+  if (fence && word && message.includes(word)) {
+    return { start: { line, character: fence.argStart }, end: { line, character: fence.argStart + word.length } }
+  }
+  const start = text.length - text.trimStart().length
+  return { start: { line, character: start }, end: { line, character: text.trimEnd().length } }
+}
+
+export function toDiagnostics(findings: Finding[], entry: string, lines: (file: string) => string[]): Map<string, Diagnostic[]> {
+  const byFile = new Map<string, Diagnostic[]>()
+  const texts = new Map<string, string[]>()
+  for (const finding of findings) {
+    const file = finding.source?.file ?? entry
+    const line = Math.max(1, finding.source?.line ?? 1) - 1
+    if (!texts.has(file)) texts.set(file, lines(file))
+    const diagnostic: Diagnostic = {
+      range: rangeOf(texts.get(file)![line] ?? '', line, finding.message),
+      severity: SEVERITY[finding.severity],
+      source: 'presmium',
+      code: finding.checkId,
+      message: finding.hint ? `${finding.message}\n${finding.hint}` : finding.message,
+    }
+    byFile.set(file, [...byFile.get(file) ?? [], diagnostic])
+  }
+  return byFile
+}

package/src/node/preview.ts

@@ -0,0 +1,111 @@
+import { spawn } from 'node:child_process'
+import type { ChildProcess } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+import { createInterface } from 'node:readline'
+
+const START_TIMEOUT = 120_000
+const PREVIEW_DIR = '.presmium/preview'
+
+const CLI = '@lincyaw/cli'
+
+function cliBin(from: string): string | undefined {
+  let dir: string
+  try {
+    dir = dirname(createRequire(from).resolve(CLI))
+  } catch {
+    return undefined
+  }
+  for (; dirname(dir) !== dir; dir = dirname(dir)) {
+    const file = join(dir, 'package.json')
+    if (!existsSync(file)) continue
+    const pkg = JSON.parse(readFileSync(file, 'utf8')) as { name?: string, bin?: Record<string, string> }
+    if (pkg.name === CLI && pkg.bin?.presmium) return join(dir, pkg.bin.presmium)
+  }
+  return undefined
+}
+
+function presmiumBin(deckDir: string): string {
+  const bin = cliBin(join(deckDir, 'package.json')) ?? cliBin(import.meta.url)
+  if (!bin) throw new Error(`${CLI} is not installed`)
+  return bin
+}
+
+function stop(child: ChildProcess, signal: NodeJS.Signals = 'SIGTERM'): void {
+  if (!child.pid || child.exitCode !== null || child.signalCode !== null) return
+  if (process.platform === 'win32') {
+    const task = spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' })
+    task.once('error', () => { child.kill(signal) })
+  } else child.kill(signal)
+}
+
+export class Previews {
+  readonly #urls = new Map<string, Promise<string>>()
+  readonly #children = new Set<ChildProcess>()
+  readonly #log: (line: string) => void
+
+  constructor(log: (line: string) => void) {
+    this.#log = log
+  }
+
+  open(entry: string): Promise<string> {
+    const known = this.#urls.get(entry)
+    if (known) return known
+    const forget = () => {
+      if (this.#urls.get(entry) === url) this.#urls.delete(entry)
+    }
+    const url: Promise<string> = this.#start(entry, forget)
+    this.#urls.set(entry, url)
+    url.catch(forget)
+    return url
+  }
+
+  #start(entry: string, forget: () => void): Promise<string> {
+    const deckDir = dirname(entry)
+    const args = [presmiumBin(deckDir), 'dev', entry, '--to', 'web', '--out', join(deckDir, PREVIEW_DIR)]
+    const child = spawn(process.execPath, args, { cwd: deckDir, stdio: ['ignore', 'pipe', 'pipe'] })
+    this.#children.add(child)
+    return new Promise((resolve, reject) => {
+      let started = false
+      const fail = (error: Error) => {
+        clearTimeout(timer)
+        reject(error)
+        if (!started) stop(child)
+      }
+      const timer = setTimeout(() => fail(new Error('presmium dev did not start the web server in time')), START_TIMEOUT)
+      createInterface({ input: child.stderr! }).on('line', line => this.#log(line))
+      createInterface({ input: child.stdout! }).on('line', (line) => {
+        this.#log(line)
+        if (started) return
+        const url = /^web\s+(https?:\/\/\S+)/.exec(line)?.[1]
+        if (url) {
+          started = true
+          clearTimeout(timer)
+          resolve(url)
+        } else if (line.startsWith('watching;')) {
+          fail(new Error('presmium dev started no web server; is the web renderer installed?'))
+        }
+      })
+      child.once('error', fail)
+      child.once('exit', (code) => {
+        this.#children.delete(child)
+        forget()
+        fail(new Error(`presmium dev exited with code ${code}`))
+      })
+    })
+  }
+
+  async close(): Promise<void> {
+    const exits = [...this.#children].map(child => new Promise<void>((done) => {
+      const timer = setTimeout(() => {
+        stop(child, 'SIGKILL')
+        done()
+      }, 5000).unref()
+      child.once('exit', () => { clearTimeout(timer); done() })
+      stop(child)
+    }))
+    this.#urls.clear()
+    await Promise.all(exits)
+  }
+}

package/src/node/server.ts

@@ -0,0 +1,134 @@
+import { readFileSync } from 'node:fs'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { sectionLinks, toPages } from '@lincyaw/web/domain'
+import { TextDocument } from 'vscode-languageserver-textdocument'
+import { createConnection, DidChangeWatchedFilesNotification, ProposedFeatures, TextDocuments, TextDocumentSyncKind } from 'vscode-languageserver/node'
+import { anchorAt, PREVIEW_REQUEST, SECTION_REQUEST, sectionAt } from '../domain/index.ts'
+import type { DocumentParams, PositionParams, Preview, SectionAt } from '../domain/index.ts'
+import { anchorDefinition, anchorHover } from './anchors.ts'
+import { complete } from './completion.ts'
+import { Decks } from './decks.ts'
+import type { Deck } from './decks.ts'
+import { toDiagnostics } from './diagnostics.ts'
+import { Previews } from './preview.ts'
+import { deckSyntax } from './syntax.ts'
+
+const COMPILE_DELAY = 50
+
+function fileOf(uri: string): string | undefined {
+  return uri.startsWith('file:') ? fileURLToPath(uri) : undefined
+}
+
+export function startServer(): void {
+  const connection = createConnection(ProposedFeatures.all)
+  const documents = new TextDocuments(TextDocument)
+  const previews = new Previews(line => connection.console.log(line))
+  const published = new Map<Deck, Set<string>>()
+  const timers = new Map<Deck, NodeJS.Timeout>()
+
+  const bufferLines = (uri: string) => documents.get(uri)?.getText().split(/\r?\n/) ?? []
+  const fileLines = (file: string): string[] => {
+    try {
+      return readFileSync(file, 'utf8').split(/\r?\n/)
+    } catch {
+      return []
+    }
+  }
+
+  const publish = (deck: Deck) => {
+    const byFile = toDiagnostics(deck.findings, deck.entry, fileLines)
+    const files = new Set([...deck.compilation?.files ?? [deck.entry], ...byFile.keys()])
+    const uris = new Set([...files].map(file => pathToFileURL(file).href))
+    for (const file of files) void connection.sendDiagnostics({ uri: pathToFileURL(file).href, diagnostics: byFile.get(file) ?? [] })
+    for (const uri of published.get(deck) ?? []) {
+      if (!uris.has(uri)) void connection.sendDiagnostics({ uri, diagnostics: [] })
+    }
+    published.set(deck, uris)
+  }
+  const decks = new Decks(publish)
+
+  const changed = (files: string[]) => {
+    for (const deck of decks.all().filter(d => files.some(file => d.reads(file)))) {
+      clearTimeout(timers.get(deck))
+      timers.set(deck, setTimeout(() => void deck.compile(), COMPILE_DELAY))
+    }
+  }
+
+  const deckOf = async (uri: string) => {
+    const file = fileOf(uri)
+    const deck = file ? await decks.of(file) : undefined
+    return file && deck?.compilation ? { file, deck, compilation: deck.compilation } : undefined
+  }
+
+  let watchFiles = false
+  connection.onInitialize(({ capabilities }) => {
+    watchFiles = capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration === true
+    return {
+      capabilities: {
+        textDocumentSync: { openClose: true, change: TextDocumentSyncKind.Incremental, save: { includeText: false } },
+        definitionProvider: true,
+        hoverProvider: true,
+        completionProvider: { triggerCharacters: ['{', ':', '#', '/', ','] },
+      },
+      serverInfo: { name: 'presmium-language-server' },
+    }
+  })
+  connection.onInitialized(() => {
+    if (watchFiles) void connection.client.register(DidChangeWatchedFilesNotification.type, { watchers: [{ globPattern: '**/*' }] })
+  })
+
+  documents.onDidOpen(({ document }) => {
+    const file = fileOf(document.uri)
+    if (file) void decks.of(file)
+  })
+  documents.onDidSave(({ document }) => {
+    const file = fileOf(document.uri)
+    if (file) changed([file])
+  })
+  connection.onDidChangeWatchedFiles(({ changes }) => changed(changes.flatMap(change => fileOf(change.uri) ?? [])))
+
+  const anchorOf = async (uri: string, line: number) => {
+    const found = await deckOf(uri)
+    if (!found) return undefined
+    const syntax = deckSyntax(found.compilation)
+    const ref = anchorAt(bufferLines(uri), line, found.compilation.resolvers.schemes(), syntax.anchors)
+    return ref && { ...found, ref, t: syntax.t }
+  }
+
+  connection.onDefinition(async ({ textDocument, position }) => {
+    const found = await anchorOf(textDocument.uri, position.line)
+    return found ? anchorDefinition(found.compilation, found.ref) : null
+  })
+
+  connection.onHover(async ({ textDocument, position }) => {
+    const found = await anchorOf(textDocument.uri, position.line)
+    return found ? anchorHover(found.compilation, found.file, found.ref, found.t) : null
+  })
+
+  connection.onCompletion(async ({ textDocument, position }) => {
+    const found = await deckOf(textDocument.uri)
+    return found ? complete(found.compilation, bufferLines(textDocument.uri), position) : []
+  })
+
+  connection.onRequest(SECTION_REQUEST, async ({ textDocument, position }: PositionParams): Promise<SectionAt | null> => {
+    const found = await deckOf(textDocument.uri)
+    const doc = found?.compilation.doc
+    const section = doc && sectionAt(doc, found.file, position.line + 1)
+    if (!section) return null
+    const link = sectionLinks(toPages(doc))[section.id] ?? '/'
+    return { entry: found.deck.entry, id: section.id, index: section.index, title: section.title, link }
+  })
+
+  connection.onRequest(PREVIEW_REQUEST, async ({ textDocument }: DocumentParams): Promise<Preview> => {
+    const file = fileOf(textDocument.uri)
+    const deck = file ? await decks.of(file) : undefined
+    if (!deck) throw new Error(`${textDocument.uri} is not a source file of a Presmium deck`)
+    return { entry: deck.entry, url: await previews.open(deck.entry) }
+  })
+
+  connection.onShutdown(() => previews.close())
+  process.once('exit', () => void previews.close())
+
+  documents.listen(connection)
+  connection.listen()
+}

package/src/node/syntax.ts

@@ -0,0 +1,30 @@
+import { BUILTIN_DIRECTIVE_INFO, COMMON_DIRECTIVE_OPTIONS, RUN_OPTION } from '@lincyaw/compiler'
+import type { Compilation, DirectiveOptionInfo } from '@lincyaw/compiler'
+import { deckLocale } from '@lincyaw/kernel'
+import type { Locale } from '@lincyaw/kernel'
+import { anchorDirectives, directiveInfos, LS_MESSAGES } from '../domain/index.ts'
+import type { DirectiveInfo, LsMessages, OptionInfo } from '../domain/index.ts'
+
+export interface DeckSyntax {
+  directives: Map<string, DirectiveInfo>
+  common: Record<string, OptionInfo>
+  anchors: Set<string>
+  t: LsMessages
+}
+
+function option(info: DirectiveOptionInfo, locale: Locale): OptionInfo {
+  return { ...info.type ? { type: info.type } : {}, ...info.doc ? { doc: info.doc[locale] } : {}, ...info.values ? { values: info.values } : {} }
+}
+
+function options(infos: Record<string, DirectiveOptionInfo>, locale: Locale): Record<string, OptionInfo> {
+  return Object.fromEntries(Object.entries(infos).map(([name, info]) => [name, option(info, locale)]))
+}
+
+export function deckSyntax(compilation: Compilation): DeckSyntax {
+  const locale = deckLocale(compilation.doc.meta.lang)
+  const t = LS_MESSAGES[locale]
+  const builtin = BUILTIN_DIRECTIVE_INFO.map(info => ({ name: info.name, source: t.builtIn, doc: info.doc[locale], options: options(info.options, locale) }))
+  const plugins = compilation.plugins.flatMap(({ plugin }) => plugin ? [{ plugin: plugin.id, directives: plugin.directives ?? [] }] : [])
+  const directives = directiveInfos(builtin, plugins, option(RUN_OPTION, locale))
+  return { directives, common: options(COMMON_DIRECTIVE_OPTIONS, locale), anchors: anchorDirectives(directives), t }
+}