@leofcoin/binary 1.0.0 → 1.1.0

package/README.md

@@ -2,8 +2,8 @@
 
 `@leofcoin/binary` is a dependency-free shared implementation of unsigned
 base-128 integers and length-prefixed byte frames. Numeric values retain the
-existing wire bytes. No chain field, codec identifier, hash algorithm or supply
-representation changes as part of this migration.
+existing low-level framing bytes. The package also provides versioned typed-value
+encoding for the application protocol described in [the wire specification](../../docs/binary-wire-protocol.md).
 
 It is independent of `@leofcoin/codecs`, which remains the registry of codec
 identifiers. This package does not import or re-export that registry.
@@ -35,14 +35,53 @@ independent copy before resetting/reusing a writer. Writers have fixed capacity;
 the caller supplies the capacity or an existing Uint8Array. There is no hidden
 buffer growth or mutable process-global `.bytes` state.
 
-New reader calls reject padded/non-canonical integers by default. Existing block
-validator framing explicitly uses `canonical: false` to preserve legacy padded
-prefix acceptance. Tightening that consensus rule needs a separate protocol
-decision. Overflow and truncated fields still fail closed. `decodeFrames` accepts
-an optional `maxFrames` policy; network size/membership limits remain the caller's
-responsibility. BigInt support does not automatically migrate existing fields.
+Reader calls reject padded/non-canonical integers by default. The typed-message
+protocol requires canonical validator framing. An explicit `canonical: false`
+option remains available for offline tooling, not as a network fallback.
+Overflow and truncated fields fail closed. `decodeFrames` accepts an optional
+`maxFrames` policy; network size/membership limits remain the caller's responsibility.
 
 Checks: `npm test -w @leofcoin/binary`, `npm test -w @leofcoin/messages`.
 Benchmark: `node test/bench/binary-codec.js`. It compares the actual installed
 legacy framing packages and verifies equal bytes before measuring. Results are
 local CPU timings, not blockchain throughput or transport latency claims.
+
+## Typed-value encoder and framing
+
+`encodeValue` validates and measures a flat per-call plan, then writes directly
+into one exactly sized output byte buffer. Strings use allocation-free UTF-8
+measurement and direct/encodeInto writes; BigInts use exact 49-bit limbs while
+retaining the same unsigned-varint bytes. No scratch buffers or application
+values are cached across calls.
+
+`encodeValueWithPrefix(value, prefix, limits)` includes an existing codec/framing
+header in that same allocation. The prefix is copied; `maxBytes` bounds the
+typed value including its magic/version, separately from caller-provided framing.
+Callers must keep framing bounded and enforce total network message limits.
+
+Message schema compilation lives in `@leofcoin/messages`. Only frozen data-property
+schemas cache field names, kinds and codec prefixes. Mutable caller schemas are
+recompiled; decoded messages and caller-owned payloads are not frozen or cached.
+
+## Reproducible performance comparison
+
+Build first, then snapshot the **pre-change** binary/message outputs once:
+
+```sh
+node scripts/benchmark-wire-codecs.js --snapshot
+```
+
+Keep the returned directory. After rebuilding changed codecs:
+
+```sh
+node --expose-gc scripts/benchmark-wire-codecs.js <snapshot-directory>
+```
+
+Run from the repository root. The read-only benchmark checks identical bytes,
+decoded values and block/transaction hashes before reporting timings. It uses
+seven alternating samples, medians and source fingerprints. Message cases use
+the actual BlockMessage/TransactionMessage classes with representative encoding
+fixtures; they are not valid-consensus-block or end-to-end throughput benchmarks.
+Snapshots are ignored generated artifacts under `node_modules/.cache`; never
+refresh the baseline midway through a comparison. Rebuild dependencies and run
+multi-node verification only after benchmarks, not concurrently with them.

package/exports/framing.d.ts

