@gmb/bitmark-parser 7.0.0 → 7.2.0

package/schema/bitmark.schema.json

@@ -46511,6 +46511,15 @@
         {
           "type": "object"
         },
+        {
+          "type": "array"
+        },
+        {
+          "type": "number"
+        },
+        {
+          "type": "boolean"
+        },
         {
           "type": "null"
         }
@@ -47989,10 +47998,10 @@
         "example": {
           "anyOf": [
             {
-              "$ref": "#/$defs/bitmarkPlus"
+              "type": "boolean"
             },
             {
-              "type": "boolean"
+              "$ref": "#/$defs/bitmarkPlus"
             }
           ]
         },
@@ -50842,7 +50851,10 @@
         "isTemplateStripTheme": {
           "type": "boolean"
         },
-        "item": {
+        "marginNumber": {
+          "$ref": "#/$defs/bitmarkPlus"
+        },
+        "pageNumber": {
           "$ref": "#/$defs/bitmarkPlus"
         }
       },
@@ -51908,7 +51920,10 @@
         "isTemplateStripTheme": {
           "type": "boolean"
         },
-        "item": {
+        "marginNumber": {
+          "$ref": "#/$defs/bitmarkPlus"
+        },
+        "pageNumber": {
           "$ref": "#/$defs/bitmarkPlus"
         }
       },
@@ -53335,7 +53350,10 @@
         "isTemplateStripTheme": {
           "type": "boolean"
         },
-        "item": {
+        "marginNumber": {
+          "$ref": "#/$defs/bitmarkPlus"
+        },
+        "pageNumber": {
           "$ref": "#/$defs/bitmarkPlus"
         }
       },
@@ -53390,6 +53408,12 @@
         },
         "listItemIndent": {
           "type": "number"
+        },
+        "marginNumber": {
+          "$ref": "#/$defs/bitmarkPlus"
+        },
+        "pageNumber": {
+          "$ref": "#/$defs/bitmarkPlus"
         }
       },
       "type": "object"
@@ -60036,7 +60060,7 @@
       ]
     }
   },
