@kupcad/editor 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,77 @@
-# Temporary Holding Version
+# @kupcad/editor
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+CodeMirror 6 for a KupCAD (`.kup`) script, for the web hosts (the playground, the desktop app,
+later the PWA; VS Code has its own editor): the language's highlighting, its blocks indented,
+its words completed, and the core's findings marked where they are, or a language server's
+features. A class any host can own,
+and a Svelte component around it.
+
+```js
+import { Editor } from '@kupcad/editor';
+
+const editor = new Editor(element, {
+  value: source,
+  onchange: (value) => run(value), // the user's changes; a host's own (setValue) aren't told
+  label: 'bracket.kup', // what the script is, for a screen reader
+});
+editor.setFindings(await kupcad.check(editor.value)); // underlined, in the gutter, a fix one click away
+editor.setFindings([{ severity: 'error', message, line, column }]); // a place a run named: a point
+editor.reveal(line, column); // the cursor there, in view, the focus in the editor
+editor.setValue(other);
+const kept = editor.snapshot(); // plain JSON: the script, its selection and its undo history
+editor.dispose();
+// Another script shown meanwhile, this one back as it was left, undo and all; `value` put in
+// place of the snapshot's text where the file changed since (itself undoable)
+const again = new Editor(element, { value: source, restore: kept });
+```
+
+```svelte
+<script>
+  import { Editor } from '@kupcad/editor/svelte';
+  let source = $state('cube(10)\n');
+</script>
+
+<Editor bind:value={source} {findings} bind:editor />
+```
+
+* **The language** (`language.js`): the literals are Ruby's (strings with interpolation, the
+  single-quoted ones, `%w` and `%q`, heredocs, symbols, comments), so CodeMirror's Ruby mode
+  reads them and indents the blocks; the words are the core's. `src/vocabulary.json` is the
+  lexer's keywords, every global function (`cube`, `param`, `raise`) and every method (a
+  Solid's, a value's, a class's), which `zig build grammar` writes from the core beside the VS
+  Code grammar, and a core test fails while it is behind. So `raise` is a function and `import`
+  a keyword, as KupCAD has them, not as Ruby does; `in` is a keyword after `for` alone. The same
+  words are completed: a word with the keywords and functions, a name after a dot with the
+  methods. `kupcad()` gives the language to a host's own CodeMirror.
+* **Findings** (`findings.js`): the core places them by 1-based lines and columns in UTF-8 bytes
+  (`@kupcad/protocol`'s `characterAt` reads them); `check`'s have an end, and a fix becomes an
+  action in its tooltip, made only on the text it was found in. A place a run named (its error, a
+  warning) is a point. Marked in place of the last ones given, they move with the edits made
+  until the next ones come.
+* **A language server** (`language-server.js`, `@codemirror/lsp-client`): for a host that runs
+  `kupcad lsp` (the desktop app), over any stream of bytes, its child process's stdin and
+  stdout. `streamTransport(stream, onError)` frames each message as LSP frames them on stdio
+  (`Content-Length`, then the JSON) and reads the server's frames back however its chunks are
+  cut (`MessageReader`); a stream that isn't framed so is `onError`'s, the messages before the
+  fault read and reading started over with the next chunk. `languageServerClient({ rootUri, notifications })` is the client with
+  every feature the package has, a server's own notifications (`kupcad/viewportReady`) handled
+  by the host. An editor given `languageServer: { client, uri }` opens its script on the server
+  (`kupcad`, its language) and takes the server's diagnostics, completion (in place of the
+  vocabulary's: the server knows the script's own names), hovers, signatures, formatting,
+  renaming and definitions; its host gives it no findings then.
+
+  ```js
+  const client = languageServerClient({ rootUri: 'file:///work' });
+  client.connect(streamTransport({ write, read }, (error) => log(error.message)));
+  new Editor(element, { value, languageServer: { client, uri: 'file:///work/part.kup' } });
+  ```
+* **The look** (`theme.js`): the `--kc-*` tokens of `@kupcad/ui` (the page's own colours where
+  they are unset), and the code's colours by `--kc-code-keyword`, `-string`, `-comment`,
+  `-constant`, `-function` and `-definition` (GitHub's, light or dark, where unset);
+  `--kc-code-font` and `--kc-code-font-size`.
+
+Tests: the highlighting, indentation and completion on the parsed text, the findings placed (the
+real core's `check`, through `@kupcad/wasm`) and their fixes made, a snapshot restored (its undo
+history, its selection, a text changed since, one it can't read), the editor and its Svelte
+component under jsdom, the LSP frames cut at every byte, and an editor opening its script on a
+stand-in server whose diagnostics it marks.

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@kupcad/editor",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "KupCAD's code editor for the web: CodeMirror 6 with the language's highlighting and the core's findings marked, and a Svelte component around it.",
+  "license": "AGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kupcad/kupcad.git",
+    "directory": "packages/kupcad-editor"
+  },
+  "files": [
+    "src",
+    "!src/**/*.test.js",
+    "!src/**/*.test-helper.*"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js",
+    "./svelte": {
+      "svelte": "./src/svelte.js",
+      "default": "./src/svelte.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@codemirror/autocomplete": "^6.20.4",
+    "@codemirror/commands": "^6.11.1",
+    "@codemirror/language": "^6.13.1",
+    "@codemirror/legacy-modes": "^6.5.5",
+    "@codemirror/lint": "^6.9.7",
+    "@codemirror/lsp-client": "^6.3.0",
+    "@codemirror/search": "^6.7.2",
+    "@codemirror/state": "^6.7.6",
+    "@codemirror/view": "^6.43.15",
+    "@kupcad/protocol": "0.1.1",
+    "@lezer/highlight": "^1.2.5"
+  },
+  "devDependencies": {
+    "@kupcad/wasm": "0.1.1",
+    "@sveltejs/vite-plugin-svelte": "^7.3.1",
+    "@testing-library/svelte": "^5.4.2",
+    "@types/node": "^26.6.5",
+    "jsdom": "^30.1.3",
+    "svelte": "^5.57.2",
+    "svelte-check": "^4.7.7",
+    "vite": "^8.3.5",
+    "vitest": "^5.0.5"
+  },
+  "peerDependencies": {
+    "svelte": "^5.57.2"
+  },
+  "peerDependenciesMeta": {
+    "svelte": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "check": "svelte-check --tsconfig ./jsconfig.json --fail-on-warnings",
+    "test": "vitest run"
+  }
 }

package/src/Editor.svelte

@@ -0,0 +1,74 @@
+<!--
+  @component
+  The editor for Svelte: CodeMirror on a KupCAD script, filling its box. `value` is bindable (the
+  user's changes set it, a host's reach the editor), and so is `editor`, the Editor itself, for
+  what isn't state: `reveal(line, column)`, `focus()`. `findings` are marked as given; with a
+  `languageServer` (set when it mounts) the server's are, and no findings are given.
+-->
+<script>
+  import { onMount } from 'svelte';
+  import { Editor } from './editor.js';
+
+  /** @import { Mark } from './findings.js' */
+
+  /**
+   * @typedef {object} Props
+   * @property {string} [value] the script; bindable
+   * @property {readonly Mark[]} [findings] what to mark in it: `check`'s, a run's error
+   * @property {Editor | null} [editor] the Editor, once mounted; bindable
+   * @property {string} [label] what the script is, for a screen reader
+   * @property {(value: string) => void} [onchange] the user changed the script
+   * @property {import('./editor.js').EditorOptions['languageServer']} [languageServer] the
+   *   server the script is known to, by its URI
+   * @property {unknown} [restore] an earlier editor's `snapshot()` of the script, its undo
+   *   history with it (read when it mounts)
+   */
+
+  /** @type {Props} */
+  let {
+    value = $bindable(''),
+    findings = [],
+    editor = $bindable(null),
+    label = 'The script',
+    onchange,
+    languageServer,
+    restore,
+  } = $props();
+
+  /** @type {HTMLDivElement} */
+  let root;
+
+  onMount(() => {
+    const made = new Editor(root, {
+      value,
+      label,
+      languageServer,
+      restore,
+      onchange: (next) => {
+        value = next;
+        onchange?.(next);
+      },
+    });
+    editor = made;
+    return () => {
+      made.dispose();
+      editor = null;
+    };
+  });
+
+  $effect(() => {
+    editor?.setValue(value);
+  });
+  $effect(() => {
+    editor?.setFindings(findings);
+  });
+</script>
+
+<div class="kc-editor" bind:this={root}></div>
+
+<style>
+  .kc-editor {
+    height: 100%;
+    min-height: 0;
+  }
+</style>

package/src/editor.js

@@ -0,0 +1,184 @@
+// The editor: CodeMirror 6 for a KupCAD script, for any host; Editor.svelte wraps it for Svelte.
+// It highlights the language and completes its words (language.js), indents its blocks, and
+// marks the findings its host gives it (findings.js: the core's `check`, a run's error), each
+// underlined and in the gutter, its fix an action. With a language server
+// (language-server.js), the server completes, marks and answers instead: hovers, signatures,
+// formatting, renaming, definitions. It tells its host of each change the user makes to the
+// script; one the host makes (setValue) it doesn't. A host that shows another script in its
+// place keeps this one's snapshot(), its undo history with it, and restores it (`restore`).
+
+import {
+  autocompletion,
+  closeBrackets,
+  closeBracketsKeymap,
+  completionKeymap,
+} from '@codemirror/autocomplete';
+import {
+  defaultKeymap,
+  history,
+  historyField,
+  historyKeymap,
+  indentWithTab,
+} from '@codemirror/commands';
+import {
+  bracketMatching,
+  indentOnInput,
+  indentUnit,
+  syntaxHighlighting,
+} from '@codemirror/language';
+import { lintGutter, lintKeymap, setDiagnostics } from '@codemirror/lint';
+import { highlightSelectionMatches, searchKeymap } from '@codemirror/search';
+import { Annotation, EditorState } from '@codemirror/state';
+import {
+  drawSelection,
+  EditorView,
+  highlightActiveLine,
+  highlightActiveLineGutter,
+  keymap,
+  lineNumbers,
+} from '@codemirror/view';
+import { diagnosticsOf, positionOf } from './findings.js';
+import { kupcad } from './language.js';
+import { editorTheme, highlightStyle } from './theme.js';
+
+/** @import { LSPClient } from '@codemirror/lsp-client' */
+/** @import { Mark } from './findings.js' */
+
+/** A change the host made (setValue): not the user's, so not told back. */
+const fromHost = Annotation.define();
+/**
+ * The state a `snapshot()` was of, on `extensions`; null for none, or one it can't read.
+ * @param {unknown} snapshot
+ * @param {import('@codemirror/state').Extension[]} extensions
+ */
+function restoredState(snapshot, extensions) {
+  if (snapshot === undefined || snapshot === null) return null;
+  try {
+    return EditorState.fromJSON(snapshot, { extensions }, { history: historyField });
+  } catch {
+    return null;
+  }
+}
+/** Two spaces a level, as `kupcad fmt` indents. */
+const INDENT = '  ';
+/** The language, as a language server is told a document's (and VS Code names it). */
+export const LANGUAGE_ID = 'kupcad';
+
+/**
+ * @typedef {object} EditorOptions
+ * @property {string} [value] the script it starts with
+ * @property {(value: string) => void} [onchange] the user changed the script: it now is `value`
+ * @property {string} [label] what the script is, for a screen reader
+ * @property {{ client: LSPClient, uri: string }} [languageServer] the server the script is known
+ *   to, by its URI: it completes and marks the script then, and the host gives no findings
+ * @property {unknown} [restore] a `snapshot()` of an editor of this script: it starts as that one
+ *   was (its undo history, its selection), `value` put in place of its text where they differ;
+ *   one it can't read is passed over
+ */
+
+export class Editor {
+  /** @type {EditorView} */
+  #view;
+
+  /**
+   * @param {HTMLElement} parent where it goes
+   * @param {EditorOptions} [options]
+   */
+  constructor(
+    parent,
+    { value = '', onchange, label = 'The script', languageServer, restore } = {},
+  ) {
+    const extensions = [
+      lineNumbers(),
+      highlightActiveLineGutter(),
+      history(),
+      drawSelection(),
+      indentOnInput(),
+      indentUnit.of(INDENT),
+      EditorState.tabSize.of(INDENT.length),
+      bracketMatching(),
+      closeBrackets(),
+      autocompletion(),
+      highlightActiveLine(),
+      highlightSelectionMatches(),
+      lintGutter(),
+      kupcad({ complete: !languageServer }),
+      syntaxHighlighting(highlightStyle),
+      editorTheme,
+      keymap.of([
+        ...closeBracketsKeymap,
+        ...defaultKeymap,
+        ...searchKeymap,
+        ...historyKeymap,
+        ...completionKeymap,
+        ...lintKeymap,
+        indentWithTab,
+      ]),
+      languageServer ? languageServer.client.plugin(languageServer.uri, LANGUAGE_ID) : [],
+      EditorView.contentAttributes.of({ 'aria-label': label }),
+      EditorView.updateListener.of((update) => {
+        const user = !update.transactions.some((tr) => tr.annotation(fromHost));
+        if (update.docChanged && user) onchange?.(update.state.doc.toString());
+      }),
+    ];
+    this.#view = new EditorView({
+      parent,
+      state: restoredState(restore, extensions) ?? EditorState.create({ doc: value, extensions }),
+    });
+    // The text the host gives now, where the snapshot's is another (the file changed since)
+    this.setValue(value);
+  }
+
+  /** The editor as it is now, its undo history with it, for `restore`: plain JSON. */
+  snapshot() {
+    return this.#view.state.toJSON({ history: historyField });
+  }
+  /** The script as it is now. */
+  get value() {
+    return this.#view.state.doc.toString();
+  }
+
+  /**
+   * Puts `value` in place of the script, unless it is the script already; the host isn't told.
+   * @param {string} value
+   */
+  setValue(value) {
+    if (value === this.value) return;
+    this.#view.dispatch({
+      changes: { from: 0, to: this.#view.state.doc.length, insert: value },
+      annotations: fromHost.of(true),
+    });
+  }
+
+  /**
+   * Marks `findings` in place of the ones marked, found in the script as it is now.
+   * @param {readonly Mark[]} findings
+   */
+  setFindings(findings) {
+    const { state } = this.#view;
+    this.#view.dispatch(setDiagnostics(state, diagnosticsOf(state.doc, findings)));
+  }
+
+  /**
+   * Puts the cursor at a place the core names (a 1-based line and column, in UTF-8 bytes), in
+   * view, and gives the editor the focus.
+   * @param {number} line
+   * @param {number} column
+   */
+  reveal(line, column) {
+    const at = positionOf(this.#view.state.doc, line, column);
+    this.#view.dispatch({
+      selection: { anchor: at },
+      effects: EditorView.scrollIntoView(at, { y: 'center' }),
+    });
+    this.#view.focus();
+  }
+
+  focus() {
+    this.#view.focus();
+  }
+
+  dispose() {
+    this.#view.destroy();
+  }
+}

