Byte Array Fixed Record Splitter

Split dense byte arrays into complete fixed-width records, preserving an incomplete tail instead of discarding it.

Description

Split dense byte arrays into complete fixed-width records, preserving an incomplete tail instead of discarding it.

Fixed-size records can be split without losing a final incomplete suffix.

When to use this tool

Split dense byte arrays into complete fixed-width records, preserving an incomplete tail instead of discarding it.

Prepare the supplied bytes, recordSize fields for this operation.
Compare the complete example with the representation used by your own input before carrying the result into another step.

How to use the tool and how it works

Enter bytes, recordSize. Use the exact text syntax, units and index conventions explained below.
Run the tool. If input validation fails, correct the supplied fields before interpreting any result.
Read result.records, result.tail. Interpret false, null and empty lists using the distinctions below; they can be valid outputs.

Require recordSize 1 to 128. Return floor(length/recordSize) consecutive complete records and every remaining byte as tail.^[1]

Input field	Meaning and representation	Accepted input
bytes	bytes.	List of integers from 0 to 255; at most 128 bytes
recordSize	record size.	Integer from 1 to 128 inclusive

Output field	Interpretation
result	Object containing the named outputs below.
result.records	The records list in the ordering and representation described above.
result.tail	The tail list in the ordering and representation described above.

json

{
  "input": {
    "bytes": [
      1,
      2,
      3,
      4,
      5
    ],
    "recordSize": 2
  },
  "output": {
    "result": {
      "records": [
        [
          1,
          2
        ],
        [
          3,
          4
        ]
      ],
      "tail": [
        5
      ]
    }
  }
}

Limitations and assumptions

No state is stored and no padding is invented. Pass the tail to a separate streaming step if more input arrives.
Every declared top-level field is required and unexpected fields are rejected. Numeric inputs must be finite; ordinary text fields are bounded to 8,192 UTF-16 code units, with tighter operation-specific limits where stated.
Lists are limited to 128 entries. JSON text must meet bounded size and depth checks, and numeric outputs beyond the safe finite magnitude are rejected. Exact large integers use decimal strings.
Indexes are zero-based and spans have an exclusive end unless explicitly stated otherwise. A valid false, null or empty-list result is distinct from malformed input.

Alternative or Complementary methods

Retain the field-width, bit-index and byte-order conventions when combining operations. Slicing, escaping, permutation and alignment are separate transforms; none supplies a complete framing or cryptographic protocol.

References

Tool behavior and example: Byte Array Fixed Record Splitter — tool.io

Similar or alternative tools

Byte Array Sentinel Splitter
Split at a literal single-byte sentinel, preserving leading, repeated and trailing empty records; no escaping.
Byte Array Escaping Inverse
Explicit byte-stuffing inverse with escape followed by reserved byte XOR 0x20; escape and sentinel must differ.