@cosense-toolbox/lsp 0.1.0-beta.2

package/LICENSE

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

package/README.md

@@ -0,0 +1,57 @@
+# @cosense-toolbox/lsp
+
+> **beta.** 設定の名前や出力の形はまだ変わりえます。
+
+`.csn` / `.csnx` の Language Server と、同じ判定でサイト全体を調べる `check` コマンド。
+どちらも [`@cosense-toolbox/parser`](../parser) で読むので、記法の解釈が Cosense の描画とずれない。
+
+## Language Server
+
+```sh
+csn-lsp --stdio
+```
+
+- 色付け (semantic tokens)
+- `[` の中と `#` の後での、ページの題名の補完
+- `[ページ名]` からそのページのファイルへの定義ジャンプ
+- 存在しないページへのリンクの診断
+
+設定はエディタの `initialization_options` で渡す。どれも省略できる。
+
+| 設定              | 内容                                                                                   | 既定               |
+| :---------------- | :------------------------------------------------------------------------------------- | :----------------- |
+| `sources`         | ページを読む場所。ワークスペースからの相対パス                                         | ワークスペース全体 |
+| `decorations`     | サイトの `customDecorations` と同じ記号。`[! 注意]` をリンクではなく装飾記法として読む | なし               |
+| `unresolvedLinks` | 存在しないページへのリンクの診断。`off` / `hint` / `information` / `warning` / `error` | `warning`          |
+| `frontmatter`     | 1 行目の `---` を frontmatter (YAML) として飛ばすか                                    | `true`             |
+
+## check
+
+エディタの診断と同じ判定で、サイトのすべてのページのリンクを調べる。CI で使う想定。
+
+```sh
+csn-lsp check src/content src/pages --decorations '|!~#'
+# src/content/posts/a.csn:5:3 error リンク先のページが見つからない: [無いページ]
+```
+
+- 引数のディレクトリの下の `.csn` / `.csnx` を読む。省略すると今いるディレクトリを読む
+- ページの題名はファイルの 1 行目。大文字小文字と、空白と `_` の違いは無視する
+- エラーが 1 件でもあれば終了コード 1、無ければ 0。オプションの誤りは 2
+
+| オプション                   | 内容                                                 | 既定    |
+| :--------------------------- | :--------------------------------------------------- | :------ |
+| `--unresolved-links <level>` | `off` / `hint` / `information` / `warning` / `error` | `error` |
+| `--decorations <markers>`    | サイトの装飾記法の記号を 1 つの文字列で (`'\|!~#'`)  | なし    |
+| `--no-frontmatter`           | 1 行目の `---` を frontmatter ではなく題名として読む |         |
+
+`check` の既定が `error` なのは、ビルドを止めるための道具だから。報告だけにしたいときは
+`--unresolved-links warning` にする (終了コードは 0 になる)。
+
+## ライブラリとして
+
+エディタのプラグインなどから、部品として使える。
+
+- `@cosense-toolbox/lsp/tokens`: `computeTokens` / `encodeTokens` / `legendOf` / `withNotations` など
+  - `notations` で独自の記法 (記号と、送るトークンの型の名前) を足せる
+  - `frontmatter: false` で、1 行目の `---` を YAML として飛ばさずに読める
+- `@cosense-toolbox/lsp/completion`: `detectCompletion` / `completionItems` / `definitionOf` など

package/dist/check.d.mts

@@ -0,0 +1,57 @@
+import "./workspace-pdw-fg9B.mjs";
+import { Effect, Schema } from "effect";
+import { ParseOptions } from "@cosense-toolbox/parser";
+import "vscode-languageserver/node";
+//#region src/diagnostics.d.ts
+/**
+ * Links to pages no file holds.
+ *
+ * Only `[title]` links are checked. A tag names a tag page more often than a page, and a
+ * `[/project/page]` link points outside the workspace; neither is expected to have a file.
+ */
+/** How loudly an unresolved link is reported, as the reader sets it. */
+declare const UnresolvedSeverity: Schema.Literal<["off", "hint", "information", "warning", "error"]>;
+type UnresolvedSeverity = typeof UnresolvedSeverity.Type;
+//#endregion
+//#region src/check.d.ts
+/**
+ * `csn-lsp check`: the server's diagnostics for every page of a site, for a terminal or CI.
+ *
+ * The same functions decide as in the editor, so what the editor flags is what fails here.
+ */
+declare const USAGE = "Usage: csn-lsp check [directory ...] [options]\n\nReads the .csn and .csnx pages under each directory (default: the current one) and reports\nevery [link] to a page none of them holds.\n\nOptions:\n  --unresolved-links <level>  off | hint | information | warning | error (default: error)\n  --decorations <markers>     the site's own decoration markers, as one string: '|!~#'\n  --no-frontmatter            read a first line of --- as the title, not as YAML\n";
+/** What the command prints, and the code it exits with. */
+interface CheckResult {
+  readonly output: string;
+  readonly exitCode: number;
+}
+/** Where to look and how to read, for `checkSite`. */
+interface CheckSiteOptions {
+  /** The directories whose `.csn` / `.csnx` pages are read, and checked against each other. */
+  readonly roots: ReadonlyArray<string>;
+  /** How a link to a missing page is reported; `off` reports none. */
+  readonly unresolvedLinks: UnresolvedSeverity;
+  /** How to parse: a site's notation extensions, as its build parses with. */
+  readonly parseOptions?: ParseOptions;
+  /** Whether a `---` fence on a page's first line opens YAML to skip (default: true). */
+  readonly frontmatter?: boolean;
+}
+type ReportLevel = "error" | "warning" | "information" | "hint";
+/** One thing found: where, counting lines and columns from 1, how loudly, and what. */
+interface Report {
+  readonly path: string;
+  readonly line: number;
+  readonly column: number;
+  readonly level: ReportLevel;
+  readonly message: string;
+}
+/**
+ * Every link to a missing page under `roots`, file by file in the order they were read.
+ * The judgement is the editor's own, so what an editor flags is what is reported here.
+ */
+declare const checkSite: ({ roots, unresolvedLinks, parseOptions, frontmatter }: CheckSiteOptions) => Effect.Effect<ReadonlyArray<Report>>;
+/** Runs a check as `args` asks, from `cwd`. Never fails: a bad option is exit code 2. */
+declare const runCheck: (args: ReadonlyArray<string>, cwd: string) => Effect.Effect<CheckResult>;
+//#endregion
+export { CheckResult, CheckSiteOptions, Report, ReportLevel, USAGE, checkSite, runCheck };
+//# sourceMappingURL=check.d.mts.map

package/dist/check.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.mts","names":[],"sources":["../src/diagnostics.ts","../src/check.ts"],"mappings":";;;;;;;;;;;;cAsBa,oBAAkB,OAAA;KAEnB,4BAA4B,mBAAmB;;;;;;;;cCP9C;;UAYI;WACN;WACA;;;UAIM;;WAEN,OAAO;;WAEP,iBAAiB;;WAEjB,eAAe;;WAEf;;KAGC;;UAGK;WACN;WACA;WACA;WACA,OAAO;WACP;;;;;;cA+DE,cAAa,OAAA,iBAAA,cAAA,eAKvB,qBAAmB,OAAO,OAAO,cAAc;;cAuBrC,WAAY,MAAM,uBAAuB,gBAAc,OAAO,OAAO"}

package/dist/check.mjs

