reg-cli 0.19.0-rc0 → 0.19.0-rc2

package/dist/cli.cjs

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
-require("./rolldown-runtime-D_mwlA32.cjs");
 const require_index = require("./index.cjs");
-const require_ximgdiff = require("./ximgdiff-wmW1BH1H.cjs");
+const require_ximgdiff = require("./ximgdiff-B16oe7EL.cjs");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 let node_module = require("node:module");

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as writeXimgdiffAssets } from "./ximgdiff-DzkRRnkW.mjs";
+import { t as writeXimgdiffAssets } from "./ximgdiff-D8GAJaxA.mjs";
 import { dir, run } from "./index.mjs";
 import { createRequire } from "node:module";
 import { copyFile, mkdir } from "node:fs/promises";

package/dist/index.cjs

@@ -1,8 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_rolldown_runtime = require("./rolldown-runtime-D_mwlA32.cjs");
-const require_tracing = require("./tracing-DlLL541f.cjs");
+const require_tracing = require("./tracing-Cf9TNPXQ.cjs");
 let node_events = require("node:events");
-node_events = require_rolldown_runtime.__toESM(node_events, 1);
+node_events = require_tracing.__toESM(node_events, 1);
 let node_worker_threads = require("node:worker_threads");
 let url = require("url");
 let node_path = require("node:path");
@@ -36,79 +35,81 @@ const runInternal = async (argv, emitter) => {
 	}
 	const traceContext = require_tracing.isTracingEnabled() ? require_tracing.startRootSpan("reg-cli") : null;
 	const t_new_entry = Date.now();
-	const worker = new node_worker_threads.Worker((0, node_path.join)(dir(), `./entry.${require_tracing.resolveExtention()}`), { workerData: { argv } });
+	const worker = new node_worker_threads.Worker((0, node_path.join)(dir(), `./runner.${require_tracing.resolveExtention()}`), { workerData: {
+		argv,
+		mode: "entry"
+	} });
 	recordMainSpan("main.new_entry_worker", t_new_entry);
 	let nextTid = 1;
 	const workers = [worker];
 	const threadWorkerSpans = [];
