@loaders.gl/parquet 4.5.3 → 5.0.0-alpha.10

package/src/parquetjs/codecs/dictionary.ts

@@ -5,13 +5,31 @@
 // Forked from https://github.com/kbajalc/parquets under MIT license
 
 import {decodeValues as decodeRleValues} from './rle';
+import {encodeValues as encodeRleValues} from './rle';
+import type {PrimitiveType} from '../schema/declare';
+import type {ParquetCodecOptions} from './declare';
 
 export function decodeValues(type, cursor, count, opts) {
-  opts.bitWidth = cursor.buffer.slice(cursor.offset, cursor.offset + 1).readInt8(0);
+  const bitWidth = cursor.buffer[cursor.offset];
   cursor.offset += 1;
-  return decodeRleValues(type, cursor, count, {...opts, disableEnvelope: true});
+  return decodeRleValues(type, cursor, count, {...opts, bitWidth, disableEnvelope: true});
 }
 
-export function encodeValues(type, cursor, count, opts) {
-  throw new Error('Encode dictionary functionality is not supported');
+/** Encodes dictionary indexes as a bit width followed by the RLE/bit-packed hybrid stream. */
+export function encodeValues(
+  _type: PrimitiveType,
+  values: number[],
+  options: ParquetCodecOptions
+): Uint8Array {
+  if (options.bitWidth === undefined) {
+    throw new Error('bitWidth is required for dictionary encoding');
+  }
+  const encodedIndices = encodeRleValues('INT32', values, {
+    bitWidth: options.bitWidth,
+    disableEnvelope: true
+  });
+  const output = new Uint8Array(encodedIndices.length + 1);
+  output[0] = options.bitWidth;
+  output.set(encodedIndices, 1);
+  return output;
 }

package/src/parquetjs/codecs/index.ts

@@ -9,6 +9,8 @@ import type {ParquetCodecKit} from './declare';
 import * as PLAIN from './plain';
 import * as RLE from './rle';
 import * as DICTIONARY from './dictionary';
+import * as DELTA from './delta';
+import * as BYTE_STREAM_SPLIT from './byte-stream-split';
 
 export * from './declare';
 
@@ -21,6 +23,10 @@ export const PARQUET_CODECS: Record<ParquetCodec, ParquetCodecKit> = {
     encodeValues: RLE.encodeValues,
     decodeValues: RLE.decodeValues
   },
+  BIT_PACKED: {
+    encodeValues: RLE.encodeBitPackedValues,
+    decodeValues: RLE.decodeBitPackedValues
+  },
   // Using the PLAIN_DICTIONARY enum value is deprecated in the Parquet 2.0 specification.
   PLAIN_DICTIONARY: {
     // @ts-ignore
@@ -32,5 +38,21 @@ export const PARQUET_CODECS: Record<ParquetCodec, ParquetCodecKit> = {
     // @ts-ignore
     encodeValues: DICTIONARY.encodeValues,
     decodeValues: DICTIONARY.decodeValues
+  },
+  DELTA_BINARY_PACKED: {
+    encodeValues: DELTA.encodeDeltaBinaryPackedValues,
+    decodeValues: DELTA.decodeDeltaBinaryPackedValues
+  },
+  DELTA_LENGTH_BYTE_ARRAY: {
+    encodeValues: DELTA.encodeDeltaLengthByteArrayValues,
+    decodeValues: DELTA.decodeDeltaLengthByteArrayValues
+  },
+  DELTA_BYTE_ARRAY: {
+    encodeValues: DELTA.encodeDeltaByteArrayValues,
+    decodeValues: DELTA.decodeDeltaByteArrayValues
+  },
+  BYTE_STREAM_SPLIT: {
+    encodeValues: BYTE_STREAM_SPLIT.encodeValues,
+    decodeValues: BYTE_STREAM_SPLIT.decodeValues
   }
 };

package/src/parquetjs/codecs/plain.ts

@@ -6,14 +6,38 @@
 
 /* eslint-disable camelcase */
 import type {PrimitiveType} from '../schema/declare';
-import type {CursorBuffer, ParquetCodecOptions} from './declare';
-import INT53 from 'int53';
+import {
+  getParquetValueOutput,
+  reserveParquetByteArrayOutput,
+  type CursorBuffer,
+  type ParquetCodecOptions,
+  type ParquetValueBuffer
+} from './declare';
+import {
+  concatUint8Arrays,
+  copyUint8Array,
+  encodeUtf8,
+  toUint8Array,
+  writeDoubleLE,
+  writeFloatLE,
+  writeInt32LE,
+  writeInt64LE,
+  writeUInt32LE
+} from '../utils/binary-utils';
+
+const JULIAN_DAY_UNIX_EPOCH = 2440588n;
+const NANOSECONDS_PER_DAY = 86_400_000_000_000n;
+const INT64_MIN = -(1n << 63n);
+const INT64_MAX = (1n << 63n) - 1n;
+const IS_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+/** Largest byte value copied inline to avoid a temporary TypedArray view. */
+const MAXIMUM_INLINE_BYTE_COPY_LENGTH = 7;
 
 export function encodeValues(
   type: PrimitiveType,
   values: any[],
-  opts: ParquetCodecOptions
-): Buffer {
+  opts: ParquetCodecOptions = {}
+): Uint8Array {
   switch (type) {
     case 'BOOLEAN':
       return encodeValues_BOOLEAN(values);
@@ -22,7 +46,7 @@ export function encodeValues(
     case 'INT64':
       return encodeValues_INT64(values);
     case 'INT96':
-      return encodeValues_INT96(values);
+      return encodeValues_INT96(values, opts.int96AsTimestamp);
     case 'FLOAT':
       return encodeValues_FLOAT(values);
     case 'DOUBLE':
@@ -41,22 +65,22 @@ export function decodeValues(
   cursor: CursorBuffer,
   count: number,
   opts: ParquetCodecOptions
-): any[] {
+): ParquetValueBuffer {
   switch (type) {
     case 'BOOLEAN':
-      return decodeValues_BOOLEAN(cursor, count);
+      return decodeValues_BOOLEAN(cursor, count, opts);
     case 'INT32':
-      return decodeValues_INT32(cursor, count);
+      return decodeValues_INT32(cursor, count, opts);
     case 'INT64':
-      return decodeValues_INT64(cursor, count);
+      return decodeValues_INT64(cursor, count, opts);
     case 'INT96':
-      return decodeValues_INT96(cursor, count);
+      return decodeValues_INT96(cursor, count, opts);
     case 'FLOAT':
-      return decodeValues_FLOAT(cursor, count);
+      return decodeValues_FLOAT(cursor, count, opts);
     case 'DOUBLE':
-      return decodeValues_DOUBLE(cursor, count);
+      return decodeValues_DOUBLE(cursor, count, opts);
     case 'BYTE_ARRAY':
-      return decodeValues_BYTE_ARRAY(cursor, count);
+      return decodeValues_BYTE_ARRAY(cursor, count, opts);
     case 'FIXED_LEN_BYTE_ARRAY':
       return decodeValues_FIXED_LEN_BYTE_ARRAY(cursor, count, opts);
     default:
@@ -64,9 +88,8 @@ export function decodeValues(
   }
 }
 
-function encodeValues_BOOLEAN(values: boolean[]): Buffer {
-  const buf = Buffer.alloc(Math.ceil(values.length / 8));
-  buf.fill(0);
+function encodeValues_BOOLEAN(values: boolean[]): Uint8Array {
+  const buf = new Uint8Array(Math.ceil(values.length / 8));
   for (let i = 0; i < values.length; i++) {
     if (values[i]) {
       buf[Math.floor(i / 8)] |= 1 << (i % 8);
@@ -75,168 +98,373 @@ function encodeValues_BOOLEAN(values: boolean[]): Buffer {
   return buf;
 }
 
-function decodeValues_BOOLEAN(cursor: CursorBuffer, count: number): boolean[] {
-  const values: boolean[] = [];
+function decodeValues_BOOLEAN(
+  cursor: CursorBuffer,
+  count: number,
+  options: ParquetCodecOptions
+): ParquetValueBuffer {
+  const {output, outputOffset} = getParquetValueOutput(options, count);
   for (let i = 0; i < count; i++) {
     const b = cursor.buffer[cursor.offset + Math.floor(i / 8)];
-    values.push((b & (1 << (i % 8))) > 0);
+    const value = (b & (1 << (i % 8))) > 0;
+    output[outputOffset + i] = output instanceof Uint8Array ? Number(value) : value;
   }
   cursor.offset += Math.ceil(count / 8);
-  return values;
+  return output;
 }
 
-function encodeValues_INT32(values: number[]): Buffer {
-  const buf = Buffer.alloc(4 * values.length);
+function encodeValues_INT32(values: number[]): Uint8Array {
+  const buf = new Uint8Array(4 * values.length);
   for (let i = 0; i < values.length; i++) {
-    buf.writeInt32LE(values[i], i * 4);
+    writeInt32LE(buf, values[i], i * 4);
   }
   return buf;
 }
 
-function decodeValues_INT32(cursor: CursorBuffer, count: number): number[] {
-  const values: number[] = [];
+function decodeValues_INT32(
+  cursor: CursorBuffer,
+  count: number,
+  options: ParquetCodecOptions
+): ParquetValueBuffer {
+  const {output, outputOffset} = getParquetValueOutput(options, count);
+  if (output instanceof Int32Array && copyPlainTypedValues(cursor, output, outputOffset, count)) {
+    return output;
+  }
+  const dataView = getCursorDataView(cursor);
   for (let i = 0; i < count; i++) {
-    values.push(cursor.buffer.readInt32LE(cursor.offset));
+    output[outputOffset + i] = dataView.getInt32(cursor.offset, true);
     cursor.offset += 4;
   }
-  return values;
+  return output;
 }
 
-function encodeValues_INT64(values: number[]): Buffer {
-  const buf = Buffer.alloc(8 * values.length);
+function encodeValues_INT64(values: Array<number | bigint>): Uint8Array {
+  const buf = new Uint8Array(8 * values.length);
   for (let i = 0; i < values.length; i++) {
-    INT53.writeInt64LE(values[i], buf, i * 8);
+    writeInt64LE(buf, values[i], i * 8);
   }
   return buf;
 }
 
-function decodeValues_INT64(cursor: CursorBuffer, count: number): number[] {
-  const values: number[] = [];
+function decodeValues_INT64(
+  cursor: CursorBuffer,
+  count: number,
+  options: ParquetCodecOptions
+): ParquetValueBuffer {
+  const {output, outputOffset} = getParquetValueOutput(options, count);
+  if (
+    options.int64AsBigInt &&
+    output instanceof BigInt64Array &&
+    copyPlainTypedValues(cursor, output, outputOffset, count)
+  ) {
+    return output;
+  }
+  const dataView = getCursorDataView(cursor);
   for (let i = 0; i < count; i++) {
-    values.push(INT53.readInt64LE(cursor.buffer, cursor.offset));
+    const value = dataView.getBigInt64(cursor.offset, true);
+    output[outputOffset + i] = options.int64AsBigInt ? value : Number(value);
     cursor.offset += 8;
   }
-  return values;
+  return output;
 }
 
-function encodeValues_INT96(values: number[]): Buffer {
-  const buf = Buffer.alloc(12 * values.length);
+function encodeValues_INT96(values: Array<number | bigint>, asTimestamp = false): Uint8Array {
+  const buf = new Uint8Array(12 * values.length);
   for (let i = 0; i < values.length; i++) {
-    if (values[i] >= 0) {
-      INT53.writeInt64LE(values[i], buf, i * 12);
-      buf.writeUInt32LE(0, i * 12 + 8); // truncate to 64 actual precision
-    } else {
-      INT53.writeInt64LE(~-values[i] + 1, buf, i * 12);
-      buf.writeUInt32LE(0xffffffff, i * 12 + 8); // truncate to 64 actual precision
+    if (!asTimestamp) {
+      writeInt64LE(buf, values[i], i * 12);
+      writeUInt32LE(buf, values[i] >= 0 ? 0 : 0xffffffff, i * 12 + 8);
+      continue;
+    }
+    const epochNanoseconds = BigInt(values[i]);
+    if (epochNanoseconds < INT64_MIN || epochNanoseconds > INT64_MAX) {
+      throw new Error(`INT96 timestamp is outside the signed 64-bit range: ${epochNanoseconds}`);
     }
+    const julianDayOffset = floorDivide(epochNanoseconds, NANOSECONDS_PER_DAY);
+    const nanosecondsOfDay = epochNanoseconds - julianDayOffset * NANOSECONDS_PER_DAY;
+    const julianDay = JULIAN_DAY_UNIX_EPOCH + julianDayOffset;
+    if (julianDay < -2147483648n || julianDay > 2147483647n) {
+      throw new Error(`INT96 timestamp has an unsupported Julian day: ${julianDay}`);
+    }
+    writeInt64LE(buf, nanosecondsOfDay, i * 12);
+    writeInt32LE(buf, Number(julianDay), i * 12 + 8);
   }
   return buf;
 }
 
-function decodeValues_INT96(cursor: CursorBuffer, count: number): number[] {
-  const values: number[] = [];
+function floorDivide(value: bigint, divisor: bigint): bigint {
+  const quotient = value / divisor;
+  const remainder = value % divisor;
+  return remainder < 0n ? quotient - 1n : quotient;
+}
+
+function decodeValues_INT96(
+  cursor: CursorBuffer,
+  count: number,
+  options: ParquetCodecOptions
+): ParquetValueBuffer {
+  const {output, outputOffset} = getParquetValueOutput(options, count);
+  const dataView = getCursorDataView(cursor);
   for (let i = 0; i < count; i++) {
-    const low = INT53.readInt64LE(cursor.buffer, cursor.offset);
-    const high = cursor.buffer.readUInt32LE(cursor.offset + 8);
-    if (high === 0xffffffff) {
-      values.push(~-low + 1); // truncate to 64 actual precision
+    if (options.int96AsTimestamp) {
+      const nanosecondsOfDay = dataView.getBigUint64(cursor.offset, true);
+      if (nanosecondsOfDay >= NANOSECONDS_PER_DAY) {
+        throw new Error(`Invalid INT96 nanoseconds of day: ${nanosecondsOfDay}`);
+      }
+      const julianDay = BigInt(dataView.getInt32(cursor.offset + 8, true));
+      const epochNanoseconds =
+        (julianDay - JULIAN_DAY_UNIX_EPOCH) * NANOSECONDS_PER_DAY + nanosecondsOfDay;
+      if (epochNanoseconds < INT64_MIN || epochNanoseconds > INT64_MAX) {
+        throw new Error(`INT96 timestamp is outside the signed 64-bit range: ${epochNanoseconds}`);
+      }
+      output[outputOffset + i] = epochNanoseconds;
     } else {
-      values.push(low); // truncate to 64 actual precision
+      const low = Number(dataView.getBigInt64(cursor.offset, true));
+      const high = dataView.getUint32(cursor.offset + 8, true);
+      if (high === 0xffffffff) {
+        output[outputOffset + i] = ~-low + 1; // truncate to 64 actual precision
+      } else {
+        output[outputOffset + i] = low; // truncate to 64 actual precision
+      }
     }
     cursor.offset += 12;
   }
-  return values;
+  return output;
 }
 
-function encodeValues_FLOAT(values: number[]): Buffer {
-  const buf = Buffer.alloc(4 * values.length);
+function encodeValues_FLOAT(values: number[]): Uint8Array {
+  const buf = new Uint8Array(4 * values.length);
   for (let i = 0; i < values.length; i++) {
-    buf.writeFloatLE(values[i], i * 4);
+    writeFloatLE(buf, values[i], i * 4);
   }
   return buf;
 }
 
-function decodeValues_FLOAT(cursor: CursorBuffer, count: number): number[] {
-  const values: number[] = [];
+function decodeValues_FLOAT(
+  cursor: CursorBuffer,
+  count: number,
+  options: ParquetCodecOptions
+): ParquetValueBuffer {
+  const {output, outputOffset} = getParquetValueOutput(options, count);
+  if (output instanceof Float32Array && copyPlainTypedValues(cursor, output, outputOffset, count)) {
+    return output;
+  }
+  const dataView = getCursorDataView(cursor);
   for (let i = 0; i < count; i++) {
-    values.push(cursor.buffer.readFloatLE(cursor.offset));
+    output[outputOffset + i] = dataView.getFloat32(cursor.offset, true);
     cursor.offset += 4;
   }
-  return values;
+  return output;
 }
 
-function encodeValues_DOUBLE(values: number[]): Buffer {
-  const buf = Buffer.alloc(8 * values.length);
+function encodeValues_DOUBLE(values: number[]): Uint8Array {
+  const buf = new Uint8Array(8 * values.length);
   for (let i = 0; i < values.length; i++) {
-    buf.writeDoubleLE(values[i], i * 8);
+    writeDoubleLE(buf, values[i], i * 8);
   }
   return buf;
 }
 
-function decodeValues_DOUBLE(cursor: CursorBuffer, count: number): number[] {
-  const values: number[] = [];
+function decodeValues_DOUBLE(
+  cursor: CursorBuffer,
+  count: number,
+  options: ParquetCodecOptions
+): ParquetValueBuffer {
+  const {output, outputOffset} = getParquetValueOutput(options, count);
+  if (output instanceof Float64Array && copyPlainTypedValues(cursor, output, outputOffset, count)) {
+    return output;
+  }
+  const dataView = getCursorDataView(cursor);
   for (let i = 0; i < count; i++) {
-    values.push(cursor.buffer.readDoubleLE(cursor.offset));
+    output[outputOffset + i] = dataView.getFloat64(cursor.offset, true);
     cursor.offset += 8;
   }
-  return values;
+  return output;
 }
 
-function encodeValues_BYTE_ARRAY(values: Buffer[]): Buffer {
+function encodeValues_BYTE_ARRAY(values: any[]): Uint8Array {
+  const byteValues = values.map(toPrimitiveBytes);
   // tslint:disable-next-line:variable-name
   let buf_len = 0;
-  for (let i = 0; i < values.length; i++) {
-    values[i] = Buffer.from(values[i]);
-    buf_len += 4 + values[i].length;
+  for (let i = 0; i < byteValues.length; i++) {
+    buf_len += 4 + byteValues[i].length;
   }
-  const buf = Buffer.alloc(buf_len);
+  const buf = new Uint8Array(buf_len);
   // tslint:disable-next-line:variable-name
   let buf_pos = 0;
-  for (let i = 0; i < values.length; i++) {
-    buf.writeUInt32LE(values[i].length, buf_pos);
-    values[i].copy(buf as Uint8Array, buf_pos + 4);
-    buf_pos += 4 + values[i].length;
+  for (let i = 0; i < byteValues.length; i++) {
+    writeUInt32LE(buf, byteValues[i].length, buf_pos);
+    buf.set(byteValues[i], buf_pos + 4);
+    buf_pos += 4 + byteValues[i].length;
   }
   return buf;
 }
 
-function decodeValues_BYTE_ARRAY(cursor: CursorBuffer, count: number): Buffer[] {
-  const values: Buffer[] = [];
+function decodeValues_BYTE_ARRAY(
+  cursor: CursorBuffer,
+  count: number,
+  options: ParquetCodecOptions
+): ParquetValueBuffer {
+  if (options.byteArrayOutput) {
+    return decodeByteArraysToContiguousOutput(cursor, count, options);
+  }
+  const {output, outputOffset} = getParquetValueOutput(options, count);
+  const dataView = getCursorDataView(cursor);
   for (let i = 0; i < count; i++) {
-    const len = cursor.buffer.readUInt32LE(cursor.offset);
+    const len = dataView.getUint32(cursor.offset, true);
     cursor.offset += 4;
-    // values.push(cursor.buffer.buffer.slice(cursor.offset, cursor.offset + len));
-    values.push(cursor.buffer.slice(cursor.offset, cursor.offset + len));
-    cursor.offset += len;
+    output[outputOffset + i] = readByteArray(cursor, len, options.retainByteArrayViews);
   }
-  return values;
+  return output;
 }
 
-function encodeValues_FIXED_LEN_BYTE_ARRAY(values: Buffer[], opts: ParquetCodecOptions): Buffer {
+/** Decodes length-prefixed PLAIN values directly into one Arrow-compatible byte buffer. */
+function decodeByteArraysToContiguousOutput(
+  cursor: CursorBuffer,
+  count: number,
+  options: ParquetCodecOptions
+): ParquetValueBuffer {
+  const byteArrayOutput = options.byteArrayOutput!;
+  const outputOffset = options.outputOffset || 0;
+  const dataView = getCursorDataView(cursor);
+  let byteOffset = byteArrayOutput.byteLength;
+  byteArrayOutput.valueOffsets[outputOffset] = byteOffset;
+  const remainingByteLength = (cursor.size ?? cursor.buffer.byteLength) - cursor.offset;
+  if (remainingByteLength < 0) {
+    throw new Error('PLAIN BYTE_ARRAY cursor exceeds the page buffer');
+  }
+  // PLAIN's remaining encoded bytes are an upper bound for its decoded payload because each value
+  // drops a four-byte length prefix. Reserve once per page instead of checking capacity per value.
+  reserveParquetByteArrayOutput(byteArrayOutput, remainingByteLength);
+  for (let valueIndex = 0; valueIndex < count; valueIndex++) {
+    const byteLength = dataView.getUint32(cursor.offset, true);
+    cursor.offset += 4;
+    const sourceEnd = cursor.offset + byteLength;
+    const destinationEnd = byteOffset + byteLength;
+    if (sourceEnd > (cursor.size ?? cursor.buffer.byteLength)) {
+      throw new Error('PLAIN BYTE_ARRAY value exceeds the page buffer');
+    }
+    if (byteLength <= MAXIMUM_INLINE_BYTE_COPY_LENGTH) {
+      for (let byteIndex = 0; byteIndex < byteLength; byteIndex++) {
+        byteArrayOutput.data[byteOffset + byteIndex] = cursor.buffer[cursor.offset + byteIndex];
+      }
+    } else {
+      byteArrayOutput.data.set(cursor.buffer.subarray(cursor.offset, sourceEnd), byteOffset);
+    }
+    cursor.offset = sourceEnd;
+    byteOffset = destinationEnd;
+    byteArrayOutput.valueOffsets[outputOffset + valueIndex + 1] = byteOffset;
+  }
+  byteArrayOutput.byteLength = byteOffset;
+  return options.output || [];
+}
+
+function encodeValues_FIXED_LEN_BYTE_ARRAY(values: any[], opts: ParquetCodecOptions): Uint8Array {
   if (!opts.typeLength) {
     throw new Error('missing option: typeLength (required for FIXED_LEN_BYTE_ARRAY)');
   }
+  const byteValues = values.map(toPrimitiveBytes);
   for (let i = 0; i < values.length; i++) {
-    values[i] = Buffer.from(values[i]);
-    if (values[i].length !== opts.typeLength) {
+    if (byteValues[i].length !== opts.typeLength) {
       throw new Error(`invalid value for FIXED_LEN_BYTE_ARRAY: ${values[i]}`);
     }
   }
-  return Buffer.concat(values as Uint8Array[]);
+  return concatUint8Arrays(byteValues);
 }
 
 function decodeValues_FIXED_LEN_BYTE_ARRAY(
   cursor: CursorBuffer,
   count: number,
   opts: ParquetCodecOptions
-): Buffer[] {
-  const values: Buffer[] = [];
+): ParquetValueBuffer {
   if (!opts.typeLength) {
     throw new Error('missing option: typeLength (required for FIXED_LEN_BYTE_ARRAY)');
   }
+  if (opts.byteArrayOutput) {
+    return decodeFixedLengthByteArraysToContiguousOutput(cursor, count, opts.typeLength, opts);
+  }
+  const {output, outputOffset} = getParquetValueOutput(opts, count);
   for (let i = 0; i < count; i++) {
-    values.push(cursor.buffer.slice(cursor.offset, cursor.offset + opts.typeLength));
-    cursor.offset += opts.typeLength;
+    output[outputOffset + i] = readByteArray(cursor, opts.typeLength, opts.retainByteArrayViews);
   }
-  return values;
+  return output;
+}
+
+/** Exposes one fixed-width PLAIN payload directly as Arrow-compatible bytes and offsets. */
+function decodeFixedLengthByteArraysToContiguousOutput(
+  cursor: CursorBuffer,
+  count: number,
+  typeLength: number,
+  options: ParquetCodecOptions
+): ParquetValueBuffer {
+  const byteArrayOutput = options.byteArrayOutput!;
+  const outputOffset = options.outputOffset || 0;
+  const payloadByteLength = count * typeLength;
+  const inputEnd = cursor.offset + payloadByteLength;
+  if (inputEnd > (cursor.size ?? cursor.buffer.byteLength)) {
+    throw new Error('PLAIN FIXED_LEN_BYTE_ARRAY values exceed the page buffer');
+  }
+
+  let byteOffset = byteArrayOutput.byteLength;
+  byteArrayOutput.valueOffsets[outputOffset] = byteOffset;
+  if (byteOffset === 0) {
+    // The common single-page case can retain the original Parquet bytes without allocating either
+    // one view per value or a second payload buffer. A later page falls back to append-and-copy.
+    byteArrayOutput.data = cursor.buffer.subarray(cursor.offset, inputEnd);
+  } else {
+    reserveParquetByteArrayOutput(byteArrayOutput, payloadByteLength);
+    byteArrayOutput.data.set(cursor.buffer.subarray(cursor.offset, inputEnd), byteOffset);
+  }
+  cursor.offset = inputEnd;
+  for (let valueIndex = 0; valueIndex < count; valueIndex++) {
+    byteOffset += typeLength;
+    byteArrayOutput.valueOffsets[outputOffset + valueIndex + 1] = byteOffset;
+  }
+  byteArrayOutput.byteLength = byteOffset;
+  return options.output || [];
+}
+
+/** Reads one byte-array value, optionally retaining a view into the decoded page buffer. */
+function readByteArray(
+  cursor: CursorBuffer,
+  byteLength: number,
+  retainByteArrayView: boolean | undefined
+): Uint8Array {
+  const value = cursor.buffer.subarray(cursor.offset, cursor.offset + byteLength);
+  cursor.offset += byteLength;
+  return retainByteArrayView ? value : copyUint8Array(value);
+}
+
+/** Creates one reusable DataView for all primitive reads from a codec cursor. */
+function getCursorDataView(cursor: CursorBuffer): DataView {
+  return new DataView(cursor.buffer.buffer, cursor.buffer.byteOffset, cursor.buffer.byteLength);
+}
+
+/** Copies little-endian PLAIN values directly into an identical typed destination. */
+function copyPlainTypedValues(
+  cursor: CursorBuffer,
+  output: Int32Array | BigInt64Array | Float32Array | Float64Array,
+  outputOffset: number,
+  count: number
+): boolean {
+  if (!IS_LITTLE_ENDIAN) {
+    return false;
+  }
+  const byteLength = count * output.BYTES_PER_ELEMENT;
+  const inputEnd = cursor.offset + byteLength;
+  if (inputEnd > (cursor.size ?? cursor.buffer.length) || outputOffset + count > output.length) {
+    throw new Error('Unexpected end of Parquet PLAIN values');
+  }
+  const outputBytes = new Uint8Array(
+    output.buffer,
+    output.byteOffset + outputOffset * output.BYTES_PER_ELEMENT,
+    byteLength
+  );
+  outputBytes.set(cursor.buffer.subarray(cursor.offset, inputEnd));
+  cursor.offset = inputEnd;
+  return true;
+}
+
+function toPrimitiveBytes(value: any): Uint8Array {
+  return typeof value === 'string' ? encodeUtf8(value) : toUint8Array(value);
 }