storybooker 0.0.1

package/.oxlintrc.json

@@ -0,0 +1,24 @@
+{
+  "extends": ["../../.oxlintrc.json"],
+  "env": {
+    "builtin": true,
+    "node": true
+  },
+  "rules": {
+    "no-console": "allow",
+    "no-process-exit": "allow",
+    "no-unsafe-call": "allow",
+    "sort-keys": "allow"
+  },
+  "ignorePatterns": [],
+  "overrides": [
+    {
+      "files": ["*.d.ts"],
+      "rules": {
+        "max-lines": "allow",
+        "consistent-indexed-object-style": "allow",
+        "no-redundant-type-constituents": "allow"
+      }
+    }
+  ]
+}

package/.turbo/turbo-build.log

@@ -0,0 +1,11 @@
+
+ℹ tsdown v0.14.2 powered by rolldown v1.0.0-beta.36
+ℹ Using tsdown config: /Users/siddhant.c.gupta/Projects/GS/storybooker/packages/cli/tsdown.config.ts
+ℹ entry: src/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ Cleaning 1 files
+ℹ Granting execute permission to dist/index.js
+ℹ dist/index.js  18.25 kB │ gzip: 5.14 kB
+ℹ 1 files, total: 18.25 kB
+✔ Build complete in 53ms

package/.turbo/turbo-check.log

@@ -0,0 +1,2 @@
+
+

package/.turbo/turbo-lint.log

@@ -0,0 +1,3 @@
+
+Found 0 warnings and 0 errors.
+Finished in 785ms on 13 files using 10 threads.

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# storybooker
+
+## 0.0.1
+
+### Patch Changes
+
+- 6578fe4: Init StoryBooker packages

package/README.md

@@ -0,0 +1,25 @@
+# StoryBooker CLI
+
+A NodeJS CLI to sync with StoryBooker service. The CLI can be used to build, test, upload StoryBook to the service.
+
+## Usage
+
+See commands + help
+
+```sh
+npx -y storybooker -h
+```
+
+### Build+Upload assets
+
+```sh
+npx -y storybooker create \
+    -u https://<storybooker-service> \
+    -p <project-id> \
+    --id <build-id> \
+    --test \
+    -l <branch-name> -l <another-label> \
+    --authorName <your-name> \
+    --authorEmail <your-email> \
+    --message "<readable message>"
+```

package/dist/index.js

