lutzroeder/netron · error · Error

Expected ${offset} more bytes. The file might be corrupted.

Error message

Expected ${offset} more bytes. The file might be corrupted. Unexpected end of file.

What it means

Thrown by the file-backed stream's _fill() when fulfilling a read of 'length' bytes from the current position would require more bytes than the file contains. _fill is the backing routine for read/peek, so this error surfaces whenever a parser asks for more data than the (possibly truncated) file can supply.

Source

Thrown at source/node.js:75

    }

    read(length) {
        length = length === undefined ? this._length - this._position : length;
        if (length < 0x10000000) {
            const position = this._fill(length);
            return this._buffer.slice(position, position + length);
        }
        const position = this._position;
        this.skip(length);
        const buffer = new Uint8Array(length);
        this._read(buffer, position);
        return buffer;
    }

    _fill(length) {
        if (this._position + length > this._length) {
            const offset = this._position + length - this._length;
            throw new Error(`Expected ${offset} 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;
            const length = Math.min(0x10000000, this._length - this._offset);
            if (!this._buffer || length !== this._buffer.length) {
                this._buffer = new Uint8Array(length);
            }
            this._read(this._buffer, this._offset);
        }
        const position = this._position;
        this._position += length;
        return position - this._offset;
    }

    _read(buffer, offset) {
        const descriptor = fs.openSync(this._file, 'r');
        const stat = fs.statSync(this._file);
        if (stat.mtimeMs !== this._mtime) {

View on GitHub (pinned to d8a543f5f8)

Solutions

Verify file integrity and size against the expected artifact.
Check the read length passed in — it may be derived from an uninitialized or misparsed size variable.
Before reading, guard with stream.position + n <= stream.length.

Example fix

// before
const bytes = stream.read(16);

// after
const remaining = stream.length - stream.position;
if (remaining < 16) throw new Error(`Need 16 bytes, only ${remaining} left`);
const bytes = stream.read(16);

Defensive patterns

Strategy: validation

Validate before calling

const remaining = stream.length - stream.position;
if (n > remaining) {
    throw new Error(`Read of ${n} bytes exceeds ${remaining} remaining bytes`);
}

Try / catch

try { const b = stream.read(n); } catch (e) { if (/more bytes/.test(e.message)) throw new Error('Unexpected EOF while reading model section'); throw e; }

Prevention

Always compare requested read size against remaining bytes.
Treat any EOF during header parsing as a corrupt file immediately.
Keep file-size sanity checks at the container level before deep parsing.

When it happens

Trigger: Calling stream.read(n) or stream.peek(n) with n greater than _length - _position; typical when a fixed-size header/struct read runs off the end of a truncated model file.

Common situations: Corrupted or partially downloaded model files, mismatched format assumptions (reading a fixed 8-byte field where fewer remain), or seeking near the end then requesting a large peek buffer.

Related errors

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