@@ -0,0 +1,89 @@
+import { i as readPageFiles, l as severityOf, n as indexOf, o as defaultSettings, s as parseOptionsOf, u as unresolvedLinkDiagnostics } from "./workspace-DouAOZnK.mjs";
+import { Array as Array$1, Effect, Match, Option, Predicate, pipe } from "effect";
+import { DiagnosticSeverity } from "vscode-languageserver/node";
+import { relative, resolve, sep } from "node:path";
+import { parseArgs } from "node:util";
+//#region src/check.ts
+/**
+* `csn-lsp check`: the server's diagnostics for every page of a site, for a terminal or CI.
+*
+* The same functions decide as in the editor, so what the editor flags is what fails here.
+*/
+const USAGE = `Usage: csn-lsp check [directory ...] [options]
+
+Reads the .csn and .csnx pages under each directory (default: the current one) and reports
+every [link] to a page none of them holds.
+
+Options:
+  --unresolved-links <level>  off | hint | information | warning | error (default: error)
+  --decorations <markers>     the site's own decoration markers, as one string: '|!~#'
+  --no-frontmatter            read a first line of --- as the title, not as YAML
+`;
+/**
+* Reports are errors unless told otherwise: the command exists to stop a build, and a
+* warning that passes would not.
+*/
+const DEFAULT_LEVEL = "error";
+const argsOf = (args, cwd) => pipe(Option.liftThrowable(parseArgs)({
+	args: [...args],
+	allowPositionals: true,
+	strict: true,
+	options: {
+		"unresolved-links": { type: "string" },
+		decorations: { type: "string" },
+		"no-frontmatter": { type: "boolean" }
+	}
+}), Option.map(({ values, positionals }) => ({
+	roots: Array$1.match(positionals, {
+		onEmpty: () => [cwd],
+		onNonEmpty: (directories) => Array$1.map(directories, (directory) => resolve(cwd, directory))
+	}),
+	unresolvedLinks: pipe(Option.fromNullable(values["unresolved-links"]), Option.match({
+		onNone: () => DEFAULT_LEVEL,
+		onSome: severityOf
+	})),
+	parseOptions: parseOptionsOf({
+		...defaultSettings,
+		decorations: Array.from(values.decorations ?? "")
+	}),
+	frontmatter: values["no-frontmatter"] !== true
+})));
+const levelOf = (severity) => Match.value(severity).pipe(Match.when(DiagnosticSeverity.Error, () => "error"), Match.when(DiagnosticSeverity.Warning, () => "warning"), Match.when(DiagnosticSeverity.Information, () => "information"), Match.orElse(() => "hint"));
+/** A file's diagnostic as a report, counting from 1 where the LSP counts from 0. */
+const reportOf = (file) => ({ range, severity, message }) => ({
+	path: file.path,
+	line: range.start.line + 1,
+	column: range.start.character + 1,
+	level: levelOf(severity),
+	message: Predicate.isString(message) ? message : message.value
+});
+/**
+* Every link to a missing page under `roots`, file by file in the order they were read.
+* The judgement is the editor's own, so what an editor flags is what is reported here.
+*/
+const checkSite = ({ roots, unresolvedLinks, parseOptions = {}, frontmatter = true }) => Effect.map(readPageFiles(roots, { frontmatter }), (files) => {
+	const index = indexOf(files);
+	return Array$1.flatMap(files, (file) => Array$1.map(unresolvedLinkDiagnostics(index, file.text, {
+		severity: unresolvedLinks,
+		components: file.path.endsWith(".csnx"),
+		parseOptions,
+		frontmatter
+	}), reportOf(file)));
+});
+/** A report as a line of output: `path:line:column level message`, `path` from `cwd`. */
+const lineOf = (cwd) => ({ path, line, column, level, message }) => `${relative(cwd, path).split(sep).join("/")}:${line}:${column} ${level} ${message}\n`;
+/** Runs a check as `args` asks, from `cwd`. Never fails: a bad option is exit code 2. */
+const runCheck = (args, cwd) => Option.match(argsOf(args, cwd), {
+	onNone: () => Effect.succeed({
+		output: USAGE,
+		exitCode: 2
+	}),
+	onSome: (options) => Effect.map(checkSite(options), (reports) => ({
+		output: Array$1.map(reports, lineOf(cwd)).join(""),
+		exitCode: Array$1.some(reports, ({ level }) => level === "error") ? 1 : 0
+	}))
+});
+//#endregion
+export { USAGE, checkSite, runCheck };
+
+//# sourceMappingURL=check.mjs.map

