las-laz-js 0.3.0 → 0.4.0

package/src/laz/pool.js

@@ -1,13 +1,14 @@
 // 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 script), createLazPool returns null and the reader
-// decodes on its own thread.
+// A pool of workers that decode and compress LAZ chunks in parallel
+// (chunks are independent, so N cores do about N times the work).
+// Browser module Workers or Node worker_threads, running
+// src/laz/chunkWorker.js. Tasks queue and go to the next free worker;
+// their buffers go there, and the results come back, transferred.
+// close() terminates every worker and fails what is still queued, so
+// nothing outlives a read or a write. When workers cannot start (no
+// Worker, a blocked or failing script), createLazPool returns null and
+// the reader or writer works 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,
@@ -23,7 +24,7 @@ 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.
+ * How many LAZ workers to use by default: one fewer than the cores, at most 16.
  * @returns {Promise<number>}
  */
 export async function defaultThreads() {
@@ -38,33 +39,57 @@ export async function defaultThreads() {
 	return Math.max(1, Math.min(MAX_THREADS, cores - 1));
 }
 
-// One worker, browser or Node, behind the same small interface
-async function spawn(onMessage, onFail) {
+// 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) { onMessage(e.data); };
-		w.onerror = function (e) { if (e && e.preventDefault) e.preventDefault(); onFail(new Error(e && e.message ? e.message : "LAZ worker failed")); };
-		return { post: function (m, t) { w.postMessage(m, t); }, close: function () { w.terminate(); } };
+		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(); } };
 	}
-	var wt = await import(/* webpackIgnore: true */ /* @vite-ignore */ NODE_WORKER_THREADS);
-	var nw = new wt.Worker(new URL("./chunkWorker.js", import.meta.url));
-	nw.unref();                                  // a forgotten pool never keeps Node running
-	nw.on("message", onMessage);
-	nw.on("error", onFail);
-	return { post: function (m, t) { nw.postMessage(m, t); }, close: function () { return nw.terminate(); } };
+	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)
- * @returns {Promise<{size:number, decode:function(object): Promise<Uint8Array>, close:function(): void}|null>}
+ * @param {URL} [nodeUrl] - a Node worker entry in place of chunkWorker.js (tests)
+ * @returns {Promise<{size:number, decode:function(object): Promise<Uint8Array>, compress:function(object): Promise<{bytes:Uint8Array, sizes:number[]}>, close:function(): void}|null>}
  */
-export async function createLazPool(n) {
+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)));
+		var e = err instanceof LasError ? err : new LasError(ERROR_CODES.UNSUPPORTED, "a LAZ 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); });
@@ -76,7 +101,8 @@ export async function createLazPool(n) {
 			var w = idle.pop(), job = queue.shift();
 			job.worker = w;
 			waiting.set(job.msg.id, job);
-			w.post(job.msg, [job.msg.packed]);
+			if (w.hold) w.hold();
+			w.post(job.msg, job.transfer);
 		}
 	}
 
@@ -84,20 +110,32 @@ export async function createLazPool(n) {
 		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));
+		else job.resolve(job.result(m));
 		pump();
 	}
 
