diff --git a/CHANGELOG.md b/CHANGELOG.md
index 44e266a..3933f37 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.3] - 2026-08-11
+
+### Changed
+
+- Advanced the canonical output schema to version 3. Record values now contain
+  one parsed `value` instead of repeating display, numeric, precision, scaling,
+  component, and raw-byte representations. Record bytes live only in
+  `header_hex` and `data_hex`.
+
+### Fixed
+
+- Restored frame, application-header, DIF/VIF, and payload colors in the web
+  hex view after annotation identifiers moved to `snake_case`.
+
 ## [0.4.2] - 2026-08-10
 
 ### Changed
diff --git a/Cargo.toml b/Cargo.toml
index 0e22a23..68b35d5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "m-bus-parser"
-version = "0.4.2"
+version = "0.4.3"
 edition = "2021"
 description = "A library for parsing M-Bus frames"
 license = "MIT"
diff --git a/README.md b/README.md
index 6b6b72a..fec2ecb 100644
--- a/README.md
+++ b/README.md
@@ -236,8 +236,11 @@ share one vocabulary:
   when one is available, such as `W`, `Cel`, or `m3.h-1`.
 - Complete temporal values use ISO 8601 notation. The parser does not invent a
   timezone when a meter does not transmit one.
+- Each record value contains a `kind` and at most one parsed `value`. Exact
+  decimals, text, and complete temporal values use strings; finite floats use
+  JSON numbers; partial temporal values use a compact component object.
 - Raw binary values use uppercase hexadecimal and fields containing them end
-  in `_hex`.
+  in `_hex`. Record bytes live only in `header_hex` and `data_hex`.
 
 There is no common JSON schema shared by M-Bus parsers. These rules retain the
 protocol vocabulary used by [M-Bus](https://m-bus.com/documentation-wired/06-application-layer)
diff --git a/cli/Cargo.toml b/cli/Cargo.toml
index 7dc5eef..8f27650 100644
--- a/cli/Cargo.toml
+++ b/cli/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "m-bus-parser-cli"
-version = "0.4.2"
+version = "0.4.3"
 edition = "2021"
 description = "A cli to use the library for parsing M-Bus frames"
 license = "MIT"
@@ -22,7 +22,7 @@ default = ["decryption"]
 decryption = ["m-bus-parser/decryption"]
 
 [dependencies]
-m-bus-parser = { path = "..", version = "0.4.2", features = ["std", "serde"] }
+m-bus-parser = { path = "..", version = "0.4.3", features = ["std", "serde"] }
 hex = "0.4"
 clap = { version = "4.5.4", features = ["derive"] }
 terminal_size = "0.4"
diff --git a/docs/index.html b/docs/index.html
index a5205c5..518cd7f 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -859,7 +859,7 @@ <h1>Online M-Bus Parser <span class="parser-version" id="parser-version"></span>
         <div id="output" aria-live="polite"></div>
     </div>
     <script type="module">
-        import init, { m_bus_highlight, m_bus_render, version } from "./m_bus_parser_wasm_pack.js?v=0.4.1";
+        import init, { m_bus_highlight, m_bus_render, version } from "./m_bus_parser_wasm_pack.js?v=0.4.3";
 
         let currentFormat = "json";
         let lastTableWidth = null;
@@ -945,7 +945,7 @@ <h1>Online M-Bus Parser <span class="parser-version" id="parser-version"></span>
                 }
             });
 
-            await init(new URL("./m_bus_parser_wasm_pack_bg.wasm?v=0.4.1", import.meta.url));
+            await init(new URL("./m_bus_parser_wasm_pack_bg.wasm?v=0.4.3", import.meta.url));
             document.getElementById('parser-version').textContent = 'v' + version();
 
             // Load data and format from URL params and auto-parse if present
@@ -1176,14 +1176,14 @@ <h1>Online M-Bus Parser <span class="parser-version" id="parser-version"></span>
 
             // Layer CSS class
             function layerClass(layer) {
-                if (layer === 'Frame') return 'hex-layer-frame';
-                if (layer === 'AppHeader') return 'hex-layer-appheader';
+                if (layer === 'frame') return 'hex-layer-frame';
+                if (layer === 'app_header') return 'hex-layer-appheader';
                 return 'hex-layer-record';
             }
             function segmentKindClass(kind) {
-                if (kind === 'Dif' || kind === 'Dife') return 'hex-kind-dif';
-                if (kind === 'Vif' || kind === 'Vife' || kind === 'PlaintextVif') return 'hex-kind-vif';
-                if (kind === 'DataPayload') return 'hex-kind-data';
+                if (kind === 'dif' || kind === 'dife') return 'hex-kind-dif';
+                if (kind === 'vif' || kind === 'vife' || kind === 'plaintext_vif') return 'hex-kind-vif';
+                if (kind === 'data_payload') return 'hex-kind-data';
                 return '';
             }
 
@@ -1375,14 +1375,14 @@ <h1>Online M-Bus Parser <span class="parser-version" id="parser-version"></span>
                     currentGroup = null;
                     const layerLabel = document.createElement('div');
                     layerLabel.className = 'hex-tree-layer';
-                    const layerNames = { 'Frame': 'Frame', 'AppHeader': 'Application Header', 'RecordField': 'Data Records' };
+                    const layerNames = { 'frame': 'Frame', 'app_header': 'Application Header', 'record_field': 'Data Records' };
                     layerLabel.textContent = layerNames[seg.layer] || seg.layer;
                     rightPanel.appendChild(layerLabel);
                     groupBody = null;
                 }
 
                 // Record grouping
