@gmb/bitmark-parser 6.11.0 → 7.0.0

package/wasm/bitmark_wasm.d.ts

@@ -1,14 +1,5 @@
 /* tslint:disable */
 /* eslint-disable */
-/**
- * Lex bitmark input text, returning one line per token in the same format as
- * the Rust CLI: `{kind:?} {span:?} "{text}"`.
- *
- * `stage` selects the lexer pipeline:
- *   - `"lex"` — combined (default)
- *   - `"lex-json"` — combined, JSON array output
- */
-export function lex(input: string, stage: string): string;
 /**
  * Breakscape text (escape bitmark special characters).
  *
@@ -41,6 +32,13 @@ export function unbreakscape_text(input: string, format: string, location: strin
  * several (adds a `titles` map), `"all"` for every resolvable language
  */
 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;
+/**
+ * Whether this build can render `info` as TEXT (PLAN-192 D6). The export is
+ * ABSENT when it cannot — the same "presence is the capability" signal
+ * `diff` uses, so a caller tests for the function rather than for a
+ * variant name.
+ */
+export function info_text_supported(): boolean;
 /**
  * Convert a standalone bitmark text fragment ↔ TextAst (ProseMirror JSON).
  *
@@ -48,7 +46,7 @@ export function info(info_type: string, format: string, bit: string, pretty: boo
  * `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, or `error: …`.
+ * Returns the converted fragment; throws on failure.
  */
 export function convert_text(input: string, direction: string, format: string, location: string): string;
 /**
@@ -58,9 +56,32 @@ export function convert_text(input: string, direction: string, format: string, l
  * `output_format_sel`: `"bitmark"` | `"json"` (default json).
  * `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, or `error: …`.
+ * runs sequentially. Returns the document text/JSON; 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;
+/**
+ * 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
+ * `{ "source": <original index> | null, "bit": <inner bit> | null,
+ *    "patch": [ … ] }`; throws on failure.
+ */
+export function resolve_patch_document(input: string, patch_json: string): string;
+/**
+ * Semantic diff of two documents (PLAN-179). Flat arguments like every
+ * other export:
+ *   - `input_format`: `"auto"` | `"bitmark"` | `"json"` | a mapping id,
+ *     applied to both sides;
+ *   - `output_format`: `"bitmark"` (unified-style text) | `"json"` |
+ *     `"patch"`;
+ *   - `context`, `locate`, `similarity`, `bbox_tolerance`,
+ *     `spaces_around_values` as documented on `DiffOptions`.
+ * Returns the diff (empty text / `[]` of unchanged bits / a patch document
+ * with no entries when the documents are semantically equal); throws on
+ * 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;
 /**
  * Register data with the parser process (PLAN-173 P12).
  *
@@ -69,24 +90,30 @@ export function transform(input: string, input_format_sel: string, output_format
  *
  * `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. Returns `""` on success, or an
- * `error:`-prefixed message — matching the other string-returning exports.
+ * 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): string;
+export function register(data_type: string, data: string): void;
 /**
  * Convert between bitmark and JSON with explicit input/output formats + mode.
  *
- * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"`.
- * `output_format`: `"auto"` (opposite of input) | `"bitmark"` | `"json"`.
+ * `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.
  * `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).
- * Returns the converted text/JSON, or a string prefixed `error:` on failure.
+ * `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
+ * format ignores them.
+ * Returns the converted text/JSON; throws on failure.
  */