package/dist/check.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.mjs","names":["Arr"],"sources":["../src/check.ts"],"sourcesContent":["import { relative, resolve, sep } from \"node:path\"\nimport { parseArgs } from \"node:util\"\n\nimport type { ParseOptions } from \"@cosense-toolbox/parser\"\nimport { Array as Arr, Effect, Match, Option, pipe, Predicate } from \"effect\"\nimport { type Diagnostic, DiagnosticSeverity } from \"vscode-languageserver/node\"\n\nimport { severityOf, unresolvedLinkDiagnostics, type UnresolvedSeverity } from \"./diagnostics\"\nimport { defaultSettings, parseOptionsOf } from \"./settings\"\nimport { indexOf, type PageFile, readPageFiles } from \"./workspace\"\n\n/**\n * `csn-lsp check`: the server's diagnostics for every page of a site, for a terminal or CI.\n *\n * The same functions decide as in the editor, so what the editor flags is what fails here.\n */\n\nexport const USAGE = `Usage: csn-lsp check [directory ...] [options]\n\nReads the .csn and .csnx pages under each directory (default: the current one) and reports\nevery [link] to a page none of them holds.\n\nOptions:\n  --unresolved-links <level>  off | hint | information | warning | error (default: error)\n  --decorations <markers>     the site's own decoration markers, as one string: '|!~#'\n  --no-frontmatter            read a first line of --- as the title, not as YAML\n`\n\n/** What the command prints, and the code it exits with. */\nexport interface CheckResult {\n  readonly output: string\n  readonly exitCode: number\n}\n\n/** Where to look and how to read, for `checkSite`. */\nexport interface CheckSiteOptions {\n  /** The directories whose `.csn` / `.csnx` pages are read, and checked against each other. */\n  readonly roots: ReadonlyArray<string>\n  /** How a link to a missing page is reported; `off` reports none. */\n  readonly unresolvedLinks: UnresolvedSeverity\n  /** How to parse: a site's notation extensions, as its build parses with. */\n  readonly parseOptions?: ParseOptions\n  /** Whether a `---` fence on a page's first line opens YAML to skip (default: true). */\n  readonly frontmatter?: boolean\n}\n\nexport type ReportLevel = \"error\" | \"warning\" | \"information\" | \"hint\"\n\n/** One thing found: where, counting lines and columns from 1, how loudly, and what. */\nexport interface Report {\n  readonly path: string\n  readonly line: number\n  readonly column: number\n  readonly level: ReportLevel\n  readonly message: string\n}\n\n/**\n * Reports are errors unless told otherwise: the command exists to stop a build, and a\n * warning that passes would not.\n */\nconst DEFAULT_LEVEL: UnresolvedSeverity = \"error\"\n\nconst argsOf = (args: ReadonlyArray<string>, cwd: string): Option.Option<CheckSiteOptions> =>\n  pipe(\n    Option.liftThrowable(parseArgs)({\n      args: [...args],\n      allowPositionals: true,\n      strict: true,\n      options: {\n        \"unresolved-links\": { type: \"string\" },\n        decorations: { type: \"string\" },\n        \"no-frontmatter\": { type: \"boolean\" },\n      },\n    }),\n    Option.map(({ values, positionals }) => ({\n      roots: Arr.match(positionals, {\n        onEmpty: () => [cwd],\n        onNonEmpty: (directories) => Arr.map(directories, (directory) => resolve(cwd, directory)),\n      }),\n      unresolvedLinks: pipe(\n        Option.fromNullable(values[\"unresolved-links\"]),\n        Option.match({ onNone: () => DEFAULT_LEVEL, onSome: severityOf }),\n      ),\n      // Each marker is one character, so a string of them is the list.\n      parseOptions: parseOptionsOf({\n        ...defaultSettings,\n        decorations: Array.from(values.decorations ?? \"\"),\n      }),\n      frontmatter: values[\"no-frontmatter\"] !== true,\n    })),\n  )\n\nconst levelOf = (severity: DiagnosticSeverity | undefined): ReportLevel =>\n  Match.value(severity).pipe(\n    Match.when(DiagnosticSeverity.Error, (): ReportLevel => \"error\"),\n    Match.when(DiagnosticSeverity.Warning, (): ReportLevel => \"warning\"),\n    Match.when(DiagnosticSeverity.Information, (): ReportLevel => \"information\"),\n    Match.orElse((): ReportLevel => \"hint\"),\n  )\n\n/** A file's diagnostic as a report, counting from 1 where the LSP counts from 0. */\nconst reportOf =\n  (file: PageFile) =>\n  ({ range, severity, message }: Diagnostic): Report => ({\n    path: file.path,\n    line: range.start.line + 1,\n    column: range.start.character + 1,\n    level: levelOf(severity),\n    // The LSP lets a message be markup; a report is text either way.\n    message: Predicate.isString(message) ? message : message.value,\n  })\n\n/**\n * Every link to a missing page under `roots`, file by file in the order they were read.\n * The judgement is the editor's own, so what an editor flags is what is reported here.\n */\nexport const checkSite = ({\n  roots,\n  unresolvedLinks,\n  parseOptions = {},\n  frontmatter = true,\n}: CheckSiteOptions): Effect.Effect<ReadonlyArray<Report>> =>\n  Effect.map(readPageFiles(roots, { frontmatter }), (files) => {\n    const index = indexOf(files)\n    return Arr.flatMap(files, (file) =>\n      Arr.map(\n        unresolvedLinkDiagnostics(index, file.text, {\n          severity: unresolvedLinks,\n          components: file.path.endsWith(\".csnx\"),\n          parseOptions,\n          frontmatter,\n        }),\n        reportOf(file),\n      ),\n    )\n  })\n\n/** A report as a line of output: `path:line:column level message`, `path` from `cwd`. */\nconst lineOf =\n  (cwd: string) =>\n  ({ path, line, column, level, message }: Report): string =>\n    `${relative(cwd, path).split(sep).join(\"/\")}:${line}:${column} ${level} ${message}\\n`\n\n/** Runs a check as `args` asks, from `cwd`. Never fails: a bad option is exit code 2. */\nexport const runCheck = (args: ReadonlyArray<string>, cwd: string): Effect.Effect<CheckResult> =>\n  Option.match(argsOf(args, cwd), {\n    onNone: () => Effect.succeed({ output: USAGE, exitCode: 2 }),\n    onSome: (options) =>\n      Effect.map(checkSite(options), (reports) => ({\n        output: Arr.map(reports, lineOf(cwd)).join(\"\"),\n        exitCode: Arr.some(reports, ({ level }) => level === \"error\") ? 1 : 0,\n      })),\n  })\n"],"mappings":";;;;;;;;;;;AAiBA,MAAa,QAAQ;;;;;;;;;;;;;;AA4CrB,MAAM,gBAAoC;AAE1C,MAAM,UAAU,MAA6B,QAC3C,KACE,OAAO,cAAc,SAAS,CAAC,CAAC;CAC9B,MAAM,CAAC,GAAG,IAAI;CACd,kBAAkB;CAClB,QAAQ;CACR,SAAS;EACP,oBAAoB,EAAE,MAAM,SAAS;EACrC,aAAa,EAAE,MAAM,SAAS;EAC9B,kBAAkB,EAAE,MAAM,UAAU;CACtC;AACF,CAAC,GACD,OAAO,KAAK,EAAE,QAAQ,mBAAmB;CACvC,OAAOA,QAAI,MAAM,aAAa;EAC5B,eAAe,CAAC,GAAG;EACnB,aAAa,gBAAgBA,QAAI,IAAI,cAAc,cAAc,QAAQ,KAAK,SAAS,CAAC;CAC1F,CAAC;CACD,iBAAiB,KACf,OAAO,aAAa,OAAO,mBAAmB,GAC9C,OAAO,MAAM;EAAE,cAAc;EAAe,QAAQ;CAAW,CAAC,CAClE;CAEA,cAAc,eAAe;EAC3B,GAAG;EACH,aAAa,MAAM,KAAK,OAAO,eAAe,EAAE;CAClD,CAAC;CACD,aAAa,OAAO,sBAAsB;AAC5C,EAAE,CACJ;AAEF,MAAM,WAAW,aACf,MAAM,MAAM,QAAQ,CAAC,CAAC,KACpB,MAAM,KAAK,mBAAmB,aAA0B,OAAO,GAC/D,MAAM,KAAK,mBAAmB,eAA4B,SAAS,GACnE,MAAM,KAAK,mBAAmB,mBAAgC,aAAa,GAC3E,MAAM,aAA0B,MAAM,CACxC;;AAGF,MAAM,YACH,UACA,EAAE,OAAO,UAAU,eAAmC;CACrD,MAAM,KAAK;CACX,MAAM,MAAM,MAAM,OAAO;CACzB,QAAQ,MAAM,MAAM,YAAY;CAChC,OAAO,QAAQ,QAAQ;CAEvB,SAAS,UAAU,SAAS,OAAO,IAAI,UAAU,QAAQ;AAC3D;;;;;AAMF,MAAa,aAAa,EACxB,OACA,iBACA,eAAe,CAAC,GAChB,cAAc,WAEd,OAAO,IAAI,cAAc,OAAO,EAAE,YAAY,CAAC,IAAI,UAAU;CAC3D,MAAM,QAAQ,QAAQ,KAAK;CAC3B,OAAOA,QAAI,QAAQ,QAAQ,SACzBA,QAAI,IACF,0BAA0B,OAAO,KAAK,MAAM;EAC1C,UAAU;EACV,YAAY,KAAK,KAAK,SAAS,OAAO;EACtC;EACA;CACF,CAAC,GACD,SAAS,IAAI,CACf,CACF;AACF,CAAC;;AAGH,MAAM,UACH,SACA,EAAE,MAAM,MAAM,QAAQ,OAAO,cAC5B,GAAG,SAAS,KAAK,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ;;AAGtF,MAAa,YAAY,MAA6B,QACpD,OAAO,MAAM,OAAO,MAAM,GAAG,GAAG;CAC9B,cAAc,OAAO,QAAQ;EAAE,QAAQ;EAAO,UAAU;CAAE,CAAC;CAC3D,SAAS,YACP,OAAO,IAAI,UAAU,OAAO,IAAI,aAAa;EAC3C,QAAQA,QAAI,IAAI,SAAS,OAAO,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE;EAC7C,UAAUA,QAAI,KAAK,UAAU,EAAE,YAAY,UAAU,OAAO,IAAI,IAAI;CACtE,EAAE;AACN,CAAC"}

package/dist/completion.d.mts

