@loaders.gl/pointclouds 0.0.0-stage → 5.0.0-beta.2

package/src/las/las-writer.ts

@@ -0,0 +1,1473 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {
+  encodeLASzipVLR,
+  encodeLAZChunk,
+  encodeLAZChunkTable,
+  type LAZChunkTableEntry,
+  type WriterOptions,
+  type WriterWithEncoder
+} from '@loaders.gl/core/loader-utils';
+import type {Mesh, MeshArrowTable, MeshAttribute} from '@loaders.gl/core/schema';
+import {convertMeshToTable, convertTableToMesh} from '@loaders.gl/core/schema-utils';
+import {LASFormat} from './las-format';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+const LAS_HEADER_LENGTH = 227;
+const LAS_1_4_HEADER_LENGTH = 375;
+const LAS_1_5_HEADER_LENGTH = 393;
+const VLR_HEADER_LENGTH = 54;
+const EXTRA_BYTES_DESCRIPTOR_LENGTH = 192;
+const DEFAULT_LAZ_CHUNK_SIZE = 50_000;
+const VARIABLE_LAZ_CHUNK_SIZE = 0xffffffff;
+const LAS_RETURN_BUCKET_COUNT = 15;
+const POINT_RECORD_LENGTHS: Record<number, number> = {
+  0: 20,
+  1: 28,
+  2: 26,
+  3: 34,
+  4: 57,
+  5: 63,
+  6: 30,
+  7: 36,
+  8: 38,
+  9: 59,
+  10: 67
+};
+
+/** Description of a typed mesh attribute stored in LAS Extra Bytes. */
+export type LASExtraBytesWriter = {
+  /** Name of the mesh attribute to append to each point record. */
+  attribute: string;
+  /** Optional LAS Extra Bytes field name. */
+  name?: string;
+  /** Optional LAS Extra Bytes field description. */
+  description?: string;
+};
+
+/** Options for `LASWriter`. */
+export type LASWriterOptions = WriterOptions & {
+  /** LAS-specific writer options. */
+  las?: {
+    /** Output container format. COPC has its own writer in @loaders.gl/tiles-3d/copc. */
+    format?: 'las' | 'laz';
+    /** LAS file version to write. LAS 1.5 requires a WKT CRS string. */
+    version?: '1.0' | '1.1' | '1.2' | '1.3' | '1.4' | '1.5';
+    /** WKT coordinate system required for LAS 1.5 output. */
+    wkt?: string;
+    /** Optional WKT math transform VLR for LAS 1.5 output. */
+    wktMathTransform?: string;
+    /** LAS 1.5 GPS time offset in the public header. */
+    timeOffset?: number;
+    /** LAS point data record format to write. */
+    pointDataRecordFormat?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+    /** Coordinate scale factors used to quantize positions into LAS integer coordinates. */
+    scale?: [number, number, number];
+    /** Coordinate offsets used to quantize positions into LAS integer coordinates. */
+    offset?: [number, number, number];
+    /** Source RGB depth: 8 scales to UInt16, 16 preserves values; auto retains legacy inference. Normalized attributes retain their declared normalization. */
+    colorDepth?: number | string;
+    /** Number of points per fixed-size LAZ chunk. */
+    chunkSize?: number;
+    /** Write a variable-size LAZ chunk table instead of a fixed-size table. */
+    variableChunkTable?: boolean;
+    /** Typed mesh attributes with one or three components to append as Extra Bytes fields. */
+    extraBytes?: LASExtraBytesWriter[];
+  };
+};
+
+/**
+ * Writer for LAS and LAZ point cloud data.
+ */
+export const LASWriter = {
+  ...LASFormat,
+  dataType: null as unknown as Mesh | MeshArrowTable,
+  batchType: null as never,
+  version: VERSION,
+  extensions: ['las', 'laz'],
+  options: {
+    las: {}
+  },
+  encode: async (data, options) => encodeLASSync(data, options),
+  encodeSync: encodeLASSync,
+  encodeInBatches: async function* (dataIterator, options) {
+    const batches: (Mesh | MeshArrowTable)[] = [];
+    for await (const batch of dataIterator as AsyncIterable<Mesh | MeshArrowTable>) {
+      batches.push(batch);
+    }
+    yield encodeLASSync(mergeMeshBatches(batches), options);
+  }
+} as const satisfies WriterWithEncoder<Mesh | MeshArrowTable, never, LASWriterOptions>;
+
+/** Encode mesh category data as LAS or LAZ bytes. */
+function encodeLASSync(data: Mesh | MeshArrowTable, options: LASWriterOptions = {}): ArrayBuffer {
+  const format = options.las?.format || 'las';
+  const colorDepth = options.las?.colorDepth;
+  if (colorDepth !== undefined && colorDepth !== 'auto' && colorDepth !== 8 && colorDepth !== 16)
+    throw new Error('LASWriter: invalid source color depth');
+  const mesh = normalizeMesh(data);
+  const positionAttribute = getRequiredAttribute(mesh, 'POSITION');
+  validatePositionAttribute(positionAttribute);
+  const vertexCount = positionAttribute.value.length / positionAttribute.size;
+  validateOptionalPointAttributes(mesh, vertexCount);
+  const colorAttribute = mesh.attributes.COLOR_0;
+  const intensityAttribute = mesh.attributes.intensity;
+  const classificationAttribute = mesh.attributes.classification;
+  const nirAttribute = mesh.attributes.nir;
+  const extraByteFields = getExtraByteFields(mesh, options, vertexCount);
+  const gpsTimeAttribute = mesh.attributes.gpsTime;
+  const scanAngleAttribute = mesh.attributes.scanAngle;
+  const userDataAttribute = mesh.attributes.userData;
+  const pointSourceIdAttribute = mesh.attributes.pointSourceId;
+  const returnNumberAttribute = mesh.attributes.returnNumber;
+  const numberOfReturnsAttribute = mesh.attributes.numberOfReturns;
+  const scannerChannelAttribute = mesh.attributes.scannerChannel;
+  const scanDirectionFlagAttribute = mesh.attributes.scanDirectionFlag;
+  const edgeOfFlightLineAttribute = mesh.attributes.edgeOfFlightLine;
+  const syntheticAttribute = mesh.attributes.synthetic;
+  const keyPointAttribute = mesh.attributes.keyPoint;
+  const withheldAttribute = mesh.attributes.withheld;
+  const overlapAttribute = mesh.attributes.overlap;
+  const waveformDescriptorAttribute = mesh.attributes.wavePacketDescriptorIndex;
+  const waveformOffsetAttribute = mesh.attributes.wavePacketOffset;
+  const waveformSizeAttribute = mesh.attributes.wavePacketSize;
+  const waveformReturnPointAttribute = mesh.attributes.wavePacketReturnPoint;
+  const waveformVectorAttribute = mesh.attributes.wavePacketVector;
+  const boundingBox = getBoundingBox(positionAttribute, vertexCount);
+  const returnCounts = getReturnCounts(returnNumberAttribute, vertexCount);
+  const scale = getScale(mesh, options);
+  const offset = getOffset(mesh, options, boundingBox);
+  validateCoordinateEncoding(positionAttribute, vertexCount, scale, offset);
+  const pointDataRecordFormat =
+    options.las?.pointDataRecordFormat ?? getDefaultPointDataRecordFormat(options, colorAttribute);
+  validateReturnAttributes(mesh, vertexCount, pointDataRecordFormat);
+  const basePointDataRecordLength = POINT_RECORD_LENGTHS[pointDataRecordFormat];
+  if (!basePointDataRecordLength) {
+    throw new Error(`LASWriter: unsupported point data record format ${pointDataRecordFormat}`);
+  }
+  const pointDataRecordLength =
+    basePointDataRecordLength +
+    extraByteFields.reduce((byteLength, field) => byteLength + field.byteLength, 0);
+  if (pointDataRecordLength > 0xffff) {
+    throw new Error(
+      `LASWriter: point data record length ${pointDataRecordLength} exceeds the LAS limit`
+    );
+  }
+  validateExtraBytesVLR(extraByteFields);
+  const version = options.las?.version || (pointDataRecordFormat >= 6 ? '1.4' : '1.2');
+  const headerLength =
+    version === '1.5'
+      ? LAS_1_5_HEADER_LENGTH
+      : version === '1.4'
+        ? LAS_1_4_HEADER_LENGTH
+        : LAS_HEADER_LENGTH;
+  validateLASVersionOptions(version, pointDataRecordFormat, options);
+  const gpsTimeRange = getGpsTimeRange(gpsTimeAttribute, vertexCount);
+  if (version === '1.5' && options.las?.timeOffset && !gpsTimeAttribute) {
+    throw new Error('LASWriter: LAS 1.5 timeOffset requires a GPS time attribute');
+  }
+  if (format === 'laz') {
+    validateLAZOptions(version, pointDataRecordFormat, options.las?.chunkSize);
+  }
+  validatePointDataRecordVersion(version, pointDataRecordFormat);
+
+  const rawPointData = new Uint8Array(vertexCount * pointDataRecordLength);
+  const pointDataView = new DataView(rawPointData.buffer);
+
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    const pointOffset = vertexIndex * pointDataRecordLength;
+    pointDataView.setInt32(
+      pointOffset,
+      Math.round((getComponent(positionAttribute, vertexIndex, 0) - offset[0]) / scale[0]),
+      true
+    );
+    pointDataView.setInt32(
+      pointOffset + 4,
+      Math.round((getComponent(positionAttribute, vertexIndex, 1) - offset[1]) / scale[1]),
+      true
+    );
+    pointDataView.setInt32(
+      pointOffset + 8,
+      Math.round((getComponent(positionAttribute, vertexIndex, 2) - offset[2]) / scale[2]),
+      true
+    );
+    writePointRecord(
+      pointDataView,
+      pointOffset,
+      vertexIndex,
+      pointDataRecordFormat,
+      basePointDataRecordLength,
+      {
+        intensityAttribute,
+        classificationAttribute,
+        nirAttribute,
+        colorAttribute,
+        colorDepth,
+        gpsTimeAttribute,
+        scanAngleAttribute,
+        userDataAttribute,
+        pointSourceIdAttribute,
+        returnNumberAttribute,
+        numberOfReturnsAttribute,
+        scannerChannelAttribute,
+        scanDirectionFlagAttribute,
+        edgeOfFlightLineAttribute,
+        syntheticAttribute,
+        keyPointAttribute,
+        withheldAttribute,
+        overlapAttribute,
+        waveformDescriptorAttribute,
+        waveformOffsetAttribute,
+        waveformSizeAttribute,
+        waveformReturnPointAttribute,
+        waveformVectorAttribute,
+        extraByteFields
+      }
+    );
+  }
+
+  const writeParameters: LASWriteParameters = {
+    vertexCount,
+    boundingBox,
+    scale,
+    offset,
+    version,
+    headerLength,
+    pointDataRecordFormat,
+    pointDataRecordLength,
+    returnCounts,
+    maxGpsTime: gpsTimeRange.maximum,
+    minGpsTime: gpsTimeRange.minimum,
+    timeOffset: options.las?.timeOffset || 0,
+    hasGpsTime: Boolean(gpsTimeAttribute),
+    hasWkt: Boolean(options.las?.wkt)
+  };
+  if (format === 'laz') {
+    return encodeLAZFile(
+      rawPointData,
+      writeParameters,
+      options.las?.chunkSize,
+      options.las?.variableChunkTable,
+      extraByteFields,
+      options
+    );
+  }
+
+  const metadataVLR = encodeMetadataVLRs(extraByteFields, options);
+  const pointDataOffset = headerLength + metadataVLR.byteLength;
+  const arrayBuffer = new ArrayBuffer(pointDataOffset + rawPointData.byteLength);
+  writeHeader(new DataView(arrayBuffer), {
+    ...writeParameters,
+    pointDataOffset,
+    vlrCount: countMetadataVLRs(extraByteFields, options)
+  });
+  const bytes = new Uint8Array(arrayBuffer);
+  bytes.set(metadataVLR, headerLength);
+  bytes.set(rawPointData, pointDataOffset);
+  return arrayBuffer;
+}
+
+/** Validate that the selected LAS header can represent the point record format. */
+function validatePointDataRecordVersion(version: string, pointDataRecordFormat: number): void {
+  const minimumVersionByPointFormat: Record<number, string> = {
+    0: '1.0',
+    1: '1.1',
+    2: '1.2',
+    3: '1.2'
+  };
+  const minimumVersion = minimumVersionByPointFormat[pointDataRecordFormat];
+  if (minimumVersion && version < minimumVersion) {
+    throw new Error(
+      `LASWriter: point data record format ${pointDataRecordFormat} requires LAS ${minimumVersion} or newer; received ${version}`
+    );
+  }
+  if (
+    pointDataRecordFormat >= 4 &&
+    pointDataRecordFormat <= 5 &&
+    !['1.3', '1.4', '1.5'].includes(version)
+  ) {
+    throw new Error(
+      `LASWriter: point data record format ${pointDataRecordFormat} requires LAS 1.3; received ${version}`
+    );
+  }
+  if (pointDataRecordFormat >= 6 && !['1.4', '1.5'].includes(version)) {
+    throw new Error(
+      `LASWriter: point data record format ${pointDataRecordFormat} requires LAS 1.4; received ${version}`
+    );
+  }
+}
+
+/** Validate LAS 1.5 writer requirements before allocating point data. */
+function validateLASVersionOptions(
+  version: string,
+  pointDataRecordFormat: number,
+  options: LASWriterOptions
+): void {
+  if (version === '1.5') {
+    if (pointDataRecordFormat < 6 || pointDataRecordFormat > 10) {
+      throw new Error('LASWriter: LAS 1.5 output requires point data record format 6-10');
+    }
+    if (!options.las?.wkt?.trim()) {
+      throw new Error('LASWriter: LAS 1.5 output requires las.wkt');
+    }
+    const timeOffset = options.las?.timeOffset ?? 0;
+    if (!Number.isInteger(timeOffset) || timeOffset < 0 || timeOffset > 0xffff) {
+      throw new Error('LASWriter: LAS 1.5 timeOffset must be an unsigned 16-bit integer');
+    }
+  }
+}
+
+/** Values shared by LAS header and point-data encoding. */
+type LASWriteParameters = {
+  /** Number of point records in the output. */
+  vertexCount: number;
+  /** World-coordinate bounds. */
+  boundingBox: [[number, number, number], [number, number, number]];
+  /** Coordinate quantization scales. */
+  scale: [number, number, number];
+  /** Coordinate quantization offsets. */
+  offset: [number, number, number];
+  /** LAS file version. */
+  version: '1.0' | '1.1' | '1.2' | '1.3' | '1.4' | '1.5';
+  /** Public header byte length. */
+  headerLength: number;
+  /** LAS point data record format. */
+  pointDataRecordFormat: number;
+  /** Byte length of each raw point record. */
+  pointDataRecordLength: number;
+  /** Counts for the fifteen LAS 1.4 return-number buckets. */
+  returnCounts: number[];
+  /** LAS 1.5 maximum GPS time, or zero when no GPS time is present. */
+  maxGpsTime: number;
+  /** LAS 1.5 minimum GPS time, or zero when no GPS time is present. */
+  minGpsTime: number;
+  /** LAS 1.5 GPS time offset. */
+  timeOffset: number;
+  /** Whether the input contained a GPS time attribute. */
+  hasGpsTime: boolean;
+  /** Whether a WKT coordinate-system VLR is emitted. */
+  hasWkt: boolean;
+};
+
+/** Internal description of one encoded LAS Extra Bytes field. */
+type LASExtraByteField = LASExtraBytesWriter & {
+  /** Mesh attribute containing the field values. */
+  meshAttribute: MeshAttribute;
+  /** LAS Extra Bytes data type code. */
+  dataType: number;
+  /** Number of bytes occupied by one field value. */
+  byteLength: number;
+  /** Number of components in one field value. */
+  componentCount: number;
+};
+
+/** Assemble raw LAS point records into a complete fixed-chunk LAZ file. */
+function encodeLAZFile(
+  rawPointData: Uint8Array,
+  parameters: LASWriteParameters,
+  requestedChunkSize?: number,
+  variableChunkTable = false,
+  extraByteFields: LASExtraByteField[] = [],
+  options: LASWriterOptions = {}
+): ArrayBuffer {
+  const chunkSize = requestedChunkSize || DEFAULT_LAZ_CHUNK_SIZE;
+  const laszipVLR = encodeLASzipVLR({
+    pointDataRecordFormat: parameters.pointDataRecordFormat,
+    pointDataRecordLength: parameters.pointDataRecordLength,
+    chunkSize: variableChunkTable ? VARIABLE_LAZ_CHUNK_SIZE : chunkSize
+  });
+  const metadataVLR = encodeMetadataVLRs(extraByteFields, options);
+  const pointDataOffset = parameters.headerLength + metadataVLR.byteLength + laszipVLR.byteLength;
+  const compressedChunks: Uint8Array[] = [];
+  const chunkTableEntries: LAZChunkTableEntry[] = [];
+
+  for (let pointOffset = 0; pointOffset < parameters.vertexCount; pointOffset += chunkSize) {
+    const pointCount = Math.min(chunkSize, parameters.vertexCount - pointOffset);
+    const byteOffset = pointOffset * parameters.pointDataRecordLength;
+    const compressed = encodeLAZChunk(
+      rawPointData.subarray(byteOffset, byteOffset + pointCount * parameters.pointDataRecordLength),
+      {
+        pointDataRecordFormat: parameters.pointDataRecordFormat,
+        pointDataRecordLength: parameters.pointDataRecordLength,
+        pointCount,
+        point14ItemVersion: 3,
+        rgb14ItemVersion: 3,
+        byte14ItemVersion: 3
+      }
+    );
+    compressedChunks.push(compressed);
+    chunkTableEntries.push({pointCount, byteLength: compressed.byteLength});
+  }
+
+  const compressedPointDataByteLength = compressedChunks.reduce(
+    (byteLength, chunk) => byteLength + chunk.byteLength,
+    0
+  );
+  const chunkTablePayload = encodeLAZChunkTable(chunkTableEntries, {
+    variable: variableChunkTable
+  });
+  const chunkTableOffset = pointDataOffset + 8 + compressedPointDataByteLength;
+  const arrayBuffer = new ArrayBuffer(chunkTableOffset + 8 + chunkTablePayload.byteLength);
+  const bytes = new Uint8Array(arrayBuffer);
+  const dataView = new DataView(arrayBuffer);
+
+  writeHeader(dataView, {
+    ...parameters,
+    pointDataOffset,
+    vlrCount: countMetadataVLRs(extraByteFields, options) + 1,
+    compressed: true
+  });
+  bytes.set(metadataVLR, parameters.headerLength);
+  bytes.set(laszipVLR, parameters.headerLength + metadataVLR.byteLength);
+  writeUint64Fallback(dataView, pointDataOffset, chunkTableOffset);
+  let compressedOffset = pointDataOffset + 8;
+  for (const chunk of compressedChunks) {
+    bytes.set(chunk, compressedOffset);
+    compressedOffset += chunk.byteLength;
+  }
+  dataView.setUint32(chunkTableOffset, 0, true);
+  dataView.setUint32(chunkTableOffset + 4, chunkTableEntries.length, true);
+  bytes.set(chunkTablePayload, chunkTableOffset + 8);
+  return arrayBuffer;
+}
+
+/** Build validated Extra Bytes field descriptions from mesh attributes. */
+function getExtraByteFields(
+  mesh: Mesh,
+  options: LASWriterOptions,
+  vertexCount: number
+): LASExtraByteField[] {
+  const extraBytes = options.las?.extraBytes || [];
+  const attributes = new Set<string>();
+  return extraBytes.map(field => {
+    if (attributes.has(field.attribute)) {
+      throw new Error(`LASWriter: duplicate Extra Bytes attribute ${field.attribute}`);
+    }
+    attributes.add(field.attribute);
+    const meshAttribute = mesh.attributes[field.attribute];
+    if (!meshAttribute) {
+      throw new Error(`LASWriter: Extra Bytes attribute ${field.attribute} is missing`);
+    }
+    if (![1, 3].includes(meshAttribute.size)) {
+      throw new Error(`LASWriter: Extra Bytes attribute ${field.attribute} must have size 1 or 3`);
+    }
+    if (meshAttribute.value.length < vertexCount * meshAttribute.size) {
+      throw new Error(`LASWriter: Extra Bytes attribute ${field.attribute} is too short`);
+    }
+    validateFiniteAttributeValues(field.attribute, meshAttribute);
+    const dataType = getExtraBytesDataType(meshAttribute.value, meshAttribute.size);
+    return {
+      ...field,
+      meshAttribute,
+      dataType,
+      byteLength: getExtraBytesDataTypeByteLength(dataType, meshAttribute.size),
+      componentCount: meshAttribute.size
+    };
+  });
+}
+
+/** Return the LAS Extra Bytes data type code for a typed array and component count. */
+function getExtraBytesDataType(values: MeshAttribute['value'], componentCount: number): number {
+  let scalarDataType = 0;
+  if (values instanceof Uint8Array) scalarDataType = 1;
+  else if (values instanceof Int8Array) scalarDataType = 2;
+  else if (values instanceof Uint16Array) scalarDataType = 3;
+  else if (values instanceof Int16Array) scalarDataType = 4;
+  else if (values instanceof Uint32Array) scalarDataType = 5;
+  else if (values instanceof Int32Array) scalarDataType = 6;
+  else if (values instanceof BigUint64Array) scalarDataType = 7;
+  else if (values instanceof BigInt64Array) scalarDataType = 8;
+  else if (values instanceof Float32Array) scalarDataType = 9;
+  else if (values instanceof Float64Array) scalarDataType = 10;
+  if (scalarDataType) {
+    return scalarDataType + (componentCount === 3 ? 20 : 0);
+  }
+  throw new Error('LASWriter: Extra Bytes attributes require a supported typed array');
+}
+
+/** Return the byte width for a LAS Extra Bytes data type. */
+function getExtraBytesDataTypeByteLength(dataType: number, componentCount: number): number {
+  const scalarDataType = dataType > 20 ? dataType - 20 : dataType > 10 ? dataType - 10 : dataType;
+  const scalarByteLength =
+    scalarDataType <= 2
+      ? 1
+      : scalarDataType <= 4
+        ? 2
+        : scalarDataType <= 6 || scalarDataType === 9
+          ? 4
+          : 8;
+  return scalarByteLength * componentCount;
+}
+
+/** Encode the LAS Extra Bytes VLR, or an empty buffer when no fields are configured. */
+function encodeExtraBytesVLR(fields: readonly LASExtraByteField[]): Uint8Array {
+  if (fields.length === 0) {
+    return new Uint8Array(0);
+  }
+  const payload = new Uint8Array(fields.length * EXTRA_BYTES_DESCRIPTOR_LENGTH);
+  const dataView = new DataView(payload.buffer);
+  let byteOffset = 0;
+  for (const field of fields) {
+    dataView.setUint8(byteOffset + 2, field.dataType);
+    writeString(dataView, byteOffset + 4, field.name || field.attribute, 32);
+    writeString(dataView, byteOffset + 160, field.description || '', 32);
+    byteOffset += EXTRA_BYTES_DESCRIPTOR_LENGTH;
+  }
+  const bytes = new Uint8Array(VLR_HEADER_LENGTH + payload.byteLength);
+  const headerView = new DataView(bytes.buffer);
+  writeString(headerView, 2, 'LASF_Spec', 16);
+  headerView.setUint16(18, 4, true);
+  headerView.setUint16(20, payload.byteLength, true);
+  writeString(headerView, 22, 'Extra Bytes', 32);
+  bytes.set(payload, VLR_HEADER_LENGTH);
+  return bytes;
+}
+
+/** Encode projection and Extra Bytes VLRs in the order used by the public header. */
+function encodeMetadataVLRs(
+  fields: readonly LASExtraByteField[],
+  options: LASWriterOptions
+): Uint8Array {
+  const records: Uint8Array[] = [];
+  if (options.las?.wktMathTransform) {
+    records.push(encodeProjectionVLR(2111, 'WKT Math Transform', options.las.wktMathTransform));
+  }
+  if (options.las?.wkt) {
+    records.push(encodeProjectionVLR(2112, 'WKT Coordinate System', options.las.wkt));
+  }
+  const extraBytesVLR = encodeExtraBytesVLR(fields);
+  if (extraBytesVLR.byteLength) {
+    records.push(extraBytesVLR);
+  }
+  const byteLength = records.reduce((total, record) => total + record.byteLength, 0);
+  const bytes = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const record of records) {
+    bytes.set(record, offset);
+    offset += record.byteLength;
+  }
+  return bytes;
+}
+
+/** Encode one LAS WKT projection VLR. */
+function encodeProjectionVLR(recordId: 2111 | 2112, description: string, wkt: string): Uint8Array {
+  const payload = new TextEncoder().encode(`${wkt}\0`);
+  if (payload.byteLength > 0xffff) {
+    throw new Error(`LASWriter: WKT VLR ${recordId} exceeds the LAS VLR size limit`);
+  }
+  const bytes = new Uint8Array(VLR_HEADER_LENGTH + payload.byteLength);
+  const dataView = new DataView(bytes.buffer);
+  writeString(dataView, 2, 'LASF_Projection', 16);
+  dataView.setUint16(18, recordId, true);
+  dataView.setUint16(20, payload.byteLength, true);
+  writeString(dataView, 22, description, 32);
+  bytes.set(payload, VLR_HEADER_LENGTH);
+  return bytes;
+}
+
+/** Count the VLR records emitted by the metadata encoder. */
+function countMetadataVLRs(
+  fields: readonly LASExtraByteField[],
+  options: LASWriterOptions
+): number {
+  return (
+    (options.las?.wktMathTransform ? 1 : 0) + (options.las?.wkt ? 1 : 0) + (fields.length ? 1 : 0)
+  );
+}
+
+/** Return the finite GPS time range needed by the LAS 1.5 public header. */
+function getGpsTimeRange(
+  attribute: MeshAttribute | undefined,
+  vertexCount: number
+): {minimum: number; maximum: number} {
+  if (!attribute) {
+    return {minimum: 0, maximum: 0};
+  }
+  let minimum = Number(attribute.value[0]);
+  let maximum = minimum;
+  for (let vertexIndex = 1; vertexIndex < vertexCount; vertexIndex++) {
+    const value = Number(attribute.value[vertexIndex * attribute.size]);
+    minimum = Math.min(minimum, value);
+    maximum = Math.max(maximum, value);
+  }
+  return {minimum, maximum};
+}
+
+/** Validate that the Extra Bytes VLR payload fits its 16-bit length field. */
+function validateExtraBytesVLR(fields: readonly LASExtraByteField[]): void {
+  const payloadByteLength = fields.length * EXTRA_BYTES_DESCRIPTOR_LENGTH;
+  if (payloadByteLength > 0xffff) {
+    throw new Error(
+      `LASWriter: Extra Bytes VLR payload ${payloadByteLength} exceeds the LAS limit`
+    );
+  }
+}
+
+/** Validate the currently supported LAZ container writer surface. */
+function validateLAZOptions(
+  version: string,
+  pointDataRecordFormat: number,
+  chunkSize?: number
+): void {
+  if (pointDataRecordFormat === 1 && !['1.1', '1.2', '1.3', '1.4', '1.5'].includes(version)) {
+    throw new Error(`LASWriter: LAZ PDRF 1 output requires LAS 1.1 or newer; received ${version}`);
+  }
+  if (
+    pointDataRecordFormat >= 2 &&
+    pointDataRecordFormat <= 3 &&
+    !['1.2', '1.3', '1.4', '1.5'].includes(version)
+  ) {
+    throw new Error(
+      `LASWriter: LAZ PDRF ${pointDataRecordFormat} output requires LAS 1.2 or newer; received ${version}`
+    );
+  }
+  if (
+    pointDataRecordFormat >= 4 &&
+    pointDataRecordFormat <= 5 &&
+    !['1.3', '1.4', '1.5'].includes(version)
+  ) {
+    throw new Error(
+      `LASWriter: LAZ PDRF ${pointDataRecordFormat} requires LAS 1.3 or newer; received ${version}`
+    );
+  }
+  if (pointDataRecordFormat >= 6 && !['1.4', '1.5'].includes(version)) {
+    throw new Error(`LASWriter: LAZ output requires LAS 1.4; received ${version}`);
+  }
+  if (![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10].includes(pointDataRecordFormat)) {
+    throw new Error(
+      `LASWriter: LAZ output currently supports point data record formats 0-10; received ${pointDataRecordFormat}`
+    );
+  }
+  if (
+    chunkSize !== undefined &&
+    (!Number.isInteger(chunkSize) || chunkSize <= 0 || chunkSize > 0xffffffff)
+  ) {
+    throw new Error(`LASWriter: invalid LAZ chunk size ${chunkSize}`);
+  }
+}
+
+/** Return mesh data as a Mesh, converting MeshArrowTable input first. */
+function normalizeMesh(data: Mesh | MeshArrowTable): Mesh {
+  if ('shape' in data && data.shape === 'arrow-table') {
+    return convertTableToMesh(data);
+  }
+  return data as Mesh;
+}
+
+/** Return mesh data as a MeshArrowTable, converting plain Mesh data first. */
+function normalizeMeshArrowTable(data: Mesh | MeshArrowTable): MeshArrowTable {
+  return 'shape' in data && data.shape === 'arrow-table'
+    ? data
+    : convertMeshToTable(data as Mesh, 'arrow-table');
+}
+
+/** Merge buffered mesh batches for `encodeInBatches`. */
+function mergeMeshBatches(batches: (Mesh | MeshArrowTable)[]): Mesh | MeshArrowTable {
+  if (batches.length === 0) {
+    throw new Error('LASWriter: at least one input batch is required');
+  }
+  if (batches.length === 1) {
+    return batches[0];
+  }
+
+  const meshes = batches.map(batch => convertTableToMesh(normalizeMeshArrowTable(batch)));
+  const firstMesh = meshes[0];
+  const mergedAttributes: Mesh['attributes'] = {};
+
+  validateBatchAttributes(meshes);
+
+  for (const attributeName of Object.keys(firstMesh.attributes)) {
+    const firstAttribute = firstMesh.attributes[attributeName];
+    const values = meshes.map(mesh => mesh.attributes[attributeName]?.value);
+    if (values.some(value => !value)) {
+      continue;
+    }
+    const totalLength = values.reduce((length, value) => length + value!.length, 0);
+    const Constructor = firstAttribute.value.constructor as new (
+      length: number
+    ) => typeof firstAttribute.value;
+    const mergedValue = new Constructor(totalLength);
+    let offset = 0;
+    for (const value of values) {
+      mergedValue.set(value!, offset);
+      offset += value!.length;
+    }
+    mergedAttributes[attributeName] = {...firstAttribute, value: mergedValue};
+  }
+
+  return {
+    ...firstMesh,
+    attributes: mergedAttributes,
+    header: {
+      ...firstMesh.header,
+      vertexCount:
+        getRequiredAttribute({...firstMesh, attributes: mergedAttributes}, 'POSITION').value
+          .length / 3
+    }
+  };
+}
+
+/** Ensure batched meshes expose the same attributes and typed layouts. */
+function validateBatchAttributes(meshes: Mesh[]): void {
+  const attributeNames = Object.keys(meshes[0].attributes);
+  for (const mesh of meshes.slice(1)) {
+    const meshAttributeNames = Object.keys(mesh.attributes);
+    if (
+      meshAttributeNames.length !== attributeNames.length ||
+      attributeNames.some(attributeName => !mesh.attributes[attributeName])
+    ) {
+      throw new Error('LASWriter: encodeInBatches requires consistent attribute names');
+    }
+    for (const attributeName of attributeNames) {
+      const firstAttribute = meshes[0].attributes[attributeName];
+      const attribute = mesh.attributes[attributeName];
+      if (
+        attribute.size !== firstAttribute.size ||
+        attribute.value.constructor !== firstAttribute.value.constructor
+      ) {
+        throw new Error(`LASWriter: encodeInBatches requires a consistent ${attributeName} layout`);
+      }
+    }
+  }
+}
+
+/** Return a required mesh attribute or throw a format-specific error. */
+function getRequiredAttribute(mesh: Mesh, attributeName: string): MeshAttribute {
+  const attribute = mesh.attributes[attributeName];
+  if (!attribute) {
+    throw new Error(`LASWriter: ${attributeName} attribute is required`);
+  }
+  return attribute;
+}
+
+/** Validate the required LAS position attribute shape. */
+function validatePositionAttribute(attribute: MeshAttribute): void {
+  if (attribute.size !== 3) {
+    throw new Error(`LASWriter: POSITION attribute must have size 3`);
+  }
+  if (attribute.value.length % attribute.size !== 0) {
+    throw new Error(`LASWriter: POSITION attribute length must be divisible by its size`);
+  }
+}
+
+/** Validate coordinate quantization before writing LAS signed 32-bit coordinates. */
+function validateCoordinateEncoding(
+  attribute: MeshAttribute,
+  vertexCount: number,
+  scale: [number, number, number],
+  offset: [number, number, number]
+): void {
+  for (let componentIndex = 0; componentIndex < 3; componentIndex++) {
+    if (!Number.isFinite(scale[componentIndex]) || scale[componentIndex] <= 0) {
+      throw new Error(`LASWriter: coordinate scale must be finite and positive`);
+    }
+    if (!Number.isFinite(offset[componentIndex])) {
+      throw new Error(`LASWriter: coordinate offset must be finite`);
+    }
+  }
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    for (let componentIndex = 0; componentIndex < 3; componentIndex++) {
+      const positionValue = attribute.value[vertexIndex * attribute.size + componentIndex];
+      if (!Number.isFinite(positionValue)) {
+        throw new Error(`LASWriter: POSITION values must be finite`);
+      }
+      const encodedValue = Math.round(
+        (positionValue - offset[componentIndex]) / scale[componentIndex]
+      );
+      if (encodedValue < -2147483648 || encodedValue > 2147483647) {
+        throw new Error(`LASWriter: encoded coordinate exceeds the signed 32-bit LAS range`);
+      }
+    }
+  }
+}
+
+/** Validate lengths and component shapes for mapped optional point attributes. */
+function validateOptionalPointAttributes(mesh: Mesh, vertexCount: number): void {
+  const scalarAttributeNames = [
+    'intensity',
+    'classification',
+    'gpsTime',
+    'scanAngle',
+    'userData',
+    'pointSourceId',
+    'returnNumber',
+    'numberOfReturns',
+    'scannerChannel',
+    'scanDirectionFlag',
+    'edgeOfFlightLine',
+    'synthetic',
+    'keyPoint',
+    'withheld',
+    'overlap',
+    'nir',
+    'wavePacketDescriptorIndex',
+    'wavePacketOffset',
+    'wavePacketSize',
+    'wavePacketReturnPoint'
+  ];
+  for (const attributeName of scalarAttributeNames) {
+    const attribute = mesh.attributes[attributeName];
+    if (attribute) {
+      validateOptionalAttribute(attributeName, attribute, vertexCount, 1);
+    }
+  }
+  const colorAttribute = mesh.attributes.COLOR_0;
+  if (colorAttribute) {
+    validateOptionalAttribute('COLOR_0', colorAttribute, vertexCount, 3, false);
+  }
+  const waveformVectorAttribute = mesh.attributes.wavePacketVector;
+  if (waveformVectorAttribute) {
+    validateOptionalAttribute('wavePacketVector', waveformVectorAttribute, vertexCount, 3);
+  }
+}
+
+/** Validate return-number ranges against the selected LAS point-data format. */
+function validateReturnAttributes(
+  mesh: Mesh,
+  vertexCount: number,
+  pointDataRecordFormat: number
+): void {
+  const maximumReturnNumber = pointDataRecordFormat >= 6 ? 15 : 5;
+  const returnNumberAttribute = mesh.attributes.returnNumber;
+  const numberOfReturnsAttribute = mesh.attributes.numberOfReturns;
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    const returnNumber = getUInt8Attribute(returnNumberAttribute, vertexIndex, 1);
+    const numberOfReturns = getUInt8Attribute(numberOfReturnsAttribute, vertexIndex, 1);
+    if (returnNumber < 1 || returnNumber > maximumReturnNumber) {
+      throw new Error(
+        `LASWriter: returnNumber must be between 1 and ${maximumReturnNumber} for point data record format ${pointDataRecordFormat}`
+      );
+    }
+    if (numberOfReturns < 1 || numberOfReturns > maximumReturnNumber) {
+      throw new Error(
+        `LASWriter: numberOfReturns must be between 1 and ${maximumReturnNumber} for point data record format ${pointDataRecordFormat}`
+      );
+    }
+    if (returnNumber > numberOfReturns) {
+      throw new Error(`LASWriter: returnNumber cannot exceed numberOfReturns`);
+    }
+  }
+}
+
+/** Validate one optional mapped attribute against the point count. */
+function validateOptionalAttribute(
+  attributeName: string,
+  attribute: MeshAttribute,
+  vertexCount: number,
+  minimumSize: number,
+  requirePointCount = true
+): void {
+  if (minimumSize === 1 ? attribute.size !== 1 : attribute.size < minimumSize) {
+    throw new Error(`LASWriter: ${attributeName} attribute must have size ${minimumSize}`);
+  }
+  validateFiniteAttributeValues(attributeName, attribute);
+  if (requirePointCount && attribute.value.length < vertexCount * attribute.size) {
+    throw new Error(`LASWriter: ${attributeName} attribute is too short`);
+  }
+  if (!requirePointCount && attribute.value.length < attribute.size) {
+    throw new Error(`LASWriter: ${attributeName} attribute is too short`);
+  }
+}
+
+/** Reject NaN and infinite values before numeric LAS conversion. */
+function validateFiniteAttributeValues(attributeName: string, attribute: MeshAttribute): void {
+  for (const value of attribute.value) {
+    if (!Number.isFinite(Number(value))) {
+      throw new Error(`LASWriter: ${attributeName} attribute must contain finite values`);
+    }
+  }
+}
+
+/** Write the LAS 1.2 public header block. */
+function writeHeader(
+  dataView: DataView,
+  parameters: LASWriteParameters & {
+    /** Absolute point-data byte offset. */
+    pointDataOffset: number;
+    /** Number of VLR records before point data. */
+    vlrCount?: number;
+    /** Whether the point format byte carries the LASzip compression flag. */
+    compressed?: boolean;
+  }
+): void {
+  const [versionMajor, versionMinor] = parameters.version.split('.').map(Number);
+  writeString(dataView, 0, 'LASF', 4);
+  dataView.setUint8(24, versionMajor);
+  dataView.setUint8(25, versionMinor);
+  writeString(dataView, 26, 'loaders.gl', 32);
+  writeString(dataView, 58, 'loaders.gl', 32);
+  dataView.setUint16(94, parameters.headerLength, true);
+  dataView.setUint32(96, parameters.pointDataOffset, true);
+  dataView.setUint32(100, parameters.vlrCount || 0, true);
+  dataView.setUint8(104, parameters.pointDataRecordFormat | (parameters.compressed ? 0x80 : 0));
+  dataView.setUint16(105, parameters.pointDataRecordLength, true);
+  const isExtendedHeader = parameters.version === '1.4' || parameters.version === '1.5';
+  dataView.setUint32(107, isExtendedHeader ? 0 : parameters.vertexCount, true);
+  for (let returnIndex = 0; returnIndex < 5; returnIndex++) {
+    dataView.setUint32(
+      111 + returnIndex * 4,
+      isExtendedHeader ? 0 : parameters.returnCounts[returnIndex],
+      true
+    );
+  }
+
+  if (parameters.version === '1.5') {
+    // LAS 1.5 requires WKT and stores the time range in the extended header.
+    dataView.setUint16(
+      6,
+      0x10 | (parameters.hasGpsTime ? 1 : 0) | (parameters.timeOffset ? 0x40 : 0),
+      true
+    );
+  } else if (parameters.version === '1.4' && parameters.hasWkt) {
+    dataView.setUint16(6, 0x10, true);
+  }
+
+  dataView.setFloat64(131, parameters.scale[0], true);
+  dataView.setFloat64(139, parameters.scale[1], true);
+  dataView.setFloat64(147, parameters.scale[2], true);
+  dataView.setFloat64(155, parameters.offset[0], true);
+  dataView.setFloat64(163, parameters.offset[1], true);
+  dataView.setFloat64(171, parameters.offset[2], true);
+  dataView.setFloat64(179, parameters.boundingBox[1][0], true);
+  dataView.setFloat64(187, parameters.boundingBox[0][0], true);
+  dataView.setFloat64(195, parameters.boundingBox[1][1], true);
+  dataView.setFloat64(203, parameters.boundingBox[0][1], true);
+  dataView.setFloat64(211, parameters.boundingBox[1][2], true);
+  dataView.setFloat64(219, parameters.boundingBox[0][2], true);
+
+  if (isExtendedHeader) {
+    writeUint64Fallback(dataView, 247, parameters.vertexCount);
+    for (let returnIndex = 0; returnIndex < LAS_RETURN_BUCKET_COUNT; returnIndex++) {
+      writeUint64Fallback(dataView, 255 + returnIndex * 8, parameters.returnCounts[returnIndex]);
+    }
+  }
+  if (parameters.version === '1.5') {
+    dataView.setFloat64(375, parameters.maxGpsTime, true);
+    dataView.setFloat64(383, parameters.minGpsTime, true);
+    dataView.setUint16(391, parameters.timeOffset, true);
+  }
+}
+
+/** Write one LAS point record. */
+function writePointRecord(
+  dataView: DataView,
+  pointOffset: number,
+  vertexIndex: number,
+  pointDataRecordFormat: number,
+  basePointDataRecordLength: number,
+  attributes: {
+    intensityAttribute?: MeshAttribute;
+    classificationAttribute?: MeshAttribute;
+    nirAttribute?: MeshAttribute;
+    colorAttribute?: MeshAttribute;
+    /** Declared source RGB component depth. */
+    colorDepth?: number | string;
+    gpsTimeAttribute?: MeshAttribute;
+    scanAngleAttribute?: MeshAttribute;
+    userDataAttribute?: MeshAttribute;
+    pointSourceIdAttribute?: MeshAttribute;
+    returnNumberAttribute?: MeshAttribute;
+    numberOfReturnsAttribute?: MeshAttribute;
+    scannerChannelAttribute?: MeshAttribute;
+    scanDirectionFlagAttribute?: MeshAttribute;
+    edgeOfFlightLineAttribute?: MeshAttribute;
+    syntheticAttribute?: MeshAttribute;
+    keyPointAttribute?: MeshAttribute;
+    withheldAttribute?: MeshAttribute;
+    overlapAttribute?: MeshAttribute;
+    waveformDescriptorAttribute?: MeshAttribute;
+    waveformOffsetAttribute?: MeshAttribute;
+    waveformSizeAttribute?: MeshAttribute;
+    waveformReturnPointAttribute?: MeshAttribute;
+    waveformVectorAttribute?: MeshAttribute;
+    extraByteFields: readonly LASExtraByteField[];
+  }
+): void {
+  dataView.setUint16(
+    pointOffset + 12,
+    getUInt16Attribute(attributes.intensityAttribute, vertexIndex),
+    true
+  );
+
+  if (pointDataRecordFormat <= 5) {
+    const returnNumber = getUInt8Attribute(attributes.returnNumberAttribute, vertexIndex, 1) & 7;
+    const numberOfReturns =
+      getUInt8Attribute(attributes.numberOfReturnsAttribute, vertexIndex, 1) & 7;
+    dataView.setUint8(pointOffset + 14, returnNumber | (numberOfReturns << 3));
+    dataView.setUint8(
+      pointOffset + 15,
+      getUInt8Attribute(attributes.classificationAttribute, vertexIndex) & 0x1f
+    );
+    dataView.setInt8(
+      pointOffset + 16,
+      getInt16Attribute(attributes.scanAngleAttribute, vertexIndex)
+    );
+    dataView.setUint8(
+      pointOffset + 17,
+      getUInt8Attribute(attributes.userDataAttribute, vertexIndex)
+    );
+    dataView.setUint16(
+      pointOffset + 18,
+      getUInt16Attribute(attributes.pointSourceIdAttribute, vertexIndex),
+      true
+    );
+    if (pointDataRecordFormat === 1 || pointDataRecordFormat === 3 || pointDataRecordFormat >= 4) {
+      dataView.setFloat64(
+        pointOffset + 20,
+        getAttributeValue(attributes.gpsTimeAttribute, vertexIndex),
+        true
+      );
+    }
+    if (pointDataRecordFormat === 4 || pointDataRecordFormat === 5) {
+      const waveformOffset = pointDataRecordFormat === 4 ? 28 : 34;
+      writeWaveformPacket(dataView, pointOffset + waveformOffset, vertexIndex, attributes);
+    }
+  } else {
+    const returnNumber = getUInt8Attribute(attributes.returnNumberAttribute, vertexIndex, 1) & 0x0f;
+    const numberOfReturns =
+      getUInt8Attribute(attributes.numberOfReturnsAttribute, vertexIndex, 1) & 0x0f;
+    const scannerChannel = getUInt8Attribute(attributes.scannerChannelAttribute, vertexIndex) & 3;
+    const returnFlags = returnNumber | (numberOfReturns << 4);
+    const classificationFlags =
+      (getBooleanAttribute(attributes.syntheticAttribute, vertexIndex) ? 1 << 0 : 0) |
+      (getBooleanAttribute(attributes.keyPointAttribute, vertexIndex) ? 1 << 1 : 0) |
+      (getBooleanAttribute(attributes.withheldAttribute, vertexIndex) ? 1 << 2 : 0) |
+      (getBooleanAttribute(attributes.overlapAttribute, vertexIndex) ? 1 << 3 : 0) |
+      (scannerChannel << 4) |
+      (getBooleanAttribute(attributes.scanDirectionFlagAttribute, vertexIndex) ? 1 << 6 : 0) |
+      (getBooleanAttribute(attributes.edgeOfFlightLineAttribute, vertexIndex) ? 1 << 7 : 0);
+    dataView.setUint8(pointOffset + 14, returnFlags);
+    dataView.setUint8(pointOffset + 15, classificationFlags);
+    dataView.setUint8(
+      pointOffset + 16,
+      getUInt8Attribute(attributes.classificationAttribute, vertexIndex)
+    );
+    dataView.setUint8(
+      pointOffset + 17,
+      getUInt8Attribute(attributes.userDataAttribute, vertexIndex)
+    );
+    dataView.setInt16(
+      pointOffset + 18,
+      getInt16Attribute(attributes.scanAngleAttribute, vertexIndex),
+      true
+    );
+    dataView.setUint16(
+      pointOffset + 20,
+      getUInt16Attribute(attributes.pointSourceIdAttribute, vertexIndex),
+      true
+    );
+    dataView.setFloat64(
+      pointOffset + 22,
+      getAttributeValue(attributes.gpsTimeAttribute, vertexIndex),
+      true
+    );
+    if (pointDataRecordFormat === 9 || pointDataRecordFormat === 10) {
+      const waveformOffset = pointDataRecordFormat === 9 ? 30 : 38;
+      writeWaveformPacket(dataView, pointOffset + waveformOffset, vertexIndex, attributes);
+    }
+  }
+
+  writePointColor(
+    dataView,
+    pointOffset,
+    vertexIndex,
+    pointDataRecordFormat,
+    attributes.colorAttribute,
+    attributes.colorDepth
+  );
+  if (pointDataRecordFormat === 8 || pointDataRecordFormat === 10) {
+    dataView.setUint16(
+      pointOffset + 36,
+      getUInt16Attribute(attributes.nirAttribute, vertexIndex),
+      true
+    );
+  }
+  writeExtraBytes(
+    dataView,
+    pointOffset,
+    vertexIndex,
+    basePointDataRecordLength,
+    attributes.extraByteFields
+  );
+}
+
+/** Write one 29-byte LAS waveform packet reference. */
+function writeWaveformPacket(
+  dataView: DataView,
+  byteOffset: number,
+  vertexIndex: number,
+  attributes: {
+    waveformDescriptorAttribute?: MeshAttribute;
+    waveformOffsetAttribute?: MeshAttribute;
+    waveformSizeAttribute?: MeshAttribute;
+    waveformReturnPointAttribute?: MeshAttribute;
+    waveformVectorAttribute?: MeshAttribute;
+  }
+): void {
+  dataView.setUint8(
+    byteOffset,
+    getUInt8Attribute(attributes.waveformDescriptorAttribute, vertexIndex)
+  );
+  dataView.setBigUint64(
+    byteOffset + 1,
+    getBigUint64Attribute(attributes.waveformOffsetAttribute, vertexIndex),
+    true
+  );
+  dataView.setUint32(
+    byteOffset + 9,
+    getUInt32Attribute(attributes.waveformSizeAttribute, vertexIndex),
+    true
+  );
+  dataView.setFloat32(
+    byteOffset + 13,
+    getAttributeValue(attributes.waveformReturnPointAttribute, vertexIndex),
+    true
+  );
+  for (let componentIndex = 0; componentIndex < 3; componentIndex++) {
+    dataView.setFloat32(
+      byteOffset + 17 + componentIndex * 4,
+      getComponent(attributes.waveformVectorAttribute, vertexIndex, componentIndex),
+      true
+    );
+  }
+}
+
+/** Write configured Extra Bytes values into one raw LAS point record. */
+function writeExtraBytes(
+  dataView: DataView,
+  pointOffset: number,
+  vertexIndex: number,
+  basePointDataRecordLength: number,
+  fields: readonly LASExtraByteField[]
+): void {
+  let byteOffset = pointOffset + basePointDataRecordLength;
+  for (const field of fields) {
+    for (let componentIndex = 0; componentIndex < field.componentCount; componentIndex++) {
+      writeExtraBytesValue(dataView, byteOffset, vertexIndex, componentIndex, field);
+      byteOffset += field.byteLength / field.componentCount;
+    }
+  }
+}
+
+/** Write one typed Extra Bytes component using its LAS data type code. */
+function writeExtraBytesValue(
+  dataView: DataView,
+  byteOffset: number,
+  vertexIndex: number,
+  componentIndex: number,
+  field: LASExtraByteField
+): void {
+  const value = field.meshAttribute.value[vertexIndex * field.componentCount + componentIndex];
+  const scalarDataType =
+    field.dataType > 20
+      ? field.dataType - 20
+      : field.dataType > 10
+        ? field.dataType - 10
+        : field.dataType;
+  switch (scalarDataType) {
+    case 1:
+      dataView.setUint8(byteOffset, Number(value));
+      break;
+    case 2:
+      dataView.setInt8(byteOffset, Number(value));
+      break;
+    case 3:
+      dataView.setUint16(byteOffset, Number(value), true);
+      break;
+    case 4:
+      dataView.setInt16(byteOffset, Number(value), true);
+      break;
+    case 5:
+      dataView.setUint32(byteOffset, Number(value), true);
+      break;
+    case 6:
+      dataView.setInt32(byteOffset, Number(value), true);
+      break;
+    case 7:
+      dataView.setBigUint64(byteOffset, BigInt(value), true);
+      break;
+    case 8:
+      dataView.setBigInt64(byteOffset, BigInt(value), true);
+      break;
+    case 9:
+      dataView.setFloat32(byteOffset, Number(value), true);
+      break;
+    case 10:
+      dataView.setFloat64(byteOffset, Number(value), true);
+      break;
+    default:
+      throw new Error(`LASWriter: unsupported Extra Bytes data type ${field.dataType}`);
+  }
+}
+
+/** Write RGB values for point formats that include color. */
+function writePointColor(
+  dataView: DataView,
+  pointOffset: number,
+  vertexIndex: number,
+  pointDataRecordFormat: number,
+  colorAttribute?: MeshAttribute,
+  colorDepth?: number | string
+): void {
+  const colorOffset = getColorOffset(pointDataRecordFormat);
+  if (colorOffset < 0 || !colorAttribute) {
+    return;
+  }
+  dataView.setUint16(
+    pointOffset + colorOffset,
+    getLASColor(colorAttribute, vertexIndex, 0, colorDepth),
+    true
+  );
+  dataView.setUint16(
+    pointOffset + colorOffset + 2,
+    getLASColor(colorAttribute, vertexIndex, 1, colorDepth),
+    true
+  );
+  dataView.setUint16(
+    pointOffset + colorOffset + 4,
+    getLASColor(colorAttribute, vertexIndex, 2, colorDepth),
+    true
+  );
+}
+
+function getColorOffset(pointDataRecordFormat: number): number {
+  switch (pointDataRecordFormat) {
+    case 2:
+      return 20;
+    case 3:
+      return 28;
+    case 5:
+      return 57;
+    case 7:
+    case 8:
+    case 10:
+      return 30;
+    default:
+      return -1;
+  }
+}
+
+function getDefaultPointDataRecordFormat(
+  options: LASWriterOptions,
+  colorAttribute?: MeshAttribute
+): number {
+  if (options.las?.format === 'laz' || options.las?.version === '1.4') {
+    return colorAttribute ? 7 : 6;
+  }
+  return colorAttribute ? 2 : 0;
+}
+
+function writeUint64Fallback(dataView: DataView, byteOffset: number, value: number): void {
+  dataView.setUint32(byteOffset, value >>> 0, true);
+  dataView.setUint32(byteOffset + 4, Math.floor(value / 2 ** 32), true);
+}
+
+/** Write a fixed-length ASCII string into a DataView. */
+function writeString(
+  dataView: DataView,
+  byteOffset: number,
+  text: string,
+  byteLength: number
+): void {
+  if (/[^\x00-\x7f]/.test(text)) {
+    throw new Error('LASWriter fixed-width text must be ASCII');
+  }
+  for (let characterIndex = 0; characterIndex < byteLength; characterIndex++) {
+    dataView.setUint8(byteOffset + characterIndex, text.charCodeAt(characterIndex) || 0);
+  }
+}
+
+/** Return a single attribute component with 0 as the missing component fallback. */
+function getComponent(
+  attribute: MeshAttribute | undefined,
+  vertexIndex: number,
+  componentIndex: number
+): number {
+  return attribute ? attribute.value[vertexIndex * attribute.size + componentIndex] || 0 : 0;
+}
+
+/** Return a LAS UInt16 attribute value. */
+function getUInt16Attribute(attribute: MeshAttribute | undefined, vertexIndex: number): number {
+  return attribute
+    ? Math.max(0, Math.min(65535, Math.round(getComponent(attribute, vertexIndex, 0))))
+    : 0;
+}
+
+/** Return a LAS unsigned 32-bit attribute value. */
+function getUInt32Attribute(attribute: MeshAttribute | undefined, vertexIndex: number): number {
+  return attribute
+    ? Math.max(0, Math.min(0xffffffff, Math.round(getComponent(attribute, vertexIndex, 0))))
+    : 0;
+}
+
+/** Return a lossless unsigned 64-bit waveform offset attribute value. */
+function getBigUint64Attribute(attribute: MeshAttribute | undefined, vertexIndex: number): bigint {
+  if (!attribute) {
+    return 0n;
+  }
+  const value = attribute.value[vertexIndex * attribute.size];
+  return typeof value === 'bigint' ? value : BigInt(Math.max(0, Math.round(Number(value))));
+}
+
+/** Return a LAS UInt8 attribute value. */
+function getUInt8Attribute(
+  attribute: MeshAttribute | undefined,
+  vertexIndex: number,
+  defaultValue = 0
+): number {
+  return attribute
+    ? Math.max(0, Math.min(255, Math.round(getComponent(attribute, vertexIndex, 0))))
+    : defaultValue;
+}
+
+/** Return a LAS signed 16-bit attribute value. */
+function getInt16Attribute(attribute: MeshAttribute | undefined, vertexIndex: number): number {
+  return attribute
+    ? Math.max(-32768, Math.min(32767, Math.round(getComponent(attribute, vertexIndex, 0))))
+    : 0;
+}
+
+/** Return a numeric point attribute value, using zero when it is absent. */
+function getAttributeValue(attribute: MeshAttribute | undefined, vertexIndex: number): number {
+  return attribute ? getComponent(attribute, vertexIndex, 0) : 0;
+}
+
+/** Return a point flag attribute as a boolean. */
+function getBooleanAttribute(attribute: MeshAttribute | undefined, vertexIndex: number): boolean {
+  return Boolean(getAttributeValue(attribute, vertexIndex));
+}
+
+/** Count point records by return number for the LAS header histograms. */
+function getReturnCounts(
+  returnNumberAttribute: MeshAttribute | undefined,
+  vertexCount: number
+): number[] {
+  const returnCounts = new Array<number>(LAS_RETURN_BUCKET_COUNT).fill(0);
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    const returnNumber = getUInt8Attribute(returnNumberAttribute, vertexIndex, 1) & 0x0f;
+    if (returnNumber >= 1 && returnNumber <= LAS_RETURN_BUCKET_COUNT) {
+      returnCounts[returnNumber - 1]++;
+    }
+  }
+  return returnCounts;
+}
+
+/** Return one color component as a LAS UInt16 color value. */
+function getLASColor(
+  attribute: MeshAttribute,
+  vertexIndex: number,
+  componentIndex: number,
+  colorDepth?: number | string
+): number {
+  const value = getComponent(attribute, vertexIndex, componentIndex);
+  if (attribute.normalized) {
+    return scaleNormalizedColor(attribute, value);
+  }
+
+  if (colorDepth === 8) return clampUInt16(value * 257);
+  if (colorDepth === 16) return clampUInt16(value);
+
+  if (value <= 1) {
+    return clampUInt16(value * 65535);
+  }
+
+  if (value <= 255) {
+    return clampUInt16(value * 257);
+  }
+
+  return clampUInt16(value);
+}
+
+/** Return a normalized color component scaled to the LAS UInt16 color range. */
+function scaleNormalizedColor(attribute: MeshAttribute, value: number): number {
+  const componentMaximum = getComponentMaximum(attribute.value);
+  return clampUInt16((value / componentMaximum) * 65535);
+}
+
+/** Return the component maximum used by the color attribute's typed array. */
+function getComponentMaximum(values: MeshAttribute['value']): number {
+  if (values instanceof Uint8Array || values instanceof Uint8ClampedArray) {
+    return 255;
+  }
+  if (values instanceof Uint16Array) {
+    return 65535;
+  }
+  return 1;
+}
+
+/** Clamp a number to the LAS UInt16 range. */
+function clampUInt16(value: number): number {
+  return Math.max(0, Math.min(65535, Math.round(value)));
+}
+
+/** Compute position bounds, using a finite zero box when there are no points. */
+function getBoundingBox(
+  positionAttribute: MeshAttribute,
+  vertexCount: number
+): [[number, number, number], [number, number, number]] {
+  if (vertexCount === 0) {
+    return [
+      [0, 0, 0],
+      [0, 0, 0]
+    ];
+  }
+  const minimum: [number, number, number] = [
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY
+  ];
+  const maximum: [number, number, number] = [
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY
+  ];
+
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    for (let componentIndex = 0; componentIndex < 3; componentIndex++) {
+      const value = getComponent(positionAttribute, vertexIndex, componentIndex);
+      minimum[componentIndex] = Math.min(minimum[componentIndex], value);
+      maximum[componentIndex] = Math.max(maximum[componentIndex], value);
+    }
+  }
+
+  return [minimum, maximum];
+}
+
+/** Return LAS coordinate scale factors from options, metadata, or defaults. */
+function getScale(mesh: Mesh, options: LASWriterOptions): [number, number, number] {
+  return (
+    options.las?.scale || getNumericTuple(mesh.schema.metadata?.las_scale) || [0.001, 0.001, 0.001]
+  );
+}
+
+/** Return LAS coordinate offsets from options, metadata, or the mesh minimum position. */
+function getOffset(
+  mesh: Mesh,
+  options: LASWriterOptions,
+  boundingBox: [[number, number, number], [number, number, number]]
+): [number, number, number] {
+  return options.las?.offset || getNumericTuple(mesh.schema.metadata?.las_offset) || boundingBox[0];
+}
+
+/** Parse a three-number metadata tuple encoded as JSON. */
+function getNumericTuple(value: unknown): [number, number, number] | undefined {
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+
+  try {
+    const parsedValue = JSON.parse(value);
+    return Array.isArray(parsedValue) &&
+      parsedValue.length === 3 &&
+      parsedValue.every(component => typeof component === 'number')
+      ? [parsedValue[0], parsedValue[1], parsedValue[2]]
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}