-                if (seg.layer === 'RecordField' && seg.group !== null && seg.group !== currentGroup) {
+                if (seg.layer === 'record_field' && seg.group !== null && seg.group !== currentGroup) {
                     currentGroup = seg.group;
                     const groupDiv = document.createElement('div');
                     groupDiv.className = 'hex-tree-group';
diff --git a/docs/m_bus_parser_wasm_pack.js b/docs/m_bus_parser_wasm_pack.js
index 2045367..260eddc 100644
--- a/docs/m_bus_parser_wasm_pack.js
+++ b/docs/m_bus_parser_wasm_pack.js
@@ -1,24 +1,127 @@
-/* @ts-self-types="./m_bus_parser_wasm_pack.d.ts" */
+let wasm;
 
+let WASM_VECTOR_LEN = 0;
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_4.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
 /**
- * Decode into the canonical schema as a native JavaScript object.
- * @param {string} data
- * @param {string | null} [key_hex]
- * @param {boolean | null} [include_enrichment]
- * @returns {any}
+ * @returns {string}
  */
-export function m_bus_decode(data, key_hex, include_enrichment) {
-    const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    var ptr1 = isLikeNone(key_hex) ? 0 : passStringToWasm0(key_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    const ret = wasm.m_bus_decode(ptr0, len0, ptr1, len1, isLikeNone(include_enrichment) ? 0xFFFFFF : include_enrichment ? 1 : 0);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
-    return takeFromExternrefTable0(ret[0]);
 }
 
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_4.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
 /**
  * Highlight JSON, YAML, CSV, XML, or plaintext with the bundled Rust grammar set.
  * @param {string} source
@@ -49,52 +152,22 @@ export function m_bus_highlight(source, language) {
 }
 
 /**
- * Compatibility wrapper returning errors as text. Prefer `m_bus_render`.
- * @param {string} data
- * @param {string} format
- * @returns {string}
- */
-export function m_bus_parse(data, format) {
-    let deferred3_0;
-    let deferred3_1;
-    try {
-        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.m_bus_parse(ptr0, len0, ptr1, len1);
-        deferred3_0 = ret[0];
-        deferred3_1 = ret[1];
-        return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
-    }
-}
-
-/**
- * Compatibility wrapper returning errors as text. Prefer `m_bus_render`.
+ * Decode into the canonical schema as a native JavaScript object.
  * @param {string} data
- * @param {string} format
- * @param {string} key_hex
- * @returns {string}
+ * @param {string | null} [key_hex]
+ * @param {boolean | null} [include_enrichment]
+ * @returns {any}
  */
-export function m_bus_parse_with_key(data, format, key_hex) {
-    let deferred4_0;
-    let deferred4_1;
-    try {
-        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(key_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.m_bus_parse_with_key(ptr0, len0, ptr1, len1, ptr2, len2);
-        deferred4_0 = ret[0];
-        deferred4_1 = ret[1];
-        return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+export function m_bus_decode(data, key_hex, include_enrichment) {
+    const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(key_hex) ? 0 : passStringToWasm0(key_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.m_bus_decode(ptr0, len0, ptr1, len1, isLikeNone(include_enrichment) ? 0xFFFFFF : include_enrichment ? 1 : 0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
@@ -116,7 +189,7 @@ export function m_bus_render(data, format, key_hex, width, include_enrichment) {
         const len1 = WASM_VECTOR_LEN;
         var ptr2 = isLikeNone(key_hex) ? 0 : passStringToWasm0(key_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len2 = WASM_VECTOR_LEN;
-        const ret = wasm.m_bus_render(ptr0, len0, ptr1, len1, ptr2, len2, isLikeNone(width) ? Number.MAX_SAFE_INTEGER : (width) >>> 0, isLikeNone(include_enrichment) ? 0xFFFFFF : include_enrichment ? 1 : 0);
+        const ret = wasm.m_bus_render(ptr0, len0, ptr1, len1, ptr2, len2, isLikeNone(width) ? 0x100000001 : (width) >>> 0, isLikeNone(include_enrichment) ? 0xFFFFFF : include_enrichment ? 1 : 0);
         var ptr4 = ret[0];
         var len4 = ret[1];
         if (ret[3]) {
@@ -132,288 +205,201 @@ export function m_bus_render(data, format, key_hex, width, include_enrichment) {
 }
 
 /**
+ * Compatibility wrapper returning errors as text. Prefer `m_bus_render`.
+ * @param {string} data
+ * @param {string} format
  * @returns {string}
  */
-export function version() {
-    let deferred1_0;
-    let deferred1_1;
+export function m_bus_parse(data, format) {
+    let deferred3_0;
+    let deferred3_1;
     try {
-        const ret = wasm.version();
-        deferred1_0 = ret[0];
-        deferred1_1 = ret[1];
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.m_bus_parse(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
-}
-function __wbg_get_imports() {
-    const import0 = {
-        __proto__: null,
-        __wbg_Error_408e67f47ca7b58b: function(arg0, arg1) {
-            const ret = Error(getStringFromWasm0(arg0, arg1));
-            return ret;
-        },
-        __wbg_String_8564e559799eccda: function(arg0, arg1) {
-            const ret = String(arg1);
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
-        __wbg___wbindgen_is_string_e6f02f0ea5f20a32: function(arg0) {
-            const ret = typeof(arg0) === 'string';
-            return ret;
-        },
-        __wbg___wbindgen_string_get_d154f1e671052120: function(arg0, arg1) {
-            const obj = arg1;
-            const ret = typeof(obj) === 'string' ? obj : undefined;
-            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            var len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
-        __wbg___wbindgen_throw_bb96b2010945f0bc: function(arg0, arg1) {
-            throw new Error(getStringFromWasm0(arg0, arg1));
-        },
-        __wbg_new_116be93542d39019: function() {
-            const ret = new Array();
-            return ret;
-        },
-        __wbg_new_358857d90afd5a2d: function(arg0, arg1) {
-            const ret = new Error(getStringFromWasm0(arg0, arg1));
-            return ret;
-        },
-        __wbg_new_cdf041679ded4c5f: function() {
-            const ret = new Map();
-            return ret;
-        },
-        __wbg_new_ebe3e0f6837f0879: function() {
-            const ret = new Object();
-            return ret;
-        },
-        __wbg_set_014226dfeca53178: function(arg0, arg1, arg2) {
-            const ret = arg0.set(arg1, arg2);
-            return ret;
-        },
-        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
-            arg0[arg1] = arg2;
-        },
-        __wbg_set_8155bb79a948541b: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = Reflect.set(arg0, arg1, arg2);
-            return ret;
-        }, arguments); },
-        __wbg_set_a80955eb93b145c6: function(arg0, arg1, arg2) {
-            arg0[arg1 >>> 0] = arg2;
-        },
-        __wbg_set_name_7a2a05b77a392440: function(arg0, arg1, arg2) {
-            arg0.name = getStringFromWasm0(arg1, arg2);
-        },
-        __wbg_stringify_f93a4ebae9231922: function() { return handleError(function (arg0) {
-            const ret = JSON.stringify(arg0);
-            return ret;
-        }, arguments); },
-        __wbindgen_cast_0000000000000001: function(arg0) {
-            // Cast intrinsic for `F64 -> Externref`.
-            const ret = arg0;
-            return ret;
-        },
-        __wbindgen_cast_0000000000000002: function(arg0) {
-            // Cast intrinsic for `I64 -> Externref`.
-            const ret = arg0;
-            return ret;
-        },
-        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Ref(String) -> Externref`.
-            const ret = getStringFromWasm0(arg0, arg1);
-            return ret;
-        },
-        __wbindgen_cast_0000000000000004: function(arg0) {
-            // Cast intrinsic for `U64 -> Externref`.
-            const ret = BigInt.asUintN(64, arg0);
-            return ret;
-        },
-        __wbindgen_init_externref_table: function() {
-            const table = wasm.__wbindgen_externrefs;
-            const offset = table.grow(4);
-            table.set(0, undefined);
-            table.set(offset + 0, undefined);
-            table.set(offset + 1, null);
-            table.set(offset + 2, true);
-            table.set(offset + 3, false);
-        },
-    };
-    return {
-        __proto__: null,
-        "./m_bus_parser_wasm_pack_bg.js": import0,
-    };
-}
-
-function addToExternrefTable0(obj) {
-    const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_externrefs.set(idx, obj);
-    return idx;
-}
-
-let cachedDataViewMemory0 = null;
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-
-function getStringFromWasm0(ptr, len) {
-    return decodeText(ptr >>> 0, len);
-}
-
-let cachedUint8ArrayMemory0 = null;
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
-    return cachedUint8ArrayMemory0;
 }
 
-function handleError(f, args) {
+/**
+ * Compatibility wrapper returning errors as text. Prefer `m_bus_render`.
+ * @param {string} data
+ * @param {string} format
+ * @param {string} key_hex
+ * @returns {string}
+ */
+export function m_bus_parse_with_key(data, format, key_hex) {
+    let deferred4_0;
+    let deferred4_1;
     try {
-        return f.apply(this, args);
-    } catch (e) {
-        const idx = addToExternrefTable0(e);
-        wasm.__wbindgen_exn_store(idx);
-    }
-}
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-function passStringToWasm0(arg, malloc, realloc) {
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-cachedTextDecoder.decode();
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(key_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.m_bus_parse_with_key(ptr0, len0, ptr1, len1, ptr2, len2);
+        deferred4_0 = ret[0];
+        deferred4_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-const cachedTextEncoder = new TextEncoder();
-
-if (!('encodeInto' in cachedTextEncoder)) {
-    cachedTextEncoder.encodeInto = function (arg, view) {
-        const buf = cachedTextEncoder.encode(arg);
-        view.set(buf);
-        return {
-            read: arg.length,
-            written: buf.length
-        };
-    };
-}
-
-let WASM_VECTOR_LEN = 0;
-
-let wasmModule, wasmInstance, wasm;
-function __wbg_finalize_init(instance, module) {
-    wasmInstance = instance;
-    wasm = instance.exports;
-    wasmModule = module;
-    cachedDataViewMemory0 = null;
-    cachedUint8ArrayMemory0 = null;
-    wasm.__wbindgen_start();
-    return wasm;
 }
 
 async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
-        if (!module.ok) {
-            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
-        }
-
         if (typeof WebAssembly.instantiateStreaming === 'function') {
             try {
                 return await WebAssembly.instantiateStreaming(module, imports);
-            } catch (e) {
-                const validResponse = expectedResponseType(module.type);
 
-                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+            } catch (e) {
+                if (module.headers.get('Content-Type') != 'application/wasm') {
                     console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
 
-                } else { throw e; }
+                } else {
+                    throw e;
+                }
             }
         }
 
         const bytes = await module.arrayBuffer();
         return await WebAssembly.instantiate(bytes, imports);
+
     } else {
         const instance = await WebAssembly.instantiate(module, imports);
 
         if (instance instanceof WebAssembly.Instance) {
             return { instance, module };
+
         } else {
             return instance;
         }
     }
+}
 
-    function expectedResponseType(type) {
-        switch (type) {
-            case 'basic': case 'cors': case 'default': return true;
-        }
-        return false;
-    }
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+        const ret = String(arg1);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_new_405e22f390576ce2 = function() {
+        const ret = new Object();
+        return ret;
+    };
+    imports.wbg.__wbg_new_5e0be73521bc8c17 = function() {
+        const ret = new Map();
+        return ret;
+    };
+    imports.wbg.__wbg_new_78feb108b6472713 = function() {
+        const ret = new Array();
+        return ret;
+    };
+    imports.wbg.__wbg_new_c68d7209be747379 = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) {
+        arg0[arg1 >>> 0] = arg2;
+    };
+    imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+        arg0[arg1] = arg2;
+    };
+    imports.wbg.__wbg_set_8fc6bf8a5b1071d1 = function(arg0, arg1, arg2) {
+        const ret = arg0.set(arg1, arg2);
+        return ret;
+    };
+    imports.wbg.__wbg_set_bb8cecf6a62b9f46 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = Reflect.set(arg0, arg1, arg2);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_setname_6df54b7ebf9404a9 = function(arg0, arg1, arg2) {
+        arg0.name = getStringFromWasm0(arg1, arg2);
+    };
+    imports.wbg.__wbg_stringify_f7ed6987935b4a24 = function() { return handleError(function (arg0) {
+        const ret = JSON.stringify(arg0);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
+        const ret = arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
+        const ret = BigInt.asUintN(64, arg0);
+        return ret;
+    };
+    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbindgen_init_externref_table = function() {
+        const table = wasm.__wbindgen_export_4;
+        const offset = table.grow(4);
+        table.set(0, undefined);
+        table.set(offset + 0, undefined);
+        table.set(offset + 1, null);
+        table.set(offset + 2, true);
+        table.set(offset + 3, false);
+        ;
+    };
+    imports.wbg.__wbindgen_is_string = function(arg0) {
+        const ret = typeof(arg0) === 'string';
+        return ret;
+    };
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+
+    return imports;
+}
+
+function __wbg_init_memory(imports, memory) {
+
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
 }
 
 function initSync(module) {
     if (wasm !== undefined) return wasm;
 
 
-    if (module !== undefined) {
+    if (typeof module !== 'undefined') {
         if (Object.getPrototypeOf(module) === Object.prototype) {
             ({module} = module)
         } else {
@@ -422,10 +408,15 @@ function initSync(module) {
     }
 
     const imports = __wbg_get_imports();
+
+    __wbg_init_memory(imports);
+
     if (!(module instanceof WebAssembly.Module)) {
         module = new WebAssembly.Module(module);
     }
+
     const instance = new WebAssembly.Instance(module, imports);
+
     return __wbg_finalize_init(instance, module);
 }
 
@@ -433,7 +424,7 @@ async function __wbg_init(module_or_path) {
     if (wasm !== undefined) return wasm;
 
 
-    if (module_or_path !== undefined) {
+    if (typeof module_or_path !== 'undefined') {
         if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
             ({module_or_path} = module_or_path)
         } else {
@@ -441,7 +432,7 @@ async function __wbg_init(module_or_path) {
         }
     }
 
-    if (module_or_path === undefined) {
+    if (typeof module_or_path === 'undefined') {
         module_or_path = new URL('m_bus_parser_wasm_pack_bg.wasm', import.meta.url);
     }
     const imports = __wbg_get_imports();
@@ -450,9 +441,12 @@ async function __wbg_init(module_or_path) {
         module_or_path = fetch(module_or_path);
     }
 
+    __wbg_init_memory(imports);
+
     const { instance, module } = await __wbg_load(await module_or_path, imports);
 
     return __wbg_finalize_init(instance, module);
 }
 
-export { initSync, __wbg_init as default };
+export { initSync };
+export default __wbg_init;
diff --git a/docs/m_bus_parser_wasm_pack_bg.wasm b/docs/m_bus_parser_wasm_pack_bg.wasm
index 5453705..f6d7740 100644
Binary files a/docs/m_bus_parser_wasm_pack_bg.wasm and b/docs/m_bus_parser_wasm_pack_bg.wasm differ
diff --git a/python/Cargo.toml b/python/Cargo.toml
index 85369a4..a2c9396 100644
--- a/python/Cargo.toml
+++ b/python/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pymbusparser"
-version = "0.4.2"
+version = "0.4.3"
 edition = "2021"
 homepage = "https://maebli.github.io/"
 repository = "https://github.com/maebli/m-bus-parser"
@@ -8,7 +8,7 @@ description = "A Python binding for the M-Bus parser"
 license = "MIT"
 
 [dependencies]
-m-bus-parser = { path = "..", version = "0.4.2", features = ["std", "serde", "decryption"] }
+m-bus-parser = { path = "..", version = "0.4.3", features = ["std", "serde", "decryption"] }
 serde_json = "1.0"
 pyo3 = { version = "0.29.0", features = ["extension-module", "generate-import-lib"] }
 hex = "0.4"
diff --git a/python/tests/test_bindings.py b/python/tests/test_bindings.py
index 408cf67..51b7899 100644
--- a/python/tests/test_bindings.py
+++ b/python/tests/test_bindings.py
@@ -27,7 +27,7 @@ def test_parse_returns_native_objects(self):
         frame_bytes = bytes.fromhex(WIRED_FRAME.replace(" ", ""))
 
         self.assertIsInstance(parsed, dict)
-        self.assertEqual(parsed["schema_version"], 2)
+        self.assertEqual(parsed["schema_version"], 3)
         self.assertEqual(parsed["protocol"], "wired")
         self.assertIn("frame", parsed)
         self.assertEqual(parsed, pymbusparser.parse(frame_bytes))
diff --git a/src/mbus_data.rs b/src/mbus_data.rs
index d2667e8..4a22f16 100644
--- a/src/mbus_data.rs
+++ b/src/mbus_data.rs
@@ -1224,7 +1224,7 @@ pub(crate) fn render_annotated_bytes(
                 })?;
             replace_encrypted_payload_segments(&mut display_segments, &display_data);
             return serde_json::to_string_pretty(&serde_json::json!({
-                "schema_version": 2,
+                "schema_version": 3,
                 "bytes": display_data,
                 "segments": display_segments,
                 "decrypted": true,
@@ -1244,7 +1244,7 @@ pub(crate) fn render_annotated_bytes(
     let _ = key;
 
     serde_json::to_string_pretty(&serde_json::json!({
-        "schema_version": 2,
+        "schema_version": 3,
         "bytes": data,
         "segments": original_segments,
         "decrypted": false,
diff --git a/src/output.rs b/src/output.rs
index c900ce8..9b0fdee 100644
--- a/src/output.rs
+++ b/src/output.rs
@@ -20,7 +20,7 @@ use crate::user_data::data_information::{
 };
 use crate::user_data::value_information::{Unit, UnitName, ValueLabel};
 
-const SCHEMA_VERSION: u8 = 2;
+const SCHEMA_VERSION: u8 = 3;
 const DEFAULT_TABLE_WIDTH: usize = 100;
 const MINIMUM_TABLE_WIDTH: usize = 32;
 
@@ -336,30 +336,18 @@ pub struct RecordOutput {
     pub data_coding: String,
     pub header_hex: String,
     pub data_hex: String,
-    pub record_hex: String,
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub struct ValueOutput {
     pub kind: String,
-    pub display: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub decimal: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub significand: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub number: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub scale_power10: Option<isize>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub offset_power10: Option<isize>,
+    /// The single canonical parsed representation for this value.
+    ///
+    /// Exact decimals and text use JSON strings, finite floating-point values
+    /// use JSON numbers, complete temporal values use ISO 8601 strings, and
+    /// partial temporal values use a compact component object.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub precision: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub special: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub components: Option<serde_json::Value>,
-    pub raw_hex: String,
+    pub value: Option<serde_json::Value>,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -1315,7 +1303,6 @@ fn record_output(index: usize, record: &user_data::DataRecord<'_>) -> RecordOutp
         data_coding,
         header_hex: record.data_record_header_hex(),
         data_hex: record.data_hex(),
-        record_hex: spaced_hex(record.raw_bytes()),
     }
 }
 
@@ -1464,9 +1451,6 @@ fn standardized_word(word: &str, first: bool) -> String {
 }
 
 fn value_output(record: &user_data::DataRecord<'_>) -> ValueOutput {
-    let header_size = record.data_record_header.get_size();
-    let raw = record.raw_bytes().get(header_size..).unwrap_or_default();
-    let raw_hex = spaced_hex(raw);
     let information = record.data_information();
     let value_information = record.value_information();
     let scale = value_information.map(|value| value.decimal_scale_exponent);
@@ -1480,16 +1464,10 @@ fn value_output(record: &user_data::DataRecord<'_>) -> ValueOutput {
                 let (number_value, special) = finite_number(*number);
                 return ValueOutput {
                     kind: "float".to_string(),
-                    display: special.clone().unwrap_or_else(|| number.to_string()),
-                    decimal: None,
-                    significand: None,
-                    number: number_value,
-                    scale_power10: None,
-                    offset_power10: None,
-                    precision: Some("f32_approximate".to_string()),
-                    special,
-                    components: None,
-                    raw_hex,
+                    value: number_value
+                        .and_then(serde_json::Number::from_f64)
+                        .map(serde_json::Value::Number)
+                        .or_else(|| special.map(serde_json::Value::String)),
                 };
             }
 
@@ -1497,42 +1475,17 @@ fn value_output(record: &user_data::DataRecord<'_>) -> ValueOutput {
                 exact_significand(record, *number).unwrap_or_else(|| format!("{number:.0}"));
             let scale_value = scale.unwrap_or(0);
             let decimal = scaled_decimal(&significand, scale_value, offset);
-            let convenience_number = decimal
-                .parse::<f64>()
-                .ok()
-                .filter(|value| value.is_finite());
             ValueOutput {
                 kind: "decimal".to_string(),
-                display: decimal.clone(),
-                decimal: Some(decimal),
-                significand: Some(significand),
-                number: convenience_number,
-                scale_power10: Some(scale_value),
-                offset_power10: offset,
-                precision: Some("exact".to_string()),
-                special: None,
-                components: None,
-                raw_hex,
-            }
-        }
-        Some(DataType::Text(text)) => {
-            let display = text.to_string();
-            ValueOutput {
-                kind: "text".to_string(),
-                display,
-                decimal: None,
-                significand: None,
-                number: None,
-                scale_power10: None,
-                offset_power10: None,
-                precision: None,
-                special: None,
-                components: None,
-                raw_hex,
+                value: Some(serde_json::Value::String(decimal)),
             }
         }
+        Some(DataType::Text(text)) => ValueOutput {
+            kind: "text".to_string(),
+            value: Some(serde_json::Value::String(text.to_string())),
+        },
         Some(DataType::Date(day, month, year)) => {
-            temporal_value("date", day, month, year, None, None, None, raw_hex)
+            temporal_value("date", day, month, year, None, None, None)
         }
         Some(DataType::Time(second, minute, hour)) => temporal_value(
             "time",
@@ -1542,18 +1495,10 @@ fn value_output(record: &user_data::DataRecord<'_>) -> ValueOutput {
             Some(hour),
             Some(minute),
             Some(second),
-            raw_hex,
-        ),
-        Some(DataType::DateTime(day, month, year, hour, minute)) => temporal_value(
-            "datetime",
-            day,
-            month,
-            year,
-            Some(hour),
-            Some(minute),
-            None,
-            raw_hex,
         ),
+        Some(DataType::DateTime(day, month, year, hour, minute)) => {
+            temporal_value("datetime", day, month, year, Some(hour), Some(minute), None)
+        }
         Some(DataType::DateTimeWithSeconds(day, month, year, hour, minute, second)) => {
             temporal_value(
                 "datetime",
@@ -1563,47 +1508,19 @@ fn value_output(record: &user_data::DataRecord<'_>) -> ValueOutput {
                 Some(hour),
                 Some(minute),
                 Some(second),
-                raw_hex,
             )
         }
-        Some(DataType::ManufacturerSpecific(data)) => ValueOutput {
+        Some(DataType::ManufacturerSpecific(_)) => ValueOutput {
             kind: "manufacturer_specific".to_string(),
-            display: hex_string(data),
-            decimal: None,
-            significand: None,
-            number: None,
-            scale_power10: None,
-            offset_power10: None,
-            precision: None,
-            special: None,
-            components: None,
-            raw_hex,
+            value: None,
         },
         None => ValueOutput {
             kind: "none".to_string(),
-            display: "No data".to_string(),
-            decimal: None,
-            significand: None,
-            number: None,
-            scale_power10: None,
-            offset_power10: None,
-            precision: None,
-            special: None,
-            components: None,
-            raw_hex,
+            value: None,
         },
         Some(_) => ValueOutput {
             kind: "unknown".to_string(),
-            display: "Unsupported value type".to_string(),
-            decimal: None,
-            significand: None,
-            number: None,
-            scale_power10: None,
-            offset_power10: None,
-            precision: None,
-            special: None,
-            components: None,
-            raw_hex,
+            value: None,
         },
     }
 }
@@ -1617,7 +1534,6 @@ fn temporal_value(
     hour: Option<&SingleEveryOrInvalid<u8>>,
     minute: Option<&SingleEveryOrInvalid<u8>>,
     second: Option<&SingleEveryOrInvalid<u8>>,
-    raw_hex: String,
 ) -> ValueOutput {
     let mut components = serde_json::Map::new();
     if kind != "time" {
@@ -1635,49 +1551,26 @@ fn temporal_value(
         components.insert("second".to_string(), component_json(value));
     }
 
-    let iso = temporal_iso(day, month, year, hour, minute, second, kind);
-    let display = iso.clone().unwrap_or_else(|| {
-        components
-            .iter()
-            .map(|(name, value)| format!("{name}={}", value["value_or_state"]))
-            .collect::<Vec<_>>()
-            .join(", ")
-    });
-    if let Some(iso) = &iso {
-        components.insert("iso".to_string(), serde_json::Value::String(iso.clone()));
-    }
+    let value = temporal_iso(day, month, year, hour, minute, second, kind)
+        .map(serde_json::Value::String)
+        .unwrap_or_else(|| serde_json::Value::Object(components));
     ValueOutput {
         kind: kind.to_string(),
-        display,
-        decimal: None,
-        significand: None,
-        number: None,
-        scale_power10: None,
-        offset_power10: None,
-        precision: None,
-        special: None,
-        components: Some(serde_json::Value::Object(components)),
-        raw_hex,
+        value: Some(value),
     }
 }
 
 fn component_json<T>(component: &SingleEveryOrInvalid<T>) -> serde_json::Value
 where
-    T: Serialize + fmt::Display,
+    T: Serialize,
 {
     match component {
-        SingleEveryOrInvalid::Single(value) => serde_json::json!({
-            "state": "single",
-            "value": value,
-            "value_or_state": value.to_string(),
-        }),
-        SingleEveryOrInvalid::Every() => {
-            serde_json::json!({"state": "every", "value_or_state": "every"})
+        SingleEveryOrInvalid::Single(value) => {
+            serde_json::to_value(value).unwrap_or(serde_json::Value::Null)
         }
-        SingleEveryOrInvalid::Invalid() => {
-            serde_json::json!({"state": "invalid", "value_or_state": "invalid"})
-        }
-        _ => serde_json::json!({"state": "unknown", "value_or_state": "unknown"}),
+        SingleEveryOrInvalid::Every() => serde_json::Value::String("every".to_string()),
+        SingleEveryOrInvalid::Invalid() => serde_json::Value::String("invalid".to_string()),
+        _ => serde_json::Value::String("unknown".to_string()),
     }
 }
 
@@ -1959,6 +1852,9 @@ fn compare_abs(left: &str, right: &str) -> std::cmp::Ordering {
 
 fn apply_power10(integer: &str, exponent: isize) -> String {
     let (negative, digits) = split_sign(integer);
+    if digits.bytes().all(|digit| digit == b'0') {
+        return "0".to_string();
+    }
     let mut output = if exponent >= 0 {
         let mut value = digits.to_string();
         value.push_str(&"0".repeat(usize::try_from(exponent).unwrap_or(0)));
@@ -2039,15 +1935,10 @@ fn render_csv(decoded: &DecodedOutput) -> Result<String, OutputError> {
         "quantities",
         "value_type",
         "value",
-        "value_decimal",
-        "raw_value",
-        "scale_power10",
-        "offset_power10",
         "unit",
         "data_coding",
         "header_hex",
         "data_hex",
-        "record_hex",
     ];
 
     let mut writer = csv::Writer::from_writer(Vec::new());
@@ -2173,27 +2064,45 @@ fn csv_record_values(record: &RecordOutput) -> Vec<String> {
         record.subunit.to_string(),
         record.quantities.join("|"),
         record.value.kind.clone(),
-        record.value.display.clone(),
-        record.value.decimal.clone().unwrap_or_default(),
-        record.value.raw_hex.clone(),
-        record
-            .value
-            .scale_power10
-            .map(|value| value.to_string())
-            .unwrap_or_default(),
-        record
-            .value
-            .offset_power10
-            .map(|value| value.to_string())
-            .unwrap_or_default(),
+        value_display(record),
         record.unit.clone().unwrap_or_default(),
         record.data_coding.clone(),
         record.header_hex.clone(),
         record.data_hex.clone(),
-        record.record_hex.clone(),
     ]
 }
 
+fn value_display(record: &RecordOutput) -> String {
+    match &record.value.value {
+        Some(serde_json::Value::String(value)) => value.clone(),
+        Some(serde_json::Value::Number(value)) => value.to_string(),
+        Some(serde_json::Value::Object(components)) => components
+            .iter()
+            .map(|(name, value)| {
+                let value = value
+                    .as_str()
+                    .map_or_else(|| value.to_string(), ToString::to_string);
+                format!("{name}={value}")
+            })
+            .collect::<Vec<_>>()
+            .join(", "),
+        Some(value) => value.to_string(),
+        None if record.value.kind == "manufacturer_specific" => record.data_hex.replace(' ', ""),
+        None if record.value.kind == "none" => "No data".to_string(),
+        None if record.value.kind == "unknown" => "Unsupported value type".to_string(),
+        None => String::new(),
+    }
+}
+
+fn record_hex(record: &RecordOutput) -> String {
+    match (record.header_hex.is_empty(), record.data_hex.is_empty()) {
+        (false, false) => format!("{} {}", record.header_hex, record.data_hex),
+        (false, true) => record.header_hex.clone(),
+        (true, false) => record.data_hex.clone(),
+        (true, true) => String::new(),
+    }
+}
+
 fn render_table(decoded: &DecodedOutput, width: usize) -> Result<String, OutputError> {
     if width < MINIMUM_TABLE_WIDTH {
         return Err(OutputError::InvalidOption {
@@ -2285,7 +2194,7 @@ fn render_table(decoded: &DecodedOutput, width: usize) -> Result<String, OutputE
                             record.storage_number, record.tariff, record.subunit
                         ),
                         record.data_coding.clone(),
-                        record.record_hex.clone(),
+                        record_hex(record),
                     ]
                 })
                 .collect::<Vec<_>>();
@@ -2313,7 +2222,7 @@ fn render_table(decoded: &DecodedOutput, width: usize) -> Result<String, OutputE
                             "{}\n{} · raw {}",
                             reading(record),
                             record.data_coding,
-                            record.record_hex
+                            record_hex(record)
                         ),
                         record.function.clone(),
                         format!(
@@ -2343,7 +2252,7 @@ fn render_table(decoded: &DecodedOutput, width: usize) -> Result<String, OutputE
                             ),
                         ),
                         ("Coding".to_string(), record.data_coding.clone()),
-                        ("Raw".to_string(), record.record_hex.clone()),
+                        ("Raw".to_string(), record_hex(record)),
                     ],
                     width,
                 ));
@@ -2378,7 +2287,7 @@ fn reading(record: &RecordOutput) -> String {
         .as_ref()
         .map(|value| format!(" {value}"))
         .unwrap_or_default();
-    format!("{quantity}: {}{unit}", record.value.display)
+    format!("{quantity}: {}{unit}", value_display(record))
 }
 
 fn key_value_box(rows: &[(String, String)], width: usize) -> String {
@@ -2670,13 +2579,6 @@ fn hex_string(data: &[u8]) -> String {
     data.iter().map(|byte| format!("{byte:02X}")).collect()
 }
 
-fn spaced_hex(data: &[u8]) -> String {
-    data.iter()
-        .map(|byte| format!("{byte:02X}"))
-        .collect::<Vec<_>>()
-        .join(" ")
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -2704,7 +2606,7 @@ mod tests {
         let rendered =
             render_hex(WIRED_FRAME, OutputFormat::Json, &RenderOptions::default()).unwrap();
         let value: serde_json::Value = serde_json::from_str(&rendered).unwrap();
-        assert_eq!(value["schema_version"], 2);
+        assert_eq!(value["schema_version"], 3);
         assert_eq!(value["protocol"], "wired");
         assert!(value["records"].is_array());
         assert!(value.get("summary").is_none());
@@ -2752,6 +2654,14 @@ mod tests {
         assert_eq!(records[0].quantities, ["Volume"]);
         assert_eq!(records[0].unit.as_deref(), Some("m3"));
         assert_eq!(records[0].data_coding, "24-bit integer");
+        assert_eq!(
+            records[0]
+                .value
+                .value
+                .as_ref()
+                .and_then(|value| value.as_str()),
+            Some("12.565")
+        );
     }
 
     #[test]
diff --git a/tests/docs_presentation.rs b/tests/docs_presentation.rs
index 34431ba..bb08142 100644
--- a/tests/docs_presentation.rs
+++ b/tests/docs_presentation.rs
@@ -49,6 +49,38 @@ fn docs_line_layout_and_palette_match_the_rust_contract() {
     }
 }
 
+#[test]
+fn docs_hex_view_uses_serialized_annotation_names() {
+    for identifier in [
+        "layer === 'frame'",
+        "layer === 'app_header'",
+        "kind === 'dif'",
+        "kind === 'vife'",
+        "kind === 'plaintext_vif'",
+        "kind === 'data_payload'",
+        "'record_field': 'Data Records'",
+        "seg.layer === 'record_field'",
+    ] {
+        assert!(
+            DOCS_HTML.contains(identifier),
+            "missing annotation identifier {identifier}"
+        );
+    }
+
+    for stale_identifier in [
+        "layer === 'Frame'",
+        "layer === 'AppHeader'",
+        "kind === 'Dif'",
+        "kind === 'DataPayload'",
+        "seg.layer === 'RecordField'",
+    ] {
+        assert!(
+            !DOCS_HTML.contains(stale_identifier),
+            "stale annotation identifier {stale_identifier}"
+        );
+    }
+}
+
 #[test]
 fn checked_in_wasm_stays_within_the_docs_budget() {
     let wasm = Path::new(env!("CARGO_MANIFEST_DIR")).join("docs/m_bus_parser_wasm_pack_bg.wasm");
diff --git a/tests/output_contract.rs b/tests/output_contract.rs
index 3723b1d..86c30ba 100644
--- a/tests/output_contract.rs
+++ b/tests/output_contract.rs
@@ -38,7 +38,7 @@ fn canonical_json_has_a_versioned_stable_root() {
             "missing canonical field {field}"
         );
     }
-    assert_eq!(value["schema_version"], 2);
+    assert_eq!(value["schema_version"], 3);
     assert_eq!(value["protocol"], "wired");
     assert!(!object.contains_key("summary"));
     assert_eq!(
@@ -53,6 +53,34 @@ fn canonical_json_has_a_versioned_stable_root() {
     assert_eq!(value["records"][2]["unit"], "W");
     assert!(value["records"][2]["unit"].is_string());
     assert_eq!(value["records"][3]["unit"], "m3.h-1");
+
+    let first_record = value["records"][0].as_object().unwrap();
+    let first_value = first_record["value"].as_object().unwrap();
+    assert_eq!(first_value["kind"], "decimal");
+    assert_eq!(first_value["value"], "0");
+    assert_eq!(
+        first_value.len(),
+        2,
+        "record values must not repeat derived data"
+    );
+    for duplicate in [
+        "display",
+        "decimal",
+        "significand",
+        "number",
+        "scale_power10",
+        "offset_power10",
+        "precision",
+        "raw_hex",
+    ] {
+        assert!(
+            !first_value.contains_key(duplicate),
+            "duplicate value field {duplicate}"
+        );
+    }
+    assert_eq!(first_record["data_hex"], "00 00 00 00");
+    assert!(!first_record.contains_key("record_hex"));
+    assert_eq!(value["records"][7]["value"]["value"], "0012-01-12");
 }
 
 #[test]
@@ -66,7 +94,7 @@ fn enrichment_is_optional_without_changing_the_schema() {
     )
     .unwrap();
     let value = serde_json::to_value(decoded).unwrap();
-    assert_eq!(value["schema_version"], 2);
+    assert_eq!(value["schema_version"], 3);
     assert!(value.get("enrichment").is_none());
 }
 
@@ -90,6 +118,15 @@ fn formats_and_compatibility_aliases_share_one_parser() {
         "one input frame must produce one CSV data row"
     );
     assert!(csv.lines().next().unwrap().contains("record_0_value"));
+    for duplicate in [
+        "value_decimal",
+        "raw_value",
+        "scale_power10",
+        "offset_power10",
+        "record_hex",
+    ] {
+        assert!(!csv.lines().next().unwrap().contains(duplicate));
+    }
     assert!(csv.contains("Instantaneous value"));
     assert!(csv.contains("Volume flow"));
     assert!(csv.contains("6-digit BCD"));
diff --git a/wasm/Cargo.toml b/wasm/Cargo.toml
index bbd74f2..09bca6a 100644
--- a/wasm/Cargo.toml
+++ b/wasm/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "m-bus-parser-wasm-pack"
-version = "0.4.2"
+version = "0.4.3"
 edition = "2021"
 description = "A wasm-pack to use the library for parsing M-Bus frames"
 license = "MIT"
@@ -22,7 +22,7 @@ decryption = ["m-bus-parser/decryption"]
 
 [dependencies]
 wasm-bindgen = "0.2.84"
-m-bus-parser = { path = "..", version = "0.4.2", features = ["std", "serde"] }
+m-bus-parser = { path = "..", version = "0.4.3", features = ["std", "serde"] }
 js-sys = "0.3"
 serde = { version = "1.0" }
 serde_json = "1.0"
diff --git a/wasm/tests/web.rs b/wasm/tests/web.rs
index a85dbf6..51a613e 100644
--- a/wasm/tests/web.rs
+++ b/wasm/tests/web.rs
@@ -34,7 +34,7 @@ fn decode_returns_a_native_versioned_object() {
         Reflect::get(&decoded, &JsValue::from_str("schema_version"))
             .unwrap()
             .as_f64(),
-        Some(2.0)
+        Some(3.0)
     );
     assert_eq!(
         Reflect::get(&decoded, &JsValue::from_str("protocol"))