@@ -0,0 +1,52 @@
+import { t as Index } from "./workspace-pdw-fg9B.mjs";
+import { Option } from "effect";
+import { ParseOptions } from "@cosense-toolbox/parser";
+import { CompletionItem, Definition, Position } from "vscode-languageserver/node";
+//#region src/completion.d.ts
+/**
+ * Where a completion applies, decided from the text alone.
+ *
+ * Cosense's own editor closes a bracket the moment it is typed, so a link is completed
+ * inside a *closed* pair rather than after an opening one. Everything here is pure: the
+ * candidates are somebody else's problem (see workspace.ts).
+ */
+interface CompletionDetection {
+  readonly kind: "link" | "hashtag";
+  readonly query: string;
+  readonly replaceStart: number;
+  readonly replaceEnd: number;
+  /** `replaceStart` up to the cursor — what the client sees as already typed. */
+  readonly typedText: string;
+}
+/**
+ * True when the bracket holds a page link, or is on its way to one — the only bracket
+ * completion answers in.
+ *
+ * The other notations (`[* 見出し]`, `[$ x^2]`, `[taro.icon]`, `[ラベル https://…]`,
+ * `[a.png]`, `[/my-project/page]`) are left alone, because accepting a candidate replaces
+ * the whole bracket and would take the notation with it.
+ */
+declare const isLinkBracket: (inner: string) => boolean;
+/** Pure line/cursor -> completion trigger detection. No AST, no I/O. */
+declare const detectCompletion: (line: string, cursor: number) => Option.Option<CompletionDetection>;
+/**
+ * `detectCompletion` for one line of a document, suppressed inside code. `parseOptions` are
+ * the site's notation extensions, parsed with as the site's build parses.
+ */
+declare const detectCompletionInDocument: (text: string, position: Position, parseOptions?: ParseOptions) => Option.Option<CompletionDetection>;
+/**
+ * Title matching, so `[Side Kanban]` and `[side_kanban]` count as one page the way Cosense
+ * links them: case-insensitive, space and `_` alike, and NFKC so width variants match too.
+ */
+declare const normalizeForMatch: (s: string) => string;
+/** The title as a tag writes it: Cosense folds a space to `_`. */
+declare const asTagName: (title: string) => string;
+/** A title that cannot be written as a tag at all is not offered as one. */
+declare const isTaggable: (title: string) => boolean;
+/** The pages that complete what is typed at `position`, or none outside a link or a tag. */
+declare const completionItems: (index: Index, text: string, position: Position, parseOptions?: ParseOptions) => CompletionItem[];
+/** The file of the page named at `position`, opened at its top. None for a missing page. */
+declare const definitionOf: (index: Index, text: string, position: Position, parseOptions?: ParseOptions) => Option.Option<Definition>;
+//#endregion
+export { CompletionDetection, asTagName, completionItems, definitionOf, detectCompletion, detectCompletionInDocument, isLinkBracket, isTaggable, normalizeForMatch };
+//# sourceMappingURL=completion.d.mts.map

package/dist/completion.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.mts","names":[],"sources":["../src/completion.ts"],"mappings":";;;;;;;;;;;;UAmBiB;WACN;WACA;WACA;WACA;;WAEA;;;;;;;;;;cAiCE,gBAAiB;;cAgEjB,mBACX,cACA,mBACC,OAAO,OAAO;;;;;cAqCJ,6BACX,cACA,UAAU,UACV,eAAc,iBACb,OAAO,OAAO;;;;;cAaJ,oBAAqB;;cAIrB,YAAa;;cAGb,aAAc;;cAoDd,kBACX,OAAO,OACP,cACA,UAAU,UACV,eAAc,iBACb;;cAUU,eACX,OAAO,OACP,cACA,UAAU,UACV,eAAc,iBACb,OAAO,OAAO"}

package/dist/completion.mjs