@@ -0,0 +1,34 @@
+export declare function varUintLength(value: number): number;
+export declare function varBigIntLength(value: bigint): number;
+/** Fixed-capacity writer. finish() is a view; copy it before reusing/resetting the writer. */
+export declare class BinaryWriter {
+    #private;
+    constructor(capacity?: number | Uint8Array);
+    get position(): number;
+    get remaining(): number;
+    writeVarUint(value: number): this;
+    writeVarBigInt(value: bigint): this;
+    writeBytes(value: Uint8Array): this;
+    writeFrame(value: Uint8Array): this;
+    reset(): this;
+    finish(copy?: boolean): Uint8Array;
+}
+/** Reads views of the original buffer. Failed operations leave the cursor unchanged. */
+export declare class BinaryReader {
+    #private;
+    constructor(buffer: Uint8Array);
+    get position(): number;
+    get remaining(): number;
+    readVarUint(canonical?: boolean): number;
+    readVarBigInt(canonical?: boolean): bigint;
+    readBytes(length: number): Uint8Array;
+    readFrame(canonical?: boolean): Uint8Array;
+}
+/** Existing smart-concat bytes, with exactly one output allocation and no prefix arrays. */
+export declare function encodeFrames(frames: readonly Uint8Array[], prefix?: Uint8Array): Uint8Array;
+export interface FrameOptions {
+    canonical?: boolean;
+    maxFrames?: number;
+}
+/** Iterative framing: bounded by the input length, not recursive stack depth. */
+export declare function decodeFrames(buffer: Uint8Array, prefixLength?: number, options?: FrameOptions): Uint8Array[];

package/exports/framing.js

