@h3ravel/core 1.7.4 → 1.9.0

package/dist/index.cjs

@@ -1,568 +1,697 @@
-"use strict";
+//#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+require("reflect-metadata");
+let __h3ravel_shared = require("@h3ravel/shared");
+__h3ravel_shared = __toESM(__h3ravel_shared);
+let __h3ravel_support = require("@h3ravel/support");
+__h3ravel_support = __toESM(__h3ravel_support);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let chalk = require("chalk");
+chalk = __toESM(chalk);
+let detect_port = require("detect-port");
+detect_port = __toESM(detect_port);
+let dotenv = require("dotenv");
+dotenv = __toESM(dotenv);
+let dotenv_expand = require("dotenv-expand");
+dotenv_expand = __toESM(dotenv_expand);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let edge_js = require("edge.js");
+edge_js = __toESM(edge_js);
+
+//#region src/Container.ts
+var Container = class {
+	bindings = /* @__PURE__ */ new Map();
+	singletons = /* @__PURE__ */ new Map();
+	/**
+	* Check if the target has any decorators
+	* 
+	* @param target 
+	* @returns 
+	*/
+	static hasAnyDecorator(target) {
+		if (Reflect.getMetadataKeys(target).length > 0) return true;
+		const paramLength = target.length;
+		for (let i = 0; i < paramLength; i++) if (Reflect.getMetadataKeys(target, `__param_${i}`).length > 0) return true;
+		return false;
+	}
+	bind(key, factory) {
+		this.bindings.set(key, factory);
+	}
+	/**
+	* Bind a singleton service to the container
+	*/
+	singleton(key, factory) {
+		this.bindings.set(key, () => {
+			if (!this.singletons.has(key)) this.singletons.set(key, factory());
+			return this.singletons.get(key);
+		});
+	}
+	/**
+	* Resolve a service from the container
+	*/
+	make(key) {
+		/**
+		* Direct factory binding
+		*/
+		if (this.bindings.has(key)) return this.bindings.get(key)();
+		/**
+		* If this is a class constructor, auto-resolve via reflection
+		*/
+		if (typeof key === "function") return this.build(key);
+		throw new Error(`No binding found for key: ${typeof key === "string" ? key : key?.name}`);
+	}
+	/**
+	* Automatically build a class with constructor dependency injection
+	*/
+	build(ClassType) {
+		let dependencies = [];
+		if (Array.isArray(ClassType.__inject__)) dependencies = ClassType.__inject__.map((alias) => {
+			return this.make(alias);
+		});
+		else dependencies = (Reflect.getMetadata("design:paramtypes", ClassType) || []).map((dep) => this.make(dep));
+		return new ClassType(...dependencies);
+	}
+	/**
+	* Check if a service is registered
+	*/
+	has(key) {
+		return this.bindings.has(key);
+	}
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+
+//#endregion
+//#region src/Di/ContainerResolver.ts
+var ContainerResolver = class ContainerResolver {
+	constructor(app) {
+		this.app = app;
+	}
+	async resolveMethodParams(instance, method, _default) {
+		/**
+		* Get param types for instance method
+		*/
+		let params = Reflect.getMetadata("design:paramtypes", instance, String(method)) || [];
+		/**
+		* Ensure that the Application class is always available
+		*/
+		if (params.length < 1 && _default) params = [_default];
+		/**
+		* Resolve the bound dependencies
+		*/
+		let args = params.filter((e) => ContainerResolver.isClass(e)).map((type) => {
+			return this.app.make(type);
+		});
+		return new Promise((resolve) => {
+			resolve(instance[method](...args));
+		});
+	}
+	static isClass(C) {
+		return typeof C === "function" && C.prototype !== void 0 && Object.toString.call(C).substring(0, 5) === "class";
+	}
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/Container.ts
-var Container;
-var init_Container = __esm({
-  "src/Container.ts"() {
-    "use strict";
-    Container = class {
-      static {
-        __name(this, "Container");
-      }
-      bindings = /* @__PURE__ */ new Map();
-      singletons = /* @__PURE__ */ new Map();
-      /**
-       * Check if the target has any decorators
-       * 
-       * @param target 
-       * @returns 
-       */
-      static hasAnyDecorator(target) {
-        if (Reflect.getMetadataKeys(target).length > 0) return true;
-        const paramLength = target.length;
-        for (let i = 0; i < paramLength; i++) {
-          if (Reflect.getMetadataKeys(target, `__param_${i}`).length > 0) {
-            return true;
-          }
-        }
-        return false;
-      }
-      bind(key, factory) {
-        this.bindings.set(key, factory);
-      }
-      /**
-       * Bind a singleton service to the container
-       */
-      singleton(key, factory) {
-        this.bindings.set(key, () => {
-          if (!this.singletons.has(key)) {
-            this.singletons.set(key, factory());
-          }
-          return this.singletons.get(key);
-        });
-      }
-      /**
-       * Resolve a service from the container
-       */
-      make(key) {
-        if (this.bindings.has(key)) {
-          return this.bindings.get(key)();
-        }
-        if (typeof key === "function") {
-          return this.build(key);
-        }
-        throw new Error(`No binding found for key: ${typeof key === "string" ? key : key?.name}`);
-      }
-      /**
-       * Automatically build a class with constructor dependency injection
-       */
-      build(ClassType) {
-        let dependencies = [];
-        if (Array.isArray(ClassType.__inject__)) {
-          dependencies = ClassType.__inject__.map((alias) => {
-            return this.make(alias);
-          });
-        } else {
-          const paramTypes = Reflect.getMetadata("design:paramtypes", ClassType) || [];
-          dependencies = paramTypes.map((dep) => this.make(dep));
-        }
-        return new ClassType(...dependencies);
-      }
-      /**
-       * Check if a service is registered
-       */
-      has(key) {
-        return this.bindings.has(key);
-      }
-    };
-  }
-});
+//#endregion
+//#region src/Registerer.ts
+var Registerer = class Registerer {
+	constructor(app) {
+		this.app = app;
+	}
+	static register(app) {
+		new Registerer(app).bootRegister();
+	}
+	bootRegister() {
+		globalThis.dd = __h3ravel_support.dd;
+		globalThis.dump = __h3ravel_support.dump;
+		globalThis.app_path = (path$1) => this.appPath(path$1);
+		globalThis.base_path = (path$1) => this.basePath(path$1);
+		globalThis.public_path = (path$1) => this.publicPath(path$1);
+		globalThis.storage_path = (path$1) => this.storagePath(path$1);
+		globalThis.database_path = (path$1) => this.databasePath(path$1);
+	}
+	appPath(path$1) {
+		return this.app.getPath("base", node_path.default.join(`/${process.env.SRC_PATH ?? "src"}/`.replace(/([^:]\/)\/+/g, "$1"), "app", path$1 ?? ""));
+	}
+	basePath(path$1) {
+		return this.app.getPath("base", path$1);
+	}
+	publicPath(path$1) {
+		return this.app.getPath("public", path$1);
+	}
+	storagePath(path$1) {
+		return this.app.getPath("base", node_path.default.join("storage", path$1 ?? ""));
+	}
+	databasePath(path$1) {
+		return this.app.getPath("database", path$1);
+	}
+};
 
-// src/Registerer.ts
-var import_support, Registerer;
-var init_Registerer = __esm({
-  "src/Registerer.ts"() {
-    "use strict";
-    import_support = require("@h3ravel/support");
-    Registerer = class {
-      static {
-        __name(this, "Registerer");
-      }
-      static register() {
-        globalThis.dd = import_support.dd;
-        globalThis.dump = import_support.dump;
-      }
-    };
-  }
-});
+//#endregion
+//#region src/Application.ts
+var Application = class Application extends Container {
+	paths = new __h3ravel_shared.PathLoader();
+	tries = 0;
+	booted = false;
+	versions = {
+		app: "0",
+		ts: "0"
+	};
+	basePath;
+	providers = [];
+	externalProviders = [];
+	/**
+	* List of registered console commands
+	*/
+	registeredCommands = [];
+	constructor(basePath) {
+		super();
+		dotenv_expand.default.expand(dotenv.default.config({ quiet: true }));
+		this.basePath = basePath;
+		this.setPath("base", basePath);
+		this.loadOptions();
+		this.registerBaseBindings();
+		Registerer.register(this);
+	}
+	/**
+	* Register core bindings into the container
+	*/
+	registerBaseBindings() {
+		this.bind(Application, () => this);
+		this.bind("path.base", () => this.basePath);
+		this.bind("load.paths", () => this.paths);
+	}
+	/**
+	* Dynamically register all configured providers
+	*/
+	async registerConfiguredProviders() {
+		const providers = await this.getAllProviders();
+		for (const ProviderClass of providers) {
+			if (!ProviderClass) continue;
+			const provider = new ProviderClass(this);
+			await this.register(provider);
+		}
+	}
+	async loadOptions() {
+		const app = await this.safeImport(this.getPath("base", "package.json"));
+		const core = await this.safeImport("../package.json");
+		if (app && app.dependencies) this.versions.app = app.dependencies["@h3ravel/core"];
+		if (core && core.devDependencies) this.versions.ts = app.devDependencies.typescript;
+	}
+	/**
+	* Get all registered providers
+	*/
+	getRegisteredProviders() {
+		return this.providers;
+	}
+	/**
+	* Load default and optional providers dynamically
+	* 
+	* Auto-Registration Behavior
+	* 
+	* Minimal App: Loads only core, config, http, router by default.
+	* Full-Stack App: Installs database, mail, queue, cache → they self-register via their providers.
+	*/
+	async getConfiguredProviders() {
+		return [(await Promise.resolve().then(() => require("./index.cjs"))).CoreServiceProvider, (await Promise.resolve().then(() => require("./index.cjs"))).ViewServiceProvider];
+	}
+	async getAllProviders() {
+		const allProviders = [...await this.getConfiguredProviders(), ...this.externalProviders];
+		/**
+		* Deduplicate by class reference
+		*/
+		const uniqueProviders = Array.from(new Set(allProviders));
+		return this.sortProviders(uniqueProviders);
+	}
+	sortProviders(providers) {
+		const priorityMap = /* @__PURE__ */ new Map();
+		/**
+		* Base priority (default 0)
+		*/
+		providers.forEach((Provider) => {
+			priorityMap.set(Provider.name, Provider.priority ?? 0);
+		});
+		/**
+		* Handle before/after adjustments
+		*/
+		providers.forEach((Provider) => {
+			const order = Provider.order;
+			if (!order) return;
+			const [direction, target] = order.split(":");
+			const targetPriority = priorityMap.get(target) ?? 0;
+			if (direction === "before") priorityMap.set(Provider.name, targetPriority - 1);
+			else if (direction === "after") priorityMap.set(Provider.name, targetPriority + 1);
+		});
+		/**
+		* Service providers sorted based on thier name and priority
+		*/
+		const sorted = providers.sort((A, B) => (priorityMap.get(B.name) ?? 0) - (priorityMap.get(A.name) ?? 0));
+		/**
+		* If debug is enabled, let's show the loaded service provider info
+		*/
+		if (process.env.APP_DEBUG === "true" && process.env.EXTENDED_DEBUG !== "false" && !sorted.some((e) => e.console)) {
+			console.table(sorted.map((P) => ({
+				Provider: P.name,
+				Priority: priorityMap.get(P.name),
+				Order: P.order || "N/A"
+			})));
+			console.info(`Set ${chalk.default.bgCyan(" APP_DEBUG = false ")} in your .env file to hide this information`, "\n");
+		}
+		return sorted;
+	}
+	registerProviders(providers) {
+		this.externalProviders.push(...providers);
+	}
+	/**
+	* Register a provider
+	*/
+	async register(provider) {
+		await new ContainerResolver(this).resolveMethodParams(provider, "register", this);
+		if (provider.registeredCommands && provider.registeredCommands.length > 0) this.registeredCommands.push(...provider.registeredCommands);
+		this.providers.push(provider);
+	}
+	/**
+	* checks if the application is running in CLI
+	*/
+	runningInConsole() {
+		return typeof process !== "undefined" && !!process.stdout && !!process.stdin;
+	}
+	getRuntimeEnv() {
+		if (typeof window !== "undefined" && typeof document !== "undefined") return "browser";
+		if (typeof process !== "undefined" && process.versions?.node) return "node";
+		return "unknown";
+	}
+	/**
+	* Boot all service providers after registration
+	*/
+	async boot() {
+		if (this.booted) return;
+		for (const provider of this.providers) if (provider.boot) if (Container.hasAnyDecorator(provider.boot))
+ /**
+		* If the service provider is decorated use the IoC container
+		*/
+		await this.make(provider.boot);
+		else
+ /**
+		* Otherwise instantiate manually so that we can at least
+		* pass the app instance
+		*/
+		await provider.boot(this);
+		this.booted = true;
+	}
+	/**
+	* Fire up the developement server using the user provided arguments
+	* 
+	* Port will be auto assigned if provided one is not available
+	* 
+	* @param h3App The current H3 app instance
+	* @param preferedPort If provided, this will overide the port set in the evironment
+	*/
+	async fire(h3App, preferedPort) {
+		const serve = this.make("http.serve");
+		const port = preferedPort ?? env("PORT", 3e3);
+		const tries = env("RETRIES", 1);
+		const hostname = env("HOSTNAME", "localhost");
+		try {
+			const realPort = await (0, detect_port.detect)(port);
+			if (port == realPort) {
+				const server = serve(h3App, {
+					port,
+					hostname,
+					silent: true
+				});
+				__h3ravel_shared.Logger.parse([[`🚀 H3ravel running at:`, "green"], [`${server.options.protocol ?? "http"}://${server.options.hostname}:${server.options.port}`, "cyan"]]);
+			} else if (this.tries <= tries) {
+				await this.fire(h3App, realPort);
+				this.tries++;
+			} else __h3ravel_shared.Logger.parse([["ERROR:", "bgRed"], ["No free port available", "red"]]);
+		} catch (e) {
+			__h3ravel_shared.Logger.parse([
+				["An error occured", "bgRed"],
+				[e.message, "red"],
+				[e.stack, "red"]
+			], "\n");
+		}
+	}
+	/**
+	* Attempt to dynamically import an optional module
+	*/
+	async safeImport(moduleName) {
+		try {
+			const mod = await import(moduleName);
+			return mod.default ?? mod ?? {};
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Get the base path of the app
+	* 
+	* @returns 
+	*/
+	getBasePath() {
+		return this.basePath;
+	}
+	/**
+	* Dynamically retrieves a path property from the class.
+	* Any property ending with "Path" is accessible automatically.
+	*
+	* @param name - The base name of the path property
+	* @returns 
+	*/
+	getPath(name, suffix) {
+		return node_path.default.join(this.paths.getPath(name, this.basePath), suffix ?? "");
+	}
+	/**
+	* Programatically set the paths.
+	*
+	* @param name - The base name of the path property
+	* @param path - The new path
+	* @returns 
+	*/
+	setPath(name, path$1) {
+		return this.paths.setPath(name, path$1, this.basePath);
+	}
+	/**
+	* Returns the installed version of the system core and typescript.
+	*
+	* @returns 
+	*/
+	getVersion(key) {
+		return this.versions[key]?.replaceAll(/\^|~/g, "");
+	}
+};
 
-// src/Application.ts
-var import_shared, import_dotenv, import_node_path, Application;
-var init_Application = __esm({
-  "src/Application.ts"() {
-    "use strict";
-    init_Container();
-    import_shared = require("@h3ravel/shared");
-    init_Registerer();
-    import_dotenv = __toESM(require("dotenv"), 1);
-    import_node_path = __toESM(require("path"), 1);
-    Application = class _Application extends Container {
-      static {
-        __name(this, "Application");
-      }
-      paths = new import_shared.PathLoader();
-      booted = false;
-      versions = {
-        app: "0",
-        ts: "0"
-      };
-      basePath;
-      providers = [];
-      externalProviders = [];
-      constructor(basePath) {
-        super();
-        this.basePath = basePath;
-        this.setPath("base", basePath);
-        this.loadOptions();
-        this.registerBaseBindings();
-        Registerer.register();
-        import_dotenv.default.config({
-          quiet: true
-        });
-      }
-      /**
-       * Register core bindings into the container
-       */
-      registerBaseBindings() {
-        this.bind(_Application, () => this);
-        this.bind("path.base", () => this.basePath);
-        this.bind("load.paths", () => this.paths);
-      }
-      /**
-       * Dynamically register all configured providers
-       */
-      async registerConfiguredProviders() {
-        const providers = await this.getAllProviders();
-        for (const ProviderClass of providers) {
-          if (!ProviderClass) continue;
-          const provider = new ProviderClass(this);
-          await this.register(provider);
-        }
-      }
-      async loadOptions() {
-        const app = await this.safeImport(this.getPath("base", "package.json"));
-        const core = await this.safeImport("../package.json");
-        if (app && app.dependencies) {
-          this.versions.app = app.dependencies["@h3ravel/core"];
-        }
-        if (core && core.devDependencies) {
-          this.versions.ts = app.devDependencies.typescript;
-        }
-      }
-      /**
-       * Load default and optional providers dynamically
-       * 
-       * Auto-Registration Behavior
-       * 
-       * Minimal App: Loads only core, config, http, router by default.
-       * Full-Stack App: Installs database, mail, queue, cache → they self-register via their providers.
-       */
-      async getConfiguredProviders() {
-        return [
-          (await Promise.resolve().then(() => (init_index(), index_exports))).CoreServiceProvider,
-          (await Promise.resolve().then(() => (init_index(), index_exports))).ViewServiceProvider
-        ];
-      }
-      async getAllProviders() {
-        const coreProviders = await this.getConfiguredProviders();
-        const allProviders = [
-          ...coreProviders,
-          ...this.externalProviders
-        ];
-        const uniqueProviders = Array.from(new Set(allProviders));
-        return this.sortProviders(uniqueProviders);
-      }
-      sortProviders(providers) {
-        const priorityMap = /* @__PURE__ */ new Map();
-        providers.forEach((Provider) => {
-          priorityMap.set(Provider.name, Provider.priority ?? 0);
-        });
-        providers.forEach((Provider) => {
-          const order = Provider.order;
-          if (!order) return;
-          const [direction, target] = order.split(":");
-          const targetPriority = priorityMap.get(target) ?? 0;
-          if (direction === "before") {
-            priorityMap.set(Provider.name, targetPriority - 1);
-          } else if (direction === "after") {
-            priorityMap.set(Provider.name, targetPriority + 1);
-          }
-        });
-        const sorted = providers.sort((A, B) => (priorityMap.get(B.name) ?? 0) - (priorityMap.get(A.name) ?? 0));
-        if (process.env.APP_DEBUG === "true") {
-          console.table(sorted.map((P) => ({
-            Provider: P.name,
-            Priority: priorityMap.get(P.name),
-            Order: P.order || "N/A"
-          })));
-        }
-        return sorted;
-      }
-      registerProviders(providers) {
-        this.externalProviders.push(...providers);
-      }
-      /**
-       * Register a provider
-       */
-      async register(provider) {
-        await provider.register();
-        this.providers.push(provider);
-      }
-      /**
-       * Boot all providers after registration
-       */
-      async boot() {
-        if (this.booted) return;
-        for (const provider of this.providers) {
-          if (provider.boot) {
-            await provider.boot();
-          }
-        }
-        this.booted = true;
-      }
-      /**
-       * Attempt to dynamically import an optional module
-       */
-      async safeImport(moduleName) {
-        try {
-          const mod = await import(moduleName);
-          return mod.default ?? mod ?? {};
-        } catch {
-          return null;
-        }
-      }
-      /**
-       * Get the base path of the app
-       * 
-       * @returns 
-       */
-      getBasePath() {
-        return this.basePath;
-      }
-      /**
-       * Dynamically retrieves a path property from the class.
-       * Any property ending with "Path" is accessible automatically.
-       *
-       * @param name - The base name of the path property
-       * @returns 
-       */
-      getPath(name, pth) {
-        return import_node_path.default.join(this.paths.getPath(name, this.basePath), pth ?? "");
-      }
-      /**
-       * Programatically set the paths.
-       *
-       * @param name - The base name of the path property
-       * @param path - The new path
-       * @returns 
-       */
-      setPath(name, path2) {
-        return this.paths.setPath(name, path2, this.basePath);
-      }
-      /**
-       * Returns the installed version of the system core and typescript.
-       *
-       * @returns 
-       */
-      getVersion(key) {
-        return this.versions[key]?.replaceAll(/\^|~/g, "");
-      }
-    };
-  }
-});
+//#endregion
+//#region src/Console/ConsoleCommand.ts
+var ConsoleCommand = class {
+	constructor(app, kernel) {
+		this.app = app;
+		this.kernel = kernel;
+	}
+	/**
+	* The underlying commander instance.
+	*
+	* @var Command
+	*/
+	program;
+	/**
+	* The name and signature of the console command.
+	*
+	* @var string
+	*/
+	signature;
+	/**
+	* A dictionary of signatures or what not.
+	*
+	* @var object
+	*/
+	dictionary = {};
+	/**
+	* The console command description.
+	*
+	* @var string
+	*/
+	description;
+	/**
+	* The console command input.
+	*
+	* @var object
+	*/
+	input = {
+		options: {},
+		arguments: {}
+	};
+	/**
+	* Execute the console command.
+	*/
+	async handle(..._args) {}
+	setApplication(app) {
+		this.app = app;
+	}
+	setInput(options, args, regArgs, dictionary, program) {
+		this.program = program;
+		this.dictionary = dictionary;
+		this.input.options = options;
+		this.input.arguments = regArgs.map((e, i) => ({ [e.name()]: args[i] })).reduce((e, x) => Object.assign(e, x), {});
+	}
+	getSignature() {
+		return this.signature;
+	}
+	getDescription() {
+		return this.description;
+	}
+	option(key, def) {
+		return this.input.options[key] ?? def;
+	}
+	options(key) {
+		if (key) return this.input.options[key];
+		return this.input.options;
+	}
+	argument(key, def) {
+		return this.input.arguments[key] ?? def;
+	}
+	arguments() {
+		return this.input.arguments;
+	}
+};
 
-// src/Contracts/ServiceProviderConstructor.ts
-var init_ServiceProviderConstructor = __esm({
-  "src/Contracts/ServiceProviderConstructor.ts"() {
-    "use strict";
-  }
-});
+//#endregion
+//#region src/Console/ConsoleKernel.ts
+var ConsoleKernel = class {
+	cwd;
+	output = typeof __h3ravel_shared.Logger;
+	basePath = "";
+	modulePath;
+	consolePath;
+	modulePackage;
+	consolePackage;
+	constructor(app) {
+		this.app = app;
+	}
+	async ensureDirectoryExists(dir) {
+		await (0, node_fs_promises.mkdir)(dir, { recursive: true });
+	}
+};
 
-// src/Controller.ts
-var Controller;
-var init_Controller = __esm({
-  "src/Controller.ts"() {
-    "use strict";
-    Controller = class {
-      static {
-        __name(this, "Controller");
-      }
-      app;
-      constructor(app) {
-        this.app = app;
-      }
-      show(..._ctx) {
-        return;
-      }
-      index(..._ctx) {
-        return;
-      }
-      store(..._ctx) {
-        return;
-      }
-      update(..._ctx) {
-        return;
-      }
-      destroy(..._ctx) {
-        return;
-      }
-    };
-  }
-});
+//#endregion
+//#region src/Controller.ts
+/**
+* Base controller class
+*/
+var Controller = class {
+	app;
+	constructor(app) {
+		this.app = app;
+	}
+	show(..._ctx) {}
+	index(..._ctx) {}
+	store(..._ctx) {}
+	update(..._ctx) {}
+	destroy(..._ctx) {}
+};
 
-// src/Di/Inject.ts
+//#endregion
+//#region src/Di/Inject.ts
 function Inject(...dependencies) {
-  return function(target) {
-    target.__inject__ = dependencies;
-  };
+	return function(target) {
+		target.__inject__ = dependencies;
+	};
 }
+/**
+* Allows binding dependencies to both class and class methods 
+* 
+* @returns 
+*/
 function Injectable() {
-  return (...args) => {
-    if (args.length === 1) {
-      void args[0];
-    }
-    if (args.length === 3) {
-      void args[0];
-      void args[1];
-      void args[2];
-    }
-  };
+	return (...args) => {
+		if (args.length === 1) args[0];
+		if (args.length === 3) {
+			args[0];
+			args[1];
+			args[2];
+		}
+	};
 }
-var init_Inject = __esm({
-  "src/Di/Inject.ts"() {
-    "use strict";
-    __name(Inject, "Inject");
-    __name(Injectable, "Injectable");
-  }
-});
 
-// src/Exceptions/Handler.ts
-var init_Handler = __esm({
-  "src/Exceptions/Handler.ts"() {
-    "use strict";
-  }
-});
-
-// src/Http/Kernel.ts
-var Kernel;
-var init_Kernel = __esm({
-  "src/Http/Kernel.ts"() {
-    "use strict";
-    Kernel = class {
-      static {
-        __name(this, "Kernel");
-      }
-      context;
-      middleware;
-      /**
-       * @param context - A factory function that converts an H3Event into an HttpContext.
-       * @param middleware - An array of middleware classes that will be executed in sequence.
-       */
-      constructor(context, middleware = []) {
-        this.context = context;
-        this.middleware = middleware;
-      }
-      /**
-       * Handles an incoming request and passes it through middleware before invoking the next handler.
-       * 
-       * @param event - The raw H3 event object.
-       * @param next - A callback function that represents the next layer (usually the controller or final handler).
-       * @returns A promise resolving to the result of the request pipeline.
-       */
-      async handle(event, next) {
-        const ctx = this.context(event);
-        const { app } = ctx.request;
-        app.bind("view", () => async (template, params) => {
-          const edge = app.make("edge");
-          return ctx.response.html(await edge.render(template, params));
-        });
-        const result = await this.runMiddleware(ctx, () => next(ctx));
-        if (result !== void 0 && this.isPlainObject(result)) {
-          event.res.headers.set("Content-Type", "application/json; charset=UTF-8");
-        }
-        return result;
-      }
-      /**
-       * Sequentially runs middleware in the order they were registered.
-       * 
-       * @param context - The standardized HttpContext.
-       * @param next - Callback to execute when middleware completes.
-       * @returns A promise resolving to the final handler's result.
-       */
-      async runMiddleware(context, next) {
-        let index = -1;
-        const runner = /* @__PURE__ */ __name(async (i) => {
-          if (i <= index) throw new Error("next() called multiple times");
-          index = i;
-          const middleware = this.middleware[i];
-          if (middleware) {
-            return middleware.handle(context, () => runner(i + 1));
-          } else {
-            return next(context);
-          }
-        }, "runner");
-        return runner(0);
-      }
-      /**
-       * Utility function to determine if a value is a plain object or array.
-       * 
-       * @param value - The value to check.
-       * @returns True if the value is a plain object or array, otherwise false.
-       */
-      isPlainObject(value) {
-        return typeof value === "object" && value !== null && (value.constructor === Object || value.constructor === Array);
-      }
-    };
-  }
-});
+//#endregion
+//#region src/Http/Kernel.ts
+/**
+* Kernel class handles middleware execution and response transformations.
+* It acts as the core middleware pipeline for HTTP requests.
+*/
+var Kernel = class {
+	/**
+	* @param context - A factory function that converts an H3Event into an HttpContext.
+	* @param middleware - An array of middleware classes that will be executed in sequence.
+	*/
+	constructor(context, middleware = []) {
+		this.context = context;
+		this.middleware = middleware;
+	}
+	/**
+	* Handles an incoming request and passes it through middleware before invoking the next handler.
+	* 
+	* @param event - The raw H3 event object.
+	* @param next - A callback function that represents the next layer (usually the controller or final handler).
+	* @returns A promise resolving to the result of the request pipeline.
+	*/
+	async handle(event, next) {
+		/**
+		* Convert the raw event into a standardized HttpContext
+		*/
+		const ctx = this.context(event);
+		const { app } = ctx.request;
+		/**
+		* Dynamically bind the view renderer to the service container.
+		* This allows any part of the request lifecycle to render templates using Edge.
+		*/
+		app.bind("view", () => async (template, params) => {
+			const edge = app.make("edge");
+			return ctx.response.html(await edge.render(template, params));
+		});
+		/**
+		* Run middleware stack and obtain result
+		*/
+		const result = await this.runMiddleware(ctx, () => next(ctx));
+		/**
+		* If a plain object is returned from a controller or middleware,
+		* automatically set the JSON Content-Type header for the response.
+		*/
+		if (result !== void 0 && this.isPlainObject(result)) event.res.headers.set("Content-Type", "application/json; charset=UTF-8");
+		return result;
+	}
+	/**
+	* Sequentially runs middleware in the order they were registered.
+	* 
+	* @param context - The standardized HttpContext.
+	* @param next - Callback to execute when middleware completes.
+	* @returns A promise resolving to the final handler's result.
+	*/
+	async runMiddleware(context, next) {
+		let index = -1;
+		const runner = async (i) => {
+			if (i <= index) throw new Error("next() called multiple times");
+			index = i;
+			const middleware = this.middleware[i];
+			if (middleware)
+ /**
+			* Execute the current middleware and proceed to the next one
+			*/
+			return middleware.handle(context, () => runner(i + 1));
+			else
+ /**
+			* If no more middleware, call the final handler
+			*/
+			return next(context);
+		};
+		return runner(0);
+	}
+	/**
+	* Utility function to determine if a value is a plain object or array.
+	* 
+	* @param value - The value to check.
+	* @returns True if the value is a plain object or array, otherwise false.
+	*/
+	isPlainObject(value) {
+		return typeof value === "object" && value !== null && (value.constructor === Object || value.constructor === Array);
+	}
+};
 
-// src/ServiceProvider.ts
-var ServiceProvider;
-var init_ServiceProvider = __esm({
-  "src/ServiceProvider.ts"() {
-    "use strict";
-    ServiceProvider = class {
-      static {
-        __name(this, "ServiceProvider");
-      }
-      static order;
-      static priority = 0;
-      app;
-      constructor(app) {
-        this.app = app;
-      }
-    };
-  }
-});
+//#endregion
+//#region src/ServiceProvider.ts
+var ServiceProvider = class {
+	/**
+	* Sort order
+	*/
+	static order;
+	/**
+	* Sort priority
+	*/
+	static priority = 0;
+	/**
+	* Indicate that this service provider only runs in console
+	*/
+	static console = false;
+	/**
+	* List of registered console commands
+	*/
+	registeredCommands;
+	app;
+	constructor(app) {
+		this.app = app;
+	}
+	/**
+	* An array of console commands to register.
+	*/
+	commands(commands) {
+		this.registeredCommands = commands;
+	}
+};
 
-// src/Providers/CoreServiceProvider.ts
-var import_reflect_metadata, CoreServiceProvider;
-var init_CoreServiceProvider = __esm({
-  "src/Providers/CoreServiceProvider.ts"() {
-    "use strict";
-    import_reflect_metadata = require("reflect-metadata");
-    init_ServiceProvider();
-    CoreServiceProvider = class extends ServiceProvider {
-      static {
-        __name(this, "CoreServiceProvider");
-      }
-      static priority = 999;
-      register() {
-      }
-    };
-  }
-});
+//#endregion
+//#region src/Providers/CoreServiceProvider.ts
+/**
+* Bootstraps core services and bindings.
+* 
+* Bind essential services to the container (logger, config repository).
+* Register app-level singletons.
+* Set up exception handling.
+* 
+* Auto-Registered
+*/
+var CoreServiceProvider = class extends ServiceProvider {
+	static priority = 999;
+	register() {}
+};
 
-// src/Providers/ViewServiceProvider.ts
-var import_edge, ViewServiceProvider;
-var init_ViewServiceProvider = __esm({
-  "src/Providers/ViewServiceProvider.ts"() {
-    "use strict";
-    import_edge = require("edge.js");
-    init_ServiceProvider();
-    ViewServiceProvider = class extends ServiceProvider {
-      static {
-        __name(this, "ViewServiceProvider");
-      }
-      static priority = 995;
-      register() {
-        const config = this.app.make("config");
-        const edge = import_edge.Edge.create({
-          cache: process.env.NODE_ENV === "production"
-        });
-        edge.mount(this.app.getPath("views"));
-        edge.global("asset", this.app.make("asset"));
-        edge.global("config", config.get);
-        edge.global("app", this.app);
-        this.app.bind("edge", () => edge);
-      }
-    };
-  }
-});
+//#endregion
+//#region src/Providers/ViewServiceProvider.ts
+var ViewServiceProvider = class extends ServiceProvider {
+	static priority = 995;
+	register() {
+		const config = this.app.make("config");
+		const edge = edge_js.Edge.create({ cache: process.env.NODE_ENV === "production" });
+		edge.mount(this.app.getPath("views"));
+		edge.global("asset", this.app.make("asset"));
+		edge.global("config", config.get);
+		edge.global("app", this.app);
+		this.app.bind("edge", () => edge);
+	}
+};
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Application: () => Application,
-  Container: () => Container,
-  Controller: () => Controller,
-  CoreServiceProvider: () => CoreServiceProvider,
-  Inject: () => Inject,
-  Injectable: () => Injectable,
-  Kernel: () => Kernel,
-  Registerer: () => Registerer,
-  ServiceProvider: () => ServiceProvider,
-  ViewServiceProvider: () => ViewServiceProvider
-});
-module.exports = __toCommonJS(index_exports);
-var init_index = __esm({
-  "src/index.ts"() {
-    init_Application();
-    init_Container();
-    init_ServiceProviderConstructor();
-    init_Controller();
-    init_Inject();
-    init_Handler();
-    init_Kernel();
-    init_CoreServiceProvider();
-    init_ViewServiceProvider();
-    init_Registerer();
-    init_ServiceProvider();
-  }
-});
-init_index();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Application,
-  Container,
-  Controller,
-  CoreServiceProvider,
-  Inject,
-  Injectable,
-  Kernel,
-  Registerer,
-  ServiceProvider,
-  ViewServiceProvider
-});
+//#endregion
+exports.Application = Application;
+exports.ConsoleCommand = ConsoleCommand;
+exports.ConsoleKernel = ConsoleKernel;
+exports.Container = Container;
+exports.ContainerResolver = ContainerResolver;
+exports.Controller = Controller;
+exports.CoreServiceProvider = CoreServiceProvider;
+exports.Inject = Inject;
+exports.Injectable = Injectable;
+exports.Kernel = Kernel;
+exports.Registerer = Registerer;
+exports.ServiceProvider = ServiceProvider;
+exports.ViewServiceProvider = ViewServiceProvider;
 //# sourceMappingURL=index.cjs.map