-	const spawn = (startArg, threadId, memory) => {
-		const t_new_worker = Date.now();
-		const worker = new node_worker_threads.Worker((0, node_path.join)(dir(), `./worker.${require_tracing.resolveExtention()}`), { workerData: { argv } });
-		const tid = nextTid++;
-		recordMainSpan("main.new_thread_worker", t_new_worker, { tid });
-		workers.push(worker);
-		worker.on("message", (msg) => {
-			const { cmd } = msg;
-			if (cmd === "loaded") {
-				if (typeof worker.unref === "function") worker.unref();
-			} else if (cmd === "thread-spawn") spawn(msg.startArg, msg.threadId, msg.memory);
-			else if (cmd === "worker-spans") {
-				if (Array.isArray(msg.workerSpans)) threadWorkerSpans.push(...msg.workerSpans);
-			} else if (cmd === "compare-event") {
-				if (msg.event) emitter.emit("compare", msg.event);
+	const attachCommonHandlers = (w) => {
+		w.on("message", (msg) => {
+			switch (msg.cmd) {
+				case "compare-event":
+					if (msg.event) emitter.emit("compare", msg.event);
+					return;
+				case "thread-spawn":
+					spawn(msg.startArg, msg.threadId, msg.memory, msg.wasmModule);
+					return;
+				case "worker-spans":
+					if (Array.isArray(msg.workerSpans)) threadWorkerSpans.push(...msg.workerSpans);
+					return;
+				case "loaded":
+					if (typeof w.unref === "function") w.unref();
+					return;
 			}
 		});
-		worker.on("error", (e) => {
-			workers.forEach((w) => w.terminate());
+		w.on("error", (e) => {
+			if (traceContext) require_tracing.endRootSpan(false);
+			workers.forEach((x) => x.terminate());
 			emitter.emit("error", e);
 		});
+	};
+	const spawn = (startArg, threadId, memory, wasmModule) => {
+		const t_new_worker = Date.now();
+		const w = new node_worker_threads.Worker((0, node_path.join)(dir(), `./runner.${require_tracing.resolveExtention()}`), { workerData: {
+			argv,
+			mode: "thread"
+		} });
+		const tid = nextTid++;
+		recordMainSpan("main.new_thread_worker", t_new_worker, { tid });
+		workers.push(w);
+		attachCommonHandlers(w);
 		if (threadId) {
 			Atomics.store(threadId, 0, tid);
 			Atomics.notify(threadId, 0);
 		}
-		worker.postMessage({
+		w.postMessage({
 			startArg,
 			tid,
-			memory
+			memory,
+			wasmModule
 		});
 		return tid;
 	};
-	worker.on("message", async ({ cmd, startArg, threadId, memory, data, traceData, workerSpans, event }) => {
-		if (cmd === "compare-event") {
-			if (event) emitter.emit("compare", event);
-			return;
+	attachCommonHandlers(worker);
+	worker.on("message", async (msg) => {
+		if (msg.cmd !== "complete") return;
+		const { data, traceData, workerSpans } = msg;
+		const t_post_complete = Date.now();
+		if (require_tracing.isTracingEnabled()) {
+			if (Array.isArray(workerSpans)) require_tracing.processWorkerSpans(workerSpans, "entry");
+			if (threadWorkerSpans.length) require_tracing.processWorkerSpans(threadWorkerSpans, "thread");
+			if (traceData) require_tracing.processRustTraceData(traceData);
+			recordMainSpan("main.process_trace_and_spans", t_post_complete);
+			mainSpans.push({
+				name: "main.run_total",
+				start_ms: run_start_ms,
+				end_ms: Date.now(),
+				worker_label: "main"
+			});
+			require_tracing.processWorkerSpans(mainSpans, "main");
+			require_tracing.endRootSpan(true);
+			await require_tracing.shutdownTracing();
 		}
-		if (cmd === "complete") {
-			const t_post_complete = Date.now();
-			if (require_tracing.isTracingEnabled()) {
-				if (Array.isArray(workerSpans)) require_tracing.processWorkerSpans(workerSpans, "entry");
-				if (threadWorkerSpans.length) require_tracing.processWorkerSpans(threadWorkerSpans, "thread");
-				if (traceData) require_tracing.processRustTraceData(traceData);
-				recordMainSpan("main.process_trace_and_spans", t_post_complete);
-				mainSpans.push({
-					name: "main.run_total",
-					start_ms: run_start_ms,
-					end_ms: Date.now(),
-					worker_label: "main"
-				});
-				require_tracing.processWorkerSpans(mainSpans, "main");
-				require_tracing.endRootSpan(true);
-				await require_tracing.shutdownTracing();
-			}
-			workers.forEach((w) => w.terminate());
-			emitter.emit("complete", data);
-			return;
-		}
-		if (cmd === "loaded") {
-			if (typeof worker.unref === "function") worker.unref();
-			return;
-		}
-		if (cmd === "thread-spawn") spawn(startArg, threadId, memory);
-	});
-	worker.on("error", (err) => {
-		if (traceContext) require_tracing.endRootSpan(false);
 		workers.forEach((w) => w.terminate());
-		emitter.emit("error", err);
+		emitter.emit("complete", data);
 	});
 };
 /** Flags that `compare()` handles itself in JS; they are NOT forwarded to
@@ -163,7 +164,7 @@ const compare = (input) => {
 	inner.on("complete", async (data) => {
 		try {
 			if (restAny.additionalDetection === "client" && typeof input.report === "string") {
-				const { writeXimgdiffAssets } = await Promise.resolve().then(() => require("./ximgdiff-wmW1BH1H.cjs")).then((n) => n.ximgdiff_exports);
+				const { writeXimgdiffAssets } = await Promise.resolve().then(() => require("./ximgdiff-B16oe7EL.cjs")).then((n) => n.ximgdiff_exports);
 				await writeXimgdiffAssets({
 					reportPath: input.report,
 					urlPrefix: typeof input.urlPrefix === "string" ? input.urlPrefix : "",

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as processWorkerSpans, d as resolveExtention, i as processRustTraceData, l as isCJS, n as initTracing, o as shutdownTracing, r as isTracingEnabled, s as startRootSpan, t as endRootSpan } from "./tracing-7HO8hac9.mjs";
+import { a as processWorkerSpans, i as processRustTraceData, n as initTracing, o as shutdownTracing, p as resolveExtention, r as isTracingEnabled, s as startRootSpan, t as endRootSpan, u as isCJS } from "./tracing-Bo38b9aR.mjs";
 import EventEmitter from "node:events";
 import { Worker } from "node:worker_threads";
 import { fileURLToPath } from "url";
@@ -33,79 +33,81 @@ const runInternal = async (argv, emitter) => {
 	}
 	const traceContext = isTracingEnabled() ? startRootSpan("reg-cli") : null;
 	const t_new_entry = Date.now();
-	const worker = new Worker(join(dir(), `./entry.${resolveExtention()}`), { workerData: { argv } });
+	const worker = new Worker(join(dir(), `./runner.${resolveExtention()}`), { workerData: {
+		argv,
+		mode: "entry"
+	} });
 	recordMainSpan("main.new_entry_worker", t_new_entry);
 	let nextTid = 1;
 	const workers = [worker];
 	const threadWorkerSpans = [];
-	const spawn = (startArg, threadId, memory) => {
-		const t_new_worker = Date.now();
-		const worker = new Worker(join(dir(), `./worker.${resolveExtention()}`), { workerData: { argv } });
-		const tid = nextTid++;
-		recordMainSpan("main.new_thread_worker", t_new_worker, { tid });
-		workers.push(worker);
-		worker.on("message", (msg) => {
-			const { cmd } = msg;
-			if (cmd === "loaded") {
-				if (typeof worker.unref === "function") worker.unref();
-			} else if (cmd === "thread-spawn") spawn(msg.startArg, msg.threadId, msg.memory);
-			else if (cmd === "worker-spans") {
-				if (Array.isArray(msg.workerSpans)) threadWorkerSpans.push(...msg.workerSpans);
-			} else if (cmd === "compare-event") {
-				if (msg.event) emitter.emit("compare", msg.event);
+	const attachCommonHandlers = (w) => {
+		w.on("message", (msg) => {
+			switch (msg.cmd) {
+				case "compare-event":
+					if (msg.event) emitter.emit("compare", msg.event);
+					return;
+				case "thread-spawn":
+					spawn(msg.startArg, msg.threadId, msg.memory, msg.wasmModule);
+					return;
+				case "worker-spans":
+					if (Array.isArray(msg.workerSpans)) threadWorkerSpans.push(...msg.workerSpans);
+					return;
+				case "loaded":
+					if (typeof w.unref === "function") w.unref();
+					return;
 			}
 		});
-		worker.on("error", (e) => {
-			workers.forEach((w) => w.terminate());
+		w.on("error", (e) => {
+			if (traceContext) endRootSpan(false);
+			workers.forEach((x) => x.terminate());
 			emitter.emit("error", e);
 		});
+	};
+	const spawn = (startArg, threadId, memory, wasmModule) => {
+		const t_new_worker = Date.now();
+		const w = new Worker(join(dir(), `./runner.${resolveExtention()}`), { workerData: {
+			argv,
+			mode: "thread"
+		} });
+		const tid = nextTid++;
+		recordMainSpan("main.new_thread_worker", t_new_worker, { tid });
+		workers.push(w);
+		attachCommonHandlers(w);
 		if (threadId) {
 			Atomics.store(threadId, 0, tid);
 			Atomics.notify(threadId, 0);
 		}
-		worker.postMessage({
+		w.postMessage({
 			startArg,
 			tid,
-			memory
+			memory,
+			wasmModule
 		});
 		return tid;
 	};
-	worker.on("message", async ({ cmd, startArg, threadId, memory, data, traceData, workerSpans, event }) => {
-		if (cmd === "compare-event") {
-			if (event) emitter.emit("compare", event);
-			return;
+	attachCommonHandlers(worker);
+	worker.on("message", async (msg) => {
+		if (msg.cmd !== "complete") return;
+		const { data, traceData, workerSpans } = msg;
+		const t_post_complete = Date.now();
+		if (isTracingEnabled()) {
+			if (Array.isArray(workerSpans)) processWorkerSpans(workerSpans, "entry");
+			if (threadWorkerSpans.length) processWorkerSpans(threadWorkerSpans, "thread");
+			if (traceData) processRustTraceData(traceData);
+			recordMainSpan("main.process_trace_and_spans", t_post_complete);
+			mainSpans.push({
+				name: "main.run_total",
+				start_ms: run_start_ms,
+				end_ms: Date.now(),
+				worker_label: "main"
+			});
+			processWorkerSpans(mainSpans, "main");
+			endRootSpan(true);
+			await shutdownTracing();
 		}
-		if (cmd === "complete") {
-			const t_post_complete = Date.now();
-			if (isTracingEnabled()) {
-				if (Array.isArray(workerSpans)) processWorkerSpans(workerSpans, "entry");
-				if (threadWorkerSpans.length) processWorkerSpans(threadWorkerSpans, "thread");
-				if (traceData) processRustTraceData(traceData);
-				recordMainSpan("main.process_trace_and_spans", t_post_complete);
-				mainSpans.push({
-					name: "main.run_total",
-					start_ms: run_start_ms,
-					end_ms: Date.now(),
-					worker_label: "main"
-				});
-				processWorkerSpans(mainSpans, "main");
-				endRootSpan(true);
-				await shutdownTracing();
-			}
-			workers.forEach((w) => w.terminate());
-			emitter.emit("complete", data);
-			return;
-		}
-		if (cmd === "loaded") {
-			if (typeof worker.unref === "function") worker.unref();
-			return;
-		}
-		if (cmd === "thread-spawn") spawn(startArg, threadId, memory);
-	});
-	worker.on("error", (err) => {
-		if (traceContext) endRootSpan(false);
 		workers.forEach((w) => w.terminate());
-		emitter.emit("error", err);
+		emitter.emit("complete", data);
 	});
 };
 /** Flags that `compare()` handles itself in JS; they are NOT forwarded to
@@ -160,7 +162,7 @@ const compare = (input) => {
 	inner.on("complete", async (data) => {
 		try {
 			if (restAny.additionalDetection === "client" && typeof input.report === "string") {
-				const { writeXimgdiffAssets } = await import("./ximgdiff-DzkRRnkW.mjs").then((n) => n.n);
+				const { writeXimgdiffAssets } = await import("./ximgdiff-D8GAJaxA.mjs").then((n) => n.n);
 				await writeXimgdiffAssets({
 					reportPath: input.report,
 					urlPrefix: typeof input.urlPrefix === "string" ? input.urlPrefix : "",

package/dist/runner.cjs

@@ -0,0 +1,235 @@
+const require_tracing = require("./tracing-Cf9TNPXQ.cjs");
+let node_worker_threads = require("node:worker_threads");
+let node_process = require("node:process");
+let node_fs = require("node:fs");
+node_fs = require_tracing.__toESM(node_fs, 1);
+let _tybys_wasm_util = require("@tybys/wasm-util");
+//#region src/proxy.ts
+const kIsProxy = Symbol("kIsProxy");
+const createInstanceProxy = (instance, memory) => {
+	if (instance[kIsProxy]) return instance;
+	const originalExports = instance.exports;
+	const createHandler = function(target) {
+		const handlers = [
+			"apply",
+			"construct",
+			"defineProperty",
+			"deleteProperty",
+			"get",
+			"getOwnPropertyDescriptor",
+			"getPrototypeOf",
+			"has",
+			"isExtensible",
+			"ownKeys",
+			"preventExtensions",
+			"set",
+			"setPrototypeOf"
+		];
+		const handler = {};
+		for (let i = 0; i < handlers.length; i++) {
+			const name = handlers[i];
+			handler[name] = function() {
+				const args = Array.prototype.slice.call(arguments, 1);
+				args.unshift(target);
+				return Reflect[name].apply(Reflect, args);
+			};
+		}
+		return handler;
+	};
+	const handler = createHandler(originalExports);
+	const _initialize = () => {};
+	const _start = () => 0;
+	handler.get = function(_target, p, receiver) {
+		if (p === "memory") return (typeof memory === "function" ? memory() : memory) ?? Reflect.get(originalExports, p, receiver);
+		if (p === "_initialize") return p in originalExports ? _initialize : void 0;
+		if (p === "_start") return p in originalExports ? _start : void 0;
+		return Reflect.get(originalExports, p, receiver);
+	};
+	handler.has = function(_target, p) {
+		if (p === "memory") return true;
+		return Reflect.has(originalExports, p);
+	};
+	const exportsProxy = new Proxy(Object.create(null), handler);
+	return new Proxy(instance, { get(target, p, receiver) {
+		if (p === "exports") return exportsProxy;
+		if (p === kIsProxy) return true;
+		return Reflect.get(target, p, receiver);
+	} });
+};
+//#endregion
+//#region src/progress.ts
+const MARKER = "__REG_CLI_EVT__	";
+/**
+* Build a WASI `printErr` hook that forwards progress events to `onEvent`
+* and everything else to `fallback` (defaults to `console.error`).
+*
+* `@tybys/wasm-util`'s `StandardOutput.write` already buffers until a
+* newline and invokes the callback with one stripped line per call
+* (see the `StandardOutput` class in
+* `node_modules/@tybys/wasm-util/dist/wasm-util.esm-bundler.js`). So
+* we can treat each invocation as a single complete line.
+*/
+const createPrintErrHook = (onEvent, fallback = (s) => console.error(s)) => {
+	return (line) => {
+		if (line.startsWith(MARKER)) {
+			const json = line.slice(16);
+			try {
+				const ev = JSON.parse(json);
+				if (ev && typeof ev.type === "string" && typeof ev.path === "string") {
+					onEvent(ev);
+					return;
+				}
+			} catch {}
+		}
+		fallback(line);
+	};
+};
+//#endregion
+//#region src/runner.ts
+const mode = node_worker_threads.workerData.mode;
+const isTracingEnabled = () => node_process.env.OTEL_ENABLED === "true" || node_process.env.JAEGER_ENABLED === "true";
+const argv = require_tracing.normalizeWasiArgv(node_worker_threads.workerData.argv);
+const sandbox = require_tracing.computeWasiSandbox(argv);
+const printErr = createPrintErrHook((ev) => {
+	node_worker_threads.parentPort?.postMessage({
+		cmd: "compare-event",
+		event: ev
+	});
+});
+const wasi = new _tybys_wasm_util.WASI({
+	version: "preview1",
+	args: argv,
+	env: sandbox.env,
+	returnOnExit: true,
+	preopens: sandbox.preopens,
+	fs: node_fs.default,
+	printErr
+});
+const wasmFile = mode === "entry" ? require_tracing.readWasm() : null;
+const readWasmString = (exports, memory, outputPtr) => {
+	const view = new DataView(memory.buffer, outputPtr);
+	const len = view.getUint32(0, true);
+	const bufPtr = view.getUint32(4, true);
+	const bytes = new Uint8Array(memory.buffer, bufPtr, len);
+	const s = new TextDecoder("utf-8").decode(bytes);
+	exports.free_wasm_output(outputPtr);
+	return s;
+};
+const makeSpanRecorder = (workerLabel) => {
+	const workerSpans = [];
+	const tSpan = async (name, fn, attributes) => {
+		if (!isTracingEnabled()) return fn();
+		const start_ms = Date.now();
+		const r = await fn();
+		workerSpans.push({
+			name,
+			start_ms,
+			end_ms: Date.now(),
+			attributes,
+			worker_label: workerLabel
+		});
+		return r;
+	};
+	return {
+		workerSpans,
+		tSpan
+	};
+};
+const makeThreadSpawnImport = (memory, wasmModule) => (startArg) => {
+	const buf = new SharedArrayBuffer(4);
+	const id = new Int32Array(buf);
+	Atomics.store(id, 0, -1);
+	node_worker_threads.parentPort?.postMessage({
+		cmd: "thread-spawn",
+		startArg,
+		threadId: id,
+		memory,
+		wasmModule
+	});
+	Atomics.wait(id, 0, -1);
+	return Atomics.load(id, 0);
+};
+const compileAndInstantiate = async (memory, tSpan, prefix, compiledModule) => {
+	const wasm = compiledModule ?? await tSpan(`${prefix}.wasm_compile`, async () => {
+		if (!wasmFile) throw new Error("Wasm bytes are unavailable in a thread worker");
+		return WebAssembly.compile(await wasmFile);
+	});
+	const wasi_snapshot_preview1 = require_tracing.filterWasiImports(wasm, wasi.getImportObject().wasi_snapshot_preview1);
+	return {
+		instance: await tSpan(`${prefix}.wasm_instantiate`, async () => WebAssembly.instantiate(wasm, {
+			wasi_snapshot_preview1,
+			wasi: { "thread-spawn": makeThreadSpawnImport(memory, wasm) },
+			env: { memory }
+		})),
+		module: wasm
+	};
+};
+if (mode === "entry") (async () => {
+	const entry_start_ms = Date.now();
+	const { workerSpans, tSpan } = makeSpanRecorder("entry");
+	const memory = new WebAssembly.Memory({
+		initial: 256,
+		maximum: 16384,
+		shared: true
+	});
+	const { instance } = await compileAndInstantiate(memory, tSpan, "entry");
+	const exports = instance.exports;
+	await tSpan("entry.wasi_start", async () => {
+		wasi.start(instance);
+	});
+	if (isTracingEnabled() && typeof exports.init_tracing === "function") await tSpan("entry.init_tracing_rust", async () => {
+		exports.init_tracing();
+	});
+	const m = await tSpan("entry.wasm_main", async () => exports.wasm_main());
+	const reportString = await tSpan("entry.read_report_string", async () => readWasmString(exports, memory, m));
+	const report = JSON.parse(reportString);
+	let traceData = null;
+	if (isTracingEnabled() && typeof exports.get_trace_data === "function") await tSpan("entry.collect_rust_traces", async () => {
+		const traceJson = readWasmString(exports, memory, exports.get_trace_data());
+		try {
+			traceData = JSON.parse(traceJson);
+		} catch (e) {
+			console.error("[Tracing] Failed to parse trace data:", e);
+		}
+		if (typeof exports.clear_trace_data === "function") exports.clear_trace_data();
+	});
+	if (isTracingEnabled()) workerSpans.push({
+		name: "entry.worker_total",
+		start_ms: entry_start_ms,
+		end_ms: Date.now(),
+		worker_label: "entry"
+	});
+	node_worker_threads.parentPort?.postMessage({
+		cmd: "complete",
+		data: report,
+		traceData,
+		workerSpans
+	});
+})();
+else node_worker_threads.parentPort?.addListener("message", async ({ startArg, tid, memory, wasmModule }) => {
+	const workerLabel = `thread-${tid}`;
+	const handler_start_ms = Date.now();
+	const { workerSpans, tSpan } = makeSpanRecorder(workerLabel);
+	let { instance } = await compileAndInstantiate(memory, tSpan, "worker", wasmModule);
+	instance = createInstanceProxy(instance, memory);
+	await tSpan("worker.wasi_start", async () => {
+		wasi.start(instance);
+	});
+	await tSpan("worker.wasi_thread_start", async () => {
+		instance.exports.wasi_thread_start(tid, startArg);
+	}, { tid });
+	if (isTracingEnabled()) {
+		workerSpans.push({
+			name: "worker.thread_total",
+			start_ms: handler_start_ms,
+			end_ms: Date.now(),
+			worker_label: workerLabel,
+			attributes: { tid }
+		});
+		node_worker_threads.parentPort?.postMessage({
+			cmd: "worker-spans",
+			workerSpans
+		});
+	}
+});
+//#endregion