@private.me/xbind 3.0.1 → 3.0.2

package/dist-standalone/serialization.js

@@ -1 +1,1031 @@
-import{ok,err}from"./_deps/shared/index.js";class JSONSerializer{format="json";contentType="application/json";serialize(e,t){try{const r=t?.pretty?JSON.stringify(e,null,2):JSON.stringify(e);return ok((new TextEncoder).encode(r))}catch(e){return err({code:"SERIALIZATION_FAILED",reason:e instanceof Error?e.message:String(e),format:"json"})}}deserialize(e){try{const t=(new TextDecoder).decode(e);return ok(JSON.parse(t))}catch(e){return err({code:"DESERIALIZATION_FAILED",reason:e instanceof Error?e.message:String(e)})}}detect(e){if(0===e.length)return!1;const t=e[0];if(void 0===t)return!1;if(123===t||91===t||34===t)return!0;if(32===t||9===t||10===t||13===t)for(let t=1;t<Math.min(e.length,10);t++){const r=e[t];if(void 0===r)return!1;if(123===r||91===r||34===r)return!0;if(32!==r&&9!==r&&10!==r&&13!==r)return!1}return!1}}class MessagePackSerializer{format="msgpack";contentType="application/msgpack";serialize(e,t){try{return ok(this.encode(e))}catch(e){return err({code:"SERIALIZATION_FAILED",reason:e instanceof Error?e.message:String(e),format:"msgpack"})}}deserialize(e){try{return ok(this.decode(e))}catch(e){return err({code:"DESERIALIZATION_FAILED",reason:e instanceof Error?e.message:String(e)})}}detect(e){if(0===e.length)return!1;const t=e[0];if(void 0===t)return!1;if(t>=224&&t<=255&&e.length<2)return!1;try{const t={offset:0};return this.decodeValue(e,t),!0}catch{return!1}}encode(e){const t=[];this.encodeValue(e,t);const r=t.reduce((e,t)=>e+t.length,0),n=new Uint8Array(r);let s=0;for(const e of t)n.set(e,s),s+=e.length;return n}encodeValue(e,t){if(null==e)t.push(new Uint8Array([192]));else if("boolean"==typeof e)t.push(new Uint8Array([e?195:194]));else if("number"==typeof e)this.encodeNumber(e,t);else if("string"==typeof e)this.encodeString(e,t);else if(e instanceof Uint8Array)this.encodeBinary(e,t);else if(Array.isArray(e))this.encodeArray(e,t);else{if("object"!=typeof e)throw new Error("Unsupported type: "+typeof e);this.encodeObject(e,t)}}encodeNumber(e,t){if(Number.isInteger(e))if(e>=0&&e<=127)t.push(new Uint8Array([e]));else if(e>=-32&&e<0)t.push(new Uint8Array([224|31&e]));else if(e>=0&&e<=255)t.push(new Uint8Array([204,e]));else if(e>=0&&e<=65535)t.push(new Uint8Array([205,e>>8,255&e]));else if(e>=0&&e<=4294967295){const r=new Uint8Array(5);r[0]=206,new DataView(r.buffer).setUint32(1,e,!1),t.push(r)}else{const r=new Uint8Array(9);r[0]=203,new DataView(r.buffer).setFloat64(1,e,!1),t.push(r)}else{const r=new Uint8Array(9);r[0]=203,new DataView(r.buffer).setFloat64(1,e,!1),t.push(r)}}encodeString(e,t){const r=(new TextEncoder).encode(e),n=r.length;if(n<=31)t.push(new Uint8Array([160|n]));else if(n<=255)t.push(new Uint8Array([217,n]));else if(n<=65535)t.push(new Uint8Array([218,n>>8,255&n]));else{const e=new Uint8Array(5);e[0]=219,new DataView(e.buffer).setUint32(1,n,!1),t.push(e)}t.push(r)}encodeBinary(e,t){const r=e.length;if(r<=255)t.push(new Uint8Array([196,r]));else if(r<=65535)t.push(new Uint8Array([197,r>>8,255&r]));else{const e=new Uint8Array(5);e[0]=198,new DataView(e.buffer).setUint32(1,r,!1),t.push(e)}t.push(e)}encodeArray(e,t){const r=e.length;if(r<=15)t.push(new Uint8Array([144|r]));else if(r<=65535)t.push(new Uint8Array([220,r>>8,255&r]));else{const e=new Uint8Array(5);e[0]=221,new DataView(e.buffer).setUint32(1,r,!1),t.push(e)}for(const r of e)this.encodeValue(r,t)}encodeObject(e,t){const r=Object.keys(e),n=r.length;if(n<=15)t.push(new Uint8Array([128|n]));else if(n<=65535)t.push(new Uint8Array([222,n>>8,255&n]));else{const e=new Uint8Array(5);e[0]=223,new DataView(e.buffer).setUint32(1,n,!1),t.push(e)}for(const n of r)this.encodeValue(n,t),this.encodeValue(e[n],t)}decode(e){return this.decodeValue(e,{offset:0})}decodeValue(e,t){if(t.offset>=e.length)throw new Error("Unexpected end of data");const r=e[t.offset++];if(void 0===r)throw new Error("Unexpected end of data");if(r<=127)return r;if(r>=128&&r<=143){const n=15&r;return this.decodeMap(e,t,n)}if(r>=144&&r<=159){const n=15&r;return this.decodeArray(e,t,n)}if(r>=160&&r<=191){const n=31&r;return this.decodeString(e,t,n)}if(r>=224)return(31&r)-32;switch(r){case 192:return null;case 194:return!1;case 195:return!0;case 196:{const r=e[t.offset++];if(void 0===r)throw new Error("Unexpected end of data");return this.decodeBinary(e,t,r)}case 197:return this.decodeBinary(e,t,this.readUint16(e,t));case 198:return this.decodeBinary(e,t,this.readUint32(e,t));case 202:return this.readFloat32(e,t);case 203:return this.readFloat64(e,t);case 204:{const r=e[t.offset++];if(void 0===r)throw new Error("Unexpected end of data");return r}case 205:return this.readUint16(e,t);case 206:return this.readUint32(e,t);case 208:return this.readInt8(e,t);case 209:return this.readInt16(e,t);case 210:return this.readInt32(e,t);case 217:{const r=e[t.offset++];if(void 0===r)throw new Error("Unexpected end of data");return this.decodeString(e,t,r)}case 218:return this.decodeString(e,t,this.readUint16(e,t));case 219:return this.decodeString(e,t,this.readUint32(e,t));case 220:return this.decodeArray(e,t,this.readUint16(e,t));case 221:return this.decodeArray(e,t,this.readUint32(e,t));case 222:return this.decodeMap(e,t,this.readUint16(e,t));case 223:return this.decodeMap(e,t,this.readUint32(e,t));default:throw new Error(`Unknown MessagePack type: 0x${r.toString(16)}`)}}decodeString(e,t,r){const n=e.slice(t.offset,t.offset+r);return t.offset+=r,(new TextDecoder).decode(n)}decodeBinary(e,t,r){const n=e.slice(t.offset,t.offset+r);return t.offset+=r,n}decodeArray(e,t,r){const n=[];for(let s=0;s<r;s++)n.push(this.decodeValue(e,t));return n}decodeMap(e,t,r){const n={};for(let s=0;s<r;s++){const r=this.decodeValue(e,t),s=this.decodeValue(e,t);n[String(r)]=s}return n}readUint16(e,t){const r=new DataView(e.buffer,e.byteOffset).getUint16(t.offset,!1);return t.offset+=2,r}readUint32(e,t){const r=new DataView(e.buffer,e.byteOffset).getUint32(t.offset,!1);return t.offset+=4,r}readInt8(e,t){if(t.offset>=e.length)throw new Error("Unexpected end of data");const r=new DataView(e.buffer,e.byteOffset).getInt8(t.offset);return t.offset+=1,r}readInt16(e,t){const r=new DataView(e.buffer,e.byteOffset).getInt16(t.offset,!1);return t.offset+=2,r}readInt32(e,t){const r=new DataView(e.buffer,e.byteOffset).getInt32(t.offset,!1);return t.offset+=4,r}readFloat32(e,t){const r=new DataView(e.buffer,e.byteOffset).getFloat32(t.offset,!1);return t.offset+=4,r}readFloat64(e,t){const r=new DataView(e.buffer,e.byteOffset).getFloat64(t.offset,!1);return t.offset+=8,r}}class CBORSerializer{format="cbor";contentType="application/cbor";serialize(e,t){try{return ok(this.encode(e))}catch(e){return err({code:"SERIALIZATION_FAILED",reason:e instanceof Error?e.message:String(e),format:"cbor"})}}deserialize(e){try{return ok(this.decode(e))}catch(e){return err({code:"DESERIALIZATION_FAILED",reason:e instanceof Error?e.message:String(e)})}}detect(e){if(0===e.length)return!1;e[0];try{const t={offset:0};return this.decodeValue(e,t),!0}catch{return!1}}encode(e){const t=[];this.encodeValue(e,t);const r=t.reduce((e,t)=>e+t.length,0),n=new Uint8Array(r);let s=0;for(const e of t)n.set(e,s),s+=e.length;return n}encodeValue(e,t){if(null==e)t.push(new Uint8Array([246]));else if("boolean"==typeof e)t.push(new Uint8Array([e?245:244]));else if("number"==typeof e)this.encodeNumber(e,t);else if("string"==typeof e)this.encodeString(e,t);else if(e instanceof Uint8Array)this.encodeBinary(e,t);else if(Array.isArray(e))this.encodeArray(e,t);else{if("object"!=typeof e)throw new Error("Unsupported type: "+typeof e);this.encodeObject(e,t)}}encodeNumber(e,t){if(Number.isInteger(e))if(e>=0)if(e<=23)t.push(new Uint8Array([e]));else if(e<=255)t.push(new Uint8Array([24,e]));else if(e<=65535)t.push(new Uint8Array([25,e>>8,255&e]));else if(e<=4294967295){const r=new Uint8Array(5);r[0]=26,new DataView(r.buffer).setUint32(1,e,!1),t.push(r)}else{const r=new Uint8Array(9);r[0]=251,new DataView(r.buffer).setFloat64(1,e,!1),t.push(r)}else{const r=-1-e;if(r<=23)t.push(new Uint8Array([32|r]));else if(r<=255)t.push(new Uint8Array([56,r]));else if(r<=65535)t.push(new Uint8Array([57,r>>8,255&r]));else{const e=new Uint8Array(5);e[0]=58,new DataView(e.buffer).setUint32(1,r,!1),t.push(e)}}else{const r=new Uint8Array(9);r[0]=251,new DataView(r.buffer).setFloat64(1,e,!1),t.push(r)}}encodeString(e,t){const r=(new TextEncoder).encode(e),n=r.length;if(n<=23)t.push(new Uint8Array([96|n]));else if(n<=255)t.push(new Uint8Array([120,n]));else if(n<=65535)t.push(new Uint8Array([121,n>>8,255&n]));else{const e=new Uint8Array(5);e[0]=122,new DataView(e.buffer).setUint32(1,n,!1),t.push(e)}t.push(r)}encodeBinary(e,t){const r=e.length;if(r<=23)t.push(new Uint8Array([64|r]));else if(r<=255)t.push(new Uint8Array([88,r]));else if(r<=65535)t.push(new Uint8Array([89,r>>8,255&r]));else{const e=new Uint8Array(5);e[0]=90,new DataView(e.buffer).setUint32(1,r,!1),t.push(e)}t.push(e)}encodeArray(e,t){const r=e.length;if(r<=23)t.push(new Uint8Array([128|r]));else if(r<=255)t.push(new Uint8Array([152,r]));else if(r<=65535)t.push(new Uint8Array([153,r>>8,255&r]));else{const e=new Uint8Array(5);e[0]=154,new DataView(e.buffer).setUint32(1,r,!1),t.push(e)}for(const r of e)this.encodeValue(r,t)}encodeObject(e,t){const r=Object.keys(e),n=r.length;if(n<=23)t.push(new Uint8Array([160|n]));else if(n<=255)t.push(new Uint8Array([184,n]));else if(n<=65535)t.push(new Uint8Array([185,n>>8,255&n]));else{const e=new Uint8Array(5);e[0]=186,new DataView(e.buffer).setUint32(1,n,!1),t.push(e)}for(const n of r)this.encodeValue(n,t),this.encodeValue(e[n],t)}decode(e){return this.decodeValue(e,{offset:0})}decodeValue(e,t){if(t.offset>=e.length)throw new Error("Unexpected end of data");const r=e[t.offset++];if(void 0===r)throw new Error("Unexpected end of data");const n=r>>5&7,s=31&r;switch(n){case 0:return this.decodeInteger(e,t,s);case 1:return-1-this.decodeInteger(e,t,s);case 2:return this.decodeBinary(e,t,s);case 3:return this.decodeString(e,t,s);case 4:return this.decodeArray(e,t,s);case 5:return this.decodeMap(e,t,s);case 7:return this.decodeSpecial(e,t,s);default:throw new Error(`Unsupported CBOR major type: ${n}`)}}decodeInteger(e,t,r){if(r<=23)return r;if(24===r){const r=e[t.offset++];if(void 0===r)throw new Error("Unexpected end of data");return r}if(25===r)return this.readUint16(e,t);if(26===r)return this.readUint32(e,t);throw new Error("Unsupported integer size")}decodeString(e,t,r){let n;n=r<=23?r:this.decodeInteger(e,t,r);const s=e.slice(t.offset,t.offset+n);return t.offset+=n,(new TextDecoder).decode(s)}decodeBinary(e,t,r){let n;n=r<=23?r:this.decodeInteger(e,t,r);const s=e.slice(t.offset,t.offset+n);return t.offset+=n,s}decodeArray(e,t,r){let n;n=r<=23?r:this.decodeInteger(e,t,r);const s=[];for(let r=0;r<n;r++)s.push(this.decodeValue(e,t));return s}decodeMap(e,t,r){let n;n=r<=23?r:this.decodeInteger(e,t,r);const s={};for(let r=0;r<n;r++){const r=this.decodeValue(e,t),n=this.decodeValue(e,t);s[String(r)]=n}return s}decodeSpecial(e,t,r){switch(r){case 20:return!1;case 21:return!0;case 22:return null;case 23:return;case 27:return this.readFloat64(e,t);default:throw new Error(`Unsupported CBOR special: ${r}`)}}readUint16(e,t){const r=new DataView(e.buffer,e.byteOffset).getUint16(t.offset,!1);return t.offset+=2,r}readUint32(e,t){const r=new DataView(e.buffer,e.byteOffset).getUint32(t.offset,!1);return t.offset+=4,r}readFloat64(e,t){const r=new DataView(e.buffer,e.byteOffset).getFloat64(t.offset,!1);return t.offset+=8,r}}const serializers=new Map([["json",new JSONSerializer],["cbor",new CBORSerializer],["msgpack",new MessagePackSerializer]]);export function serialize(e,t={}){const r=t.format??"json",n=serializers.get(r);if(!n)return err({code:"UNSUPPORTED_FORMAT",format:r});const s=t.collectMetrics?performance.now():0,o=n.serialize(e,t);if(!o.ok)return o;const i=t.collectMetrics?{serializeDuration:performance.now()-s,size:o.value.length,format:r,timestamp:Date.now()}:void 0;return ok({data:o.value,format:r,size:o.value.length,contentType:n.contentType,metrics:i})}export function deserialize(e,t={}){const r=t.collectMetrics?performance.now():0;let n,s;if(t.format){if(n=t.format,s=serializers.get(n),!s)return err({code:"UNSUPPORTED_FORMAT",format:n})}else{const t=detectFormat(e);if(!t.ok)return t;if(n=t.value,s=serializers.get(n),!s)return err({code:"UNSUPPORTED_FORMAT",format:n})}const o=s.deserialize(e);if(!o.ok)return o;const i=t.collectMetrics?{serializeDuration:performance.now()-r,size:e.length,format:n,timestamp:Date.now()}:void 0;return ok({value:o.value,format:n,metrics:i})}export function detectFormat(e){const t=serializers.get("json");if(t?.detect(e))return ok("json");if(0===e.length)return err({code:"FORMAT_DETECTION_FAILED",reason:"Empty data"});const r=serializers.get("cbor");if(r?.detect(e))return ok("cbor");const n=serializers.get("msgpack");return n?.detect(e)?ok("msgpack"):err({code:"FORMAT_DETECTION_FAILED",reason:"No serializer recognized the data format"})}export function negotiateFormat(e,t){for(const r of e)if(t.includes(r))return ok(r);return err({code:"UNSUPPORTED_FORMAT",format:`No common format (client: ${e.join(",")}, server: ${t.join(",")})`})}export function compareFormats(e,t=["json","msgpack","cbor"]){const r=[];for(const n of t){const t=serialize(e,{format:n,collectMetrics:!0});if(!t.ok)return t;r.push({format:n,size:t.value.size,duration:t.value.metrics?.serializeDuration??0})}return ok(r)}export function getContentType(e){const t=serializers.get(e);return t?.contentType??"application/octet-stream"}export function parseContentType(e){const t=e.toLowerCase().split(";")[0]?.trim()??"";for(const e of serializers.values())if(e.contentType===t)return e.format}
+/**
+ * Alternative Serialization Formats (API-14)
+ *
+ * Pluggable serialization system supporting JSON, MessagePack, and CBOR.
+ * Provides format negotiation, backward compatibility, and performance benchmarks.
+ *
+ * @module serialization
+ */
+import { ok, err } from"./_deps/shared/index.js";
+/* ── JSON Serializer ── */
+class JSONSerializer {
+    format = 'json';
+    contentType = 'application/json';
+    serialize(value, options) {
+        try {
+            const json = options?.pretty
+                ? JSON.stringify(value, null, 2)
+                : JSON.stringify(value);
+            return ok(new TextEncoder().encode(json));
+        }
+        catch (error) {
+            return err({
+                code: 'SERIALIZATION_FAILED',
+                reason: error instanceof Error ? error.message : String(error),
+                format: 'json',
+            });
+        }
+    }
+    deserialize(data) {
+        try {
+            const text = new TextDecoder().decode(data);
+            return ok(JSON.parse(text));
+        }
+        catch (error) {
+            return err({
+                code: 'DESERIALIZATION_FAILED',
+                reason: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    detect(data) {
+        if (data.length === 0)
+            return false;
+        // JSON starts with { [ " or whitespace + one of those
+        const first = data[0];
+        if (first === undefined)
+            return false;
+        if (first === 0x7B || first === 0x5B || first === 0x22)
+            return true; // { [ "
+        if (first === 0x20 || first === 0x09 || first === 0x0A || first === 0x0D) {
+            // Whitespace - scan for first non-whitespace
+            for (let i = 1; i < Math.min(data.length, 10); i++) {
+                const byte = data[i];
+                if (byte === undefined)
+                    return false;
+                if (byte === 0x7B || byte === 0x5B || byte === 0x22)
+                    return true;
+                if (byte !== 0x20 && byte !== 0x09 && byte !== 0x0A && byte !== 0x0D)
+                    return false;
+            }
+        }
+        return false;
+    }
+}
+/* ── MessagePack Serializer ── */
+class MessagePackSerializer {
+    format = 'msgpack';
+    contentType = 'application/msgpack';
+    serialize(value, _options) {
+        try {
+            return ok(this.encode(value));
+        }
+        catch (error) {
+            return err({
+                code: 'SERIALIZATION_FAILED',
+                reason: error instanceof Error ? error.message : String(error),
+                format: 'msgpack',
+            });
+        }
+    }
+    deserialize(data) {
+        try {
+            return ok(this.decode(data));
+        }
+        catch (error) {
+            return err({
+                code: 'DESERIALIZATION_FAILED',
+                reason: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    detect(data) {
+        if (data.length === 0)
+            return false;
+        const first = data[0];
+        if (first === undefined)
+            return false;
+        // MessagePack format markers
+        // fixmap: 0x80-0x8F, fixarray: 0x90-0x9F, fixstr: 0xA0-0xBF
+        // nil: 0xC0, false: 0xC2, true: 0xC3
+        // bin8/16/32: 0xC4-0xC6, ext8/16/32: 0xC7-0xC9
+        // float32/64: 0xCA-0xCB, uint8/16/32/64: 0xCC-0xCF
+        // int8/16/32/64: 0xD0-0xD3, fixext1/2/4/8/16: 0xD4-0xD8
+        // str8/16/32: 0xD9-0xDB, array16/32: 0xDC-0xDD, map16/32: 0xDE-0xDF
+        // Reject invalid patterns that would cause decode errors
+        if (first >= 0xE0 && first <= 0xFF) {
+            // Negative fixint: valid only for single-byte integers
+            // But we need more data to validate structure
+            if (data.length < 2)
+                return false;
+        }
+        // Try to validate structure
+        try {
+            const state = { offset: 0 };
+            this.decodeValue(data, state);
+            return true; // Successfully decoded
+        }
+        catch {
+            return false; // Decode failed
+        }
+    }
+    // Minimal MessagePack encoder (subset implementation)
+    encode(value) {
+        const chunks = [];
+        this.encodeValue(value, chunks);
+        // Concatenate chunks
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return result;
+    }
+    encodeValue(value, chunks) {
+        if (value === null || value === undefined) {
+            chunks.push(new Uint8Array([0xC0])); // nil
+        }
+        else if (typeof value === 'boolean') {
+            chunks.push(new Uint8Array([value ? 0xC3 : 0xC2])); // true/false
+        }
+        else if (typeof value === 'number') {
+            this.encodeNumber(value, chunks);
+        }
+        else if (typeof value === 'string') {
+            this.encodeString(value, chunks);
+        }
+        else if (value instanceof Uint8Array) {
+            this.encodeBinary(value, chunks);
+        }
+        else if (Array.isArray(value)) {
+            this.encodeArray(value, chunks);
+        }
+        else if (typeof value === 'object') {
+            this.encodeObject(value, chunks);
+        }
+        else {
+            throw new Error(`Unsupported type: ${typeof value}`);
+        }
+    }
+    encodeNumber(value, chunks) {
+        if (Number.isInteger(value)) {
+            if (value >= 0 && value <= 127) {
+                chunks.push(new Uint8Array([value])); // positive fixint
+            }
+            else if (value >= -32 && value < 0) {
+                chunks.push(new Uint8Array([0xE0 | (value & 0x1F)])); // negative fixint
+            }
+            else if (value >= 0 && value <= 0xFF) {
+                chunks.push(new Uint8Array([0xCC, value])); // uint8
+            }
+            else if (value >= 0 && value <= 0xFFFF) {
+                chunks.push(new Uint8Array([0xCD, value >> 8, value & 0xFF])); // uint16
+            }
+            else if (value >= 0 && value <= 0xFFFFFFFF) {
+                const bytes = new Uint8Array(5);
+                bytes[0] = 0xCE;
+                new DataView(bytes.buffer).setUint32(1, value, false);
+                chunks.push(bytes);
+            }
+            else {
+                // Use float64 for large integers or negative integers
+                const bytes = new Uint8Array(9);
+                bytes[0] = 0xCB;
+                new DataView(bytes.buffer).setFloat64(1, value, false);
+                chunks.push(bytes);
+            }
+        }
+        else {
+            // Float
+            const bytes = new Uint8Array(9);
+            bytes[0] = 0xCB; // float64
+            new DataView(bytes.buffer).setFloat64(1, value, false);
+            chunks.push(bytes);
+        }
+    }
+    encodeString(value, chunks) {
+        const utf8 = new TextEncoder().encode(value);
+        const len = utf8.length;
+        if (len <= 31) {
+            chunks.push(new Uint8Array([0xA0 | len])); // fixstr
+        }
+        else if (len <= 0xFF) {
+            chunks.push(new Uint8Array([0xD9, len])); // str8
+        }
+        else if (len <= 0xFFFF) {
+            chunks.push(new Uint8Array([0xDA, len >> 8, len & 0xFF])); // str16
+        }
+        else {
+            const header = new Uint8Array(5);
+            header[0] = 0xDB;
+            new DataView(header.buffer).setUint32(1, len, false);
+            chunks.push(header);
+        }
+        chunks.push(utf8);
+    }
+    encodeBinary(value, chunks) {
+        const len = value.length;
+        if (len <= 0xFF) {
+            chunks.push(new Uint8Array([0xC4, len])); // bin8
+        }
+        else if (len <= 0xFFFF) {
+            chunks.push(new Uint8Array([0xC5, len >> 8, len & 0xFF])); // bin16
+        }
+        else {
+            const header = new Uint8Array(5);
+            header[0] = 0xC6;
+            new DataView(header.buffer).setUint32(1, len, false);
+            chunks.push(header);
+        }
+        chunks.push(value);
+    }
+    encodeArray(value, chunks) {
+        const len = value.length;
+        if (len <= 15) {
+            chunks.push(new Uint8Array([0x90 | len])); // fixarray
+        }
+        else if (len <= 0xFFFF) {
+            chunks.push(new Uint8Array([0xDC, len >> 8, len & 0xFF])); // array16
+        }
+        else {
+            const header = new Uint8Array(5);
+            header[0] = 0xDD;
+            new DataView(header.buffer).setUint32(1, len, false);
+            chunks.push(header);
+        }
+        for (const item of value) {
+            this.encodeValue(item, chunks);
+        }
+    }
+    encodeObject(value, chunks) {
+        const keys = Object.keys(value);
+        const len = keys.length;
+        if (len <= 15) {
+            chunks.push(new Uint8Array([0x80 | len])); // fixmap
+        }
+        else if (len <= 0xFFFF) {
+            chunks.push(new Uint8Array([0xDE, len >> 8, len & 0xFF])); // map16
+        }
+        else {
+            const header = new Uint8Array(5);
+            header[0] = 0xDF;
+            new DataView(header.buffer).setUint32(1, len, false);
+            chunks.push(header);
+        }
+        for (const key of keys) {
+            this.encodeValue(key, chunks);
+            this.encodeValue(value[key], chunks);
+        }
+    }
+    // Minimal MessagePack decoder (subset implementation)
+    decode(data) {
+        const state = { offset: 0 };
+        return this.decodeValue(data, state);
+    }
+    decodeValue(data, state) {
+        if (state.offset >= data.length) {
+            throw new Error('Unexpected end of data');
+        }
+        const byte = data[state.offset++];
+        if (byte === undefined) {
+            throw new Error('Unexpected end of data');
+        }
+        // Positive fixint (0x00 - 0x7F)
+        if (byte <= 0x7F)
+            return byte;
+        // Fixmap (0x80 - 0x8F)
+        if (byte >= 0x80 && byte <= 0x8F) {
+            const len = byte & 0x0F;
+            return this.decodeMap(data, state, len);
+        }
+        // Fixarray (0x90 - 0x9F)
+        if (byte >= 0x90 && byte <= 0x9F) {
+            const len = byte & 0x0F;
+            return this.decodeArray(data, state, len);
+        }
+        // Fixstr (0xA0 - 0xBF)
+        if (byte >= 0xA0 && byte <= 0xBF) {
+            const len = byte & 0x1F;
+            return this.decodeString(data, state, len);
+        }
+        // Negative fixint (0xE0 - 0xFF)
+        if (byte >= 0xE0)
+            return (byte & 0x1F) - 32;
+        // Other types
+        switch (byte) {
+            case 0xC0: return null; // nil
+            case 0xC2: return false;
+            case 0xC3: return true;
+            case 0xC4: { // bin8
+                const len = data[state.offset++];
+                if (len === undefined)
+                    throw new Error('Unexpected end of data');
+                return this.decodeBinary(data, state, len);
+            }
+            case 0xC5: return this.decodeBinary(data, state, this.readUint16(data, state)); // bin16
+            case 0xC6: return this.decodeBinary(data, state, this.readUint32(data, state)); // bin32
+            case 0xCA: return this.readFloat32(data, state);
+            case 0xCB: return this.readFloat64(data, state);
+            case 0xCC: { // uint8
+                const value = data[state.offset++];
+                if (value === undefined)
+                    throw new Error('Unexpected end of data');
+                return value;
+            }
+            case 0xCD: return this.readUint16(data, state); // uint16
+            case 0xCE: return this.readUint32(data, state); // uint32
+            case 0xD0: return this.readInt8(data, state); // int8
+            case 0xD1: return this.readInt16(data, state); // int16
+            case 0xD2: return this.readInt32(data, state); // int32
+            case 0xD9: { // str8
+                const len = data[state.offset++];
+                if (len === undefined)
+                    throw new Error('Unexpected end of data');
+                return this.decodeString(data, state, len);
+            }
+            case 0xDA: return this.decodeString(data, state, this.readUint16(data, state)); // str16
+            case 0xDB: return this.decodeString(data, state, this.readUint32(data, state)); // str32
+            case 0xDC: return this.decodeArray(data, state, this.readUint16(data, state)); // array16
+            case 0xDD: return this.decodeArray(data, state, this.readUint32(data, state)); // array32
+            case 0xDE: return this.decodeMap(data, state, this.readUint16(data, state)); // map16
+            case 0xDF: return this.decodeMap(data, state, this.readUint32(data, state)); // map32
+            default:
+                throw new Error(`Unknown MessagePack type: 0x${byte.toString(16)}`);
+        }
+    }
+    decodeString(data, state, len) {
+        const bytes = data.slice(state.offset, state.offset + len);
+        state.offset += len;
+        return new TextDecoder().decode(bytes);
+    }
+    decodeBinary(data, state, len) {
+        const bytes = data.slice(state.offset, state.offset + len);
+        state.offset += len;
+        return bytes;
+    }
+    decodeArray(data, state, len) {
+        const result = [];
+        for (let i = 0; i < len; i++) {
+            result.push(this.decodeValue(data, state));
+        }
+        return result;
+    }
+    decodeMap(data, state, len) {
+        const result = {};
+        for (let i = 0; i < len; i++) {
+            const key = this.decodeValue(data, state);
+            const value = this.decodeValue(data, state);
+            result[String(key)] = value;
+        }
+        return result;
+    }
+    readUint16(data, state) {
+        const value = new DataView(data.buffer, data.byteOffset).getUint16(state.offset, false);
+        state.offset += 2;
+        return value;
+    }
+    readUint32(data, state) {
+        const value = new DataView(data.buffer, data.byteOffset).getUint32(state.offset, false);
+        state.offset += 4;
+        return value;
+    }
+    readInt8(data, state) {
+        if (state.offset >= data.length)
+            throw new Error('Unexpected end of data');
+        const value = new DataView(data.buffer, data.byteOffset).getInt8(state.offset);
+        state.offset += 1;
+        return value;
+    }
+    readInt16(data, state) {
+        const value = new DataView(data.buffer, data.byteOffset).getInt16(state.offset, false);
+        state.offset += 2;
+        return value;
+    }
+    readInt32(data, state) {
+        const value = new DataView(data.buffer, data.byteOffset).getInt32(state.offset, false);
+        state.offset += 4;
+        return value;
+    }
+    readFloat32(data, state) {
+        const value = new DataView(data.buffer, data.byteOffset).getFloat32(state.offset, false);
+        state.offset += 4;
+        return value;
+    }
+    readFloat64(data, state) {
+        const value = new DataView(data.buffer, data.byteOffset).getFloat64(state.offset, false);
+        state.offset += 8;
+        return value;
+    }
+}
+/* ── CBOR Serializer ── */
+class CBORSerializer {
+    format = 'cbor';
+    contentType = 'application/cbor';
+    serialize(value, _options) {
+        try {
+            return ok(this.encode(value));
+        }
+        catch (error) {
+            return err({
+                code: 'SERIALIZATION_FAILED',
+                reason: error instanceof Error ? error.message : String(error),
+                format: 'cbor',
+            });
+        }
+    }
+    deserialize(data) {
+        try {
+            return ok(this.decode(data));
+        }
+        catch (error) {
+            return err({
+                code: 'DESERIALIZATION_FAILED',
+                reason: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    detect(data) {
+        if (data.length === 0)
+            return false;
+        const first = data[0];
+        // CBOR major types:
+        // 0: unsigned integer (0x00-0x1B)
+        // 1: negative integer (0x20-0x3B)
+        // 2: byte string (0x40-0x5B)
+        // 3: text string (0x60-0x7B)
+        // 4: array (0x80-0x9B)
+        // 5: map (0xA0-0xBB)
+        // 6: tag (0xC0-0xDB)
+        // 7: float/special (0xE0-0xFB, 0xF4-0xF7 for false/true/null/undefined)
+        // Try to validate structure
+        try {
+            const state = { offset: 0 };
+            this.decodeValue(data, state);
+            return true; // Successfully decoded
+        }
+        catch {
+            return false; // Decode failed
+        }
+    }
+    // Minimal CBOR encoder (subset implementation)
+    encode(value) {
+        const chunks = [];
+        this.encodeValue(value, chunks);
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return result;
+    }
+    encodeValue(value, chunks) {
+        if (value === null || value === undefined) {
+            chunks.push(new Uint8Array([0xF6])); // null
+        }
+        else if (typeof value === 'boolean') {
+            chunks.push(new Uint8Array([value ? 0xF5 : 0xF4])); // true/false
+        }
+        else if (typeof value === 'number') {
+            this.encodeNumber(value, chunks);
+        }
+        else if (typeof value === 'string') {
+            this.encodeString(value, chunks);
+        }
+        else if (value instanceof Uint8Array) {
+            this.encodeBinary(value, chunks);
+        }
+        else if (Array.isArray(value)) {
+            this.encodeArray(value, chunks);
+        }
+        else if (typeof value === 'object') {
+            this.encodeObject(value, chunks);
+        }
+        else {
+            throw new Error(`Unsupported type: ${typeof value}`);
+        }
+    }
+    encodeNumber(value, chunks) {
+        if (Number.isInteger(value)) {
+            if (value >= 0) {
+                if (value <= 23) {
+                    chunks.push(new Uint8Array([value])); // 0-23 direct
+                }
+                else if (value <= 0xFF) {
+                    chunks.push(new Uint8Array([0x18, value])); // uint8
+                }
+                else if (value <= 0xFFFF) {
+                    chunks.push(new Uint8Array([0x19, value >> 8, value & 0xFF])); // uint16
+                }
+                else if (value <= 0xFFFFFFFF) {
+                    const bytes = new Uint8Array(5);
+                    bytes[0] = 0x1A;
+                    new DataView(bytes.buffer).setUint32(1, value, false);
+                    chunks.push(bytes);
+                }
+                else {
+                    // Large integer as float64
+                    const bytes = new Uint8Array(9);
+                    bytes[0] = 0xFB;
+                    new DataView(bytes.buffer).setFloat64(1, value, false);
+                    chunks.push(bytes);
+                }
+            }
+            else {
+                // Negative integer
+                const absMinusOne = -1 - value;
+                if (absMinusOne <= 23) {
+                    chunks.push(new Uint8Array([0x20 | absMinusOne]));
+                }
+                else if (absMinusOne <= 0xFF) {
+                    chunks.push(new Uint8Array([0x38, absMinusOne]));
+                }
+                else if (absMinusOne <= 0xFFFF) {
+                    chunks.push(new Uint8Array([0x39, absMinusOne >> 8, absMinusOne & 0xFF]));
+                }
+                else {
+                    const bytes = new Uint8Array(5);
+                    bytes[0] = 0x3A;
+                    new DataView(bytes.buffer).setUint32(1, absMinusOne, false);
+                    chunks.push(bytes);
+                }
+            }
+        }
+        else {
+            // Float
+            const bytes = new Uint8Array(9);
+            bytes[0] = 0xFB; // float64
+            new DataView(bytes.buffer).setFloat64(1, value, false);
+            chunks.push(bytes);
+        }
+    }
+    encodeString(value, chunks) {
+        const utf8 = new TextEncoder().encode(value);
+        const len = utf8.length;
+        if (len <= 23) {
+            chunks.push(new Uint8Array([0x60 | len])); // text string 0-23
+        }
+        else if (len <= 0xFF) {
+            chunks.push(new Uint8Array([0x78, len])); // text string uint8
+        }
+        else if (len <= 0xFFFF) {
+            chunks.push(new Uint8Array([0x79, len >> 8, len & 0xFF])); // text string uint16
+        }
+        else {
+            const header = new Uint8Array(5);
+            header[0] = 0x7A;
+            new DataView(header.buffer).setUint32(1, len, false);
+            chunks.push(header);
+        }
+        chunks.push(utf8);
+    }
+    encodeBinary(value, chunks) {
+        const len = value.length;
+        if (len <= 23) {
+            chunks.push(new Uint8Array([0x40 | len])); // byte string 0-23
+        }
+        else if (len <= 0xFF) {
+            chunks.push(new Uint8Array([0x58, len])); // byte string uint8
+        }
+        else if (len <= 0xFFFF) {
+            chunks.push(new Uint8Array([0x59, len >> 8, len & 0xFF])); // byte string uint16
+        }
+        else {
+            const header = new Uint8Array(5);
+            header[0] = 0x5A;
+            new DataView(header.buffer).setUint32(1, len, false);
+            chunks.push(header);
+        }
+        chunks.push(value);
+    }
+    encodeArray(value, chunks) {
+        const len = value.length;
+        if (len <= 23) {
+            chunks.push(new Uint8Array([0x80 | len])); // array 0-23
+        }
+        else if (len <= 0xFF) {
+            chunks.push(new Uint8Array([0x98, len])); // array uint8
+        }
+        else if (len <= 0xFFFF) {
+            chunks.push(new Uint8Array([0x99, len >> 8, len & 0xFF])); // array uint16
+        }
+        else {
+            const header = new Uint8Array(5);
+            header[0] = 0x9A;
+            new DataView(header.buffer).setUint32(1, len, false);
+            chunks.push(header);
+        }
+        for (const item of value) {
+            this.encodeValue(item, chunks);
+        }
+    }
+    encodeObject(value, chunks) {
+        const keys = Object.keys(value);
+        const len = keys.length;
+        if (len <= 23) {
+            chunks.push(new Uint8Array([0xA0 | len])); // map 0-23
+        }
+        else if (len <= 0xFF) {
+            chunks.push(new Uint8Array([0xB8, len])); // map uint8
+        }
+        else if (len <= 0xFFFF) {
+            chunks.push(new Uint8Array([0xB9, len >> 8, len & 0xFF])); // map uint16
+        }
+        else {
+            const header = new Uint8Array(5);
+            header[0] = 0xBA;
+            new DataView(header.buffer).setUint32(1, len, false);
+            chunks.push(header);
+        }
+        for (const key of keys) {
+            this.encodeValue(key, chunks);
+            this.encodeValue(value[key], chunks);
+        }
+    }
+    // Minimal CBOR decoder
+    decode(data) {
+        const state = { offset: 0 };
+        return this.decodeValue(data, state);
+    }
+    decodeValue(data, state) {
+        if (state.offset >= data.length) {
+            throw new Error('Unexpected end of data');
+        }
+        const byte = data[state.offset++];
+        if (byte === undefined) {
+            throw new Error('Unexpected end of data');
+        }
+        const majorType = (byte >> 5) & 0x07;
+        const additionalInfo = byte & 0x1F;
+        switch (majorType) {
+            case 0: // unsigned integer
+                return this.decodeInteger(data, state, additionalInfo);
+            case 1: // negative integer
+                return -1 - this.decodeInteger(data, state, additionalInfo);
+            case 2: // byte string
+                return this.decodeBinary(data, state, additionalInfo);
+            case 3: // text string
+                return this.decodeString(data, state, additionalInfo);
+            case 4: // array
+                return this.decodeArray(data, state, additionalInfo);
+            case 5: // map
+                return this.decodeMap(data, state, additionalInfo);
+            case 7: // float/special
+                return this.decodeSpecial(data, state, additionalInfo);
+            default:
+                throw new Error(`Unsupported CBOR major type: ${majorType}`);
+        }
+    }
+    decodeInteger(data, state, additionalInfo) {
+        if (additionalInfo <= 23) {
+            return additionalInfo;
+        }
+        else if (additionalInfo === 24) {
+            const value = data[state.offset++];
+            if (value === undefined)
+                throw new Error('Unexpected end of data');
+            return value;
+        }
+        else if (additionalInfo === 25) {
+            return this.readUint16(data, state);
+        }
+        else if (additionalInfo === 26) {
+            return this.readUint32(data, state);
+        }
+        else {
+            throw new Error('Unsupported integer size');
+        }
+    }
+    decodeString(data, state, additionalInfo) {
+        let len;
+        if (additionalInfo <= 23) {
+            len = additionalInfo;
+        }
+        else {
+            len = this.decodeInteger(data, state, additionalInfo);
+        }
+        const bytes = data.slice(state.offset, state.offset + len);
+        state.offset += len;
+        return new TextDecoder().decode(bytes);
+    }
+    decodeBinary(data, state, additionalInfo) {
+        let len;
+        if (additionalInfo <= 23) {
+            len = additionalInfo;
+        }
+        else {
+            len = this.decodeInteger(data, state, additionalInfo);
+        }
+        const bytes = data.slice(state.offset, state.offset + len);
+        state.offset += len;
+        return bytes;
+    }
+    decodeArray(data, state, additionalInfo) {
+        let len;
+        if (additionalInfo <= 23) {
+            len = additionalInfo;
+        }
+        else {
+            len = this.decodeInteger(data, state, additionalInfo);
+        }
+        const result = [];
+        for (let i = 0; i < len; i++) {
+            result.push(this.decodeValue(data, state));
+        }
+        return result;
+    }
+    decodeMap(data, state, additionalInfo) {
+        let len;
+        if (additionalInfo <= 23) {
+            len = additionalInfo;
+        }
+        else {
+            len = this.decodeInteger(data, state, additionalInfo);
+        }
+        const result = {};
+        for (let i = 0; i < len; i++) {
+            const key = this.decodeValue(data, state);
+            const value = this.decodeValue(data, state);
+            result[String(key)] = value;
+        }
+        return result;
+    }
+    decodeSpecial(data, state, additionalInfo) {
+        switch (additionalInfo) {
+            case 20: return false;
+            case 21: return true;
+            case 22: return null;
+            case 23: return undefined;
+            case 27: { // float64
+                return this.readFloat64(data, state);
+            }
+            default:
+                throw new Error(`Unsupported CBOR special: ${additionalInfo}`);
+        }
+    }
+    readUint16(data, state) {
+        const value = new DataView(data.buffer, data.byteOffset).getUint16(state.offset, false);
+        state.offset += 2;
+        return value;
+    }
+    readUint32(data, state) {
+        const value = new DataView(data.buffer, data.byteOffset).getUint32(state.offset, false);
+        state.offset += 4;
+        return value;
+    }
+    readFloat64(data, state) {
+        const value = new DataView(data.buffer, data.byteOffset).getFloat64(state.offset, false);
+        state.offset += 8;
+        return value;
+    }
+}
+/* ── Serializer Registry ── */
+// Order matters for format detection: JSON (most specific), CBOR, MessagePack
+const serializers = new Map([
+    ['json', new JSONSerializer()],
+    ['cbor', new CBORSerializer()],
+    ['msgpack', new MessagePackSerializer()],
+]);
+/* ── Public API ── */
+/**
+ * Serialize a value using the specified format.
+ *
+ * @param value - Value to serialize
+ * @param options - Serialization options
+ * @returns Serialized data with metadata
+ *
+ * @example
+ * ```typescript
+ * const data = { message: 'Hello', timestamp: Date.now() };
+ *
+ * // JSON (default, human-readable)
+ * const json = serialize(data);
+ *
+ * // MessagePack (compact binary)
+ * const msgpack = serialize(data, { format: 'msgpack' });
+ *
+ * // CBOR (standard binary)
+ * const cbor = serialize(data, { format: 'cbor' });
+ *
+ * console.log('JSON:', json.value.size, 'bytes');
+ * console.log('MessagePack:', msgpack.value.size, 'bytes');
+ * console.log('CBOR:', cbor.value.size, 'bytes');
+ * ```
+ */
+export function serialize(value, options = {}) {
+    const format = options.format ?? 'json';
+    const serializer = serializers.get(format);
+    if (!serializer) {
+        return err({ code: 'UNSUPPORTED_FORMAT', format });
+    }
+    const startTime = options.collectMetrics ? performance.now() : 0;
+    const result = serializer.serialize(value, options);
+    if (!result.ok)
+        return result;
+    const metrics = options.collectMetrics ? {
+        serializeDuration: performance.now() - startTime,
+        size: result.value.length,
+        format,
+        timestamp: Date.now(),
+    } : undefined;
+    return ok({
+        data: result.value,
+        format,
+        size: result.value.length,
+        contentType: serializer.contentType,
+        metrics,
+    });
+}
+/**
+ * Deserialize bytes using format auto-detection or explicit format.
+ *
+ * @param data - Serialized bytes
+ * @param options - Deserialization options
+ * @returns Deserialized value with format metadata
+ *
+ * @example
+ * ```typescript
+ * // Auto-detect format
+ * const result = deserialize(bytes);
+ * if (result.ok) {
+ *   console.log('Format:', result.value.format);
+ *   console.log('Data:', result.value.value);
+ * }
+ *
+ * // Explicit format (faster, skips detection)
+ * const json = deserialize(bytes, { format: 'json' });
+ * ```
+ */
+export function deserialize(data, options = {}) {
+    const startTime = options.collectMetrics ? performance.now() : 0;
+    let format;
+    let serializer;
+    if (options.format) {
+        // Explicit format
+        format = options.format;
+        serializer = serializers.get(format);
+        if (!serializer) {
+            return err({ code: 'UNSUPPORTED_FORMAT', format });
+        }
+    }
+    else {
+        // Auto-detect format
+        const detected = detectFormat(data);
+        if (!detected.ok)
+            return detected;
+        format = detected.value;
+        serializer = serializers.get(format);
+        if (!serializer) {
+            return err({ code: 'UNSUPPORTED_FORMAT', format });
+        }
+    }
+    const result = serializer.deserialize(data);
+    if (!result.ok)
+        return result;
+    const metrics = options.collectMetrics ? {
+        serializeDuration: performance.now() - startTime,
+        size: data.length,
+        format,
+        timestamp: Date.now(),
+    } : undefined;
+    return ok({
+        value: result.value,
+        format,
+        metrics,
+    });
+}
+/**
+ * Detect serialization format from bytes.
+ *
+ * @param data - Serialized bytes
+ * @returns Detected format
+ *
+ * @example
+ * ```typescript
+ * const format = detectFormat(bytes);
+ * if (format.ok) {
+ *   console.log('Detected format:', format.value); // 'json' | 'msgpack' | 'cbor'
+ * }
+ * ```
+ */
+export function detectFormat(data) {
+    // Try JSON first (most specific - must start with { [ " or whitespace + those)
+    const jsonSerializer = serializers.get('json');
+    if (jsonSerializer?.detect(data)) {
+        return ok('json');
+    }
+    if (data.length === 0) {
+        return err({
+            code: 'FORMAT_DETECTION_FAILED',
+            reason: 'Empty data',
+        });
+    }
+    // CBOR and MessagePack have overlapping byte ranges
+    // Both formats can successfully decode data but with different interpretations
+    // Priority: Try CBOR first, then MessagePack
+    // This matches the serializers Map insertion order
+    const cborSerializer = serializers.get('cbor');
+    if (cborSerializer?.detect(data)) {
+        return ok('cbor');
+    }
+    const msgpackSerializer = serializers.get('msgpack');
+    if (msgpackSerializer?.detect(data)) {
+        return ok('msgpack');
+    }
+    return err({
+        code: 'FORMAT_DETECTION_FAILED',
+        reason: 'No serializer recognized the data format',
+    });
+}
+/**
+ * Negotiate format between client and server.
+ *
+ * @param clientFormats - Formats accepted by client (in preference order)
+ * @param serverFormats - Formats supported by server
+ * @returns Best matching format
+ *
+ * @example
+ * ```typescript
+ * const client = ['msgpack', 'cbor', 'json'];
+ * const server = ['json', 'cbor'];
+ * const format = negotiateFormat(client, server);
+ * console.log(format.value); // 'cbor' (first match)
+ * ```
+ */
+export function negotiateFormat(clientFormats, serverFormats) {
+    for (const format of clientFormats) {
+        if (serverFormats.includes(format)) {
+            return ok(format);
+        }
+    }
+    return err({
+        code: 'UNSUPPORTED_FORMAT',
+        format: `No common format (client: ${clientFormats.join(',')}, server: ${serverFormats.join(',')})`,
+    });
+}
+/**
+ * Compare serialization performance across formats.
+ *
+ * @param value - Value to benchmark
+ * @param formats - Formats to compare
+ * @returns Performance comparison
+ *
+ * @example
+ * ```typescript
+ * const data = { message: 'Hello', items: [1, 2, 3, 4, 5] };
+ * const comparison = compareFormats(data);
+ *
+ * if (comparison.ok) {
+ *   for (const result of comparison.value) {
+ *     console.log(`${result.format}: ${result.size} bytes, ${result.duration}ms`);
+ *   }
+ * }
+ * ```
+ */
+export function compareFormats(value, formats = ['json', 'msgpack', 'cbor']) {
+    const results = [];
+    for (const format of formats) {
+        const result = serialize(value, { format, collectMetrics: true });
+        if (!result.ok)
+            return result;
+        results.push({
+            format,
+            size: result.value.size,
+            duration: result.value.metrics?.serializeDuration ?? 0,
+        });
+    }
+    return ok(results);
+}
+/**
+ * Get Content-Type header for a serialization format.
+ *
+ * @param format - Serialization format
+ * @returns Content-Type header value
+ *
+ * @example
+ * ```typescript
+ * const contentType = getContentType('msgpack');
+ * console.log(contentType); // 'application/msgpack'
+ * ```
+ */
+export function getContentType(format) {
+    const serializer = serializers.get(format);
+    return serializer?.contentType ?? 'application/octet-stream';
+}
+/**
+ * Parse Content-Type header to serialization format.
+ *
+ * @param contentType - Content-Type header value
+ * @returns Serialization format or undefined
+ *
+ * @example
+ * ```typescript
+ * const format = parseContentType('application/json');
+ * console.log(format); // 'json'
+ *
+ * const format2 = parseContentType('application/msgpack');
+ * console.log(format2); // 'msgpack'
+ * ```
+ */
+export function parseContentType(contentType) {
+    const normalized = contentType.toLowerCase().split(';')[0]?.trim() ?? '';
+    for (const serializer of serializers.values()) {
+        if (serializer.contentType === normalized) {
+            return serializer.format;
+        }
+    }
+    return undefined;
+}