gh-inbox-clean 0.0.1

package/README.md

@@ -0,0 +1,40 @@
+# gh-inbox-clean
+
+CLI to cleanup GitHub PR notifications you no longer need to review. Marks notifications as done for PRs that are closed or where you are no longer a requested reviewer.
+
+## Prerequisites
+
+You must have the [GitHub CLI](https://cli.github.com/) installed and authenticated:
+
+```sh
+gh auth login
+```
+
+## Usage
+
+```sh
+npx gh-inbox-clean
+```
+
+### Options
+
+```
+-h, --help        Show help message
+-v, --version     Show version number
+-d, --dry-run     Preview what would be cleared without making changes
+-t, --teams       Comma-separated team slugs to keep notifications for
+```
+
+### Examples
+
+Preview what would be cleared:
+
+```sh
+npx gh-inbox-clean --dry-run
+```
+
+Keep notifications where specific teams are requested reviewers:
+
+```sh
+npx gh-inbox-clean --teams my-team,other-team
+```

package/dist/cli.mjs

@@ -0,0 +1,637 @@
+#!/usr/bin/env node
+import { Octokit } from "@octokit/rest";
+import { RequestError } from "@octokit/request-error";
+import { execFile } from "node:child_process";
+import { parseArgs, promisify, stripVTControlCharacters } from "node:util";
+import process$1 from "node:process";
+import tty from "node:tty";
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region node_modules/yoctocolors/base.js
+var base_exports = /* @__PURE__ */ __exportAll({
+	bgBlack: () => bgBlack,
+	bgBlue: () => bgBlue,
+	bgBlueBright: () => bgBlueBright,
+	bgCyan: () => bgCyan,
+	bgCyanBright: () => bgCyanBright,
+	bgGray: () => bgGray,
+	bgGreen: () => bgGreen,
+	bgGreenBright: () => bgGreenBright,
+	bgMagenta: () => bgMagenta,
+	bgMagentaBright: () => bgMagentaBright,
+	bgRed: () => bgRed,
+	bgRedBright: () => bgRedBright,
+	bgWhite: () => bgWhite,
+	bgWhiteBright: () => bgWhiteBright,
+	bgYellow: () => bgYellow,
+	bgYellowBright: () => bgYellowBright,
+	black: () => black,
+	blue: () => blue,
+	blueBright: () => blueBright,
+	bold: () => bold,
+	cyan: () => cyan,
+	cyanBright: () => cyanBright,
+	dim: () => dim,
+	gray: () => gray,
+	green: () => green,
+	greenBright: () => greenBright,
+	hidden: () => hidden,
+	inverse: () => inverse,
+	italic: () => italic,
+	magenta: () => magenta,
+	magentaBright: () => magentaBright,
+	overline: () => overline,
+	red: () => red,
+	redBright: () => redBright,
+	reset: () => reset,
+	strikethrough: () => strikethrough,
+	underline: () => underline,
+	white: () => white,
+	whiteBright: () => whiteBright,
+	yellow: () => yellow,
+	yellowBright: () => yellowBright
+});
+const hasColors = tty?.WriteStream?.prototype?.hasColors?.() ?? false;
+const format = (open, close) => {
+	if (!hasColors) return (input) => input;
+	const openCode = `\u001B[${open}m`;
+	const closeCode = `\u001B[${close}m`;
+	return (input) => {
+		const string = input + "";
+		let index = string.indexOf(closeCode);
+		if (index === -1) return openCode + string + closeCode;
+		let result = openCode;
+		let lastIndex = 0;
+		const replaceCode = (close === 22 ? closeCode : "") + openCode;
+		while (index !== -1) {
+			result += string.slice(lastIndex, index) + replaceCode;
+			lastIndex = index + closeCode.length;
+			index = string.indexOf(closeCode, lastIndex);
+		}
+		result += string.slice(lastIndex) + closeCode;
+		return result;
+	};
+};
+const reset = format(0, 0);
+const bold = format(1, 22);
+const dim = format(2, 22);
+const italic = format(3, 23);
+const underline = format(4, 24);
+const overline = format(53, 55);
+const inverse = format(7, 27);
+const hidden = format(8, 28);
+const strikethrough = format(9, 29);
+const black = format(30, 39);
+const red = format(31, 39);
+const green = format(32, 39);
+const yellow = format(33, 39);
+const blue = format(34, 39);
+const magenta = format(35, 39);
+const cyan = format(36, 39);
+const white = format(37, 39);
+const gray = format(90, 39);
+const bgBlack = format(40, 49);
+const bgRed = format(41, 49);
+const bgGreen = format(42, 49);
+const bgYellow = format(43, 49);
+const bgBlue = format(44, 49);
+const bgMagenta = format(45, 49);
+const bgCyan = format(46, 49);
+const bgWhite = format(47, 49);
+const bgGray = format(100, 49);
+const redBright = format(91, 39);
+const greenBright = format(92, 39);
+const yellowBright = format(93, 39);
+const blueBright = format(94, 39);
+const magentaBright = format(95, 39);
+const cyanBright = format(96, 39);
+const whiteBright = format(97, 39);
+const bgRedBright = format(101, 49);
+const bgGreenBright = format(102, 49);
+const bgYellowBright = format(103, 49);
+const bgBlueBright = format(104, 49);
+const bgMagentaBright = format(105, 49);
+const bgCyanBright = format(106, 49);
+const bgWhiteBright = format(107, 49);
+
+//#endregion
+//#region node_modules/yocto-spinner/index.js
+const isUnicodeSupported = process$1.platform !== "win32" || Boolean(process$1.env.WT_SESSION) || process$1.env.TERM_PROGRAM === "vscode";
+const isInteractive = (stream) => Boolean(stream.isTTY && process$1.env.TERM !== "dumb" && !("CI" in process$1.env));
+const infoSymbol = blue(isUnicodeSupported ? "ℹ" : "i");
+const successSymbol = green(isUnicodeSupported ? "✔" : "√");
+const warningSymbol = yellow(isUnicodeSupported ? "⚠" : "‼");
+const errorSymbol = red(isUnicodeSupported ? "✖" : "×");
+const defaultSpinner = {
+	frames: isUnicodeSupported ? [
+		"⠋",
+		"⠙",
+		"⠹",
+		"⠸",
+		"⠼",
+		"⠴",
+		"⠦",
+		"⠧",
+		"⠇",
+		"⠏"
+	] : [
+		"-",
+		"\\",
+		"|",
+		"/"
+	],
+	interval: 80
+};
+const SYNCHRONIZED_OUTPUT_ENABLE = "\x1B[?2026h";
+const SYNCHRONIZED_OUTPUT_DISABLE = "\x1B[?2026l";
+const activeHooksPerStream = /* @__PURE__ */ new Set();
+var YoctoSpinner = class {
+	#frames;
+	#interval;
+	#currentFrame = -1;
+	#timer;
+	#text;
+	#stream;
+	#color;
+	#lines = 0;
+	#exitHandlerBound;
+	#isInteractive;
+	#lastSpinnerFrameTime = 0;
+	#isSpinning = false;
+	#hookedStreams = /* @__PURE__ */ new Map();
+	#isInternalWrite = false;
+	#isDeferringRender = false;
+	constructor(options = {}) {
+		const spinner = options.spinner ?? defaultSpinner;
+		this.#frames = spinner.frames;
+		this.#interval = spinner.interval;
+		this.#text = options.text ?? "";
+		this.#stream = options.stream ?? process$1.stderr;
+		this.#color = options.color ?? "cyan";
+		this.#isInteractive = isInteractive(this.#stream);
+		this.#exitHandlerBound = this.#exitHandler.bind(this);
+	}
+	#internalWrite(action) {
+		this.#isInternalWrite = true;
+		try {
+			return action();
+		} finally {
+			this.#isInternalWrite = false;
+		}
+	}
+	#stringifyChunk(chunk, encoding) {
+		if (chunk === void 0 || chunk === null) return "";
+		if (typeof chunk === "string") return chunk;
+		if (Buffer.isBuffer(chunk) || ArrayBuffer.isView(chunk)) {
+			const normalizedEncoding = typeof encoding === "string" && encoding !== "" && encoding !== "buffer" ? encoding : "utf8";
+			return Buffer.from(chunk).toString(normalizedEncoding);
+		}
+		return String(chunk);
+	}
+	#withSynchronizedOutput(action) {
+		if (!this.#isInteractive) return action();
+		try {
+			this.#write(SYNCHRONIZED_OUTPUT_ENABLE);
+			return action();
+		} finally {
+			this.#write(SYNCHRONIZED_OUTPUT_DISABLE);
+		}
+	}
+	#hookStream(stream) {
+		if (!stream || this.#hookedStreams.has(stream) || typeof stream.write !== "function") return;
+		if (activeHooksPerStream.has(stream)) return;
+		const originalWrite = stream.write;
+		const hookedWrite = (...writeArguments) => this.#hookedWrite(stream, originalWrite, writeArguments);
+		this.#hookedStreams.set(stream, {
+			originalWrite,
+			hookedWrite
+		});
+		activeHooksPerStream.add(stream);
+		stream.write = hookedWrite;
+	}
+	#installHook() {
+		if (!this.#isInteractive || this.#hookedStreams.size > 0) return;
+		const streamsToHook = new Set([this.#stream]);
+		if (this.#stream === process$1.stdout || this.#stream === process$1.stderr) {
+			if (isInteractive(process$1.stdout)) streamsToHook.add(process$1.stdout);
+			if (isInteractive(process$1.stderr)) streamsToHook.add(process$1.stderr);
+		}
+		for (const stream of streamsToHook) this.#hookStream(stream);
+	}
+	#uninstallHook() {
+		for (const [stream, hookInfo] of this.#hookedStreams) {
+			if (stream.write === hookInfo.hookedWrite) stream.write = hookInfo.originalWrite;
+			activeHooksPerStream.delete(stream);
+		}
+		this.#hookedStreams.clear();
+	}
+	#hookedWrite(stream, originalWrite, writeArguments) {
+		const [chunk, encoding, callback] = writeArguments;
+		let resolvedEncoding = encoding;
+		let resolvedCallback = callback;
+		if (typeof resolvedEncoding === "function") {
+			resolvedCallback = resolvedEncoding;
+			resolvedEncoding = void 0;
+		}
+		if (this.#isInternalWrite || !this.isSpinning) return originalWrite.call(stream, chunk, resolvedEncoding, resolvedCallback);
+		if (this.#lines > 0) this.clear();
+		const chunkString = this.#stringifyChunk(chunk, resolvedEncoding);
+		const chunkTerminatesLine = chunkString.at(-1) === "\n";
+		const writeResult = originalWrite.call(stream, chunk, resolvedEncoding, resolvedCallback);
+		if (chunkTerminatesLine) this.#isDeferringRender = false;
+		else if (chunkString !== "") this.#isDeferringRender = true;
+		if (this.isSpinning && !this.#isDeferringRender) this.#render();
+		return writeResult;
+	}
+	start(text) {
+		if (text) this.#text = text;
+		if (this.isSpinning) return this;
+		this.#isSpinning = true;
+		this.#hideCursor();
+		this.#installHook();
+		this.#render();
+		this.#subscribeToProcessEvents();
+		if (this.#isInteractive) this.#timer = setInterval(() => {
+			this.#render();
+		}, this.#interval);
+		return this;
+	}
+	stop(finalText) {
+		if (!this.isSpinning) return this;
+		const shouldWriteNewline = this.#isDeferringRender;
+		this.#isSpinning = false;
+		if (this.#timer) {
+			clearInterval(this.#timer);
+			this.#timer = void 0;
+		}
+		this.#isDeferringRender = false;
+		this.#uninstallHook();
+		this.#showCursor();
+		this.clear();
+		this.#unsubscribeFromProcessEvents();
+		if (finalText) {
+			const prefix = shouldWriteNewline ? "\n" : "";
+			this.#stream.write(`${prefix}${finalText}\n`);
+		}
+		return this;
+	}
+	#symbolStop(symbol, text) {
+		return this.stop(`${symbol} ${text ?? this.#text}`);
+	}
+	success(text) {
+		return this.#symbolStop(successSymbol, text);
+	}
+	error(text) {
+		return this.#symbolStop(errorSymbol, text);
+	}
+	warning(text) {
+		return this.#symbolStop(warningSymbol, text);
+	}
+	info(text) {
+		return this.#symbolStop(infoSymbol, text);
+	}
+	get isSpinning() {
+		return this.#isSpinning;
+	}
+	get text() {
+		return this.#text;
+	}
+	set text(value) {
+		this.#text = value ?? "";
+		this.#render();
+	}
+	get color() {
+		return this.#color;
+	}
+	set color(value) {
+		this.#color = value;
+		this.#render();
+	}
+	clear() {
+		if (!this.#isInteractive) return this;
+		if (this.#lines === 0) return this;
+		this.#internalWrite(() => {
+			this.#stream.cursorTo(0);
+			for (let index = 0; index < this.#lines; index++) {
+				if (index > 0) this.#stream.moveCursor(0, -1);
+				this.#stream.clearLine(1);
+			}
+		});
+		this.#lines = 0;
+		return this;
+	}
+	#render() {
+		if (this.#isDeferringRender) return;
+		const useSynchronizedOutput = this.#isInteractive;
+		const now = Date.now();
+		if (this.#currentFrame === -1 || now - this.#lastSpinnerFrameTime >= this.#interval) {
+			this.#currentFrame = ++this.#currentFrame % this.#frames.length;
+			this.#lastSpinnerFrameTime = now;
+		}
+		const applyColor = base_exports[this.#color] ?? cyan;
+		const frame = this.#frames[this.#currentFrame];
+		let string = `${applyColor(frame)} ${this.#text}`;
+		if (!this.#isInteractive) string += "\n";
+		if (useSynchronizedOutput) this.#withSynchronizedOutput(() => {
+			this.clear();
+			this.#write(string);
+		});
+		else this.#write(string);
+		if (this.#isInteractive) this.#lines = this.#lineCount(string);
+	}
+	#write(text) {
+		this.#internalWrite(() => {
+			this.#stream.write(text);
+		});
+	}
+	#lineCount(text) {
+		const width = this.#stream.columns ?? 80;
+		const lines = stripVTControlCharacters(text).split("\n");
+		let lineCount = 0;
+		for (const line of lines) lineCount += Math.max(1, Math.ceil(line.length / width));
+		return lineCount;
+	}
+	#hideCursor() {
+		if (this.#isInteractive) this.#write("\x1B[?25l");
+	}
+	#showCursor() {
+		if (this.#isInteractive) this.#write("\x1B[?25h");
+	}
+	#subscribeToProcessEvents() {
+		process$1.once("SIGINT", this.#exitHandlerBound);
+		process$1.once("SIGTERM", this.#exitHandlerBound);
+	}
+	#unsubscribeFromProcessEvents() {
+		process$1.off("SIGINT", this.#exitHandlerBound);
+		process$1.off("SIGTERM", this.#exitHandlerBound);
+	}
+	#exitHandler(signal) {
+		if (this.isSpinning) this.stop();
+		const exitCode = signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 1;
+		process$1.exit(exitCode);
+	}
+};
+function yoctoSpinner(options) {
+	return new YoctoSpinner(options);
+}
+
+//#endregion
+//#region ui.ts
+function createSpinner() {
+	const instance = yoctoSpinner({ color: "cyan" });
+	return {
+		get isSpinning() {
+			return instance.isSpinning;
+		},
+		start(text) {
+			instance.start(text);
+		},
+		update(text) {
+			instance.text = text;
+		},
+		success(text) {
+			instance.success(text);
+		},
+		error(text) {
+			instance.error(text);
+		},
+		warning(text) {
+			instance.warning(text);
+		},
+		info(text) {
+			instance.info(text);
+		},
+		stop() {
+			if (instance.isSpinning) instance.stop();
+		}
+	};
+}
+function createLogger(spinner) {
+	return {
+		info(msg) {
+			spinner.stop();
+			process.stdout.write(`${msg}\n`);
+		},
+		error(msg) {
+			spinner.stop();
+			process.stderr.write(`${red(bold("error"))} ${msg}\n`);
+		}
+	};
+}
+function createUI() {
+	const spinner = createSpinner();
+	return {
+		spinner,
+		log: createLogger(spinner)
+	};
+}
+
+//#endregion
+//#region index.ts
+const VERSION = "1.0.0";
+const execFile$1 = promisify(execFile);
+function printHelp() {
+	process.stdout.write(`gh-inbox-clean v${VERSION}
+
+Cleanup GitHub PR notifications you no longer need to review.
+Marks notifications as done for PRs that are closed or where
+you are no longer a requested reviewer.
+
+Requires the GitHub CLI (gh) to be installed and authenticated.
+
+Usage:
+  npx gh-inbox-clean [options]
+
+Options:
+  -h, --help        Show this help message
+  -v, --version     Show version number
+  -d, --dry-run     Preview what would be cleared without making changes
+  -t, --teams       Comma-separated team slugs to keep notifications for
+`);
+}
+function parseCliArgs() {
+	const { values } = parseArgs({
+		options: {
+			help: {
+				type: "boolean",
+				short: "h",
+				default: false
+			},
+			version: {
+				type: "boolean",
+				short: "v",
+				default: false
+			},
+			"dry-run": {
+				type: "boolean",
+				short: "d",
+				default: false
+			},
+			teams: {
+				type: "string",
+				short: "t",
+				default: ""
+			}
+		},
+		strict: true
+	});
+	const teamsRaw = values.teams ?? "";
+	return {
+		help: values.help ?? false,
+		version: values.version ?? false,
+		dryRun: values["dry-run"] ?? false,
+		teams: teamsRaw.split(",").map((s) => s.trim()).filter(Boolean)
+	};
+}
+function isRateLimitError(error) {
+	if (!(error instanceof RequestError)) return false;
+	if (error.status === 429) return true;
+	if (error.status === 403) return error.response?.headers?.["x-ratelimit-remaining"] === "0";
+	return false;
+}
+async function withRateLimitRetry(fn, onRetry, maxRetries = 3, baseDelay = 1e3) {
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		return await fn();
+	} catch (error) {
+		if (attempt === maxRetries || !isRateLimitError(error)) throw error;
+		const retryAfter = Number(error.response?.headers?.["retry-after"]);
+		const delay = !Number.isNaN(retryAfter) && retryAfter > 0 ? retryAfter * 1e3 : baseDelay * 2 ** attempt;
+		const msg = `Rate limited, retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})...`;
+		if (onRetry) onRetry(msg);
+		await new Promise((resolve) => setTimeout(resolve, delay));
+	}
+	throw new Error("Exceeded maximum retries");
+}
+async function getGithubToken() {
+	try {
+		const { stdout } = await execFile$1("gh", ["auth", "token"]);
+		return {
+			succeeded: true,
+			token: stdout.trim()
+		};
+	} catch {
+		try {
+			await execFile$1("gh", ["help"]);
+			return {
+				succeeded: false,
+				error: "GitHub CLI is installed but not authenticated. Run `gh auth login` first."
+			};
+		} catch (error) {
+			return {
+				succeeded: false,
+				error: `Could not run \`gh\`: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+	}
+}
+function parsePullRequestUrl(url) {
+	const { pathname } = new URL(url);
+	const parts = pathname.split("/");
+	const owner = parts[2];
+	const repo = parts[3];
+	const pull_number = Number(parts[5]);
+	if (!owner || !repo || Number.isNaN(pull_number)) throw new Error(`Could not parse PR URL: ${url}`);
+	return {
+		owner,
+		repo,
+		pull_number
+	};
+}
+async function getAuthenticatedLogin(github) {
+	try {
+		const { data } = await github.users.getAuthenticated();
+		return data.login;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to authenticate with GitHub. Is your token valid? Run \`gh auth login\` to re-authenticate. (${message})`);
+	}
+}
+async function main() {
+	const options = parseCliArgs();
+	if (options.help) {
+		printHelp();
+		return;
+	}
+	if (options.version) {
+		process.stdout.write(`${VERSION}\n`);
+		return;
+	}
+	const { spinner, log } = createUI();
+	try {
+		const onRetry = (msg) => spinner.update(yellow(msg));
+		spinner.start("Authenticating with GitHub...");
+		const tokenResult = await getGithubToken();
+		if (!tokenResult.succeeded) {
+			spinner.error(tokenResult.error ?? "Failed to get GitHub token");
+			process.exitCode = 1;
+			return;
+		}
+		const github = new Octokit({ auth: tokenResult.token });
+		const login = await withRateLimitRetry(() => getAuthenticatedLogin(github), onRetry);
+		spinner.success(`Authenticated as ${bold(login)}`);
+		if (options.dryRun) spinner.warning("Dry run — no notifications will be marked as done");
+		spinner.start("Fetching notifications...");
+		const cleared = [];
+		let checked = 0;
+		for await (const { data: notifications } of github.paginate.iterator("GET /notifications", { all: true })) for (const notification of notifications) try {
+			if (notification.subject.type !== "PullRequest") continue;
+			const subjectUrl = notification.subject.url;
+			if (!subjectUrl) continue;
+			checked++;
+			const { owner, repo, pull_number } = parsePullRequestUrl(subjectUrl);
+			const prLabel = `${owner}/${repo}#${pull_number}`;
+			spinner.update(`Checking PR ${dim(String(checked))} ${cyan(prLabel)}`);
+			const { data: pr } = await withRateLimitRetry(() => github.pulls.get({
+				owner,
+				repo,
+				pull_number
+			}), onRetry);
+			const isReviewer = pr.requested_reviewers?.some((r) => r.login === login);
+			const isTeamReviewer = options.teams.length > 0 && pr.requested_teams?.some((t) => options.teams.includes(t.slug));
+			if (pr.state !== "closed" && (isReviewer || isTeamReviewer)) continue;
+			const reason = pr.merged ? "merged" : pr.state === "closed" ? "closed" : "not a reviewer";
+			if (!options.dryRun) {
+				spinner.update(`Clearing ${cyan(prLabel)} ${dim(`(${reason})`)}`);
+				await withRateLimitRetry(() => github.activity.markThreadAsDone({ thread_id: Number(notification.id) }), onRetry);
+			}
+			cleared.push(`${pr.html_url} ${dim(`(${reason})`)}`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			spinner.error(`Failed to process notification ${notification.id}: ${message}`);
+			spinner.start("Continuing...");
+		}
+		const suffix = options.dryRun ? dim(" (dry run)") : "";
+		if (cleared.length > 0) {
+			spinner.success(`${bold(String(cleared.length))} PR notifications cleared!${suffix}`);
+			for (const url of cleared) log.info(`  ${green("+")} ${dim(url)}`);
+		} else spinner.info(`No PR notifications to clear.${suffix}`);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		spinner.error(message);
+		process.exitCode = 1;
+	}
+}
+main().catch((error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	process.stderr.write(`${red(bold("error"))} ${message}\n`);
+	process.exitCode = 1;
+});
+
+//#endregion
+export {  };

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "gh-inbox-clean",
+  "version": "0.0.1",
+  "type": "module",
+  "bin": {
+    "gh-inbox-clean": "dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "start": "node index.ts",
+    "build": "rolldown -c rolldown.config.ts",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Jack Westbrook <jack.westbrook@gmail.com>",
+  "license": "MIT",
+  "description": "CLI to cleanup GitHub PR notifications you no longer need to review",
+  "dependencies": {
+    "@octokit/request-error": "^7.0.0",
+    "@octokit/rest": "^22.0.0",
+    "yocto-spinner": "^1.1.0",
+    "yoctocolors": "^2.1.2"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "devDependencies": {
+    "@tsconfig/node24": "^24.0.4",
+    "@tsconfig/recommended": "^1.0.13",
+    "@types/node": "^24.10.13",
+    "rolldown": "1.0.0-rc.5",
+    "typescript": "^5.9.3"
+  }
+}