@vorra/cli 0.3.0

package/dist/bin.js

@@ -0,0 +1,748 @@
+#!/usr/bin/env node
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { build, rolldown } from "rolldown";
+import { generateScopeId, vorraPlugin } from "@vorra/compiler";
+import * as url from "node:url";
+import { createRequire } from "node:module";
+import * as http from "node:http";
+import { spawnSync } from "node:child_process";
+//#region src/utils/config.ts
+const CONFIG_CANDIDATES = [
+	"vorra.config.js",
+	"vorra.config.mjs",
+	"vorra.config.cjs"
+];
+/**
+* Loads vorra.config.{js,mjs,cjs} from `cwd` and returns the config object.
+* Returns an empty object if no config file is found.
+*
+* Note: `.ts` configs are not supported at CLI runtime without a TS loader.
+* Compile `vorra.config.ts` to `.js` first, or run with `tsx`:
+*   npx tsx node_modules/.bin/forge dev
+*/
+async function loadConfig(cwd) {
+	for (const candidate of CONFIG_CANDIDATES) {
+		const configPath = path.join(cwd, candidate);
+		if (fs.existsSync(configPath)) {
+			const mod = await import(url.pathToFileURL(configPath).href);
+			if (mod.default !== null && mod.default !== void 0 && typeof mod.default === "object") return mod.default;
+			return {};
+		}
+	}
+	const tsConfigPath = path.join(cwd, "vorra.config.ts");
+	if (fs.existsSync(tsConfigPath)) console.warn("[Vorra CLI] vorra.config.ts found but cannot be loaded without a TS loader.\n  Tip: Compile it first (tsc vorra.config.ts) or run via: npx tsx .../bin.js dev");
+	return {};
+}
+//#endregion
+//#region src/utils/vorra-dedupe-plugin.ts
+const _require = createRequire(import.meta.url);
+/**
+* Resolves an `@vorra/*` package to an absolute path inside its `dist/`
+* directory. Uses the CJS main entry as an anchor so we never need to access
+* `pkg/package.json` directly (which would require the package's `exports`
+* field to allow that subpath).
+*/
+function resolveVorraPackage(name, subpath = "dist/index.js") {
+	const mainCjs = _require.resolve(name);
+	const pkgRoot = path.dirname(path.dirname(mainCjs));
+	return path.join(pkgRoot, subpath);
+}
+/**
+* Lazily-built alias map. Populated on first use inside `resolveId` so that
+* importing this module never triggers `_require.resolve()` at load time.
+* This keeps the module safe to import in test environments where `dist/`
+* files may not exist yet.
+*/
+let _aliases;
+function getVorraAliases() {
+	if (_aliases === void 0) _aliases = {
+		"@vorra/core": resolveVorraPackage("@vorra/core"),
+		"@vorra/core/dom": resolveVorraPackage("@vorra/core", "dist/dom.js"),
+		"@vorra/core/reactivity": resolveVorraPackage("@vorra/core", "dist/reactivity.js"),
+		"@vorra/core/di": resolveVorraPackage("@vorra/core", "dist/di.js"),
+		"@vorra/forms": resolveVorraPackage("@vorra/forms"),
+		"@vorra/router": resolveVorraPackage("@vorra/router")
+	};
+	return _aliases;
+}
+/**
+* Rolldown plugin that forces all `@vorra/*` imports to their canonical dist
+* entry points. A `resolveId` hook applies unconditionally to every import —
+* including those inside pre-built dist files — unlike `resolve.alias` which
+* Rolldown skips for files it considers already-resolved.
+*/
+const vorraDedupePlugin = {
+	name: "vorra-dedupe",
+	resolveId(id) {
+		const resolved = getVorraAliases()[id];
+		if (resolved !== void 0) return {
+			id: resolved,
+			external: false
+		};
+	}
+};
+//#endregion
+//#region src/commands/build.ts
+/**
+* Runs a production build.
+*
+* CLI flags (override vorra.config.js):
+*   --entry <path>   Entry file (default: src/main.ts)
+*   --outDir <path>  Output directory (default: dist)
+*/
+async function runBuild(args) {
+	const cwd = process.cwd();
+	const config = await loadConfig(cwd);
+	const entryIdx = args.indexOf("--entry");
+	const outDirIdx = args.indexOf("--outDir");
+	const entry = (entryIdx !== -1 ? args[entryIdx + 1] : void 0) ?? config.entry ?? "src/main.ts";
+	const outDir = (outDirIdx !== -1 ? args[outDirIdx + 1] : void 0) ?? config.outDir ?? "dist";
+	const entryAbs = path.join(cwd, entry);
+	const outDirAbs = path.join(cwd, outDir);
+	const entryName = path.basename(entry, path.extname(entry));
+	const userPlugins = config.plugins ?? [];
+	const plugins = [
+		vorraDedupePlugin,
+		vorraPlugin({
+			...config.css ? { css: path.join(cwd, config.css) } : {},
+			...config.postcss ? { postcss: config.postcss } : {}
+		}),
+		...userPlugins
+	];
+	console.log(`[vorra build] ${entry} → ${outDir}/`);
+	const build = await rolldown({
+		input: entryAbs,
+		plugins
+	});
+	const sourcemap = config.sourcemap ?? false;
+	await build.write({
+		dir: outDirAbs,
+		format: "es",
+		sourcemap,
+		entryFileNames: "[name].js",
+		chunkFileNames: "[name]-[hash].js"
+	});
+	const htmlSrc = path.join(cwd, "index.html");
+	if (fs.existsSync(htmlSrc)) {
+		const outDirRel = path.relative(cwd, outDirAbs).replace(/\\/g, "/");
+		const outDirPattern = new RegExp(`((?:src|href)=["'])(?:\\./)?(${escapeRegExp(outDirRel)}/)`, "g");
+		let html = fs.readFileSync(htmlSrc, "utf8");
+		html = html.replace(outDirPattern, "$1");
+		if (!/<script\s[^>]*type=["']module["']/i.test(html)) {
+			const tag = `  <script type="module" src="./${entryName}.js"><\/script>`;
+			html = html.includes("</body>") ? html.replace("</body>", `${tag}\n</body>`) : html + tag;
+		}
+		fs.writeFileSync(path.join(outDirAbs, "index.html"), html, "utf8");
+		console.log(`[vorra build] Copied index.html → ${outDir}/index.html`);
+	} else console.warn("[vorra build] No index.html found in project root — skipping HTML copy.");
+	console.log("[vorra build] Done.");
+}
+/** Escapes special regex characters in a literal string. */
+function escapeRegExp(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/commands/dev.ts
+const HMR_ENDPOINT = "/__vorra_hmr";
+/**
+* Injected before </body> in every HTML response.
+*
+* Sets up window.__vorra_hmr with an instance registry, then opens an SSE
+* connection to receive either component-level HMR updates or full reloads.
+*
+* 'hmr-update' — one or more .vorra chunks changed; each is re-imported with
+*   a cache-busting timestamp. The new chunk calls window.__vorra_hmr.accept()
+*   which triggers the in-place component swap implemented in @vorra/core.
+*
+* 'reload' — a non-component file changed; fall back to a full page reload.
+*/
+const HMR_CLIENT_SCRIPT = `<script type="module">
+(function () {
+  if (!window.__vorra_hmr) window.__vorra_hmr = {};
+  var hmr = window.__vorra_hmr;
+  if (!hmr.instances) hmr.instances = new Map();
+
+  var es = new EventSource('${HMR_ENDPOINT}');
+
+  es.addEventListener('hmr-update', function (e) {
+    var data = JSON.parse(e.data);
+    data.updates.forEach(function (update) {
+      console.log('[vorra hmr] updating component ' + update.id);
+      import(update.url + '?t=' + Date.now()).catch(function (err) {
+        console.error('[vorra hmr] failed to load update, falling back to reload', err);
+        location.reload();
+      });
+    });
+  });
+
+  es.addEventListener('reload', function () {
+    console.log('[vorra hmr] full reload');
+    location.reload();
+  });
+
+  es.addEventListener('error', function () { es.close(); });
+})();
+<\/script>`;
+const MIME = {
+	".html": "text/html; charset=utf-8",
+	".js": "application/javascript; charset=utf-8",
+	".mjs": "application/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf"
+};
+/**
+* Starts the vorra development server.
+*
+* CLI flags (override vorra.config.js):
+*   --port <number>   Dev server port (default: 3000)
+*   --entry <path>    Entry file (default: src/main.ts)
+*   --outDir <path>   Output directory (default: dist)
+*/
+async function runDev(args) {
+	const cwd = process.cwd();
+	const config = await loadConfig(cwd);
+	const portIdx = args.indexOf("--port");
+	const entryIdx = args.indexOf("--entry");
+	const outDirIdx = args.indexOf("--outDir");
+	const port = portIdx !== -1 ? parseInt(args[portIdx + 1] ?? "3000", 10) : config.port ?? 3e3;
+	const entry = (entryIdx !== -1 ? args[entryIdx + 1] : void 0) ?? config.entry ?? "src/main.ts";
+	const outDir = (outDirIdx !== -1 ? args[outDirIdx + 1] : void 0) ?? config.devOutDir ?? ".vorra";
+	const entryAbs = path.join(cwd, entry);
+	const outDirAbs = path.join(cwd, outDir);
+	const outDirNorm = outDirAbs.replace(/\\/g, "/") + "/";
+	const outDirRel = path.relative(cwd, outDirAbs).replace(/\\/g, "/");
+	const userPlugins = config.plugins ?? [];
+	const devDefinePlugin = {
+		name: "vorra-dev-define",
+		transform(code) {
+			if (!code.includes("__vorra_dev")) return null;
+			let result = code.replace(/declare\s+const\s+__vorra_dev\b[^\n]*\n?/g, "");
+			result = result.replaceAll("__vorra_dev", "true");
+			return { code: result };
+		}
+	};
+	const plugins = [
+		vorraDedupePlugin,
+		vorraPlugin({
+			hmr: true,
+			...config.css ? { css: path.join(cwd, config.css) } : {},
+			...config.postcss ? { postcss: config.postcss } : {}
+		}),
+		devDefinePlugin,
+		...userPlugins
+	];
+	fs.mkdirSync(outDirAbs, { recursive: true });
+	const clients = /* @__PURE__ */ new Set();
+	/** Broadcasts an SSE event to all connected browser clients. */
+	function broadcast(event, data) {
+		for (const client of clients) try {
+			client.write(`event: ${event}\ndata: ${data}\n\n`);
+		} catch {
+			clients.delete(client);
+		}
+	}
+	/** Absolute paths of .vorra files that changed since the last build. */
+	const changedVorraFiles = /* @__PURE__ */ new Set();
+	/** True if any non-.vorra source file changed since the last build. */
+	let hasNonVorraChanges = false;
+	let isBuilding = false;
+	let pendingRebuild = false;
+	const devOutput = {
+		dir: outDirAbs,
+		format: "es",
+		sourcemap: true,
+		entryFileNames: "[name].js",
+		chunkFileNames: "[name].js",
+		manualChunks(id) {
+			if (id.endsWith(".vorra")) return path.relative(cwd, id).replace(/\\/g, "/").replace(".vorra", "");
+			if (id.includes(path.join("node_modules", "@vorra"))) return "vorra-runtime";
+		}
+	};
+	async function runBuild() {
+		if (isBuilding) {
+			pendingRebuild = true;
+			return;
+		}
+		isBuilding = true;
+		pendingRebuild = false;
+		const currentVorraChanges = new Set(changedVorraFiles);
+		const currentHasNonVorra = hasNonVorraChanges;
+		changedVorraFiles.clear();
+		hasNonVorraChanges = false;
+		try {
+			await build({
+				input: entryAbs,
+				plugins,
+				output: devOutput
+			});
+			if (currentVorraChanges.size > 0 && !currentHasNonVorra) {
+				const updates = Array.from(currentVorraChanges).map((filePath) => {
+					const id = generateScopeId(filePath);
+					const rel = path.relative(cwd, filePath).replace(/\\/g, "/").replace(".vorra", "");
+					return {
+						id,
+						url: `/${path.join(outDir, rel).replace(/\\/g, "/")}.js`
+					};
+				});
+				console.log(`[vorra hmr] Hot-updating ${updates.length} component(s)...`);
+				broadcast("hmr-update", JSON.stringify({ updates }));
+			} else {
+				console.log("[vorra dev] Rebuilt — notifying clients...");
+				broadcast("reload", "{}");
+			}
+		} catch {
+			console.error("[vorra dev] Build error — check the terminal above for details.");
+		} finally {
+			isBuilding = false;
+			if (pendingRebuild) runBuild();
+		}
+	}
+	let debounceTimer = null;
+	const fsWatcher = fs.watch(cwd, { recursive: true }, (_event, filename) => {
+		if (!filename) return;
+		const rel = filename.replace(/\\/g, "/");
+		if (rel.startsWith(outDirRel + "/")) return;
+		if (rel.startsWith("node_modules/")) return;
+		if ((path.resolve(cwd, filename).replace(/\\/g, "/") + "/").startsWith(outDirNorm)) return;
+		const SOURCE_EXTENSIONS = [
+			".ts",
+			".tsx",
+			".js",
+			".mjs",
+			".cjs",
+			".json",
+			".html",
+			".css"
+		];
+		if (filename.endsWith(".vorra")) changedVorraFiles.add(path.resolve(cwd, filename));
+		else if (SOURCE_EXTENSIONS.some((ext) => filename.endsWith(ext))) hasNonVorraChanges = true;
+		else return;
+		if (debounceTimer) clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(() => {
+			debounceTimer = null;
+			runBuild();
+		}, 80);
+	});
+	const devScriptSrc = `/${outDir}/${path.basename(entry, path.extname(entry))}.js`;
+	console.log(`[vorra dev] Server:  http://localhost:${port}`);
+	console.log(`[vorra dev] Entry:   ${entry}`);
+	console.log(`[vorra dev] Output:  ${outDir}/`);
+	console.log("[vorra dev] HMR:     enabled");
+	console.log("[vorra dev] Building...");
+	await runBuild();
+	console.log("[vorra dev] Watching for changes...\n");
+	const server = http.createServer((req, res) => {
+		const rawUrl = req.url ?? "/";
+		if (rawUrl === HMR_ENDPOINT) {
+			res.writeHead(200, {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache",
+				Connection: "keep-alive",
+				"Access-Control-Allow-Origin": "*"
+			});
+			res.write(":\n\n");
+			clients.add(res);
+			res.on("close", () => {
+				clients.delete(res);
+			});
+			return;
+		}
+		const urlPath = rawUrl.split("?")[0] ?? "/";
+		const filePath = resolveFilePath(urlPath, cwd, outDirAbs);
+		if (filePath === null) {
+			res.writeHead(404, { "Content-Type": "text/plain" });
+			res.end(`Not found: ${urlPath}`);
+			return;
+		}
+		serveFile(filePath, res, devScriptSrc);
+	});
+	server.listen(port);
+	process.on("SIGINT", () => {
+		console.log("\n[vorra dev] Stopping...");
+		fsWatcher.close();
+		for (const client of clients) try {
+			client.destroy();
+		} catch {}
+		clients.clear();
+		server.closeAllConnections();
+		server.close(() => process.exit(0));
+	});
+}
+/**
+* Resolves a URL path to a file on disk.
+*
+* Search order:
+*   1. `<cwd>/<urlPath>`   — public assets, index.html in project root
+*   2. `<outDir>/<urlPath>` — compiled JS / CSS output
+*   3. `<cwd>/index.html`  — SPA fallback for unknown paths
+*
+* Returns null if no file is found anywhere.
+*/
+function resolveFilePath(urlPath, cwd, outDirAbs) {
+	const normalized = urlPath === "/" ? "/index.html" : urlPath;
+	const fromCwd = path.join(cwd, normalized);
+	if (fs.existsSync(fromCwd) && fs.statSync(fromCwd).isFile()) return fromCwd;
+	const fromDist = path.join(outDirAbs, normalized);
+	if (fs.existsSync(fromDist) && fs.statSync(fromDist).isFile()) return fromDist;
+	const indexHtml = path.join(cwd, "index.html");
+	if (fs.existsSync(indexHtml)) return indexHtml;
+	return null;
+}
+/**
+* Reads a file from disk and writes it to the HTTP response.
+*
+* For HTML files, two scripts are injected before </body>:
+*   1. The compiled entry module — only when no <script type="module"> is
+*      already present in the file, so users don't need to add the tag
+*      manually; the framework adds it for them.
+*   2. The HMR client — always present in dev mode.
+*/
+function serveFile(filePath, res, entryScript) {
+	const ext = path.extname(filePath).toLowerCase();
+	const contentType = MIME[ext] ?? "application/octet-stream";
+	let body;
+	try {
+		body = fs.readFileSync(filePath);
+	} catch {
+		res.writeHead(500, { "Content-Type": "text/plain" });
+		res.end("Internal server error");
+		return;
+	}
+	if (ext === ".html") {
+		let html = body.toString("utf8");
+		if (entryScript && !/<script\s[^>]*type=["']module["']/i.test(html)) {
+			const tag = `<script type="module" src="${entryScript}"><\/script>`;
+			html = html.includes("</body>") ? html.replace("</body>", `${tag}\n</body>`) : html + tag;
+		}
+		const injected = html.includes("</body>") ? html.replace("</body>", `${HMR_CLIENT_SCRIPT}\n</body>`) : html + HMR_CLIENT_SCRIPT;
+		const injectedBuf = Buffer.from(injected, "utf8");
+		res.writeHead(200, {
+			"Content-Type": contentType,
+			"Content-Length": injectedBuf.length
+		});
+		res.end(injectedBuf);
+		return;
+	}
+	res.writeHead(200, {
+		"Content-Type": contentType,
+		"Content-Length": body.length
+	});
+	res.end(body);
+}
+//#endregion
+//#region src/commands/new.ts
+/**
+* Scaffolds a new project.
+*
+* Usage: vorra new <project-name>
+*
+* Creates the following structure:
+*   <name>/
+*     .gitignore
+*     index.html
+*     vorra.config.js
+*     package.json
+*     tsconfig.json
+*     src/
+*       env.d.ts
+*       main.ts
+*       App.vorra
+*/
+function runNew(args) {
+	const name = args[0];
+	if (!name) {
+		console.error("[Vorra CLI] Usage: vorra new <project-name>");
+		process.exit(1);
+		return;
+	}
+	if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+		console.error("[Vorra CLI] Project name must be lowercase letters/digits/hyphens, starting with a letter.");
+		process.exit(1);
+		return;
+	}
+	const projectDir = path.join(process.cwd(), name);
+	if (fs.existsSync(projectDir)) {
+		console.error(`[Vorra CLI] Directory "${name}" already exists.`);
+		process.exit(1);
+		return;
+	}
+	console.log(`\n  Scaffolding Vorra app: ${name}\n`);
+	fs.mkdirSync(path.join(projectDir, "src"), { recursive: true });
+	write(projectDir, "package.json", tplPackageJson(name));
+	write(projectDir, "tsconfig.json", tplTsconfig());
+	write(projectDir, "vorra.config.js", tplVorraConfig());
+	write(projectDir, "index.html", tplIndexHtml(name));
+	write(projectDir, ".gitignore", tplGitignore());
+	write(projectDir, "src/env.d.ts", tplEnvDts());
+	write(projectDir, "src/main.ts", tplMainTs());
+	write(projectDir, "src/App.vorra", tplAppVorra());
+	for (const f of [
+		"package.json",
+		"tsconfig.json",
+		"vorra.config.js",
+		"index.html",
+		".gitignore",
+		"src/env.d.ts",
+		"src/main.ts",
+		"src/App.vorra"
+	]) console.log(`  \u2713 ${name}/${f}`);
+	console.log(`
+  Done! Next steps:
+
+    cd ${name}
+    npm install
+    npm run dev
+`);
+}
+function write(dir, filename, content) {
+	fs.writeFileSync(path.join(dir, filename), content, "utf8");
+}
+function tplPackageJson(name) {
+	return JSON.stringify({
+		name,
+		version: "0.1.0",
+		private: true,
+		type: "module",
+		scripts: {
+			dev: "vorra dev",
+			build: "vorra build",
+			typecheck: "vorra typecheck"
+		},
+		dependencies: { "@vorra/core": "^0.1.0" },
+		devDependencies: {
+			"@vorra/cli": "^0.1.0",
+			"@vorra/compiler": "^0.1.0",
+			rolldown: "^0.14.0",
+			typescript: "^5.4.0"
+		},
+		engines: { node: ">=20.0.0" }
+	}, null, 2);
+}
+function tplTsconfig() {
+	return JSON.stringify({
+		compilerOptions: {
+			target: "ES2022",
+			module: "ESNext",
+			moduleResolution: "Bundler",
+			strict: true,
+			exactOptionalPropertyTypes: true,
+			noUncheckedIndexedAccess: true,
+			experimentalDecorators: true,
+			useDefineForClassFields: false,
+			skipLibCheck: true,
+			noEmit: true
+		},
+		include: ["src"]
+	}, null, 2);
+}
+function tplVorraConfig() {
+	return `// vorra.config.js
+import { defineConfig } from '@vorra/cli';
+
+export default defineConfig({
+  entry: 'src/main.ts',
+  outDir: 'dist',
+  port: 3000,
+});
+`;
+}
+function tplIndexHtml(name) {
+	return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${name}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <!-- entry script injected automatically by vorra dev / vorra build -->
+  </body>
+</html>
+`;
+}
+function tplGitignore() {
+	return `node_modules/
+dist/
+.vorra/
+*.tsbuildinfo
+`;
+}
+function tplEnvDts() {
+	return `// Type declarations for .vorra single-file components.
+import type { ComponentContext } from '@vorra/core';
+
+declare module '*.vorra' {
+  const component: (ctx: ComponentContext) => Node;
+  export default component;
+}
+`;
+}
+function tplMainTs() {
+	return `import { bootstrapApp } from '@vorra/core';
+import { createComponent, mountComponent } from '@vorra/core';
+import App from './App.vorra';
+
+const appEl = document.getElementById('app');
+if (appEl === null) throw new Error('[App] #app element not found in index.html');
+
+const root = bootstrapApp();
+const ctx = createComponent(root);
+mountComponent(App, appEl, ctx);
+`;
+}
+function tplAppVorra() {
+	return `<script>
+import { signal } from '@vorra/core';
+
+const count = signal(0);
+
+function increment(): void {
+  count.update((n) => n + 1);
+}
+<\/script>
+
+<template>
+  <div class="app">
+    <h1>Welcome to Vorra ⚡</h1>
+    <p class="counter">Count: {count()}</p>
+    <button @click="increment">Increment</button>
+  </div>
+</template>
+
+<style scoped>
+.app {
+  font-family: system-ui, sans-serif;
+  max-width: 480px;
+  margin: 4rem auto;
+  padding: 0 1rem;
+  text-align: center;
+}
+
+h1 {
+  font-size: 2rem;
+  margin-bottom: 1rem;
+}
+
+.counter {
+  font-size: 1.25rem;
+  margin-bottom: 1.5rem;
+}
+
+button {
+  padding: 0.5rem 1.5rem;
+  font-size: 1rem;
+  cursor: pointer;
+  border: 2px solid currentColor;
+  border-radius: 6px;
+  background: transparent;
+  transition: background 0.2s;
+}
+
+button:hover {
+  background: #f0f0f0;
+}
+</style>
+`;
+}
+//#endregion
+//#region src/commands/typecheck.ts
+/**
+* Runs TypeScript type checking via `tsc --build`.
+* Passes `--noEmit` unless the project tsconfig already disables emit.
+* Exits with the same code as tsc.
+*/
+function runTypecheck(args) {
+	const noEmit = args.includes("--emit") ? [] : ["--noEmit"];
+	console.log("[vorra typecheck] Running tsc --build...");
+	const result = spawnSync("tsc", ["--build", ...noEmit], {
+		stdio: "inherit",
+		shell: true,
+		cwd: process.cwd()
+	});
+	if (result.error !== void 0) {
+		console.error("[Vorra CLI] Failed to run tsc:", result.error.message);
+		process.exit(1);
+		return;
+	}
+	process.exit(result.status ?? 0);
+}
+//#endregion
+//#region src/bin.ts
+const args = process.argv.slice(2);
+const command = args[0];
+const commandArgs = args.slice(1);
+const VERSION = "0.1.0";
+const HELP = `
+  ⚡ Vorra — compiled signal-first framework for enterprise apps
+
+  Usage: vorra <command> [options]
+
+  Commands:
+    new <name>          Scaffold a new Vorra application
+    dev                 Start the development server (with live reload)
+    build               Build for production
+    typecheck           Run TypeScript type checking
+
+  Options:
+    --help, -h          Show this help message
+    --version, -v       Show the Vorra version
+
+  Flags per command:
+    dev   --port <n>    Dev server port (default: 3000)
+          --entry <p>   Entry file     (default: src/main.ts)
+          --outDir <p>  Output dir     (default: dist)
+    build --entry <p>   Entry file     (default: src/main.ts)
+          --outDir <p>  Output dir     (default: dist)
+
+  Examples:
+    vorra new my-app
+    vorra dev --port 4000
+    vorra build --outDir dist
+`;
+switch (command) {
+	case "new":
+		runNew(commandArgs);
+		break;
+	case "dev":
+		runDev(commandArgs).catch((err) => {
+			const msg = err instanceof Error ? err.message : String(err);
+			console.error("[Vorra CLI] dev error:", msg);
+			process.exit(1);
+		});
+		break;
+	case "build":
+		runBuild(commandArgs).catch((err) => {
+			const msg = err instanceof Error ? err.message : String(err);
+			console.error("[Vorra CLI] build error:", msg);
+			process.exit(1);
+		});
+		break;
+	case "typecheck":
+		runTypecheck(commandArgs);
+		break;
+	case "--version":
+	case "-v":
+		console.log(VERSION);
+		break;
+	case "--help":
+	case "-h":
+	case void 0:
+		console.log(HELP);
+		break;
+	default:
+		console.error(`[Vorra CLI] Unknown command: "${command}". Run "vorra --help" for usage.`);
+		process.exit(1);
+}
+//#endregion
+
+//# sourceMappingURL=bin.js.map