las-laz-js 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## 0.4.0 (2026-10-22)
+
+Writes LAZ.
+
+- `writeLas(points, { compress: true })` and `createLasWriter(sink, { compress: true })` write LAZ:
+  point formats 0–3 (point-wise) and 6–8 (layered), with a LASzip VLR, 50,000-point chunks and a
+  chunk table, as PDAL (LAZperf) lays it out. Plain JavaScript, translated from laz-rs
+  (Apache-2.0), like the decoders. Formats 4, 5, 9, 10 cannot be compressed (`UNSUPPORTED`).
+- `chunkSize`: points per chunk, a whole number 1 to 4294967294 (default 50,000); ignored without
+  `compress`.
+- `threads`: chunks compress on the worker pool the LAZ reader uses, written in chunk order, so the
+  bytes are the same for any thread count. Automatic by default: from 4 chunks up, with at most 4
+  workers, as gains flatten after about 4 (explicit `threads` are honoured); `1` is the calling
+  thread. A 10 M-point LAZ (format 3) rewritten: `writeLas` 7166 ms on one thread, 1708 ms
+  automatic (4 workers, 4.2×), 1624 ms with 16; `createLasWriter` 7109 ms, 2033–2246 ms, 1657 ms.
+- With workers, up to about 2 tasks of 4 chunks per worker of records are in flight: about 55 MB
+  at the automatic 4 workers with 50,000-point format 3 chunks. That holds across awaited
+  `writePoints` calls; unawaited calls, or one huge batch, submit at once. An abandoned writer
+  keeps its workers until `close()`.
+- A streaming LAZ writer stops at its first error (a chunk, a sink write, `close()`):
+  `writePoints` and `close` keep rejecting. Start a new writer. After `close()`, both reject
+  (`ABORTED`).
+- The compressed bytes are PDAL's (LAZperf's) with one lossless exception: in formats 6–8 a GPS
+  time of −0 following +0 is coded as a change (LAZperf finds the doubles equal).
+- Extra bytes are not written yet (as for LAS); they arrive with 0.7.0.
+- Checked against PDAL 2.10: the committed fixtures' chunks, chunk tables and LASzip VLRs are
+  PDAL's bytes; PDAL reads what we write (`pdal info`, `pdal translate`) and finds the same points
+  field by field. Real files compress and read back to the same points: a 1.1 GB, 34-million-point
+  LAS streams to a 155 MB LAZ (0.14 of its size) in 6.4 s; a 10-million-point LAZ recompresses to
+  the same size in 2.7 s. That file, written by PDAL 1.6 in 2019, comes back as LAS 1.2 format 3 with
+  the original's point data byte for byte, and opens in CloudCompare as LAS 1.2 format 3 and as
+  LAS 1.4 format 7.
+- Docs: README "Writing LAZ"; the demo says LAZ is read and written.
+
+## 0.3.1 (2026-10-21)
+
+Worker fixes.
+
+- Node: a script that stopped part way through a parallel LAZ read (one `chunks()` window, then
+  done) never exited, because an idle pool kept Node running. Workers now hold Node only while
+  they have work.
+- Node: `node --input-type=module -e` scripts can decode in parallel. Workers used to inherit
+  `--input-type` and fail to start.
+- A worker that cannot start (blocked or failing script) now means one-thread decoding, as
+  documented, rather than a failed read. The pool waits for every worker to report ready.
+
 ## 0.3.0 (2026-10-21)
 
 Faster LAZ.

package/NOTICE

