@gmb/bitmark-parser 7.7.0 → 7.9.0

package/wasm/bitmark_wasm.js

@@ -260,6 +260,115 @@ function takeObject(idx) {
     dropObject(idx);
     return ret;
 }
+/**
+ * Split a JSON document (a top-level array of bit envelopes) into its per-bit
+ * envelope objects, returned as a JSON array string. Lets a JS caller iterate
+ * JSON-input bits for per-bit hooks (the JSON counterpart of [`split_bits`]).
+ * Throws if the input is not a JSON array of bits.
+ * @param {string} input
+ * @returns {string}
+ */
+module.exports.split_json_bits = function(input) {
+    let deferred3_0;
+    let deferred3_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;
+        wasm.split_json_bits(retptr, ptr0, len0);
+        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 ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
+    }
+};
+
+/**
+ * Pretty-print a compact JSON string with the given indent. Used to format a
+ * document recombined on the JS side (the per-bit hook path) so its output
+ * matches the in-Rust recombination byte-for-byte.
+ * @param {string} json
+ * @param {number} indent
+ * @returns {string}
+ */
+module.exports.prettify = function(json, indent) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.prettify(retptr, ptr0, len0, indent);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+    }
+};
+
+/**
+ * Convert a standalone bitmark text fragment ↔ TextAst (ProseMirror JSON).
+ *
+ * `direction`: `"textToAst"` | `"astToText"` | `"astToPlainText"`.
+ * `format`: a bitmark text format (`"bitmark++"`, `"bitmark+"`) parses
+ * inline marks; anything else is treated as plain text (textToAst only).
+ * `location`: `"body"` (default) or `"tag"`.
+ * Returns the converted fragment; throws on failure.
+ * @param {string} input
+ * @param {string} direction
+ * @param {string} format
+ * @param {string} location
+ * @returns {string}
+ */
+module.exports.convert_text = function(input, direction, format, location) {
+    let deferred6_0;
+    let deferred6_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(direction, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(format, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(location, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.convert_text(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        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 ptr5 = r0;
+        var len5 = r1;
+        if (r3) {
+            ptr5 = 0; len5 = 0;
+            throw takeObject(r2);
+        }
+        deferred6_0 = ptr5;
+        deferred6_1 = len5;
+        return getStringFromWasm0(ptr5, len5);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred6_0, deferred6_1, 1);
+    }
+};
+
 /**
  * Apply a patch (a JSON array of patch entries) to every bit and re-emit.
  *
@@ -430,18 +539,20 @@ module.exports.diff = function(a, b, input_format_sel, output_format_sel, contex
  * `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.
+ * (PLAN-203 D1); `bit_template` makes a bit-type item insert the bit's
+ * normal template as a snippet (PLAN-225 D9). 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
+ * @param {boolean} bit_template
  * @returns {string}
  */
-module.exports.complete = function(input, line, character, position_encoding, include_deprecated, trigger_character) {
+module.exports.complete = function(input, line, character, position_encoding, include_deprecated, trigger_character, bit_template) {
     let deferred5_0;
     let deferred5_1;
     try {
@@ -452,7 +563,7 @@ module.exports.complete = function(input, line, character, position_encoding, in
         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);
+        wasm.complete(retptr, ptr0, len0, line, character, ptr1, len1, include_deprecated, ptr2, len2, bit_template);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -484,11 +595,12 @@ module.exports.complete = function(input, line, character, position_encoding, in
  * @param {number} character
  * @param {string} position_encoding
  * @param {boolean} include_deprecated
+ * @param {boolean} bit_template
  * @param {string} label
  * @param {number} kind
  * @returns {string}
  */
-module.exports.resolve = function(input, line, character, position_encoding, include_deprecated, label, kind) {
+module.exports.resolve = function(input, line, character, position_encoding, include_deprecated, bit_template, label, kind) {
     let deferred5_0;
     let deferred5_1;
     try {
@@ -499,7 +611,7 @@ module.exports.resolve = function(input, line, character, position_encoding, inc
         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);
+        wasm.resolve(retptr, ptr0, len0, line, character, ptr1, len1, include_deprecated, bit_template, 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);
@@ -557,6 +669,76 @@ module.exports.hover = function(input, line, character, position_encoding) {
     }
 };
 
+/**
+ * One bit's template (PLAN-225 D8): `format` is `text` (plain bitmark),
+ * `snippet` (LSP snippet) or `json` (the slot model with both renderings);
+ * `full` lists every tag and every attachable resource chain instead of
+ * the normal template; `include_deprecated` keeps deprecated tags. Throws
+ * for an unknown bit. ABSENT on a variant built without `template` — the
+ * "presence is the capability" signal `diff` uses.
+ * @param {string} bit
+ * @param {string} format
+ * @param {boolean} full
+ * @param {boolean} include_deprecated
+ * @param {boolean} pretty
+ * @param {number} indent
+ * @returns {string}
+ */
+module.exports.template = function(bit, format, full, include_deprecated, pretty, indent) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(bit, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.template(retptr, ptr0, len0, ptr1, len1, full, include_deprecated, pretty, indent);
+        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);
+    }
+};
+
+/**
+ * Every authorable bit's `normal` and `full` template as one JSON object
+ * keyed by bit name (PLAN-225 D8); `include_deprecated` admits deprecated
+ * bits and tags.
+ * @param {boolean} include_deprecated
+ * @param {boolean} pretty
+ * @param {number} indent
+ * @returns {string}
+ */
+module.exports.template_all = function(include_deprecated, pretty, indent) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.template_all(retptr, include_deprecated, pretty, indent);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+    }
+};
+
 /**
  * Register data with the parser process (PLAN-173 P12).
  *
@@ -702,125 +884,39 @@ module.exports.split_bits = function(input, position_encoding) {
 };
 
 /**
- * Whether `input` looks like bitmark (vs JSON). Mirrors the auto-detection
- * used across the API so a JS caller can resolve `"auto"` consistently.
- * @param {string} input
- * @returns {boolean}
- */
-module.exports.is_bitmark = function(input) {
-    const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.is_bitmark(ptr0, len0);
-    return ret !== 0;
-};
-
-/**
- * Split a JSON document (a top-level array of bit envelopes) into its per-bit
- * envelope objects, returned as a JSON array string. Lets a JS caller iterate
- * JSON-input bits for per-bit hooks (the JSON counterpart of [`split_bits`]).
- * Throws if the input is not a JSON array of bits.
- * @param {string} input
- * @returns {string}
- */
-module.exports.split_json_bits = function(input) {
-    let deferred3_0;
-    let deferred3_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;
-        wasm.split_json_bits(retptr, ptr0, len0);
-        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 ptr2 = r0;
-        var len2 = r1;
-        if (r3) {
-            ptr2 = 0; len2 = 0;
-            throw takeObject(r2);
-        }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
-    }
-};
-
-/**
- * Pretty-print a compact JSON string with the given indent. Used to format a
- * document recombined on the JS side (the per-bit hook path) so its output
- * matches the in-Rust recombination byte-for-byte.
- * @param {string} json
- * @param {number} indent
+ * The version of this wasm (the crate version, kept in lockstep with the npm
+ * package). The browser entry checks it against its own before using the
+ * module, so a wrapper never drives another release's wasm (PLAN-224 D2).
  * @returns {string}
  */
-module.exports.prettify = function(json, indent) {
-    let deferred2_0;
-    let deferred2_1;
+module.exports.version = function() {
+    let deferred1_0;
+    let deferred1_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.prettify(retptr, ptr0, len0, indent);
+        wasm.version(retptr);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred2_0 = r0;
-        deferred2_1 = r1;
+        deferred1_0 = r0;
+        deferred1_1 = r1;
         return getStringFromWasm0(r0, r1);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+        wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
     }
 };
 
 /**
- * Convert a standalone bitmark text fragment ↔ TextAst (ProseMirror JSON).
- *
- * `direction`: `"textToAst"` | `"astToText"` | `"astToPlainText"`.
- * `format`: a bitmark text format (`"bitmark++"`, `"bitmark+"`) parses
- * inline marks; anything else is treated as plain text (textToAst only).
- * `location`: `"body"` (default) or `"tag"`.
- * Returns the converted fragment; throws on failure.
+ * Whether `input` looks like bitmark (vs JSON). Mirrors the auto-detection
+ * used across the API so a JS caller can resolve `"auto"` consistently.
  * @param {string} input
- * @param {string} direction
- * @param {string} format
- * @param {string} location
- * @returns {string}
+ * @returns {boolean}
  */
-module.exports.convert_text = function(input, direction, format, location) {
-    let deferred6_0;
-    let deferred6_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(direction, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(format, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len2 = WASM_VECTOR_LEN;
-        const ptr3 = passStringToWasm0(location, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len3 = WASM_VECTOR_LEN;
-        wasm.convert_text(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
-        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 ptr5 = r0;
-        var len5 = r1;
-        if (r3) {
-            ptr5 = 0; len5 = 0;
-            throw takeObject(r2);
-        }
-        deferred6_0 = ptr5;
-        deferred6_1 = len5;
-        return getStringFromWasm0(ptr5, len5);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred6_0, deferred6_1, 1);
-    }
+module.exports.is_bitmark = function(input) {
+    const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.is_bitmark(ptr0, len0);
+    return ret !== 0;
 };
 
 /**
@@ -1001,8 +1097,8 @@ class ConvertDetails {
         }
     }
     /**
-     * The bit spans, flat `[index, start, end, …]`; `undefined` when not
-     * asked for.
+     * The bit spans, flat `[index, inputStart, inputEnd, outputStart,
+     * outputEnd, …]` (PLAN-223 F5); `undefined` when not asked for.
      * @returns {Uint32Array | undefined}
      */
     bit_spans() {

package/wasm/bitmark_wasm_bg.wasm.d.ts

@@ -4,7 +4,7 @@ export const memory: WebAssembly.Memory;
 export const __wbg_convertdetails_free: (a: number, b: number) => void;
 export const breakscape_text: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: 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 complete: (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 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 convert_with_details: (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, s: number) => void;
@@ -19,12 +19,15 @@ 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: (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: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: 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, d: number, e: number) => void;
 export const split_json_bits: (a: number, b: number, c: number) => void;
+export const template: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+export const template_all: (a: number, b: number, c: number, d: 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;
 export const unbreakscape_text: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+export const version: (a: number) => void;
 export const __wbindgen_add_to_stack_pointer: (a: number) => number;
 export const __wbindgen_export_0: (a: number, b: number) => number;
 export const __wbindgen_export_1: (a: number, b: number, c: number, d: number) => number;

package/wasm/package.json

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

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

@@ -39,20 +39,47 @@ export function unbreakscape_text(input: string, format: string, location: strin
  */
 export function info(info_type: string, format: string, bit: string, pretty: boolean, indent: number, include_deprecated: boolean, only_deprecated: boolean, full: boolean, language: string): string;
 /**
- * Register data with the parser process (PLAN-173 P12).
- *
- * `data_type`: `"translations"` today. One verb rather than one function per
- * registerable thing — the same discriminated-options idiom as `info`.
+ * One bit's template (PLAN-225 D8): `format` is `text` (plain bitmark),
+ * `snippet` (LSP snippet) or `json` (the slot model with both renderings);
+ * `full` lists every tag and every attachable resource chain instead of
+ * the normal template; `include_deprecated` keeps deprecated tags. Throws
+ * for an unknown bit. ABSENT on a variant built without `template` — the
+ * "presence is the capability" signal `diff` uses.
+ */
+export function template(bit: string, format: string, full: boolean, include_deprecated: boolean, pretty: boolean, indent: number): string;
+/**
+ * Pretty-print a compact JSON string with the given indent. Used to format a
+ * document recombined on the JS side (the per-bit hook path) so its output
+ * matches the in-Rust recombination byte-for-byte.
+ */
+export function prettify(json: string, indent: number): string;
+/**
+ * Convert a standalone bitmark text fragment ↔ TextAst (ProseMirror JSON).
  *
- * `data` is the file's own text. Semantics are REPLACE: a second call
- * supersedes the first entirely, and the built-in table (where the variant
- * bakes one) stays underneath. Throws on bad data — like every other
- * fallible export (PLAN-192 D1).
+ * `direction`: `"textToAst"` | `"astToText"` | `"astToPlainText"`.
+ * `format`: a bitmark text format (`"bitmark++"`, `"bitmark+"`) parses
+ * inline marks; anything else is treated as plain text (textToAst only).
+ * `location`: `"body"` (default) or `"tag"`.
+ * Returns the converted fragment; throws on failure.
+ */
+export function convert_text(input: string, direction: string, format: string, location: string): string;
+/**
+ * Apply a patch (a JSON array of patch entries) to every bit and re-emit.
  *
- * Available in EVERY variant, including those that bake nothing: that is
- * exactly where a consumer must supply the file themselves.
+ * `input_format_sel`: `"auto"` | `"bitmark"` | `"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 `{ "data": <document text/JSON>, "diagnostics":
+ * [ { "path", "kind", "message" } ] }` — the diagnostics are the entries the
+ * pipeline skipped (PLAN-209 T9; `kind` is the error contract's identifier,
+ * e.g. `patch-index-out-of-range`); throws on failure.
  */
-export function register(data_type: string, data: string): void;
+export function transform(input: string, input_format_sel: string, output_format_sel: string, mode: string, patch_json: string, pretty: boolean, indent: number, spaces_around_values: number): string;
 /**
  * Resolve a patch document against `input` (bitmark or JSON) into the
  * ordered output items, so a JS per-bit planner (hooks, worker pool) can
@@ -73,11 +100,12 @@ export function resolve_patch_document(input: string, input_format_sel: string,
  * `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.
+ * (PLAN-203 D1); `bit_template` makes a bit-type item insert the bit's
+ * normal template as a snippet (PLAN-225 D9). 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;
+export function complete(input: string, line: number, character: number, position_encoding: string, include_deprecated: boolean, trigger_character: string, bit_template: boolean): string;
 /**
  * One item of the list `complete` returns at this position, its Markdown
  * `documentation` filled in — LSP `completionItem/resolve` (PLAN-202):
@@ -86,12 +114,33 @@ export function complete(input: string, line: number, character: number, positio
  * 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;
+export function resolve(input: string, line: number, character: number, position_encoding: string, include_deprecated: boolean, bit_template: 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;
+/**
+ * Every authorable bit's `normal` and `full` template as one JSON object
+ * keyed by bit name (PLAN-225 D8); `include_deprecated` admits deprecated
+ * bits and tags.
+ */
+export function template_all(include_deprecated: boolean, pretty: boolean, indent: number): string;
+/**
+ * Register data with the parser process (PLAN-173 P12).
+ *
+ * `data_type`: `"translations"` today. One verb rather than one function per
+ * registerable thing — the same discriminated-options idiom as `info`.
+ *
+ * `data` is the file's own text. Semantics are REPLACE: a second call
+ * supersedes the first entirely, and the built-in table (where the variant
+ * bakes one) stays underneath. Throws on bad data — like every other
+ * fallible export (PLAN-192 D1).
+ *
+ * Available in EVERY variant, including those that bake nothing: that is
+ * exactly where a consumer must supply the file themselves.
+ */
+export function register(data_type: string, data: string): void;
 /**
  * Re-emit input in its own format in canonical form at `mode`.
  *
@@ -114,6 +163,12 @@ export function count_bits(input: string): string;
  * feed a worker pool).
  */
 export function split_bits(input: string, position_encoding: string): string;
+/**
+ * The version of this wasm (the crate version, kept in lockstep with the npm
+ * package). The browser entry checks it against its own before using the
+ * module, so a wrapper never drives another release's wasm (PLAN-224 D2).
+ */
+export function version(): string;
 /**
  * Whether `input` looks like bitmark (vs JSON). Mirrors the auto-detection
  * used across the API so a JS caller can resolve `"auto"` consistently.
@@ -126,39 +181,6 @@ export function is_bitmark(input: string): boolean;
  * Throws if the input is not a JSON array of bits.
  */
 export function split_json_bits(input: string): string;
-/**
- * Pretty-print a compact JSON string with the given indent. Used to format a
- * document recombined on the JS side (the per-bit hook path) so its output
- * matches the in-Rust recombination byte-for-byte.
- */
-export function prettify(json: string, indent: number): string;
-/**
- * Convert a standalone bitmark text fragment ↔ TextAst (ProseMirror JSON).
- *
- * `direction`: `"textToAst"` | `"astToText"` | `"astToPlainText"`.
- * `format`: a bitmark text format (`"bitmark++"`, `"bitmark+"`) parses
- * inline marks; anything else is treated as plain text (textToAst only).
- * `location`: `"body"` (default) or `"tag"`.
- * Returns the converted fragment; throws on failure.
- */
-export function convert_text(input: string, direction: string, format: string, location: string): string;
-/**
- * Apply a patch (a JSON array of patch entries) to every bit and re-emit.
- *
- * `input_format_sel`: `"auto"` | `"bitmark"` | `"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 `{ "data": <document text/JSON>, "diagnostics":
- * [ { "path", "kind", "message" } ] }` — the diagnostics are the entries the
- * pipeline skipped (PLAN-209 T9; `kind` is the error contract's identifier,
- * e.g. `patch-index-out-of-range`); throws on failure.
- */
-export function transform(input: string, input_format_sel: string, output_format_sel: string, mode: string, patch_json: string, pretty: boolean, indent: number, spaces_around_values: number): string;
 /**
  * Convert between bitmark and JSON with explicit input/output formats + mode.
  *
@@ -198,8 +220,8 @@ export class ConvertDetails {
    */
   bit_spans_encoding(): string | undefined;
   /**
-   * The bit spans, flat `[index, start, end, …]`; `undefined` when not
-   * asked for.
+   * The bit spans, flat `[index, inputStart, inputEnd, outputStart,
+   * outputEnd, …]` (PLAN-223 F5); `undefined` when not asked for.
    */
   bit_spans(): Uint32Array | undefined;
   /**