@@ -0,0 +1,139 @@
+import { Array, Match, Option, pipe } from "effect";
+import { normalizeLineEndings, parse } from "@cosense-toolbox/parser";
+import { collect } from "@cosense-toolbox/parser/utils";
+import { CompletionItemKind } from "vscode-languageserver/node";
+//#region src/completion.ts
+/**
+* The notations a bracket can hold other than a page link: a formula, a project link, a
+* decoration, an icon, a URL, an image path.
+*/
+const OTHER_NOTATIONS = [
+	/^\$/,
+	/^\//,
+	/^[!"#%&'()*+,\-./{|}<>_~]+(?:\s|$)/,
+	/^.+\.icon(?:\*\d+)?$/,
+	/https?:\/\//i,
+	/\.(png|jpe?g|gif|webp|svg|bmp|avif)$/i
+];
+/**
+* True when the bracket holds a page link, or is on its way to one — the only bracket
+* completion answers in.
+*
+* The other notations (`[* 見出し]`, `[$ x^2]`, `[taro.icon]`, `[ラベル https://…]`,
+* `[a.png]`, `[/my-project/page]`) are left alone, because accepting a candidate replaces
+* the whole bracket and would take the notation with it.
+*/
+const isLinkBracket = (inner) => inner === "" || !Array.some(OTHER_NOTATIONS, (notation) => notation.test(inner));
+const isBracket = (char) => char === "[" || char === "]";
+/**
+* The `[` that opens the bracket around `cursor`: the nearest bracket to its left, if that
+* is an opening one. A `[` that is the second half of `[[` opens bold or a large image, not
+* a link.
+*/
+const openingBefore = (line, cursor) => pipe(line.slice(0, cursor).split(""), Array.findLastIndex(isBracket), Option.filter((open) => line[open] === "[" && line[open - 1] !== "["));
+/** The `]` that closes it: the nearest bracket to the right of `cursor`, if a closing one. */
+const closingAfter = (line, cursor) => pipe(line.slice(cursor).split(""), Array.findFirstIndex(isBracket), Option.map((offset) => cursor + offset), Option.filter((close) => line[close] === "]"));
+/** Only inside a *closed* pair, matching Cosense. */
+const detectLink = (line, cursor) => pipe(Option.all([openingBefore(line, cursor), closingAfter(line, cursor)]), Option.map(([open, close]) => ({
+	open,
+	close,
+	inner: line.slice(open + 1, close)
+})), Option.filter(({ inner }) => isLinkBracket(inner)), Option.map(({ open, close, inner }) => ({
+	kind: "link",
+	query: inner,
+	replaceStart: open,
+	replaceEnd: close + 1,
+	typedText: line.slice(open, cursor)
+})));
+/**
+* A `#` at a tag boundary (the line's start, or after whitespace) and the tag name typed
+* after it up to the cursor, mirroring the parser's hashtag construct.
+*/
+const TAG_BEFORE_CURSOR = /(?:^|(?<=\s))#([^\s[\]#]*)$/;
+const detectHashtag = (line, cursor) => pipe(Option.fromNullable(TAG_BEFORE_CURSOR.exec(line.slice(0, cursor))), Option.map(({ index, 1: query = "" }) => ({
+	kind: "hashtag",
+	query,
+	replaceStart: index,
+	replaceEnd: cursor,
+	typedText: line.slice(index, cursor)
+})));
+/** Pure line/cursor -> completion trigger detection. No AST, no I/O. */
+const detectCompletion = (line, cursor) => pipe(detectLink(line, cursor), Option.orElse(() => detectHashtag(line, cursor)));
+/**
+* Inside code, a bracket is not notation. The cursor must be strictly between the
+* backticks (not touching them) to count as inside an inline span.
+*/
+const isInCode = (text, { line, character }, parseOptions) => {
+	const page = parse(text, parseOptions);
+	return Array.some(collect(page, "codeBlock"), ({ position }) => line >= position.start.line && line <= position.end.line) || Array.some(collect(page, "inlineCode"), ({ position }) => line === position.start.line && character > position.start.column && character < position.end.column);
+};
+/**
+* `detectCompletion` for one line of a document, suppressed inside code. `parseOptions` are
+* the site's notation extensions, parsed with as the site's build parses.
+*/
+const detectCompletionInDocument = (text, position, parseOptions = {}) => pipe(Option.liftPredicate(text, (document) => !isInCode(document, position, parseOptions)), Option.map((document) => normalizeLineEndings(document).split("\n")[position.line] ?? ""), Option.flatMap((line) => detectCompletion(line, position.character)));
+/**
+* Title matching, so `[Side Kanban]` and `[side_kanban]` count as one page the way Cosense
+* links them: case-insensitive, space and `_` alike, and NFKC so width variants match too.
+*/
+const normalizeForMatch = (s) => s.normalize("NFKC").toLowerCase().replace(/[_ ]/g, " ");
+/** The title as a tag writes it: Cosense folds a space to `_`. */
+const asTagName = (title) => title.replace(/ /g, "_");
+/** A title that cannot be written as a tag at all is not offered as one. */
+const isTaggable = (title) => !/[\s[\]#]/.test(asTagName(title));
+/** The last part of a `/`-separated location. */
+const fileNameOf = (location) => Option.getOrElse(Array.last(location.split("/")), () => location);
+/**
+* A page as a candidate for `detection`, or None when it does not fit: a tag cannot hold a
+* space or a bracket, so a page whose title does is not offered after `#` (accepting it
+* would write something that reads as two tags).
+*/
+const candidate = (detection, line) => (page) => {
+	const query = normalizeForMatch(detection.query);
+	const normalized = normalizeForMatch(page.title);
+	const notation = Match.value(detection.kind).pipe(Match.when("hashtag", () => `#${asTagName(page.title)}`), Match.when("link", () => `[${page.title}]`), Match.exhaustive);
+	return pipe(Option.some(page), Option.filter(() => detection.kind === "link" || isTaggable(page.title)), Option.filter(() => query === "" || normalized.includes(query)), Option.map(() => ({
+		label: page.title,
+		kind: CompletionItemKind.File,
+		detail: fileNameOf(page.location),
+		documentation: page.location,
+		textEdit: {
+			range: {
+				start: {
+					line,
+					character: detection.replaceStart
+				},
+				end: {
+					line,
+					character: detection.replaceEnd
+				}
+			},
+			newText: notation
+		},
+		filterText: notation,
+		sortText: `${normalized} ${page.location}`
+	})));
+};
+/** The pages that complete what is typed at `position`, or none outside a link or a tag. */
+const completionItems = (index, text, position, parseOptions = {}) => pipe(detectCompletionInDocument(text, position, parseOptions), Option.match({
+	onNone: () => [],
+	onSome: (detection) => Array.filterMap(index.pages, candidate(detection, position.line))
+}));
+/** The file of the page named at `position`, opened at its top. None for a missing page. */
+const definitionOf = (index, text, position, parseOptions = {}) => pipe(detectCompletionInDocument(text, position, parseOptions), Option.map(({ query }) => normalizeForMatch(query)), Option.flatMap((key) => Array.findFirst(index.pages, (page) => normalizeForMatch(page.title) === key)), Option.map(({ uri }) => {
+	const start = {
+		line: 0,
+		character: 0
+	};
+	return {
+		uri,
+		range: {
+			start,
+			end: start
+		}
+	};
+}));
+//#endregion
+export { asTagName, completionItems, definitionOf, detectCompletion, detectCompletionInDocument, isLinkBracket, isTaggable, normalizeForMatch };
+
+//# sourceMappingURL=completion.mjs.map

package/dist/completion.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.mjs","names":["Arr"],"sources":["../src/completion.ts"],"sourcesContent":["import { normalizeLineEndings, parse, type ParseOptions } from \"@cosense-toolbox/parser\"\nimport { collect } from \"@cosense-toolbox/parser/utils\"\nimport { Array as Arr, Match, Option, pipe } from \"effect\"\nimport {\n  type CompletionItem,\n  CompletionItemKind,\n  type Definition,\n  type Position,\n} from \"vscode-languageserver/node\"\n\nimport type { Index, Page } from \"./workspace\"\n\n/**\n * Where a completion applies, decided from the text alone.\n *\n * Cosense's own editor closes a bracket the moment it is typed, so a link is completed\n * inside a *closed* pair rather than after an opening one. Everything here is pure: the\n * candidates are somebody else's problem (see workspace.ts).\n */\nexport interface CompletionDetection {\n  readonly kind: \"link\" | \"hashtag\"\n  readonly query: string\n  readonly replaceStart: number\n  readonly replaceEnd: number\n  /** `replaceStart` up to the cursor — what the client sees as already typed. */\n  readonly typedText: string\n}\n\n// --- Which bracket is a link --------------------------------------------------------------\n\n/**\n * A marker run followed by whitespace, or by nothing at all: the parser waits for a body,\n * but a menu that opens between `[* ` and its text is the flicker this rule exists to stop.\n * The markers are every character Cosense accepts in a decoration, from help-jp/文字装飾記法.\n */\nconst STARTS_DECORATION = /^[!\"#%&'()*+,\\-./{|}<>_~]+(?:\\s|$)/\n\n/**\n * The notations a bracket can hold other than a page link: a formula, a project link, a\n * decoration, an icon, a URL, an image path.\n */\nconst OTHER_NOTATIONS: ReadonlyArray<RegExp> = [\n  /^\\$/,\n  /^\\//,\n  STARTS_DECORATION,\n  /^.+\\.icon(?:\\*\\d+)?$/,\n  /https?:\\/\\//i,\n  /\\.(png|jpe?g|gif|webp|svg|bmp|avif)$/i,\n]\n\n/**\n * True when the bracket holds a page link, or is on its way to one — the only bracket\n * completion answers in.\n *\n * The other notations (`[* 見出し]`, `[$ x^2]`, `[taro.icon]`, `[ラベル https://…]`,\n * `[a.png]`, `[/my-project/page]`) are left alone, because accepting a candidate replaces\n * the whole bracket and would take the notation with it.\n */\nexport const isLinkBracket = (inner: string): boolean =>\n  inner === \"\" || !Arr.some(OTHER_NOTATIONS, (notation) => notation.test(inner))\n\n// --- Where the cursor is ------------------------------------------------------------------\n\nconst isBracket = (char: string): boolean => char === \"[\" || char === \"]\"\n\n/**\n * The `[` that opens the bracket around `cursor`: the nearest bracket to its left, if that\n * is an opening one. A `[` that is the second half of `[[` opens bold or a large image, not\n * a link.\n */\nconst openingBefore = (line: string, cursor: number): Option.Option<number> =>\n  pipe(\n    line.slice(0, cursor).split(\"\"),\n    Arr.findLastIndex(isBracket),\n    Option.filter((open) => line[open] === \"[\" && line[open - 1] !== \"[\"),\n  )\n\n/** The `]` that closes it: the nearest bracket to the right of `cursor`, if a closing one. */\nconst closingAfter = (line: string, cursor: number): Option.Option<number> =>\n  pipe(\n    line.slice(cursor).split(\"\"),\n    Arr.findFirstIndex(isBracket),\n    Option.map((offset) => cursor + offset),\n    Option.filter((close) => line[close] === \"]\"),\n  )\n\n/** Only inside a *closed* pair, matching Cosense. */\nconst detectLink = (line: string, cursor: number): Option.Option<CompletionDetection> =>\n  pipe(\n    Option.all([openingBefore(line, cursor), closingAfter(line, cursor)]),\n    // The whole bracket content, not just up to the cursor: Cosense treats the link text\n    // as one unit, so the candidates are the same wherever the cursor sits.\n    Option.map(([open, close]) => ({ open, close, inner: line.slice(open + 1, close) })),\n    Option.filter(({ inner }) => isLinkBracket(inner)),\n    Option.map(({ open, close, inner }) => ({\n      kind: \"link\",\n      query: inner,\n      replaceStart: open,\n      replaceEnd: close + 1,\n      typedText: line.slice(open, cursor),\n    })),\n  )\n\n/**\n * A `#` at a tag boundary (the line's start, or after whitespace) and the tag name typed\n * after it up to the cursor, mirroring the parser's hashtag construct.\n */\nconst TAG_BEFORE_CURSOR = /(?:^|(?<=\\s))#([^\\s[\\]#]*)$/\n\nconst detectHashtag = (line: string, cursor: number): Option.Option<CompletionDetection> =>\n  pipe(\n    Option.fromNullable(TAG_BEFORE_CURSOR.exec(line.slice(0, cursor))),\n    Option.map(({ index, 1: query = \"\" }) => ({\n      kind: \"hashtag\",\n      query,\n      replaceStart: index,\n      replaceEnd: cursor,\n      typedText: line.slice(index, cursor),\n    })),\n  )\n\n/** Pure line/cursor -> completion trigger detection. No AST, no I/O. */\nexport const detectCompletion = (\n  line: string,\n  cursor: number,\n): Option.Option<CompletionDetection> =>\n  pipe(\n    detectLink(line, cursor),\n    Option.orElse(() => detectHashtag(line, cursor)),\n  )\n\n// --- In a document ------------------------------------------------------------------------\n\n/**\n * Inside code, a bracket is not notation. The cursor must be strictly between the\n * backticks (not touching them) to count as inside an inline span.\n */\nconst isInCode = (\n  text: string,\n  { line, character }: Position,\n  parseOptions: ParseOptions,\n): boolean => {\n  const page = parse(text, parseOptions)\n  return (\n    Arr.some(\n      collect(page, \"codeBlock\"),\n      ({ position }) => line >= position.start.line && line <= position.end.line,\n    ) ||\n    Arr.some(\n      collect(page, \"inlineCode\"),\n      ({ position }) =>\n        line === position.start.line &&\n        character > position.start.column &&\n        character < position.end.column,\n    )\n  )\n}\n\n/**\n * `detectCompletion` for one line of a document, suppressed inside code. `parseOptions` are\n * the site's notation extensions, parsed with as the site's build parses.\n */\nexport const detectCompletionInDocument = (\n  text: string,\n  position: Position,\n  parseOptions: ParseOptions = {},\n): Option.Option<CompletionDetection> =>\n  pipe(\n    Option.liftPredicate(text, (document) => !isInCode(document, position, parseOptions)),\n    Option.map((document) => normalizeLineEndings(document).split(\"\\n\")[position.line] ?? \"\"),\n    Option.flatMap((line) => detectCompletion(line, position.character)),\n  )\n\n// --- Matching titles ----------------------------------------------------------------------\n\n/**\n * Title matching, so `[Side Kanban]` and `[side_kanban]` count as one page the way Cosense\n * links them: case-insensitive, space and `_` alike, and NFKC so width variants match too.\n */\nexport const normalizeForMatch = (s: string): string =>\n  s.normalize(\"NFKC\").toLowerCase().replace(/[_ ]/g, \" \")\n\n/** The title as a tag writes it: Cosense folds a space to `_`. */\nexport const asTagName = (title: string): string => title.replace(/ /g, \"_\")\n\n/** A title that cannot be written as a tag at all is not offered as one. */\nexport const isTaggable = (title: string): boolean => !/[\\s[\\]#]/.test(asTagName(title))\n\n// --- Answers ------------------------------------------------------------------------------\n\n/** The last part of a `/`-separated location. */\nconst fileNameOf = (location: string): string =>\n  Option.getOrElse(Arr.last(location.split(\"/\")), () => location)\n\n/**\n * A page as a candidate for `detection`, or None when it does not fit: a tag cannot hold a\n * space or a bracket, so a page whose title does is not offered after `#` (accepting it\n * would write something that reads as two tags).\n */\nconst candidate =\n  (detection: CompletionDetection, line: number) =>\n  (page: Page): Option.Option<CompletionItem> => {\n    const query = normalizeForMatch(detection.query)\n    const normalized = normalizeForMatch(page.title)\n    const notation = Match.value(detection.kind).pipe(\n      Match.when(\"hashtag\", () => `#${asTagName(page.title)}`),\n      Match.when(\"link\", () => `[${page.title}]`),\n      Match.exhaustive,\n    )\n    return pipe(\n      Option.some(page),\n      Option.filter(() => detection.kind === \"link\" || isTaggable(page.title)),\n      Option.filter(() => query === \"\" || normalized.includes(query)),\n      Option.map((): CompletionItem => ({\n        label: page.title,\n        kind: CompletionItemKind.File,\n        // The file name alone: a whole path is cut off in the menu before the name shows.\n        detail: fileNameOf(page.location),\n        // The whole path, where the editor shows more room once the item is selected.\n        documentation: page.location,\n        // The whole notation is replaced, brackets included: the reader typed the `[`,\n        // and leaving it in place would give `[[title]]`.\n        textEdit: {\n          range: {\n            start: { line, character: detection.replaceStart },\n            end: { line, character: detection.replaceEnd },\n          },\n          newText: notation,\n        },\n        // A client filters by the text from the edit's start to the cursor, `[設` here, so\n        // it has to find that in the notation rather than in the bare title.\n        filterText: notation,\n        sortText: `${normalized} ${page.location}`,\n      })),\n    )\n  }\n\n/** The pages that complete what is typed at `position`, or none outside a link or a tag. */\nexport const completionItems = (\n  index: Index,\n  text: string,\n  position: Position,\n  parseOptions: ParseOptions = {},\n): CompletionItem[] =>\n  pipe(\n    detectCompletionInDocument(text, position, parseOptions),\n    Option.match({\n      onNone: () => [],\n      onSome: (detection) => Arr.filterMap(index.pages, candidate(detection, position.line)),\n    }),\n  )\n\n/** The file of the page named at `position`, opened at its top. None for a missing page. */\nexport const definitionOf = (\n  index: Index,\n  text: string,\n  position: Position,\n  parseOptions: ParseOptions = {},\n): Option.Option<Definition> =>\n  pipe(\n    detectCompletionInDocument(text, position, parseOptions),\n    Option.map(({ query }) => normalizeForMatch(query)),\n    Option.flatMap((key) =>\n      Arr.findFirst(index.pages, (page) => normalizeForMatch(page.title) === key),\n    ),\n    Option.map(({ uri }) => {\n      const start = { line: 0, character: 0 }\n      return { uri, range: { start, end: start } }\n    }),\n  )\n"],"mappings":"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"}