@@ -0,0 +1,554 @@
+#!/usr/bin/env node
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import * as fs$1 from "node:fs";
+import fs from "node:fs";
+import * as path$1 from "node:path";
+import path from "node:path";
+import { styleText } from "node:util";
+import createClient from "openapi-fetch";
+import z from "zod";
+import { ChildProcess, execSync, spawnSync } from "node:child_process";
+import * as process$1 from "node:process";
+import { tmpdir } from "node:os";
+
+//#region package.json
+var name = "storybooker";
+var version = "0.0.0";
+
+//#endregion
+//#region src/utils/auth-utils.ts
+function createAuthMiddleware(options) {
+	const { authType, authValue } = options;
+	return { onRequest: ({ request }) => {
+		if (!authValue) return request;
+		if (!authType) return request;
+		switch (authType) {
+			case "auth-header":
+				request.headers.set("Authorization", authValue);
+				return request;
+			default: return request;
+		}
+	} };
+}
+
+//#endregion
+//#region src/utils/pkg-utils.ts
+function detectPackageManager(startDir = process.cwd(), maxDepth = 5) {
+	let currentDir = startDir;
+	let depth = 0;
+	while (depth < maxDepth) {
+		if (fs$1.existsSync(path$1.join(currentDir, `yarn.lock`))) return "yarn";
+		if (fs$1.existsSync(path$1.join(currentDir, `pnpm-lock.yaml`))) return "pnpm";
+		if (fs$1.existsSync(path$1.join(currentDir, `package-lock.json`))) return "npm";
+		if (fs$1.existsSync(path$1.join(currentDir, `bun.lock`))) return "bun";
+		const parentDir = path$1.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	throw new Error("Package manager could not be determined.");
+}
+
+//#endregion
+//#region src/utils/sb-build.ts
+function buildStoryBook({ build, cwd, silent }) {
+	if (build === false) {
+		console.log("> Skipping StoryBook Build.");
+		return;
+	}
+	let output = "";
+	if (typeof build === "string" && build.trim() !== "") {
+		console.log("> Building StoryBook with script: %s", build);
+		const pkgManager = detectPackageManager(cwd);
+		output = spawnSync(pkgManager, ["run", build], {
+			cwd,
+			shell: true,
+			stdio: silent ? void 0 : "inherit",
+			encoding: "utf8"
+		}).stdout;
+	} else {
+		console.log("> Building StoryBook with storybook CLI");
+		output = spawnSync("npx", [
+			"-y",
+			"storybook",
+			"build"
+		], {
+			cwd,
+			stdio: silent ? void 0 : "inherit",
+			encoding: "utf8"
+		}).stdout;
+	}
+	const outputDirpath = output?.split("Output directory: ").at(1)?.trim();
+	if (!outputDirpath || !fs$1.existsSync(outputDirpath)) {
+		console.error(`Could not find build output at '${outputDirpath}'.`);
+		return;
+	}
+	console.log("> Built StoryBook to dir: '%s'.", path$1.relative(cwd, outputDirpath));
+	return outputDirpath;
+}
+
+//#endregion
+//#region src/utils/sb-test.ts
+function testStoryBook({ test, cwd, silent, testReportDir = ".test/report", testCoverageDir = ".test/coverage" }) {
+	if (test) try {
+		runTest(test, {
+			cwd,
+			silent,
+			testCoverageDir,
+			testReportDir
+		});
+	} catch (error) {
+		console.error(error);
+	}
+	else console.log("> Skipping tests");
+	const testReportDirpath = path$1.join(cwd, testReportDir);
+	const existsTestReportDirpath = fs$1.existsSync(testReportDirpath);
+	if (existsTestReportDirpath) console.log("> Test report saved at '%s'.", path$1.relative(cwd, testReportDirpath));
+	else console.warn("> Test report was not created'.");
+	const testCoverageDirpath = path$1.join(cwd, testCoverageDir);
+	const existsTestCoverageDirpath = fs$1.existsSync(testCoverageDirpath);
+	if (existsTestCoverageDirpath) console.log("> Test coverage saved at '%s'.", path$1.relative(cwd, testCoverageDirpath));
+	else console.warn("> Test coverage was not created'.");
+	return {
+		testCoverageDirpath: existsTestCoverageDirpath ? testCoverageDirpath : void 0,
+		testReportDirpath: existsTestReportDirpath ? testReportDirpath : void 0
+	};
+}
+function runTest(test, options) {
+	const { cwd, silent, testCoverageDir, testReportDir } = options;
+	if (typeof test === "string" && test.trim() !== "") {
+		console.log("> Testing StoryBook with script: %s", test);
+		const pkgManager = detectPackageManager(cwd);
+		spawnSync(pkgManager, ["run", test], {
+			cwd,
+			shell: true,
+			stdio: silent ? void 0 : "inherit"
+		});
+		return;
+	}
+	console.log("> Testing StoryBook with Vitest");
+	spawnSync("npx", [
+		"-y",
+		"vitest",
+		"run",
+		"--reporter=default",
+		"--reporter=html",
+		`--outputFile.html=${path$1.join(testReportDir, "index.html")}`,
+		"--reporter=json",
+		`--outputFile.json=${path$1.join(testReportDir, "report.json")}`,
+		"--coverage",
+		"--coverage.provider=v8",
+		"--coverage.reportOnFailure",
+		`--coverage.reportsDirectory=${testCoverageDir}`,
+		"--coverage.reporter=text",
+		"--coverage.reporter=html",
+		"--coverage.reporter=text-summary",
+		"--coverage.reporter=json-summary"
+	], {
+		cwd,
+		stdio: silent ? void 0 : "inherit"
+	});
+}
+
+//#endregion
+//#region src/utils/schema-utils.ts
+const sharedSchemas = {
+	project: z.string({ error: "ProjectID is required to match with project." }).meta({
+		alias: ["p"],
+		description: "Project ID associated with the StoryBook."
+	}),
+	url: z.url({ error: "URL is required to connect to the service." }).meta({
+		alias: ["u"],
+		description: "URL of the StoryBooker service."
+	}),
+	cwd: z.string().optional().meta({ description: "Change the working directory for the command." }),
+	testReportDir: z.string().optional().meta({ description: "Relative path of the test report directory to upload." }),
+	testCoverageDir: z.string().optional().meta({ description: "Relative path of the test coverage directory to upload." }),
+	authType: z.enum(["auth-header"]).optional().meta({ description: "Enable auth for outgoing requests." }),
+	authValue: z.string().optional().meta({
+		description: "Auth value set for outgoing requests.",
+		implies: "authType"
+	})
+};
+function zodSchemaToCommandBuilder(objectSchema) {
+	const builder = {};
+	for (const [key, schema$1] of Object.entries(objectSchema._zod.def.shape)) {
+		const meta = schema$1 instanceof z.ZodType ? schema$1.meta() : void 0;
+		let optional = false;
+		try {
+			if (schema$1["~standard"].validate(void 0, {}) instanceof Promise) throw new TypeError("Cannot handle async schema");
+			optional = true;
+		} catch {
+			optional = false;
+		}
+		let errorMessage = schema$1._zod.def.error?.(void 0);
+		if (typeof errorMessage === "object") errorMessage = errorMessage?.message;
+		let defaultValue = schema$1 instanceof z.core.$ZodDefault ? schema$1._zod.def.defaultValue : void 0;
+		if (typeof defaultValue === "function") defaultValue = String(defaultValue());
+		const description = String(schema$1._zod.def.description ?? schema$1.description);
+		builder[key] = {
+			alias: meta?.alias,
+			description,
+			demandOption: optional ? false : errorMessage ?? true,
+			type: zodSchemaTypeToYargsBuilderType(schema$1),
+			default: defaultValue,
+			deprecated: meta?.deprecated,
+			hidden: meta?.hidden,
+			implies: meta?.implies
+		};
+	}
+	return builder;
+}
+function zodSchemaTypeToYargsBuilderType(schema$1) {
+	if (schema$1 instanceof z.core.$ZodArray) return "array";
+	if (schema$1 instanceof z.core.$ZodBoolean) return "boolean";
+	if (schema$1 instanceof z.core.$ZodNumber) return "number";
+	if (schema$1 instanceof z.core.$ZodOptional) return zodSchemaTypeToYargsBuilderType(schema$1._zod.def.innerType);
+	if (schema$1 instanceof z.core.$ZodDefault) return zodSchemaTypeToYargsBuilderType(schema$1._zod.def.innerType);
+	if (schema$1 instanceof z.core.$ZodUnion) return;
+	return "string";
+}
+
+//#endregion
+//#region src/utils/stream-utils.ts
+function toReadableStream(readable, filesize, onProgress = onUploadProgress) {
+	let uploaded = 0;
+	return new ReadableStream({
+		start: (controller) => {
+			function onData(chunk) {
+				try {
+					uploaded += chunk.length;
+					controller.enqueue(chunk);
+					onProgress?.(uploaded, filesize);
+				} catch {
+					cleanup();
+					readable.destroy();
+				}
+			}
+			function onEnd() {
+				cleanup();
+				controller.close();
+			}
+			function onError(err) {
+				cleanup();
+				controller.error(err);
+			}
+			function cleanup() {
+				readable.off("data", onData);
+				readable.off("end", onEnd);
+				readable.off("error", onError);
+				console.log("");
+			}
+			readable.on("data", onData);
+			readable.on("end", onEnd);
+			readable.on("error", onError);
+		},
+		cancel: () => {
+			readable.destroy();
+		}
+	});
+}
+/** Function to handle upload progress */
+function onUploadProgress(uploaded, total) {
+	const percentStr = (uploaded / total * 100).toFixed(2).padStart(6, " ");
+	const totalStr = (total / 1e3).toFixed(2);
+	const uploadedStr = (uploaded / 1e3).toFixed(2).padStart(totalStr.length, " ");
+	process$1.stdout.write(styleText("dim", `\r  - Uploaded: ${uploadedStr} / ${totalStr} KB (${percentStr}%)`));
+}
+
+//#endregion
+//#region src/utils/zip.ts
+const isWindows = process.platform === "win32";
+/**
+* Cross-platform sync zip utility that works on Windows and Unix-like systems.
+* It uses the `zip` command on Unix-like systems and PowerShell on Windows.
+* It throws an error if the `zip` command is not available on Unix-like systems.
+*/
+function zip(inPath, outPath) {
+	if (isWindows) {
+		if (fs.statSync(inPath).isFile()) {
+			const inFile = fs.readFileSync(inPath);
+			const tmpPath = path.join(tmpdir(), `cross-zip-${Date.now()}`);
+			fs.mkdirSync(tmpPath);
+			fs.writeFileSync(path.join(tmpPath, path.basename(inPath)), inFile);
+			inPath = tmpPath;
+		}
+		fs.rmdirSync(outPath, {
+			recursive: true,
+			maxRetries: 3
+		});
+	}
+	const cwd = path.dirname(inPath);
+	const zipCmd = getZipCommand();
+	const zipCmdArgs = getZipArgs(inPath, outPath);
+	try {
+		execSync([zipCmd, ...zipCmdArgs].join(" "), {
+			cwd,
+			maxBuffer: Infinity,
+			encoding: "utf8"
+		});
+	} catch (error) {
+		if (error instanceof ChildProcess) {
+			console.error("STDOUT:", error.stdout);
+			console.error("STDERR:", error.stderr);
+		}
+		throw error;
+	}
+}
+function getZipCommand() {
+	if (isWindows) return "powershell.exe";
+	return "zip";
+}
+function getZipArgs(inPath, outPath) {
+	if (isWindows) return [
+		"-nologo",
+		"-noprofile",
+		"-command",
+		"& { param([String]$myInPath, [String]$myOutPath); Add-Type -A \"System.IO.Compression.FileSystem\"; [IO.Compression.ZipFile]::CreateFromDirectory($myInPath, $myOutPath); exit !$? }",
+		"-myInPath",
+		quotePath(inPath),
+		"-myOutPath",
+		quotePath(outPath)
+	];
+	const dirname = path.basename(inPath.toString());
+	return [
+		"-r",
+		"-y",
+		outPath.toString(),
+		dirname
+	];
+}
+function quotePath(pathToTransform) {
+	return `"${pathToTransform.toString()}"`;
+}
+
+//#endregion
+//#region src/commands/create.ts
+const CreateSchema = z.object({
+	project: sharedSchemas.project,
+	url: sharedSchemas.url,
+	cwd: sharedSchemas.cwd,
+	sha: z.string({ error: "URL is required to connect to the service." }).meta({
+		alias: ["id"],
+		description: "Unique ID of the build."
+	}),
+	message: z.string().optional().meta({
+		alias: ["m"],
+		description: "Readable message for the build."
+	}),
+	labels: z.string().array().meta({
+		alias: ["l"],
+		description: "Labels associated with the build."
+	}),
+	build: z.union([z.string(), z.boolean()]).optional().meta({
+		alias: ["b"],
+		description: "Name of the script in package.json to build the StoryBook."
+	}),
+	test: z.union([z.string(), z.boolean()]).optional().meta({
+		alias: ["t"],
+		description: "Name of the script in package.json to test the StoryBook."
+	}),
+	testCoverageDir: sharedSchemas.testCoverageDir,
+	testReportDir: sharedSchemas.testReportDir,
+	silent: z.boolean().default(false).meta({
+		alias: ["s"],
+		description: "Silent the logs and only show final error/status."
+	}),
+	authorName: z.string().optional().meta({ description: "Name of the author of the build." }),
+	authorEmail: z.email().optional().meta({ description: "Email of the author of the build." }),
+	ignoreError: z.boolean().default(false).meta({ hidden: true }),
+	authType: sharedSchemas.authType,
+	authValue: sharedSchemas.authValue
+});
+const createCommandModule = {
+	command: "create",
+	describe: "Create and upload StoryBook assets to the service.",
+	builder: zodSchemaToCommandBuilder(CreateSchema),
+	handler: async (args) => {
+		const result = CreateSchema.safeParse(args);
+		if (!result.success) throw new Error(z.prettifyError(result.error));
+		const cwd = result.data.cwd ? path$1.resolve(result.data.cwd) : process.cwd();
+		if (cwd && !fs$1.existsSync(cwd)) throw new Error(`Path provided to CWD does not exists: '${cwd}'`);
+		const { build, silent, url, project, sha, ignoreError, test, testCoverageDir, testReportDir, authType, authValue } = result.data;
+		const client = createClient({ baseUrl: url });
+		client.use(createAuthMiddleware({
+			authType,
+			authValue
+		}));
+		try {
+			console.group(styleText("bold", "\nCreate Build Entry"));
+			await createSBRBuild(client, result.data, ignoreError);
+			console.groupEnd();
+			console.group(styleText("bold", "\nBuild StoryBook"));
+			const buildDirpath = buildStoryBook({
+				build,
+				cwd,
+				silent
+			});
+			if (buildDirpath) {
+				await uploadSBRBuild(client, {
+					project,
+					sha,
+					dirpath: buildDirpath,
+					variant: "storybook",
+					cwd
+				});
+				console.groupEnd();
+			}
+			console.group(styleText("bold", "\nTest StoryBook"));
+			const { testCoverageDirpath, testReportDirpath } = testStoryBook({
+				cwd,
+				test,
+				silent,
+				testCoverageDir,
+				testReportDir
+			});
+			if (testReportDirpath) await uploadSBRBuild(client, {
+				project,
+				sha,
+				dirpath: testReportDirpath,
+				cwd,
+				variant: "testReport"
+			});
+			if (testCoverageDirpath) await uploadSBRBuild(client, {
+				project,
+				sha,
+				dirpath: testCoverageDirpath,
+				cwd,
+				variant: "coverage"
+			});
+			console.groupEnd();
+			console.log(styleText("green", "Created build successfully."));
+		} catch (error) {
+			console.error(error);
+			process.exit(1);
+		}
+	}
+};
+async function createSBRBuild(client, { project, sha, message, labels }, ignorePrevious) {
+	const { error, response } = await client.POST("/projects/{projectId}/builds/create", {
+		params: { path: { projectId: project } },
+		body: {
+			authorEmail: "Siddhant@asd.com",
+			authorName: "Siddhant",
+			labels,
+			sha,
+			message
+		},
+		headers: {
+			Accept: "application/json",
+			"Content-Type": "application/x-www-form-urlencoded"
+		}
+	});
+	if (error) if (ignorePrevious) console.warn(styleText("yellow", "> StoryBooker Build entry already exits."));
+	else throw new Error(error.errorMessage || `Request to service failed with status: ${response.status}.`);
+	else console.log("New Build entry created '%s / %s'", project, sha);
+}
+async function uploadSBRBuild(client, { project, sha, dirpath, variant, cwd }) {
+	const zipFilepath = path$1.join(cwd, `${variant}.zip`);
+	console.log(`> Compressing directory '%s' to file '%s'...`, path$1.relative(cwd, dirpath), path$1.relative(cwd, zipFilepath));
+	zip(path$1.join(dirpath, "*"), zipFilepath);
+	const fileSize = fs$1.statSync(zipFilepath).size;
+	console.log(`> Uploading file '%s'...`, path$1.relative(cwd, zipFilepath));
+	const { error, response } = await client.POST("/projects/{projectId}/builds/{buildSHA}/upload", {
+		params: {
+			path: {
+				projectId: project,
+				buildSHA: sha
+			},
+			query: { variant }
+		},
+		body: toReadableStream(fs$1.createReadStream(zipFilepath), fileSize),
+		bodySerializer: (body) => body,
+		headers: {
+			Accept: "application/json",
+			"Content-Type": "application/zip",
+			"Content-Length": fileSize.toString()
+		},
+		duplex: "half"
+	});
+	if (error) throw new Error(error.errorMessage || `Request to service failed with status: ${response.status}.`);
+	else {
+		console.log("> Uploaded '%s / %s / %s'.", project, sha, variant);
+		fs$1.rmSync(zipFilepath);
+	}
+}
+
+//#endregion
+//#region src/commands/purge.ts
+const PurgeSchema = z.object({
+	project: sharedSchemas.project,
+	url: sharedSchemas.url,
+	label: z.string().meta({
+		alias: ["l"],
+		description: "The label slug to purge associated builds."
+	}),
+	authType: sharedSchemas.authType,
+	authValue: sharedSchemas.authValue
+});
+const purgeCommandModule = {
+	command: "purge",
+	describe: "Purge StoryBook assets from the service.",
+	builder: zodSchemaToCommandBuilder(PurgeSchema),
+	handler: async (args) => {
+		const result = PurgeSchema.safeParse(args);
+		if (!result.success) throw new Error(z.prettifyError(result.error));
+		const { label, project, url, authType, authValue } = result.data;
+		const client = createClient({ baseUrl: url });
+		client.use(createAuthMiddleware({
+			authType,
+			authValue
+		}));
+		try {
+			console.group(styleText("bold", "\nPurge Label '%s' (project: %s)"), label, project);
+			console.log(`> Deleting label '%s' and associated builds...`, label);
+			const { error, response } = await client.DELETE("/projects/{projectId}/labels/{labelSlug}", {
+				params: { path: {
+					labelSlug: label,
+					projectId: project
+				} },
+				headers: { Accept: "application/json" }
+			});
+			if (error) throw new Error(error.errorMessage || `Request to service failed with status: ${response.status}.`);
+			else console.log("> Purged '%s / %s'.", project, label);
+			console.groupEnd();
+		} catch (error) {
+			console.error(error);
+			process.exit(1);
+		}
+	}
+};
+
+//#endregion
+//#region src/commands/test.ts
+const schema = z.object({
+	cwd: sharedSchemas.cwd,
+	testCoverageDir: sharedSchemas.testCoverageDir,
+	testReportDir: sharedSchemas.testReportDir
+});
+const testCommandModule = {
+	command: "test",
+	describe: "Run test on StoryBook with Vitest",
+	builder: zodSchemaToCommandBuilder(schema),
+	handler(args) {
+		const result = schema.safeParse(args);
+		if (!result.success) throw new Error(z.prettifyError(result.error));
+		const cwd = result.data.cwd ? path$1.resolve(result.data.cwd) : process.cwd();
+		if (cwd && !fs$1.existsSync(cwd)) throw new Error(`Path provided to CWD does not exists: '${cwd}'`);
+		console.group(styleText("bold", "\nTest StoryBook"));
+		testStoryBook({
+			cwd,
+			test: true,
+			testCoverageDir: result.data.testCoverageDir,
+			testReportDir: result.data.testReportDir
+		});
+		console.groupEnd();
+	}
+};
+
+//#endregion
+//#region src/index.ts
+await yargs(hideBin(process.argv)).scriptName(name).usage(`npx -y $0 [command] (options)`).version(version).command(createCommandModule).command(purgeCommandModule).command(testCommandModule).alias("h", "help").alias("v", "version").parse();
+
+//#endregion
+export {  };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "storybooker",
+  "version": "0.0.1",
+  "type": "module",
+  "bin": "./dist/index.js",
+  "description": "Storybooker CLI for uploading builds and files.",
+  "author": {
+    "name": "Siddhant Gupta",
+    "url": "https://guptasiddhant.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/guptasiddhant/storybooker",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsdown",
+    "check": "tsgo --noEmit",
+    "cli": "node ./dist/index.js --cwd ../../apps/test-ui",
+    "dev": "tsdown -w ./src",
+    "fmt": "prettier src --write --config ../../.prettierrc",
+    "lint": "oxlint --type-aware ./src",
+    "lint:fix": "yarn lint --fix",
+    "openapi": "openapi-typescript ../core/dist/openapi.json -o ./src/service-schema.d.ts",
+    "start": "node --watch ./dist/index.js --cwd ../../apps/test-ui"
+  },
+  "dependencies": {
+    "openapi-fetch": "^0.14.0",
+    "yargs": "^18.0.0",
+    "zod": "4.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/yargs": "^17.0.33",
+    "@typescript/native-preview": "^7.0.0-dev.20250823.8",
+    "openapi-typescript": "^7.9.1",
+    "oxlint": "^1.12.0",
+    "oxlint-tsgolint": "^0.0.4",
+    "prettier": "^3.6.2",
+    "tsdown": "^0.14.1",
+    "typescript": "^5.9.2"
+  }
+}