package/src/findings.js

@@ -0,0 +1,74 @@
+// The core's findings as CodeMirror's diagnostics: `check`'s, and a place a run named (its error,
+// a warning) given as one. Each is underlined where it is and marked in the gutter, and a fix
+// the core offers is an action in its tooltip. The core places them by 1-based lines and
+// columns in UTF-8 bytes (@kupcad/protocol's characterAt reads them).
+
+import { characterAt } from '@kupcad/protocol';
+
+/** @import { Diagnostic } from '@codemirror/lint' */
+/** @import { Text } from '@codemirror/state' */
+/** @import { EditorView } from '@codemirror/view' */
+/** @import { Finding, Fix } from '@kupcad/protocol/types' */
+
+/**
+ * What the editor marks: a finding of `check`, or a place a run named, which has no end (the
+ * mark is a point there).
+ * @typedef {Pick<Finding, 'severity' | 'message' | 'line' | 'column'> & Partial<Pick<Finding, 'endLine' | 'endColumn' | 'code' | 'fix'>>} Mark
+ */
+
+/**
+ * Where a place the core names (a 1-based line and column in UTF-8 bytes) is in `doc`: a line
+ * past its last is its last, a column past a line's end its end.
+ * @param {Text} doc
+ * @param {number} line
+ * @param {number} column
+ */
+export function positionOf(doc, line, column) {
+  const at = doc.line(Math.min(Math.max(line, 1), doc.lines));
+  return at.from + characterAt(at.text, column);
+}
+
+/**
+ * The marks as diagnostics in `doc`, the text they were found in.
+ * @param {Text} doc
+ * @param {readonly Mark[]} marks
+ * @returns {Diagnostic[]}
+ */
+export function diagnosticsOf(doc, marks) {
+  return marks.map((mark) => {
+    const from = positionOf(doc, mark.line, mark.column);
+    const end =
+      mark.endLine === undefined ? from : positionOf(doc, mark.endLine, mark.endColumn ?? 1);
+    /** @type {Diagnostic} */
+    const diagnostic = {
+      from,
+      to: Math.max(from, end),
+      severity: mark.severity,
+      message: mark.message,
+    };
+    if (mark.code) diagnostic.source = mark.code;
+    if (mark.fix) diagnostic.actions = [actionOf(mark.fix, doc)];
+    return diagnostic;
+  });
+}
+
+/**
+ * A fix as an action: its edits made, on the text it was found in; once the text is another,
+ * nothing (its places are the old text's: the next check offers it again, placed in the new).
+ * @param {Fix} fix
+ * @param {Text} doc
+ */
+function actionOf(fix, doc) {
+  const changes = fix.edits.map((edit) => ({
+    from: positionOf(doc, edit.line, edit.column),
+    to: positionOf(doc, edit.endLine, edit.endColumn),
+    insert: edit.text,
+  }));
+  return {
+    name: fix.title,
+    /** @param {EditorView} view */
+    apply(view) {
+      if (view.state.doc.eq(doc)) view.dispatch({ changes });
+    },
+  };
+}