package/dist/main.d.mts

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

package/dist/main.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { Effect, Match, pipe } from "effect";
+//#region src/main.ts
+/**
+* `csn-lsp`: the language server, or with `check` as its first argument, a one-off check of
+* a site's pages that exits with a code a build can act on.
+*
+* Each is loaded only when asked for: the server opens its connection as it loads, which a
+* check must not do.
+*/
+const [command, ...args] = process.argv.slice(2);
+const check = pipe(Effect.promise(() => import("./check.mjs")), Effect.flatMap(({ runCheck }) => runCheck(args, process.cwd())), Effect.tap(({ output, exitCode }) => Effect.sync(() => {
+	(exitCode === 2 ? process.stderr : process.stdout).write(output);
+	process.exitCode = exitCode;
+})));
+const serve = Effect.promise(() => import("./server-DPPxtJ6Y.mjs"));
+Effect.runFork(Match.value(command).pipe(Match.when("check", () => Effect.asVoid(check)), Match.orElse(() => Effect.asVoid(serve))));
+//#endregion
+export {};
+
+//# sourceMappingURL=main.mjs.map

package/dist/main.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.mjs","names":[],"sources":["../src/main.ts"],"sourcesContent":["#!/usr/bin/env node\n/**\n * `csn-lsp`: the language server, or with `check` as its first argument, a one-off check of\n * a site's pages that exits with a code a build can act on.\n *\n * Each is loaded only when asked for: the server opens its connection as it loads, which a\n * check must not do.\n */\nimport { Effect, Match, pipe } from \"effect\"\n\nconst [command, ...args] = process.argv.slice(2)\n\nconst check = pipe(\n  Effect.promise(() => import(\"./check\")),\n  Effect.flatMap(({ runCheck }) => runCheck(args, process.cwd())),\n  Effect.tap(({ output, exitCode }) =>\n    Effect.sync(() => {\n      // A usage error goes where errors go; reports are the command's output.\n      ;(exitCode === 2 ? process.stderr : process.stdout).write(output)\n      process.exitCode = exitCode\n    }),\n  ),\n)\n\nconst serve = Effect.promise(() => import(\"./server\"))\n\nEffect.runFork(\n  Match.value(command).pipe(\n    Match.when(\"check\", () => Effect.asVoid(check)),\n    Match.orElse(() => Effect.asVoid(serve)),\n  ),\n)\n"],"mappings":";;;;;;;;;;AAUA,MAAM,CAAC,SAAS,GAAG,QAAQ,QAAQ,KAAK,MAAM,CAAC;AAE/C,MAAM,QAAQ,KACZ,OAAO,cAAc,OAAO,cAAU,GACtC,OAAO,SAAS,EAAE,eAAe,SAAS,MAAM,QAAQ,IAAI,CAAC,CAAC,GAC9D,OAAO,KAAK,EAAE,QAAQ,eACpB,OAAO,WAAW;CAEf,CAAC,aAAa,IAAI,QAAQ,SAAS,QAAQ,OAAA,CAAQ,MAAM,MAAM;CAChE,QAAQ,WAAW;AACrB,CAAC,CACH,CACF;AAEA,MAAM,QAAQ,OAAO,cAAc,OAAO,wBAAW;AAErD,OAAO,QACL,MAAM,MAAM,OAAO,CAAC,CAAC,KACnB,MAAM,KAAK,eAAe,OAAO,OAAO,KAAK,CAAC,GAC9C,MAAM,aAAa,OAAO,OAAO,KAAK,CAAC,CACzC,CACF"}

