alepha 0.15.0 → 0.15.2

package/dist/cli/index.js

@@ -1,16 +1,1852 @@
-import { $atom, $hook, $inject, $module, $use, Alepha, AlephaError, t } from "alepha";
-import { FileSystemProvider } from "alepha/file";
-import { $command, CliProvider, EnvUtils } from "alepha/command";
-import { $logger, ConsoleColorProvider } from "alepha/logger";
-import { boot, buildClient, buildServer, copyAssets, devServer, generateCloudflare, generateDocker, generateSitemap, generateVercel, prerenderPages } from "alepha/vite";
-import { exec, spawn } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { $atom, $hook, $inject, $module, $use, Alepha, AlephaError, Json, isFileLike, t } from "alepha";
 import { basename, dirname, join } from "node:path";
+import { createReadStream, readFileSync } from "node:fs";
+import { access, copyFile, cp, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { PassThrough, Readable } from "node:stream";
+import { fileURLToPath } from "node:url";
+import { exec, spawn } from "node:child_process";
+import { $logger, ConsoleColorProvider } from "alepha/logger";
+import { $command, CliProvider, EnvUtils } from "alepha/command";
+import { buildClient, buildServer, copyAssets, generateCloudflare, generateDocker, generateSitemap, generateVercel, importVite, importViteReact, prerenderPages, viteAlephaSsrPreload } from "alepha/vite";
 import { promisify } from "node:util";
 import { ServerSwaggerProvider } from "alepha/server/swagger";
-import { access, readFile, readdir } from "node:fs/promises";
 import * as os from "node:os";
 
+//#region ../../src/system/providers/FileSystemProvider.ts
+/**
+* FileSystem interface providing utilities for working with files.
+*/
+var FileSystemProvider = class {};
+
+//#endregion
+//#region ../../src/system/providers/MemoryFileSystemProvider.ts
+/**
+* In-memory implementation of FileSystemProvider for testing.
+*
+* This provider stores all files and directories in memory, making it ideal for
+* unit tests that need to verify file operations without touching the real file system.
+*
+* @example
+* ```typescript
+* // In tests, substitute the real FileSystemProvider with MemoryFileSystemProvider
+* const alepha = Alepha.create().with({
+*   provide: FileSystemProvider,
+*   use: MemoryFileSystemProvider,
+* });
+*
+* // Run code that uses FileSystemProvider
+* const service = alepha.inject(MyService);
+* await service.saveFile("test.txt", "Hello World");
+*
+* // Verify the file was written
+* const memoryFs = alepha.inject(MemoryFileSystemProvider);
+* expect(memoryFs.files.get("test.txt")?.toString()).toBe("Hello World");
+* ```
+*/
+var MemoryFileSystemProvider = class {
+	json = $inject(Json);
+	/**
+	* In-memory storage for files (path -> content)
+	*/
+	files = /* @__PURE__ */ new Map();
+	/**
+	* In-memory storage for directories
+	*/
+	directories = /* @__PURE__ */ new Set();
+	/**
+	* Track mkdir calls for test assertions
+	*/
+	mkdirCalls = [];
+	/**
+	* Track writeFile calls for test assertions
+	*/
+	writeFileCalls = [];
+	/**
+	* Track readFile calls for test assertions
+	*/
+	readFileCalls = [];
+	/**
+	* Track rm calls for test assertions
+	*/
+	rmCalls = [];
+	/**
+	* Track join calls for test assertions
+	*/
+	joinCalls = [];
+	/**
+	* Error to throw on mkdir (for testing error handling)
+	*/
+	mkdirError = null;
+	/**
+	* Error to throw on writeFile (for testing error handling)
+	*/
+	writeFileError = null;
+	/**
+	* Error to throw on readFile (for testing error handling)
+	*/
+	readFileError = null;
+	constructor(options = {}) {
+		this.mkdirError = options.mkdirError ?? null;
+		this.writeFileError = options.writeFileError ?? null;
+		this.readFileError = options.readFileError ?? null;
+	}
+	/**
+	* Join path segments using forward slashes.
+	* Uses Node's path.join for proper normalization (handles .. and .)
+	*/
+	join(...paths) {
+		this.joinCalls.push(paths);
+		return join(...paths);
+	}
+	/**
+	* Create a FileLike object from various sources.
+	*/
+	createFile(options) {
+		if ("path" in options) {
+			const filePath = options.path;
+			const buffer = this.files.get(filePath);
+			if (buffer === void 0) throw new Error(`ENOENT: no such file or directory, open '${filePath}'`);
+			return {
+				name: options.name ?? filePath.split("/").pop() ?? "file",
+				type: options.type ?? "application/octet-stream",
+				size: buffer.byteLength,
+				lastModified: Date.now(),
+				stream: () => {
+					throw new Error("Stream not implemented in MemoryFileSystemProvider");
+				},
+				arrayBuffer: async () => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
+				text: async () => buffer.toString("utf-8")
+			};
+		}
+		if ("buffer" in options) {
+			const buffer = options.buffer;
+			return {
+				name: options.name ?? "file",
+				type: options.type ?? "application/octet-stream",
+				size: buffer.byteLength,
+				lastModified: Date.now(),
+				stream: () => {
+					throw new Error("Stream not implemented in MemoryFileSystemProvider");
+				},
+				arrayBuffer: async () => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
+				text: async () => buffer.toString("utf-8")
+			};
+		}
+		if ("text" in options) {
+			const buffer = Buffer.from(options.text, "utf-8");
+			return {
+				name: options.name ?? "file.txt",
+				type: options.type ?? "text/plain",
+				size: buffer.byteLength,
+				lastModified: Date.now(),
+				stream: () => {
+					throw new Error("Stream not implemented in MemoryFileSystemProvider");
+				},
+				arrayBuffer: async () => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
+				text: async () => options.text
+			};
+		}
+		throw new Error("MemoryFileSystemProvider.createFile: unsupported options. Only buffer and text are supported.");
+	}
+	/**
+	* Remove a file or directory from memory.
+	*/
+	async rm(path, options) {
+		this.rmCalls.push({
+			path,
+			options
+		});
+		if (!(this.files.has(path) || this.directories.has(path)) && !options?.force) throw new Error(`ENOENT: no such file or directory, rm '${path}'`);
+		if (this.directories.has(path)) if (options?.recursive) {
+			this.directories.delete(path);
+			for (const filePath of this.files.keys()) if (filePath.startsWith(`${path}/`)) this.files.delete(filePath);
+			for (const dirPath of this.directories) if (dirPath.startsWith(`${path}/`)) this.directories.delete(dirPath);
+		} else throw new Error(`EISDIR: illegal operation on a directory, rm '${path}'`);
+		else this.files.delete(path);
+	}
+	/**
+	* Copy a file or directory in memory.
+	*/
+	async cp(src, dest, options) {
+		if (this.directories.has(src)) {
+			if (!options?.recursive) throw new Error(`Cannot copy directory without recursive option: ${src}`);
+			this.directories.add(dest);
+			for (const [filePath, content] of this.files) if (filePath.startsWith(`${src}/`)) {
+				const newPath = filePath.replace(src, dest);
+				this.files.set(newPath, Buffer.from(content));
+			}
+		} else if (this.files.has(src)) {
+			const content = this.files.get(src);
+			this.files.set(dest, Buffer.from(content));
+		} else throw new Error(`ENOENT: no such file or directory, cp '${src}'`);
+	}
+	/**
+	* Move/rename a file or directory in memory.
+	*/
+	async mv(src, dest) {
+		if (this.directories.has(src)) {
+			this.directories.delete(src);
+			this.directories.add(dest);
+			for (const [filePath, content] of this.files) if (filePath.startsWith(`${src}/`)) {
+				const newPath = filePath.replace(src, dest);
+				this.files.delete(filePath);
+				this.files.set(newPath, content);
+			}
+		} else if (this.files.has(src)) {
+			const content = this.files.get(src);
+			this.files.delete(src);
+			this.files.set(dest, content);
+		} else throw new Error(`ENOENT: no such file or directory, mv '${src}'`);
+	}
+	/**
+	* Create a directory in memory.
+	*/
+	async mkdir(path, options) {
+		this.mkdirCalls.push({
+			path,
+			options
+		});
+		if (this.mkdirError) throw this.mkdirError;
+		if (this.directories.has(path) && !options?.recursive) throw new Error(`EEXIST: file already exists, mkdir '${path}'`);
+		this.directories.add(path);
+		if (options?.recursive) {
+			const parts = path.split("/").filter(Boolean);
+			let current = "";
+			for (const part of parts) {
+				current = current ? `${current}/${part}` : part;
+				this.directories.add(current);
+			}
+		}
+	}
+	/**
+	* List files in a directory.
+	*/
+	async ls(path, options) {
+		const normalizedPath = path.replace(/\/$/, "");
+		const entries = /* @__PURE__ */ new Set();
+		for (const filePath of this.files.keys()) if (filePath.startsWith(`${normalizedPath}/`)) {
+			const relativePath = filePath.slice(normalizedPath.length + 1);
+			const parts = relativePath.split("/");
+			if (options?.recursive) entries.add(relativePath);
+			else entries.add(parts[0]);
+		}
+		for (const dirPath of this.directories) if (dirPath.startsWith(`${normalizedPath}/`) && dirPath !== normalizedPath) {
+			const relativePath = dirPath.slice(normalizedPath.length + 1);
+			const parts = relativePath.split("/");
+			if (options?.recursive) entries.add(relativePath);
+			else if (parts.length === 1) entries.add(parts[0]);
+		}
+		let result = Array.from(entries);
+		if (!options?.hidden) result = result.filter((entry) => !entry.startsWith("."));
+		return result.sort();
+	}
+	/**
+	* Check if a file or directory exists in memory.
+	*/
+	async exists(path) {
+		return this.files.has(path) || this.directories.has(path);
+	}
+	/**
+	* Read a file from memory.
+	*/
+	async readFile(path) {
+		this.readFileCalls.push(path);
+		if (this.readFileError) throw this.readFileError;
+		const content = this.files.get(path);
+		if (!content) throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+		return content;
+	}
+	/**
+	* Read a file from memory as text.
+	*/
+	async readTextFile(path) {
+		return (await this.readFile(path)).toString("utf-8");
+	}
+	/**
+	* Read a file from memory as JSON.
+	*/
+	async readJsonFile(path) {
+		const text = await this.readTextFile(path);
+		return this.json.parse(text);
+	}
+	/**
+	* Write a file to memory.
+	*/
+	async writeFile(path, data) {
+		const dataStr = typeof data === "string" ? data : data instanceof Buffer || data instanceof Uint8Array ? data.toString("utf-8") : await data.text();
+		this.writeFileCalls.push({
+			path,
+			data: dataStr
+		});
+		if (this.writeFileError) throw this.writeFileError;
+		const buffer = typeof data === "string" ? Buffer.from(data, "utf-8") : data instanceof Buffer ? data : data instanceof Uint8Array ? Buffer.from(data) : Buffer.from(await data.text(), "utf-8");
+		this.files.set(path, buffer);
+	}
+	/**
+	* Reset all in-memory state (useful between tests).
+	*/
+	reset() {
+		this.files.clear();
+		this.directories.clear();
+		this.mkdirCalls = [];
+		this.writeFileCalls = [];
+		this.readFileCalls = [];
+		this.rmCalls = [];
+		this.joinCalls = [];
+		this.mkdirError = null;
+		this.writeFileError = null;
+		this.readFileError = null;
+	}
+	/**
+	* Check if a file was written during the test.
+	*
+	* @example
+	* ```typescript
+	* expect(fs.wasWritten("/project/tsconfig.json")).toBe(true);
+	* ```
+	*/
+	wasWritten(path) {
+		return this.writeFileCalls.some((call) => call.path === path);
+	}
+	/**
+	* Check if a file was written with content matching a pattern.
+	*
+	* @example
+	* ```typescript
+	* expect(fs.wasWrittenMatching("/project/tsconfig.json", /extends/)).toBe(true);
+	* ```
+	*/
+	wasWrittenMatching(path, pattern) {
+		const call = this.writeFileCalls.find((c) => c.path === path);
+		return call ? pattern.test(call.data) : false;
+	}
+	/**
+	* Check if a file was read during the test.
+	*
+	* @example
+	* ```typescript
+	* expect(fs.wasRead("/project/package.json")).toBe(true);
+	* ```
+	*/
+	wasRead(path) {
+		return this.readFileCalls.includes(path);
+	}
+	/**
+	* Check if a file was deleted during the test.
+	*
+	* @example
+	* ```typescript
+	* expect(fs.wasDeleted("/project/old-file.txt")).toBe(true);
+	* ```
+	*/
+	wasDeleted(path) {
+		return this.rmCalls.some((call) => call.path === path);
+	}
+	/**
+	* Get the content of a file as a string (convenience method for testing).
+	*/
+	getFileContent(path) {
+		return this.files.get(path)?.toString("utf-8");
+	}
+};
+
+//#endregion
+//#region ../../src/system/providers/MemoryShellProvider.ts
+/**
+* In-memory implementation of ShellProvider for testing.
+*
+* Records all commands that would be executed without actually running them.
+* Can be configured to return specific outputs or throw errors for testing.
+*
+* @example
+* ```typescript
+* // In tests, substitute the real ShellProvider with MemoryShellProvider
+* const alepha = Alepha.create().with({
+*   provide: ShellProvider,
+*   use: MemoryShellProvider,
+* });
+*
+* // Configure mock behavior
+* const shell = alepha.inject(MemoryShellProvider);
+* shell.configure({
+*   outputs: { "echo hello": "hello\n" },
+*   errors: { "failing-cmd": "Command failed" },
+* });
+*
+* // Or use the fluent API
+* shell.outputs.set("another-cmd", "output");
+* shell.errors.set("another-error", "Error message");
+*
+* // Run code that uses ShellProvider
+* const service = alepha.inject(MyService);
+* await service.doSomething();
+*
+* // Verify commands were called
+* expect(shell.calls).toHaveLength(2);
+* expect(shell.calls[0].command).toBe("yarn install");
+* ```
+*/
+var MemoryShellProvider = class {
+	/**
+	* All recorded shell calls.
+	*/
+	calls = [];
+	/**
+	* Simulated outputs for specific commands.
+	*/
+	outputs = /* @__PURE__ */ new Map();
+	/**
+	* Commands that should throw an error.
+	*/
+	errors = /* @__PURE__ */ new Map();
+	/**
+	* Commands considered installed in the system PATH.
+	*/
+	installedCommands = /* @__PURE__ */ new Set();
+	/**
+	* Configure the mock with predefined outputs, errors, and installed commands.
+	*/
+	configure(options) {
+		if (options.outputs) for (const [cmd, output] of Object.entries(options.outputs)) this.outputs.set(cmd, output);
+		if (options.errors) for (const [cmd, error] of Object.entries(options.errors)) this.errors.set(cmd, error);
+		if (options.installedCommands) for (const cmd of options.installedCommands) this.installedCommands.add(cmd);
+		return this;
+	}
+	/**
+	* Record command and return simulated output.
+	*/
+	async run(command, options = {}) {
+		this.calls.push({
+			command,
+			options
+		});
+		const errorMsg = this.errors.get(command);
+		if (errorMsg) throw new Error(errorMsg);
+		return this.outputs.get(command) ?? "";
+	}
+	/**
+	* Check if a specific command was called.
+	*/
+	wasCalled(command) {
+		return this.calls.some((call) => call.command === command);
+	}
+	/**
+	* Check if a command matching a pattern was called.
+	*/
+	wasCalledMatching(pattern) {
+		return this.calls.some((call) => pattern.test(call.command));
+	}
+	/**
+	* Get all calls matching a pattern.
+	*/
+	getCallsMatching(pattern) {
+		return this.calls.filter((call) => pattern.test(call.command));
+	}
+	/**
+	* Check if a command is installed.
+	*/
+	async isInstalled(command) {
+		return this.installedCommands.has(command);
+	}
+	/**
+	* Reset all recorded state.
+	*/
+	reset() {
+		this.calls = [];
+		this.outputs.clear();
+		this.errors.clear();
+		this.installedCommands.clear();
+	}
+};
+
+//#endregion
+//#region ../../src/system/services/FileDetector.ts
+/**
+* Service for detecting file types and getting content types.
+*
+* @example
+* ```typescript
+* const detector = alepha.inject(FileDetector);
+*
+* // Get content type from filename
+* const mimeType = detector.getContentType("image.png"); // "image/png"
+*
+* // Detect file type by magic bytes
+* const stream = createReadStream('image.png');
+* const result = await detector.detectFileType(stream, 'image.png');
+* console.log(result.mimeType); // 'image/png'
+* console.log(result.verified); // true if magic bytes match
+* ```
+*/
+var FileDetector = class FileDetector {
+	/**
+	* Magic byte signatures for common file formats.
+	* Each signature is represented as an array of bytes or null (wildcard).
+	*/
+	static MAGIC_BYTES = {
+		png: [{
+			signature: [
+				137,
+				80,
+				78,
+				71,
+				13,
+				10,
+				26,
+				10
+			],
+			mimeType: "image/png"
+		}],
+		jpg: [
+			{
+				signature: [
+					255,
+					216,
+					255,
+					224
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					225
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					226
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					227
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					232
+				],
+				mimeType: "image/jpeg"
+			}
+		],
+		jpeg: [
+			{
+				signature: [
+					255,
+					216,
+					255,
+					224
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					225
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					226
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					227
+				],
+				mimeType: "image/jpeg"
+			},
+			{
+				signature: [
+					255,
+					216,
+					255,
+					232
+				],
+				mimeType: "image/jpeg"
+			}
+		],
+		gif: [{
+			signature: [
+				71,
+				73,
+				70,
+				56,
+				55,
+				97
+			],
+			mimeType: "image/gif"
+		}, {
+			signature: [
+				71,
+				73,
+				70,
+				56,
+				57,
+				97
+			],
+			mimeType: "image/gif"
+		}],
+		webp: [{
+			signature: [
+				82,
+				73,
+				70,
+				70,
+				null,
+				null,
+				null,
+				null,
+				87,
+				69,
+				66,
+				80
+			],
+			mimeType: "image/webp"
+		}],
+		bmp: [{
+			signature: [66, 77],
+			mimeType: "image/bmp"
+		}],
+		ico: [{
+			signature: [
+				0,
+				0,
+				1,
+				0
+			],
+			mimeType: "image/x-icon"
+		}],
+		tiff: [{
+			signature: [
+				73,
+				73,
+				42,
+				0
+			],
+			mimeType: "image/tiff"
+		}, {
+			signature: [
+				77,
+				77,
+				0,
+				42
+			],
+			mimeType: "image/tiff"
+		}],
+		tif: [{
+			signature: [
+				73,
+				73,
+				42,
+				0
+			],
+			mimeType: "image/tiff"
+		}, {
+			signature: [
+				77,
+				77,
+				0,
+				42
+			],
+			mimeType: "image/tiff"
+		}],
+		pdf: [{
+			signature: [
+				37,
+				80,
+				68,
+				70,
+				45
+			],
+			mimeType: "application/pdf"
+		}],
+		zip: [
+			{
+				signature: [
+					80,
+					75,
+					3,
+					4
+				],
+				mimeType: "application/zip"
+			},
+			{
+				signature: [
+					80,
+					75,
+					5,
+					6
+				],
+				mimeType: "application/zip"
+			},
+			{
+				signature: [
+					80,
+					75,
+					7,
+					8
+				],
+				mimeType: "application/zip"
+			}
+		],
+		rar: [{
+			signature: [
+				82,
+				97,
+				114,
+				33,
+				26,
+				7
+			],
+			mimeType: "application/vnd.rar"
+		}],
+		"7z": [{
+			signature: [
+				55,
+				122,
+				188,
+				175,
+				39,
+				28
+			],
+			mimeType: "application/x-7z-compressed"
+		}],
+		tar: [{
+			signature: [
+				117,
+				115,
+				116,
+				97,
+				114
+			],
+			mimeType: "application/x-tar"
+		}],
+		gz: [{
+			signature: [31, 139],
+			mimeType: "application/gzip"
+		}],
+		tgz: [{
+			signature: [31, 139],
+			mimeType: "application/gzip"
+		}],
+		mp3: [
+			{
+				signature: [255, 251],
+				mimeType: "audio/mpeg"
+			},
+			{
+				signature: [255, 243],
+				mimeType: "audio/mpeg"
+			},
+			{
+				signature: [255, 242],
+				mimeType: "audio/mpeg"
+			},
+			{
+				signature: [
+					73,
+					68,
+					51
+				],
+				mimeType: "audio/mpeg"
+			}
+		],
+		wav: [{
+			signature: [
+				82,
+				73,
+				70,
+				70,
+				null,
+				null,
+				null,
+				null,
+				87,
+				65,
+				86,
+				69
+			],
+			mimeType: "audio/wav"
+		}],
+		ogg: [{
+			signature: [
+				79,
+				103,
+				103,
+				83
+			],
+			mimeType: "audio/ogg"
+		}],
+		flac: [{
+			signature: [
+				102,
+				76,
+				97,
+				67
+			],
+			mimeType: "audio/flac"
+		}],
+		mp4: [
+			{
+				signature: [
+					null,
+					null,
+					null,
+					null,
+					102,
+					116,
+					121,
+					112
+				],
+				mimeType: "video/mp4"
+			},
+			{
+				signature: [
+					null,
+					null,
+					null,
+					null,
+					102,
+					116,
+					121,
+					112,
+					105,
+					115,
+					111,
+					109
+				],
+				mimeType: "video/mp4"
+			},
+			{
+				signature: [
+					null,
+					null,
+					null,
+					null,
+					102,
+					116,
+					121,
+					112,
+					109,
+					112,
+					52,
+					50
+				],
+				mimeType: "video/mp4"
+			}
+		],
+		webm: [{
+			signature: [
+				26,
+				69,
+				223,
+				163
+			],
+			mimeType: "video/webm"
+		}],
+		avi: [{
+			signature: [
+				82,
+				73,
+				70,
+				70,
+				null,
+				null,
+				null,
+				null,
+				65,
+				86,
+				73,
+				32
+			],
+			mimeType: "video/x-msvideo"
+		}],
+		mov: [{
+			signature: [
+				null,
+				null,
+				null,
+				null,
+				102,
+				116,
+				121,
+				112,
+				113,
+				116,
+				32,
+				32
+			],
+			mimeType: "video/quicktime"
+		}],
+		mkv: [{
+			signature: [
+				26,
+				69,
+				223,
+				163
+			],
+			mimeType: "video/x-matroska"
+		}],
+		docx: [{
+			signature: [
+				80,
+				75,
+				3,
+				4
+			],
+			mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+		}],
+		xlsx: [{
+			signature: [
+				80,
+				75,
+				3,
+				4
+			],
+			mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+		}],
+		pptx: [{
+			signature: [
+				80,
+				75,
+				3,
+				4
+			],
+			mimeType: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+		}],
+		doc: [{
+			signature: [
+				208,
+				207,
+				17,
+				224,
+				161,
+				177,
+				26,
+				225
+			],
+			mimeType: "application/msword"
+		}],
+		xls: [{
+			signature: [
+				208,
+				207,
+				17,
+				224,
+				161,
+				177,
+				26,
+				225
+			],
+			mimeType: "application/vnd.ms-excel"
+		}],
+		ppt: [{
+			signature: [
+				208,
+				207,
+				17,
+				224,
+				161,
+				177,
+				26,
+				225
+			],
+			mimeType: "application/vnd.ms-powerpoint"
+		}]
+	};
+	/**
+	* All possible format signatures for checking against actual file content
+	*/
+	static ALL_SIGNATURES = Object.entries(FileDetector.MAGIC_BYTES).flatMap(([ext, signatures]) => signatures.map((sig) => ({
+		ext,
+		...sig
+	})));
+	/**
+	* MIME type map for file extensions.
+	*
+	* Can be used to get the content type of file based on its extension.
+	* Feel free to add more mime types in your project!
+	*/
+	static mimeMap = {
+		json: "application/json",
+		txt: "text/plain",
+		html: "text/html",
+		htm: "text/html",
+		xml: "application/xml",
+		csv: "text/csv",
+		pdf: "application/pdf",
+		md: "text/markdown",
+		markdown: "text/markdown",
+		rtf: "application/rtf",
+		css: "text/css",
+		js: "application/javascript",
+		mjs: "application/javascript",
+		ts: "application/typescript",
+		jsx: "text/jsx",
+		tsx: "text/tsx",
+		zip: "application/zip",
+		rar: "application/vnd.rar",
+		"7z": "application/x-7z-compressed",
+		tar: "application/x-tar",
+		gz: "application/gzip",
+		tgz: "application/gzip",
+		png: "image/png",
+		jpg: "image/jpeg",
+		jpeg: "image/jpeg",
+		gif: "image/gif",
+		webp: "image/webp",
+		svg: "image/svg+xml",
+		bmp: "image/bmp",
+		ico: "image/x-icon",
+		tiff: "image/tiff",
+		tif: "image/tiff",
+		mp3: "audio/mpeg",
+		wav: "audio/wav",
+		ogg: "audio/ogg",
+		m4a: "audio/mp4",
+		aac: "audio/aac",
+		flac: "audio/flac",
+		mp4: "video/mp4",
+		webm: "video/webm",
+		avi: "video/x-msvideo",
+		mov: "video/quicktime",
+		wmv: "video/x-ms-wmv",
+		flv: "video/x-flv",
+		mkv: "video/x-matroska",
+		doc: "application/msword",
+		docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+		xls: "application/vnd.ms-excel",
+		xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+		ppt: "application/vnd.ms-powerpoint",
+		pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+		woff: "font/woff",
+		woff2: "font/woff2",
+		ttf: "font/ttf",
+		otf: "font/otf",
+		eot: "application/vnd.ms-fontobject"
+	};
+	/**
+	* Reverse MIME type map for looking up extensions from MIME types.
+	* Prefers shorter, more common extensions when multiple exist.
+	*/
+	static reverseMimeMap = (() => {
+		const reverse = {};
+		for (const [ext, mimeType] of Object.entries(FileDetector.mimeMap)) if (!reverse[mimeType]) reverse[mimeType] = ext;
+		return reverse;
+	})();
+	/**
+	* Returns the file extension for a given MIME type.
+	*
+	* @param mimeType - The MIME type to look up
+	* @returns The file extension (without dot), or "bin" if not found
+	*
+	* @example
+	* ```typescript
+	* const detector = alepha.inject(FileDetector);
+	* const ext = detector.getExtensionFromMimeType("image/png"); // "png"
+	* const ext2 = detector.getExtensionFromMimeType("application/octet-stream"); // "bin"
+	* ```
+	*/
+	getExtensionFromMimeType(mimeType) {
+		return FileDetector.reverseMimeMap[mimeType] || "bin";
+	}
+	/**
+	* Returns the content type of file based on its filename.
+	*
+	* @param filename - The filename to check
+	* @returns The MIME type
+	*
+	* @example
+	* ```typescript
+	* const detector = alepha.inject(FileDetector);
+	* const mimeType = detector.getContentType("image.png"); // "image/png"
+	* ```
+	*/
+	getContentType(filename) {
+		const ext = filename.toLowerCase().split(".").pop() || "";
+		return FileDetector.mimeMap[ext] || "application/octet-stream";
+	}
+	/**
+	* Detects the file type by checking magic bytes against the stream content.
+	*
+	* @param stream - The readable stream to check
+	* @param filename - The filename (used to get the extension)
+	* @returns File type information including MIME type, extension, and verification status
+	*
+	* @example
+	* ```typescript
+	* const detector = alepha.inject(FileDetector);
+	* const stream = createReadStream('image.png');
+	* const result = await detector.detectFileType(stream, 'image.png');
+	* console.log(result.mimeType); // 'image/png'
+	* console.log(result.verified); // true if magic bytes match
+	* ```
+	*/
+	async detectFileType(stream, filename) {
+		const expectedMimeType = this.getContentType(filename);
+		const lastDotIndex = filename.lastIndexOf(".");
+		const ext = lastDotIndex > 0 ? filename.substring(lastDotIndex + 1).toLowerCase() : "";
+		const { buffer, stream: newStream } = await this.peekBytes(stream, 16);
+		const expectedSignatures = FileDetector.MAGIC_BYTES[ext];
+		if (expectedSignatures) {
+			for (const { signature, mimeType } of expectedSignatures) if (this.matchesSignature(buffer, signature)) return {
+				mimeType,
+				extension: ext,
+				verified: true,
+				stream: newStream
+			};
+		}
+		for (const { ext: detectedExt, signature, mimeType } of FileDetector.ALL_SIGNATURES) if (detectedExt !== ext && this.matchesSignature(buffer, signature)) return {
+			mimeType,
+			extension: detectedExt,
+			verified: true,
+			stream: newStream
+		};
+		return {
+			mimeType: expectedMimeType,
+			extension: ext,
+			verified: false,
+			stream: newStream
+		};
+	}
+	/**
+	* Reads all bytes from a stream and returns the first N bytes along with a new stream containing all data.
+	* This approach reads the entire stream upfront to avoid complex async handling issues.
+	*
+	* @protected
+	*/
+	async peekBytes(stream, numBytes) {
+		const chunks = [];
+		for await (const chunk of stream) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+		const allData = Buffer.concat(chunks);
+		return {
+			buffer: allData.subarray(0, numBytes),
+			stream: Readable.from(allData)
+		};
+	}
+	/**
+	* Checks if a buffer matches a magic byte signature.
+	*
+	* @protected
+	*/
+	matchesSignature(buffer, signature) {
+		if (buffer.length < signature.length) return false;
+		for (let i = 0; i < signature.length; i++) if (signature[i] !== null && buffer[i] !== signature[i]) return false;
+		return true;
+	}
+};
+
+//#endregion
+//#region ../../src/system/providers/NodeFileSystemProvider.ts
+/**
+* Node.js implementation of FileSystem interface.
+*
+* @example
+* ```typescript
+* const fs = alepha.inject(NodeFileSystemProvider);
+*
+* // Create from URL
+* const file1 = fs.createFile({ url: "file:///path/to/file.png" });
+*
+* // Create from Buffer
+* const file2 = fs.createFile({ buffer: Buffer.from("hello"), name: "hello.txt" });
+*
+* // Create from text
+* const file3 = fs.createFile({ text: "Hello, world!", name: "greeting.txt" });
+*
+* // File operations
+* await fs.mkdir("/tmp/mydir", { recursive: true });
+* await fs.cp("/src/file.txt", "/dest/file.txt");
+* await fs.mv("/old/path.txt", "/new/path.txt");
+* const files = await fs.ls("/tmp");
+* await fs.rm("/tmp/file.txt");
+* ```
+*/
+var NodeFileSystemProvider = class {
+	detector = $inject(FileDetector);
+	json = $inject(Json);
+	join(...paths) {
+		return join(...paths);
+	}
+	/**
+	* Creates a FileLike object from various sources.
+	*
+	* @param options - Options for creating the file
+	* @returns A FileLike object
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // From URL
+	* const file1 = fs.createFile({ url: "https://example.com/image.png" });
+	*
+	* // From Buffer
+	* const file2 = fs.createFile({
+	*   buffer: Buffer.from("hello"),
+	*   name: "hello.txt",
+	*   type: "text/plain"
+	* });
+	*
+	* // From text
+	* const file3 = fs.createFile({ text: "Hello!", name: "greeting.txt" });
+	*
+	* // From stream with detection
+	* const stream = createReadStream("/path/to/file.png");
+	* const file4 = fs.createFile({ stream, name: "image.png" });
+	* ```
+	*/
+	createFile(options) {
+		if ("path" in options) {
+			const path = options.path;
+			const filename = path.split("/").pop() || "file";
+			return this.createFileFromUrl(`file://${path}`, {
+				type: options.type,
+				name: options.name || filename
+			});
+		}
+		if ("url" in options) return this.createFileFromUrl(options.url, {
+			type: options.type,
+			name: options.name
+		});
+		if ("response" in options) {
+			if (!options.response.body) throw new AlephaError("Response has no body stream");
+			const res = options.response;
+			const sizeHeader = res.headers.get("content-length");
+			const size = sizeHeader ? parseInt(sizeHeader, 10) : void 0;
+			let name = options.name;
+			const contentDisposition = res.headers.get("content-disposition");
+			if (contentDisposition && !name) {
+				const match = contentDisposition.match(/filename="?([^"]+)"?/);
+				if (match) name = match[1];
+			}
+			const type = options.type || res.headers.get("content-type") || void 0;
+			return this.createFileFromStream(options.response.body, {
+				type,
+				name,
+				size
+			});
+		}
+		if ("file" in options) return this.createFileFromWebFile(options.file, {
+			type: options.type,
+			name: options.name,
+			size: options.size
+		});
+		if ("buffer" in options) return this.createFileFromBuffer(options.buffer, {
+			type: options.type,
+			name: options.name
+		});
+		if ("arrayBuffer" in options) return this.createFileFromBuffer(Buffer.from(options.arrayBuffer), {
+			type: options.type,
+			name: options.name
+		});
+		if ("text" in options) return this.createFileFromBuffer(Buffer.from(options.text, "utf-8"), {
+			type: options.type || "text/plain",
+			name: options.name || "file.txt"
+		});
+		if ("stream" in options) return this.createFileFromStream(options.stream, {
+			type: options.type,
+			name: options.name,
+			size: options.size
+		});
+		throw new AlephaError("Invalid createFile options: no valid source provided");
+	}
+	/**
+	* Removes a file or directory.
+	*
+	* @param path - The path to remove
+	* @param options - Remove options
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // Remove a file
+	* await fs.rm("/tmp/file.txt");
+	*
+	* // Remove a directory recursively
+	* await fs.rm("/tmp/mydir", { recursive: true });
+	*
+	* // Remove with force (no error if doesn't exist)
+	* await fs.rm("/tmp/maybe-exists.txt", { force: true });
+	* ```
+	*/
+	async rm(path, options) {
+		await rm(path, options);
+	}
+	/**
+	* Copies a file or directory.
+	*
+	* @param src - Source path
+	* @param dest - Destination path
+	* @param options - Copy options
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // Copy a file
+	* await fs.cp("/src/file.txt", "/dest/file.txt");
+	*
+	* // Copy a directory recursively
+	* await fs.cp("/src/dir", "/dest/dir", { recursive: true });
+	*
+	* // Copy with force (overwrite existing)
+	* await fs.cp("/src/file.txt", "/dest/file.txt", { force: true });
+	* ```
+	*/
+	async cp(src, dest, options) {
+		if ((await stat(src)).isDirectory()) {
+			if (!options?.recursive) throw new Error(`Cannot copy directory without recursive option: ${src}`);
+			await cp(src, dest, {
+				recursive: true,
+				force: options?.force ?? false
+			});
+		} else await copyFile(src, dest);
+	}
+	/**
+	* Moves/renames a file or directory.
+	*
+	* @param src - Source path
+	* @param dest - Destination path
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // Move/rename a file
+	* await fs.mv("/old/path.txt", "/new/path.txt");
+	*
+	* // Move a directory
+	* await fs.mv("/old/dir", "/new/dir");
+	* ```
+	*/
+	async mv(src, dest) {
+		await rename(src, dest);
+	}
+	/**
+	* Creates a directory.
+	*
+	* @param path - The directory path to create
+	* @param options - Mkdir options
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // Create a directory
+	* await fs.mkdir("/tmp/mydir");
+	*
+	* // Create nested directories
+	* await fs.mkdir("/tmp/path/to/dir", { recursive: true });
+	*
+	* // Create with specific permissions
+	* await fs.mkdir("/tmp/mydir", { mode: 0o755 });
+	* ```
+	*/
+	async mkdir(path, options) {
+		await mkdir(path, options);
+	}
+	/**
+	* Lists files in a directory.
+	*
+	* @param path - The directory path to list
+	* @param options - List options
+	* @returns Array of filenames
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // List files in a directory
+	* const files = await fs.ls("/tmp");
+	* console.log(files); // ["file1.txt", "file2.txt", "subdir"]
+	*
+	* // List with hidden files
+	* const allFiles = await fs.ls("/tmp", { hidden: true });
+	*
+	* // List recursively
+	* const allFilesRecursive = await fs.ls("/tmp", { recursive: true });
+	* ```
+	*/
+	async ls(path, options) {
+		const entries = await readdir(path);
+		const filteredEntries = options?.hidden ? entries : entries.filter((e) => !e.startsWith("."));
+		if (options?.recursive) {
+			const allFiles = [];
+			for (const entry of filteredEntries) {
+				const fullPath = join(path, entry);
+				if ((await stat(fullPath)).isDirectory()) {
+					allFiles.push(entry);
+					const subFiles = await this.ls(fullPath, options);
+					allFiles.push(...subFiles.map((f) => join(entry, f)));
+				} else allFiles.push(entry);
+			}
+			return allFiles;
+		}
+		return filteredEntries;
+	}
+	/**
+	* Checks if a file or directory exists.
+	*
+	* @param path - The path to check
+	* @returns True if the path exists, false otherwise
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* if (await fs.exists("/tmp/file.txt")) {
+	*   console.log("File exists");
+	* }
+	* ```
+	*/
+	async exists(path) {
+		try {
+			await access(path);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Reads the content of a file.
+	*
+	* @param path - The file path to read
+	* @returns The file content as a Buffer
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* const buffer = await fs.readFile("/tmp/file.txt");
+	* console.log(buffer.toString("utf-8"));
+	* ```
+	*/
+	async readFile(path) {
+		return await readFile(path);
+	}
+	/**
+	* Writes data to a file.
+	*
+	* @param path - The file path to write to
+	* @param data - The data to write (Buffer or string)
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	*
+	* // Write string
+	* await fs.writeFile("/tmp/file.txt", "Hello, world!");
+	*
+	* // Write Buffer
+	* await fs.writeFile("/tmp/file.bin", Buffer.from([0x01, 0x02, 0x03]));
+	* ```
+	*/
+	async writeFile(path, data) {
+		if (isFileLike(data)) {
+			await writeFile(path, Readable.from(data.stream()));
+			return;
+		}
+		await writeFile(path, data);
+	}
+	/**
+	* Reads the content of a file as a string.
+	*
+	* @param path - The file path to read
+	* @returns The file content as a string
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	* const content = await fs.readTextFile("/tmp/file.txt");
+	* ```
+	*/
+	async readTextFile(path) {
+		return (await this.readFile(path)).toString("utf-8");
+	}
+	/**
+	* Reads the content of a file as JSON.
+	*
+	* @param path - The file path to read
+	* @returns The parsed JSON content
+	*
+	* @example
+	* ```typescript
+	* const fs = alepha.inject(NodeFileSystemProvider);
+	* const config = await fs.readJsonFile<{ name: string }>("/tmp/config.json");
+	* ```
+	*/
+	async readJsonFile(path) {
+		const text = await this.readTextFile(path);
+		return this.json.parse(text);
+	}
+	/**
+	* Creates a FileLike object from a Web File.
+	*
+	* @protected
+	*/
+	createFileFromWebFile(source, options = {}) {
+		const name = options.name ?? source.name;
+		return {
+			name,
+			type: options.type ?? (source.type || this.detector.getContentType(name)),
+			size: options.size ?? source.size ?? 0,
+			lastModified: source.lastModified || Date.now(),
+			stream: () => source.stream(),
+			arrayBuffer: async () => {
+				return await source.arrayBuffer();
+			},
+			text: async () => {
+				return await source.text();
+			}
+		};
+	}
+	/**
+	* Creates a FileLike object from a Buffer.
+	*
+	* @protected
+	*/
+	createFileFromBuffer(source, options = {}) {
+		const name = options.name ?? "file";
+		return {
+			name,
+			type: options.type ?? this.detector.getContentType(options.name ?? name),
+			size: source.byteLength,
+			lastModified: Date.now(),
+			stream: () => Readable.from(source),
+			arrayBuffer: async () => {
+				return this.bufferToArrayBuffer(source);
+			},
+			text: async () => {
+				return source.toString("utf-8");
+			}
+		};
+	}
+	/**
+	* Creates a FileLike object from a stream.
+	*
+	* @protected
+	*/
+	createFileFromStream(source, options = {}) {
+		let buffer = null;
+		return {
+			name: options.name ?? "file",
+			type: options.type ?? this.detector.getContentType(options.name ?? "file"),
+			size: options.size ?? 0,
+			lastModified: Date.now(),
+			stream: () => source,
+			_buffer: null,
+			arrayBuffer: async () => {
+				buffer ??= await this.streamToBuffer(source);
+				return this.bufferToArrayBuffer(buffer);
+			},
+			text: async () => {
+				buffer ??= await this.streamToBuffer(source);
+				return buffer.toString("utf-8");
+			}
+		};
+	}
+	/**
+	* Creates a FileLike object from a URL.
+	*
+	* @protected
+	*/
+	createFileFromUrl(url, options = {}) {
+		const parsedUrl = new URL(url);
+		const filename = options.name || parsedUrl.pathname.split("/").pop() || "file";
+		let buffer = null;
+		return {
+			name: filename,
+			type: options.type ?? this.detector.getContentType(filename),
+			size: 0,
+			lastModified: Date.now(),
+			stream: () => this.createStreamFromUrl(url),
+			arrayBuffer: async () => {
+				buffer ??= await this.loadFromUrl(url);
+				return this.bufferToArrayBuffer(buffer);
+			},
+			text: async () => {
+				buffer ??= await this.loadFromUrl(url);
+				return buffer.toString("utf-8");
+			},
+			filepath: url
+		};
+	}
+	/**
+	* Gets a streaming response from a URL.
+	*
+	* @protected
+	*/
+	getStreamingResponse(url) {
+		const stream = new PassThrough();
+		fetch(url).then((res) => Readable.fromWeb(res.body).pipe(stream)).catch((err) => stream.destroy(err));
+		return stream;
+	}
+	/**
+	* Loads data from a URL.
+	*
+	* @protected
+	*/
+	async loadFromUrl(url) {
+		const parsedUrl = new URL(url);
+		if (parsedUrl.protocol === "file:") return await readFile(fileURLToPath(url));
+		else if (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:") {
+			const response = await fetch(url);
+			if (!response.ok) throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+			const arrayBuffer = await response.arrayBuffer();
+			return Buffer.from(arrayBuffer);
+		} else throw new Error(`Unsupported protocol: ${parsedUrl.protocol}`);
+	}
+	/**
+	* Creates a stream from a URL.
+	*
+	* @protected
+	*/
+	createStreamFromUrl(url) {
+		const parsedUrl = new URL(url);
+		if (parsedUrl.protocol === "file:") return createReadStream(fileURLToPath(url));
+		else if (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:") return this.getStreamingResponse(url);
+		else throw new AlephaError(`Unsupported protocol: ${parsedUrl.protocol}`);
+	}
+	/**
+	* Converts a stream-like object to a Buffer.
+	*
+	* @protected
+	*/
+	async streamToBuffer(streamLike) {
+		const stream = streamLike instanceof Readable ? streamLike : Readable.fromWeb(streamLike);
+		return new Promise((resolve, reject) => {
+			const buffer = [];
+			stream.on("data", (chunk) => buffer.push(Buffer.from(chunk)));
+			stream.on("end", () => resolve(Buffer.concat(buffer)));
+			stream.on("error", (err) => reject(new AlephaError("Error converting stream", { cause: err })));
+		});
+	}
+	/**
+	* Converts a Node.js Buffer to an ArrayBuffer.
+	*
+	* @protected
+	*/
+	bufferToArrayBuffer(buffer) {
+		return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+	}
+};
+
+//#endregion
+//#region ../../src/system/providers/NodeShellProvider.ts
+/**
+* Node.js implementation of ShellProvider.
+*
+* Executes shell commands using Node.js child_process module.
+* Supports binary resolution from node_modules/.bin for local packages.
+*/
+var NodeShellProvider = class {
+	log = $logger();
+	fs = $inject(FileSystemProvider);
+	/**
+	* Run a shell command or binary.
+	*/
+	async run(command, options = {}) {
+		const { resolve = false, capture = false, root, env } = options;
+		const cwd = root ?? process.cwd();
+		this.log.debug(`Shell: ${command}`, {
+			cwd,
+			resolve,
+			capture
+		});
+		let executable;
+		let args;
+		if (resolve) {
+			const [bin, ...rest] = command.split(" ");
+			executable = await this.resolveExecutable(bin, cwd);
+			args = rest;
+		} else [executable, ...args] = command.split(" ");
+		if (capture) return this.execCapture(command, {
+			cwd,
+			env
+		});
+		return this.execInherit(executable, args, {
+			cwd,
+			env
+		});
+	}
+	/**
+	* Execute command with inherited stdio (streams to terminal).
+	*/
+	async execInherit(executable, args, options) {
+		const proc = spawn(executable, args, {
+			stdio: "inherit",
+			cwd: options.cwd,
+			env: {
+				...process.env,
+				...options.env
+			}
+		});
+		return new Promise((resolve, reject) => {
+			proc.on("exit", (code) => {
+				if (code === 0 || code === null) resolve("");
+				else reject(new AlephaError(`Command exited with code ${code}`));
+			});
+			proc.on("error", reject);
+		});
+	}
+	/**
+	* Execute command and capture stdout.
+	*/
+	execCapture(command, options) {
+		return new Promise((resolve, reject) => {
+			exec(command, {
+				cwd: options.cwd,
+				env: {
+					...process.env,
+					LOG_FORMAT: "pretty",
+					...options.env
+				}
+			}, (err, stdout) => {
+				if (err) {
+					err.stdout = stdout;
+					reject(err);
+				} else resolve(stdout);
+			});
+		});
+	}
+	/**
+	* Resolve executable path from node_modules/.bin.
+	*
+	* Search order:
+	* 1. Local: node_modules/.bin/
+	* 2. Pnpm nested: node_modules/alepha/node_modules/.bin/
+	* 3. Monorepo: Walk up to 3 parent directories
+	*/
+	async resolveExecutable(name, root) {
+		const suffix = process.platform === "win32" ? ".cmd" : "";
+		let execPath = await this.findExecutable(root, `node_modules/.bin/${name}${suffix}`);
+		if (!execPath) execPath = await this.findExecutable(root, `node_modules/alepha/node_modules/.bin/${name}${suffix}`);
+		if (!execPath) {
+			let parentDir = this.fs.join(root, "..");
+			for (let i = 0; i < 3; i++) {
+				execPath = await this.findExecutable(parentDir, `node_modules/.bin/${name}${suffix}`);
+				if (execPath) break;
+				parentDir = this.fs.join(parentDir, "..");
+			}
+		}
+		if (!execPath) throw new AlephaError(`Could not find executable for '${name}'. Make sure the package is installed.`);
+		return execPath;
+	}
+	/**
+	* Check if executable exists at path.
+	*/
+	async findExecutable(root, relativePath) {
+		const fullPath = this.fs.join(root, relativePath);
+		if (await this.fs.exists(fullPath)) return fullPath;
+	}
+	/**
+	* Check if a command is installed and available in the system PATH.
+	*/
+	isInstalled(command) {
+		return new Promise((resolve) => {
+			exec(process.platform === "win32" ? `where ${command}` : `command -v ${command}`, (error) => resolve(!error));
+		});
+	}
+};
+
+//#endregion
+//#region ../../src/system/providers/ShellProvider.ts
+/**
+* Abstract provider for executing shell commands and binaries.
+*
+* Implementations:
+* - `NodeShellProvider` - Real shell execution using Node.js child_process
+* - `MemoryShellProvider` - In-memory mock for testing
+*
+* @example
+* ```typescript
+* class MyService {
+*   protected readonly shell = $inject(ShellProvider);
+*
+*   async build() {
+*     // Run shell command directly
+*     await this.shell.run("yarn install");
+*
+*     // Run local binary with resolution
+*     await this.shell.run("vite build", { resolve: true });
+*
+*     // Capture output
+*     const output = await this.shell.run("echo hello", { capture: true });
+*   }
+* }
+* ```
+*/
+var ShellProvider = class {};
+
+//#endregion
+//#region ../../src/system/index.ts
+/**
+* | type | quality | stability |
+* |------|---------|-----------|
+* | tooling | standard | stable |
+*
+* System-level abstractions for portable code across runtimes.
+*
+* **Features:**
+* - File system operations (read, write, exists, etc.)
+* - Shell command execution
+* - File type detection and MIME utilities
+* - Memory implementations for testing
+*
+* @module alepha.system
+*/
+const AlephaSystem = $module({
+	name: "alepha.system",
+	primitives: [],
+	services: [
+		FileDetector,
+		FileSystemProvider,
+		MemoryFileSystemProvider,
+		NodeFileSystemProvider,
+		ShellProvider,
+		MemoryShellProvider,
+		NodeShellProvider
+	],
+	register: (alepha) => alepha.with({
+		optional: true,
+		provide: FileSystemProvider,
+		use: NodeFileSystemProvider
+	}).with({
+		optional: true,
+		provide: ShellProvider,
+		use: alepha.isTest() ? MemoryShellProvider : NodeShellProvider
+	})
+});
+
+//#endregion
 //#region ../../src/core/constants/KIND.ts
 /**
 * Used for identifying primitives.
@@ -79,7 +1915,7 @@ $atom$1[KIND] = "atom";
 * Options can be overridden via vite.config.ts or CLI flags.
 */
 const buildOptions = $atom$1({
-	name: "alepha.build.options",
+	name: "alepha.cli.build.options",
 	description: "Build configuration options",
 	schema: t.object({
 		stats: t.optional(t.boolean({ default: false })),
@@ -102,6 +1938,187 @@ const buildOptions = $atom$1({
 	default: {}
 });
 
+//#endregion
+//#region ../../src/cli/atoms/appEntryOptions.ts
+const appEntryOptions = $atom({
+	name: "alepha.cli.appEntry.options",
+	schema: t.object({
+		server: t.optional(t.text()),
+		browser: t.optional(t.text()),
+		style: t.optional(t.text())
+	}),
+	default: {}
+});
+
+//#endregion
+//#region ../../src/cli/providers/AppEntryProvider.ts
+/**
+* Service for locating entry files in Alepha projects.
+*
+* Originally in alepha/vite, moved to CLI to avoid cli -> vite dependency.
+*/
+var AppEntryProvider = class {
+	fs = $inject(FileSystemProvider);
+	options = $use(appEntryOptions);
+	serverEntries = [
+		"main.server.ts",
+		"main.server.tsx",
+		"main.ts",
+		"main.tsx"
+	];
+	browserEntries = [
+		"main.browser.ts",
+		"main.browser.tsx",
+		"main.ts",
+		"main.tsx"
+	];
+	styleEntries = [
+		"main.css",
+		"styles.css",
+		"style.css"
+	];
+	/**
+	* Get application entry points.
+	*
+	* Server entry is required, an error is thrown if not found.
+	* Browser entry is optional.
+	*
+	* It will first check for custom entries in options, see appEntryOptions.
+	*/
+	async getAppEntry(root) {
+		const appEntry = {
+			root,
+			server: ""
+		};
+		if (this.options.server) {
+			if (!await this.fs.exists(this.fs.join(root, this.options.server))) throw new AlephaError(`Custom server entry "${this.options.server}" not found.`);
+			appEntry.server = this.options.server;
+		}
+		if (this.options.browser) {
+			if (!await this.fs.exists(this.fs.join(root, this.options.browser))) throw new AlephaError(`Custom browser entry "${this.options.browser}" not found.`);
+			appEntry.browser = this.options.browser;
+		}
+		if (this.options.style) {
+			if (!await this.fs.exists(this.fs.join(root, this.options.style))) throw new AlephaError(`Custom style entry "${this.options.style}" not found.`);
+			appEntry.style = this.options.style;
+		}
+		const srcFiles = await this.fs.ls(this.fs.join(root, "src"));
+		if (!appEntry.server) {
+			for (const entry of this.serverEntries) if (srcFiles.includes(entry)) {
+				appEntry.server = this.fs.join("src", entry);
+				break;
+			}
+		}
+		if (!appEntry.server) throw new AlephaError("No server entry found. Please, add a main.server.ts file in the src/ directory or configure a custom entry in alepha.config.ts.");
+		if (!appEntry.browser) {
+			for (const entry of this.browserEntries) if (srcFiles.includes(entry)) {
+				appEntry.browser = this.fs.join("src", entry);
+				break;
+			}
+		}
+		if (!appEntry.style) {
+			for (const entry of this.styleEntries) if (srcFiles.includes(entry)) {
+				appEntry.style = this.fs.join("src", entry);
+				break;
+			}
+		}
+		return appEntry;
+	}
+};
+
+//#endregion
+//#region ../../src/cli/services/ViteUtils.ts
+var ViteUtils = class {
+	fs = $inject(FileSystemProvider);
+	viteDevServer;
+	generateIndexHtml(entry) {
+		const style = entry.style;
+		const browser = entry.browser ?? entry.server;
+		return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<title>App</title>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+${style ? `<link rel="stylesheet" href="/${style}" />` : ""}
+</head>
+<body>
+<div id="root"></div>
+<script type="module" src="/${browser}"><\/script>
+</body>
+</html>
+`.trim();
+	}
+	/**
+	* We need to close the Vite dev server after build is done.
+	*/
+	onReady = $hook({
+		on: "ready",
+		priority: "last",
+		handler: async () => {
+			await this.viteDevServer?.close();
+		}
+	});
+	onStop = $hook({
+		on: "stop",
+		handler: async () => {
+			await this.viteDevServer?.close();
+		}
+	});
+	async runAlepha(opts) {
+		const { createServer } = await importVite();
+		process.env.NODE_ENV = opts.mode;
+		process.env.ALEPHA_CLI_IMPORT = "true";
+		process.env.LOG_LEVEL ??= "warn";
+		/**
+		* 01/26 Vite 7
+		* "runnerImport" doesn't work as expected here. (e.g. build docs fail)
+		* -> We still use devServer and ssrLoadModule for now.
+		* -> This is clearly a bad stuff, we need to find better way.
+		*/
+		this.viteDevServer = await createServer({
+			server: { middlewareMode: true },
+			appType: "custom",
+			logLevel: "silent"
+		});
+		await this.viteDevServer.ssrLoadModule(opts.entry.server);
+		const alepha = globalThis.__alepha;
+		if (!alepha) throw new AlephaError("Alepha instance not found after loading entry module");
+		return alepha;
+	}
+};
+
+//#endregion
+//#region ../../src/cli/providers/ViteBuildProvider.ts
+var ViteBuildProvider = class {
+	alepha;
+	appEntry;
+	viteUtils = $inject(ViteUtils);
+	async init(opts) {
+		const alepha = await this.viteUtils.runAlepha({
+			entry: opts.entry,
+			mode: "production"
+		});
+		this.alepha = alepha;
+		this.appEntry = opts.entry;
+		return alepha;
+	}
+	hasClient() {
+		if (!this.alepha) throw new AlephaError("ViteBuildProvider not initialized");
+		try {
+			this.alepha.inject("ReactServerProvider");
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	generateIndexHtml() {
+		if (!this.appEntry) throw new AlephaError("ViteBuildProvider not initialized");
+		return this.viteUtils.generateIndexHtml(this.appEntry);
+	}
+};
+
 //#endregion
 //#region ../../src/cli/services/AlephaCliUtils.ts
 /**
@@ -117,36 +2134,24 @@ var AlephaCliUtils = class {
 	log = $logger();
 	fs = $inject(FileSystemProvider);
 	envUtils = $inject(EnvUtils);
+	boot = $inject(AppEntryProvider);
+	shell = $inject(ShellProvider);
+	viteUtils = $inject(ViteUtils);
 	/**
 	* Execute a command with inherited stdio.
+	*
+	* @param command - The command to execute
+	* @param options.root - Working directory
+	* @param options.env - Additional environment variables
+	* @param options.global - If true, run command directly without resolving from node_modules
 	*/
 	async exec(command, options = {}) {
-		const root = options.root ?? process.cwd();
-		this.log.debug(`Executing command: ${command}`, { cwd: root });
-		const runExec = async (app$1, args$1) => {
-			const prog = spawn(app$1, args$1, {
-				stdio: "inherit",
-				cwd: root,
-				env: {
-					...process.env,
-					...options.env
-				}
-			});
-			await new Promise((resolve) => prog.on("exit", () => {
-				resolve();
-			}));
-		};
-		if (options.global) {
-			const [app$1, ...args$1] = command.split(" ");
-			await runExec(app$1, args$1);
-			return;
-		}
-		const suffix = process.platform === "win32" ? ".cmd" : "";
-		const [app, ...args] = command.split(" ");
-		let execPath = await this.checkFileExists(root, `node_modules/.bin/${app}${suffix}`);
-		if (!execPath) execPath = await this.checkFileExists(root, `node_modules/alepha/node_modules/.bin/${app}${suffix}`);
-		if (!execPath) throw new AlephaError(`Could not find executable for command '${app}'. Make sure the package is installed.`);
-		await runExec(execPath, args);
+		await this.shell.run(command, {
+			root: options.root,
+			env: options.env,
+			resolve: !options.global,
+			capture: false
+		});
 	}
 	/**
 	* Write a configuration file to node_modules/.alepha directory.
@@ -159,25 +2164,14 @@ var AlephaCliUtils = class {
 		this.log.debug(`Config file written: ${path}`);
 		return path;
 	}
-	/**
-	* Load Alepha instance from a server entry file.
-	*/
-	async loadAlephaFromServerEntryFile(rootDir, explicitEntry) {
-		process.env.ALEPHA_CLI_IMPORT = "true";
-		const entry = await boot.getServerEntry(rootDir, explicitEntry);
-		delete global.__alepha;
-		const mod = await import(entry);
-		this.log.debug(`Load entry: ${entry}`);
-		if (mod.default instanceof Alepha) return {
-			alepha: mod.default,
-			entry
-		};
-		const g = global;
-		if (g.__alepha) return {
-			alepha: g.__alepha,
-			entry
-		};
-		throw new AlephaError(`Could not find Alepha instance in entry file: ${entry}`);
+	async loadAlephaFromServerEntryFile(opts) {
+		let entry;
+		if ("root" in opts) entry = await this.boot.getAppEntry(opts.root);
+		else entry = opts.entry;
+		return await this.viteUtils.runAlepha({
+			entry,
+			mode: opts.mode
+		});
 	}
 	/**
 	* Generate JavaScript code for Drizzle entities export.
@@ -205,12 +2199,39 @@ ${models.map((it) => `export const ${it} = models["${it}"];`).join("\n")}
 	async exists(root, path) {
 		return this.fs.exists(this.fs.join(root, path));
 	}
-	async checkFileExists(root, name) {
-		const configPath = this.fs.join(root, name);
-		if (await this.fs.exists(configPath)) return configPath;
+	/**
+	* Check if a command is installed and available in the system PATH.
+	*/
+	isInstalledAsync(cmd) {
+		return this.shell.isInstalled(cmd);
 	}
 };
 
+//#endregion
+//#region ../../package.json
+var devDependencies = {
+	"@biomejs/biome": "^2.3.13",
+	"@electric-sql/pglite": "^0.3.15",
+	"@faker-js/faker": "^10.2.0",
+	"@testing-library/dom": "^10.4.1",
+	"@testing-library/react": "^16.3.2",
+	"@types/node": "^25.1.0",
+	"@types/nodemailer": "^7.0.9",
+	"@types/react": "^19.2.10",
+	"@types/react-dom": "^19.2.3",
+	"@types/ws": "^8.18.1",
+	"cron-schedule": "^6.0.0",
+	"jose": "^6.1.3",
+	"jsdom": "^27.4.0",
+	"openid-client": "^6.8.1",
+	"prom-client": "^15.1.3",
+	"react": "^19.2.4",
+	"react-dom": "^19.2.4",
+	"swagger-ui-dist": "^5.31.0",
+	"tsdown": "^0.20.1",
+	"vitest": "^4.0.18"
+};
+
 //#endregion
 //#region ../../src/cli/version.ts
 const packageJson = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
@@ -234,11 +2255,8 @@ var PackageManagerUtils = class {
 	/**
 	* Detect the package manager used in the project.
 	*/
-	async getPackageManager(root, flags) {
-		if (flags?.yarn) return "yarn";
-		if (flags?.pnpm) return "pnpm";
-		if (flags?.npm) return "npm";
-		if (flags?.bun) return "bun";
+	async getPackageManager(root, pm) {
+		if (pm) return pm;
 		if (this.alepha.isBun()) return "bun";
 		if (await this.fs.exists(this.fs.join(root, "bun.lock"))) return "bun";
 		if (await this.fs.exists(this.fs.join(root, "yarn.lock"))) return "yarn";
@@ -246,6 +2264,46 @@ var PackageManagerUtils = class {
 		return "npm";
 	}
 	/**
+	* Detect workspace context when inside a monorepo package.
+	*
+	* Checks if we're inside a workspace package (e.g., packages/my-pkg or apps/my-app)
+	* by looking 2 levels up for workspace indicators like lockfiles and config files.
+	*
+	* @param root - The current package directory
+	* @returns Workspace context with root path, PM, and config presence
+	*/
+	async getWorkspaceContext(root) {
+		const workspaceRoot = this.fs.join(root, "..", "..");
+		const [hasYarnLock, hasPnpmLock, hasNpmLock, hasBunLock] = await Promise.all([
+			this.fs.exists(this.fs.join(workspaceRoot, "yarn.lock")),
+			this.fs.exists(this.fs.join(workspaceRoot, "pnpm-lock.yaml")),
+			this.fs.exists(this.fs.join(workspaceRoot, "package-lock.json")),
+			this.fs.exists(this.fs.join(workspaceRoot, "bun.lock"))
+		]);
+		const [hasBiome, hasEditorConfig, hasTsConfig, hasWorkspacePackageJson] = await Promise.all([
+			this.fs.exists(this.fs.join(workspaceRoot, "biome.json")),
+			this.fs.exists(this.fs.join(workspaceRoot, ".editorconfig")),
+			this.fs.exists(this.fs.join(workspaceRoot, "tsconfig.json")),
+			this.fs.exists(this.fs.join(workspaceRoot, "package.json"))
+		]);
+		const isPackage = (hasYarnLock || hasPnpmLock || hasNpmLock || hasBunLock) && hasWorkspacePackageJson;
+		let packageManager = null;
+		if (hasYarnLock) packageManager = "yarn";
+		else if (hasPnpmLock) packageManager = "pnpm";
+		else if (hasBunLock) packageManager = "bun";
+		else if (hasNpmLock) packageManager = "npm";
+		return {
+			isPackage,
+			workspaceRoot: isPackage ? workspaceRoot : null,
+			packageManager,
+			config: {
+				biomeJson: hasBiome,
+				editorconfig: hasEditorConfig,
+				tsconfigJson: hasTsConfig
+			}
+		};
+	}
+	/**
 	* Get the install command for a package.
 	*/
 	async getInstallCommand(root, packageName, dev = true) {
@@ -283,17 +2341,33 @@ var PackageManagerUtils = class {
 		return this.hasDependency(root, "expo");
 	}
 	/**
+	* Check if React is present in the project.
+	*/
+	async hasReact(root) {
+		return this.hasDependency(root, "react");
+	}
+	/**
 	* Install a dependency if it's missing from the project.
+	* Optionally checks workspace root for the dependency in monorepo setups.
 	*/
 	async ensureDependency(root, packageName, options = {}) {
-		const { dev = true } = options;
+		const { dev = true, checkWorkspace = false } = options;
 		if (await this.hasDependency(root, packageName)) {
 			this.log.debug(`Dependency '${packageName}' is already installed`);
 			return;
 		}
+		if (checkWorkspace) {
+			const workspace = await this.getWorkspaceContext(root);
+			if (workspace.workspaceRoot) {
+				if (await this.hasDependency(workspace.workspaceRoot, packageName)) {
+					this.log.debug(`Dependency '${packageName}' is already installed in workspace root`);
+					return;
+				}
+			}
+		}
 		const cmd = await this.getInstallCommand(root, packageName, dev);
 		if (options.run) await options.run(cmd, {
-			alias: `installing ${packageName}`,
+			alias: `add ${packageName}`,
 			root
 		});
 		else if (options.exec) {
@@ -368,21 +2442,26 @@ var PackageManagerUtils = class {
 			await this.writePackageJson(root, content);
 			return content;
 		}
-		const packageJson$1 = await this.readPackageJson(root);
+		const packageJson = await this.readPackageJson(root);
 		const newContent = this.generatePackageJsonContent(modes);
-		packageJson$1.type = "module";
-		packageJson$1.dependencies ??= {};
-		packageJson$1.devDependencies ??= {};
-		packageJson$1.scripts ??= {};
-		Object.assign(packageJson$1.dependencies, newContent.dependencies);
-		Object.assign(packageJson$1.devDependencies, newContent.devDependencies);
-		Object.assign(packageJson$1.scripts, newContent.scripts);
-		await this.writePackageJson(root, packageJson$1);
-		return packageJson$1;
+		packageJson.type = "module";
+		packageJson.dependencies ??= {};
+		packageJson.devDependencies ??= {};
+		packageJson.scripts ??= {};
+		Object.assign(packageJson.dependencies, newContent.dependencies);
+		Object.assign(packageJson.devDependencies, newContent.devDependencies);
+		Object.assign(packageJson.scripts, newContent.scripts);
+		await this.writePackageJson(root, packageJson);
+		return packageJson;
 	}
 	generatePackageJsonContent(modes) {
+		const alephaDeps = devDependencies;
 		const dependencies = { alepha: `^${version}` };
-		const devDependencies = {};
+		const devDependencies$1 = {};
+		if (!modes.isPackage) {
+			devDependencies$1["@biomejs/biome"] = alephaDeps["@biomejs/biome"];
+			if (modes.test) devDependencies$1.vitest = alephaDeps.vitest;
+		}
 		const scripts = {
 			dev: "alepha dev",
 			build: "alepha build",
@@ -390,20 +2469,20 @@ var PackageManagerUtils = class {
 			typecheck: "alepha typecheck",
 			verify: "alepha verify"
 		};
-		if (modes.admin) {
+		if (modes.test) scripts.test = "vitest run";
+		if (modes.ui) {
 			dependencies["@alepha/ui"] = `^${version}`;
-			modes.web = true;
+			modes.react = true;
 		}
-		if (modes.web) {
-			dependencies["@alepha/react"] = `^${version}`;
-			dependencies.react = "^19.2.0";
-			dependencies["react-dom"] = "^19.2.0";
-			devDependencies["@types/react"] = "^19.2.0";
+		if (modes.react) {
+			dependencies.react = alephaDeps.react;
+			dependencies["react-dom"] = alephaDeps["react-dom"];
+			devDependencies$1["@types/react"] = alephaDeps["@types/react"];
 		}
 		return {
 			type: "module",
 			dependencies,
-			devDependencies,
+			devDependencies: devDependencies$1,
 			scripts
 		};
 	}
@@ -416,87 +2495,20 @@ var PackageManagerUtils = class {
 };
 
 //#endregion
-//#region ../../src/cli/assets/apiHelloControllerTs.ts
-const apiHelloControllerTs = () => `
-import { t } from "alepha";
-import { $action } from "alepha/server";
-
-export class HelloController {
-  hello = $action({
-    path: "/hello",
-    schema: {
-      response: t.object({
-        message: t.string(),
-      }),
-    },
-    handler: () => ({
-      message: "Hello, Alepha!",
-    }),
-  });
-}
-`.trim();
-
-//#endregion
-//#region ../../src/cli/assets/apiIndexTs.ts
-const apiIndexTs = (options = {}) => {
-	const { appName = "app" } = options;
-	return `
-import { $module } from "alepha";
-import { HelloController } from "./controllers/HelloController.ts";
-
-export const ApiModule = $module({
-  name: "${appName}.api",
-  services: [HelloController],
-});
-`.trim();
-};
+//#region ../../src/cli/templates/agentMd.ts
+const agentMd = (type, options = {}) => {
+	const { react = false, projectName = "my-app" } = options;
+	const header = type === "claude" ? `# CLAUDE.md
 
-//#endregion
-//#region ../../src/cli/assets/biomeJson.ts
-const biomeJson = `
-{
-  "$schema": "https://biomejs.dev/schemas/latest/schema.json",
-  "vcs": {
-    "enabled": true,
-    "clientKind": "git"
-  },
-  "files": {
-    "ignoreUnknown": true,
-    "includes": ["**", "!node_modules", "!dist"]
-  },
-  "formatter": {
-    "enabled": true,
-    "useEditorconfig": true
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true
-    },
-    "domains": {
-      "react": "recommended"
-    }
-  },
-  "assist": {
-    "actions": {
-      "source": {
-        "organizeImports": "on"
-      }
-    }
-  }
-}
-`.trim();
+This file provides guidance to Claude Code when working with this Alepha project.` : `# AGENTS.md
 
-//#endregion
-//#region ../../src/cli/assets/claudeMd.ts
-const claudeMd = (options = {}) => {
-	const { react = false, projectName = "my-app" } = options;
+This file provides guidance to AI coding assistants when working with this Alepha project.`;
 	const reactSection = react ? `
 ## React & Frontend
 
 ### Pages with \`$page\`
 \`\`\`tsx
-import { $page } from "@alepha/react/router";
+import { $page } from "alepha/react/router";
 import { $client } from "alepha/server/links";
 import type { UserController } from "./UserController.ts";
 
@@ -522,9 +2534,9 @@ class AppRouter {
 
 ### React Hooks
 \`\`\`typescript
-import { useAlepha, useClient, useStore, useAction, useInject } from "@alepha/react";
-import { useRouter, useActive } from "@alepha/react/router";
-import { useForm } from "@alepha/react/form";
+import { useAlepha, useClient, useStore, useAction, useInject } from "alepha/react";
+import { useRouter, useActive } from "alepha/react/router";
+import { useForm } from "alepha/react/form";
 \`\`\`
 
 - \`useClient<Controller>()\` - Type-safe API calls
@@ -549,8 +2561,8 @@ ${projectName}/
 │   │   ├── AppRouter.ts  # Routes with $page
 │   │   └── index.ts      # Web module definition with $module
 │   ├── main.server.ts    # Server entry
-│   └── main.browser.ts   # Browser entry (React only)
-├── index.html            # (React only)
+│   ├── main.browser.ts   # Browser entry (React only)
+│   └── main.css          # CSS entry (React only)
 ├── package.json
 └── tsconfig.json
 \`\`\`
@@ -569,9 +2581,7 @@ ${projectName}/
 └── tsconfig.json
 \`\`\`
 `;
-	return `# CLAUDE.md
-
-This file provides guidance to Claude Code when working with this Alepha project.
+	return `${header}
 
 ## Overview
 
@@ -585,16 +2595,18 @@ This is an **Alepha** project - a convention-driven TypeScript framework for typ
 
 ## Rules
 
-- Use TypeScript strict mode
+- Use TypeScript strict mode, always check types (\`alepha typecheck\`)
 - Use Biome for formatting (\`alepha lint\`)
-- Use Vitest for testing
-- One file = one class
+- Use Vitest for testing (\`alepha test\`)
+- One file = one class, multiple interfaces/types allowed
 - Primitives are class properties (except \`$entity\`, \`$atom\`)
 - No decorators, no Express/Fastify patterns
 - No manual instantiation - use dependency injection
 - Use \`protected\` instead of \`private\` for class members
 - Import with file extensions: \`import { User } from "./User.ts"\`
 - Use \`t\` from Alepha for schemas (not Zod)
+- Prefer \`t.text()\` over \`t.string()\` for user input (has default max length, auto-trim, supports lowercase option)
+- One file = one schema (schemas/createUserSchema.ts)
 
 ## Project Structure
 ${projectStructure}
@@ -637,17 +2649,12 @@ export const userEntity = $entity({
     id: db.primaryKey(),
     email: t.email(),
     createdAt: db.createdAt(),
-    updatedAt: db.updatedAt(),
   }),
   indexes: [{ column: "email", unique: true }],
 });
 
 class UserService {
-  repo = $repository(userEntity);
-
-  async findById(id: string) {
-    return this.repo.findById(id);
-  }
+  userRepository = $repository(userEntity);
 }
 \`\`\`
 
@@ -657,11 +2664,6 @@ import { $inject } from "alepha";
 
 class OrderService {
   userService = $inject(UserService);  // Within same module
-
-  async createOrder(userId: string) {
-    const user = await this.userService.findById(userId);
-    // ...
-  }
 }
 
 // Cross-module: use $client instead of $inject
@@ -725,7 +2727,7 @@ ${reactSection}
 | \`$bucket\` | \`alepha/bucket\` | File storage |
 | \`$issuer\` | \`alepha/security\` | JWT tokens |
 | \`$command\` | \`alepha/command\` | CLI commands |${react ? `
-| \`$page\` | \`@alepha/react/router\` | React pages with SSR |
+| \`$page\` | \`alepha/react/router\` | React pages with SSR |
 | \`$atom\` | \`alepha\` | Global state |` : ""}
 
 ## Testing
@@ -773,15 +2775,92 @@ alepha test      # Run tests (if applicable)
 alepha build     # Build the project
 \`\`\`
 
-## Documentation
+## Documentation
+
+- Full docs: https://alepha.dev/llms.txt
+- Detailed docs: https://alepha.dev/llms-full.txt
+
+## Source Code Access
+
+Full framework source available at \`node_modules/alepha/src/\`.
+Read primitives directly when you need implementation details.
+`.trim();
+};
+
+//#endregion
+//#region ../../src/cli/templates/apiHelloControllerTs.ts
+const apiHelloControllerTs = () => `
+import { t } from "alepha";
+import { $action } from "alepha/server";
+
+export class HelloController {
+  hello = $action({
+    path: "/hello",
+    schema: {
+      response: t.object({
+        message: t.string(),
+      }),
+    },
+    handler: () => ({
+      message: "Hello, Alepha!",
+    }),
+  });
+}
+`.trim();
+
+//#endregion
+//#region ../../src/cli/templates/apiIndexTs.ts
+const apiIndexTs = (options = {}) => {
+	const { appName = "app" } = options;
+	return `
+import { $module } from "alepha";
+import { HelloController } from "./controllers/HelloController.ts";
 
-- Full docs: https://alepha.dev/llms.txt
-- Detailed docs: https://alepha.dev/llms-full.txt
+export const ApiModule = $module({
+  name: "${appName}.api",
+  services: [HelloController],
+});
 `.trim();
 };
 
 //#endregion
-//#region ../../src/cli/assets/dummySpecTs.ts
+//#region ../../src/cli/templates/biomeJson.ts
+const biomeJson = () => `
+{
+  "$schema": "https://biomejs.dev/schemas/latest/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git"
+  },
+  "files": {
+    "ignoreUnknown": true,
+    "includes": ["**", "!node_modules", "!dist"]
+  },
+  "formatter": {
+    "enabled": true,
+    "useEditorconfig": true
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    },
+    "domains": {
+      "react": "recommended"
+    }
+  },
+  "assist": {
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  }
+}
+`.trim();
+
+//#endregion
+//#region ../../src/cli/templates/dummySpecTs.ts
 const dummySpecTs = () => `
 import { test, expect } from "vitest";
 
@@ -791,8 +2870,8 @@ test("dummy test", () => {
 `.trim();
 
 //#endregion
-//#region ../../src/cli/assets/editorconfig.ts
-const editorconfig = `
+//#region ../../src/cli/templates/editorconfig.ts
+const editorconfig = () => `
 # https://editorconfig.org
 
 root = true
@@ -807,23 +2886,48 @@ indent_size = 2
 `.trim();
 
 //#endregion
-//#region ../../src/cli/assets/indexHtml.ts
-const indexHtml = (browserEntry) => `
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title>App</title>
-</head>
-<body>
-<div id="root"></div>
-<script type="module" src="${browserEntry}"><\/script>
-</body>
-</html>
+//#region ../../src/cli/templates/gitignore.ts
+const gitignore = () => `
+# Dependencies
+node_modules/
+
+# Build outputs
+dist/
+.vite/
+
+# Environment files
+.env
+.env.*
+!.env.example
+
+# IDE
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Test coverage
+coverage/
+
+# Yarn
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+.pnp.*
 `.trim();
 
 //#endregion
-//#region ../../src/cli/assets/mainBrowserTs.ts
+//#region ../../src/cli/templates/mainBrowserTs.ts
 const mainBrowserTs = () => `
 import { Alepha, run } from "alepha";
 import { WebModule } from "./web/index.ts";
@@ -836,58 +2940,115 @@ run(alepha);
 `.trim();
 
 //#endregion
-//#region ../../src/cli/assets/mainServerTs.ts
+//#region ../../src/cli/templates/mainCss.ts
+const mainCss = (options = {}) => {
+	if (options.ui) return `@import "@alepha/ui/styles";`;
+	return `
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+html,
+body {
+  height: 100%;
+}
+
+body {
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto,
+    "Helvetica Neue", Arial, sans-serif;
+  line-height: 1.5;
+  -webkit-font-smoothing: antialiased;
+}
+
+#root {
+  height: 100%;
+}
+`.trim();
+};
+
+//#endregion
+//#region ../../src/cli/templates/mainServerTs.ts
 const mainServerTs = (options = {}) => {
-	const { react = false } = options;
+	const { api = false, react = false } = options;
+	const imports = [];
+	const withs = [];
+	if (api) {
+		imports.push(`import { ApiModule } from "./api/index.ts";`);
+		withs.push(`alepha.with(ApiModule);`);
+	}
+	if (react) {
+		imports.push(`import { WebModule } from "./web/index.ts";`);
+		withs.push(`alepha.with(WebModule);`);
+	}
 	return `
 import { Alepha, run } from "alepha";
-import { ApiModule } from "./api/index.ts";
-${react ? `import { WebModule } from "./web/index.ts";\n` : ""}
+${imports.length > 0 ? `${imports.join("\n")}\n` : ""}
 const alepha = Alepha.create();
+${withs.length > 0 ? `\n${withs.join("\n")}` : ""}
 
-alepha.with(ApiModule);
-${react ? `alepha.with(WebModule);\n` : ""}
 run(alepha);
 `.trim();
 };
 
 //#endregion
-//#region ../../src/cli/assets/tsconfigJson.ts
-const tsconfigJson = `
+//#region ../../src/cli/templates/tsconfigJson.ts
+const tsconfigJson = () => `
 {
   "extends": "alepha/tsconfig.base"
 }
 `.trim();
 
 //#endregion
-//#region ../../src/cli/assets/webAppRouterTs.ts
-const webAppRouterTs = () => `
-import { $page } from "@alepha/react/router";
-import { $client } from "alepha/server/links";
-import type { HelloController } from "../api/controllers/HelloController.ts";
-
-export class AppRouter {
-  api = $client<HelloController>();
-
-  home = $page({
+//#region ../../src/cli/templates/webAppRouterTs.ts
+const webAppRouterTs = (options) => {
+	const imports = [];
+	const classMembers = [];
+	if (options.ui) imports.push("import { $ui } from \"@alepha/ui\";");
+	imports.push("import { $page } from \"alepha/react/router\";");
+	if (options.api) {
+		imports.push("import { $client } from \"alepha/server/links\";");
+		imports.push("import type { HelloController } from \"../api/controllers/HelloController.ts\";");
+		classMembers.push("  api = $client<HelloController>();");
+	}
+	if (options.ui) {
+		classMembers.push("  ui = $ui();");
+		classMembers.push(`  layout = $page({
+    parent: this.ui.root,
+    children: () => [this.home],
+  });`);
+	}
+	if (options.api) classMembers.push(`  home = $page({
     path: "/",
     lazy: () => import("./components/Hello.tsx"),
     loader: () => this.api.hello(),
-  });
-}
-`.trim();
+  });`);
+	else classMembers.push(`  home = $page({
+    path: "/",
+    lazy: () => import("./components/Hello.tsx"),
+  });`);
+	return `${imports.join("\n")}
+
+export class AppRouter {
+${classMembers.join("\n\n")}
+}`;
+};
 
 //#endregion
-//#region ../../src/cli/assets/webHelloComponentTsx.ts
-const webHelloComponentTsx = () => `
+//#region ../../src/cli/templates/webHelloComponentTsx.ts
+const webHelloComponentTsx = () => `import { useState } from "react";
+
 interface Props {
-  message: string;
+  message?: string;
 }
 
 const Hello = (props: Props) => {
+  const [message, setMessage] = useState(props.message ?? "");
   return (
     <div>
-      <h1>{props.message}</h1>
+      <h1>{message}</h1>
+      <input value={message} onChange={e => setMessage(e.target.value)} />
       <p>Edit this component in src/web/components/Hello.tsx</p>
     </div>
   );
@@ -897,7 +3058,7 @@ export default Hello;
 `.trim();
 
 //#endregion
-//#region ../../src/cli/assets/webIndexTs.ts
+//#region ../../src/cli/templates/webIndexTs.ts
 const webIndexTs = (options = {}) => {
 	const { appName = "app" } = options;
 	return `
@@ -926,6 +3087,7 @@ var ProjectScaffolder = class {
 	log = $logger();
 	fs = $inject(FileSystemProvider);
 	pm = $inject(PackageManagerUtils);
+	utils = $inject(AlephaCliUtils);
 	/**
 	* Get the app name from the directory name.
 	*
@@ -942,69 +3104,99 @@ var ProjectScaffolder = class {
 	*/
 	async ensureConfig(root, opts) {
 		const tasks = [];
+		const force = opts.force ?? false;
+		const checkWorkspace = opts.checkWorkspace ?? false;
 		if (opts.packageJson) tasks.push(this.pm.ensurePackageJson(root, typeof opts.packageJson === "boolean" ? {} : opts.packageJson).then(() => {}));
-		if (opts.tsconfigJson) tasks.push(this.ensureTsConfig(root));
-		if (opts.indexHtml) tasks.push(this.ensureReactProject(root));
-		if (opts.biomeJson) tasks.push(this.ensureBiomeConfig(root));
-		if (opts.editorconfig) tasks.push(this.ensureEditorConfig(root));
-		if (opts.claudeMd) tasks.push(this.ensureClaudeMd(root, typeof opts.claudeMd === "boolean" ? {} : opts.claudeMd));
+		if (opts.tsconfigJson) tasks.push(this.ensureTsConfig(root, { force }));
+		if (opts.biomeJson) tasks.push(this.ensureBiomeConfig(root, {
+			force,
+			checkWorkspace
+		}));
+		if (opts.editorconfig) tasks.push(this.ensureEditorConfig(root, {
+			force,
+			checkWorkspace
+		}));
+		if (opts.agentMd) tasks.push(this.ensureAgentMd(root, {
+			...opts.agentMd,
+			force
+		}));
 		await Promise.all(tasks);
 	}
-	async ensureTsConfig(root) {
-		if (await this.existsInParents(root, "tsconfig.json")) return;
-		await this.fs.writeFile(this.fs.join(root, "tsconfig.json"), tsconfigJson);
+	async ensureTsConfig(root, opts = {}) {
+		if (!opts.force && await this.existsInParents(root, "tsconfig.json")) return;
+		await this.fs.writeFile(this.fs.join(root, "tsconfig.json"), tsconfigJson());
+	}
+	async ensureBiomeConfig(root, opts = {}) {
+		if (!opts.force && opts.checkWorkspace && await this.existsInParents(root, "biome.json")) return;
+		await this.ensureFile(root, "biome.json", biomeJson(), opts.force);
 	}
-	async ensureBiomeConfig(root) {
-		await this.ensureFileIfNotExists(root, "biome.json", biomeJson);
+	async ensureEditorConfig(root, opts = {}) {
+		if (!opts.force && opts.checkWorkspace && await this.existsInParents(root, ".editorconfig")) return;
+		await this.ensureFile(root, ".editorconfig", editorconfig(), opts.force);
+	}
+	/**
+	* Ensure git repository is initialized with .gitignore.
+	*
+	* @returns true if git was initialized, false if already exists or git unavailable
+	*/
+	async ensureGitRepo(root, opts = {}) {
+		const gitDir = this.fs.join(root, ".git");
+		if (!opts.force && await this.fs.exists(gitDir)) return false;
+		if (!await this.utils.isInstalledAsync("git")) return false;
+		await this.utils.exec("git init", {
+			root,
+			global: true
+		});
+		await this.ensureFile(root, ".gitignore", gitignore(), opts.force);
+		return true;
 	}
-	async ensureEditorConfig(root) {
-		await this.ensureFileIfNotExists(root, ".editorconfig", editorconfig);
+	async ensureAgentMd(root, options) {
+		const filename = options.type === "claude" ? "CLAUDE.md" : "AGENTS.md";
+		await this.ensureFile(root, filename, agentMd(options.type, options), options.force);
 	}
-	async ensureClaudeMd(root, options = {}) {
-		const path = this.fs.join(root, "CLAUDE.md");
-		if (!await this.fs.exists(path)) await this.fs.writeFile(path, claudeMd(options));
+	/**
+	* Ensure src/main.server.ts exists with correct module imports.
+	*/
+	async ensureMainServerTs(root, opts = {}) {
+		const srcDir = this.fs.join(root, "src");
+		await this.fs.mkdir(srcDir, { recursive: true });
+		await this.ensureFile(srcDir, "main.server.ts", mainServerTs({
+			api: opts.api,
+			react: opts.react
+		}), opts.force);
 	}
 	/**
-	* Ensure src/main.server.ts exists with full API structure.
+	* Ensure API module structure exists.
 	*
 	* Creates:
-	* - src/main.server.ts (entry point)
 	* - src/api/index.ts (API module)
 	* - src/api/controllers/HelloController.ts (example controller)
 	*/
-	async ensureApiProject(root) {
-		const srcDir = this.fs.join(root, "src");
-		if (await this.fs.exists(srcDir)) {
-			if ((await this.fs.ls(srcDir)).length > 0) return;
-		}
+	async ensureApiProject(root, opts = {}) {
 		const appName = this.getAppName(root);
 		await this.fs.mkdir(this.fs.join(root, "src/api/controllers"), { recursive: true });
-		await this.fs.writeFile(this.fs.join(srcDir, "main.server.ts"), mainServerTs());
-		await this.fs.writeFile(this.fs.join(srcDir, "api/index.ts"), apiIndexTs({ appName }));
-		await this.fs.writeFile(this.fs.join(srcDir, "api/controllers/HelloController.ts"), apiHelloControllerTs());
+		await this.ensureFile(root, "src/api/index.ts", apiIndexTs({ appName }), opts.force);
+		await this.ensureFile(root, "src/api/controllers/HelloController.ts", apiHelloControllerTs(), opts.force);
 	}
 	/**
-	* Ensure full React project structure exists.
+	* Ensure web/React project structure exists.
 	*
 	* Creates:
-	* - index.html
-	* - src/main.server.ts, src/main.browser.ts
-	* - src/api/index.ts, src/api/controllers/HelloController.ts
+	* - src/main.browser.ts
+	* - src/main.css
 	* - src/web/index.ts, src/web/AppRouter.ts, src/web/components/Hello.tsx
 	*/
-	async ensureReactProject(root) {
-		if (await this.fs.exists(this.fs.join(root, "index.html"))) return;
+	async ensureWebProject(root, opts = {}) {
 		const appName = this.getAppName(root);
-		await this.fs.mkdir(this.fs.join(root, "src/api/controllers"), { recursive: true });
 		await this.fs.mkdir(this.fs.join(root, "src/web/components"), { recursive: true });
-		await this.fs.writeFile(this.fs.join(root, "index.html"), indexHtml("src/main.browser.ts"));
-		await this.ensureFileIfNotExists(root, "src/api/index.ts", apiIndexTs({ appName }));
-		await this.ensureFileIfNotExists(root, "src/api/controllers/HelloController.ts", apiHelloControllerTs());
-		await this.ensureFileIfNotExists(root, "src/main.server.ts", mainServerTs({ react: true }));
-		await this.ensureFileIfNotExists(root, "src/web/index.ts", webIndexTs({ appName }));
-		await this.ensureFileIfNotExists(root, "src/web/AppRouter.ts", webAppRouterTs());
-		await this.ensureFileIfNotExists(root, "src/web/components/Hello.tsx", webHelloComponentTsx());
-		await this.ensureFileIfNotExists(root, "src/main.browser.ts", mainBrowserTs());
+		await this.ensureFile(root, "src/main.css", mainCss({ ui: opts.ui }), opts.force);
+		await this.ensureFile(root, "src/web/index.ts", webIndexTs({ appName }), opts.force);
+		await this.ensureFile(root, "src/web/AppRouter.ts", webAppRouterTs({
+			api: opts.api,
+			ui: opts.ui
+		}), opts.force);
+		await this.ensureFile(root, "src/web/components/Hello.tsx", webHelloComponentTsx(), opts.force);
+		await this.ensureFile(root, "src/main.browser.ts", mainBrowserTs(), opts.force);
 	}
 	/**
 	* Ensure test directory exists with a dummy test file.
@@ -1019,9 +3211,12 @@ var ProjectScaffolder = class {
 		}
 		if ((await this.fs.ls(testDir)).length === 0) await this.fs.writeFile(dummyPath, dummySpecTs());
 	}
-	async ensureFileIfNotExists(root, relativePath, content) {
+	/**
+	* Write a file, optionally overriding if it exists.
+	*/
+	async ensureFile(root, relativePath, content, force) {
 		const fullPath = this.fs.join(root, relativePath);
-		if (!await this.fs.exists(fullPath)) await this.fs.writeFile(fullPath, content);
+		if (force || !await this.fs.exists(fullPath)) await this.fs.writeFile(fullPath, content);
 	}
 	/**
 	* Check if a file exists in the given directory or any parent directory.
@@ -1045,15 +3240,13 @@ var BuildCommand = class {
 	utils = $inject(AlephaCliUtils);
 	pm = $inject(PackageManagerUtils);
 	scaffolder = $inject(ProjectScaffolder);
+	boot = $inject(AppEntryProvider);
+	viteBuildProvider = $inject(ViteBuildProvider);
 	options = $use(buildOptions);
 	build = $command({
 		name: "build",
 		mode: "production",
 		description: "Build the project for production",
-		args: t.optional(t.text({
-			title: "path",
-			description: "Filepath to build"
-		})),
 		flags: t.object({
 			stats: t.optional(t.boolean({ description: "Generate build stats report" })),
 			vercel: t.optional(t.boolean({ description: "Generate Vercel deployment configuration" })),
@@ -1062,53 +3255,70 @@ var BuildCommand = class {
 			sitemap: t.optional(t.text({ description: "Generate sitemap.xml with base URL" })),
 			bun: t.optional(t.boolean({ description: "Prioritize .bun.ts entry files for Bun runtime" }))
 		}),
-		handler: async ({ flags, args, run, root }) => {
-			process.env.ALEPHA_BUILD_MODE = "cli";
+		handler: async ({ flags, run, root }) => {
 			process.env.NODE_ENV = "production";
 			if (await this.pm.hasExpo(root)) return;
 			await this.scaffolder.ensureConfig(root, { tsconfigJson: true });
-			const entry = await boot.getServerEntry(root, args);
+			const entry = await this.boot.getAppEntry(root);
 			this.log.trace("Entry file found", { entry });
 			const distDir = "dist";
-			const clientDir = "public";
-			await this.pm.ensureDependency(root, "vite", {
-				run,
-				exec: (cmd, opts) => this.utils.exec(cmd, opts)
-			});
+			const publicDir = "public";
 			await run.rm("dist", { alias: "clean dist" });
 			const options = this.options;
 			await this.utils.loadEnv(root, [".env", ".env.production"]);
 			const stats = flags.stats ?? options.stats ?? false;
-			const hasClient = await this.fs.exists(this.fs.join(root, "index.html"));
-			if (hasClient) await run({
-				name: "vite build client",
-				handler: () => buildClient({
-					silent: true,
-					dist: `${distDir}/${clientDir}`,
-					stats,
-					precompress: true
-				})
+			let template = "";
+			let hasClient = false;
+			let alepha;
+			await run({
+				name: "analyze app",
+				handler: async () => {
+					alepha = await this.viteBuildProvider.init({ entry });
+					hasClient = this.viteBuildProvider.hasClient();
+					if (hasClient) template = this.viteBuildProvider.generateIndexHtml();
+				}
 			});
+			if (!alepha) throw new AlephaError("Alepha instance not found");
+			if (hasClient) {
+				const indexHtmlPath = this.fs.join(root, "index.html");
+				await this.fs.writeFile(indexHtmlPath, template);
+				try {
+					await run({
+						name: "vite build client",
+						handler: () => buildClient({
+							silent: true,
+							dist: `${distDir}/${publicDir}`,
+							stats,
+							precompress: true
+						})
+					});
+				} finally {
+					await this.fs.rm(indexHtmlPath);
+				}
+			}
 			await run({
 				name: "vite build server",
 				handler: async () => {
-					const clientIndexPath = `${distDir}/${clientDir}/index.html`;
+					if (!alepha) throw new AlephaError("Alepha instance not found");
+					const clientIndexPath = `${distDir}/${publicDir}/index.html`;
 					const clientBuilt = await this.fs.exists(clientIndexPath);
 					const conditions = [];
 					if (flags.bun) conditions.push("bun");
 					if (options.cloudflare) conditions.push("workerd");
 					await buildServer({
 						silent: true,
-						entry,
+						entry: entry.server,
 						distDir,
-						clientDir: clientBuilt ? clientDir : void 0,
+						clientDir: clientBuilt ? publicDir : void 0,
 						stats,
-						conditions
+						conditions,
+						alepha
 					});
 					if (clientBuilt) await this.fs.rm(clientIndexPath);
 				}
 			});
 			await copyAssets({
+				alepha,
 				root,
 				entry: `${distDir}/index.js`,
 				distDir,
@@ -1116,31 +3326,24 @@ var BuildCommand = class {
 			});
 			if (hasClient) {
 				const sitemapHostname = flags.sitemap ?? options.sitemap?.hostname;
-				if (sitemapHostname) await run({
-					name: "add sitemap",
-					handler: async () => {
-						await this.fs.writeFile(`${distDir}/${clientDir}/sitemap.xml`, await generateSitemap({
-							entry: `${distDir}/index.js`,
-							baseUrl: sitemapHostname
-						}));
-					}
+				if (sitemapHostname) await generateSitemap({
+					alepha,
+					baseUrl: sitemapHostname,
+					output: `${distDir}/${publicDir}/sitemap.xml`,
+					run
 				});
-				await run({
-					name: "pre-render pages",
-					handler: async () => {
-						await prerenderPages({
-							dist: `${distDir}/${clientDir}`,
-							entry: `${distDir}/index.js`,
-							compress: true
-						});
-					}
+				await prerenderPages({
+					alepha,
+					dist: `${distDir}/${publicDir}`,
+					compress: true,
+					run
 				});
 			}
 			if (flags.vercel || options.vercel) await run({
 				name: "add Vercel config",
 				handler: () => generateVercel({
 					distDir,
-					clientDir,
+					clientDir: publicDir,
 					config: options.vercel
 				})
 			});
@@ -1187,6 +3390,7 @@ var DbCommand = class {
 	log = $logger();
 	fs = $inject(FileSystemProvider);
 	utils = $inject(AlephaCliUtils);
+	entryProvider = $inject(AppEntryProvider);
 	/**
 	* Check if database migrations are up to date.
 	*/
@@ -1201,7 +3405,11 @@ var DbCommand = class {
 		handler: async ({ args, root }) => {
 			const rootDir = root;
 			this.log.debug(`Using project root: ${rootDir}`);
-			const { alepha } = await this.utils.loadAlephaFromServerEntryFile(rootDir, args);
+			const entry = await this.entryProvider.getAppEntry(root);
+			const alepha = await this.utils.loadAlephaFromServerEntryFile({
+				mode: "development",
+				entry
+			});
 			const repositoryProvider = alepha.inject("RepositoryProvider");
 			const drizzleKitProvider = alepha.inject("DrizzleKitProvider");
 			const accepted = /* @__PURE__ */ new Set([]);
@@ -1365,7 +3573,11 @@ var DbCommand = class {
 		if (options.env) envFiles.push(`.env.${options.env}`);
 		await this.utils.loadEnv(rootDir, envFiles);
 		this.log.debug(`Using project root: ${rootDir}`);
-		const { alepha, entry } = await this.utils.loadAlephaFromServerEntryFile(rootDir, options.args);
+		const entry = await this.entryProvider.getAppEntry(rootDir);
+		const alepha = await this.utils.loadAlephaFromServerEntryFile({
+			mode: "development",
+			entry
+		});
 		const drizzleKitProvider = alepha.inject("DrizzleKitProvider");
 		const repositoryProvider = alepha.inject("RepositoryProvider");
 		const accepted = /* @__PURE__ */ new Set([]);
@@ -1389,11 +3601,11 @@ var DbCommand = class {
 				providerUrl: provider.url,
 				providerDriver: provider.driver,
 				dialect,
-				entry,
+				entry: this.fs.join(rootDir, entry.server),
 				rootDir
 			});
 			const flags = options.commandFlags ? ` ${options.commandFlags}` : "";
-			await this.utils.exec(`drizzle-kit ${options.command} --config=${drizzleConfigJsPath}${flags}`, { env: { NODE_OPTIONS: "--import tsx" } });
+			await this.utils.exec(`drizzle-kit ${options.command} --config=${drizzleConfigJsPath}${flags}`, { env: { NODE_OPTIONS: [process.env.NODE_OPTIONS, "--import tsx"].filter(Boolean).join(" ") } });
 		}
 	}
 	/**
@@ -1529,70 +3741,275 @@ var DeployCommand = class {
 };
 
 //#endregion
-//#region ../../src/cli/commands/dev.ts
-var DevCommand = class {
+//#region ../../src/cli/providers/ViteDevServerProvider.ts
+/**
+* Vite development server with Alepha integration.
+*
+* Architecture:
+* - Vite runs in middleware mode (no HTTP server)
+* - Alepha is the HTTP server via server:onRequest event
+* - Request flow: Page requests → Alepha SSR, Assets → Vite middleware
+*
+* HMR Strategy:
+* - Browser-only changes (CSS, client components) → Vite HMR (React Fast Refresh)
+* - Server-only changes → Restart Alepha → Full browser reload
+* - Shared changes → Restart Alepha → Let Vite HMR propagate
+*
+* Features:
+* - Automatic .env reload detection
+* - Error recovery on next file change
+* - Optimized module invalidation (only changed files + importers)
+*/
+var ViteDevServerProvider = class {
 	log = $logger();
 	fs = $inject(FileSystemProvider);
-	utils = $inject(AlephaCliUtils);
-	pm = $inject(PackageManagerUtils);
-	scaffolder = $inject(ProjectScaffolder);
-	alepha = $inject(Alepha);
+	templateProvider = $inject(ViteUtils);
+	server;
+	options;
+	alepha = null;
+	hasError = false;
+	changedFiles = /* @__PURE__ */ new Set();
+	async init(options) {
+		this.options = options;
+		await this.createViteServer();
+		return await this.loadAlepha(true);
+	}
+	async start() {
+		await this.alepha?.start();
+	}
 	/**
-	* Will run the project in watch mode.
-	*
-	* - If an index.html file is found in the project root, it will run Vite in dev mode.
-	* - Otherwise, it will look for a server entry file and run it with tsx in watch mode.
+	* Create the Vite server in middleware mode.
 	*/
-	dev = $command({
-		name: "dev",
-		description: "Run the project in development mode",
-		args: t.optional(t.text({
-			title: "path",
-			description: "Filepath to run"
-		})),
-		handler: async ({ args, root }) => {
-			const expo = await this.pm.hasExpo(root);
-			await this.scaffolder.ensureConfig(root, { tsconfigJson: true });
-			if (expo) {
-				await this.utils.exec("expo start");
-				return;
+	async createViteServer() {
+		const { createServer } = await importVite();
+		const viteReact = await importViteReact();
+		const plugins = [];
+		if (viteReact) plugins.push(viteReact());
+		plugins.push(viteAlephaSsrPreload());
+		plugins.push(this.createHmrPlugin());
+		this.server = await createServer({
+			root: this.options.root,
+			plugins,
+			server: { middlewareMode: true },
+			appType: "custom",
+			customLogger: {
+				info: () => {},
+				warn: this.log.warn.bind(this.log),
+				error: this.log.error.bind(this.log),
+				warnOnce: this.log.warn.bind(this.log),
+				clearScreen: () => {},
+				hasWarned: false,
+				hasErrorLogged: () => false
 			}
-			const entry = await boot.getServerEntry(root, args);
-			this.log.trace("Entry file found", { entry });
-			if (!await this.isFullstackProject(root)) {
-				const exe = await this.isBunProject(root) ? "bun" : "tsx";
-				let cmd = `${exe} --watch`;
-				if (await this.utils.exists(root, ".env")) cmd += " --env-file=./.env";
-				cmd += ` ${entry}`;
-				await this.utils.exec(cmd, { global: exe === "bun" });
-				return;
+		});
+		this.server.restart = async () => {
+			const startTime = Date.now();
+			try {
+				this.hasError = true;
+				await this.loadAlepha(false);
+				await this.alepha?.start();
+				this.log.debug(`Env reloaded in ${Date.now() - startTime}ms`);
+				this.sendBrowserReload();
+			} catch (err) {
+				this.hasError = true;
+				this.log.error("Reload failed", err);
+				this.log.warn("Waiting for file changes to retry...");
+				this.alepha = null;
+			}
+		};
+	}
+	/**
+	* Vite plugin to handle HMR for Alepha.
+	*/
+	createHmrPlugin() {
+		return {
+			name: "alepha-hmr",
+			handleHotUpdate: async (ctx) => {
+				if (ctx.file.includes("/.idea/")) return [];
+				const firstModule = ctx.modules[0];
+				const isBrowserOnly = firstModule && !firstModule._ssrModule;
+				const isServerOnly = firstModule && !firstModule._clientModule;
+				if (isBrowserOnly) return;
+				const startTime = Date.now();
+				try {
+					this.changedFiles.add(ctx.file);
+					await this.loadAlepha(false);
+					await this.alepha?.start();
+					this.log.debug(`Reloaded in ${Date.now() - startTime}ms`);
+					if (isServerOnly) {
+						this.sendBrowserReload();
+						return [];
+					}
+					return;
+				} catch (err) {
+					this.hasError = true;
+					this.log.error("Reload failed", err);
+					this.log.warn("Waiting for file changes to retry...");
+					this.alepha = null;
+					return [];
+				}
 			}
-			await this.pm.ensureDependency(root, "vite", { exec: (cmd, opts) => this.utils.exec(cmd, opts) });
-			await devServer();
+		};
+	}
+	/**
+	* Send browser reload signal via custom event.
+	* Browser listens for 'alepha:reload' and does window.location.reload()
+	*/
+	sendBrowserReload() {
+		this.server.ws.send({
+			type: "custom",
+			event: "alepha:reload",
+			data: {}
+		});
+	}
+	/**
+	* Setup environment variables for dev mode.
+	*/
+	async setupEnvironment() {
+		const { loadEnv } = await importVite();
+		const env = loadEnv(process.env.NODE_ENV || "development", this.options.root, "");
+		for (const [key, value] of Object.entries(env)) process.env[key] ??= value;
+		process.env.NODE_ENV ??= "development";
+		process.env.VITE_ALEPHA_DEV = "true";
+		process.env.SERVER_HOST ??= this.options.host?.toString() ?? "localhost";
+		process.env.SERVER_PORT ??= String(this.options.port ?? (process.env.SERVER_PORT ? Number(process.env.SERVER_PORT) : 3e3));
+	}
+	/**
+	* Load or reload the Alepha instance.
+	*/
+	async loadAlepha(isInitialLoad = false) {
+		if (this.alepha) {
+			await this.alepha.stop().catch((err) => this.log.warn("Error stopping Alepha", err));
+			this.alepha = null;
+		}
+		if (isInitialLoad || this.hasError) this.server.moduleGraph.invalidateAll();
+		else this.invalidateModulesWithImporters();
+		this.changedFiles.clear();
+		const envSnapshot = { ...process.env };
+		await this.setupEnvironment();
+		await this.server.ssrLoadModule(this.options.entry.server);
+		const alepha = globalThis.__alepha;
+		if (!alepha) throw new AlephaError("Alepha instance not found after loading entry module");
+		this.alepha = alepha;
+		await this.setupAlepha();
+		this.hasError = false;
+		process.env = envSnapshot;
+		return alepha;
+	}
+	hasReact() {
+		try {
+			this.alepha?.inject("ReactServerProvider");
+			return true;
+		} catch {
+			return false;
 		}
-	});
-	async isBunProject(root) {
-		if (this.alepha.isBun()) return true;
-		return this.fs.exists(this.fs.join(root, "bun.lock"));
 	}
-	async isFullstackProject(root) {
-		return this.fs.exists(this.fs.join(root, "index.html"));
+	/**
+	* Setup Alepha instance with Vite middleware and template.
+	*/
+	async setupAlepha() {
+		if (!this.alepha || !this.hasReact()) return;
+		const template = await this.server.transformIndexHtml("/", this.templateProvider.generateIndexHtml(this.options.entry));
+		this.alepha.store.set("alepha.react.server.template", template);
+		this.alepha.events.on("server:onRequest", {
+			priority: "first",
+			callback: async ({ request }) => {
+				const node = request.raw.node;
+				if (!node || this.isPageRequest(node.req)) return;
+				if (await this.runViteMiddleware(node.req, node.res, request)) {
+					request.reply.status = node.res.statusCode || 200;
+					request.reply.body = null;
+				}
+			}
+		});
+	}
+	/**
+	* Check if request is for an HTML page (not an asset).
+	*/
+	isPageRequest(req) {
+		const url = req.url || "/";
+		if (url === "/" || url === "/index.html") return true;
+		if (url.startsWith("/@") || url.startsWith("/__vite")) return false;
+		if (/\.\w+$/.test(url.split("?")[0])) return false;
+		return true;
+	}
+	/**
+	* Run Vite middleware and detect if it handled the request.
+	*/
+	async runViteMiddleware(req, res, ctx) {
+		if (res.headersSent || res.writableEnded) return false;
+		return new Promise((resolve) => {
+			let resolved = false;
+			const done = (handled) => {
+				if (resolved) return;
+				resolved = true;
+				if (handled) ctx.metadata.vite = true;
+				resolve(handled);
+			};
+			const originalSetHeader = res.setHeader.bind(res);
+			const originalWriteHead = res.writeHead?.bind(res);
+			const originalWrite = res.write.bind(res);
+			const originalEnd = res.end.bind(res);
+			const guardedCall = (fn, ...args) => {
+				if (resolved && !ctx.metadata.vite) return;
+				return fn(...args);
+			};
+			res.setHeader = (...args) => guardedCall(originalSetHeader, ...args);
+			if (originalWriteHead) res.writeHead = (...args) => guardedCall(originalWriteHead, ...args);
+			res.write = (...args) => guardedCall(originalWrite, ...args);
+			res.end = (...args) => guardedCall(originalEnd, ...args);
+			res.on("finish", () => done(true));
+			res.on("close", () => res.headersSent && done(true));
+			this.server.middlewares(req, res, () => done(false));
+			setImmediate(() => {
+				if (res.headersSent || res.writableEnded) done(true);
+			});
+		});
+	}
+	/**
+	* Invalidate modules and all their importers.
+	*/
+	invalidateModulesWithImporters() {
+		const invalidated = /* @__PURE__ */ new Set();
+		const queue = [...this.changedFiles];
+		while (queue.length > 0) {
+			const file = queue.pop();
+			if (invalidated.has(file)) continue;
+			const mod = this.server.moduleGraph.getModuleById(file);
+			if (!mod) continue;
+			this.server.moduleGraph.invalidateModule(mod);
+			invalidated.add(file);
+			for (const importer of mod.importers) if (importer.id && !invalidated.has(importer.id)) queue.push(importer.id);
+		}
 	}
 };
 
 //#endregion
-//#region ../../src/cli/commands/format.ts
-var FormatCommand = class {
+//#region ../../src/cli/commands/dev.ts
+var DevCommand = class {
+	log = $logger();
+	fs = $inject(FileSystemProvider);
 	utils = $inject(AlephaCliUtils);
 	pm = $inject(PackageManagerUtils);
 	scaffolder = $inject(ProjectScaffolder);
-	format = $command({
-		name: "format",
-		description: "Format the codebase using Biome",
+	alepha = $inject(Alepha);
+	viteDevServer = $inject(ViteDevServerProvider);
+	boot = $inject(AppEntryProvider);
+	/**
+	* Will run the project in watch mode.
+	*/
+	dev = $command({
+		name: "dev",
+		description: "Run the project in development mode",
 		handler: async ({ root }) => {
-			await this.scaffolder.ensureConfig(root, { biomeJson: true });
-			await this.pm.ensureDependency(root, "@biomejs/biome", { exec: (cmd, opts) => this.utils.exec(cmd, opts) });
-			await this.utils.exec("biome format --fix");
+			await this.scaffolder.ensureConfig(root, { tsconfigJson: true });
+			const entry = await this.boot.getAppEntry(root);
+			this.log.debug("Entry file found", { entry });
+			await this.viteDevServer.init({
+				root,
+				entry
+			});
+			await this.viteDevServer.start();
 		}
 	});
 };
@@ -1627,7 +4044,7 @@ const DEFAULT_IGNORE = [
 * ```
 */
 const changelogOptions = $atom({
-	name: "alepha.changelog",
+	name: "alepha.cli.changelog.options",
 	schema: t.object({ ignore: t.optional(t.array(t.string())) }),
 	default: { ignore: DEFAULT_IGNORE }
 });
@@ -1827,7 +4244,10 @@ var GenEnvCommand = class {
 			description: "Output file path (e.g., .env)"
 		})) }),
 		handler: async ({ root, flags }) => {
-			const { alepha } = await this.utils.loadAlephaFromServerEntryFile(root);
+			const alepha = await this.utils.loadAlephaFromServerEntryFile({
+				root,
+				mode: "development"
+			});
 			try {
 				const { env } = alepha.dump();
 				let dotEnvFile = "";
@@ -1835,7 +4255,7 @@ var GenEnvCommand = class {
 					if (value.description) dotEnvFile += `# ${value.description.split("\n").join("\n# ")}\n`;
 					if (value.required && !value.default) dotEnvFile += `# (required)\n`;
 					if (value.enum) dotEnvFile += `# Possible values: ${value.enum.join(", ")}\n`;
-					dotEnvFile += `${key}=${value.default || ""}\n\n`;
+					dotEnvFile += `#${key}=${value.default || ""}\n\n`;
 				}
 				if (flags.out) await this.fs.writeFile(this.fs.join(root, flags.out), dotEnvFile);
 				else this.log.info(dotEnvFile);
@@ -1860,7 +4280,10 @@ var OpenApiCommand = class {
 			description: "Output file path"
 		})) }),
 		handler: async ({ root, flags }) => {
-			const { alepha } = await this.utils.loadAlephaFromServerEntryFile(root);
+			const alepha = await this.utils.loadAlephaFromServerEntryFile({
+				root,
+				mode: "development"
+			});
 			try {
 				const openapiProvider = alepha.inject(ServerSwaggerProvider);
 				await alepha.events.emit("configure", alepha);
@@ -1929,70 +4352,91 @@ var InitCommand = class {
 		flags: t.object({
 			agent: t.optional(t.boolean({
 				aliases: ["a"],
-				description: "Add CLAUDE.md for Claude Code AI assistant"
+				description: "Add AI agent instructions (CLAUDE.md if claude CLI installed, else AGENTS.md)"
 			})),
-			yarn: t.optional(t.boolean({ description: "Use Yarn package manager" })),
-			pnpm: t.optional(t.boolean({ description: "Use pnpm package manager" })),
-			npm: t.optional(t.boolean({ description: "Use npm package manager" })),
-			bun: t.optional(t.boolean({ description: "Use Bun package manager" })),
-			web: t.optional(t.boolean({
+			pm: t.optional(t.enum([
+				"yarn",
+				"npm",
+				"pnpm",
+				"bun"
+			], { description: "Package manager to use" })),
+			api: t.optional(t.boolean({ description: "Include API module structure (src/api/)" })),
+			react: t.optional(t.boolean({
 				aliases: ["r"],
-				description: "Include Alepha React dependencies"
+				description: "Include React dependencies and web module (src/web/)"
 			})),
-			admin: t.optional(t.boolean({ description: "Include Alepha UI dependencies" })),
-			test: t.optional(t.boolean({ description: "Include Vitest and create test directory" }))
+			ui: t.optional(t.boolean({ description: "Include @alepha/ui (components, auth portal, admin portal)" })),
+			test: t.optional(t.boolean({ description: "Include Vitest and create test directory" })),
+			force: t.optional(t.boolean({
+				aliases: ["f"],
+				description: "Override existing files"
+			}))
 		}),
 		handler: async ({ run, flags, root, args }) => {
-			if (flags.admin) flags.web = true;
 			if (args) {
 				root = this.fs.join(root, args);
 				await this.fs.mkdir(root);
 			}
+			if (flags.ui) flags.react = true;
+			const workspace = await this.pm.getWorkspaceContext(root);
+			let agentType = false;
+			if (flags.agent) agentType = await this.utils.isInstalledAsync("claude") ? "claude" : "agents";
 			const isExpo = await this.pm.hasExpo(root);
+			const force = !!flags.force;
 			await run({
 				name: "ensuring configuration files",
 				handler: async () => {
 					await this.scaffolder.ensureConfig(root, {
-						tsconfigJson: true,
-						packageJson: flags,
-						biomeJson: true,
-						editorconfig: true,
-						indexHtml: !!flags.web && !isExpo,
-						claudeMd: flags.agent ? {
-							react: !!flags.web,
-							ui: !!flags.admin
+						force,
+						tsconfigJson: !workspace.config.tsconfigJson,
+						packageJson: {
+							...flags,
+							isPackage: workspace.isPackage
+						},
+						biomeJson: !workspace.config.biomeJson,
+						editorconfig: !workspace.config.editorconfig,
+						agentMd: agentType ? {
+							type: agentType,
+							react: !!flags.react,
+							ui: !!flags.ui
 						} : false
 					});
-					if (!flags.web) await this.scaffolder.ensureApiProject(root);
+					await this.scaffolder.ensureMainServerTs(root, {
+						api: !!flags.api,
+						react: !!flags.react && !isExpo,
+						force
+					});
+					if (flags.api) await this.scaffolder.ensureApiProject(root, { force });
+					if (flags.react && !isExpo) await this.scaffolder.ensureWebProject(root, {
+						api: !!flags.api,
+						ui: !!flags.ui,
+						force
+					});
 				}
 			});
-			const pmName = await this.pm.getPackageManager(root, flags);
-			if (pmName === "yarn") {
+			const pmName = await this.pm.getPackageManager(workspace.workspaceRoot ?? root, flags.pm ?? workspace.packageManager ?? void 0);
+			if (!workspace.isPackage) if (pmName === "yarn") {
 				await this.pm.ensureYarn(root);
 				await run("yarn set version stable", { root });
 			} else if (pmName === "bun") await this.pm.ensureBun(root);
 			else if (pmName === "pnpm") await this.pm.ensurePnpm(root);
 			else await this.pm.ensureNpm(root);
+			const installRoot = workspace.workspaceRoot ?? root;
 			await run(`${pmName} install`, {
 				alias: `installing dependencies with ${pmName}`,
-				root
-			});
-			if (!isExpo) await this.pm.ensureDependency(root, "vite", {
-				run,
-				exec: (cmd, opts) => this.utils.exec(cmd, opts)
-			});
-			await this.pm.ensureDependency(root, "@biomejs/biome", {
-				run,
-				exec: (cmd, opts) => this.utils.exec(cmd, opts)
+				root: installRoot
 			});
-			if (flags.test) {
-				await this.scaffolder.ensureTestDir(root);
-				await run(`${pmName} ${pmName === "yarn" ? "add" : "install"} -D vitest`, { alias: "setup testing with Vitest" });
-			}
+			if (flags.test) await this.scaffolder.ensureTestDir(root);
 			await run(`${pmName} run lint`, {
 				alias: "running linter",
-				root
+				root: installRoot
 			});
+			if (!workspace.isPackage) {
+				if (await this.scaffolder.ensureGitRepo(root, { force })) await run("git add .", {
+					alias: "staging generated files",
+					root
+				});
+			}
 		}
 	});
 };
@@ -2007,9 +4451,15 @@ var LintCommand = class {
 		name: "lint",
 		description: "Run linter across the codebase using Biome",
 		handler: async ({ root }) => {
-			await this.scaffolder.ensureConfig(root, { biomeJson: true });
-			await this.pm.ensureDependency(root, "@biomejs/biome", { exec: (cmd, opts) => this.utils.exec(cmd, opts) });
-			await this.utils.exec("biome check --formatter-enabled=false --fix");
+			await this.scaffolder.ensureConfig(root, {
+				biomeJson: true,
+				checkWorkspace: true
+			});
+			await this.pm.ensureDependency(root, "@biomejs/biome", {
+				checkWorkspace: true,
+				exec: (cmd, opts) => this.utils.exec(cmd, opts)
+			});
+			await this.utils.exec("biome check --fix");
 		}
 	});
 };
@@ -2074,6 +4524,7 @@ var TypecheckCommand = class {
 	utils = $inject(AlephaCliUtils);
 	pm = $inject(PackageManagerUtils);
 	log = $logger();
+	scaffolder = $inject(ProjectScaffolder);
 	/**
 	* Run TypeScript type checking across the codebase with no emit.
 	*/
@@ -2083,7 +4534,14 @@ var TypecheckCommand = class {
 		description: "Check TypeScript types across the codebase",
 		handler: async ({ root }) => {
 			this.log.info("Starting TypeScript type checking...");
-			await this.pm.ensureDependency(root, "typescript", { exec: (cmd, opts) => this.utils.exec(cmd, opts) });
+			await this.scaffolder.ensureConfig(root, {
+				tsconfigJson: true,
+				checkWorkspace: true
+			});
+			await this.pm.ensureDependency(root, "typescript", {
+				checkWorkspace: true,
+				exec: (cmd, opts) => this.utils.exec(cmd, opts)
+			});
 			await this.utils.exec("tsc --noEmit");
 			this.log.info("TypeScript type checking completed successfully.");
 		}
@@ -2127,15 +4585,6 @@ var VerifyCommand = class {
 //#endregion
 //#region ../../src/cli/apps/AlephaCli.ts
 /**
-* Register `tsx` when running in Node.js, ignore for Bun.
-*
-* It's required to have a full TypeScript support. (mostly .tsx files)
-*/
-if (typeof Bun === "undefined") {
-	const { register } = await import("tsx/esm/api");
-	register();
-}
-/**
 * Allow to extend Alepha CLI via `alepha.config.ts` file located in the project root.
 */
 var AlephaCliExtension = class {
@@ -2162,7 +4611,6 @@ const AlephaCli = $module({
 		DbCommand,
 		DeployCommand,
 		DevCommand,
-		FormatCommand,
 		InitCommand,
 		LintCommand,
 		RootCommand,
@@ -2170,6 +4618,7 @@ const AlephaCli = $module({
 		TypecheckCommand,
 		VerifyCommand,
 		GenCommand,
+		AppEntryProvider,
 		GitProvider
 	]
 });
@@ -2232,6 +4681,7 @@ var AlephaPackageBuilderCli = class {
 					sourcemap: true,
 					fixedExtension: false,
 					platform: "node",
+					inlineOnly: false,
 					external,
 					dts: { sourcemap: true }
 				});
@@ -2241,6 +4691,7 @@ var AlephaPackageBuilderCli = class {
 					platform: "neutral",
 					sourcemap: true,
 					dts: false,
+					inlineOnly: false,
 					external
 				});
 				if (item.browser) entries.push({
@@ -2249,6 +4700,7 @@ var AlephaPackageBuilderCli = class {
 					platform: "browser",
 					sourcemap: true,
 					dts: false,
+					inlineOnly: false,
 					external
 				});
 				if (item.bun) entries.push({
@@ -2258,6 +4710,7 @@ var AlephaPackageBuilderCli = class {
 					sourcemap: true,
 					fixedExtension: false,
 					dts: false,
+					inlineOnly: false,
 					external
 				});
 				const config = this.fs.join(tmpDir, `tsdown-${item.name.replace("/", "-")}.config.js`);
@@ -2281,6 +4734,7 @@ var AlephaPackageBuilderCli = class {
 		}
 	});
 };
+var AlephaPackageBuilderCli_default = AlephaPackageBuilderCli;
 async function getAllFiles(dir) {
 	const files = [];
 	async function scan(currentDir) {
@@ -2384,6 +4838,7 @@ const defineConfig = (runConfig) => {
 		if (config.services) for (const it of config.services) alepha.with(it);
 		if (config.env) for (const [key, value] of Object.entries(config.env)) process.env[key] = String(value);
 		if (config.build) alepha.set(buildOptions, config.build);
+		if (config.entry) alepha.set(appEntryOptions, config.entry);
 		return { ...config.commands };
 	};
 };
@@ -2393,5 +4848,5 @@ const defineConfig = (runConfig) => {
 const defineAlephaConfig = defineConfig;
 
 //#endregion
-export { AlephaCli, AlephaCliUtils, AlephaPackageBuilderCli, BuildCommand, ChangelogCommand, CleanCommand, DEFAULT_IGNORE, DbCommand, DeployCommand, DevCommand, FormatCommand, GitMessageParser, GitProvider, InitCommand, LintCommand, OpenApiCommand, RootCommand, TestCommand, TypecheckCommand, VerifyCommand, analyzeModules, changelogOptions, defineAlephaConfig, defineConfig, version };
+export { AlephaCli, AlephaCliUtils, AlephaPackageBuilderCli_default as AlephaPackageBuilderCli, AppEntryProvider, BuildCommand, ChangelogCommand, CleanCommand, DEFAULT_IGNORE, DbCommand, DeployCommand, DevCommand, GitMessageParser, GitProvider, InitCommand, LintCommand, OpenApiCommand, RootCommand, TestCommand, TypecheckCommand, VerifyCommand, analyzeModules, changelogOptions, defineAlephaConfig, defineConfig, version };
 //# sourceMappingURL=index.js.map