-export function convert(input: string, input_format_sel: string, output_format_sel: string, mode: string, pretty: boolean, indent: number, spaces_around_values: number, include_unknown_properties: boolean, mapping_report: boolean): string;
+export function convert(input: string, input_format_sel: string, output_format_sel: string, mode: string, pretty: boolean, indent: number, spaces_around_values: number, include_unknown_properties: boolean, mapping_report: boolean, position_encoding: string, tokens_layout: string): string;
 /**
  * Re-emit input in its own format in canonical form at `mode`.
  *
@@ -96,7 +123,7 @@ export function convert(input: string, input_format_sel: string, output_format_s
 export function canonicalize(input: string, input_format_sel: string, mode: string, pretty: boolean, indent: number, spaces_around_values: number): string;
 /**
  * Count the bits in `input` (auto-detecting bitmark vs JSON).
- * Returns the count as a decimal string, or `error: …`.
+ * Returns the count as a decimal string; throws on failure.
  */
 export function count_bits(input: string): string;
 /**
@@ -115,7 +142,7 @@ export function is_bitmark(input: string): boolean;
  * 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`]).
- * Returns `error: …` if the input is not a JSON array of bits.
+ * Throws if the input is not a JSON array of bits.
  */
 export function split_json_bits(input: string): string;
 /**

package/wasm/bitmark_wasm.js

@@ -1,9 +1,12 @@
 
 let imports = {};
+imports['__wbindgen_placeholder__'] = module.exports;
 let wasm;
-const { TextEncoder, TextDecoder } = require(`util`);
+const { TextDecoder, TextEncoder } = require(`util`);
 
-let WASM_VECTOR_LEN = 0;
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
 
 let cachedUint8ArrayMemory0 = null;
 
@@ -14,6 +17,28 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+let WASM_VECTOR_LEN = 0;
+
 let cachedTextEncoder = new TextEncoder('utf-8');
 
 const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
@@ -76,47 +101,6 @@ function getDataViewMemory0() {
     }
     return cachedDataViewMemory0;
 }
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-/**
- * Lex bitmark input text, returning one line per token in the same format as
- * the Rust CLI: `{kind:?} {span:?} "{text}"`.
- *
- * `stage` selects the lexer pipeline:
- *   - `"lex"` — combined (default)
- *   - `"lex-json"` — combined, JSON array output
- * @param {string} input
- * @param {string} stage
- * @returns {string}
- */
-module.exports.lex = function(input, stage) {
-    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;
-        const ptr1 = passStringToWasm0(stage, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
-        const len1 = WASM_VECTOR_LEN;
-        wasm.lex(retptr, ptr0, len0, ptr1, len1);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred3_0 = r0;
-        deferred3_1 = r1;
-        return getStringFromWasm0(r0, r1);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
-    }
-};
-
 /**
  * Breakscape text (escape bitmark special characters).
  *
@@ -235,6 +219,31 @@ module.exports.info = function(info_type, format, bit, pretty, indent, include_d
     }
 };
 
+/**
+ * Whether this build can render `info` as TEXT (PLAN-192 D6). The export is
+ * ABSENT when it cannot — the same "presence is the capability" signal
+ * `diff` uses, so a caller tests for the function rather than for a
+ * variant name.
+ * @returns {boolean}
+ */
+module.exports.info_text_supported = function() {
+    const ret = wasm.info_text_supported();
+    return ret !== 0;
+};
+
+function getObject(idx) { return heap[idx]; }
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
 /**
  * Convert a standalone bitmark text fragment ↔ TextAst (ProseMirror JSON).
  *
@@ -242,7 +251,7 @@ module.exports.info = function(info_type, format, bit, pretty, indent, include_d
  * `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, or `error: …`.
+ * Returns the converted fragment; throws on failure.
  * @param {string} input
  * @param {string} direction
  * @param {string} format
@@ -250,8 +259,8 @@ module.exports.info = function(info_type, format, bit, pretty, indent, include_d
  * @returns {string}
  */
 module.exports.convert_text = function(input, direction, format, location) {
-    let deferred5_0;
-    let deferred5_1;
+    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);
@@ -265,12 +274,20 @@ module.exports.convert_text = function(input, direction, format, location) {
         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);
-        deferred5_0 = r0;
-        deferred5_1 = r1;
-        return getStringFromWasm0(r0, r1);
+        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(deferred5_0, deferred5_1, 1);
+        wasm.__wbindgen_export_2(deferred6_0, deferred6_1, 1);
     }
 };
 