-	try {
-		for (var i = 0; i < n; i++) workers.push(await spawn(onMessage, fail));
-	} catch (e) {
+	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();
 
+	function run(msg, transfer, result) {
+		if (closed) return Promise.reject(new LasError(ERROR_CODES.ABORTED, "the LAZ pool is closed"));
+		return new Promise(function (resolve, reject) {
+			queue.push({ msg: Object.assign({ id: nextId++ }, msg), transfer: transfer, result: result, resolve: resolve, reject: reject });
+			pump();
+		});
+	}
+
 	return {
 		size: n,
 		/**
@@ -106,16 +144,21 @@ export async function createLazPool(n) {
 		 * @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();
-			});
+			return run(task, [task.packed], function (m) { return new Uint8Array(m.records); });
+		},
+		/**
+		 * Compress whole chunks from their own copy of the raw records (transferred).
+		 * @param {{vlr:object, recordLength:number, records:ArrayBuffer, counts:number[]}} task
+		 *   counts: each chunk's points, the chunks back to back from the start of records
+		 * @returns {Promise<{bytes:Uint8Array, sizes:number[]}>} the chunks, back to back, and each one's length
+		 */
+		compress: function (task) {
+			return run(Object.assign({ op: "compress" }, task), [task.records], function (m) { return { bytes: new Uint8Array(m.chunks), sizes: m.sizes }; });
 		},
 		close: function () {
 			if (closed) return;
 			closed = true;
-			fail(new LasError(ERROR_CODES.ABORTED, "the read stopped"));
+			fail(new LasError(ERROR_CODES.ABORTED, "the LAZ pool was closed"));
 			workers.forEach(function (w) { w.close(); });
 		}
 	};

package/src/laz/v2/byte.js

@@ -8,19 +8,23 @@
 // 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.
+// NOTICE). Changes: translated from Rust to JavaScript, Brent Buffham 2026;
+// the compressor (ByteCompressor) added beside the decompressor.
 //==========================================================
 
 import { ArithmeticModel } from "../models.js";
 
-/** Byte v2 decompressor for `count` extra bytes: one per chunk. */
-export function ByteDecompressor(count) {
-	this.size = count;
-	this.last = new Uint8Array(count);
-	this.models = [];
-	for (var i = 0; i < count; i++) this.models.push(new ArithmeticModel(256));
+// The state and models both halves start a chunk with: the last bytes and one model per byte
+function initByte(self, count) {
+	self.size = count;
+	self.last = new Uint8Array(count);
+	self.models = [];
+	for (var i = 0; i < count; i++) self.models.push(new ArithmeticModel(256));
 }
 
+/** Byte v2 decompressor for `count` extra bytes: one per chunk. */
+export function ByteDecompressor(count) { initByte(this, count); }
+
 ByteDecompressor.prototype.first = function (src, s, view, o) {
 	for (var i = 0; i < this.size; i++) { this.last[i] = src[s + i]; view.setUint8(o + i, src[s + i]); }
 };
@@ -31,3 +35,15 @@ ByteDecompressor.prototype.next = function (dec, view, o) {
 		view.setUint8(o + i, this.last[i]);
 	}
 };
+
+/** Byte v2 compressor for `count` extra bytes: one per chunk, the mirror of ByteDecompressor. */
+export function ByteCompressor(count) { initByte(this, count); }
+
+ByteCompressor.prototype.first = function (src, s) { this.last.set(src.subarray(s, s + this.size)); };
+
+ByteCompressor.prototype.next = function (enc, src, s) {
+	for (var i = 0; i < this.size; i++) {
+		enc.encodeSymbol(this.models[i], (src[s + i] - this.last[i]) & 255);   // u8 wrapping_sub
+		this.last[i] = src[s + i];
+	}
+};

package/src/laz/v2/gpstime11.js

@@ -12,11 +12,14 @@
 // 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, i64 as two u32
-// halves, Brent Buffham 2026.
+// halves, Brent Buffham 2026; the compressor (GpsTime11Compressor) added
+// beside the decompressor, rounding its multiplier as LAZperf does; its
+// multiplier and 64-bit difference shared with the Point14 compressor.
 //==========================================================
 
 import { ArithmeticModel } from "../models.js";
 import { IntegerDecompressor } from "../IntegerDecompressor.js";
+import { IntegerCompressor } from "../IntegerCompressor.js";
 
 var LE = true;
 var MULTI = 500, MULTI_MINUS = -10;
@@ -24,18 +27,39 @@ var MULTI_UNCHANGED = MULTI - MULTI_MINUS + 1;   // 511
 var MULTI_CODE_FULL = MULTI - MULTI_MINUS + 2;   // 512
 var MULTI_TOTAL = MULTI - MULTI_MINUS + 6;       // 516
 
+// The state and models both halves start a chunk with; IC is the integer coder
+// (IntegerCompressor or IntegerDecompressor)
+function initGps(self, IC) {
+	self.size = 8;
+	self.multiModel = new ArithmeticModel(MULTI_TOTAL);
+	self.zeroDiffModel = new ArithmeticModel(6);
+	self.ic = new IC(32, 9);
+	self.last = 0;
+	self.nextSeq = 0;
+	self.hi = new Int32Array(4);
+	self.lo = new Float64Array(4);              // u32 values, held exactly
+	self.diffs = new Int32Array(4);
+	self.extremes = new Int32Array(4);
+}
+
+// A full time (hi, lo) starts the next of the four sequences, with no difference yet
+function startSequence(self, hi, lo) {
+	self.nextSeq = (self.nextSeq + 1) & 3;
+	self.hi[self.nextSeq] = hi;
+	self.lo[self.nextSeq] = lo;
+	self.last = self.nextSeq;
+	self.diffs[self.last] = 0;
+	self.extremes[self.last] = 0;
+}
+
+// After three extreme differences in a row, the latest becomes the new reference
+function extreme(self, d) {
+	if (++self.extremes[self.last] > 3) { self.diffs[self.last] = d; self.extremes[self.last] = 0; }
+}
+
 /** GpsTime11 v2 decompressor: one per chunk. */
 export function GpsTime11Decompressor() {
-	this.size = 8;
-	this.multiModel = new ArithmeticModel(MULTI_TOTAL);
-	this.zeroDiffModel = new ArithmeticModel(6);
-	this.ic = new IntegerDecompressor(32, 9);
-	this.last = 0;
-	this.nextSeq = 0;
-	this.hi = new Int32Array(4);
-	this.lo = new Float64Array(4);              // u32 values, held exactly
-	this.diffs = new Int32Array(4);
-	this.extremes = new Int32Array(4);
+	initGps(this, IntegerDecompressor);
 }
 
 GpsTime11Decompressor.prototype._add = function (i, d) {
@@ -46,17 +70,8 @@ GpsTime11Decompressor.prototype._add = function (i, d) {
 };
 
 GpsTime11Decompressor.prototype._full = function (dec) {
-	this.nextSeq = (this.nextSeq + 1) & 3;
-	this.hi[this.nextSeq] = this.ic.decompress(dec, this.hi[this.last], 8);
-	this.lo[this.nextSeq] = dec.readInt();
-	this.last = this.nextSeq;
-	this.diffs[this.last] = 0;
-	this.extremes[this.last] = 0;
-};
-
-// After three extreme differences in a row, the latest becomes the new reference
-GpsTime11Decompressor.prototype._extreme = function (d) {
-	if (++this.extremes[this.last] > 3) { this.diffs[this.last] = d; this.extremes[this.last] = 0; }
+	var hi = this.ic.decompress(dec, this.hi[this.last], 8);
+	startSequence(this, hi, dec.readInt());
 };
 
 GpsTime11Decompressor.prototype.first = function (src, s, view, o) {
@@ -88,19 +103,19 @@ GpsTime11Decompressor.prototype.next = function (dec, view, o) {
 			} else if (multi < MULTI_UNCHANGED) {
 				if (multi === 0) {
 					d = this.ic.decompress(dec, 0, 7);
-					this._extreme(d);
+					extreme(this, d);
 				} else if (multi < MULTI) {
 					d = this.ic.decompress(dec, Math.imul(multi, this.diffs[L]), multi < 10 ? 2 : 3);
 				} else if (multi === MULTI) {
 					d = this.ic.decompress(dec, Math.imul(MULTI, this.diffs[L]), 4);
-					this._extreme(d);
+					extreme(this, d);
 				} else {
 					multi = MULTI - multi;
 					if (multi > MULTI_MINUS) {
 						d = this.ic.decompress(dec, Math.imul(multi, this.diffs[L]), 5);
 					} else {
 						d = this.ic.decompress(dec, Math.imul(MULTI_MINUS, this.diffs[L]), 6);
-						this._extreme(d);
+						extreme(this, d);
 					}
 				}
 				this._add(L, d);
@@ -116,3 +131,128 @@ GpsTime11Decompressor.prototype.next = function (dec, view, o) {
 	view.setUint32(o, this.lo[this.last], LE);
 	view.setInt32(o + 4, this.hi[this.last], LE);
 };
+
+// The multiplier between this and the last difference, as LAZperf rounds it:
+// std::round of the f32 quotient (half away from zero), then (int). LASzip and
+// laz-rs add 0.5f in f32 instead, which differs only within an f32 step of a
+// half; the fixtures' oracle is LAZperf. The one quotient past i32 (2^31, a last
+// difference of +-1) converts as x86 does, to -2^31. Either choice decodes the same.
+export function quantizeMulti(curr, last) {
+	var q = Math.fround(Math.fround(curr) / Math.fround(last));
+	var m = q >= 0 ? Math.floor(q + 0.5) : -Math.floor(0.5 - q);
+	return m > 2147483647 ? -2147483648 : m;
+}
+
+// A DataView over the caller's records, made once per buffer
+function viewOf(item, src) {
+	if (item._src !== src) { item._src = src; item._view = new DataView(src.buffer, src.byteOffset, src.byteLength); }
+	return item._view;
+}
+
+/** GpsTime11 v2 compressor: one per chunk, the mirror of GpsTime11Decompressor. */
+export function GpsTime11Compressor() {
+	initGps(this, IntegerCompressor);
+	this._src = null;
+	this._view = null;
+}
+
+
+// (hi, lo) - (hi0, lo0) as an i32, or null when the 64-bit difference does not fit
+// (hi signed, lo unsigned; shared with the Point14 compressor's GPS time)
+export function diff32(hi, lo, hi0, lo0) {
+	var dl = lo - lo0, dh = hi - hi0;
+	if (dl < 0) { dl += 4294967296; dh -= 1; }
+	dh = dh | 0;                                 // the high word of the i64 wrapping_sub
+	if (dh === 0 && dl < 2147483648) return dl;
+	if (dh === -1 && dl >= 2147483648) return dl - 4294967296;
+	return null;
+}
+
+// (hi, lo) minus sequence i as an i32, or null when the 64-bit difference does not fit
+GpsTime11Compressor.prototype._diff = function (i, hi, lo) { return diff32(hi, lo, this.hi[i], this.lo[i]); };
+
+// The first other sequence (1-3 on from the last) this time is within i32 of, or 0
+GpsTime11Compressor.prototype._other = function (hi, lo) {
+	for (var i = 1; i < 4; i++) if (this._diff((this.last + i) & 3, hi, lo) !== null) return i;
+	return 0;
+};
+
+GpsTime11Compressor.prototype._full = function (enc, hi, lo) {
+	this.ic.compress(enc, this.hi[this.last], hi, 8);
+	enc.writeInt(lo);
+	startSequence(this, hi, lo);
+};
+
+GpsTime11Compressor.prototype.first = function (src, s) {
+	var v = viewOf(this, src);
+	this.lo[0] = v.getUint32(s, LE);
+	this.hi[0] = v.getInt32(s + 4, LE);
+};
+
+GpsTime11Compressor.prototype.next = function (enc, src, s) {
+	var v = viewOf(this, src);
+	var lo = v.getUint32(s, LE), hi = v.getInt32(s + 4, LE);
+	for (;;) {
+		var L = this.last, d, j, multi;
+		if (hi === this.hi[L] && lo === this.lo[L]) {
+			if (this.diffs[L] === 0) enc.encodeSymbol(this.zeroDiffModel, 0);
+			else enc.encodeSymbol(this.multiModel, MULTI_UNCHANGED);
+			return;
+		}
+		d = this._diff(L, hi, lo);
+		if (this.diffs[L] === 0) {
+			if (d !== null) {
+				enc.encodeSymbol(this.zeroDiffModel, 1);
+				this.ic.compress(enc, 0, d, 0);
+				this.diffs[L] = d;
+				this.extremes[L] = 0;
+			} else if ((j = this._other(hi, lo))) {
+				enc.encodeSymbol(this.zeroDiffModel, j + 2);
+				this.last = (L + j) & 3;
+				continue;                            // laz-rs recurses: code again against the new sequence
+			} else {
+				enc.encodeSymbol(this.zeroDiffModel, 2);
+				this._full(enc, hi, lo);
+			}
+		} else if (d !== null) {
+			multi = quantizeMulti(d, this.diffs[L]);
+			if (multi === 1) {
+				enc.encodeSymbol(this.multiModel, 1);
+				this.ic.compress(enc, this.diffs[L], d, 1);
+				this.extremes[L] = 0;
+			} else if (multi > 0) {
+				if (multi < MULTI) {
+					enc.encodeSymbol(this.multiModel, multi);
+					this.ic.compress(enc, Math.imul(multi, this.diffs[L]), d, multi < 10 ? 2 : 3);
+				} else {
+					enc.encodeSymbol(this.multiModel, MULTI);
+					this.ic.compress(enc, Math.imul(MULTI, this.diffs[L]), d, 4);
+					extreme(this, d);
+				}
+			} else if (multi < 0) {
+				if (multi > MULTI_MINUS) {
+					enc.encodeSymbol(this.multiModel, MULTI - multi);
+					this.ic.compress(enc, Math.imul(multi, this.diffs[L]), d, 5);
+				} else {
+					enc.encodeSymbol(this.multiModel, MULTI - MULTI_MINUS);
+					this.ic.compress(enc, Math.imul(MULTI_MINUS, this.diffs[L]), d, 6);
+					extreme(this, d);
+				}
+			} else {
+				enc.encodeSymbol(this.multiModel, 0);
+				this.ic.compress(enc, 0, d, 7);
+				extreme(this, d);
+			}
+		} else if ((j = this._other(hi, lo))) {
+			enc.encodeSymbol(this.multiModel, MULTI_CODE_FULL + j);
+			this.last = (L + j) & 3;
+			continue;
+		} else {
+			enc.encodeSymbol(this.multiModel, MULTI_CODE_FULL);
+			this._full(enc, hi, lo);
+		}
+		this.hi[this.last] = hi;
+		this.lo[this.last] = lo;
+		return;
+	}
+};

package/src/laz/v2/point10.js

@@ -4,8 +4,9 @@
 // (formats 0-5) starts with. Each point codes which attributes changed
 // since the last one; X and Y are corrections to a streaming median
 // of the recent differences, Z to the last height at the same return
-// level, all through integer decompressors whose contexts follow the
-// return structure.
+// level, all through integer coders whose contexts follow the return
+// structure. The compressor and decompressor below make the same model
+// choices from the same state, so they stay in step point for point.
 //
 // Ported from laz-rs src/las/point0.rs, module v2, and the median and
 // return tables of src/las/utils.rs (https://github.com/laz-rs/laz-rs),
@@ -13,11 +14,13 @@
 // 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, working on raw
-// record bytes, Brent Buffham 2026.
+// record bytes, Brent Buffham 2026; the compressor (Point10Compressor)
+// added beside the decompressor, sharing its models, median and tables.
 //==========================================================
 
 import { ArithmeticModel } from "../models.js";
 import { IntegerDecompressor } from "../IntegerDecompressor.js";
+import { IntegerCompressor } from "../IntegerCompressor.js";
 
 var LE = true;
 
@@ -66,23 +69,34 @@ function models(n, symbols) { var out = []; for (var i = 0; i < n; i++) out.push
 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; }
 
+// The Y and Z coder contexts, from the bit lengths of the X (and Y) corrections just coded
+// (Point14 uses them too)
+export function yContext(single, icDx) { var k = icDx.k; return single + (k < 20 ? k & 0xFFFFFFFE : 20); }
+export function zContext(single, icDx, icDy) { var k = Math.floor((icDx.k + icDy.k) / 2); return single + (k < 18 ? k & 0xFFFFFFFE : 18); }
+
+// The state and models both halves start a chunk with; IC is the integer coder
+// (IntegerCompressor or IntegerDecompressor), so each side gets the same widths and contexts
+function initPoint10(self, IC) {
+	self.size = 20;
+	self.lastIntensity = new Uint16Array(16);
+	self.xMedian = medians();
+	self.yMedian = medians();
+	self.lastHeight = new Int32Array(8);
+	self.changedValues = new ArithmeticModel(64);
+	self.scanAngleRank = models(2, 256);
+	self.bitByte = new Array(256);
+	self.classification = new Array(256);
+	self.userData = new Array(256);
+	self.icIntensity = new IC(16, 4);
+	self.icPointSourceId = new IC(16, 1);
+	self.icDx = new IC(32, 2);
+	self.icDy = new IC(32, 22);
+	self.icZ = new IC(32, 20);
+}
+
 /** Point10 v2 decompressor: one per chunk. */
 export function Point10Decompressor() {
-	this.size = 20;
-	this.lastIntensity = new Uint16Array(16);
-	this.xMedian = medians();
-	this.yMedian = medians();
-	this.lastHeight = new Int32Array(8);
-	this.changedValues = new ArithmeticModel(64);
-	this.scanAngleRank = models(2, 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);
-	this.icDy = new IntegerDecompressor(32, 22);
-	this.icZ = new IntegerDecompressor(32, 20);
+	initPoint10(this, IntegerDecompressor);
 }
 
 /** The first point of a chunk is stored raw. */
@@ -125,12 +139,10 @@ Point10Decompressor.prototype.next = function (dec, view, o) {
 	var diff = this.icDx.decompress(dec, this.xMedian[m].get(), single);
 	this.x = (this.x + diff) | 0;
 	this.xMedian[m].add(diff);
-	var kx = this.icDx.k;
-	diff = this.icDy.decompress(dec, this.yMedian[m].get(), single + (kx < 20 ? kx & 0xFFFFFFFE : 20));
+	diff = this.icDy.decompress(dec, this.yMedian[m].get(), yContext(single, this.icDx));
 	this.y = (this.y + diff) | 0;
 	this.yMedian[m].add(diff);
-	var kz = Math.floor((this.icDx.k + this.icDy.k) / 2);
-	this.z = this.icZ.decompress(dec, this.lastHeight[l], single + (kz < 18 ? kz & 0xFFFFFFFE : 18));
+	this.z = this.icZ.decompress(dec, this.lastHeight[l], zContext(single, this.icDx, this.icDy));
 	this.lastHeight[l] = this.z;
 	view.setInt32(o, this.x, LE); view.setInt32(o + 4, this.y, LE); view.setInt32(o + 8, this.z, LE);
 	view.setUint16(o + 12, this.intensity, LE);
@@ -140,3 +152,60 @@ Point10Decompressor.prototype.next = function (dec, view, o) {
 	view.setUint8(o + 17, this.user);
 	view.setUint16(o + 18, this.psid, LE);
 };
+
+// A DataView over the caller's records, made once per buffer
+function viewOf(item, src) {
+	if (item._src !== src) { item._src = src; item._view = new DataView(src.buffer, src.byteOffset, src.byteLength); }
+	return item._view;
+}
+
+/** Point10 v2 compressor: one per chunk, the mirror of Point10Decompressor. */
+export function Point10Compressor() {
+	initPoint10(this, IntegerCompressor);
+	this._src = null;
+	this._view = null;
+}
+
+/** The first point of a chunk is stored raw; it only sets the state. */
+Point10Compressor.prototype.first = function (src, s) {
+	var v = viewOf(this, src);
+	this.x = v.getInt32(s, LE); this.y = v.getInt32(s + 4, LE); this.z = v.getInt32(s + 8, LE);
+	this.bits = v.getUint8(s + 14);
+	this.cls = v.getUint8(s + 15);
+	this.angle = v.getInt8(s + 16);
+	this.user = v.getUint8(s + 17);
+	this.psid = v.getUint16(s + 18, LE);
+};
+
+Point10Compressor.prototype.next = function (enc, src, s) {
+	var v = viewOf(this, src);
+	var x = v.getInt32(s, LE), y = v.getInt32(s + 4, LE), z = v.getInt32(s + 8, LE);
+	var intensity = v.getUint16(s + 12, LE), bits = v.getUint8(s + 14), cls = v.getUint8(s + 15);
+	var angle = v.getInt8(s + 16), user = v.getUint8(s + 17), psid = v.getUint16(s + 18, LE);
+	var r = bits & 7, n = (bits >>> 3) & 7;
+	var m = NUMBER_RETURN_MAP[n][r], l = NUMBER_RETURN_LEVEL[n][r];
+	// return number, number of returns, scan direction and edge fill the bit byte, so "any changed" is the byte changed
+	var changed = (bits !== this.bits ? 32 : 0) | (intensity !== this.lastIntensity[m] ? 16 : 0) | (cls !== this.cls ? 8 : 0) |
+		(angle !== this.angle ? 4 : 0) | (user !== this.user ? 2 : 0) | (psid !== this.psid ? 1 : 0);
+	enc.encodeSymbol(this.changedValues, changed);
+	if (changed & 32) enc.encodeSymbol(lazyModel(this.bitByte, this.bits), bits);
+	if (changed & 16) {
+		this.icIntensity.compress(enc, this.lastIntensity[m], intensity, m < 3 ? m : 3);
+		this.lastIntensity[m] = intensity;
+	}
+	if (changed & 8) enc.encodeSymbol(lazyModel(this.classification, this.cls), cls);
+	if (changed & 4) enc.encodeSymbol(this.scanAngleRank[(bits >>> 6) & 1], (angle - this.angle) & 255);   // u8 wrapping_sub
+	if (changed & 2) enc.encodeSymbol(lazyModel(this.userData, this.user), user);
+	if (changed & 1) this.icPointSourceId.compress(enc, this.psid, psid, 0);
+	var single = n === 1 ? 1 : 0;
+	var diff = (x - this.x) | 0;              // i32 wrapping_sub
+	this.icDx.compress(enc, this.xMedian[m].get(), diff, single);
+	this.xMedian[m].add(diff);
+	diff = (y - this.y) | 0;
+	this.icDy.compress(enc, this.yMedian[m].get(), diff, yContext(single, this.icDx));
+	this.yMedian[m].add(diff);
+	this.icZ.compress(enc, this.lastHeight[l], z, zContext(single, this.icDx, this.icDy));
+	this.lastHeight[l] = z;
+	this.x = x; this.y = y; this.z = z;
+	this.bits = bits; this.cls = cls; this.angle = angle; this.user = user; this.psid = psid;
+};