las-laz-js 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "las-laz-js",
-	"version": "0.3.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/index.js

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

package/src/laz/chunkWorker.js

@@ -5,7 +5,8 @@
 // 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: { id, records: ArrayBuffer } or { id, error: { code, message, 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,
@@ -28,6 +29,7 @@ if (typeof self !== "undefined" && typeof self.postMessage === "function") {
 	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 };
 

package/src/laz/pool.js

@@ -6,8 +6,8 @@
 // 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.
+// 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,
@@ -38,28 +38,52 @@ 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)
+ * @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) {
+export async function createLazPool(n, nodeUrl) {
 	var workers = [], idle = [], queue = [], waiting = new Map(), nextId = 1, closed = false;
 
 	function fail(err) {
@@ -76,6 +100,7 @@ export async function createLazPool(n) {
 			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]);
 		}
 	}
@@ -84,15 +109,19 @@ 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));
 		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;
 	}