-  "$id": "https://schema.getmorebrain.com/bitmark/7.0.0.schema.json",
+  "$id": "https://schema.getmorebrain.com/bitmark/7.2.0.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "description": "Generated from bitmark.json by bitmark-schemagen (PLAN-117). Do not edit by hand.",
   "items": {

package/wasm/bitmark_wasm.d.ts

@@ -53,7 +53,11 @@ export function convert_text(input: string, direction: string, format: string, l
  * Apply a patch (a JSON array of patch entries) to every bit and re-emit.
  *
  * `input_format_sel`: `"auto"` | `"bitmark"` | `"json"`.
- * `output_format_sel`: `"bitmark"` | `"json"` (default json).
+ * `output_format_sel`: the same vocabulary as `convert` — `"bitmark"` |
+ * `"json"` | `"text"` | a mapping id (`"html"`, …), `"auto"` (or empty) being
+ * the opposite of the resolved input format. The whole-document outputs
+ * (`lex`, `semantic-tokens`, `diagnostics`) are not per-bit formats; the
+ * pipeline refuses them and that refusal is what throws.
  * `patch_json`: the patch entry array (empty string = no patches, i.e. a
  * canonicalizing pass). Parallelism is a JS-side concern (web workers); this
  * runs sequentially. Returns the document text/JSON; throws on failure.
@@ -63,11 +67,14 @@ export function transform(input: string, input_format_sel: string, output_format
  * Resolve a patch document against `input` (bitmark or JSON) into the
  * ordered output items, so a JS per-bit planner (hooks, worker pool) can
  * reorder, drop and insert jobs from the one Rust implementation
- * (PLAN-179). Returns a JSON array of
+ * (PLAN-179). `input_format_sel` is the caller's input-format selector
+ * (`"auto"` | `"bitmark"` | `"json"`): the document is split under the SAME
+ * selection the planner already resolved, never re-sniffed (PLAN-187 D1).
+ * Returns a JSON array of
  * `{ "source": <original index> | null, "bit": <inner bit> | null,
  *    "patch": [ … ] }`; throws on failure.
  */
-export function resolve_patch_document(input: string, patch_json: string): string;
+export function resolve_patch_document(input: string, input_format_sel: string, patch_json: string): string;
 /**
  * Semantic diff of two documents (PLAN-179). Flat arguments like every
  * other export:
@@ -82,6 +89,33 @@ export function resolve_patch_document(input: string, patch_json: string): strin
  * failure.
  */
 export function diff(a: string, b: string, input_format_sel: string, output_format_sel: string, context: number, locate: boolean, similarity: number, bbox_tolerance: number, spaces_around_values: number): string;
+/**
+ * The constructs valid at a position, as an LSP `CompletionList` (PLAN-196
+ * D7; contract `API-EDT-editor-services.tsp`). `line` / `character` are
+ * 0-based, `character` in `position_encoding` units (`"utf-16"`, the
+ * default, or `"utf-8"`); `include_deprecated` offers deprecated bits too;
+ * `trigger_character` is the character the editor sent as the trigger (LSP
+ * `CompletionContext.triggerCharacter`; empty when invoked explicitly) — a
+ * trigger that opens nothing where the cursor is answers the empty list
+ * (PLAN-203 D1). ABSENT on a variant built without `editor` — the same
+ * "presence is the capability" signal `diff` uses. Throws when the line is
+ * past the text.
+ */
+export function complete(input: string, line: number, character: number, position_encoding: string, include_deprecated: boolean, trigger_character: string): string;
+/**
+ * One item of the list `complete` returns at this position, its Markdown
+ * `documentation` filled in — LSP `completionItem/resolve` (PLAN-202):
+ * `complete` ships no documentation, an editor asks for the one item it is
+ * about to show. `label` and `kind` (the LSP `CompletionItemKind` number)
+ * name the item; the JSON `null` when the list has no such item. Arguments
+ * otherwise as `complete`.
+ */
+export function resolve(input: string, line: number, character: number, position_encoding: string, include_deprecated: boolean, label: string, kind: number): string;
+/**
+ * The construct at a position, as an LSP `Hover` — or the JSON `null` when
+ * there is nothing to show (PLAN-196 D8). Arguments as `complete`.
+ */
+export function hover(input: string, line: number, character: number, position_encoding: string): string;
 /**
  * Register data with the parser process (PLAN-173 P12).
  *
@@ -102,14 +136,15 @@ export function register(data_type: string, data: string): void;
  *
  * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"` | a mapping id.
  * `output_format`: `"auto"` (opposite of input) | `"bitmark"` | `"json"` |
- * `"text"` | `"lex"` (the token stream as JSON, bitmark input only) | a
- * mapping id.
+ * `"text"` | `"lex"` (the token stream as JSON) | `"semantic-tokens"` |
+ * `"diagnostics"` (the last three bitmark input only) | a mapping id.
  * `mode`: `"optimized"` (default) | `"full"`.
  * `mapping_report`: replace the output with a human-readable report of the
  * input→output mappings, including inputs that are NOT mapped (PLAN-147).
- * `position_encoding`: `"utf-16"` (default) | `"utf-8"` and `tokens_layout`:
- * `"lsp"` (default) | `"absolute"` — the `semantic-tokens` output's two
- * options (PLAN-193); `""` means the default, and every other output
+ * `position_encoding`: `"utf-16"` (default) | `"utf-8"` — the
+ * `semantic-tokens` and `diagnostics` outputs' encoding (PLAN-193 /
+ * PLAN-196) — and `tokens_layout`: `"lsp"` (default) | `"absolute"` — the
+ * `semantic-tokens` layout; `""` means the default, and every other output
  * format ignores them.
  * Returns the converted text/JSON; throws on failure.
  */

package/wasm/bitmark_wasm.js

@@ -295,7 +295,11 @@ module.exports.convert_text = function(input, direction, format, location) {
  * Apply a patch (a JSON array of patch entries) to every bit and re-emit.
  *
  * `input_format_sel`: `"auto"` | `"bitmark"` | `"json"`.
- * `output_format_sel`: `"bitmark"` | `"json"` (default json).
+ * `output_format_sel`: the same vocabulary as `convert` — `"bitmark"` |
+ * `"json"` | `"text"` | a mapping id (`"html"`, …), `"auto"` (or empty) being
+ * the opposite of the resolved input format. The whole-document outputs
+ * (`lex`, `semantic-tokens`, `diagnostics`) are not per-bit formats; the
+ * pipeline refuses them and that refusal is what throws.
  * `patch_json`: the patch entry array (empty string = no patches, i.e. a
  * canonicalizing pass). Parallelism is a JS-side concern (web workers); this
  * runs sequentially. Returns the document text/JSON; throws on failure.
@@ -348,39 +352,45 @@ module.exports.transform = function(input, input_format_sel, output_format_sel,
  * Resolve a patch document against `input` (bitmark or JSON) into the
  * ordered output items, so a JS per-bit planner (hooks, worker pool) can
  * reorder, drop and insert jobs from the one Rust implementation
- * (PLAN-179). Returns a JSON array of
+ * (PLAN-179). `input_format_sel` is the caller's input-format selector
+ * (`"auto"` | `"bitmark"` | `"json"`): the document is split under the SAME
+ * selection the planner already resolved, never re-sniffed (PLAN-187 D1).
+ * Returns a JSON array of
  * `{ "source": <original index> | null, "bit": <inner bit> | null,
  *    "patch": [ … ] }`; throws on failure.
  * @param {string} input
+ * @param {string} input_format_sel
  * @param {string} patch_json
  * @returns {string}
  */
-module.exports.resolve_patch_document = function(input, patch_json) {
-    let deferred4_0;
-    let deferred4_1;
+module.exports.resolve_patch_document = function(input, input_format_sel, patch_json) {
+    let deferred5_0;
+    let deferred5_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(patch_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const ptr1 = passStringToWasm0(input_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len1 = WASM_VECTOR_LEN;
-        wasm.resolve_patch_document(retptr, ptr0, len0, ptr1, len1);
+        const ptr2 = passStringToWasm0(patch_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.resolve_patch_document(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
         var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        var ptr3 = r0;
-        var len3 = r1;
+        var ptr4 = r0;
+        var len4 = r1;
         if (r3) {
-            ptr3 = 0; len3 = 0;
+            ptr4 = 0; len4 = 0;
             throw takeObject(r2);
         }
-        deferred4_0 = ptr3;
-        deferred4_1 = len3;
-        return getStringFromWasm0(ptr3, len3);
+        deferred5_0 = ptr4;
+        deferred5_1 = len4;
+        return getStringFromWasm0(ptr4, len4);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
+        wasm.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
     }
 };
 
@@ -440,6 +450,141 @@ module.exports.diff = function(a, b, input_format_sel, output_format_sel, contex
     }
 };
 
+/**
+ * The constructs valid at a position, as an LSP `CompletionList` (PLAN-196
+ * D7; contract `API-EDT-editor-services.tsp`). `line` / `character` are
+ * 0-based, `character` in `position_encoding` units (`"utf-16"`, the
+ * default, or `"utf-8"`); `include_deprecated` offers deprecated bits too;
+ * `trigger_character` is the character the editor sent as the trigger (LSP
+ * `CompletionContext.triggerCharacter`; empty when invoked explicitly) — a
+ * trigger that opens nothing where the cursor is answers the empty list
+ * (PLAN-203 D1). ABSENT on a variant built without `editor` — the same
+ * "presence is the capability" signal `diff` uses. Throws when the line is
+ * past the text.
+ * @param {string} input
+ * @param {number} line
+ * @param {number} character
+ * @param {string} position_encoding
+ * @param {boolean} include_deprecated
+ * @param {string} trigger_character
+ * @returns {string}
+ */
+module.exports.complete = function(input, line, character, position_encoding, include_deprecated, trigger_character) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(position_encoding, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(trigger_character, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.complete(retptr, ptr0, len0, line, character, ptr1, len1, include_deprecated, ptr2, len2);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr4 = r0;
+        var len4 = r1;
+        if (r3) {
+            ptr4 = 0; len4 = 0;
+            throw takeObject(r2);
+        }
+        deferred5_0 = ptr4;
+        deferred5_1 = len4;
+        return getStringFromWasm0(ptr4, len4);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
+    }
+};
+
+/**
+ * One item of the list `complete` returns at this position, its Markdown
+ * `documentation` filled in — LSP `completionItem/resolve` (PLAN-202):
+ * `complete` ships no documentation, an editor asks for the one item it is
+ * about to show. `label` and `kind` (the LSP `CompletionItemKind` number)
+ * name the item; the JSON `null` when the list has no such item. Arguments
+ * otherwise as `complete`.
+ * @param {string} input
+ * @param {number} line
+ * @param {number} character
+ * @param {string} position_encoding
+ * @param {boolean} include_deprecated
+ * @param {string} label
+ * @param {number} kind
+ * @returns {string}
+ */
+module.exports.resolve = function(input, line, character, position_encoding, include_deprecated, label, kind) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(position_encoding, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(label, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.resolve(retptr, ptr0, len0, line, character, ptr1, len1, include_deprecated, ptr2, len2, kind);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr4 = r0;
+        var len4 = r1;
+        if (r3) {
+            ptr4 = 0; len4 = 0;
+            throw takeObject(r2);
+        }
+        deferred5_0 = ptr4;
+        deferred5_1 = len4;
+        return getStringFromWasm0(ptr4, len4);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
+    }
+};
+
+/**
+ * The construct at a position, as an LSP `Hover` — or the JSON `null` when
+ * there is nothing to show (PLAN-196 D8). Arguments as `complete`.
+ * @param {string} input
+ * @param {number} line
+ * @param {number} character
+ * @param {string} position_encoding
+ * @returns {string}
+ */
+module.exports.hover = function(input, line, character, position_encoding) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(position_encoding, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.hover(retptr, ptr0, len0, line, character, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr3 = r0;
+        var len3 = r1;
+        if (r3) {
+            ptr3 = 0; len3 = 0;
+            throw takeObject(r2);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred4_0, deferred4_1, 1);
+    }
+};
+
 /**
  * Register data with the parser process (PLAN-173 P12).
  *
@@ -479,14 +624,15 @@ module.exports.register = function(data_type, data) {
  *
  * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"` | a mapping id.
  * `output_format`: `"auto"` (opposite of input) | `"bitmark"` | `"json"` |
- * `"text"` | `"lex"` (the token stream as JSON, bitmark input only) | a
- * mapping id.
+ * `"text"` | `"lex"` (the token stream as JSON) | `"semantic-tokens"` |
+ * `"diagnostics"` (the last three bitmark input only) | a mapping id.
  * `mode`: `"optimized"` (default) | `"full"`.
  * `mapping_report`: replace the output with a human-readable report of the
  * input→output mappings, including inputs that are NOT mapped (PLAN-147).
- * `position_encoding`: `"utf-16"` (default) | `"utf-8"` and `tokens_layout`:
- * `"lsp"` (default) | `"absolute"` — the `semantic-tokens` output's two
- * options (PLAN-193); `""` means the default, and every other output
+ * `position_encoding`: `"utf-16"` (default) | `"utf-8"` — the
+ * `semantic-tokens` and `diagnostics` outputs' encoding (PLAN-193 /
+ * PLAN-196) — and `tokens_layout`: `"lsp"` (default) | `"absolute"` — the
+ * `semantic-tokens` layout; `""` means the default, and every other output
  * format ignores them.
  * Returns the converted text/JSON; throws on failure.
  * @param {string} input

package/wasm/bitmark_wasm_bg.wasm.d.ts

@@ -3,16 +3,19 @@
 export const memory: WebAssembly.Memory;
 export const breakscape_text: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const canonicalize: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+export const complete: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
 export const convert: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number) => void;
 export const convert_text: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
 export const count_bits: (a: number, b: number, c: number) => void;
 export const diff: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number) => void;
+export const hover: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const info: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number) => void;
 export const info_text_supported: () => number;
 export const is_bitmark: (a: number, b: number) => number;
 export const prettify: (a: number, b: number, c: number, d: number) => void;
 export const register: (a: number, b: number, c: number, d: number, e: number) => void;
-export const resolve_patch_document: (a: number, b: number, c: number, d: number, e: number) => void;
+export const resolve: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+export const resolve_patch_document: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const split_bits: (a: number, b: number, c: number) => void;
 export const split_json_bits: (a: number, b: number, c: number) => void;
 export const transform: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number) => void;

package/wasm/package.json

@@ -4,7 +4,7 @@
     "Get More Brain Ltd <info@getmorebrain.com>"
   ],
   "description": "WebAssembly bindings for the bitmark parser",
-  "version": "7.0.0",
+  "version": "7.2.0",
   "license": "ISC",
   "repository": {
     "type": "git",

package/wasm-bitmark-json/bitmark_json_wasm.d.ts

@@ -51,7 +51,11 @@ export function register(data_type: string, data: string): void;
  * Apply a patch (a JSON array of patch entries) to every bit and re-emit.
  *
  * `input_format_sel`: `"auto"` | `"bitmark"` | `"json"`.
- * `output_format_sel`: `"bitmark"` | `"json"` (default json).
+ * `output_format_sel`: the same vocabulary as `convert` — `"bitmark"` |
+ * `"json"` | `"text"` | a mapping id (`"html"`, …), `"auto"` (or empty) being
+ * the opposite of the resolved input format. The whole-document outputs
+ * (`lex`, `semantic-tokens`, `diagnostics`) are not per-bit formats; the
+ * pipeline refuses them and that refusal is what throws.
  * `patch_json`: the patch entry array (empty string = no patches, i.e. a
  * canonicalizing pass). Parallelism is a JS-side concern (web workers); this
  * runs sequentially. Returns the document text/JSON; throws on failure.
@@ -61,24 +65,55 @@ export function transform(input: string, input_format_sel: string, output_format
  * Resolve a patch document against `input` (bitmark or JSON) into the
  * ordered output items, so a JS per-bit planner (hooks, worker pool) can
  * reorder, drop and insert jobs from the one Rust implementation
- * (PLAN-179). Returns a JSON array of
+ * (PLAN-179). `input_format_sel` is the caller's input-format selector
+ * (`"auto"` | `"bitmark"` | `"json"`): the document is split under the SAME
+ * selection the planner already resolved, never re-sniffed (PLAN-187 D1).
+ * Returns a JSON array of
  * `{ "source": <original index> | null, "bit": <inner bit> | null,
  *    "patch": [ … ] }`; throws on failure.
  */
-export function resolve_patch_document(input: string, patch_json: string): string;
+export function resolve_patch_document(input: string, input_format_sel: string, patch_json: string): string;
+/**
+ * The constructs valid at a position, as an LSP `CompletionList` (PLAN-196
+ * D7; contract `API-EDT-editor-services.tsp`). `line` / `character` are
+ * 0-based, `character` in `position_encoding` units (`"utf-16"`, the
+ * default, or `"utf-8"`); `include_deprecated` offers deprecated bits too;
+ * `trigger_character` is the character the editor sent as the trigger (LSP
+ * `CompletionContext.triggerCharacter`; empty when invoked explicitly) — a
+ * trigger that opens nothing where the cursor is answers the empty list
+ * (PLAN-203 D1). ABSENT on a variant built without `editor` — the same
+ * "presence is the capability" signal `diff` uses. Throws when the line is
+ * past the text.
+ */
+export function complete(input: string, line: number, character: number, position_encoding: string, include_deprecated: boolean, trigger_character: string): string;
+/**
+ * One item of the list `complete` returns at this position, its Markdown
+ * `documentation` filled in — LSP `completionItem/resolve` (PLAN-202):
+ * `complete` ships no documentation, an editor asks for the one item it is
+ * about to show. `label` and `kind` (the LSP `CompletionItemKind` number)
+ * name the item; the JSON `null` when the list has no such item. Arguments
+ * otherwise as `complete`.
+ */
+export function resolve(input: string, line: number, character: number, position_encoding: string, include_deprecated: boolean, label: string, kind: number): string;
+/**
+ * The construct at a position, as an LSP `Hover` — or the JSON `null` when
+ * there is nothing to show (PLAN-196 D8). Arguments as `complete`.
+ */
+export function hover(input: string, line: number, character: number, position_encoding: string): string;
 /**
  * Convert between bitmark and JSON with explicit input/output formats + mode.
  *
  * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"` | a mapping id.
  * `output_format`: `"auto"` (opposite of input) | `"bitmark"` | `"json"` |
- * `"text"` | `"lex"` (the token stream as JSON, bitmark input only) | a
- * mapping id.
+ * `"text"` | `"lex"` (the token stream as JSON) | `"semantic-tokens"` |
+ * `"diagnostics"` (the last three bitmark input only) | a mapping id.
  * `mode`: `"optimized"` (default) | `"full"`.
  * `mapping_report`: replace the output with a human-readable report of the
  * input→output mappings, including inputs that are NOT mapped (PLAN-147).
- * `position_encoding`: `"utf-16"` (default) | `"utf-8"` and `tokens_layout`:
- * `"lsp"` (default) | `"absolute"` — the `semantic-tokens` output's two
- * options (PLAN-193); `""` means the default, and every other output
+ * `position_encoding`: `"utf-16"` (default) | `"utf-8"` — the
+ * `semantic-tokens` and `diagnostics` outputs' encoding (PLAN-193 /
+ * PLAN-196) — and `tokens_layout`: `"lsp"` (default) | `"absolute"` — the
+ * `semantic-tokens` layout; `""` means the default, and every other output
  * format ignores them.
  * Returns the converted text/JSON; throws on failure.
  */