package/src/index.js

@@ -0,0 +1,17 @@
+// @kupcad/editor: CodeMirror 6 for a KupCAD script, for any host (Editor), and for Svelte
+// (`@kupcad/editor/svelte`); the language alone, for a host's own CodeMirror (kupcad()); and a
+// client of `kupcad lsp` over a byte stream for it (language-server.js).
+
+export { Editor, LANGUAGE_ID } from './editor.js';
+export { kupcad } from './language.js';
+export {
+  FramingError,
+  frameMessage,
+  languageServerClient,
+  MessageReader,
+  streamTransport,
+} from './language-server.js';
+
+/** @typedef {import('./findings.js').Mark} Mark */
+/** @typedef {import('./language-server.js').ByteStream} ByteStream */
+/** @typedef {import('@codemirror/lsp-client').LSPClient} LSPClient */

package/src/language-server.js

@@ -0,0 +1,163 @@
+// The editor's language server (@codemirror/lsp-client): `kupcad lsp` over a stream of bytes, a
+// host's child process (the desktop app's), its messages framed as LSP frames them on stdio, a
+// `Content-Length` header before each JSON body. The client gives the editor the server's
+// diagnostics, completion, hover, signature help, formatting, renaming and definitions.
+
+import { LSPClient, languageServerExtensions } from '@codemirror/lsp-client';
+
+/** @import { Transport } from '@codemirror/lsp-client' */
+
+const HEADER_END = new TextEncoder().encode('\r\n\r\n');
+const CONTENT_LENGTH = /^content-length:\s*(\d+)\s*$/im;
+/** A header block longer than this is no LSP header: the stream isn't the server's. */
+const MAX_HEADER_BYTES = 1024;
+
+/** A stream that isn't framed as LSP frames its messages. */
+export class FramingError extends Error {
+  /** @param {string} message */
+  constructor(message) {
+    super(message);
+    this.name = 'FramingError';
+  }
+}
+
+/**
+ * `message` (JSON) as LSP frames it: its length in UTF-8 bytes, then it.
+ * @param {string} message
+ * @returns {Uint8Array}
+ */
+export function frameMessage(message) {
+  const body = new TextEncoder().encode(message);
+  const header = new TextEncoder().encode(`Content-Length: ${body.length}\r\n\r\n`);
+  const framed = new Uint8Array(header.length + body.length);
+  framed.set(header);
+  framed.set(body, header.length);
+  return framed;
+}
+
+/**
+ * The messages in a stream of LSP frames, as its chunks arrive, cut wherever they are. A stream
+ * that isn't framed so (a header with no length, or none where one should be) is `onError`'s:
+ * the messages before the fault are read, what follows it is dropped, and reading starts over
+ * with the next chunk.
+ */
+export class MessageReader {
+  #pending = new Uint8Array(0);
+  /** @type {(error: FramingError) => void} */
+  #onError;
+
+  /** @param {(error: FramingError) => void} onError */
+  constructor(onError) {
+    this.#onError = onError;
+  }
+
+  /**
+   * The messages `chunk` completes, in order; what it starts waits for the next.
+   * @param {Uint8Array} chunk
+   * @returns {string[]}
+   */
+  push(chunk) {
+    const joined = new Uint8Array(this.#pending.length + chunk.length);
+    joined.set(this.#pending);
+    joined.set(chunk, this.#pending.length);
+    /** @type {string[]} */
+    const messages = [];
+    let at = 0;
+    for (;;) {
+      const headerEnd = indexOf(joined, HEADER_END, at);
+      if (headerEnd === -1) {
+        if (joined.length - at > MAX_HEADER_BYTES) {
+          return this.#unframed(messages, `no LSP header in the first ${MAX_HEADER_BYTES} bytes`);
+        }
+        break;
+      }
+      const header = new TextDecoder().decode(joined.subarray(at, headerEnd));
+      const length = CONTENT_LENGTH.exec(header)?.[1];
+      if (length === undefined) {
+        return this.#unframed(messages, `an LSP header with no length: ${header}`);
+      }
+      const bodyStart = headerEnd + HEADER_END.length;
+      const bodyEnd = bodyStart + Number(length);
+      if (bodyEnd > joined.length) break;
+      messages.push(new TextDecoder().decode(joined.subarray(bodyStart, bodyEnd)));
+      at = bodyEnd;
+    }
+    this.#pending = joined.slice(at);
+    return messages;
+  }
+
+  /**
+   * `messages`, read before a fault in the framing: what follows it is dropped.
+   * @param {string[]} messages
+   * @param {string} why
+   */
+  #unframed(messages, why) {
+    this.#pending = new Uint8Array(0);
+    this.#onError(new FramingError(why));
+    return messages;
+  }
+}
+
+/**
+ * Where `needle` first is in `bytes` from `from`, or -1.
+ * @param {Uint8Array} bytes
+ * @param {Uint8Array} needle
+ * @param {number} from
+ */
+function indexOf(bytes, needle, from) {
+  outer: for (let i = from; i + needle.length <= bytes.length; i++) {
+    for (let j = 0; j < needle.length; j++) if (bytes[i + j] !== needle[j]) continue outer;
+    return i;
+  }
+  return -1;
+}
+
+/**
+ * A byte stream to a language server: what is written to it, and what it sends.
+ * @typedef {object} ByteStream
+ * @property {(bytes: Uint8Array) => void} write
+ * @property {(onChunk: (chunk: Uint8Array) => void) => void} read calls `onChunk` with each chunk
+ *   the server sends, from now on
+ */
+
+/**
+ * The client's transport over `stream`: each message framed on the way out, the frames read
+ * back into messages on the way in. A stream that isn't framed as LSP frames is `onError`'s.
+ * @param {ByteStream} stream
+ * @param {(error: FramingError) => void} onError
+ * @returns {Transport}
+ */
+export function streamTransport(stream, onError) {
+  /** @type {Set<(message: string) => void>} */
+  const handlers = new Set();
+  const reader = new MessageReader(onError);
+  stream.read((chunk) => {
+    for (const message of reader.push(chunk)) for (const handler of handlers) handler(message);
+  });
+  return {
+    send: (message) => stream.write(frameMessage(message)),
+    subscribe: (handler) => void handlers.add(handler),
+    unsubscribe: (handler) => void handlers.delete(handler),
+  };
+}
+
+/**
+ * @typedef {object} LanguageServerOptions
+ * @property {string} rootUri the folder the server reads the scripts' imports from
+ * @property {Record<string, (client: LSPClient, params: any) => boolean>} [notifications] the
+ *   server's notifications of its own (`kupcad/viewportReady`), by method
+ */
+
+/**
+ * A client of the language server, with every feature the editor takes from it: connect it
+ * (`client.connect(streamTransport(...))`), then give each editor `client.plugin(uri)`.
+ * @param {LanguageServerOptions} options
+ * @returns {LSPClient}
+ */
+export function languageServerClient({ rootUri, notifications = {} }) {
+  return new LSPClient({
+    rootUri,
+    extensions: languageServerExtensions(),
+    notificationHandlers: notifications,
+  });
+}