reg-cli 0.18.16 → 0.19.0-rc1

package/dist/index.mjs

@@ -0,0 +1,207 @@
+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";
+import { dirname, join } from "node:path";
+//#region src/index.ts
+const dir = () => {
+	return isCJS ? __dirname : dirname(fileURLToPath(import.meta.url));
+};
+const mainSpans = [];
+const recordMainSpan = (name, start_ms, attributes) => {
+	if (!isTracingEnabled()) return;
+	mainSpans.push({
+		name,
+		start_ms,
+		end_ms: Date.now(),
+		attributes,
+		worker_label: "main"
+	});
+};
+const run = (argv) => {
+	const emitter = new EventEmitter();
+	setImmediate(() => emitter.emit("start"));
+	runInternal(argv, emitter);
+	return emitter;
+};
+const runInternal = async (argv, emitter) => {
+	const run_start_ms = Date.now();
+	const t_init = Date.now();
+	if (isTracingEnabled()) {
+		await initTracing();
+		recordMainSpan("main.init_tracing", t_init);
+	}
+	const traceContext = isTracingEnabled() ? startRootSpan("reg-cli") : null;
+	const t_new_entry = Date.now();
+	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 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);
+					return;
+				case "worker-spans":
+					if (Array.isArray(msg.workerSpans)) threadWorkerSpans.push(...msg.workerSpans);
+					return;
+				case "loaded":
+					if (typeof w.unref === "function") w.unref();
+					return;
+			}
+		});
+		w.on("error", (e) => {
+			if (traceContext) endRootSpan(false);
+			workers.forEach((x) => x.terminate());
+			emitter.emit("error", e);
+		});
+	};
+	const spawn = (startArg, threadId, memory) => {
+		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);
+		}
+		w.postMessage({
+			startArg,
+			tid,
+			memory
+		});
+		return tid;
+	};
+	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();
+		}
+		workers.forEach((w) => w.terminate());
+		emitter.emit("complete", data);
+	});
+};
+/** Flags that `compare()` handles itself in JS; they are NOT forwarded to
+*  the Wasm binary. `extendedErrors` WAS here but now also feeds the
+*  Rust-side junit generator, so it's forwarded below via KEY_REMAP.
+*
+*  `ignoreChange` and `enableCliAdditionalDetection` are stripped because
+*  reg-suit unconditionally passes them (see
+*  reg-viz/reg-suit `packages/reg-suit-core/src/processor.ts` `compare({…})`)
+*  and the Rust clap layer doesn't recognise them — forwarding would abort
+*  the binary with "unexpected argument". Semantically both are no-ops at
+*  the library-event layer:
+*    - `ignoreChange` only governs classic reg-cli's process exit code;
+*      the EventEmitter surface never needed it.
+*    - `enableCliAdditionalDetection` was classic's flag for running an
+*      extra CLI-side x-img-diff pass; the Wasm port's diff pipeline
+*      already produces the final pass/fail classification, so toggling
+*      it changes nothing. (The *client*-side variant is handled via
+*      `additionalDetection: 'client'` / the legacy
+*      `enableClientAdditionalDetection: true` alias further down.) */
+const CLI_ONLY_KEYS = new Set([
+	"update",
+	"ignoreChange",
+	"enableCliAdditionalDetection"
+]);
+/** Library option names that must be forwarded to the Wasm binary under a
+*  different flag name (Rust uses `--junit`, callers pass `junitReport`). */
+const KEY_REMAP = { junitReport: "junit" };
+const compare = (input) => {
+	const { actualDir, expectedDir, diffDir, threshold, update, ...rest } = input;
+	if (rest.diffFormat == null) rest.diffFormat = "png";
+	if (rest.json == null) rest.json = "./reg.json";
+	if (threshold != null && rest.thresholdRate == null) rest.thresholdRate = threshold;
+	const restAny = rest;
+	if (restAny.enableClientAdditionalDetection && restAny.additionalDetection == null) restAny.additionalDetection = "client";
+	delete restAny.enableClientAdditionalDetection;
+	for (const k of CLI_ONLY_KEYS) delete rest[k];
+	const inner = run([
+		"--",
+		actualDir,
+		expectedDir,
+		diffDir,
+		...Object.entries(rest).flatMap(([k, v]) => {
+			if (v == null || v === "") return [];
+			return [`--${KEY_REMAP[k] ?? k}`, String(v)];
+		})
+	]);
+	const outer = new EventEmitter();
+	inner.on("start", () => outer.emit("start"));
+	inner.on("compare", (p) => outer.emit("compare", p));
+	inner.on("error", (e) => outer.emit("error", e));
+	inner.on("complete", async (data) => {
+		try {
+			if (restAny.additionalDetection === "client" && typeof input.report === "string") {
+				const { writeXimgdiffAssets } = await import("./ximgdiff-D8GAJaxA.mjs").then((n) => n.n);
+				await writeXimgdiffAssets({
+					reportPath: input.report,
+					urlPrefix: typeof input.urlPrefix === "string" ? input.urlPrefix : "",
+					distDir: dir()
+				});
+			}
+			if (update) {
+				await updateExpected(actualDir, expectedDir, {
+					newItems: data.newItems ?? [],
+					failedItems: data.failedItems ?? [],
+					deletedItems: data.deletedItems ?? []
+				});
+				outer.emit("update");
+			}
+		} catch (e) {
+			outer.emit("error", e);
+			return;
+		}
+		outer.emit("complete", data);
+	});
+	return outer;
+};
+async function writeRegJson(path, data) {
+	const { writeFile, mkdir } = await import("node:fs/promises");
+	const { dirname } = await import("node:path");
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+async function updateExpected(actualDir, expectedDir, items) {
+	const { mkdir, copyFile, rm } = await import("node:fs/promises");
+	const { dirname, join } = await import("node:path");
+	const toRemove = [...items.deletedItems, ...items.failedItems];
+	for (const img of toRemove) await rm(join(expectedDir, img), { force: true });
+	const toCopy = [...items.newItems, ...items.failedItems];
+	for (const img of toCopy) {
+		const src = join(actualDir, img);
+		const dst = join(expectedDir, img);
+		await mkdir(dirname(dst), { recursive: true });
+		await copyFile(src, dst);
+	}
+}
+//#endregion
+export { compare, dir, run, writeRegJson };

package/dist/runner.cjs

@@ -0,0 +1,228 @@
+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 = require_tracing.readWasm();
+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) => (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
+	});
+	Atomics.wait(id, 0, -1);
+	return Atomics.load(id, 0);
+};
+const compileAndInstantiate = async (memory, tSpan, prefix) => {
+	const wasm = await tSpan(`${prefix}.wasm_compile`, async () => WebAssembly.compile(await wasmFile));
+	const wasi_snapshot_preview1 = require_tracing.filterWasiImports(wasm, wasi.getImportObject().wasi_snapshot_preview1);
+	return tSpan(`${prefix}.wasm_instantiate`, async () => WebAssembly.instantiate(wasm, {
+		wasi_snapshot_preview1,
+		wasi: { "thread-spawn": makeThreadSpawnImport(memory) },
+		env: { memory }
+	}));
+};
+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 }) => {
+	const workerLabel = `thread-${tid}`;
+	const handler_start_ms = Date.now();
+	const { workerSpans, tSpan } = makeSpanRecorder(workerLabel);
+	let instance = await compileAndInstantiate(memory, tSpan, "worker");
+	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

package/dist/runner.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/runner.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/runner.mjs

@@ -0,0 +1,228 @@
+import { c as computeWasiSandbox, d as normalizeWasiArgv, f as readWasm, l as filterWasiImports } from "./tracing-Bo38b9aR.mjs";
+import { parentPort, workerData } from "node:worker_threads";
+import { env } from "node:process";
+import fs from "node:fs";
+import { WASI } from "@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 = workerData.mode;
+const isTracingEnabled = () => env.OTEL_ENABLED === "true" || env.JAEGER_ENABLED === "true";
+const argv = normalizeWasiArgv(workerData.argv);
+const sandbox = computeWasiSandbox(argv);
+const printErr = createPrintErrHook((ev) => {
+	parentPort?.postMessage({
+		cmd: "compare-event",
+		event: ev
+	});
+});
+const wasi = new WASI({
+	version: "preview1",
+	args: argv,
+	env: sandbox.env,
+	returnOnExit: true,
+	preopens: sandbox.preopens,
+	fs,
+	printErr
+});
+const wasmFile = readWasm();
+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) => (startArg) => {
+	const buf = new SharedArrayBuffer(4);
+	const id = new Int32Array(buf);
+	Atomics.store(id, 0, -1);
+	parentPort?.postMessage({
+		cmd: "thread-spawn",
+		startArg,
+		threadId: id,
+		memory
+	});
+	Atomics.wait(id, 0, -1);
+	return Atomics.load(id, 0);
+};
+const compileAndInstantiate = async (memory, tSpan, prefix) => {
+	const wasm = await tSpan(`${prefix}.wasm_compile`, async () => WebAssembly.compile(await wasmFile));
+	const wasi_snapshot_preview1 = filterWasiImports(wasm, wasi.getImportObject().wasi_snapshot_preview1);
+	return tSpan(`${prefix}.wasm_instantiate`, async () => WebAssembly.instantiate(wasm, {
+		wasi_snapshot_preview1,
+		wasi: { "thread-spawn": makeThreadSpawnImport(memory) },
+		env: { memory }
+	}));
+};
+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"
+	});
+	parentPort?.postMessage({
+		cmd: "complete",
+		data: report,
+		traceData,
+		workerSpans
+	});
+})();
+else parentPort?.addListener("message", async ({ startArg, tid, memory }) => {
+	const workerLabel = `thread-${tid}`;
+	const handler_start_ms = Date.now();
+	const { workerSpans, tSpan } = makeSpanRecorder(workerLabel);
+	let instance = await compileAndInstantiate(memory, tSpan, "worker");
+	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 }
+		});
+		parentPort?.postMessage({
+			cmd: "worker-spans",
+			workerSpans
+		});
+	}
+});
+//#endregion
+export {};