las-laz-js 0.2.0 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 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.
+
+- LAZ chunks decode in parallel on a pool of workers (browser Workers, Node worker_threads; one
+  fewer than the cores, at most 16), with the next window decoding while the current one becomes
+  columns. A 10-million-point LAZ reads in about 0.6 s (3.9 s on one thread); a 1.2 GB,
+  160-million-point LAZ in about 12 s (102 s in 0.2.0). Output is identical.
+- `openLas(src, { threads })`: automatic by default (used from 4 chunks up); `threads: 1` decodes
+  on the calling thread. Falls back to one thread when workers cannot start.
+- The decoder's hot loop does less: about 30% faster on one thread, same results.
+- Demo: decodes in the background with a progress bar, then shows the cloud once; colour, ramp
+  and range recolour the points already read instead of reading the file again.
+
 ## 0.2.0 (2026-10-21)
 
 Reads LAZ.

package/README.md

@@ -12,8 +12,8 @@ runs in the browser and in Node — and built for files far larger than memory.
 - 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).
 - Big files: a 1.1 GB, 34-million-point LAS reads in under a second in Node, and a 10-million-point
-  LAZ decodes at about 1.8 million points a second; neither is held in memory whole (see LAZ below
-  for the one exception).
+  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).
@@ -30,8 +30,9 @@ Node 22 or newer, or any current browser. No dependencies.
 
 Try it in the browser: **https://brentbuffham.github.io/las-laz-js/**
 
-Drop a LAS or LAZ file onto the page. It is read locally (never uploaded), in the library's
-Worker, and streamed into a Three.js viewer. The side panel shows the header, VLRs, coordinate
+Drop a LAS or LAZ file onto the page. It is read locally (never uploaded), decoded in the
+library's Worker (LAZ on every core) behind a progress bar, then shown once in a Three.js viewer;
+colour changes recolour the points already read, without reading the file again. The side panel shows the header, VLRs, coordinate
 system and LAZ compression; reads with class, return, bounds, thinning and dedupe filters;
 colours by RGB, intensity, elevation or class; lists point statistics; and saves the points back
 out as LAS. To run it locally: `npm run demo`, then open http://localhost:8080/.
@@ -89,6 +90,13 @@ reading the LAS it was compressed from.
   naming what it found — never garbage points.
 - A LAZ file cut short is `TRUNCATED`.
 