@@ -281,7 +298,7 @@ module.exports.convert_text = function(input, direction, format, location) {
  * `output_format_sel`: `"bitmark"` | `"json"` (default json).
  * `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, or `error: …`.
+ * runs sequentially. Returns the document text/JSON; throws on failure.
  * @param {string} input
  * @param {string} input_format_sel
  * @param {string} output_format_sel
@@ -293,8 +310,8 @@ module.exports.convert_text = function(input, direction, format, location) {
  * @returns {string}
  */
 module.exports.transform = function(input, input_format_sel, output_format_sel, mode, patch_json, pretty, indent, spaces_around_values) {
-    let deferred6_0;
-    let deferred6_1;
+    let deferred7_0;
+    let deferred7_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
@@ -310,9 +327,113 @@ module.exports.transform = function(input, input_format_sel, output_format_sel,
         wasm.transform(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, pretty, indent, spaces_around_values);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred6_0 = r0;
-        deferred6_1 = r1;
-        return getStringFromWasm0(r0, r1);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr6 = r0;
+        var len6 = r1;
+        if (r3) {
+            ptr6 = 0; len6 = 0;
+            throw takeObject(r2);
+        }
+        deferred7_0 = ptr6;
+        deferred7_1 = len6;
+        return getStringFromWasm0(ptr6, len6);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_2(deferred7_0, deferred7_1, 1);
+    }
+};
+
+/**
+ * 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
+ * `{ "source": <original index> | null, "bit": <inner bit> | null,
+ *    "patch": [ … ] }`; throws on failure.
+ * @param {string} input
+ * @param {string} patch_json
+ * @returns {string}
+ */
+module.exports.resolve_patch_document = function(input, patch_json) {
+    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(patch_json, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.resolve_patch_document(retptr, ptr0, len0, 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);
+    }
+};
+
+/**
+ * Semantic diff of two documents (PLAN-179). Flat arguments like every
+ * other export:
+ *   - `input_format`: `"auto"` | `"bitmark"` | `"json"` | a mapping id,
+ *     applied to both sides;
+ *   - `output_format`: `"bitmark"` (unified-style text) | `"json"` |
+ *     `"patch"`;
+ *   - `context`, `locate`, `similarity`, `bbox_tolerance`,
+ *     `spaces_around_values` as documented on `DiffOptions`.
+ * Returns the diff (empty text / `[]` of unchanged bits / a patch document
+ * with no entries when the documents are semantically equal); throws on
+ * failure.
+ * @param {string} a
+ * @param {string} b
+ * @param {string} input_format_sel
+ * @param {string} output_format_sel
+ * @param {number} context
+ * @param {boolean} locate
+ * @param {number} similarity
+ * @param {number} bbox_tolerance
+ * @param {number} spaces_around_values
+ * @returns {string}
+ */
+module.exports.diff = function(a, b, input_format_sel, output_format_sel, context, locate, similarity, bbox_tolerance, spaces_around_values) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(a, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(b, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(input_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(output_format_sel, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.diff(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, context, locate, similarity, bbox_tolerance, spaces_around_values);
+        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);
@@ -327,18 +448,15 @@ module.exports.transform = function(input, input_format_sel, output_format_sel,
  *
  * `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. Returns `""` on success, or an
- * `error:`-prefixed message — matching the other string-returning exports.
+ * 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.
  * @param {string} data_type
  * @param {string} data
- * @returns {string}
  */
 module.exports.register = function(data_type, data) {
-    let deferred3_0;
-    let deferred3_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(data_type, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
@@ -348,24 +466,29 @@ module.exports.register = function(data_type, data) {
         wasm.register(retptr, ptr0, len0, ptr1, len1);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred3_0 = r0;
-        deferred3_1 = r1;
-        return getStringFromWasm0(r0, r1);
+        if (r1) {
+            throw takeObject(r0);
+        }
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
     }
 };
 
 /**
  * Convert between bitmark and JSON with explicit input/output formats + mode.
  *
- * `input_format`: `"auto"` (default) | `"bitmark"` | `"json"`.
- * `output_format`: `"auto"` (opposite of input) | `"bitmark"` | `"json"`.
+ * `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.
  * `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).
- * Returns the converted text/JSON, or a string prefixed `error:` on failure.
+ * `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
+ * format ignores them.
+ * Returns the converted text/JSON; throws on failure.
  * @param {string} input
  * @param {string} input_format_sel
  * @param {string} output_format_sel
@@ -375,11 +498,13 @@ module.exports.register = function(data_type, data) {
  * @param {number} spaces_around_values
  * @param {boolean} include_unknown_properties
  * @param {boolean} mapping_report
+ * @param {string} position_encoding
+ * @param {string} tokens_layout
  * @returns {string}
  */
-module.exports.convert = function(input, input_format_sel, output_format_sel, mode, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report) {
-    let deferred5_0;
-    let deferred5_1;
+module.exports.convert = function(input, input_format_sel, output_format_sel, mode, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report, position_encoding, tokens_layout) {
+    let deferred8_0;
+    let deferred8_1;
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
         const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
@@ -390,15 +515,27 @@ module.exports.convert = function(input, input_format_sel, output_format_sel, mo
         const len2 = WASM_VECTOR_LEN;
         const ptr3 = passStringToWasm0(mode, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
         const len3 = WASM_VECTOR_LEN;
-        wasm.convert(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report);
+        const ptr4 = passStringToWasm0(position_encoding, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passStringToWasm0(tokens_layout, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len5 = WASM_VECTOR_LEN;
+        wasm.convert(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, pretty, indent, spaces_around_values, include_unknown_properties, mapping_report, ptr4, len4, ptr5, len5);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred5_0 = r0;
-        deferred5_1 = r1;
-        return getStringFromWasm0(r0, r1);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr7 = r0;
+        var len7 = r1;
+        if (r3) {
+            ptr7 = 0; len7 = 0;
+            throw takeObject(r2);
+        }
+        deferred8_0 = ptr7;
+        deferred8_1 = len7;
+        return getStringFromWasm0(ptr7, len7);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
+        wasm.__wbindgen_export_2(deferred8_0, deferred8_1, 1);
     }
 };
 
@@ -416,8 +553,8 @@ module.exports.convert = function(input, input_format_sel, output_format_sel, mo
  * @returns {string}
  */
 module.exports.canonicalize = function(input, input_format_sel, mode, pretty, indent, spaces_around_values) {
-    let deferred4_0;
-    let deferred4_1;
+    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);
@@ -429,24 +566,32 @@ module.exports.canonicalize = function(input, input_format_sel, mode, pretty, in
         wasm.canonicalize(retptr, ptr0, len0, ptr1, len1, ptr2, len2, pretty, indent, spaces_around_values);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred4_0 = r0;
-        deferred4_1 = r1;
-        return getStringFromWasm0(r0, r1);
+        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(deferred4_0, deferred4_1, 1);
+        wasm.__wbindgen_export_2(deferred5_0, deferred5_1, 1);
     }
 };
 
 /**
  * Count the bits in `input` (auto-detecting bitmark vs JSON).
- * Returns the count as a decimal string, or `error: …`.
+ * Returns the count as a decimal string; throws on failure.
  * @param {string} input
  * @returns {string}
  */
 module.exports.count_bits = function(input) {
-    let deferred2_0;
-    let deferred2_1;
+    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);
@@ -454,12 +599,20 @@ module.exports.count_bits = function(input) {
         wasm.count_bits(retptr, ptr0, len0);
         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);
+        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(deferred2_0, deferred2_1, 1);
+        wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
     }
 };
 
@@ -507,13 +660,13 @@ module.exports.is_bitmark = function(input) {
  * 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`]).
- * Returns `error: …` if the input is not a JSON array of 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 deferred2_0;
-    let deferred2_1;
+    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);
@@ -521,12 +674,20 @@ module.exports.split_json_bits = function(input) {
         wasm.split_json_bits(retptr, ptr0, len0);
         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);
+        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(deferred2_0, deferred2_1, 1);
+        wasm.__wbindgen_export_2(deferred3_0, deferred3_1, 1);
     }
 };
 
@@ -557,6 +718,11 @@ module.exports.prettify = function(json, indent) {
     }
 };
 
+module.exports.__wbindgen_error_new = function(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+};
+
 const path = require('path').join(__dirname, 'bitmark_wasm_bg.wasm');
 const bytes = require('fs').readFileSync(path);