@heroiclands/package-build 22.12.3 → 22.13.0

package/engine/wikilinks.mjs

@@ -12,74 +12,17 @@
  */
 
 /**
- * Wikilink resolution for the pack compilers.
+ * Resolve body wikilinks for Foundry packs.
  *
- * Content notes link to one another with wikilinks rather than file paths:
+ * `[[type-shortcode|Text]]` defaults to the readable `note` Address. A stated
+ * game system names an Actor or Item; `none` names a systemless document.
+ * Journal links can carry a heading anchor. Actor, Item and Macro links open
+ * their sheets, so their anchors do not select a page.
  *
- *   `[[type-shortcode|Text]]`   a document of that type
- *   `[[type-shortcode|]]`       the same, showing the target's current name
- *   `[[type-shortcode#slug|T]]` a section (see below)
- *   `[[#slug|Text]]`            a section of the source note itself
- *   `[[doctype-shortcode|T]]`   an item's *documentation* (see below)
+ * `doc<type>` is accepted as an input alias for the readable note Address.
+ * A link with an empty label displays the target's current name.
  *
- * **Every link is an address, and every address carries a label**. A
- * link written without one addresses nothing and is reported — see
- * {@link unlabelledLinkMessage}, which states the rule for both builds. The
- * bare `[[Alias]]` form and the index it was looked up in are retired.
- *
- * The qualifier is the note's **type**, which with its shortcode is the system's
- * logical identity: `(type, shortcode)` is unique by rule (see the Shortcode
- * Integrity doc). It is deliberately not the note's directory — shortcodes are
- * unique per type, not per directory, so a directory qualifier would add nothing
- * to the address while breaking every inbound link the moment a note is refiled.
- *
- * Nothing narrower than `(type, shortcode)` is consulted — a note's directory
- * and its `category` play no part in resolution — and nothing wider: a note's
- * *name* is not an address, so two notes of a type may share a display name
- * ("Gear" as a rules page and as a user guide page) with nothing to disambiguate.
- *
- * At compile time each becomes a Foundry UUID enricher, routed to the pack that
- * the target's type compiles into (see {@link packForType}):
- *
- *   `@UUID[Compendium.sohl.items.Item.<id>]{Text}`
- *   `@UUID[Compendium.sohl.journals.JournalEntry.<id>.JournalEntryPage.<anchorId>]{Text}`
- *
- * **Every address is computed once, when the target is indexed** — see
- * {@link buildWikilinkIndex} — and a link is resolved by looking that value up.
- * Nothing here concatenates a prefix at the point of use.
- *
- * Section links address a **JournalEntryPage**, because Foundry UUIDs cannot
- * target a position inside a page. A heading carrying `{#slug}` therefore starts
- * its own page, whose id is {@link anchorPageId} — derived from the note id and
- * the slug so that the link and the page agree without any shared state.
- *
- * **An anchor on an Item, an Actor or a Macro is a no-op** and is dropped. What
- * such a link does is open that document's **sheet** — not its documentation —
- * and a sheet has no sections to address. Only a JournalEntry link opens a
- * journal, at its first page or at the page an anchor names. An item's pages are
- * reached through its `doc<type>` counterpart, below.
- *
- * **A document and its documentation are two documents.** An item note
- * compiles into an item — and, separately, its prose compiles into a
- * JournalEntry in the journals pack (see
- * {@link sohl.utils.packs.itemDocEntryId}); a macro note works the same way.
- * `skill/wpnc` addresses the skill; the **virtual qualifier**
- * `docskill/wpnc` addresses that skill's documentation, and
- * `docskill/wpnc#crafting` a page within it. `docmacro/autoattack#script`
- * reaches a macro's source. Every doc-carrying type has a `doc<type>`
- * counterpart, formed by prefix and never enumerated; see
- * {@link resolveItemDocType}. Without it a section link to an item note
- * produced a UUID against the *items* pack, which cannot hold a
- * JournalEntryPage, and dead-ended.
- *
- * **The two builds read the qualifier differently, by design.** In Foundry the
- * item and its documentation are separate documents in separate packs, so the
- * two qualifiers resolve to two different UUIDs. On the knowledgebase the item
- * note renders as a single page which *is* its documentation, so `doc<type>` and
- * `<type>` are aliases for the same URL and an anchor on either is an ordinary
- * in-page anchor. One authored link, correct in both.
- *
- * Plain ESM with no Foundry and no filesystem access, so it is unit-testable.
+ * @module
  */
 
 import { resolveShortcodeReference } from "./shortcode-references.mjs";