package/dist/server-DPPxtJ6Y.mjs

@@ -0,0 +1,100 @@
+import { a as encodeTokens, i as computeTokens, n as LEGEND } from "./tokens-D0NP_uLo.mjs";
+import { completionItems, definitionOf } from "./completion.mjs";
+import { a as rootsOf, c as settingsOf, o as defaultSettings, r as readIndex, s as parseOptionsOf, t as emptyIndex, u as unresolvedLinkDiagnostics } from "./workspace-DouAOZnK.mjs";
+import { Array, Effect, Option, Ref, pipe } from "effect";
+import { ProposedFeatures, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
+//#region src/server.ts
+const connection = createConnection(ProposedFeatures.all);
+const documents = new TextDocuments(TextDocument);
+/** The language ids editors give `.csnx`. Not every editor names the language the same way. */
+const CSNX_LANGUAGE_IDS = ["csnx", "cosense-x"];
+/**
+* `.csnx` is `.csn` plus component lines, so the format is decided per document. The
+* language id the editor sends is trusted first; a file:// URI's suffix is the fallback.
+*/
+const readsComponents = (document) => Array.contains(CSNX_LANGUAGE_IDS, document.languageId) || document.uri.endsWith(".csnx");
+/** What the reader set in the editor's initialization options (see settings.ts). */
+const settings = Ref.unsafeMake(defaultSettings);
+const currentSettings = () => Effect.runSync(Ref.get(settings));
+/** How to parse, so notation reads as the site's build reads it. */
+const currentParseOptions = () => parseOptionsOf(currentSettings());
+const semanticTokensOf = (document) => ({ data: encodeTokens(computeTokens(document.getText(), {
+	components: readsComponents(document),
+	parseOptions: currentParseOptions(),
+	frontmatter: currentSettings().frontmatter
+})) });
+/**
+* `answer` for the open document at `uri`, or `fallback` when the editor asks about one it
+* has not synced yet.
+*/
+const withDocument = (uri, answer, fallback) => pipe(Option.fromNullable(documents.get(uri)), Option.map(answer), Option.getOrElse(() => fallback));
+/**
+* Every page the workspace holds. Read once at initialize and again when a page is saved,
+* because a title only changes by someone writing it, and re-reading on every keystroke
+* would walk the whole tree while the reader is typing.
+*/
+const index = Ref.unsafeMake(Option.none());
+const roots = Ref.unsafeMake([]);
+/** The index as it stands; empty until it has been read once. */
+const currentIndex = () => Option.getOrElse(Effect.runSync(Ref.get(index)), () => emptyIndex);
+/**
+* Sends `document`'s links to missing pages. Nothing until the index has been read once:
+* against an empty index every link would be flagged, only to be cleared a moment later.
+*/
+const publishDiagnostics = (document) => pipe(Effect.all([Ref.get(index), Ref.get(settings)]), Effect.flatMap(([read, set]) => Option.match(read, {
+	onNone: () => Effect.void,
+	onSome: (pages) => Effect.promise(() => connection.sendDiagnostics({
+		uri: document.uri,
+		diagnostics: unresolvedLinkDiagnostics(pages, document.getText(), {
+			severity: set.unresolvedLinks,
+			components: readsComponents(document),
+			parseOptions: parseOptionsOf(set),
+			frontmatter: set.frontmatter
+		})
+	}))
+})));
+/**
+* Reads the index again in the background; requests meanwhile answer from the last one.
+* A page may have appeared or gone, so every open document is checked again after.
+*/
+const refreshIndex = () => {
+	pipe(Effect.all([Ref.get(roots), Ref.get(settings)]), Effect.flatMap(([at, set]) => readIndex(at, { frontmatter: set.frontmatter })), Effect.flatMap((next) => Ref.set(index, Option.some(next))), Effect.flatMap(() => Effect.forEach(documents.all(), publishDiagnostics, { discard: true })), Effect.runFork);
+};
+connection.onInitialize(({ workspaceFolders, initializationOptions }) => {
+	const read = settingsOf(initializationOptions);
+	Effect.runSync(Ref.set(settings, read));
+	Effect.runSync(Ref.set(roots, rootsOf(workspaceFolders, read.sources)));
+	refreshIndex();
+	return { capabilities: {
+		textDocumentSync: TextDocumentSyncKind.Incremental,
+		semanticTokensProvider: {
+			legend: {
+				tokenTypes: [...LEGEND],
+				tokenModifiers: []
+			},
+			full: true
+		},
+		completionProvider: { triggerCharacters: ["[", "#"] },
+		definitionProvider: true
+	} };
+});
+documents.onDidSave(refreshIndex);
+documents.onDidChangeContent(({ document }) => {
+	Effect.runFork(publishDiagnostics(document));
+});
+documents.onDidClose(({ document }) => {
+	Effect.runFork(Effect.promise(() => connection.sendDiagnostics({
+		uri: document.uri,
+		diagnostics: []
+	})));
+});
+connection.onCompletion(({ textDocument: { uri }, position }) => withDocument(uri, (document) => completionItems(currentIndex(), document.getText(), position, currentParseOptions()), []));
+connection.onDefinition(({ textDocument: { uri }, position }) => withDocument(uri, (document) => Option.getOrNull(definitionOf(currentIndex(), document.getText(), position, currentParseOptions())), null));
+connection.languages.semanticTokens.on(({ textDocument: { uri } }) => withDocument(uri, semanticTokensOf, { data: [] }));
+documents.listen(connection);
+connection.listen();
+//#endregion
+export {};
+
+//# sourceMappingURL=server-DPPxtJ6Y.mjs.map

package/dist/server-DPPxtJ6Y.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-DPPxtJ6Y.mjs","names":["Arr"],"sources":["../src/server.ts"],"sourcesContent":["import { Array as Arr, Effect, Option, pipe, Ref } from \"effect\"\nimport {\n  type CompletionItem,\n  createConnection,\n  type Definition,\n  type InitializeResult,\n  ProposedFeatures,\n  type SemanticTokens,\n  TextDocuments,\n  TextDocumentSyncKind,\n} from \"vscode-languageserver/node\"\nimport { TextDocument } from \"vscode-languageserver-textdocument\"\n\nimport { completionItems, definitionOf } from \"./completion\"\nimport { unresolvedLinkDiagnostics } from \"./diagnostics\"\nimport { defaultSettings, parseOptionsOf, settingsOf } from \"./settings\"\nimport { computeTokens, encodeTokens, LEGEND } from \"./tokens\"\nimport { emptyIndex, type Index, readIndex, rootsOf } from \"./workspace\"\n\nconst connection = createConnection(ProposedFeatures.all)\nconst documents = new TextDocuments(TextDocument)\n\n/** The language ids editors give `.csnx`. Not every editor names the language the same way. */\nconst CSNX_LANGUAGE_IDS: ReadonlyArray<string> = [\"csnx\", \"cosense-x\"]\n\n/**\n * `.csnx` is `.csn` plus component lines, so the format is decided per document. The\n * language id the editor sends is trusted first; a file:// URI's suffix is the fallback.\n */\nconst readsComponents = (document: TextDocument): boolean =>\n  Arr.contains(CSNX_LANGUAGE_IDS, document.languageId) || document.uri.endsWith(\".csnx\")\n\n// --- Settings -----------------------------------------------------------------------------\n\n/** What the reader set in the editor's initialization options (see settings.ts). */\nconst settings = Ref.unsafeMake(defaultSettings)\n\nconst currentSettings = () => Effect.runSync(Ref.get(settings))\n\n/** How to parse, so notation reads as the site's build reads it. */\nconst currentParseOptions = () => parseOptionsOf(currentSettings())\n\nconst semanticTokensOf = (document: TextDocument): SemanticTokens => ({\n  data: encodeTokens(\n    computeTokens(document.getText(), {\n      components: readsComponents(document),\n      parseOptions: currentParseOptions(),\n      frontmatter: currentSettings().frontmatter,\n    }),\n  ),\n})\n\n/**\n * `answer` for the open document at `uri`, or `fallback` when the editor asks about one it\n * has not synced yet.\n */\nconst withDocument = <A>(uri: string, answer: (document: TextDocument) => A, fallback: A): A =>\n  pipe(\n    Option.fromNullable(documents.get(uri)),\n    Option.map(answer),\n    Option.getOrElse(() => fallback),\n  )\n\n// --- The workspace index --------------------------------------------------------------------\n\n/**\n * Every page the workspace holds. Read once at initialize and again when a page is saved,\n * because a title only changes by someone writing it, and re-reading on every keystroke\n * would walk the whole tree while the reader is typing.\n */\nconst index = Ref.unsafeMake<Option.Option<Index>>(Option.none())\nconst roots = Ref.unsafeMake<ReadonlyArray<string>>([])\n\n/** The index as it stands; empty until it has been read once. */\nconst currentIndex = (): Index => Option.getOrElse(Effect.runSync(Ref.get(index)), () => emptyIndex)\n\n// --- Diagnostics --------------------------------------------------------------------------\n\n/**\n * Sends `document`'s links to missing pages. Nothing until the index has been read once:\n * against an empty index every link would be flagged, only to be cleared a moment later.\n */\nconst publishDiagnostics = (document: TextDocument): Effect.Effect<void> =>\n  pipe(\n    Effect.all([Ref.get(index), Ref.get(settings)]),\n    Effect.flatMap(([read, set]) =>\n      Option.match(read, {\n        onNone: () => Effect.void,\n        onSome: (pages) =>\n          Effect.promise(() =>\n            connection.sendDiagnostics({\n              uri: document.uri,\n              diagnostics: unresolvedLinkDiagnostics(pages, document.getText(), {\n                severity: set.unresolvedLinks,\n                components: readsComponents(document),\n                parseOptions: parseOptionsOf(set),\n                frontmatter: set.frontmatter,\n              }),\n            }),\n          ),\n      }),\n    ),\n  )\n\n/**\n * Reads the index again in the background; requests meanwhile answer from the last one.\n * A page may have appeared or gone, so every open document is checked again after.\n */\nconst refreshIndex = (): void => {\n  pipe(\n    Effect.all([Ref.get(roots), Ref.get(settings)]),\n    Effect.flatMap(([at, set]) => readIndex(at, { frontmatter: set.frontmatter })),\n    Effect.flatMap((next) => Ref.set(index, Option.some(next))),\n    Effect.flatMap(() => Effect.forEach(documents.all(), publishDiagnostics, { discard: true })),\n    Effect.runFork,\n  )\n}\n\n// --- Handlers -----------------------------------------------------------------------------\n\nconnection.onInitialize(({ workspaceFolders, initializationOptions }): InitializeResult => {\n  const read = settingsOf(initializationOptions)\n  Effect.runSync(Ref.set(settings, read))\n  Effect.runSync(Ref.set(roots, rootsOf(workspaceFolders, read.sources)))\n  refreshIndex()\n  return {\n    capabilities: {\n      // Incremental: a page is one file the reader types into, and resending all of it on\n      // every keystroke is what makes a large page feel slow.\n      textDocumentSync: TextDocumentSyncKind.Incremental,\n      semanticTokensProvider: {\n        legend: { tokenTypes: [...LEGEND], tokenModifiers: [] },\n        full: true,\n      },\n      // `[` and `#` open a link and a tag. The editor asks again on every character after\n      // one, so nothing else has to be declared for typing to keep the menu up to date.\n      completionProvider: { triggerCharacters: [\"[\", \"#\"] },\n      definitionProvider: true,\n    },\n  }\n})\n\n// A title only changes when a page is written, so the index is rebuilt then rather than\n// on a timer or on every request.\ndocuments.onDidSave(refreshIndex)\n\n// Opening a document counts as a change, so this covers both.\ndocuments.onDidChangeContent(({ document }) => {\n  Effect.runFork(publishDiagnostics(document))\n})\n\n// A closed document's diagnostics would otherwise linger in the editor's problem list.\ndocuments.onDidClose(({ document }) => {\n  Effect.runFork(\n    Effect.promise(() => connection.sendDiagnostics({ uri: document.uri, diagnostics: [] })),\n  )\n})\n\nconnection.onCompletion(({ textDocument: { uri }, position }): CompletionItem[] =>\n  withDocument(\n    uri,\n    (document) =>\n      completionItems(currentIndex(), document.getText(), position, currentParseOptions()),\n    [],\n  ),\n)\n\nconnection.onDefinition(({ textDocument: { uri }, position }): Definition | null =>\n  withDocument(\n    uri,\n    (document) =>\n      Option.getOrNull(\n        definitionOf(currentIndex(), document.getText(), position, currentParseOptions()),\n      ),\n    null,\n  ),\n)\n\nconnection.languages.semanticTokens.on(({ textDocument: { uri } }): SemanticTokens =>\n  // Asked before the document was synced: nothing to colour yet.\n  withDocument(uri, semanticTokensOf, { data: [] }),\n)\n\ndocuments.listen(connection)\nconnection.listen()\n"],"mappings":"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"}