@@ -0,0 +1,221 @@
+/** @leofcoin/binary: dependency-free unsigned framing, with no global byte counters. */
+const MAX_BIGINT = (1n << 256n) - 1n;
+function size(value) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new RangeError('Expected an unsigned safe integer');
+}
+function bytes(value) {
+    if (!(value instanceof Uint8Array))
+        throw new TypeError('Expected Uint8Array');
+}
+export function varUintLength(value) {
+    size(value);
+    let length = 1;
+    while (value >= 128) {
+        value = Math.floor(value / 128);
+        length++;
+    }
+    return length;
+}
+export function varBigIntLength(value) {
+    if (typeof value !== 'bigint')
+        throw new TypeError('Expected BigInt');
+    if (value < 0n || value > MAX_BIGINT)
+        throw new RangeError('Expected an unsigned 256-bit integer');
+    let length = 1;
+    // Count whole eight-byte varint groups before the short tail.
+    while (value >= 0x100000000000000n) {
+        value >>= 56n;
+        length += 8;
+    }
+    while (value >= 128n) {
+        value >>= 7n;
+        length++;
+    }
+    return length;
+}
+/** Fixed-capacity writer. finish() is a view; copy it before reusing/resetting the writer. */
+export class BinaryWriter {
+    #buffer;
+    #position = 0;
+    constructor(capacity = 64) {
+        if (typeof capacity === 'number') {
+            size(capacity);
+            this.#buffer = new Uint8Array(capacity);
+        }
+        else {
+            bytes(capacity);
+            this.#buffer = capacity;
+        }
+    }
+    get position() {
+        return this.#position;
+    }
+    get remaining() {
+        return this.#buffer.length - this.#position;
+    }
+    #require(length) {
+        size(length);
+        if (length > this.remaining)
+            throw new RangeError('Binary output buffer is too small');
+    }
+    writeVarUint(value) {
+        this.#require(varUintLength(value));
+        this.#writeVarUint(value);
+        return this;
+    }
+    #writeVarUint(value) {
+        while (value >= 128) {
+            this.#buffer[this.#position++] = value % 128 | 128;
+            value = Math.floor(value / 128);
+        }
+        this.#buffer[this.#position++] = value;
+    }
+    writeVarBigInt(value) {
+        this.#require(varBigIntLength(value));
+        do {
+            const byte = Number(value & 127n);
+            value >>= 7n;
+            this.#buffer[this.#position++] = byte | (value ? 128 : 0);
+        } while (value);
+        return this;
+    }
+    writeBytes(value) {
+        bytes(value);
+        this.#require(value.length);
+        this.#buffer.set(value, this.#position);
+        this.#position += value.length;
+        return this;
+    }
+    writeFrame(value) {
+        bytes(value);
+        // Check the complete operation before writing its length prefix.
+        const prefixLength = varUintLength(value.length);
+        this.#require(prefixLength + value.length);
+        const prefixStart = this.#buffer.byteOffset + this.#position;
+        if (value.buffer === this.#buffer.buffer &&
+            value.byteOffset < prefixStart + prefixLength &&
+            value.byteOffset + value.length > prefixStart)
+            throw new RangeError('Frame source overlaps its length prefix');
+        this.#writeVarUint(value.length);
+        this.#buffer.set(value, this.#position);
+        this.#position += value.length;
+        return this;
+    }
+    reset() {
+        this.#position = 0;
+        return this;
+    }
+    finish(copy = false) {
+        const result = this.#buffer.subarray(0, this.#position);
+        // Buffer.slice() aliases memory; this constructor copies every Uint8Array subtype.
+        return copy ? new Uint8Array(result) : result;
+    }
+}
+/** Reads views of the original buffer. Failed operations leave the cursor unchanged. */
+export class BinaryReader {
+    #buffer;
+    #position = 0;
+    constructor(buffer) {
+        bytes(buffer);
+        this.#buffer = buffer;
+    }
+    get position() {
+        return this.#position;
+    }
+    get remaining() {
+        return this.#buffer.length - this.#position;
+    }
+    readVarUint(canonical = true) {
+        let result = 0;
+        let multiplier = 1;
+        for (let index = 0; index < 8; index++) {
+            const cursor = this.#position + index;
+            if (cursor >= this.#buffer.length)
+                throw new RangeError('Truncated varint');
+            const byte = this.#buffer[cursor];
+            const payload = byte & 127;
+            if (index === 7 && payload > Math.floor((Number.MAX_SAFE_INTEGER - result) / multiplier))
+                throw new RangeError('Varint exceeds safe integer range');
+            result += payload * multiplier;
+            if (byte < 128) {
+                if (canonical && index > 0 && payload === 0)
+                    throw new RangeError('Non-canonical varint');
+                this.#position = cursor + 1;
+                return result;
+            }
+            multiplier *= 128;
+        }
+        throw new RangeError('Varint exceeds safe integer range');
+    }
+    readVarBigInt(canonical = true) {
+        let result = 0n;
+        for (let index = 0; index < 37; index++) {
+            const cursor = this.#position + index;
+            if (cursor >= this.#buffer.length)
+                throw new RangeError('Truncated varint');
+            const byte = this.#buffer[cursor];
+            result |= BigInt(byte & 127) << BigInt(index * 7);
+            if (result > MAX_BIGINT)
+                throw new RangeError('Varint exceeds 256 bits');
+            if (byte < 128) {
+                if (canonical && index > 0 && byte === 0)
+                    throw new RangeError('Non-canonical varint');
+                this.#position = cursor + 1;
+                return result;
+            }
+        }
+        throw new RangeError('Varint exceeds 256 bits');
+    }
+    readBytes(length) {
+        size(length);
+        if (length > this.remaining)
+            throw new RangeError('Truncated binary field');
+        const start = this.#position;
+        this.#position += length;
+        return this.#buffer.subarray(start, this.#position);
+    }
+    readFrame(canonical = true) {
+        const start = this.#position;
+        try {
+            return this.readBytes(this.readVarUint(canonical));
+        }
+        catch (error) {
+            this.#position = start;
+            throw error;
+        }
+    }
+}
+/** Existing smart-concat bytes, with exactly one output allocation and no prefix arrays. */
+export function encodeFrames(frames, prefix) {
+    if (!Array.isArray(frames))
+        throw new TypeError('Expected an array of byte frames');
+    if (prefix !== undefined)
+        bytes(prefix);
+    let length = prefix?.length ?? 0;
+    for (const frame of frames) {
+        bytes(frame);
+        length += varUintLength(frame.length) + frame.length;
+        size(length);
+    }
+    const writer = new BinaryWriter(length);
+    if (prefix)
+        writer.writeBytes(prefix);
+    for (const frame of frames)
+        writer.writeFrame(frame);
+    return writer.finish();
+}
+/** Iterative framing: bounded by the input length, not recursive stack depth. */
+export function decodeFrames(buffer, prefixLength = 0, options = {}) {
+    const reader = new BinaryReader(buffer);
+    reader.readBytes(prefixLength);
+    const maxFrames = options.maxFrames ?? buffer.length;
+    size(maxFrames);
+    const frames = [];
+    while (reader.remaining) {
+        if (frames.length >= maxFrames)
+            throw new RangeError('Too many binary frames');
+        frames.push(reader.readFrame(options.canonical ?? true));
+    }
+    return frames;
+}

package/exports/index.d.ts

@@ -0,0 +1,2 @@
+export * from './framing.js';
+export * from './value.js';

package/exports/index.js

@@ -0,0 +1,2 @@
+export * from './framing.js';
+export * from './value.js';

package/exports/value.d.ts

@@ -0,0 +1,18 @@
+export interface ValueLimits {
+    maxBytes?: number;
+    maxDepth?: number;
+    maxNodes?: number;
+}
+export declare const BINARY_CONTENT_TYPE = "application/octet-stream";
+/** Versioned canonical typed values. Validation/planning allocates no byte buffers. */
+export declare function encodeValue(value: unknown, options?: ValueLimits): Uint8Array;
+/** Prepend an existing framing/codec header in the same allocation.
+ * maxBytes bounds the typed value (including MAGIC), as with encodeValue.
+ * The caller-owned prefix is separate framing and is copied, never retained.
+ */
+export declare function encodeValueWithPrefix(value: unknown, prefix: Uint8Array, options?: ValueLimits): Uint8Array;
+/** Strict decoder: byte input, version, canonical ordering, bounds and complete consumption. */
+export declare function decodeValue(input: Uint8Array, options?: ValueLimits): any;
+/** Domain separation prevents RPC bytes from being accepted as worker/chat/peer messages. */
+export declare const encodeWire: (channel: string, value: unknown, limits?: ValueLimits) => Uint8Array<ArrayBufferLike>;
+export declare function decodeWire(channel: string, bytes: Uint8Array, limits?: ValueLimits): any;

package/exports/value.js

@@ -0,0 +1,289 @@
+import { BinaryReader, varUintLength, varBigIntLength } from './framing.js';
+export const BINARY_CONTENT_TYPE = 'application/octet-stream';
+const MAGIC = new Uint8Array([0x4c, 0x46, 0x43, 1]);
+const utf8 = new TextEncoder();
+const text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+const defaults = { maxBytes: 16 * 1024 * 1024, maxDepth: 64, maxNodes: 200000 };
+const BIGINT_LIMB = 1n << 49n;
+const BIGINT_MASK = BIGINT_LIMB - 1n;
+const limitsFor = (options) => {
+    const limits = { ...defaults, ...options };
+    for (const value of Object.values(limits))
+        if (!Number.isSafeInteger(value) || value < 1)
+            throw new RangeError('Invalid binary limits');
+    return limits;
+};
+/** Canonical UTF-8 length without allocating a temporary encoded string. */
+function stringLength(value, maximum) {
+    if (value.length > maximum)
+        throw new RangeError('Invalid binary string');
+    let length = value.length;
+    for (let index = 0; index < value.length; index++) {
+        const code = value.charCodeAt(index);
+        if (code < 0x80)
+            continue;
+        if (code < 0x800) {
+            length++;
+            continue;
+        }
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const low = value.charCodeAt(++index);
+            if (!(low >= 0xdc00 && low <= 0xdfff))
+                throw new RangeError('Invalid binary string');
+            length += 2;
+        }
+        else {
+            if (code >= 0xdc00 && code <= 0xdfff)
+                throw new RangeError('Invalid binary string');
+            length += 2;
+        }
+    }
+    return length;
+}
+/** Versioned canonical typed values. Validation/planning allocates no byte buffers. */
+export function encodeValue(value, options = {}) {
+    return encodeValueWithPrefix(value, EMPTY, options);
+}
+const EMPTY = new Uint8Array();
+/** Prepend an existing framing/codec header in the same allocation.
+ * maxBytes bounds the typed value (including MAGIC), as with encodeValue.
+ * The caller-owned prefix is separate framing and is copied, never retained.
+ */
+export function encodeValueWithPrefix(value, prefix, options = {}) {
+    if (!(prefix instanceof Uint8Array))
+        throw new TypeError('Expected Uint8Array prefix');
+    const limits = limitsFor(options);
+    // Flat plan retains validated data-property values; writing never reads user properties again.
+    // Internal tag 11 is an untagged map key and is never emitted on the wire.
+    const plan = [];
+    const ancestors = new Set();
+    let size = MAGIC.length;
+    let nodes = 0;
+    const reserve = (length) => {
+        size += length;
+        if (size > limits.maxBytes)
+            throw new RangeError('Binary value exceeds byte limit');
+    };
+    const string = (value, tag) => {
+        const length = stringLength(value, limits.maxBytes);
+        reserve((tag === 7 ? 1 : 0) + varUintLength(length) + length);
+        plan.push(tag, value, length);
+    };
+    const visit = (value, depth) => {
+        if (++nodes > limits.maxNodes || depth > limits.maxDepth)
+            throw new RangeError('Binary value exceeds complexity limit');
+        if (value === undefined || value === null || typeof value === 'boolean') {
+            reserve(1);
+            plan.push(value === undefined ? 0 : value === null ? 1 : value === false ? 2 : 3);
+            return;
+        }
+        if (typeof value === 'number') {
+            if (!Number.isFinite(value))
+                throw new TypeError('Binary numbers must be finite');
+            reserve(9);
+            plan.push(4, value);
+            return;
+        }
+        if (typeof value === 'bigint') {
+            const magnitude = value < 0n ? -value : value;
+            reserve(1 + varBigIntLength(magnitude));
+            plan.push(value < 0n ? 6 : 5, magnitude);
+            return;
+        }
+        if (typeof value === 'string')
+            return string(value, 7);
+        if (value instanceof Uint8Array) {
+            reserve(1 + varUintLength(value.length) + value.length);
+            plan.push(8, value, value.length);
+            return;
+        }
+        if (typeof value !== 'object')
+            throw new TypeError('Unsupported binary value');
+        if (ancestors.has(value))
+            throw new TypeError('Cyclic binary value');
+        ancestors.add(value);
+        try {
+            if (Array.isArray(value)) {
+                if (value.length > limits.maxNodes - nodes)
+                    throw new RangeError('Binary array exceeds node limit');
+                if (Object.keys(value).length !== value.length || Object.getOwnPropertySymbols(value).length)
+                    throw new TypeError('Binary arrays cannot have extra properties or holes');
+                reserve(1 + varUintLength(value.length));
+                plan.push(9, value.length);
+                for (let index = 0; index < value.length; index++) {
+                    const entry = Object.getOwnPropertyDescriptor(value, String(index));
+                    if (!entry || !('value' in entry))
+                        throw new TypeError('Sparse arrays and accessors are not binary values');
+                    visit(entry.value, depth + 1);
+                }
+            }
+            else {
+                const prototype = Object.getPrototypeOf(value);
+                if (prototype !== Object.prototype && prototype !== null)
+                    throw new TypeError('Binary maps must be plain objects');
+                const keys = Object.keys(value).sort();
+                if (Object.getOwnPropertySymbols(value).length)
+                    throw new TypeError('Symbol keys are not binary values');
+                if (keys.length > limits.maxNodes - nodes)
+                    throw new RangeError('Binary map exceeds node limit');
+                reserve(1 + varUintLength(keys.length));
+                plan.push(10, keys.length);
+                for (const key of keys) {
+                    const entry = Object.getOwnPropertyDescriptor(value, key);
+                    if (!('value' in entry))
+                        throw new TypeError('Accessors are not binary values');
+                    string(key, 11);
+                    visit(entry.value, depth + 1);
+                }
+            }
+        }
+        finally {
+            ancestors.delete(value);
+        }
+    };
+    visit(value, 0);
+    const capacity = prefix.length + size;
+    if (!Number.isSafeInteger(capacity))
+        throw new RangeError('Binary output is too large');
+    const output = new Uint8Array(capacity);
+    output.set(prefix);
+    output.set(MAGIC, prefix.length);
+    let position = prefix.length + MAGIC.length;
+    let view;
+    const uint = (value) => {
+        while (value >= 128) {
+            output[position++] = value % 128 | 128;
+            value = Math.floor(value / 128);
+        }
+        output[position++] = value;
+    };
+    for (let cursor = 0; cursor < plan.length;) {
+        const tag = plan[cursor++];
+        if (tag !== 11)
+            output[position++] = tag;
+        if (tag < 4)
+            continue;
+        if (tag === 4) {
+            view ??= new DataView(output.buffer);
+            view.setFloat64(position, plan[cursor++], false);
+            position += 8;
+        }
+        else if (tag === 5 || tag === 6) {
+            let value = plan[cursor++];
+            // Seven varint bytes fit exactly in a safe-integer Number (49 bits).
+            // Extract one BigInt limb rather than shifting/masking BigInt for every byte.
+            while (value >= BIGINT_LIMB) {
+                let limb = Number(value & BIGINT_MASK);
+                for (let index = 0; index < 7; index++) {
+                    output[position++] = limb % 128 | 128;
+                    limb = Math.floor(limb / 128);
+                }
+                value >>= 49n;
+            }
+            uint(Number(value));
+        }
+        else if (tag === 7 || tag === 11) {
+            const value = plan[cursor++];
+            const length = plan[cursor++];
+            uint(length);
+            if (length === value.length) {
+                for (let index = 0; index < length; index++)
+                    output[position++] = value.charCodeAt(index);
+            }
+            else {
+                const result = utf8.encodeInto(value, output.subarray(position, position + length));
+                if (result.read !== value.length || result.written !== length)
+                    throw new Error('UTF-8 planning mismatch');
+                position += length;
+            }
+        }
+        else if (tag === 8) {
+            const value = plan[cursor++];
+            const length = plan[cursor++];
+            if (value.length !== length)
+                throw new RangeError('Byte input changed while encoding');
+            uint(length);
+            output.set(value, position);
+            position += length;
+        }
+        else {
+            uint(plan[cursor++]);
+        }
+    }
+    if (position !== capacity)
+        throw new Error('Binary planning mismatch');
+    return output;
+}
+/** Strict decoder: byte input, version, canonical ordering, bounds and complete consumption. */
+export function decodeValue(input, options = {}) {
+    const limits = limitsFor(options);
+    if (!(input instanceof Uint8Array))
+        throw new TypeError('Wire payload must be Uint8Array');
+    if (input.length > limits.maxBytes)
+        throw new RangeError('Binary value exceeds byte limit');
+    const reader = new BinaryReader(input);
+    if (reader.readBytes(MAGIC.length).some((byte, index) => byte !== MAGIC[index]))
+        throw new TypeError('Unsupported binary wire version');
+    let nodes = 0;
+    const string = () => text.decode(reader.readFrame());
+    const read = (depth) => {
+        if (++nodes > limits.maxNodes || depth > limits.maxDepth)
+            throw new RangeError('Binary value exceeds complexity limit');
+        const tag = reader.readBytes(1)[0];
+        if (tag === 0)
+            return undefined;
+        if (tag === 1)
+            return null;
+        if (tag === 2)
+            return false;
+        if (tag === 3)
+            return true;
+        if (tag === 4) {
+            const bytes = reader.readBytes(8);
+            const value = new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0, false);
+            if (!Number.isFinite(value))
+                throw new TypeError('Binary numbers must be finite');
+            return value;
+        }
+        if (tag === 5 || tag === 6) {
+            const value = reader.readVarBigInt();
+            if (tag === 6 && value === 0n)
+                throw new TypeError('Non-canonical negative zero');
+            return tag === 6 ? -value : value;
+        }
+        if (tag === 7)
+            return string();
+        if (tag === 8)
+            return new Uint8Array(reader.readFrame());
+        if (tag === 9 || tag === 10) {
+            const count = reader.readVarUint();
+            if (count > limits.maxNodes - nodes || count > reader.remaining)
+                throw new RangeError('Invalid binary collection size');
+            if (tag === 9)
+                return Array.from({ length: count }, () => read(depth + 1));
+            const result = {};
+            let previous;
+            for (let index = 0; index < count; index++) {
+                const key = string();
+                if (previous !== undefined && key <= previous)
+                    throw new TypeError('Non-canonical binary map keys');
+                previous = key;
+                Object.defineProperty(result, key, { value: read(depth + 1), enumerable: true, writable: true, configurable: true });
+            }
+            return result;
+        }
+        throw new TypeError('Unknown binary value tag');
+    };
+    const value = read(0);
+    if (reader.remaining)
+        throw new TypeError('Trailing binary data');
+    return value;
+}
+/** Domain separation prevents RPC bytes from being accepted as worker/chat/peer messages. */
+export const encodeWire = (channel, value, limits) => encodeValue([channel, value], limits);
+export function decodeWire(channel, bytes, limits) {
+    const envelope = decodeValue(bytes, limits);
+    if (!Array.isArray(envelope) || envelope.length !== 2 || envelope[0] !== channel)
+        throw new TypeError('Wrong binary message channel');
+    return envelope[1];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/binary",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Dependency-free binary Reader/Writer, unsigned varints and byte framing",
   "type": "module",
   "license": "MIT",
@@ -19,6 +19,7 @@
   ],
   "scripts": {
     "build": "tsc6 -p tsconfig.json",
+    "prepack": "npm run build",
     "test": "node --test"
   },
   "devDependencies": {