@@ -100,12 +43,13 @@ import {
     renderAddress,
     isAddressTuple,
     completeAddress,
+    ownDocumentSystem,
 } from "./address.mjs";
 import { ASSET_TYPE_NAMES } from "./asset-types.mjs";
-import { NO_SYSTEM } from "./systems.mjs";
+import { NOTE_SYSTEM } from "./systems.mjs";
 import { systemOf } from "./document-subtypes.mjs";
 import { KNOWN_DOCUMENT_SUBTYPE_MAPS } from "./subtype-registry.mjs";
-import { itemDocEntryId } from "./item-docs.mjs";
+import { hasDocEntry, itemDocEntryId } from "./item-docs.mjs";
 import { replaceOutsideCode } from "./code-fences.mjs";
 // The syntax lives in `./wikilink-syntax.mjs`, so the web resolver and this
 // one cannot disagree about what counts as a link.
@@ -228,10 +172,8 @@ export function buildWikilinkIndex(
                     // type and a UUID carries the pack name, so the address
                     // cannot be derived from the type alone.
                     uuid: compendiumUuid(packageId, d.type, d.id, d.pack),
-                    // An item's prose compiles into a separate JournalEntry,
-                    // addressed by the virtual `doc<type>` qualifier. Its id
-                    // is derived from the item's, so its address is knowable
-                    // here too.
+                    // The readable note has a separate JournalEntry whose id
+                    // is derived from the item's id.
                     docUuid: compendiumUuid(packageId, "doc", itemDocEntryId(d.id), d.docPack),
                 },
         );
