reg-cli 0.19.0-rc0 → 0.19.0-rc2

package/dist/runner.mjs

@@ -0,0 +1,235 @@
+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 = mode === "entry" ? 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);
+	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 = 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"
+	});
+	parentPort?.postMessage({
+		cmd: "complete",
+		data: report,
+		traceData,
+		workerSpans
+	});
+})();
+else 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 }
+		});
+		parentPort?.postMessage({
+			cmd: "worker-spans",
+			workerSpans
+		});
+	}
+});
+//#endregion
+export {};