@omni-oss/task-bench 0.0.0-beta.1

package/dist/src-D3XyMXAu.mjs

@@ -0,0 +1,1167 @@
+import { existsSync as e, readFileSync as t, writeFileSync as n } from "node:fs";
+import { cpus as r, tmpdir as i } from "node:os";
+import { dirname as a, join as o } from "node:path";
+import { mkdir as s, readFile as c, rm as l, writeFile as u } from "node:fs/promises";
+import { performance as d } from "node:perf_hooks";
+import { execa as f } from "execa";
+import { z as p } from "zod";
+import { satisfies as m } from "semver";
+import { stringify as h } from "yaml";
+//#region package.json
+var g = "@omni-oss/task-bench", _ = "Generate configurable test workspaces and benchmark omni/turbo/nx task execution performance", v = "0.0.0-beta.1", y = [
+	"isolated",
+	"chain",
+	"fan-out",
+	"layered",
+	"random"
+], b = p.enum(y), x = [
+	"omni",
+	"turbo",
+	"nx",
+	"moon"
+], S = p.enum(x), C = p.object({
+	strategy: b.default("layered").describe("Shape of the inter-project dependency graph."),
+	layers: p.number().int().positive().default(5).describe("Number of layers for the `layered` strategy."),
+	fanout: p.number().int().nonnegative().default(3).describe("Maximum number of upstream dependencies per project (cap for `layered`/`random`)."),
+	edgeProbability: p.number().min(0).max(1).default(.35).describe("Edge inclusion probability for the `random` strategy.")
+}).prefault({}), w = p.object({
+	logLines: p.number().int().nonnegative().default(25).describe("How many log lines each task prints to stdout."),
+	workIterations: p.number().int().nonnegative().default(15e4).describe("Iterations of cheap CPU work per task. Keep small so caching dominates."),
+	outputFiles: p.number().int().positive().default(1).describe("Number of output files each task writes into dist/."),
+	chainWithinProject: p.boolean().default(!0).describe("Whether task `tN` depends on `t(N-1)` within a project."),
+	fanUpstream: p.boolean().default(!0).describe("Whether task `tN` depends on `tN` of upstream projects (^tN).")
+}).prefault({}), T = p.object({
+	turbo: p.string().default("2.10.3"),
+	nx: p.string().default("23.0.1"),
+	moon: p.string().default("2.3.5"),
+	bun: p.string().default("1.3.14")
+}).prefault({}), E = p.object({
+	seed: p.number().int().nonnegative().default(1).describe("Seed for deterministic graph generation."),
+	projectPrefix: p.string().regex(/^[a-z][a-z0-9-]*$/).default("bench-p").describe("Prefix used for generated package names."),
+	projects: p.number().int().positive().default(50).describe("Number of projects to generate."),
+	tasksPerProject: p.number().int().positive().default(3).describe("Number of tasks (t0..tN-1) per project."),
+	dependency: C,
+	task: w,
+	tools: p.array(S).min(1).default([...x]).describe("Which runners to configure and benchmark."),
+	versions: T
+});
+function D(e) {
+	return E.parse(e ?? {});
+}
+//#endregion
+//#region src/graph.ts
+function ee(e) {
+	let t = e >>> 0;
+	return () => {
+		t = t + 1831565813 | 0;
+		let e = Math.imul(t ^ t >>> 15, 1 | t);
+		return e = e + Math.imul(e ^ e >>> 7, 61 | e) ^ e, ((e ^ e >>> 14) >>> 0) / 4294967296;
+	};
+}
+function te(e) {
+	return Math.max(4, String(e - 1).length);
+}
+function O(e, t) {
+	let n = te(e.projects);
+	return `${e.projectPrefix}${String(t).padStart(n, "0")}`;
+}
+function ne(e, t, n) {
+	let r = t - e + 1;
+	if (r <= 0 || n <= 0) return [];
+	if (n >= r) return Array.from({ length: r }, (t, n) => e + n);
+	let i = [];
+	for (let t = 0; t < n; t++) {
+		let a = Math.round(t * (r - 1) / (n - 1 || 1));
+		i.push(e + a);
+	}
+	return [...new Set(i)];
+}
+function re(e, t, n) {
+	let { strategy: r, layers: i, fanout: a, edgeProbability: o } = e.dependency;
+	switch (r) {
+		case "isolated": return [];
+		case "chain": return t > 0 ? [t - 1] : [];
+		case "fan-out": return t > 0 ? [0] : [];
+		case "layered": {
+			let n = Math.ceil(e.projects / i), r = Math.floor(t / n);
+			return r === 0 ? [] : ne((r - 1) * n, Math.min(r * n, e.projects) - 1, a);
+		}
+		case "random": {
+			if (t === 0) return [];
+			let e = [];
+			for (let r = 0; r < t; r++) n() < o && e.push(r);
+			return a > 0 && e.length > a ? e.slice(e.length - a) : e;
+		}
+		default: return [];
+	}
+}
+function k(e) {
+	let t = ee(e.seed), n = [];
+	for (let r = 0; r < e.projects; r++) {
+		let i = O(e, r);
+		n.push({
+			index: r,
+			name: i,
+			dir: `packages/${i}`,
+			dependencies: re(e, r, t)
+		});
+	}
+	return n;
+}
+function A(e) {
+	return Array.from({ length: e.tasksPerProject }, (e, t) => `t${t}`);
+}
+//#endregion
+//#region src/tools/types.ts
+function j(t, n) {
+	let r = o(t, "node_modules", ".bin", n);
+	return e(r) ? r : n;
+}
+async function M(e) {
+	await Promise.all(e.projectDirs.map((t) => l(o(e.rootDir, t, "dist"), {
+		recursive: !0,
+		force: !0
+	})));
+}
+function N(e, t) {
+	let n = [];
+	return e.task.chainWithinProject && t > 0 && n.push(`t${t - 1}`), e.task.fanUpstream && n.push(`^t${t}`), n;
+}
+function ie(e, t) {
+	return e.dependencies.map((e) => t[e]?.name ?? "");
+}
+//#endregion
+//#region src/tools/moon.ts
+var ae = "https://moonrepo.dev/schemas/workspace.json", oe = "https://moonrepo.dev/schemas/toolchain.json", se = "https://moonrepo.dev/schemas/project.json";
+function ce(e, t) {
+	let n = [];
+	return e.task.chainWithinProject && t > 0 && n.push(`~:t${t - 1}`), e.task.fanUpstream && n.push(`^:t${t}`), n;
+}
+function le() {
+	return h({
+		$schema: ae,
+		projects: ["packages/*"]
+	});
+}
+function ue() {
+	return h({ $schema: oe });
+}
+function de(e, t, n) {
+	let r = {};
+	return A(e).forEach((t, n) => {
+		let i = ce(e, n);
+		r[t] = {
+			command: `node ./task.mjs ${t}`,
+			...i.length ? { deps: i } : {},
+			inputs: [
+				"package.json",
+				"task.mjs",
+				"src/**/*"
+			],
+			outputs: [`dist/${t}.*`]
+		};
+	}), h({
+		$schema: se,
+		id: t.name,
+		layer: "library",
+		language: "javascript",
+		...t.dependencies.length ? { dependsOn: ie(t, n) } : {},
+		tasks: r
+	});
+}
+var fe = {
+	tool: "moon",
+	hasDaemon: !1,
+	supportedVersions: ["^2.0.0"],
+	pinnedVersion: (e) => e.versions.moon,
+	devDependencies: (e) => ({ "@moonrepo/cli": e.versions.moon }),
+	setup: async (e) => {
+		await e.write(".moon/workspace.yml", le()), await e.write(".moon/toolchain.yml", ue());
+		for (let t of e.projects) await e.write(`${t.dir}/moon.yml`, de(e.config, t, e.projects));
+	},
+	run: (e, t) => ({
+		file: j(t.rootDir, "moon"),
+		args: [
+			"run",
+			`:${e}`,
+			"--concurrency",
+			String(t.concurrency)
+		]
+	}),
+	env: () => ({}),
+	clearCaches: async (e) => {
+		await M(e), await l(o(e.rootDir, ".moon", "cache"), {
+			recursive: !0,
+			force: !0
+		});
+	},
+	stopDaemon: async () => {}
+};
+//#endregion
+//#region src/tools/nx.ts
+function pe(e) {
+	let t = {};
+	return A(e).forEach((n, r) => {
+		t[n] = {
+			dependsOn: N(e, r),
+			cache: !0,
+			outputs: [`{projectRoot}/dist/${n}.*`],
+			inputs: [
+				"{projectRoot}/package.json",
+				"{projectRoot}/task.mjs",
+				"{projectRoot}/src/**/*"
+			]
+		};
+	}), `${JSON.stringify({
+		$schema: "./node_modules/nx/schemas/nx-schema.json",
+		targetDefaults: t
+	}, null, 2)}\n`;
+}
+function me(e, t) {
+	let n = {};
+	for (let r of A(e)) n[r] = {
+		executor: "nx:run-commands",
+		options: {
+			command: `node ./task.mjs ${r}`,
+			cwd: t.dir
+		}
+	};
+	return `${JSON.stringify({
+		name: t.name,
+		$schema: "../../node_modules/nx/schemas/project-schema.json",
+		targets: n
+	}, null, 2)}\n`;
+}
+var he = {
+	tool: "nx",
+	hasDaemon: !0,
+	supportedVersions: [">=21.0.0 <24.0.0"],
+	pinnedVersion: (e) => e.versions.nx,
+	devDependencies: (e) => ({ nx: e.versions.nx }),
+	setup: async (e) => {
+		await e.write("nx.json", pe(e.config));
+		for (let t of e.projects) await e.write(`${t.dir}/project.json`, me(e.config, t));
+	},
+	run: (e, t) => ({
+		file: j(t.rootDir, "nx"),
+		args: [
+			"run-many",
+			"-t",
+			e,
+			`--parallel=${t.concurrency}`
+		]
+	}),
+	env: (e) => ({
+		NX_DAEMON: e.daemon ? "true" : "false",
+		NX_TUI: "false"
+	}),
+	clearCaches: async (e) => {
+		await M(e), await f(j(e.rootDir, "nx"), ["reset"], {
+			cwd: e.rootDir,
+			reject: !1,
+			stdio: "ignore",
+			env: {
+				NX_DAEMON: e.daemon ? "true" : "false",
+				NX_TUI: "false"
+			}
+		});
+	},
+	stopDaemon: async (e) => {
+		await f(j(e.rootDir, "nx"), ["reset"], {
+			cwd: e.rootDir,
+			reject: !1,
+			stdio: "ignore",
+			env: { NX_DAEMON: "false" }
+		});
+	}
+}, ge = "# yaml-language-server: $schema=https://raw.githubusercontent.com/omni-oss/json-schemas/refs/heads/main/project.json", _e = "# yaml-language-server: $schema=https://raw.githubusercontent.com/omni-oss/json-schemas/refs/heads/main/workspace.json";
+function ve() {
+	return `${_e}\n${h({
+		ui: "stream",
+		projects: ["packages/*"]
+	})}`;
+}
+function ye(e, t, n) {
+	let r = {};
+	return A(e).forEach((t, n) => {
+		let i = N(e, n);
+		r[t] = {
+			exec: `node ./task.mjs ${t}`,
+			...i.length ? { dependencies: i } : {},
+			cache: { output: { files: [`dist/${t}.*`] } }
+		};
+	}), `${ge}\n${h({
+		name: t.name,
+		...t.dependencies.length ? { dependencies: ie(t, n) } : {},
+		cache: { key: { files: [
+			"package.json",
+			"task.mjs",
+			"src/**/*.js"
+		] } },
+		tasks: r
+	})}`;
+}
+var be = {
+	tool: "omni",
+	hasDaemon: !1,
+	supportedVersions: [">=0.16.0"],
+	pinnedVersion: () => null,
+	detectVersion: async (e) => {
+		let t = await f("omni", ["--version"], {
+			cwd: e,
+			reject: !1
+		});
+		return `${t.stdout} ${t.stderr}`.match(/(\d+\.\d+\.\d+[\w.-]*)/)?.[1] ?? null;
+	},
+	devDependencies: () => ({}),
+	setup: async (e) => {
+		await e.write("workspace.omni.yaml", ve());
+		for (let t of e.projects) await e.write(`${t.dir}/project.omni.yaml`, ye(e.config, t, e.projects));
+	},
+	run: (e, t) => ({
+		file: "omni",
+		args: [
+			"run",
+			e,
+			"-u",
+			"stream",
+			"-c",
+			String(t.concurrency)
+		]
+	}),
+	env: () => ({}),
+	clearCaches: async (e) => {
+		await M(e), await l(o(e.rootDir, ".omni", "cache"), {
+			recursive: !0,
+			force: !0
+		});
+	},
+	stopDaemon: async () => {}
+};
+//#endregion
+//#region src/tools/turbo.ts
+function xe(e) {
+	let t = {};
+	return A(e).forEach((n, r) => {
+		t[n] = {
+			dependsOn: N(e, r),
+			outputs: [`dist/${n}.*`],
+			inputs: [
+				"package.json",
+				"task.mjs",
+				"src/**"
+			]
+		};
+	}), `${JSON.stringify({
+		$schema: "https://turbo.build/schema.json",
+		globalPassThroughEnv: ["TASK_BENCH_EXEC_LOG"],
+		tasks: t
+	}, null, 2)}\n`;
+}
+//#endregion
+//#region src/tools/index.ts
+var Se = {
+	omni: be,
+	turbo: {
+		tool: "turbo",
+		hasDaemon: !0,
+		supportedVersions: ["^2.0.0"],
+		pinnedVersion: (e) => e.versions.turbo,
+		devDependencies: (e) => ({ turbo: e.versions.turbo }),
+		setup: async (e) => {
+			await e.write("turbo.json", xe(e.config));
+		},
+		run: (e, t) => ({
+			file: j(t.rootDir, "turbo"),
+			args: [
+				"run",
+				e,
+				"--log-order=stream",
+				`--concurrency=${t.concurrency}`,
+				t.daemon ? "--daemon" : "--no-daemon"
+			]
+		}),
+		env: () => ({}),
+		clearCaches: async (e) => {
+			await M(e), await l(o(e.rootDir, ".turbo"), {
+				recursive: !0,
+				force: !0
+			}), await l(o(e.rootDir, "node_modules", ".cache", "turbo"), {
+				recursive: !0,
+				force: !0
+			});
+		},
+		stopDaemon: async (e) => {
+			await f(j(e.rootDir, "turbo"), ["daemon", "stop"], {
+				cwd: e.rootDir,
+				reject: !1,
+				stdio: "ignore"
+			});
+		}
+	},
+	nx: he,
+	moon: fe
+};
+function P(e) {
+	return Se[e];
+}
+function F(e) {
+	return e.map(P);
+}
+function I(e, t) {
+	if (!e.supportedVersions.some((e) => m(t, e, {
+		includePrerelease: !0,
+		loose: !0
+	}))) throw Error(`${e.tool} version "${t}" is not supported by task-bench (supported: ${e.supportedVersions.join(" || ")}). Adjust versions.${e.tool} in your config or upgrade/downgrade the tool.`);
+}
+async function L(e, t, n = e.tools) {
+	let r = /* @__PURE__ */ new Map();
+	for (let i of n) {
+		let n = P(i), a = n.pinnedVersion(e);
+		a === null && n.detectVersion && (a = await n.detectVersion(t)), a !== null && I(n, a), r.set(i, a);
+	}
+	return r;
+}
+//#endregion
+//#region src/bench/stats.ts
+function R(e) {
+	if (e.length === 0) return {
+		samples: e,
+		min: 0,
+		max: 0,
+		mean: 0,
+		median: 0,
+		stddev: 0
+	};
+	let t = [...e].sort((e, t) => e - t), n = t.reduce((e, t) => e + t, 0) / t.length, r = Math.floor(t.length / 2), i = t.length % 2 == 0 ? ((t[r - 1] ?? 0) + (t[r] ?? 0)) / 2 : t[r] ?? 0, a = t.reduce((e, t) => e + (t - n) ** 2, 0) / t.length;
+	return {
+		samples: e,
+		min: t[0] ?? 0,
+		max: t[t.length - 1] ?? 0,
+		mean: n,
+		median: i,
+		stddev: Math.sqrt(a)
+	};
+}
+function z(e) {
+	return e >= 1e3 ? `${(e / 1e3).toFixed(2)}s` : `${e.toFixed(0)}ms`;
+}
+//#endregion
+//#region src/bench/index.ts
+function Ce(e) {
+	if (e.length === 0) return 0;
+	let t = [...e].sort((e, t) => e - t), n = Math.floor(t.length / 2);
+	return t.length % 2 == 0 ? ((t[n - 1] ?? 0) + (t[n] ?? 0)) / 2 : t[n] ?? 0;
+}
+function we(e) {
+	try {
+		let n = t(e, "utf8");
+		if (n.length === 0) return 0;
+		let r = 0;
+		for (let e = 0; e < n.length; e++) n[e] === "\n" && r++;
+		return r;
+	} catch {
+		return 0;
+	}
+}
+async function B(e, t, r, i, a) {
+	n(i, "");
+	let o = d.now(), s = await f(e, t, {
+		cwd: r,
+		reject: !1,
+		env: {
+			FORCE_COLOR: "0",
+			TURBO_TELEMETRY_DISABLED: "1",
+			DO_NOT_TRACK: "1",
+			NX_TUI: "false",
+			TASK_BENCH_EXEC_LOG: i,
+			...a
+		}
+	}), c = d.now() - o, l = typeof s.stdout == "string" ? s.stdout : "", u = typeof s.stderr == "string" ? s.stderr : "";
+	return {
+		durationMs: c,
+		exitCode: s.exitCode ?? -1,
+		stdout: l,
+		stderr: u,
+		executed: we(i),
+		ok: s.exitCode === 0
+	};
+}
+function V(e) {
+	return {
+		runs: e.length,
+		failures: e.filter((e) => !e.ok).length,
+		stats: R(e.map((e) => e.durationMs)),
+		executedMedian: Ce(e.map((e) => e.executed))
+	};
+}
+async function H(e, t = {}) {
+	let n = JSON.parse(await c(o(e, "bench.config.json"), "utf8")), a = E.parse(n), s = k(a), l = A(a), u = t.tools ?? a.tools, d = t.task ?? l[l.length - 1] ?? "t0", f = t.coldRuns ?? 3, p = t.warmRuns ?? 5, m = t.concurrency ?? Math.max(1, r().length), h = t.daemon ?? !0, g = t.onEvent ?? (() => {}), _ = o(i(), `task-bench-exec-${process.pid}-${Date.now()}.log`), v = {
+		rootDir: e,
+		projectDirs: s.map((e) => e.dir),
+		concurrency: m,
+		daemon: h
+	}, y = await L(a, e, u), b = {};
+	for (let [e, t] of y) b[e] = t;
+	let x = [];
+	for (let t of u) {
+		g({
+			kind: "tool-start",
+			tool: t
+		});
+		let n = P(t), r = n.run(d, v), i = n.env(v);
+		try {
+			!h && n.hasDaemon && await n.stopDaemon(v);
+			let a = [];
+			for (let o = 1; o <= f; o++) {
+				await n.clearCaches(v), h && n.hasDaemon && await n.stopDaemon(v);
+				let s = await B(r.file, r.args, e, _, i);
+				a.push(s), g({
+					kind: "scenario",
+					tool: t,
+					scenario: "cold",
+					run: o,
+					total: f,
+					sample: s
+				}), s.exitCode !== 0 && g({
+					kind: "tool-unsuccessful",
+					tool: t,
+					sample: s
+				});
+			}
+			await B(r.file, r.args, e, _, i);
+			let o = [];
+			for (let n = 1; n <= p; n++) {
+				let a = await B(r.file, r.args, e, _, i);
+				o.push(a), g({
+					kind: "scenario",
+					tool: t,
+					scenario: "warm",
+					run: n,
+					total: p,
+					sample: a
+				}), a.exitCode !== 0 && g({
+					kind: "tool-unsuccessful",
+					tool: t,
+					sample: a
+				});
+			}
+			let s = Math.max(0, ...a.map((e) => e.executed), ...o.map((e) => e.executed));
+			x.push({
+				tool: t,
+				task: d,
+				taskGraphSize: s,
+				cold: V(a),
+				warm: V(o)
+			});
+		} catch (e) {
+			let n = e instanceof Error ? e.message : String(e);
+			g({
+				kind: "tool-error",
+				tool: t,
+				error: n
+			}), x.push({
+				tool: t,
+				task: d,
+				taskGraphSize: 0,
+				cold: V([]),
+				warm: V([]),
+				error: n
+			});
+		} finally {
+			await n.stopDaemon(v);
+		}
+	}
+	return {
+		rootDir: e,
+		task: d,
+		projects: a.projects,
+		tasksPerProject: a.tasksPerProject,
+		concurrency: m,
+		daemon: h,
+		versions: b,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		tools: x
+	};
+}
+//#endregion
+//#region src/bench/install.ts
+async function U(e, t = {}) {
+	await f("bun", ["install"], {
+		cwd: e,
+		stdio: t.quiet ? "ignore" : "inherit"
+	});
+}
+//#endregion
+//#region src/bench/report.ts
+function Te(e, t) {
+	return e.length >= t ? e : e + " ".repeat(t - e.length);
+}
+function W(e, t) {
+	if (e.samples.length === 0) return "—";
+	let n = `${z(e.median)} ±${z(e.stddev)}`;
+	return t > 0 ? `${n} ⚠${t}` : n;
+}
+function G(e) {
+	return e.taskGraphSize <= 0 || e.warm.stats.samples.length === 0 ? null : (e.taskGraphSize - e.warm.executedMedian) / e.taskGraphSize * 100;
+}
+function K(e) {
+	let t = G(e);
+	return t === null ? "—" : `${t.toFixed(0)}%`;
+}
+function Ee(e) {
+	let t = [], n = Math.max(0, ...e.tools.map((e) => e.taskGraphSize));
+	t.push(""), t.push(`task-bench: ${e.projects} projects × ${e.tasksPerProject} tasks (${n} task-graph nodes), running "${e.task}" at concurrency ${e.concurrency} (daemons ${e.daemon ? "on" : "off"})`), t.push(De(e)), t.push("");
+	let r = [
+		"tool",
+		"cold (median)",
+		"warm (median)",
+		"warm cache-hit",
+		"notes"
+	], i = e.tools.map((e) => {
+		let t = e.error ? `error: ${(e.error.split("\n")[0] ?? "").slice(0, 40)}` : "";
+		return [
+			e.tool,
+			W(e.cold.stats, e.cold.failures),
+			W(e.warm.stats, e.warm.failures),
+			K(e),
+			t
+		];
+	}), a = r.map((e, t) => Math.max(e.length, ...i.map((e) => (e[t] ?? "").length))), o = (e) => `| ${e.map((e, t) => Te(e, a[t] ?? 0)).join(" | ")} |`;
+	t.push(o(r)), t.push(`| ${a.map((e) => "-".repeat(e)).join(" | ")} |`);
+	for (let e of i) t.push(o(e));
+	t.push("");
+	let s = e.tools.filter((e) => {
+		let t = G(e);
+		return t !== null && t < 99.5;
+	});
+	for (let e of s) t.push(`⚠ ${e.tool}: warm runs were not fully cached (${K(e)} hit, ${e.warm.executedMedian}/${e.taskGraphSize} tasks re-ran) — treat its warm number with caution.`);
+	s.length && t.push("");
+	let c = e.tools.filter((e) => {
+		let t = G(e);
+		return !e.error && t !== null && t >= 99.5;
+	}).sort((e, t) => e.warm.stats.median - t.warm.stats.median), l = c[0], u = c[c.length - 1];
+	if (c.length > 1 && l && u) {
+		let e = u.warm.stats.median / l.warm.stats.median;
+		t.push(`Warm-cache overhead: ${l.tool} is fastest (${z(l.warm.stats.median)}), ${e.toFixed(2)}× faster than ${u.tool} (${z(u.warm.stats.median)}).\n`);
+	}
+	let d = e.tools.filter((e) => !e.error && e.cold.stats.samples.length > 0).sort((e, t) => e.cold.stats.median - t.cold.stats.median), f = d[0], p = d[d.length - 1];
+	if (d.length > 1 && f && p) {
+		let e = p.cold.stats.median / f.cold.stats.median;
+		t.push(`Cold-run overhead: ${f.tool} is fastest (${z(f.cold.stats.median)}), ${e.toFixed(2)}× faster than ${p.tool} (${z(p.cold.stats.median)}).`);
+	}
+	return (c.length > 1 || d.length > 1) && t.push(""), t.join("\n");
+}
+function De(e) {
+	return `versions: ${e.tools.map((t) => `\`${t.tool} ${e.versions[t.tool] ?? "?"}\``).join(", ")}`;
+}
+//#endregion
+//#region src/generate/templates.ts
+function Oe(e) {
+	return [
+		`// Auto-generated source for ${e.name}.`,
+		"// Edit the harness config, not this file.",
+		`export const id = ${JSON.stringify(e.name)};`,
+		`export const index = ${e.index};`,
+		"export const answer = 42;",
+		""
+	].join("\n");
+}
+function ke(e, t) {
+	let { logLines: n, workIterations: r, outputFiles: i } = e.task;
+	return `#!/usr/bin/env node
+import { createHash } from "node:crypto";
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const PROJECT = ${JSON.stringify(t.name)};
+const LOG_LINES = ${n};
+const WORK_ITERATIONS = ${r};
+const OUTPUT_FILES = ${i};
+
+const task = process.argv[2] ?? "task";
+
+// Ground-truth execution marker: this line is only ever reached when the task
+// actually runs. Cache hits skip the process entirely, so counting the lines
+// in this out-of-tree log yields a tool-agnostic cache-hit rate. The log path
+// lives outside the workspace so no runner hashes it as an input.
+const execLog = process.env.TASK_BENCH_EXEC_LOG;
+if (execLog) {
+    appendFileSync(execLog, \`\${PROJECT}\\t\${task}\\n\`);
+}
+
+const source = readFileSync(join(HERE, "src", "index.js"), "utf8");
+
+// Cheap, deterministic CPU work.
+let acc = 0;
+for (let i = 0; i < WORK_ITERATIONS; i++) {
+    acc = (acc + Math.imul(i ^ acc, 2654435761)) >>> 0;
+}
+
+const digest = createHash("sha256")
+    .update(source)
+    .update(task)
+    .update(String(acc))
+    .digest("hex");
+
+for (let i = 1; i <= LOG_LINES; i++) {
+    console.log(\`[\${PROJECT}] \${task}: step \${i}/\${LOG_LINES} digest=\${digest.slice(0, 12)}\`);
+}
+
+const outDir = join(HERE, "dist");
+mkdirSync(outDir, { recursive: true });
+for (let f = 0; f < OUTPUT_FILES; f++) {
+    writeFileSync(
+        join(outDir, \`\${task}.\${f}.txt\`),
+        \`\${PROJECT}\\t\${task}\\t\${digest}\\n\`,
+    );
+}
+
+console.log(\`[\${PROJECT}] \${task}: complete (\${OUTPUT_FILES} output file(s))\`);
+`;
+}
+//#endregion
+//#region src/generate/index.ts
+async function q(e, t, n, r) {
+	let i = o(e, t);
+	await s(a(i), { recursive: !0 }), await u(i, n), r.push(t);
+}
+function Ae(e, t) {
+	let n = {};
+	for (let r of t) Object.assign(n, r.devDependencies(e));
+	return `${JSON.stringify({
+		name: "task-bench-harness",
+		private: !0,
+		packageManager: `bun@${e.versions.bun}`,
+		workspaces: ["packages/*"],
+		...Object.keys(n).length ? { devDependencies: n } : {}
+	}, null, 2)}\n`;
+}
+function je(e, t, n) {
+	let r = {};
+	for (let t of A(e)) r[t] = `node ./task.mjs ${t}`;
+	let i = {};
+	for (let e of t.dependencies) {
+		let t = n[e];
+		t && (i[t.name] = "workspace:*");
+	}
+	return `${JSON.stringify({
+		name: t.name,
+		version: "0.0.0",
+		private: !0,
+		scripts: r,
+		...Object.keys(i).length ? { dependencies: i } : {}
+	}, null, 2)}\n`;
+}
+function Me() {
+	return [
+		"node_modules",
+		"dist",
+		".turbo",
+		".nx",
+		".omni",
+		".moon/cache",
+		"*.log",
+		""
+	].join("\n");
+}
+function Ne(e) {
+	return [
+		"# task-bench harness",
+		"",
+		"Auto-generated benchmark workspace. Do not edit by hand; regenerate via",
+		"`@omni-oss/task-bench` instead.",
+		"",
+		`- projects: **${e.projects}**`,
+		`- tasks per project: **${e.tasksPerProject}**`,
+		`- dependency strategy: **${e.dependency.strategy}**`,
+		`- tools: **${e.tools.join(", ")}**`,
+		"",
+		"The exact configuration is captured in `bench.config.json`.",
+		""
+	].join("\n");
+}
+async function Pe(e) {
+	let t = {
+		cwd: e,
+		reject: !1,
+		stdio: "ignore"
+	};
+	await f("git", ["init", "-q"], t), await f("git", ["add", "-A"], t), await f("git", [
+		"-c",
+		"user.email=bench@task-bench.local",
+		"-c",
+		"user.name=task-bench",
+		"commit",
+		"-qm",
+		"generated benchmark workspace"
+	], t);
+}
+async function Fe(e, t) {
+	let n = D(t), r = k(n), i = [], a = F(n.tools);
+	await l(e, {
+		recursive: !0,
+		force: !0
+	}), await s(e, { recursive: !0 });
+	let o = await L(n, e);
+	await q(e, "package.json", Ae(n, a), i), await q(e, ".gitignore", Me(), i), await q(e, "README.md", Ne(n), i), await q(e, "bench.config.json", `${JSON.stringify(n, null, 2)}\n`, i);
+	for (let t of r) {
+		let a = t.dir;
+		await q(e, `${a}/package.json`, je(n, t, r), i), await q(e, `${a}/src/index.js`, Oe(t), i), await q(e, `${a}/task.mjs`, ke(n, t), i);
+	}
+	let c = (t, n) => q(e, t, n, i);
+	for (let t of a) await t.setup({
+		rootDir: e,
+		config: n,
+		projects: r,
+		version: o.get(t.tool) ?? null,
+		write: c
+	});
+	return await Pe(e), {
+		rootDir: e,
+		config: n,
+		projects: r,
+		files: i
+	};
+}
+//#endregion
+//#region src/suite/preset.ts
+var J = p.object({
+	tools: p.array(S).optional(),
+	task: p.string().optional(),
+	coldRuns: p.number().int().nonnegative().optional(),
+	warmRuns: p.number().int().nonnegative().optional(),
+	concurrency: p.number().int().positive().optional(),
+	daemon: p.boolean().optional()
+}).default({}), Ie = p.record(p.string(), p.unknown()).default({}), Le = p.object({
+	name: p.string().regex(/^[a-zA-Z0-9._-]+$/, "scenario name must be filesystem-safe (letters, digits, . _ -)"),
+	description: p.string().optional(),
+	config: Ie,
+	run: J
+}), Y = p.object({
+	name: p.string().default("task-bench suite"),
+	description: p.string().optional(),
+	defaults: p.object({
+		config: Ie,
+		run: J
+	}).prefault({}),
+	scenarios: p.array(Le).min(1)
+});
+function Re(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+function X(e, t) {
+	let n = { ...e };
+	for (let [e, r] of Object.entries(t)) {
+		let t = n[e];
+		n[e] = Re(t) && Re(r) ? X(t, r) : r;
+	}
+	return n;
+}
+function ze(e, t) {
+	let n = X(e.defaults.config, t.config), r = {
+		...e.defaults.run,
+		...t.run
+	};
+	return {
+		name: t.name,
+		description: t.description,
+		config: D(n),
+		run: r
+	};
+}
+var Z = [
+	"isolated",
+	"chain",
+	"fan-out",
+	"layered",
+	"random"
+], Q = {
+	quick: {
+		name: "quick smoke suite",
+		description: "Tiny, fast sanity sweep across two shapes.",
+		defaults: {
+			config: {
+				projects: 30,
+				tasksPerProject: 2
+			},
+			run: {
+				concurrency: 8,
+				coldRuns: 1,
+				warmRuns: 2
+			}
+		},
+		scenarios: [{
+			name: "quick-isolated",
+			config: { dependency: { strategy: "isolated" } }
+		}, {
+			name: "quick-layered",
+			config: { dependency: { strategy: "layered" } }
+		}]
+	},
+	shapes: {
+		name: "dependency-shape sweep",
+		description: "How the dependency-graph shape affects discovery/scheduling overhead at a fixed scale.",
+		defaults: {
+			config: {
+				projects: 120,
+				tasksPerProject: 3
+			},
+			run: {
+				concurrency: 8,
+				coldRuns: 2,
+				warmRuns: 3
+			}
+		},
+		scenarios: Z.map((e) => ({
+			name: `shape-${e}`,
+			config: { dependency: { strategy: e } }
+		}))
+	},
+	scale: {
+		name: "scale sweep",
+		description: "How overhead grows with workspace size (layered graph).",
+		defaults: {
+			config: {
+				tasksPerProject: 3,
+				dependency: {
+					strategy: "layered",
+					layers: 8
+				}
+			},
+			run: {
+				concurrency: 8,
+				coldRuns: 2,
+				warmRuns: 3
+			}
+		},
+		scenarios: [
+			50,
+			150,
+			300,
+			600
+		].map((e) => ({
+			name: `scale-${e}`,
+			config: { projects: e }
+		}))
+	},
+	density: {
+		name: "task-density sweep",
+		description: "How the number of tasks per project affects overhead.",
+		defaults: {
+			config: {
+				projects: 120,
+				dependency: { strategy: "layered" }
+			},
+			run: {
+				concurrency: 8,
+				coldRuns: 2,
+				warmRuns: 3
+			}
+		},
+		scenarios: [
+			2,
+			5,
+			10
+		].map((e) => ({
+			name: `density-${e}`,
+			config: { tasksPerProject: e }
+		}))
+	},
+	daemon: {
+		name: "daemon on vs off",
+		description: "Whether each tool's persistent daemon changes warm/cold overhead.",
+		defaults: {
+			config: {
+				projects: 200,
+				tasksPerProject: 3,
+				dependency: { strategy: "layered" }
+			},
+			run: {
+				concurrency: 8,
+				coldRuns: 2,
+				warmRuns: 3
+			}
+		},
+		scenarios: [{
+			name: "daemon-on",
+			run: { daemon: !0 }
+		}, {
+			name: "daemon-off",
+			run: { daemon: !1 }
+		}]
+	},
+	full: {
+		name: "full suite",
+		description: "Shapes + scale + density in one run.",
+		defaults: { run: {
+			concurrency: 8,
+			coldRuns: 2,
+			warmRuns: 3
+		} },
+		scenarios: [
+			...Z.map((e) => ({
+				name: `shape-${e}`,
+				config: {
+					projects: 120,
+					tasksPerProject: 3,
+					dependency: { strategy: e }
+				}
+			})),
+			...[
+				50,
+				150,
+				300
+			].map((e) => ({
+				name: `scale-${e}`,
+				config: {
+					projects: e,
+					tasksPerProject: 3,
+					dependency: {
+						strategy: "layered",
+						layers: 8
+					}
+				}
+			})),
+			...[
+				2,
+				5,
+				10
+			].map((e) => ({
+				name: `density-${e}`,
+				config: {
+					projects: 120,
+					tasksPerProject: e,
+					dependency: { strategy: "layered" }
+				}
+			}))
+		]
+	}
+};
+function Be() {
+	return Object.keys(Q);
+}
+function Ve(e) {
+	let t = Q[e];
+	if (!t) throw Error(`unknown preset "${e}" (available: ${Be().join(", ")})`);
+	return Y.parse(t);
+}
+function He(e) {
+	return Y.parse(e);
+}
+//#endregion
+//#region src/suite/index.ts
+async function Ue(e, t) {
+	let n = t.onEvent ?? (() => {}), r = [], i = e.scenarios.length;
+	for (let a = 0; a < i; a++) {
+		let s = e.scenarios[a];
+		if (!s) continue;
+		let c = ze(e, s), { config: u, run: d } = c, f = t.overrides?.tools ?? d.tools ?? u.tools;
+		u.tools = f;
+		let p = o(t.workdir, c.name);
+		n({
+			kind: "scenario-start",
+			name: c.name,
+			index: a,
+			total: i
+		}), await Fe(p, u), t.install !== !1 && await U(p, { quiet: !0 });
+		let m = await H(p, {
+			tools: f,
+			task: t.overrides?.task ?? d.task,
+			coldRuns: t.overrides?.coldRuns ?? d.coldRuns,
+			warmRuns: t.overrides?.warmRuns ?? d.warmRuns,
+			concurrency: t.overrides?.concurrency ?? d.concurrency,
+			daemon: t.overrides?.daemon ?? d.daemon,
+			onEvent: (e) => n({
+				kind: "bench",
+				name: c.name,
+				event: e
+			})
+		});
+		r.push({
+			name: c.name,
+			description: c.description,
+			config: u,
+			run: d,
+			result: m
+		}), t.keep || await l(p, {
+			recursive: !0,
+			force: !0
+		}), n({
+			kind: "scenario-done",
+			name: c.name,
+			index: a,
+			total: i
+		});
+	}
+	return {
+		name: e.name,
+		description: e.description,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		scenarios: r,
+		taskBenchVersion: v
+	};
+}
+//#endregion
+//#region src/suite/report.ts
+function We(e) {
+	let t = /* @__PURE__ */ new Set();
+	for (let n of e.scenarios) for (let e of n.result.tools) t.add(e.tool);
+	return x.filter((e) => t.has(e));
+}
+function Ge(e, t) {
+	return `Tool versions:\n\n${t.map((t) => `\`${t} ${e.scenarios.map((e) => e.result.versions[t]).find((e) => e != null) ?? "?"}\``).join("\n\n")}`;
+}
+function Ke(e, t) {
+	let n = e.result.tools.find((e) => e.tool === t);
+	if (!n || n.error) return n?.error ? "err" : "—";
+	let r = n.taskGraphSize > 0 ? (n.taskGraphSize - n.warm.executedMedian) / n.taskGraphSize : 1, i = z(n.warm.stats.median);
+	return r < .995 ? `${i}⚠` : i;
+}
+function qe(e, t) {
+	let n = e.result.tools.find((e) => e.tool === t);
+	return !n || n.error ? n?.error ? "err" : "—" : z(n.cold.stats.median);
+}
+function $(e, t) {
+	let n = e.map((e, n) => Math.max(e.length, ...t.map((e) => (e[n] ?? "").length))), r = (e, t) => e.padEnd(t), i = (e) => `| ${e.map((e, t) => r(e, n[t] ?? 0)).join(" | ")} |`;
+	return [
+		i(e),
+		`| ${n.map((e) => "-".repeat(e)).join(" | ")} |`,
+		...t.map(i)
+	];
+}
+function Je(e) {
+	let t = We(e), n = [];
+	n.push(`# ${e.name}`), n.push(""), n.push(`TaskBench v${e.taskBenchVersion}`), n.push(""), e.description && (n.push(e.description), n.push("")), n.push(`Generated ${e.generatedAt} · ${e.scenarios.length} scenario(s).`), n.push(""), n.push(Ge(e, t)), n.push(""), n.push("`warm` = median wall time with a verified 100% cache hit (discovery + cache-restore overhead). `⚠` marks a scenario whose warm runs were not fully cached. Absolute times are hardware-dependent — read the ratios."), n.push(""), n.push("## Summary — warm median"), n.push(""), n.push(...$([
+		"scenario",
+		"nodes",
+		"conc",
+		"daemon",
+		...t
+	], e.scenarios.map((e) => [
+		e.name,
+		String(e.result.tools[0]?.taskGraphSize ?? 0),
+		String(e.result.concurrency),
+		e.result.daemon ? "on" : "off",
+		...t.map((t) => Ke(e, t))
+	]))), n.push(""), n.push("## Summary — cold median"), n.push(""), n.push(...$([
+		"scenario",
+		"nodes",
+		"conc",
+		...t
+	], e.scenarios.map((e) => [
+		e.name,
+		String(e.result.tools[0]?.taskGraphSize ?? 0),
+		String(e.result.concurrency),
+		...t.map((t) => qe(e, t))
+	]))), n.push(""), n.push("## Details"), n.push("");
+	for (let t of e.scenarios) {
+		let e = t.description ? `${t.name} — ${t.description}` : t.name;
+		n.push(`### ${e}`), n.push(`Config: ${t.config.projects} projects × ${t.config.tasksPerProject} tasks, strategy \`${t.config.dependency.strategy}\`.`), n.push(Ee(t.result).trimEnd()), n.push("");
+	}
+	return n.join("\n");
+}
+//#endregion
+export { w as A, O as C, b as D, C as E, g as F, v as I, T as M, D as N, E as O, _ as P, k as S, y as T, z as _, Le as a, F as b, Ve as c, ze as d, Fe as f, R as g, H as h, J as i, S as j, x as k, Be as l, U as m, Ue as n, Y as o, Ee as p, Q as r, X as s, Je as t, He as u, I as v, A as w, L as x, P as y };