@@ -249,19 +191,8 @@ export function buildWikilinkIndex(
     for (const v of foreignByKey.values()) {
         if (v.type) foreignTypes.push(norm(v.type));
     }
-    // A manifest publishes `doc<type>` addresses, but `doc<type>` is a
-    // *virtual* qualifier formed by prefix — never a real type. Admitting it
-    // here would make it one, and a real type owns its own name, so the
-    // virtual reading would stop firing and every `[[docskill-wpnc]]` would
-    // resolve nowhere. The virtual form still reaches a foreign documentation
-    // entry: it reads as `skill` + `itemDoc`, which the manifest lookup then
-    // asks for as `docskill`.
-    //
-    // Real types are admitted **first**, in a pass of their own, so the test
-    // below sees the complete set. Done in one pass it would depend on
-    // manifest iteration order wherever the base type is published only by a
-    // foreign package — `docmacro` admitted or not according to whether
-    // `macro` happened to come first.
+    // A legacy index may contain `doc<type>` records. Keep the authored type
+    // vocabulary separate so the input alias can resolve to its base type.
     for (const t of foreignTypes) {
         if (!t.startsWith(ITEM_DOC_PREFIX)) types.add(t);
     }
@@ -334,7 +265,8 @@ function findForeign(index, read) {
  */
 function foreignHits(index, read) {
     if (!read || read.reason || !index.foreign?.size) return [];
-    const wanted = norm(read.itemDoc ? `doc${read.type}` : read.type);
+    const tuple = completeAddress(read, { package: index.contentPackage, system: NOTE_SYSTEM });
+    const wanted = norm(tuple.type);
     const shortcode = norm(read.shortcode);
 
     // **An omitted package means this package**, so a short form
@@ -348,7 +280,7 @@ function foreignHits(index, read) {
     // than a filter. That is what makes a cross-package `ambiguous` impossible:
     // one key, one entry.
     if (!read.package) return [];
-    const wantedSystem = norm(read.system ?? NO_SYSTEM);
+    const wantedSystem = norm(tuple.system);
     const hits = [];
     for (const [key, entry] of index.foreign) {
         const parts = readCanonicalKey(key);
@@ -460,7 +392,7 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
     const out = replaceOutsideCode(markdown, WIKILINK, (all, rawInner, offset) => {
         const parsed = readWikilink(rawInner, {
             package: index.contentPackage,
-            system: "none",
+            system: "note",
             types: index.types,
             packages: index.packages,
             noIndexPackages: index.noIndexPackages,
@@ -516,20 +448,13 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
                 });
                 return unresolvedLink(text || target, target);
             }
-            // An omitted system defaults from where the link is written,
-            // and a body is under no system block, so it is `none`. Under
-            // `none` a system-bearing type addresses its *documentation* — a
-            // note's `none` address IS its `doc<type>` entry — which is what a
-            // prose link almost always means. Stating the system is how prose
-            // reaches the Item instead.
-            //
-            // Only a type whose *own* document carries a system is redirected.
-            // A `macro` and the map types have documentation journals too, but
-            // their own documents are core ones already at `none`, so
-            // `macro-autoattack` names the Macro and `docmacro-autoattack` its
-            // journal — two live addresses the redirect would collapse.
+            // Ordinary wikilinks default to readable note content.
             const baseType = resolveItemDocType(qualified.type, index.types);
-            itemDoc = Boolean(baseType);
+            const address = completeAddress(qualified, {
+                package: index.contentPackage,
+                system: NOTE_SYSTEM,
+            });
+            itemDoc = address.system === NOTE_SYSTEM && hasDocEntry(baseType ?? qualified.type);
             if (qualified.package === index.contentPackage)
                 doc = index.byShortcode.get(`${baseType ?? qualified.type}/${qualified.shortcode}`);
         }
@@ -615,7 +540,7 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
         // *sheet*, which has no sections, so the anchor has nothing to address
         // and is dropped. Forging a JournalEntryPage id onto a document that
         // can never hold one is what made such links dead-end; an
-        // item's pages are addressed through its `doc<type>` counterpart.
+        // an item's pages are addressed through its `note` Address.
         // A `#section` the target declares no heading for. Checked here, and
         // not only by `content-build links`, because this is the build that
         // *emits* the link: `anchorPageId` will hash any slug into a page id,
@@ -672,7 +597,7 @@ export function resolveReference(index, ref, hint) {
         );
     const tuple = parseAddress(ref, {
         package: index.contentPackage,
-        system: "none",
+        system: "note",
         types: index.types,
         packages: index.packages,
         noIndexPackages: index.noIndexPackages,
@@ -699,15 +624,15 @@ export function resolveReference(index, ref, hint) {
             if (foreign) return { ...foreign, address: tuple };
             return undefined;
         }
-        const base = resolveItemDocType(tuple.type, index.types);
-        const type = base ?? tuple.type;
-        if (tuple.system !== (base ? NO_SYSTEM : systemOf(type, KNOWN_DOCUMENT_SUBTYPE_MAPS)))
+        const type = tuple.type;
+        const documentation = tuple.system === NOTE_SYSTEM && hasDocEntry(type);
+        if (tuple.system !== (documentation ? NOTE_SYSTEM : ownDocumentSystem(type)))
             return undefined;
         const local = index.byShortcode?.get(`${type}/${tuple.shortcode}`);
         if (!local) return undefined;
         const addresses = index.uuidByDoc?.get(local);
         const uuid =
-            base ?
+            documentation ?
                 Object.hasOwn(local, "documentationUuid") ?
                     local.documentationUuid
                 :   addresses?.docUuid

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "22.12.3",
+    "version": "22.13.0",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package — content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",
@@ -96,8 +96,7 @@
     },
     "bin": {
         "package-build": "./bin/package-build.mjs",
-        "content-build": "./bin/content-build.mjs",
-        "heroiclands-content-language-server": "./bin/heroiclands-content-language-server.mjs"
+        "content-build": "./bin/content-build.mjs"
     },
     "files": [
         "CHANGELOG-content-build.md",

package/sohl/infobox.mjs

@@ -270,7 +270,7 @@ function itemPresentation(item, resolve, block) {
     if (!item.shortcode) return undefined;
     if (!item.address)
         return resolve?.(item.shortcode, { kind: "shortcode", type: item.type, system: block });
-    const documentation = completeAddress({ ...item.address, system: "none" });
+    const documentation = completeAddress({ ...item.address, system: "note" });
     const found = resolve?.(documentation, { type: documentation.type });
     const native =
         !found?.name || !found?.subType ? resolve?.(item.address, { type: item.type }) : undefined;
@@ -556,7 +556,7 @@ export function affiliationSections(fm, ctx) {
     const entries = value.map((skill) => {
         const native = ctx.resolve?.(skill, { type: "skill", system: "sohl" });
         const docAddress =
-            isAddressTuple(skill) ? completeAddress({ ...skill, system: "none" }) : undefined;
+            isAddressTuple(skill) ? completeAddress({ ...skill, system: "note" }) : undefined;
         const doc = docAddress ? ctx.resolve?.(docAddress, { type: docAddress.type }) : undefined;
         return {
             text: doc?.name || native?.name || humanizeValue(skill),

package/types/engine/address.d.mts

@@ -1,14 +1,9 @@
 /**
- * A complete Address: four segments, and nothing else.
- *
- * `type` is the segment the canonical string carries, after the `doc<type>`
- * redirect. There is no fifth field recording the written form, because the
- * written form is a rendering rather than part of the value.
+ * A complete Address: four segments, with no memory of the authored form.
  *
  * @typedef {object} AddressTuple
  * @property {string} package - The owning **content** package.
- * @property {string} system - The system whose document this addresses, or
- *   `none`.
+ * @property {string} system - `note`, `none`, or a game system id.
  * @property {string} type - The type segment of the canonical Address.
  * @property {string} shortcode - The note's `shortcode`.
  */
@@ -33,29 +28,8 @@
  * @typedef {{reason: string, package?: string}} AddressProblem
  */
 /**
- * Every content type whose **prose compiles into a JournalEntry of its own**,
- * addressed by the virtual `doc<type>` qualifier.
- *
- * Every item type, every actor type, every map type, plus `macro` — a macro
- * note's body documents the script the note also compiles into a Macro, which
- * is the same shape as an item and its description: one note, two documents,
- * the prose living in the journals pack.
- *
- * **One set, read by the compilers and by the grammar alike.** The journals
- * pass decides what to compile from it, the link manifest decides what to
- * publish a `doc<type>` entry for, and the parser decides whether `doc<type>`
- * is a legal type segment. Held apart, the three drift into a manifest that
- * asserts documentation nothing compiled, a compiled entry no consumer can
- * address, or an authored `doc<type>` link that stops parsing. It is composed
- * exactly once, in `defineConfig`, and read from there — never recomposed at a
- * call site.
- *
- * `doc` notes are absent, for the reason that applies to them alone: a `doc`
- * note's single document *is* its prose, so there is no second document for a
- * `doc<type>` address to name.
- *
- * An accessor rather than a hoisted constant, so that importing this module
- * needs no configuration.
+ * The configured types whose prose compiles into a separate JournalEntry.
+ * The journal has a `note` Address with the authored type segment.
  *
  * @returns {ReadonlySet<string>} The configured doc-carrying types.
  */
@@ -69,30 +43,15 @@ export function docEntryTypes(): ReadonlySet<string>;
  *   `macro`; false for `doc`.
  */
 export function hasDocEntry(type: string): boolean;
+/** The segment of a note's own document. */
+export function ownDocumentSystem(type: any): string;
 /**
- * Reads a qualifier as the **virtual `doc<type>`** form, or reports that it is
- * not one.
- *
- * A document and its documentation are two documents in two packs, so they need
- * two addresses. `skill-wpnc` is the item; `docskill-wpnc` is the JournalEntry
- * its prose compiled into, and `docmacro-autoattack` is the same arrangement
- * for a macro.
- *
- * The virtual form exists for a type that carries separate documentation
- * ({@link docEntryTypes} — the set the journals compiler and the link manifest
- * read too), **or** for one that routes to the items pack. The second clause
- * covers the open, unenumerated set: types that compile into items are not
- * enumerated anywhere, and a foreign package may publish an item type this
- * build has never heard of. Dropping it would silently unlink every `doc<type>`
- * address into such a package.
- *
- * A **real** type of the same name always wins: the virtual reading is only
- * consulted for a qualifier no authored note claims.
- *
- * @param {string} qualifier - The already-normalised type segment.
- * @param {Set<string>} types - Every type the content tree contains.
- * @returns {string|null} The underlying document type, or `null` when the
- *   qualifier is not a virtual one.
+ * Read a `doc<type>` input qualifier as the underlying authored type.
+ * A real type with that spelling takes precedence.
+ *
+ * @param {string} qualifier - The type segment from the input.
+ * @param {Set<string>} types - Types in the content tree.
+ * @returns {string|null} The underlying type, or `null`.
  */
 export function resolveItemDocType(qualifier: string, types: Set<string>): string | null;
 /**
@@ -164,29 +123,17 @@ export function isAddressTuple(value: unknown): boolean;
  */
 export function renderAddress(tuple: AddressTuple): string;
 /**
- * Whether the type an Address names is one this position accepts.
+ * Whether the canonical type an Address names is accepted at this position.
  *
- * The second of the two questions, and separate from the first because the
- * accepted **set** is a property of the position while the grammar is not.
- *
- * **An accepted type carries its documentation form with it.** A position
- * accepting `weapongear` accepts `docweapongear`, because the journal that
- * documents a weapon is the same thing to a position that wanted a weapon — and
- * a prose address of one *is* the journal, so refusing it would refuse the form
- * an author most often writes. It is the widening `defineConfig` applies to the
- * types a package may claim, applied here to the types a position may take.
- *
- * @param {AddressTuple} tuple - A parsed Address.
- * @param {Iterable<string>} allowed - The types this position accepts.
- * @returns {boolean} True when the Address names one of them.
+ * @param {AddressTuple} tuple - A complete Address.
+ * @param {Iterable<string>} allowed - Accepted types.
+ * @returns {boolean} Whether the type is accepted.
  */
 export function acceptsType(tuple: AddressTuple, allowed: Iterable<string>): boolean;
 /**
  * Apply the defaults to a partial reading, giving a complete Address.
  *
- * The three rules of the module note, applied in the order they depend on each
- * other: the package, then the system the type may fix, then the redirect the
- * system may force.
+ * Complete a parsed Address using the citing position's package and system.
  *
  * @param {{type: string, shortcode: string, package?: string, system?: string,
  *   itemDoc?: boolean}} read - A partial reading, as {@link readQualifier}
@@ -351,23 +298,10 @@ export const ADDRESS_SEPARATOR: string;
  * @type {number}
  */
 export const CANONICAL_KEY_SEGMENTS: number;
+/** The accepted `doc<type>` input prefix for readable note links. */
+export const ITEM_DOC_PREFIX: "doc";
 /**
- * The qualifier prefix that addresses a note's **documentation** rather than
- * the note's own document: `docskill-wpnc` is the JournalEntry that
- * `skill-wpnc`'s prose compiled into.
- *
- * Every doc-carrying type has a `doc<type>` counterpart, formed by prefix and
- * never enumerated, so the prefix itself is the whole of that vocabulary.
- *
- * @type {string}
- */
-export const ITEM_DOC_PREFIX: string;
-/**
- * A complete Address: four segments, and nothing else.
- *
- * `type` is the segment the canonical string carries, after the `doc<type>`
- * redirect. There is no fifth field recording the written form, because the
- * written form is a rendering rather than part of the value.
+ * A complete Address: four segments, with no memory of the authored form.
  */
 export type AddressTuple = {
     /**
@@ -375,8 +309,7 @@ export type AddressTuple = {
      */
     package: string;
     /**
-     * - The system whose document this addresses, or
-     * `none`.
+     * - `note`, `none`, or a game system id.
      */
     system: string;
     /**

package/types/engine/content-address.d.mts

@@ -69,12 +69,9 @@ export function packageAddress(fm: object): string;
  *
  * The **enclosing system block** decides, at any depth within it, and nothing
  * else does: `sohl.items[3].model` and `sohl.system.body.structure` are both
- * `sohl` because both sit under `sohl:`. Everywhere else is {@link NO_SYSTEM} —
- * top-level frontmatter, the shared `data:` container, and body prose, which has
- * no key path at all and passes `undefined`.
- *
- * It is the block rather than the field, so an `Address` field needs no opinion
- * about systems and no per-field table has to be kept in step with the schema.
+ * `sohl` because both sit under `sohl:`. Everywhere else takes
+ * {@link NOTE_SYSTEM}; fields declared for assets or folders supply their own
+ * `none` default at the field parser.
  *
  * The first segment must **be** a declared system, not merely look like one:
  * `sohlish.items` is a key called `sohlish`, and `notes.sohl.thing` names no

package/types/engine/content-links.d.mts

@@ -39,12 +39,8 @@ export function anchorsOf(body: string): Set<string>;
  * before, since the walk read the file and it then read it again for the raw
  * text.
  *
- * The index mirrors what both builds construct, including the two addresses a
- * doc-carrying note answers to: `type/shortcode` for the document, and
- * `doc<type>/shortcode` for the JournalEntry its prose compiles into. Once a
- * manifest publishes `doc<type>` entries that prefix is a *known type*, and the
- * virtual reading that used to answer for it no longer fires — a real type owns
- * its own name — so the note is indexed under both.
+ * The index holds each compiled document under its complete Address. Readable
+ * content uses `note`, and system documents use their declared system.
  *
  * @param {string} contentBase - Root of the content tree.
  * @param {object} [opts]

package/types/engine/note-addresses.d.mts

@@ -30,6 +30,7 @@ export const STRUCTURED_ADDRESSES: readonly ({
     shape: string;
     type: string;
     accepts: string[];
+    system: string;
     noteType?: undefined;
 } | {
     noteType: string;
@@ -37,5 +38,6 @@ export const STRUCTURED_ADDRESSES: readonly ({
     shape: string;
     type: string;
     accepts: string[];
+    system?: undefined;
 })[];
 export { AddressEntries, encodeAddresses, cloneAddressState } from "./address-values.mjs";

package/types/engine/systems.d.mts

@@ -80,6 +80,8 @@ export function assertSystemCharset(segments: Iterable<string>, where?: string):
  * @type {string}
  */
 export const NO_SYSTEM: string;
+/** The Address segment for a note's readable content. */
+export const NOTE_SYSTEM: "note";
 /**
  * Every game system this toolchain compiles for.
  *

package/bin/heroiclands-content-language-server.mjs

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-/*
- * SPDX-License-Identifier: GPL-3.0-or-later
- */
-
-import { runLanguageServer } from "../engine/content-language-server.mjs";
-
-runLanguageServer();

package/docs/content-language-server.md

@@ -1,25 +0,0 @@
-# Content language server
-
-`heroiclands-content-language-server` provides editor navigation for Markdown notes in a HeroicLands content project. It is a stdio Language Server Protocol process; an editor starts it from the project root. The command uses the same `package-build.config.yaml` and Address rules as `content-build`.
-
-Build the content index in the project before starting navigation:
-
-```sh
-npx content-build content-index
-```
-
-The generated JSONL file under the configured `paths.contentIndex` is the source for note names, aliases, tags, shortcodes, Addresses, and destinations. Search covers the current project. Search and destinations reflect the saved index, so run the index command after changing note metadata. The language server reads a completed replacement index on its next request. An editor's unsaved buffer text is used to identify the Address at the cursor, but it does not add search results.
-
-| LSP request               | Behavior                                                                                                                     |
-| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
-| `textDocument/definition` | Follows an Address or wikilink to the indexed note. An anchor lands on its indexed line.                                     |
-| `workspace/symbol`        | Finds notes by name, alias, ASCII name, shortcode, or Address. `tag:myth` searches tags. One result appears per source note. |
-| `textDocument/references` | Finds authored wikilinks, embeds, and declared frontmatter Address values or keys. Ordinary prose is excluded.               |
-
-The server reports a missing index with the `content-build content-index` command. Reference search scans Markdown notes in the configured content tree. The server writes only LSP messages to stdout, and it uses UTF-16 positions as required by the default LSP position encoding.
-
-## Editor integration
-
-The [HeroicLands Emacs package](https://github.com/HeroicLands/heroiclands-emacs) connects this command through Eglot in content Markdown buffers. Eglot maps `M-.` to definition, `C-M-.` to workspace search, `M-?` to references, and `M-,` to the Xref location stack.
-
-An editor other than Emacs starts the executable from the package root and associates it with Markdown notes under the configured content directory. The process handles `initialize`, `shutdown`, `exit`, full and incremental document synchronization, definition, references, and workspace symbols. It does not advertise completion, diagnostics, rename, or document symbols.