+**Speed.** LAZ chunks are independent, so they are decoded on a pool of workers — browser
+`Worker`s or Node `worker_threads`, one fewer than the cores (at most 16) — while the next window
+is already decoding. A 10-million-point LAZ reads in about 0.6 s on a 24-core machine (about 4 s
+on one core). Files under four chunks (200,000 points) stay on one thread, where starting workers
+would cost more than it saves. `openLas(file, { threads: 1 })` decodes on the calling thread;
+`threads: n` asks for n workers. If workers cannot start, it falls back to one thread.
+
 ## Files bigger than memory
 
 `openLas` reads only the header and the VLRs. Points are read in windows (64 MiB of records by
@@ -152,6 +160,11 @@ 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
+`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.
+
 ## Errors
 
 Every failure is a `LasError` with a stable `code` (`ERROR_CODES`) and, for byte-level problems,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "las-laz-js",
-	"version": "0.2.0",
+	"version": "0.3.1",
 	"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.",
 	"type": "module",
 	"exports": {

package/src/LasReader.js

@@ -22,11 +22,13 @@ import { windows, lazWindows } from "./read/windows.js";
 import { findLazVlr } from "./laz/LazVlr.js";
 import { readChunks } from "./laz/chunkTable.js";
 import { createChunkDecoder } from "./laz/decompressChunk.js";
+import { createLazPool, defaultThreads } from "./laz/pool.js";
 import { makeKeep, countKept } from "./filter/filters.js";
 import { dedupe } from "./filter/dedupe.js";
 import { openScratchSyncWriter } from "./io/ScratchBinaryFile.js";
 
 var DEFAULT_WINDOW = 64 * 1024 * 1024;
+var AUTO_MIN_CHUNKS = 4;
 
 function memorySource(bytes) {
 	return { size: bytes.length, read: async function (a, b) {
@@ -62,7 +64,8 @@ async function toSource(source) {
 /**
  * Open a LAS (or LAZ) file and read its header and VLRs.
  * @param {*} source
- * @param {{windowSize?: number}} [opts]
+ * @param {{windowSize?: number, threads?: number}} [opts] - threads: LAZ decode workers
+ *   (default automatic: cores - 1, at most 16; 1 = decode on this thread)
  * @returns {Promise<LasReader>}
  */
 export async function openLas(source, opts) {
@@ -79,7 +82,9 @@ export async function openLas(source, opts) {
 	if (header.numberOfEvlrs > 0 && header.evlrStart > 0 && header.evlrStart < src.size) {
 		evlrs = await walkEvlrs(src, header.evlrStart, header.numberOfEvlrs);
 	}
-	return new LasReader(src, header, vlrs, evlrs, (opts && opts.windowSize) || DEFAULT_WINDOW);
+	var reader = new LasReader(src, header, vlrs, evlrs, (opts && opts.windowSize) || DEFAULT_WINDOW);
+	reader._threads = opts && opts.threads > 0 ? Math.floor(opts.threads) : 0;   // 0 = automatic
+	return reader;
 }
 
 // EVLRs sit after the points and can be huge (waveform data): read each
@@ -153,7 +158,19 @@ LasReader.prototype._plan = async function () {
 				var view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
 				win.chunks.forEach(function (c) { decode(packed, c.start - win.start, c.end - win.start, c.count, view, (c.firstRecord - win.firstRecord) * len, win.start); });
 				return buf.subarray(0, win.count * len);
-			}
+			},
+			// The same records, each chunk decoded by a pool worker from its own copy of the bytes
+			parallel: async function (win, pool) {
+				var packed = await src.read(win.start, win.end);
+				var out = new Uint8Array(win.count * len);
+				await Promise.all(win.chunks.map(function (c) {
+					var piece = packed.slice(c.start - win.start, c.end - win.start);
+					return pool.decode({ vlr: vlr, recordLength: len, packed: piece.buffer, chunks: [{ s: 0, e: piece.length, count: c.count }], base: c.start })
+						.then(function (rec) { out.set(rec, (c.firstRecord - win.firstRecord) * len); });
+				}));
+				return out;
+			},
+			chunkCount: lazList.reduce(function (n, w) { return n + w.chunks.length; }, 0)
 		};
 	}
 	this._planned = plan;
@@ -179,32 +196,62 @@ LasReader.prototype._scan = async function* (opts, into) {
 	var keep = makeKeep(opts, h);
 	var fields = resolveFields(h, opts.fields);
 	var list = plan.list;
-	var buf = plan.bufferSize ? new Uint8Array(plan.bufferSize) : null;
-	var thin = null;
-	if (opts.maxPoints > 0) {
-		// Thin the points that pass the filters; with filters set, count them first (a second read)
-		var passing = keep ? await this._countPassing(plan, buf, keep, opts.signal) : h.pointCount;
-		if (passing > opts.maxPoints) thin = { total: passing, target: opts.maxPoints, acc: 0 };
-	}
-	var kept = 0;
-	for (var w = 0; w < list.length; w++) {
+	var pool = await this._pool(plan);
+	try {
+		var buf = !pool && plan.bufferSize ? new Uint8Array(plan.bufferSize) : null;
+		var thin = null;
+		if (opts.maxPoints > 0) {
+			// Thin the points that pass the filters; with filters set, count them first (a second read)
+			var passing = keep ? await this._countPassing(plan, pool, buf, keep, opts.signal) : h.pointCount;
+			if (passing > opts.maxPoints) thin = { total: passing, target: opts.maxPoints, acc: 0 };
+		}
+		var kept = 0, w = 0;
+		for await (var bytes of windowBytes(plan, pool, buf, opts.signal)) {
+			var win = list[w];
+			var cols = decodeRecords(bytes, h, { fields: fields, keep: keep, thin: thin, localOrigin: opts.localOrigin, float32: opts.float32, into: into ? into(win) : null });
+			kept += cols.count;
+			w++;
+			if (typeof opts.onProgress === "function") opts.onProgress(w / list.length, "read " + kept + " points");
+			yield cols;
+		}
 		if (opts.signal && opts.signal.aborted) throw new LasError(ERROR_CODES.ABORTED, "read aborted");
-		var win = list[w];
-		var bytes = await plan.records(win, buf);
-		var cols = decodeRecords(bytes, h, { fields: fields, keep: keep, thin: thin, localOrigin: opts.localOrigin, float32: opts.float32, into: into ? into(win) : null });
-		kept += cols.count;
-		if (typeof opts.onProgress === "function") opts.onProgress((w + 1) / list.length, "read " + kept + " points");
-		yield cols;
+	} finally {
+		if (pool) pool.close();
 	}
-	if (opts.signal && opts.signal.aborted) throw new LasError(ERROR_CODES.ABORTED, "read aborted");
 };
 
-LasReader.prototype._countPassing = async function (plan, buf, keep, signal) {
-	var n = 0;
-	for (var w = 0; w < plan.list.length; w++) {
+// Each window's raw records in order. With a pool the next window is already
+// decoding while this one is used; without one, one buffer is reused.
+async function* windowBytes(plan, pool, buf, signal) {
+	var list = plan.list;
+	function fetch(i) {
+		var p = plan.parallel(list[i], pool);
+		p.catch(function () {});                 // a prefetch abandoned by an abort must not go unhandled
+		return p;
+	}
+	var next = pool && list.length ? fetch(0) : null;
+	for (var w = 0; w < list.length; w++) {
 		if (signal && signal.aborted) throw new LasError(ERROR_CODES.ABORTED, "read aborted");
-		n += countKept(await plan.records(plan.list[w], buf), this.header.recordLength, keep);
+		if (!pool) { yield await plan.records(list[w], buf); continue; }
+		var current = next;
+		next = w + 1 < list.length ? fetch(w + 1) : null;
+		yield await current;
 	}
+}
+
+// A decode pool for this scan, or null: LAS, threads: 1, one chunk, or no workers available
+LasReader.prototype._pool = async function (plan) {
+	if (!plan.parallel || this._threads === 1) return null;
+	// automatic: only when there is enough to share (starting workers costs about as much as
+	// decoding a few chunks); an explicit thread count is always honoured
+	if (!this._threads && plan.chunkCount < AUTO_MIN_CHUNKS) return null;
+	var n = Math.min(this._threads || await defaultThreads(), plan.chunkCount);
+	return n >= 2 ? createLazPool(n) : null;
+};
+
+LasReader.prototype._countPassing = async function (plan, pool, buf, keep, signal) {
+	var n = 0;
+	for await (var bytes of windowBytes(plan, pool, buf, signal)) n += countKept(bytes, this.header.recordLength, keep);
 	return n;
 };
 

package/src/index.js

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

package/src/laz/ArithmeticDecoder.js

@@ -77,7 +77,7 @@ ArithmeticDecoder.prototype.decodeSymbol = function (m) {
 	if (m.decoderTable) {
 		this.range = this.range >>> 15;   // DM_LENGTH_SHIFT
 		if (this.range === 0) throw new LasError(ERROR_CODES.TRUNCATED, "corrupt LAZ stream (zero interval)", this.base + this.p);
-		var dv = Math.floor(this.value / this.range);
+		var dv = (this.value / this.range) >>> 0;   // both u32: truncation = floor
 		var t = dv >>> m.tableShift;
 		sym = m.decoderTable[t];
 		n = m.decoderTable[t + 1] + 1;
@@ -114,7 +114,7 @@ ArithmeticDecoder.prototype.readBits = function (bits) {
 		return this.readBits(bits - 16) * 65536 + low;
 	}
 	this.range = this.range >>> bits;
-	var sym = Math.floor(this.value / this.range);
+	var sym = (this.value / this.range) >>> 0;
 	this.value -= this.range * sym;
 	if (this.range < AC_MIN_LENGTH) this._renorm();
 	return sym;
@@ -123,7 +123,7 @@ ArithmeticDecoder.prototype.readBits = function (bits) {
 /** 16 raw bits. */
 ArithmeticDecoder.prototype.readShort = function () {
 	this.range = this.range >>> 16;
-	var sym = Math.floor(this.value / this.range);
+	var sym = (this.value / this.range) >>> 0;
 	this.value -= this.range * sym;
 	if (this.range < AC_MIN_LENGTH) this._renorm();
 	return sym;

package/src/laz/IntegerDecompressor.js

@@ -15,6 +15,10 @@
 
 import { ArithmeticModel, ArithmeticBitModel } from "./models.js";
 
+// 2^0 .. 2^32, exact in Numbers (the hot loop needs them per integer)
+var POW2 = new Float64Array(33);
+for (var p2 = 0; p2 <= 32; p2++) POW2[p2] = Math.pow(2, p2);
+
 /**
  * @param {number} [bits] - integer width (default 16; 32 wraps as i32)
  * @param {number} [contexts] - number of k models (default 1)
@@ -60,10 +64,10 @@ IntegerDecompressor.prototype.decompress = function (dec, pred, context) {
 				c = dec.decodeSymbol(this.mCorrector[k - 1]);
 			} else {
 				var k1 = k - this.bitsHigh;
-				c = dec.decodeSymbol(this.mCorrector[k - 1]) * Math.pow(2, k1) + dec.readBits(k1);
+				c = dec.decodeSymbol(this.mCorrector[k - 1]) * POW2[k1] + dec.readBits(k1);
 			}
-			if (c >= Math.pow(2, k - 1)) c += 1;
-			else c -= Math.pow(2, k) - 1;
+			if (c >= POW2[k - 1]) c += 1;
+			else c -= POW2[k] - 1;
 		} else {
 			c = this.corrMin;
 		}

package/src/laz/chunkWorker.js

@@ -0,0 +1,53 @@
+// src/laz/chunkWorker.js
+//==========================================================
+// Worker entry for parallel LAZ decoding (src/laz/pool.js): decodes
+// whole chunks into raw LAS records and sends them back (transferred).
+// Runs as a browser module Worker or a Node worker_threads Worker.
+// In:  { id, vlr, recordLength, packed: ArrayBuffer, chunks: [{ s, e, count }], base }
+//      (s / e index into packed; base is packed's file offset)
+// Out: { ready: true } once listening, then per task
+//      { id, records: ArrayBuffer } or { id, error: { code, message, offset } }
+//
+// Uses the chunk decoder translated from laz-rs (https://github.com/laz-rs/laz-rs),
+// itself a port of LASzip by rapidlasso. (c) 2007-2015 martin isenburg,
+// rapidlasso; (c) 2019-2023 Thomas Montaigu.
+// Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
+// NOTICE). Changes: written in JavaScript as a worker entry, Brent Buffham 2026.
+//==========================================================
+
+import { createChunkDecoder } from "./decompressChunk.js";
+
+// node:worker_threads is named at run time so browser bundlers leave it alone
+var NODE_WORKER_THREADS = ["node", "worker_threads"].join(":");
+
+var port = null;
+if (typeof self !== "undefined" && typeof self.postMessage === "function") {
+	port = { post: function (m, t) { self.postMessage(m, t); } };
+	self.onmessage = function (e) { handle(e.data); };
+} else {
+	var wt = await import(/* webpackIgnore: true */ /* @vite-ignore */ NODE_WORKER_THREADS);
+	port = { post: function (m, t) { wt.parentPort.postMessage(m, t); } };
+	wt.parentPort.on("message", handle);
+}
+port.post({ ready: true });                    // the pool waits for this before sending work
+
+var cached = { key: null, decode: null };
+
+function handle(m) {
+	try {
+		var key = JSON.stringify(m.vlr) + "/" + m.recordLength;
+		if (cached.key !== key) cached = { key: key, decode: createChunkDecoder(m.vlr, m.recordLength) };
+		var bytes = new Uint8Array(m.packed);
+		var total = m.chunks.reduce(function (s, c) { return s + c.count; }, 0);
+		var out = new ArrayBuffer(total * m.recordLength);
+		var view = new DataView(out), o = 0;
+		for (var i = 0; i < m.chunks.length; i++) {
+			var c = m.chunks[i];
+			cached.decode(bytes, c.s, c.e, c.count, view, o, m.base);
+			o += c.count * m.recordLength;
+		}
+		port.post({ id: m.id, records: out }, [out]);
+	} catch (err) {
+		port.post({ id: m.id, error: { code: err && err.code, message: err && err.message ? err.message : String(err), offset: err && err.offset } });
+	}
+}

package/src/laz/pool.js

@@ -0,0 +1,151 @@
+// src/laz/pool.js
+//==========================================================
+// A pool of workers that decode LAZ chunks in parallel (chunks are
+// independent, so N cores decode about N times as fast). Browser module
+// Workers or Node worker_threads, running src/laz/chunkWorker.js. Tasks
+// queue and go to the next free worker; results come back as transferred
+// buffers. close() terminates every worker and fails what is still
+// queued, so nothing outlives a read. When workers cannot start (no
+// Worker, a blocked or failing script), createLazPool returns null and
+// the reader decodes on its own thread.
+//
+// Uses the chunk decoder translated from laz-rs (https://github.com/laz-rs/laz-rs),
+// itself a port of LASzip by rapidlasso. (c) 2007-2015 martin isenburg,
+// rapidlasso; (c) 2019-2023 Thomas Montaigu.
+// Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
+// NOTICE). Changes: written in JavaScript as a worker pool, Brent Buffham 2026.
+//==========================================================
+
+import { LasError, ERROR_CODES } from "../errors.js";
+
+var NODE_WORKER_THREADS = ["node", "worker_threads"].join(":");
+var NODE_OS = ["node", "os"].join(":");
+var MAX_THREADS = 16;
+
+/**
+ * How many decode workers to use by default: one fewer than the cores, at most 16.
+ * @returns {Promise<number>}
+ */
+export async function defaultThreads() {
+	var cores = 1;
+	if (typeof navigator !== "undefined" && navigator.hardwareConcurrency) cores = navigator.hardwareConcurrency;
+	else {
+		try {
+			var os = await import(/* webpackIgnore: true */ /* @vite-ignore */ NODE_OS);
+			cores = typeof os.availableParallelism === "function" ? os.availableParallelism() : os.cpus().length;
+		} catch (e) { cores = 1; }
+	}
+	return Math.max(1, Math.min(MAX_THREADS, cores - 1));
+}
+
+// Node worker options: the parent's flags are inherited, except --input-type
+// (node --input-type=module -e passes it on, and a worker has no string input
+// for it). Only then is execArgv given: an explicit one is checked flag by
+// flag, and some parents (the test runner) hold flags a worker may not take.
+function nodeWorkerOptions(argv) {
+	var isInputType = function (a, i) { return /^--input-type(=|$)/.test(a) || argv[i - 1] === "--input-type"; };
+	if (!argv.some(isInputType)) return undefined;
+	return { execArgv: argv.filter(function (a, i) { return !isInputType(a, i); }) };
+}
+
+// One worker, browser or Node, behind the same small interface. Resolves once
+// the worker says it is ready; rejects if it fails or exits first (a blocked
+// or broken script), so a pool that cannot start is known before any task.
+async function spawn(onMessage, onFail, nodeUrl) {
+	var started = false, ready, failed;
+	var up = new Promise(function (res, rej) { ready = res; failed = rej; });
+	function message(m) { if (m && m.ready) { started = true; ready(); } else onMessage(m); }
+	function error(e) { if (started) onFail(e); else failed(e); }
+	var handle;
+	if (typeof Worker === "function") {
+		// written inline so bundlers (Vite, webpack 5) see the worker and emit it
+		var w = new Worker(new URL("./chunkWorker.js", import.meta.url), { type: "module" });
+		w.onmessage = function (e) { message(e.data); };
+		w.onerror = function (e) { if (e && e.preventDefault) e.preventDefault(); error(new Error(e && e.message ? e.message : "LAZ worker failed")); };
+		handle = { post: function (m, t) { w.postMessage(m, t); }, close: function () { w.terminate(); } };
+	} else {
+		var wt = await import(/* webpackIgnore: true */ /* @vite-ignore */ NODE_WORKER_THREADS);
+		var nw = new wt.Worker(nodeUrl || new URL("./chunkWorker.js", import.meta.url), nodeWorkerOptions(process.execArgv));
+		nw.on("message", message);
+		nw.on("error", error);
+		nw.on("exit", function (code) { if (!started) failed(new Error("LAZ worker exited (" + code + ") before it started")); });
+		// Node runs while a worker has a task and not while it is idle, so a forgotten
+		// pool never keeps it running (unref after the "message" listener, which refs again)
+		handle = { post: function (m, t) { nw.postMessage(m, t); }, close: function () { return nw.terminate(); }, hold: function () { nw.ref(); }, release: function () { nw.unref(); } };
+	}
+	try { await up; } catch (e) { handle.close(); throw e; }
+	if (handle.release) handle.release();
+	return handle;
+}
+
+/**
+ * @param {number} n - workers to start (2 or more)
+ * @param {URL} [nodeUrl] - a Node worker entry in place of chunkWorker.js (tests)
+ * @returns {Promise<{size:number, decode:function(object): Promise<Uint8Array>, close:function(): void}|null>}
+ */
+export async function createLazPool(n, nodeUrl) {
+	var workers = [], idle = [], queue = [], waiting = new Map(), nextId = 1, closed = false;
+
+	function fail(err) {
+		// a worker that dies takes the pool with it: every waiting task fails
+		var e = err instanceof LasError ? err : new LasError(ERROR_CODES.UNSUPPORTED, "a LAZ decode worker failed: " + (err && err.message ? err.message : String(err)));
+		waiting.forEach(function (job) { job.reject(e); });
+		waiting.clear();
+		queue.forEach(function (job) { job.reject(e); });
+		queue = [];
+	}
+
+	function pump() {
+		while (idle.length && queue.length) {
+			var w = idle.pop(), job = queue.shift();
+			job.worker = w;
+			waiting.set(job.msg.id, job);
+			if (w.hold) w.hold();
+			w.post(job.msg, [job.msg.packed]);
+		}
+	}
+
+	function onMessage(m) {
+		var job = waiting.get(m.id);
+		if (!job) return;
+		waiting.delete(m.id);
+		if (job.worker.release) job.worker.release();
+		idle.push(job.worker);
+		if (m.error) job.reject(new LasError(m.error.code || ERROR_CODES.UNSUPPORTED, m.error.message, m.error.offset));
+		else job.resolve(new Uint8Array(m.records));
+		pump();
+	}
+
+	var starts = [];
+	for (var i = 0; i < n; i++) starts.push(spawn(onMessage, fail, nodeUrl));
+	var settled = await Promise.allSettled(starts);
+	workers = settled.filter(function (s) { return s.status === "fulfilled"; }).map(function (s) { return s.value; });
+	if (workers.length < n) {
+		// any worker that cannot start means the reader decodes on its own thread
+		workers.forEach(function (w) { w.close(); });
+		return null;
+	}
+	idle = workers.slice();
+
+	return {
+		size: n,
+		/**
+		 * Decode chunks from their own copy of the compressed bytes.
+		 * @param {{vlr:object, recordLength:number, packed:ArrayBuffer, chunks:Array, base:number}} task
+		 * @returns {Promise<Uint8Array>} the chunks' raw LAS records, in order
+		 */
+		decode: function (task) {
+			if (closed) return Promise.reject(new LasError(ERROR_CODES.ABORTED, "the LAZ decode pool is closed"));
+			return new Promise(function (resolve, reject) {
+				queue.push({ msg: Object.assign({ id: nextId++ }, task), resolve: resolve, reject: reject });
+				pump();
+			});
+		},
+		close: function () {
+			if (closed) return;
+			closed = true;
+			fail(new LasError(ERROR_CODES.ABORTED, "the read stopped"));
+			workers.forEach(function (w) { w.close(); });
+		}
+	};
+}

package/src/laz/v2/point10.js

@@ -61,6 +61,9 @@ StreamingMedian.prototype.add = function (x) {
 };
 
 function models(n, symbols) { var out = []; for (var i = 0; i < n; i++) out.push(new ArithmeticModel(symbols)); return out; }
+// A model made on first use: a fresh model is the same whenever it is made, and most
+// of the 256 per table are never touched in a chunk
+function lazyModel(table, i) { return table[i] || (table[i] = new ArithmeticModel(256)); }
 function medians() { var out = []; for (var i = 0; i < 16; i++) out.push(new StreamingMedian()); return out; }
 
 /** Point10 v2 decompressor: one per chunk. */
@@ -72,9 +75,9 @@ export function Point10Decompressor() {
 	this.lastHeight = new Int32Array(8);
 	this.changedValues = new ArithmeticModel(64);
 	this.scanAngleRank = models(2, 256);
-	this.bitByte = models(256, 256);
-	this.classification = models(256, 256);
-	this.userData = models(256, 256);
+	this.bitByte = new Array(256);
+	this.classification = new Array(256);
+	this.userData = new Array(256);
 	this.icIntensity = new IntegerDecompressor(16, 4);
 	this.icPointSourceId = new IntegerDecompressor(16, 1);
 	this.icDx = new IntegerDecompressor(32, 2);
@@ -98,7 +101,7 @@ Point10Decompressor.prototype.next = function (dec, view, o) {
 	var changed = dec.decodeSymbol(this.changedValues);
 	var r, n, m, l;
 	if (changed !== 0) {
-		if (changed & 32) this.bits = dec.decodeSymbol(this.bitByte[this.bits]);
+		if (changed & 32) this.bits = dec.decodeSymbol(lazyModel(this.bitByte, this.bits));
 		r = this.bits & 7; n = (this.bits >>> 3) & 7;
 		m = NUMBER_RETURN_MAP[n][r]; l = NUMBER_RETURN_LEVEL[n][r];
 		if (changed & 16) {
@@ -107,12 +110,12 @@ Point10Decompressor.prototype.next = function (dec, view, o) {
 		} else {
 			this.intensity = this.lastIntensity[m];
 		}
-		if (changed & 8) this.cls = dec.decodeSymbol(this.classification[this.cls]);
+		if (changed & 8) this.cls = dec.decodeSymbol(lazyModel(this.classification, this.cls));
 		if (changed & 4) {
 			var d = dec.decodeSymbol(this.scanAngleRank[(this.bits >>> 6) & 1]);
 			this.angle = ((this.angle + d) << 24) >> 24;   // i8 wrapping_add
 		}
-		if (changed & 2) this.user = dec.decodeSymbol(this.userData[this.user]);
+		if (changed & 2) this.user = dec.decodeSymbol(lazyModel(this.userData, this.user));
 		if (changed & 1) this.psid = this.icPointSourceId.decompress(dec, this.psid, 0);
 	} else {
 		r = this.bits & 7; n = (this.bits >>> 3) & 7;

package/src/laz/v3/layered.js

@@ -23,12 +23,13 @@ var LE = true;
 
 // laz-rs's context switch, shared by the three items: returns the index whose
 // last value predicts this point (`last_idx`), after switching to `ctx`.
-function enterContext(item, ctx, seed) {
+// item.seed(from, to) starts a context from another's last value.
+function enterContext(item, ctx) {
 	var lastIdx = item.lastContext;
 	if (item.lastContext !== ctx) {
 		item.lastContext = ctx;
 		if (item.unused[ctx]) {
-			seed(lastIdx, ctx);
+			item.seed(lastIdx, ctx);
 			item.unused[ctx] = false;
 			if (item.version === 3) lastIdx = ctx;
 		}
@@ -65,9 +66,9 @@ Rgb14Decompressor.prototype.first = function (src, s, view, o, ctx) {
 };
 Rgb14Decompressor.prototype.readLayerSizes = function (dv, q) { this.layerSize = dv.getUint32(q, LE); return q + 4; };
 Rgb14Decompressor.prototype.readLayers = function (bytes, q, e, fail, base) { this.dec = layer(this, bytes, q, this.layerSize, fail, e, base); return q + this.layerSize; };
+Rgb14Decompressor.prototype.seed = function (from, to) { this.last[to].set(this.last[from]); };
 Rgb14Decompressor.prototype.next = function (view, o, ctx) {
-	var self = this;
-	var idx = enterContext(this, ctx.v, function (from, to) { self.last[to].set(self.last[from]); });
+	var idx = enterContext(this, ctx.v);
 	var rgb = this.last[idx];
 	if (this.dec) decodeRgb(this.dec, this.models[this.lastContext], rgb);
 	view.setUint16(o, rgb[0], LE); view.setUint16(o + 2, rgb[1], LE); view.setUint16(o + 4, rgb[2], LE);
@@ -93,9 +94,9 @@ Nir14Decompressor.prototype.first = function (src, s, view, o, ctx) {
 };
 Nir14Decompressor.prototype.readLayerSizes = Rgb14Decompressor.prototype.readLayerSizes;
 Nir14Decompressor.prototype.readLayers = Rgb14Decompressor.prototype.readLayers;
+Nir14Decompressor.prototype.seed = function (from, to) { this.last[to] = this.last[from]; };
 Nir14Decompressor.prototype.next = function (view, o, ctx) {
-	var self = this;
-	var idx = enterContext(this, ctx.v, function (from, to) { self.last[to] = self.last[from]; });
+	var idx = enterContext(this, ctx.v);
 	if (this.dec) {
 		var c = this.lastContext, last = this.last[idx];
 		var sym = this.dec.decodeSymbol(this.used[c]);
@@ -134,9 +135,9 @@ Byte14Decompressor.prototype.readLayers = function (bytes, q, e, fail, base) {
 	for (var i = 0; i < this.size; i++) { this.dec[i] = layer(this, bytes, q, this.sizes[i], fail, e, base); q += this.sizes[i]; }
 	return q;
 };
+Byte14Decompressor.prototype.seed = function (from, to) { this.models[to] = byteModels(this.size); this.last[to].set(this.last[from]); };
 Byte14Decompressor.prototype.next = function (view, o, ctx) {
-	var self = this;
-	var idx = enterContext(this, ctx.v, function (from, to) { self.models[to] = byteModels(self.size); self.last[to].set(self.last[from]); });
+	var idx = enterContext(this, ctx.v);
 	var last = this.last[idx], models = this.models[ctx.v];
 	for (var i = 0; i < this.size; i++) {
 		if (this.dec[i]) last[i] = (last[i] + this.dec[i].decodeSymbol(models[i])) & 255;