@@ -1,7 +1,7 @@
 las-laz-js
 Copyright (c) 2026 Brent Buffham (https://kirra-design.com). MIT licence (see LICENSE).
 
-The LAZ decoder in src/laz/ is a JavaScript translation of laz-rs
+The LAZ decoder and encoder in src/laz/ are a JavaScript translation of laz-rs
 (https://github.com/laz-rs/laz-rs), which is itself a Rust port of LASzip
 (https://laszip.org) by rapidlasso. Those files are licensed under the
 Apache License, Version 2.0 (see LICENSE-APACHE), not the MIT licence:

package/README.md

@@ -1,6 +1,6 @@
 # las-laz-js
 
-A JavaScript reader and writer for ASPRS **LAS** point clouds, and a reader for **LAZ**
+A JavaScript reader and writer for ASPRS **LAS** point clouds and **LAZ**
 (LASzip-compressed LAS), published on npm as `las-laz-js`. Plain ES modules, no dependencies,
 runs in the browser and in Node — and built for files far larger than memory.
 
@@ -8,15 +8,16 @@ runs in the browser and in Node — and built for files far larger than memory.
 
 - Working: `openLas` reads the header, VLRs / EVLRs and coordinate system of LAS 1.0–1.4;
   `readPoints` and `chunks` decode every point format (0–10) a window at a time, with filters
-  and thinning; `colourize` colours points; `writeLas` writes LAS 1.0–1.4.
-- LAZ: point formats 0–3 and 6–8, with extra bytes, read exactly like LAS — the same calls, the
-  same options, decoded chunk by chunk in plain JavaScript (no WebAssembly).
+  and thinning; `colourize` colours points; `writeLas` and `createLasWriter` write LAS 1.0–1.4.
+- LAZ: point formats 0–3 and 6–8, read exactly like LAS — the same calls, the same options,
+  decoded chunk by chunk in plain JavaScript (no WebAssembly) — and written with
+  `compress: true`, byte for byte what PDAL (LAZperf) writes (bar one lossless exception, see
+  Writing LAZ), compressed in parallel.
 - Big files: a 1.1 GB, 34-million-point LAS reads in under a second in Node, and a 10-million-point
   LAZ decodes on every core (a 10-million-point file in about 0.6 s); neither is held in memory
   whole (see LAZ below for the one exception).
 - Also: a ready-made module Worker (`las-laz-js/worker`) and a
   [Three.js demo](https://brentbuffham.github.io/las-laz-js/).
-- Not yet: writing LAZ (0.3.0).
 
 ## Install
 
@@ -135,6 +136,7 @@ import { writeLas, createLasWriter } from "las-laz-js";
 
 var bytes = await writeLas(pts, { version: "1.2", pointFormat: 3, crs: { epsg: 28350 } });
 var v14 = await writeLas(pts, { version: "1.4", pointFormat: 7, crs: { wkt: las.crs.wkt } });
+var laz = await writeLas(pts, { compress: true, pointFormat: 3 });   // LAZ
 
 var w = await createLasWriter(sink, { version: "1.2", pointFormat: 3, scale, offset });
 // sink: an OPFS writer from openScratchSyncWriter, a Node FileHandle, or any { write(bytes, position) }
@@ -146,7 +148,44 @@ A version and point format that do not go together (format 6 in LAS 1.2) are ref
 silently changed. Scale and offset are chosen from the bounds when not given. `crs.epsg`
 writes a GeoKey record; `crs.wkt` a WKT record. Point formats 6–10 must carry WKT (LAS 1.4), so
 an EPSG code alone is refused for them — the library has no projection database to turn a code
-into WKT. Writing LAZ arrives in 0.3.0.
+into WKT.
+
+| Option | Default | Meaning |
+|---|---|---|
+| `compress` | `false` | write LAZ (LASzip) instead of LAS: point formats 0–3 and 6–8; formats 4, 5, 9, 10 are refused (`UNSUPPORTED`) |
+| `chunkSize` | `50000` | points per LAZ chunk, a whole number from 1 to 4294967294; ignored without `compress` |
+| `threads` | automatic | workers that compress chunks: automatic by default (from 4 chunks up, at most 4 workers), `1` compresses on the calling thread, `n` asks for n workers; only with `compress` |
+
+### Writing LAZ
+
+`writeLas(pts, { compress: true })` and `createLasWriter(sink, { compress: true, ... })` write the
+same records as the LAS writers, compressed `chunkSize` points at a time (LASzip's 50,000 by
+default) behind a LASzip VLR, with the chunk table at the end of the point data. The layout and
+the compressed bytes are those PDAL (LAZperf) writes: for the same points, version, format, scale
+and offset, the point data is identical to PDAL's — with one exception: in formats 6–8 a GPS time
+of −0 following +0 is coded as a change, so it reads back as −0 (lossless), where LAZperf compares
+the doubles, finds them equal and writes no change. Point formats 0–3 are written point-wise
+(LASzip item version 2), 6–8 layered (item version 3).
+
+- **Speed.** Chunks are independent, so they compress on the same pool of workers that decode
+  LAZ, and are written strictly in chunk order: the bytes are the same for any `threads`. Gains
+  flatten after about four workers, so with `threads` automatic the writers use at most four (one
+  fewer than the cores, if that is less): a 10-million-point format 3 file writes in about 1.7 s
+  that way on a 24-core machine, 1.6 s with `threads: 16`, about 7 s on one thread. A write of
+  under four chunks (200,000 points) stays on one thread, where workers would cost more than they
+  save. If workers cannot start, it falls back to one thread.
+- **Memory.** With workers, up to about 2 tasks of 4 chunks per worker are in flight at once —
+  about 55 MB of records at the automatic four workers with 50,000-point format 3 chunks (about
+  220 MB at `threads: 16`). That bound holds across awaited `writePoints` calls; calls made
+  without waiting, or one huge batch, submit all at once. Pass a smaller `threads` or `chunkSize`
+  to bound it further. A writer that is abandoned without `close()` keeps its workers in a
+  browser until it is closed.
+- **Errors.** A streaming LAZ writer stops for good at its first error — in a chunk, in a sink
+  write or in `close()` — and `writePoints` and `close` keep rejecting with it. Start a new
+  writer. After a successful `close()`, both reject (`ABORTED`, "the LAZ writer is closed").
+- **Extra bytes** are not written (the writers have never written them): a file read with
+  extra bytes is written without them. They arrive with 0.7.0.
+- The streaming writer needs `scale` and `offset` up front, as for LAS.
 
 ## In a Worker
 
@@ -160,7 +199,7 @@ worker.postMessage({ id: 2, type: "chunks", payload: { fields: ["x", "y", "z"],
 The protocol is documented in `src/workers/workerProtocol.js` and can be driven directly with
 `createWorkerHandler(post)`.
 
-**Bundlers.** The worker entry and the LAZ decode workers are found through
+**Bundlers.** The worker entry and the LAZ decode and encode workers are found through
 `new Worker(new URL(..., import.meta.url))`, which Vite and webpack 5 follow. With Vite, keep the
 package out of dependency pre-bundling (`optimizeDeps: { exclude: ["las-laz-js"] }`), so the
 worker files stay next to the module that loads them.
@@ -182,11 +221,12 @@ COPC, EPT and E57 are not read.
 ## Provenance
 
 The LAS reader, writer and big-file handling come from [Kirra](https://kirra-design.com),
-Brent Buffham's blast-design app, rewritten as a standalone library. The LAZ decoder in
-`src/laz/` is a JavaScript translation of [laz-rs](https://github.com/laz-rs/laz-rs) by Thomas
+Brent Buffham's blast-design app, rewritten as a standalone library. The LAZ decoder and encoder in
+`src/laz/` are a JavaScript translation of [laz-rs](https://github.com/laz-rs/laz-rs) by Thomas
 Montaigu, itself a Rust port of [LASzip](https://laszip.org) by Martin Isenburg (rapidlasso).
-It is checked against an independent encoder: the test fixtures were compressed by
-[PDAL](https://pdal.io), and every record must equal PDAL's own decompression.
+It is checked against an independent implementation: the test fixtures were compressed by
+[PDAL](https://pdal.io), every record must equal PDAL's own decompression, and what this
+library compresses must equal PDAL's bytes and be read by PDAL.
 Formats are written to the ASPRS LAS 1.4 R15 specification; see `docs/LAS_FORMAT_NOTES.md`.
 
 ## Development
@@ -200,12 +240,14 @@ node _dev/makeLazFixtures.mjs   # remake test/fixtures/laz with PDAL (needs PDAL
 ```
 
 Private sample files go in the gitignored `samples/` folder, or are listed by path in
-`samples/paths.txt`; the sample tests compare each file with its own header, and each LAZ with a
-LAS twin (same count and bounds) field by field.
+`samples/paths.txt`; the sample tests compare each file with its own header, each LAZ with a
+LAS twin (same count and bounds) field by field, and compress each file to LAZ and read it back.
+Set `LAS_PDAL=<path to pdal>` to also have PDAL read what this library writes
+(`test/laz/pdalWrite.test.js` and the sample tests).
 
 ## Licence
 
-`MIT AND Apache-2.0`. The library is MIT © Brent Buffham (`LICENSE`). The LAZ decoder in
+`MIT AND Apache-2.0`. The library is MIT © Brent Buffham (`LICENSE`). The LAZ decoder and encoder in
 `src/laz/`, translated from laz-rs / LASzip, is under the Apache License 2.0 (`LICENSE-APACHE`,
 `NOTICE`). Both are permissive: use, change and ship it in open or closed software, keeping the
 notices.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "las-laz-js",
-	"version": "0.3.0",
-	"description": "Zero-dependency JavaScript reader and writer for ASPRS LAS point clouds, and reader for LAZ (LASzip), for the browser and Node, built for files larger than memory.",
+	"version": "0.4.0",
+	"description": "Zero-dependency JavaScript reader and writer for ASPRS LAS point clouds, and reader and writer for LAZ (LASzip), for the browser and Node, built for files larger than memory.",
 	"type": "module",
 	"exports": {
 		".": "./src/index.js",

package/src/index.js

@@ -6,7 +6,7 @@
 //==========================================================
 
 /** Library version, matches package.json. */
-export var VERSION = "0.3.0";
+export var VERSION = "0.4.0";
 
 export { LasError, ERROR_CODES } from "./errors.js";
 export { openLas, LasReader } from "./LasReader.js";

package/src/laz/ArithmeticEncoder.js

@@ -0,0 +1,123 @@
+// src/laz/ArithmeticEncoder.js
+//==========================================================
+// The LASzip arithmetic encoder, the writing half of ArithmeticDecoder:
+// whatever it writes, the decoder reads back exactly. Bytes go into a
+// growable Uint8Array (64 KiB to start, doubled when full); done()
+// flushes the coder and returns a copy of the bytes written. A carry out
+// of base walks back over those bytes, as laz-rs walks its buffer.
+//
+// Ported from laz-rs src/encoders.rs (https://github.com/laz-rs/laz-rs),
+// itself a port of LASzip by rapidlasso. (c) 2007-2014 martin isenburg,
+// rapidlasso; (c) 2014 Uday Verma, Hobu, Inc.; (c) 2019 Thomas Montaigu.
+// Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
+// NOTICE). Changes: translated from Rust to JavaScript, Brent Buffham 2026;
+// written into a growable byte array instead of laz-rs's ring buffer.
+// base and range are u32 in Numbers (no bit operators: sums and
+// products stay below 2^53 and wrap by subtraction or modulo).
+// The models are the library's (models.js): the encoder and decoder
+// must share them, as LASzip's do.
+//==========================================================
+
+var AC_MIN_LENGTH = 0x01000000;
+var FIRST_ALLOCATION = 65536;
+
+/** An arithmetic encoder over a growable byte buffer. */
+export function ArithmeticEncoder() {
+	this.buf = new Uint8Array(FIRST_ALLOCATION);
+	this.n = 0;   // bytes written
+	this.base = 0;
+	this.range = 0xFFFFFFFF;
+}
+
+ArithmeticEncoder.prototype._put = function (b) {
+	if (this.n === this.buf.length) {
+		var bigger = new Uint8Array(this.buf.length * 2);
+		bigger.set(this.buf);
+		this.buf = bigger;
+	}
+	this.buf[this.n++] = b;
+};
+
+/** Add one to the bytes already written (base overflowed 2^32). */
+ArithmeticEncoder.prototype._carry = function () {
+	var p = this.n - 1;
+	while (this.buf[p] === 0xFF) { this.buf[p] = 0; p--; }
+	this.buf[p]++;
+};
+
+ArithmeticEncoder.prototype._add = function (x) {
+	var b = this.base + x;
+	if (b >= 4294967296) { b -= 4294967296; this._carry(); }
+	this.base = b;
+};
+
+ArithmeticEncoder.prototype._renorm = function () {
+	do {
+		this._put(Math.floor(this.base / 16777216));
+		this.base = (this.base % 16777216) * 256;
+		this.range = (this.range * 256) % 4294967296;
+	} while (this.range < AC_MIN_LENGTH);
+};
+
+/** Encode one bit with an adaptive binary model. */
+ArithmeticEncoder.prototype.encodeBit = function (m, sym) {
+	var x = m.bit0Prob * Math.floor(this.range / 8192);   // BM_LENGTH_SHIFT
+	if (sym === 0) { this.range = x; m.bit0Count++; }
+	else { this._add(x); this.range -= x; }
+	if (this.range < AC_MIN_LENGTH) this._renorm();
+	if (--m.bitsUntilUpdate === 0) m.update();
+};
+
+/** Encode one symbol with an adaptive multi-symbol model. */
+ArithmeticEncoder.prototype.encodeSymbol = function (m, sym) {
+	var x;
+	if (sym === m.lastSymbol) {
+		x = m.distribution[sym] * Math.floor(this.range / 32768);   // DM_LENGTH_SHIFT
+		this._add(x);
+		this.range -= x;
+	} else {
+		this.range = Math.floor(this.range / 32768);
+		x = m.distribution[sym] * this.range;
+		this._add(x);
+		this.range = m.distribution[sym + 1] * this.range - x;
+	}
+	if (this.range < AC_MIN_LENGTH) this._renorm();
+	m.symbolCount[sym]++;
+	if (--m.symbolsUntilUpdate === 0) m.update();
+};
+
+/** `bits` raw bits (1-32) of an unsigned Number. */
+ArithmeticEncoder.prototype.writeBits = function (bits, sym) {
+	if (bits > 19) { this.writeShort(sym % 65536); sym = Math.floor(sym / 65536); bits -= 16; }
+	this.range = Math.floor(this.range / Math.pow(2, bits));
+	this._add(sym * this.range);
+	if (this.range < AC_MIN_LENGTH) this._renorm();
+};
+
+/** 16 raw bits. */
+ArithmeticEncoder.prototype.writeShort = function (sym) {
+	this.range = Math.floor(this.range / 65536);
+	this._add(sym * this.range);
+	if (this.range < AC_MIN_LENGTH) this._renorm();
+};
+
+/** 32 raw bits (low 16 first), from an unsigned Number. */
+ArithmeticEncoder.prototype.writeInt = function (sym) {
+	this.writeShort(sym % 65536);
+	this.writeShort(Math.floor(sym / 65536));
+};
+
+/**
+ * Flush the coder, as laz-rs done().
+ * @returns {Uint8Array} a copy of the bytes written (the encoder is finished)
+ */
+ArithmeticEncoder.prototype.done = function () {
+	var another = true;
+	if (this.range > 2 * AC_MIN_LENGTH) { this._add(AC_MIN_LENGTH); this.range = AC_MIN_LENGTH / 2; }
+	else { this._add(AC_MIN_LENGTH / 2); this.range = AC_MIN_LENGTH / 512; another = false; }
+	this._renorm();
+	this._put(0);
+	this._put(0);
+	if (another) this._put(0);
+	return this.buf.slice(0, this.n);
+};

package/src/laz/IntegerCompressor.js

@@ -0,0 +1,76 @@
+// src/laz/IntegerCompressor.js
+//==========================================================
+// LASzip's integer compressor, the writing half of IntegerDecompressor:
+// an integer is coded as a correction to a prediction — first k, the
+// bit length of the correction (one model per context), then the
+// correction's bits (modelled up to bitsHigh bits, raw above). The
+// correction wraps into the integer's range (i32 wrap for 32-bit
+// integers), so the decoder's wrap undoes it.
+//
+// Ported from laz-rs src/compressors.rs (https://github.com/laz-rs/laz-rs),
+// itself a port of LASzip by rapidlasso. (c) 2007-2014 martin isenburg,
+// rapidlasso; (c) 2014 Uday Verma, Hobu, Inc.; (c) 2019 Thomas Montaigu.
+// Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
+// NOTICE). Changes: translated from Rust to JavaScript, Brent Buffham 2026.
+//==========================================================
+
+import { ArithmeticModel, ArithmeticBitModel } from "./models.js";
+
+/**
+ * @param {number} [bits] - integer width (default 16; 32 wraps as i32)
+ * @param {number} [contexts] - number of k models (default 1)
+ * @param {number} [bitsHigh] - correction bits that are modelled (default 8)
+ * (laz-rs also takes an explicit range; no LAZ item uses one, so it is left out)
+ */
+export function IntegerCompressor(bits, contexts, bitsHigh) {
+	bits = bits === undefined ? 16 : bits;
+	this.contexts = contexts === undefined ? 1 : contexts;
+	this.bitsHigh = bitsHigh === undefined ? 8 : bitsHigh;
+	if (bits && bits < 32) {
+		this.corrBits = bits;
+		this.corrRange = Math.pow(2, bits);
+		this.corrMin = -this.corrRange / 2;
+		this.corrMax = this.corrMin + this.corrRange - 1;
+	} else {
+		this.corrBits = 32;
+		this.corrRange = 0;
+		this.corrMin = -2147483648;
+		this.corrMax = 2147483647;
+	}
+	this.k = 0;   // bit length of the last correction, as IntegerDecompressor.k
+	this.mBits = [];
+	for (var c = 0; c < this.contexts; c++) this.mBits.push(new ArithmeticModel(this.corrBits + 1));
+	this.mCorrector0 = new ArithmeticBitModel();
+	this.mCorrector = [];
+	for (var i = 1; i <= this.corrBits; i++) this.mCorrector.push(new ArithmeticModel(Math.pow(2, i <= this.bitsHigh ? i : this.bitsHigh)));
+}
+
+/**
+ * @param {import("./ArithmeticEncoder.js").ArithmeticEncoder} enc
+ * @param {number} pred - the prediction (i32)
+ * @param {number} real - the integer to write
+ * @param {number} context
+ */
+IntegerCompressor.prototype.compress = function (enc, pred, real, context) {
+	var corr = (real - pred) | 0;   // i32 wrapping_sub
+	if (corr < this.corrMin) corr += this.corrRange;
+	else if (corr > this.corrMax) corr -= this.corrRange;
+	var c1 = corr <= 0 ? -corr : corr - 1, k = 0;
+	while (c1 >= 1) { c1 = Math.floor(c1 / 2); k++; }
+	this.k = k;
+	enc.encodeSymbol(this.mBits[context], k);
+	if (k !== 0) {
+		if (k < 32) {
+			var c = corr >= 0 ? corr - 1 : corr + Math.pow(2, k) - 1;
+			if (k <= this.bitsHigh) {
+				enc.encodeSymbol(this.mCorrector[k - 1], c);
+			} else {
+				var k1 = k - this.bitsHigh, low = c % Math.pow(2, k1);
+				enc.encodeSymbol(this.mCorrector[k - 1], Math.floor(c / Math.pow(2, k1)));
+				enc.writeBits(k1, low);
+			}
+		}
+	} else {
+		enc.encodeBit(this.mCorrector0, corr);
+	}
+};

package/src/laz/LazVlr.js

@@ -12,10 +12,12 @@
 // rapidlasso; (c) 2019-2023 Thomas Montaigu.
 // Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
 // NOTICE). Changes: written
-// in JavaScript from that layout, Brent Buffham 2026.
+// in JavaScript from that layout; lazVlrFor (the writing half) added,
+// Brent Buffham 2026.
 //==========================================================
 
 import { LasError, ERROR_CODES } from "../errors.js";
+import { POINT_FORMATS } from "../format/PointFormats.js";
 
 /** LASzip compressor kinds. */
 export var COMPRESSOR = Object.freeze({ NONE: 0, POINTWISE: 1, POINTWISE_CHUNKED: 2, LAYERED_CHUNKED: 3 });
@@ -63,3 +65,63 @@ export function findLazVlr(vlrs) {
 	}
 	return null;
 }
+
+// The items of each writable point format as [type, size, version]; the
+// extra-bytes item (Byte / Byte14) follows when the record is longer
+var FORMAT_ITEMS = {
+	0: [[ITEM.POINT10, 20, 2]],
+	1: [[ITEM.POINT10, 20, 2], [ITEM.GPSTIME11, 8, 2]],
+	2: [[ITEM.POINT10, 20, 2], [ITEM.RGB12, 6, 2]],
+	3: [[ITEM.POINT10, 20, 2], [ITEM.GPSTIME11, 8, 2], [ITEM.RGB12, 6, 2]],
+	6: [[ITEM.POINT14, 30, 3]],
+	7: [[ITEM.POINT14, 30, 3], [ITEM.RGB14, 6, 3]],
+	8: [[ITEM.POINT14, 30, 3], [ITEM.RGBNIR14, 8, 3]]
+};
+
+/**
+ * The LASzip VLR a writer puts in a file: compressor 2 (formats 0-3) or 3 (6-8),
+ * LASzip 3.4 r3, chunked.
+ * @param {number} pointFormat - 0-3 or 6-8 (4, 5, 9, 10 carry waveform or 1.3 items that are not written)
+ * @param {number} recordLength - the file's point record length
+ * @param {number} chunkSize - points per chunk
+ * @returns {{vlr: object, bytes: Uint8Array}} vlr has the parseLazVlr shape; bytes is its 34 + 6 * items payload
+ */
+export function lazVlrFor(pointFormat, recordLength, chunkSize) {
+	var layered = pointFormat >= 6;
+	if (!FORMAT_ITEMS[pointFormat]) {
+		throw new LasError(ERROR_CODES.UNSUPPORTED, "LAZ compression of point format " + pointFormat + " is not written (formats 0-3 and 6-8 only)");
+	}
+	var extra = recordLength - POINT_FORMATS[pointFormat].size;
+	if (!(extra >= 0 && extra <= 0xFFFF)) {
+		throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "record length " + recordLength + " does not fit point format " + pointFormat + " (" + POINT_FORMATS[pointFormat].size + " bytes)");
+	}
+	var items = FORMAT_ITEMS[pointFormat].map(function (it) {
+		return { type: it[0], size: it[1], version: it[2] };
+	});
+	if (extra > 0) items.push({ type: layered ? ITEM.BYTE14 : ITEM.BYTE, size: extra, version: layered ? 3 : 2 });
+	var vlr = {
+		compressor: layered ? COMPRESSOR.LAYERED_CHUNKED : COMPRESSOR.POINTWISE_CHUNKED,
+		coder: 0,
+		version: { major: 3, minor: 4, revision: 3 },
+		options: 0,
+		chunkSize: chunkSize,
+		variableChunks: false,
+		items: items
+	};
+	var bytes = new Uint8Array(34 + 6 * items.length), v = new DataView(bytes.buffer);
+	v.setUint16(0, vlr.compressor, true);
+	v.setUint16(2, 0, true);
+	v.setUint8(4, 3);
+	v.setUint8(5, 4);
+	v.setUint16(6, 3, true);
+	v.setUint32(8, 0, true);
+	v.setUint32(12, chunkSize, true);
+	for (var at = 16; at < 32; at += 4) v.setUint32(at, 0xFFFFFFFF, true);   // no special EVLRs: count -1, offset -1 (two i64)
+	v.setUint16(32, items.length, true);
+	items.forEach(function (it, i) {
+		v.setUint16(34 + i * 6, it.type, true);
+		v.setUint16(36 + i * 6, it.size, true);
+		v.setUint16(38 + i * 6, it.version, true);
+	});
+	return { vlr: vlr, bytes: bytes };
+}