@lincyaw/language-server 1.0.0-rc.0 → 1.0.0-rc.1

package/README.md

@@ -1,8 +1,8 @@
 # @lincyaw/language-server
 
-The language server of Presmium documents: diagnostics, anchor definitions and hovers, completion of directives, options and anchors, and the preview that follows the cursor.
+Language server for canonical `lecture.json` teaching documents: shared validation, normalized entity definitions, project code anchor definitions and hovers, and preview synchronization by stable page ownership.
 
-Part of [Presmium](https://github.com/Lincyaw/presmium), which turns lectures written in MyST Markdown into web pages, slides, Jupyter notebooks and narrated lectures.
+Part of [Presmium](https://github.com/Lincyaw/presmium), which derives web pages, slides, Jupyter notebooks and narrated playback from the same teaching document.
 
 ## Usage
 
@@ -10,11 +10,17 @@ Part of [Presmium](https://github.com/Lincyaw/presmium), which turns lectures wr
 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.
+It also takes `--node-ipc` and `--socket=<port>`. Clients select `**/lecture.json` using their native JSON editor and associate the public kernel schema for completion. The VS Code extension generates and bundles this schema from `DOCUMENT_JSON_SCHEMA`; the server adds syntax and domain graph diagnostics using `validateDocument`.
+
+Opened buffers are validated without writing or compiling unsaved text. Saving JSON and notifications for watched project inputs trigger a real compiler run. Diagnostics resolve JSON pointers to token ranges; entity and `origin.anchor` definitions navigate to their authoritative JSON or project code. `presmium/section` locates a page from the entity under the cursor, including normalized blocks, steps and narration. `presmium/preview` starts a real `presmium dev` web server for the canonical entry and stops it when the language server closes.
+
+Compilation and preview prefer the document's installed `@lincyaw/presmium` package, which supplies its bundled plugins and renderers. A standalone installation uses the project's CLI or the language server's own CLI dependencies.
+
+The server does not register its own completion provider: JSON schema completion remains with the editor. The studio provides native rich-text editing of the same `lecture.json` document.
 
 ## Documentation
 
-- [Author guide](https://github.com/Lincyaw/presmium/blob/main/site/guide/lecture.en.md)
+- [Author guide](https://github.com/Lincyaw/presmium/blob/main/site/guide/locales/en/lecture.json)
 
 ## License
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lincyaw/language-server",
-  "version": "1.0.0-rc.0",
-  "description": "Language server for Presmium documents: diagnostics, anchor definitions and hovers, completion and preview sync",
+  "version": "1.0.0-rc.1",
+  "description": "Language server for canonical lecture.json documents: validation, entity navigation, code anchors and preview sync",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -36,14 +36,15 @@
   ],
   "dependencies": {
     "jiti": "^2.7.0",
+    "jsonc-parser": "3.3.1",
     "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"
+    "@lincyaw/cli": "1.0.0-rc.1",
+    "@lincyaw/compiler": "1.0.0-rc.1",
+    "@lincyaw/kernel": "1.0.0-rc.1",
+    "@lincyaw/viewer": "1.0.0-rc.1",
+    "@lincyaw/host": "1.0.0-rc.1",
+    "@lincyaw/web": "1.0.0-rc.1"
   },
   "scripts": {
     "typecheck": "tsc -p tsconfig.json"

package/src/domain/document.ts

@@ -0,0 +1,92 @@
+import { isRecord, validateDocument } from '@lincyaw/kernel'
+import type { TeachingDocument } from '@lincyaw/kernel'
+import { findNodeAtLocation, findNodeAtOffset, getNodePath, getNodeValue, parseTree } from 'jsonc-parser'
+import type { JSONPath, Node, ParseError } from 'jsonc-parser'
+
+/** Strict JSON syntax, using parser offsets unchanged even when the entry has a BOM. */
+export function readDocument(text: string) {
+  const errors: ParseError[] = []
+  const tree = parseTree(text.replace(/^\uFEFF/, ' '), errors, { disallowComments: true, allowTrailingComma: false, allowEmptyContent: false })
+  const validation = tree && !errors.length ? validateDocument(getNodeValue(tree)) : undefined
+  return { tree, errors, validation, document: validation?.document }
+}
+
+export function nodeAt(tree: Node, offset: number): { node: Node, path: JSONPath } | undefined {
+  const node = findNodeAtOffset(tree, offset, true)
+  return node ? { node, path: getNodePath(node) } : undefined
+}
+
+/** Missing properties point at the closest existing parent, rather than an invented source line. */
+export function nodeAtPointer(tree: Node, pointer: string): Node {
+  const path = pointer.replace(/^#/, '').split('/').slice(1).map(key => key.replaceAll('~1', '/').replaceAll('~0', '~'))
+  let node = tree
+  for (const key of path) {
+    const found = findNodeAtLocation(node, [node.type === 'array' ? Number(key) : key])
+    if (!found) break
+    node = found
+  }
+  return node
+}
+
+function owners(document: TeachingDocument): Map<string, string> {
+  const result = new Map<string, string>()
+  const rich = (node: unknown, section: string) => {
+    if (!isRecord(node)) return
+    if (typeof node.id === 'string') result.set(node.id, section)
+    if (Array.isArray(node.children)) node.children.forEach(child => rich(child, section))
+    if (Array.isArray(node.fallback)) node.fallback.forEach(child => rich(child, section))
+  }
+  const visit = (id: string, section: string) => {
+    result.set(id, section)
+    const block = document.blocks[id]!
+    if (block.type === 'container' || block.type === 'component') block.children?.forEach(child => visit(child, section))
+    if (block.type === 'text') block.content.forEach(node => rich(node, section))
+  }
+  for (const id of document.sectionOrder) {
+    result.set(`page:${id}`, id)
+    document.sections[id]!.children.forEach(child => visit(child, id))
+  }
+  return result
+}
+
+/** Entity ownership determines the page even if normalized maps are reordered or minified. */
+export function sectionAtPath(document: TeachingDocument, path: JSONPath): string | undefined {
+  const [map, id, field, key] = path
+  const owner = owners(document)
+  const narration = (id: string) => document.sectionOrder.find(section => document.sections[section]!.stepOrder.some(step => document.steps[step]!.narrationIds.includes(id)))
+  const usedBlock = (predicate: (block: TeachingDocument['blocks'][string]) => boolean) => Object.values(document.blocks).find(predicate)?.id
+  if (map === 'sections' && typeof id === 'string') return document.sections[id]?.id
+  if (map === 'sectionOrder' && typeof id === 'number') return document.sectionOrder[id]
+  if (map === 'blocks' && typeof id === 'string') return owner.get(id)
+  if (map === 'steps' && typeof id === 'string') return document.steps[id]?.sectionId
+  if (map === 'narrations' && typeof id === 'string') return narration(id)
+  if (map === 'definitions' && typeof id === 'string') return owner.get(usedBlock(block => block.type === 'component' && block.definitionId === id) ?? '')
+  if (map === 'assets' && typeof id === 'string') return owner.get(usedBlock(block => block.type === 'image' && block.assetId === id) ?? '')
+  if (map === 'production') {
+    if (id === 'sectionOverrides' && typeof field === 'string') return document.sections[field]?.id
+    if (id === 'stepOverrides' && typeof field === 'string') return document.steps[field]?.sectionId
+    if (id === 'narrationOverrides' && typeof field === 'string') return narration(field)
+    if (id === 'cueTimings' && typeof field === 'string') {
+      const owner = Object.values(document.narrations).find(value => value.content.some(node => node.type === 'cue' && node.id === field))
+      return owner && narration(owner.id)
+    }
+    if (id === 'mediaClips' && typeof field === 'number') return document.steps[document.production.mediaClips[field]?.attachment.stepId ?? '']?.sectionId
+  }
+  if (map === 'comments' && typeof id === 'string') return owner.get(document.comments?.[id]?.anchor?.[key === 'to' ? 'to' : 'from'].blockId ?? '')
+  return map === 'metadata' || !path.length ? document.sectionOrder[0] : undefined
+}
+
+export function entityReference(document: TeachingDocument, path: JSONPath, value: unknown): JSONPath | undefined {
+  if (typeof value !== 'string') return undefined
+  const [root, , field] = path, last = path.at(-1)
+  const child = path.length === 4 && field === 'children' && (root === 'sections' || root === 'blocks')
+  const visual = root === 'steps' && field === 'visuals' && path.length === 5 && last === 'blockId'
+  const cue = root === 'narrations' && field === 'content' && path.length === 6 && path.at(-2) === 'target' && last === 'blockId'
+  const asset = last === 'assetId' && (root === 'blocks' && path.length === 3 || root === 'production' && (path.at(-2) === 'voiceSource' || path[1] === 'mediaClips' && path.length === 4))
+  const map = root === 'sectionOrder' && path.length === 2 || root === 'steps' && field === 'sectionId' && path.length === 3 ? 'sections'
+    : root === 'blocks' && field === 'definitionId' && path.length === 3 ? 'definitions'
+    : asset ? 'assets' : child || visual || cue ? 'blocks'
+    : root === 'sections' && field === 'stepOrder' && path.length === 4 || root === 'steps' && field === 'inherits' && path.length === 3 || root === 'production' && path[1] === 'mediaClips' && path.at(-2) === 'attachment' && last === 'stepId' ? 'steps'
+    : root === 'steps' && field === 'narrationIds' && path.length === 4 ? 'narrations' : undefined
+  return map && Object.hasOwn(document[map], value) ? [map, value] : undefined
+}

package/src/domain/index.ts

@@ -1,11 +1,6 @@
-export { anchorDirectives, directiveInfos, optionsOf } from './directives.ts'
-export type { DirectiveInfo, OptionInfo } from './directives.ts'
+export { entityReference, nodeAt, nodeAtPointer, readDocument, sectionAtPath } from './document.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 { previewUrl } from './preview-url.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'
+export type { DocumentParams, PositionParams, Preview, SectionLocation } from './protocol.ts'

package/src/domain/messages.ts

@@ -9,13 +9,9 @@ export const LS_MESSAGES = {
     timedOut: '超时',
     exitCode: (code: number | null) => `退出码 ${code}`,
     noOutput: '（没有输出）',
-    runsLive: '*在浏览器中执行（`:run: live`），没有录制的输出。*',
+    runsLive: '*配置为在浏览器中执行，尚无录制输出。*',
     notRecorded: '*还没有录制的输出。*',
     moreLines: (count: number) => `…… 另有 ${count} 行`,
-    anchorScheme: '锚点类型',
-    options: '选项',
-    suggest: '提示',
-    builtIn: '内置',
   },
   'en': {
     status: { exact: 'exact', moved: 'moved', fuzzy: 'to confirm', lost: 'lost' } as Record<string, string>,
@@ -25,13 +21,9 @@ export const LS_MESSAGES = {
     timedOut: 'timed out',
     exitCode: (code: number | null) => `exit code ${code}`,
     noOutput: '(no output)',
-    runsLive: '*Runs in the browser (`:run: live`); no recorded output.*',
+    runsLive: '*Configured to run in the browser; 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>
 

package/src/domain/{preview.ts → preview-url.ts}

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

package/src/domain/protocol.ts

@@ -15,7 +15,8 @@ export interface Preview {
 
 export const SECTION_REQUEST = 'presmium/section'
 
-export interface SectionAt {
+/** The section at a position in a source file, and its page in the web form. */
+export interface SectionLocation {
   entry: string
   id: string
   index: number

package/src/node/anchors.ts

@@ -1,54 +1,39 @@
-import { readdir } from 'node:fs/promises'
-import { isAbsolute, relative, resolve, sep } from 'node:path'
+import { resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import type { Compilation } from '@lincyaw/compiler'
-import { isRenderable } from '@lincyaw/kernel'
+import { docBlocks, 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'
+import { MarkupKind } from 'vscode-languageserver/node'
+import type { Hover, Location, Range } from 'vscode-languageserver/node'
+import type { LsMessages } from '../domain/index.ts'
 
-const MAX_NAMES = 200
 const MAX_LINES = 60
+export interface AnchorRef { anchor: AnchorString, blockId: string, pin?: string, range: Range }
 
-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 resolveAnchor(compilation: Compilation, ref: AnchorRef): Promise<Resolution> {
+  return compilation.resolvers.resolve(ref.anchor, compilation.src, compilation.lock.get(ref.anchor), ref.pin)
 }
-
 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 } },
-  }
+  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))
+  const resolution = await resolveAnchor(compilation, ref)
+  return (resolution.location ? [resolution.location] : resolution.candidates ?? []).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
+function where(file: string, startLine: number, endLine: number): string { return `\`${file}:${startLine}-${endLine}\`` }
+export async function anchorHover(compilation: Compilation, ref: AnchorRef, t: LsMessages): Promise<Hover> {
+  const block = [...docBlocks(compilation.doc)].find(({ block }) => block.id === ref.blockId)?.block
+  const node = block?.node.type === 'code' && block.node.origin?.anchor === ref.anchor && block.node.origin?.pin === ref.pin ? 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 }
+  return { contents: { kind: MarkupKind.Markdown, value: parts.join('\n\n') }, range: ref.range }
 }
 
 function codeNodeHover(node: CodeNode, t: LsMessages): string[] {
@@ -66,56 +51,10 @@ function codeNodeHover(node: CodeNode, t: LsMessages): string[] {
 }
 
 async function resolvedHover(compilation: Compilation, ref: AnchorRef, t: LsMessages): Promise<string[]> {
-  const resolution = await resolveAnchor(compilation, ref.anchor)
+  const resolution = await resolveAnchor(compilation, ref)
   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/decks.ts

@@ -1,9 +1,10 @@
-import { existsSync, readFileSync } from 'node:fs'
-import { basename, dirname, join } from 'node:path'
-import { Compiler, DECK_ENTRY, readFrontmatter } from '@lincyaw/compiler'
+import { basename, join } from 'node:path'
+import { readFileSync } from 'node:fs'
+import { Compiler, DECK_ENTRY } from '@lincyaw/compiler'
 import type { Compilation } from '@lincyaw/compiler'
-import { ANCHOR_LOCK_PATH, errorMessage } from '@lincyaw/kernel'
+import { ANCHOR_LOCK_PATH, errorMessage, fnv1a64 } from '@lincyaw/kernel'
 import type { Finding } from '@lincyaw/kernel'
+import { documentCli } from './document-cli.ts'
 
 export class Deck {
   readonly entry: string
@@ -11,12 +12,15 @@ export class Deck {
   readonly #compiled: (deck: Deck) => void
   compilation?: Compilation
   findings: Finding[] = []
+  sourceFingerprint?: string
   #running?: Promise<void>
   #again = false
+  #version = 0
+  #completedVersion = -1
 
   constructor(entry: string, compiled: (deck: Deck) => void) {
     this.entry = entry
-    this.#compiler = new Compiler(entry)
+    this.#compiler = new Compiler(entry, { bundled: documentCli(entry).bundled })
     this.#compiled = compiled
   }
 
@@ -39,45 +43,32 @@ export class Deck {
     return this.#running ?? Promise.resolve()
   }
 
-  owns(file: string): boolean {
-    return this.compilation ? this.compilation.files.includes(file) : file === this.entry
-  }
+  invalidate(): void { this.#version++ }
+  get findingsCurrent(): boolean { return this.#completedVersion === this.#version }
 
-  reads(file: string): boolean {
+  dependsOn(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)
+    return compilation.sourceFiles.includes(file) || compilation.inputs.files.includes(file) || file === join(compilation.deckDir, ANCHOR_LOCK_PATH)
   }
 
   async #compileOnce(): Promise<void> {
+    const version = this.#version
+    let attemptedFingerprint: string | undefined
+    try { attemptedFingerprint = fnv1a64(readFileSync(this.entry, 'utf8')) } catch { /* The compiler reports unavailable entries. */ }
     try {
       const compilation = await this.#compiler.compile()
       this.findings = [...compilation.doc.diagnostics, ...await compilation.check()]
       this.compilation = compilation
+      this.sourceFingerprint = compilation.sourceFingerprints?.[this.entry]
     } catch (error) {
+      this.compilation = undefined
+      this.sourceFingerprint = attemptedFingerprint
       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
+    this.#completedVersion = version
+    if (this.findingsCurrent && !this.#again) this.#compiled(this)
   }
-  if (basename(file) !== DECK_ENTRY && declaresPlugins(file)) entries.push(file)
-  return entries
 }
 
 export class Decks {
@@ -102,20 +93,11 @@ export class Decks {
     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
+  /** Only the canonical JSON entry opens a document; project inputs are watched dependencies. */
+  async findByFile(file: string): Promise<Deck | undefined> {
+    if (basename(file) !== DECK_ENTRY) return undefined
+    const deck = this.open(file)
+    await deck.ready()
+    return deck
   }
 }

package/src/node/{preview.ts → dev-server-launcher.ts}

@@ -1,38 +1,13 @@
 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'
+import { documentCli } from './document-cli.ts'
 
 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 {
+function stopProcess(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' })
@@ -40,7 +15,8 @@ function stop(child: ChildProcess, signal: NodeJS.Signals = 'SIGTERM'): void {
   } else child.kill(signal)
 }
 
-export class Previews {
+/** Starts a `presmium dev` web server for each deck the editor previews, once, and stops them all on close. */
+export class DevServerLauncher {
   readonly #urls = new Map<string, Promise<string>>()
   readonly #children = new Set<ChildProcess>()
   readonly #log: (line: string) => void
@@ -49,7 +25,8 @@ export class Previews {
     this.#log = log
   }
 
-  open(entry: string): Promise<string> {
+  /** The address of the deck's dev server, started on first use. */
+  urlOf(entry: string): Promise<string> {
     const known = this.#urls.get(entry)
     if (known) return known
     const forget = () => {
@@ -63,15 +40,16 @@ export class Previews {
 
   #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'] })
+    const args = [documentCli(entry).bin, 'dev', entry, '--to', 'web', '--out', join(deckDir, PREVIEW_DIR)]
+    // The lines read below are the English ones: `presmium dev` prints in the system's language.
+    const child = spawn(process.execPath, args, { cwd: deckDir, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, LC_ALL: 'en_US.UTF-8' } })
     this.#children.add(child)
     return new Promise((resolve, reject) => {
       let started = false
       const fail = (error: Error) => {
         clearTimeout(timer)
         reject(error)
-        if (!started) stop(child)
+        if (!started) stopProcess(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))
@@ -99,11 +77,11 @@ export class Previews {
   async close(): Promise<void> {
     const exits = [...this.#children].map(child => new Promise<void>((done) => {
       const timer = setTimeout(() => {
-        stop(child, 'SIGKILL')
+        stopProcess(child, 'SIGKILL')
         done()
       }, 5000).unref()
       child.once('exit', () => { clearTimeout(timer); done() })
-      stop(child)
+      stopProcess(child)
     }))
     this.#urls.clear()
     await Promise.all(exits)

package/src/node/diagnostics.ts

@@ -1,38 +1,39 @@
-import type { Finding, Severity } from '@lincyaw/kernel'
+import type { Finding, Severity, SourcePos } from '@lincyaw/kernel'
+import { printParseErrorCode } from 'jsonc-parser'
+import { TextDocument } from 'vscode-languageserver-textdocument'
 import { DiagnosticSeverity } from 'vscode-languageserver/node'
 import type { Diagnostic, Range } from 'vscode-languageserver/node'
-import { fenceAt } from '../domain/index.ts'
+import { nodeAtPointer, readDocument } from '../domain/document.ts'
 
-const SEVERITY: Record<Severity, DiagnosticSeverity> = {
-  error: DiagnosticSeverity.Error,
-  warning: DiagnosticSeverity.Warning,
-  info: DiagnosticSeverity.Information,
-}
+const SEVERITY: Record<Severity, DiagnosticSeverity> = { error: DiagnosticSeverity.Error, warning: DiagnosticSeverity.Warning, info: DiagnosticSeverity.Information }
+export const offsetRange = (document: TextDocument, offset: number, length: number): Range => ({ start: document.positionAt(offset), end: document.positionAt(offset + Math.max(1, length)) })
 
-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 } }
+/** The same syntax and graph validator used by source saves, before compilation is available. */
+export function documentDiagnostics(text: string): Diagnostic[] {
+  const document = TextDocument.create('', 'json', 0, text), source = readDocument(text)
+  return [
+    ...source.errors.map(error => ({ range: offsetRange(document, error.offset, error.length), severity: DiagnosticSeverity.Error, source: 'presmium', code: 'document.json', message: printParseErrorCode(error.error) })),
+    ...(source.validation?.issues.map(issue => {
+      const node = nodeAtPointer(source.tree!, issue.path)
+      return { range: offsetRange(document, node.offset, node.length), severity: SEVERITY[issue.severity], source: 'presmium', code: issue.code, message: issue.message }
+    }) ?? []),
+  ]
 }
 
-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[]>()
+/** Compiler JSON pointers resolve to real token ranges; project findings retain their code lines. */
+export function diagnosticsByFile(findings: Finding[], entry: string, textOf: (file: string) => string): Map<string, Diagnostic[]> {
+  const byFile = new Map<string, Diagnostic[]>(), documents = new Map<string, TextDocument>()
+  const trees = new Map<string, ReturnType<typeof readDocument>['tree']>()
   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,
-    }
+    const source = finding.source as SourcePos | undefined, file = source?.file ?? entry
+    let document = documents.get(file)
+    if (!document) { document = TextDocument.create('', 'json', 0, textOf(file)); documents.set(file, document) }
+    if (source?.pointer && !trees.has(file)) trees.set(file, readDocument(document.getText()).tree)
+    const tree = trees.get(file)
+    const node = tree && source?.pointer ? nodeAtPointer(tree, source.pointer) : undefined
+    const line = Math.max(1, source?.line ?? 1) - 1, text = document.getText().split(/\r?\n/)[line] ?? ''
+    const range = node ? offsetRange(document, node.offset, node.length) : { start: { line, character: text.length - text.trimStart().length }, end: { line, character: text.trimEnd().length } }
+    const diagnostic: Diagnostic = { range, 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/document-cli.ts

@@ -0,0 +1,19 @@
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { findPackageDir } from '@lincyaw/compiler'
+import { findPackageBin } from '@lincyaw/kernel/node'
+
+/** The document's installed command and the package that supplies its bundled plugins. */
+export function documentCli(entry: string): { bin: string, bundled: string } {
+  const project = dirname(entry)
+  for (const [name, from] of [
+    ['@lincyaw/presmium', project],
+    ['@lincyaw/cli', project],
+    ['@lincyaw/cli', dirname(fileURLToPath(import.meta.url))],
+  ] as const) {
+    const bundled = findPackageDir(name, from)
+    const bin = findPackageBin(name, 'presmium', join(from, 'package.json'))
+    if (bundled && bin) return { bin, bundled }
+  }
+  throw new Error('@lincyaw/cli is not installed')
+}

package/src/node/server.ts

@@ -1,134 +1,126 @@
 import { readFileSync } from 'node:fs'
+import { basename } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
-import { sectionLinks, toPages } from '@lincyaw/web/domain'
+import { DOCUMENT_ENTRY, fnv1a64 } from '@lincyaw/kernel'
+import type { AnchorString } from '@lincyaw/kernel'
+import { sectionLinks, webPages } from '@lincyaw/web/domain'
+import { findNodeAtLocation, getNodeValue } from 'jsonc-parser'
 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 { entityReference, LS_MESSAGES, nodeAt, readDocument, sectionAtPath, PREVIEW_REQUEST, SECTION_REQUEST } from '../domain/index.ts'
+import type { DocumentParams, PositionParams, Preview, SectionLocation } from '../domain/index.ts'
 import { anchorDefinition, anchorHover } from './anchors.ts'
-import { complete } from './completion.ts'
+import type { AnchorRef } from './anchors.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'
+import { DevServerLauncher } from './dev-server-launcher.ts'
+import { diagnosticsByFile, documentDiagnostics, offsetRange } from './diagnostics.ts'
 
 const COMPILE_DELAY = 50
-
-function fileOf(uri: string): string | undefined {
-  return uri.startsWith('file:') ? fileURLToPath(uri) : undefined
-}
+const fileOf = (uri: string): string | undefined => uri.startsWith('file:') ? fileURLToPath(uri) : undefined
+const canonical = (file: string | undefined): file is string => !!file && basename(file) === DOCUMENT_ENTRY
+function fileText(file: string): string { try { return readFileSync(file, 'utf8') } catch { return '' } }
 
 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 connection = createConnection(ProposedFeatures.all), documents = new TextDocuments(TextDocument)
+  const devServers = new DevServerLauncher(line => connection.console.log(line))
+  const published = new Map<Deck, Set<string>>(), timers = new Map<Deck, NodeJS.Timeout>()
+  const textOf = (file: string) => documents.get(pathToFileURL(file).href)?.getText() ?? fileText(file)
+  const publishDiagnostics = (deck: Deck) => {
+    const text = textOf(deck.entry), disk = fileText(deck.entry), source = documentDiagnostics(text)
+    const findings = !deck.findingsCurrent || deck.sourceFingerprint !== fnv1a64(disk) || source.some(d => d.severity === 1) || text.replace(/^\uFEFF/, '') !== disk.replace(/^\uFEFF/, '') ? [] : deck.findings
+    const byFile = diagnosticsByFile(findings, deck.entry, textOf)
+    byFile.set(deck.entry, [...source, ...byFile.get(deck.entry) ?? []])
+    const files = new Set([...deck.compilation?.sourceFiles ?? [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: [] })
+    for (const file of files) {
+      const uri = pathToFileURL(file).href
+      void connection.sendDiagnostics({ uri, version: documents.get(uri)?.version, 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 decks = new Decks(publishDiagnostics)
   const changed = (files: string[]) => {
-    for (const deck of decks.all().filter(d => files.some(file => d.reads(file)))) {
+    for (const deck of decks.all().filter(d => files.some(file => d.dependsOn(file)))) {
+      deck.invalidate()
       clearTimeout(timers.get(deck))
-      timers.set(deck, setTimeout(() => void deck.compile(), COMPILE_DELAY))
+      timers.set(deck, setTimeout(() => { timers.delete(deck); 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' },
-    }
+    return { capabilities: {
+      textDocumentSync: { openClose: true, change: TextDocumentSyncKind.Incremental, save: { includeText: false } },
+      definitionProvider: true, hoverProvider: true,
+    }, 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)
+    if (!canonical(file)) return
+    void connection.sendDiagnostics({ uri: document.uri, version: document.version, diagnostics: documentDiagnostics(document.getText()) })
+    void decks.findByFile(file)
   })
-  documents.onDidSave(({ document }) => {
-    const file = fileOf(document.uri)
-    if (file) changed([file])
+  documents.onDidChangeContent(({ document }) => {
+    if (canonical(fileOf(document.uri))) void connection.sendDiagnostics({ uri: document.uri, version: document.version, diagnostics: documentDiagnostics(document.getText()) })
   })
+  documents.onDidSave(({ document }) => { const file = fileOf(document.uri); if (canonical(file)) changed([file]) })
+  documents.onDidClose(({ document }) => { const deck = decks.all().find(deck => pathToFileURL(deck.entry).href === document.uri); if (deck) publishDiagnostics(deck) })
   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 }
+  const sourceAt = (uri: string, position: { line: number, character: number }) => {
+    const file = fileOf(uri)
+    if (!canonical(file)) return undefined
+    const document = documents.get(uri) ?? TextDocument.create(uri, 'json', 0, fileText(file))
+    const source = readDocument(document.getText())
+    const found = source.tree && source.document ? nodeAt(source.tree, document.offsetAt(position)) : undefined
+    return found && source.document ? { ...found, document, file, tree: source.tree!, content: source.document } : undefined
+  }
+  const anchorOf = async (uri: string, position: { line: number, character: number }) => {
+    const found = sourceAt(uri, position)
+    if (!found || found.path[0] !== 'blocks' || found.path.at(-1) !== 'anchor' || found.path.at(-2) !== 'origin' || found.node.type !== 'string') return undefined
+    const block = found.content.blocks[String(found.path[1])]
+    if (block?.type !== 'code') return undefined
+    const deck = await decks.findByFile(found.file)
+    if (!deck?.compilation) return undefined
+    const origin = findNodeAtLocation(found.tree, found.path.slice(0, -1)), pin = origin && getNodeValue(origin)?.pin
+    const ref: AnchorRef = { anchor: found.node.value as AnchorString, blockId: block.id, range: offsetRange(found.document, found.node.offset + 1, found.node.length - 2), ...typeof pin === 'string' ? { pin } : {} }
+    return { compilation: deck.compilation, ref, t: LS_MESSAGES[found.content.metadata.lang === 'en' ? 'en' : 'zh-CN'] }
   }
-
   connection.onDefinition(async ({ textDocument, position }) => {
-    const found = await anchorOf(textDocument.uri, position.line)
-    return found ? anchorDefinition(found.compilation, found.ref) : null
+    const anchor = await anchorOf(textDocument.uri, position)
+    if (anchor) return anchorDefinition(anchor.compilation, anchor.ref)
+    const found = sourceAt(textDocument.uri, position)
+    const target = found && entityReference(found.content, found.path, found.node.value)
+    const node = target && found ? findNodeAtLocation(found.tree, target) : undefined
+    return node && found ? [{ uri: textDocument.uri, range: offsetRange(found.document, node.offset, node.length) }] : 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
+    const found = await anchorOf(textDocument.uri, position)
+    return found ? anchorHover(found.compilation, 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(SECTION_REQUEST, async ({ textDocument, position }: PositionParams): Promise<SectionLocation | null> => {
+    const found = sourceAt(textDocument.uri, position)
+    const id = found && sectionAtPath(found.content, found.path)
+    const section = id && found?.content.sections[id]
+    if (!found || !id || !section) return null
+    const deck = await decks.findByFile(found.file)
+    const link = deck?.compilation ? sectionLinks(webPages(deck.compilation.doc))[id] ?? '/' : '/'
+    return { entry: found.file, id, index: found.content.sectionOrder.indexOf(id) + 1, 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) }
+    const file = fileOf(textDocument.uri), deck = canonical(file) ? await decks.findByFile(file) : undefined
+    if (!deck) throw new Error(`Preview requires a canonical ${DOCUMENT_ENTRY} document.`)
+    return { entry: deck.entry, url: await devServers.urlOf(deck.entry) }
   })
 
-  connection.onShutdown(() => previews.close())
-  process.once('exit', () => void previews.close())
-
+  connection.onShutdown(() => { for (const timer of timers.values()) clearTimeout(timer); timers.clear(); return devServers.close() })
+  process.once('exit', () => void devServers.close())
   documents.listen(connection)
   connection.listen()
 }

package/src/domain/directives.ts

@@ -1,35 +0,0 @@
-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/names.ts

@@ -1,27 +0,0 @@
-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/sections.ts

@@ -1,26 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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/completion.ts

@@ -1,66 +0,0 @@
-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/syntax.ts

@@ -1,30 +0,0 @@
-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 }
-}