lutzroeder/netron · error · Error

Expected ${this._position + length - this._length} more byte

Error message

Expected ${this._position + length - this._length} more bytes. The file might be corrupted. Unexpected end of file.

What it means

Error thrown by protobuf.BinaryReader._fill when a requested read of 'length' bytes at the current position would exceed the underlying stream's declared length. _fill is invoked by every buffered read primitive, so this is the streaming counterpart of the memory-reader overrun check and reports exactly how many bytes are missing.

Source

Thrown at source/protobuf.js:633

    }

    varint() {
        let value = 0n;
        let shift = 0n;
        for (let i = 0; i < 10 && this._position < this._length; i++) {
            const byte = this.byte();
            value |= BigInt(byte & 0x7F) << shift;
            if ((byte & 0x80) === 0) {
                return value;
            }
            shift += 7n;
        }
        throw new protobuf.Error('Invalid varint value.');
    }

    _fill(length) {
        if (this._position + length > this._length) {
            throw new Error(`Expected ${this._position + length - this._length} more bytes. The file might be corrupted. Unexpected end of file.`);
        }
        if (!this._buffer || this._position < this._offset || this._position + length > this._offset + this._buffer.length) {
            this._offset = this._position;
            this._stream.seek(this._offset);
            const size = Math.min(0x10000000, this._length - this._offset);
            this._buffer = this._stream.read(size);
            this._view = new DataView(this._buffer.buffer, this._buffer.byteOffset, this._buffer.byteLength);
        }
        const position = this._position;
        this._position += length;
        return position - this._offset;
    }
};

protobuf.TextReader = class {

    static open(data) {
        if (data) {

View on GitHub (pinned to d8a543f5f8)

Solutions

Validate the file/stream length against the container header before decoding.
Ensure the schema version used for decoding matches the encoder's (field ordering affects length parsing).
Wrap decode in try-catch and report the missing-byte count to pinpoint the corrupt section.

Example fix

// before
const field = reader.bytes(); // length-delimited read

// after — validate declared length before reading
const len = reader.uint32();
if (reader.position + len > reader.length) {
    throw new Error(`Field claims ${len} bytes, only ${reader.length - reader.position} remain`);
}
const field = reader.bytes(len);

Defensive patterns

Strategy: validation

Validate before calling

if (reader.position + expectedLength > reader.length) {
    throw new Error(`Declared section of ${expectedLength} bytes exceeds stream bounds`);
}

Try / catch

try { const data = reader.bytes(); } catch (e) { if (/more bytes/.test(e.message)) throw new Error('Corrupted length-delimited field in model file'); throw e; }

Prevention

Cross-check container-level length fields with actual stream length before decoding.
Keep encoder and decoder schema versions in lockstep.
Catch and log the missing-byte count to identify which section is corrupt.

When it happens

Trigger: Calling any read (uint32, bytes, string, fixed64, ...) whose wire-format length extends past _length — e.g. a length-delimited field claims 1000 bytes but only 10 remain in the stream.

Common situations: Truncated model files, mismatched length prefixes caused by decoding with the wrong schema or field order, or a stream length computed from a wrong header value.

Related errors

AI-assisted analysis of lutzroeder/netron@d8a543f5f8 (2026-08-27). Data as JSON: /api/errors/b112fa2d811bed54. Report an issue: GitHub.