@h3ravel/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1860 @@
+"use strict";
+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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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;
+};
+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();
+      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) {
+        const paramTypes = Reflect.getMetadata("design:paramtypes", ClassType) || [];
+        const dependencies = paramTypes.map((dep) => this.make(dep));
+        return new ClassType(...dependencies);
+      }
+      /**
+       * Check if a service is registered
+       */
+      has(key) {
+        return this.bindings.has(key);
+      }
+    };
+  }
+});
+
+// src/Utils/PathLoader.ts
+var import_path, PathLoader;
+var init_PathLoader = __esm({
+  "src/Utils/PathLoader.ts"() {
+    "use strict";
+    import_path = __toESM(require("path"), 1);
+    PathLoader = class {
+      static {
+        __name(this, "PathLoader");
+      }
+      paths = {
+        base: "",
+        views: "/src/resources/views",
+        assets: "/public/assets",
+        routes: "/src/routes",
+        config: "/src/config",
+        public: "/public",
+        storage: "/src/storage"
+      };
+      /**
+       * 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
+       * @param base - The base path to include to the path
+       * @returns 
+       */
+      getPath(name, base) {
+        if (base && name !== "base") {
+          return import_path.default.join(base, this.paths[name]);
+        }
+        return this.paths[name];
+      }
+      /**
+       * Programatically set the paths.
+       *
+       * @param name - The base name of the path property
+       * @param path - The new path
+       * @param base - The base path to include to the path
+       */
+      setPath(name, path4, base) {
+        if (base && name !== "base") {
+          this.paths[name] = import_path.default.join(base, path4);
+        }
+        this.paths[name] = path4;
+      }
+    };
+  }
+});
+
+// ../http/src/Middleware.ts
+var Middleware;
+var init_Middleware = __esm({
+  "../http/src/Middleware.ts"() {
+    "use strict";
+    Middleware = class {
+      static {
+        __name(this, "Middleware");
+      }
+    };
+  }
+});
+
+// ../support/src/Contracts/ObjContract.ts
+var init_ObjContract = __esm({
+  "../support/src/Contracts/ObjContract.ts"() {
+    "use strict";
+  }
+});
+
+// ../support/src/Contracts/StrContract.ts
+var init_StrContract = __esm({
+  "../support/src/Contracts/StrContract.ts"() {
+    "use strict";
+  }
+});
+
+// ../support/src/Helpers/Arr.ts
+var init_Arr = __esm({
+  "../support/src/Helpers/Arr.ts"() {
+    "use strict";
+  }
+});
+
+// ../support/src/Helpers/Number.ts
+var init_Number = __esm({
+  "../support/src/Helpers/Number.ts"() {
+    "use strict";
+  }
+});
+
+// ../support/src/Helpers/Obj.ts
+function safeDot(data, key) {
+  if (!key) return data;
+  return key.split(".").reduce((acc, k) => acc?.[k], data);
+}
+var setNested;
+var init_Obj = __esm({
+  "../support/src/Helpers/Obj.ts"() {
+    "use strict";
+    __name(safeDot, "safeDot");
+    setNested = /* @__PURE__ */ __name((obj, key, value) => {
+      if (!key.includes(".")) {
+        obj[key] = value;
+        return;
+      }
+      const parts = key.split(".");
+      let current = obj;
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (i === parts.length - 1) {
+          current[part] = value;
+        } else {
+          if (typeof current[part] !== "object" || current[part] === null) {
+            current[part] = {};
+          }
+          current = current[part];
+        }
+      }
+    }, "setNested");
+  }
+});
+
+// ../support/src/Helpers/Str.ts
+var afterLast, before;
+var init_Str = __esm({
+  "../support/src/Helpers/Str.ts"() {
+    "use strict";
+    init_Obj();
+    afterLast = /* @__PURE__ */ __name((value, search) => {
+      if (!search) return value;
+      const lastIndex = value.lastIndexOf(search);
+      return lastIndex !== -1 ? value.slice(lastIndex + search.length) : value;
+    }, "afterLast");
+    before = /* @__PURE__ */ __name((value, search) => {
+      if (!search) return value;
+      const index = value.indexOf(search);
+      return index !== -1 ? value.slice(0, index) : value;
+    }, "before");
+  }
+});
+
+// ../support/src/index.ts
+var init_src = __esm({
+  "../support/src/index.ts"() {
+    "use strict";
+    init_ObjContract();
+    init_StrContract();
+    init_Arr();
+    init_Number();
+    init_Obj();
+    init_Str();
+  }
+});
+
+// ../http/src/Request.ts
+var import_h3, Request;
+var init_Request = __esm({
+  "../http/src/Request.ts"() {
+    "use strict";
+    import_h3 = require("h3");
+    init_src();
+    Request = class {
+      static {
+        __name(this, "Request");
+      }
+      event;
+      constructor(event) {
+        this.event = event;
+      }
+      /**
+       * Get all input data (query + body).
+       */
+      async all() {
+        let data = {
+          ...(0, import_h3.getRouterParams)(this.event),
+          ...(0, import_h3.getQuery)(this.event)
+        };
+        if (this.event.req.method === "POST") {
+          data = Object.assign({}, data, Object.fromEntries((await this.event.req.formData()).entries()));
+        } else if (this.event.req.method === "PUT") {
+          data = Object.fromEntries(Object.entries(await (0, import_h3.readBody)(this.event)));
+        }
+        return data;
+      }
+      /**
+       * Get a single input field from query or body.
+       */
+      async input(key, defaultValue) {
+        const data = await this.all();
+        return data[key] ?? defaultValue;
+      }
+      /**
+       * Get route parameters.
+       */
+      params() {
+        return (0, import_h3.getRouterParams)(this.event);
+      }
+      /**
+       * Get query parameters.
+       */
+      query() {
+        return (0, import_h3.getQuery)(this.event);
+      }
+      getEvent(key) {
+        return safeDot(this.event, key);
+      }
+    };
+  }
+});
+
+// ../http/src/Response.ts
+var import_h32, Response;
+var init_Response = __esm({
+  "../http/src/Response.ts"() {
+    "use strict";
+    init_src();
+    import_h32 = require("h3");
+    Response = class {
+      static {
+        __name(this, "Response");
+      }
+      event;
+      statusCode = 200;
+      headers = {};
+      constructor(event) {
+        this.event = event;
+      }
+      /**
+       * Set HTTP status code.
+       */
+      setStatusCode(code) {
+        this.statusCode = code;
+        this.event.res.status = code;
+        return this;
+      }
+      /**
+       * Set a header.
+       */
+      setHeader(name, value) {
+        this.headers[name] = value;
+        return this;
+      }
+      html(content) {
+        this.applyHeaders();
+        return (0, import_h32.html)(this.event, content);
+      }
+      /**
+       * Send a JSON response.
+       */
+      json(data) {
+        this.setHeader("content-type", "application/json; charset=utf-8");
+        this.applyHeaders();
+        return data;
+      }
+      /**
+       * Send plain text.
+       */
+      text(data) {
+        this.setHeader("content-type", "text/plain; charset=utf-8");
+        this.applyHeaders();
+        return data;
+      }
+      /**
+       * Redirect to another URL.
+       */
+      redirect(url, status = 302) {
+        this.setStatusCode(status);
+        return (0, import_h32.redirect)(this.event, url, this.statusCode);
+      }
+      /**
+       * Apply headers before sending response.
+       */
+      applyHeaders() {
+        Object.entries(this.headers).forEach(([key, value]) => {
+          this.event.res.headers.set(key, value);
+        });
+      }
+      getEvent(key) {
+        return safeDot(this.event, key);
+      }
+    };
+  }
+});
+
+// ../http/src/Contracts/ControllerContracts.ts
+var init_ControllerContracts = __esm({
+  "../http/src/Contracts/ControllerContracts.ts"() {
+    "use strict";
+  }
+});
+
+// ../http/src/Contracts/HttpContract.ts
+var init_HttpContract = __esm({
+  "../http/src/Contracts/HttpContract.ts"() {
+    "use strict";
+  }
+});
+
+// ../http/src/Middleware/LogRequests.ts
+var LogRequests;
+var init_LogRequests = __esm({
+  "../http/src/Middleware/LogRequests.ts"() {
+    "use strict";
+    init_src2();
+    LogRequests = class extends Middleware {
+      static {
+        __name(this, "LogRequests");
+      }
+      async handle({ request }, next) {
+        const url = request.getEvent("url");
+        console.log(`[${request.getEvent("method")}] ${url.pathname + url.search}`);
+        return next();
+      }
+    };
+  }
+});
+
+// ../http/src/Providers/HttpServiceProvider.ts
+var import_h33, HttpServiceProvider;
+var init_HttpServiceProvider = __esm({
+  "../http/src/Providers/HttpServiceProvider.ts"() {
+    "use strict";
+    import_h33 = require("h3");
+    init_index();
+    HttpServiceProvider = class extends ServiceProvider {
+      static {
+        __name(this, "HttpServiceProvider");
+      }
+      register() {
+        this.app.singleton("http.app", () => {
+          return new import_h33.H3();
+        });
+        this.app.singleton("http.serve", () => import_h33.serve);
+      }
+    };
+  }
+});
+
+// ../http/src/Resources/JsonResource.ts
+var JsonResource;
+var init_JsonResource = __esm({
+  "../http/src/Resources/JsonResource.ts"() {
+    "use strict";
+    JsonResource = class {
+      static {
+        __name(this, "JsonResource");
+      }
+      event;
+      /**
+       * The request instance
+       */
+      request;
+      /**
+       * The response instance
+       */
+      response;
+      /**
+       * The data to send to the client
+       */
+      resource;
+      /**
+       * The final response data object
+       */
+      body = {
+        data: {}
+      };
+      /**
+       * Flag to track if response should be sent automatically
+       */
+      shouldSend = false;
+      /**
+       * Flag to track if response has been sent
+       */
+      responseSent = false;
+      /**
+       * @param req The request instance
+       * @param res The response instance
+       * @param rsc The data to send to the client
+       */
+      constructor(event, rsc) {
+        this.event = event;
+        this.request = event.req;
+        this.response = event.res;
+        this.resource = rsc;
+        for (const key of Object.keys(rsc)) {
+          if (!(key in this)) {
+            Object.defineProperty(this, key, {
+              enumerable: true,
+              configurable: true,
+              get: /* @__PURE__ */ __name(() => this.resource[key], "get"),
+              set: /* @__PURE__ */ __name((value) => {
+                this.resource[key] = value;
+              }, "set")
+            });
+          }
+        }
+      }
+      /**
+       * Return the data in the expected format
+       * 
+       * @returns 
+       */
+      data() {
+        return this.resource;
+      }
+      /**
+       * Build the response object
+       * @returns this
+       */
+      json() {
+        this.shouldSend = true;
+        this.response.status = 200;
+        const resource = this.data();
+        let data = Array.isArray(resource) ? [
+          ...resource
+        ] : {
+          ...resource
+        };
+        if (typeof data.data !== "undefined") {
+          data = data.data;
+        }
+        if (!Array.isArray(resource)) {
+          delete data.pagination;
+        }
+        this.body = {
+          data
+        };
+        if (!Array.isArray(resource) && resource.pagination) {
+          const meta = this.body.meta ?? {};
+          meta.pagination = resource.pagination;
+          this.body.meta = meta;
+        }
+        if (this.resource.pagination && !this.body.meta?.pagination) {
+          const meta = this.body.meta ?? {};
+          meta.pagination = this.resource.pagination;
+          this.body.meta = meta;
+        }
+        return this;
+      }
+      /**
+       * Add context data to the response object
+       * @param data Context data
+       * @returns this
+       */
+      additional(data) {
+        this.shouldSend = true;
+        delete data.data;
+        delete data.pagination;
+        this.body = {
+          ...this.body,
+          ...data
+        };
+        return this;
+      }
+      /**
+       * Send the output to the client
+       * @returns this
+       */
+      send() {
+        this.shouldSend = false;
+        if (!this.responseSent) {
+          this.#send();
+        }
+        return this;
+      }
+      /**
+       * Set the status code for this response
+       * @param code Status code
+       * @returns this
+       */
+      status(code) {
+        this.response.status = code;
+        return this;
+      }
+      /**
+       * Private method to send the response
+       */
+      #send() {
+        if (!this.responseSent) {
+          this.event.context.this.response.json(this.body);
+          this.responseSent = true;
+        }
+      }
+      /**
+       * Check if send should be triggered automatically
+       */
+      checkSend() {
+        if (this.shouldSend && !this.responseSent) {
+          this.#send();
+        }
+      }
+    };
+  }
+});
+
+// ../http/src/Resources/ApiResource.ts
+function ApiResource(instance) {
+  return new Proxy(instance, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        if (prop === "json" || prop === "additional") {
+          return (...args) => {
+            const result = value.apply(target, args);
+            setImmediate(() => target["checkSend"]());
+            return result;
+          };
+        } else if (prop === "send") {
+          return (...args) => {
+            target["shouldSend"] = false;
+            return value.apply(target, args);
+          };
+        }
+      }
+      return value;
+    }
+  });
+}
+var init_ApiResource = __esm({
+  "../http/src/Resources/ApiResource.ts"() {
+    "use strict";
+    init_JsonResource();
+    __name(ApiResource, "ApiResource");
+  }
+});
+
+// ../http/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ApiResource: () => ApiResource,
+  HttpServiceProvider: () => HttpServiceProvider,
+  JsonResource: () => JsonResource,
+  LogRequests: () => LogRequests,
+  Middleware: () => Middleware,
+  Request: () => Request,
+  Response: () => Response
+});
+var init_src2 = __esm({
+  "../http/src/index.ts"() {
+    "use strict";
+    init_Middleware();
+    init_Request();
+    init_Response();
+    init_ControllerContracts();
+    init_HttpContract();
+    init_LogRequests();
+    init_HttpServiceProvider();
+    init_ApiResource();
+    init_JsonResource();
+  }
+});
+
+// ../config/src/ConfigRepository.ts
+var import_node_path, import_promises, ConfigRepository;
+var init_ConfigRepository = __esm({
+  "../config/src/ConfigRepository.ts"() {
+    "use strict";
+    init_src();
+    import_node_path = __toESM(require("path"), 1);
+    import_promises = require("fs/promises");
+    ConfigRepository = class {
+      static {
+        __name(this, "ConfigRepository");
+      }
+      app;
+      loaded = false;
+      configs = {};
+      constructor(app) {
+        this.app = app;
+      }
+      get(key, def) {
+        return safeDot(this.configs, key) ?? def;
+      }
+      /**
+       * Modify the defined configurations
+       */
+      set(key, value) {
+        setNested(this.configs, key, value);
+      }
+      async load() {
+        if (!this.loaded) {
+          const configPath = this.app.getPath("config");
+          const files = await (0, import_promises.readdir)(configPath);
+          for (let i = 0; i < files.length; i++) {
+            const configModule = await import(import_node_path.default.join(configPath, files[i]));
+            const name = files[i].replaceAll(/.ts|js/g, "");
+            if (typeof configModule.default === "function") {
+              this.configs[name] = configModule.default(this.app);
+            }
+          }
+          this.loaded = true;
+        }
+        return this;
+      }
+    };
+  }
+});
+
+// ../config/src/EnvLoader.ts
+var EnvLoader;
+var init_EnvLoader = __esm({
+  "../config/src/EnvLoader.ts"() {
+    "use strict";
+    init_src();
+    EnvLoader = class {
+      static {
+        __name(this, "EnvLoader");
+      }
+      _app;
+      constructor(_app) {
+        this._app = _app;
+      }
+      get(key, def) {
+        return safeDot(process.env, key) ?? def;
+      }
+    };
+  }
+});
+
+// ../config/src/Helpers.ts
+var init_Helpers = __esm({
+  "../config/src/Helpers.ts"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/dotenv@17.2.1/node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "../../node_modules/.pnpm/dotenv@17.2.1/node_modules/dotenv/package.json"(exports2, module2) {
+    module2.exports = {
+      name: "dotenv",
+      version: "17.2.1",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          types: "./lib/main.d.ts",
+          require: "./lib/main.js",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap run --allow-empty-coverage --disable-coverage --timeout=60000",
+        "test:coverage": "tap run --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      homepage: "https://github.com/motdotla/dotenv#readme",
+      funding: "https://dotenvx.com",
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@types/node": "^18.11.3",
+        decache: "^4.6.2",
+        sinon: "^14.0.1",
+        standard: "^17.0.0",
+        "standard-version": "^9.5.0",
+        tap: "^19.2.0",
+        typescript: "^4.8.4"
+      },
+      engines: {
+        node: ">=12"
+      },
+      browser: {
+        fs: false
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/dotenv@17.2.1/node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/.pnpm/dotenv@17.2.1/node_modules/dotenv/lib/main.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path4 = require("path");
+    var os = require("os");
+    var crypto = require("crypto");
+    var packageJson = require_package();
+    var version = packageJson.version;
+    var TIPS = [
+      "\u{1F510} encrypt with Dotenvx: https://dotenvx.com",
+      "\u{1F510} prevent committing .env to code: https://dotenvx.com/precommit",
+      "\u{1F510} prevent building .env in docker: https://dotenvx.com/prebuild",
+      "\u{1F4E1} observe env with Radar: https://dotenvx.com/radar",
+      "\u{1F4E1} auto-backup env with Radar: https://dotenvx.com/radar",
+      "\u{1F4E1} version env with Radar: https://dotenvx.com/radar",
+      "\u{1F6E0}\uFE0F  run anywhere with `dotenvx run -- yourcommand`",
+      "\u2699\uFE0F  specify custom .env file path with { path: '/custom/path/.env' }",
+      "\u2699\uFE0F  enable debug logging with { debug: true }",
+      "\u2699\uFE0F  override existing env vars with { override: true }",
+      "\u2699\uFE0F  suppress all logs with { quiet: true }",
+      "\u2699\uFE0F  write to custom object with { processEnv: myObject }",
+      "\u2699\uFE0F  load multiple .env files with { path: ['.env.local', '.env'] }"
+    ];
+    function _getRandomTip() {
+      return TIPS[Math.floor(Math.random() * TIPS.length)];
+    }
+    __name(_getRandomTip, "_getRandomTip");
+    function parseBoolean(value) {
+      if (typeof value === "string") {
+        return ![
+          "false",
+          "0",
+          "no",
+          "off",
+          ""
+        ].includes(value.toLowerCase());
+      }
+      return Boolean(value);
+    }
+    __name(parseBoolean, "parseBoolean");
+    function supportsAnsi() {
+      return process.stdout.isTTY;
+    }
+    __name(supportsAnsi, "supportsAnsi");
+    function dim(text) {
+      return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+    }
+    __name(dim, "dim");
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    __name(parse, "parse");
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    __name(_parseVault, "_parseVault");
+    function _warn(message) {
+      console.error(`[dotenv@${version}][WARN] ${message}`);
+    }
+    __name(_warn, "_warn");
+    function _debug(message) {
+      console.log(`[dotenv@${version}][DEBUG] ${message}`);
+    }
+    __name(_debug, "_debug");
+    function _log(message) {
+      console.log(`[dotenv@${version}] ${message}`);
+    }
+    __name(_log, "_log");
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    __name(_dotenvKey, "_dotenvKey");
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return {
+        ciphertext,
+        key
+      };
+    }
+    __name(_instructions, "_instructions");
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path4.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    __name(_vaultPath, "_vaultPath");
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path4.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    __name(_resolveHome, "_resolveHome");
+    function _configVault(options) {
+      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (debug || !quiet) {
+        _log("Loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return {
+        parsed
+      };
+    }
+    __name(_configVault, "_configVault");
+    function configDotenv(options) {
+      const dotenvPath = path4.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("No encoding is specified. UTF-8 is used by default");
+        }
+      }
+      let optionPaths = [
+        dotenvPath
+      ];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [
+            _resolveHome(options.path)
+          ];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path5 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs.readFileSync(path5, {
+            encoding
+          }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`Failed to load ${path5} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      const populated = DotenvModule.populate(processEnv, parsedAll, options);
+      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(populated).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative = path4.relative(process.cwd(), filePath);
+            shortPaths.push(relative);
+          } catch (e) {
+            if (debug) {
+              _debug(`Failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+      }
+      if (lastError) {
+        return {
+          parsed: parsedAll,
+          error: lastError
+        };
+      } else {
+        return {
+          parsed: parsedAll
+        };
+      }
+    }
+    __name(configDotenv, "configDotenv");
+    function config(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    __name(config, "config");
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    __name(decrypt, "decrypt");
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      const populated = {};
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+            populated[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+      }
+      return populated;
+    }
+    __name(populate, "populate");
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config,
+      decrypt,
+      parse,
+      populate
+    };
+    module2.exports.configDotenv = DotenvModule.configDotenv;
+    module2.exports._configVault = DotenvModule._configVault;
+    module2.exports._parseVault = DotenvModule._parseVault;
+    module2.exports.config = DotenvModule.config;
+    module2.exports.decrypt = DotenvModule.decrypt;
+    module2.exports.parse = DotenvModule.parse;
+    module2.exports.populate = DotenvModule.populate;
+    module2.exports = DotenvModule;
+  }
+});
+
+// ../config/src/Providers/ConfigServiceProvider.ts
+var import_dotenv, ConfigServiceProvider;
+var init_ConfigServiceProvider = __esm({
+  "../config/src/Providers/ConfigServiceProvider.ts"() {
+    "use strict";
+    init_index();
+    init_src3();
+    import_dotenv = __toESM(require_main(), 1);
+    ConfigServiceProvider = class extends ServiceProvider {
+      static {
+        __name(this, "ConfigServiceProvider");
+      }
+      async register() {
+        (0, import_dotenv.config)();
+        this.app.singleton("env", () => {
+          return new EnvLoader(this.app).get;
+        });
+        const repo = new ConfigRepository(this.app);
+        await repo.load();
+        this.app.singleton("config", () => {
+          return {
+            get: /* @__PURE__ */ __name((key, def) => repo.get(key, def), "get"),
+            set: repo.set
+          };
+        });
+        this.app.make("http.app").use((e) => {
+          repo.set("app.url", e.url.origin);
+        });
+      }
+    };
+  }
+});
+
+// ../config/src/index.ts
+var src_exports2 = {};
+__export(src_exports2, {
+  ConfigRepository: () => ConfigRepository,
+  ConfigServiceProvider: () => ConfigServiceProvider,
+  EnvLoader: () => EnvLoader
+});
+var init_src3 = __esm({
+  "../config/src/index.ts"() {
+    "use strict";
+    init_ConfigRepository();
+    init_EnvLoader();
+    init_Helpers();
+    init_ConfigServiceProvider();
+  }
+});
+
+// ../router/src/Controller.ts
+var init_Controller = __esm({
+  "../router/src/Controller.ts"() {
+    "use strict";
+  }
+});
+
+// ../router/src/Route.ts
+var init_Route = __esm({
+  "../router/src/Route.ts"() {
+    "use strict";
+  }
+});
+
+// ../router/src/Router.ts
+var Router;
+var init_Router = __esm({
+  "../router/src/Router.ts"() {
+    "use strict";
+    init_index();
+    init_src();
+    Router = class {
+      static {
+        __name(this, "Router");
+      }
+      h3App;
+      app;
+      routes = [];
+      groupPrefix = "";
+      groupMiddleware = [];
+      constructor(h3App, app) {
+        this.h3App = h3App;
+        this.app = app;
+      }
+      /**
+       * Route Resolver
+       * 
+       * @param handler 
+       * @param middleware 
+       * @returns 
+       */
+      resolveHandler(handler, middleware = []) {
+        return async (event) => {
+          const kernel = new Kernel(middleware);
+          return kernel.handle(event, (ctx) => Promise.resolve(handler(ctx)));
+        };
+      }
+      /**
+       * Add a route to the stack
+       * 
+       * @param method 
+       * @param path 
+       * @param handler 
+       * @param name 
+       * @param middleware 
+       */
+      addRoute(method, path4, handler, name, middleware = []) {
+        const fullPath = `${this.groupPrefix}${path4}`.replace(/\/+/g, "/");
+        this.routes.push({
+          method,
+          path: fullPath,
+          name,
+          handler
+        });
+        this.h3App[method](fullPath, this.resolveHandler(handler, middleware));
+      }
+      resolveControllerOrHandler(handler, methodName) {
+        if (typeof handler === "function" && handler.prototype instanceof Controller) {
+          return (ctx) => {
+            const controller = new handler(this.app);
+            const action = methodName || "index";
+            if (typeof controller[action] !== "function") {
+              throw new Error(`Method "${action}" not found on controller ${handler.name}`);
+            }
+            return controller[action](ctx);
+          };
+        }
+        return handler;
+      }
+      get(path4, handler, methodName, name, middleware = []) {
+        this.addRoute("get", path4, this.resolveControllerOrHandler(handler, methodName), name, middleware);
+      }
+      post(path4, handler, methodName, name, middleware = []) {
+        this.addRoute("post", path4, this.resolveControllerOrHandler(handler, methodName), name, middleware);
+      }
+      put(path4, handler, methodName, name, middleware = []) {
+        this.addRoute("put", path4, this.resolveControllerOrHandler(handler, methodName), name, middleware);
+      }
+      delete(path4, handler, methodName, name, middleware = []) {
+        this.addRoute("delete", path4, this.resolveControllerOrHandler(handler, methodName), name, middleware);
+      }
+      /**
+       * API Resource support  
+       * 
+       * @param path 
+       * @param controller 
+       */
+      apiResource(path4, Controller2, middleware = []) {
+        path4 = path4.replace(/\//g, "/");
+        const name = afterLast(path4, "/");
+        const basePath = `/${path4}`.replace(/\/+/g, "/");
+        const controller = new Controller2(this.app);
+        this.addRoute("get", basePath, controller.index.bind(controller), `${name}.index`, middleware);
+        this.addRoute("post", basePath, controller.store.bind(controller), `${name}.store`, middleware);
+        this.addRoute("get", `${basePath}/:id`, controller.show.bind(controller), `${name}.show`, middleware);
+        this.addRoute("put", `${basePath}/:id`, controller.update.bind(controller), `${name}.update`, middleware);
+        this.addRoute("patch", `${basePath}/:id`, controller.update.bind(controller), `${name}.update`, middleware);
+        this.addRoute("delete", `${basePath}/:id`, controller.destroy.bind(controller), `${name}.destroy`, middleware);
+      }
+      /**
+       * Named route URL generator
+       * 
+       * @param name 
+       * @param params 
+       * @returns 
+       */
+      route(name, params = {}) {
+        const found = this.routes.find((r) => r.name === name);
+        if (!found) return void 0;
+        let url = found.path;
+        for (const [key, value] of Object.entries(params)) {
+          url = url.replace(`:${key}`, value);
+        }
+        return url;
+      }
+      /**
+       * Grouping
+       * 
+       * @param options 
+       * @param callback 
+       */
+      group(options, callback) {
+        const prevPrefix = this.groupPrefix;
+        const prevMiddleware = [
+          ...this.groupMiddleware
+        ];
+        this.groupPrefix += options.prefix || "";
+        this.groupMiddleware.push(...options.middleware || []);
+        callback();
+        this.groupPrefix = prevPrefix;
+        this.groupMiddleware = prevMiddleware;
+      }
+      middleware(path4, handler, opts) {
+        this.h3App.use(path4, handler, opts);
+      }
+    };
+  }
+});
+
+// ../router/src/Decorators/ApiResource.ts
+var init_ApiResource2 = __esm({
+  "../router/src/Decorators/ApiResource.ts"() {
+    "use strict";
+  }
+});
+
+// ../router/src/Decorators/Controller.ts
+var init_Controller2 = __esm({
+  "../router/src/Decorators/Controller.ts"() {
+    "use strict";
+  }
+});
+
+// ../router/src/Decorators/Get.ts
+var init_Get = __esm({
+  "../router/src/Decorators/Get.ts"() {
+    "use strict";
+  }
+});
+
+// ../router/src/Decorators/Middleware.ts
+var init_Middleware2 = __esm({
+  "../router/src/Decorators/Middleware.ts"() {
+    "use strict";
+  }
+});
+
+// ../router/src/Decorators/Post.ts
+var init_Post = __esm({
+  "../router/src/Decorators/Post.ts"() {
+    "use strict";
+  }
+});
+
+// ../router/src/Providers/AssetsServiceProvider.ts
+var import_promises2, import_node_path2, import_h34, import_node_fs, AssetsServiceProvider;
+var init_AssetsServiceProvider = __esm({
+  "../router/src/Providers/AssetsServiceProvider.ts"() {
+    "use strict";
+    import_promises2 = require("fs/promises");
+    init_index();
+    init_src();
+    import_node_path2 = require("path");
+    import_h34 = require("h3");
+    import_node_fs = require("fs");
+    AssetsServiceProvider = class extends ServiceProvider {
+      static {
+        __name(this, "AssetsServiceProvider");
+      }
+      register() {
+        const app = this.app.make("router");
+        const config = this.app.make("config");
+        const fsconfig = config.get("filesystem");
+        const publicPath = this.app.getPath("public");
+        app.middleware(`/${fsconfig.public_mask}/**`, (event) => {
+          return (0, import_h34.serveStatic)(event, {
+            indexNames: [
+              "/index.html"
+            ],
+            getContents: /* @__PURE__ */ __name((id) => {
+              const newId = id.replace(`/${fsconfig.public_mask}/`, "");
+              return (0, import_promises2.readFile)((0, import_node_path2.join)(before(publicPath, newId), newId));
+            }, "getContents"),
+            getMeta: /* @__PURE__ */ __name(async (id) => {
+              const newId = id.replace(`/${fsconfig.public_mask}/`, "");
+              const stats = await (0, import_promises2.stat)((0, import_node_path2.join)(before(publicPath, newId), newId)).catch(() => {
+              });
+              if (stats?.isFile()) {
+                return {
+                  size: stats.size,
+                  mtime: stats.mtimeMs
+                };
+              }
+            }, "getMeta")
+          });
+        });
+        this.app.singleton("asset", () => {
+          return (key, def = "") => {
+            try {
+              (0, import_node_fs.statSync)((0, import_node_path2.join)(before(publicPath, key), key));
+            } catch {
+              key = def;
+            }
+            return (0, import_node_path2.join)(fsconfig.public_mask, key);
+          };
+        });
+      }
+    };
+  }
+});
+
+// ../router/src/Providers/RouteServiceProvider.ts
+var import_node_path3, import_promises3, RouteServiceProvider;
+var init_RouteServiceProvider = __esm({
+  "../router/src/Providers/RouteServiceProvider.ts"() {
+    "use strict";
+    init_Router();
+    init_index();
+    import_node_path3 = __toESM(require("path"), 1);
+    import_promises3 = require("fs/promises");
+    RouteServiceProvider = class extends ServiceProvider {
+      static {
+        __name(this, "RouteServiceProvider");
+      }
+      register() {
+        this.app.singleton("router", () => {
+          const h3App = this.app.make("http.app");
+          return new Router(h3App, this.app);
+        });
+      }
+      /**
+       * Load routes from src/routes
+       */
+      async boot() {
+        try {
+          const routePath = this.app.getPath("routes");
+          const files = await (0, import_promises3.readdir)(routePath);
+          for (let i = 0; i < files.length; i++) {
+            const routesModule = await import(import_node_path3.default.join(routePath, files[i]));
+            if (typeof routesModule.default === "function") {
+              const router = this.app.make("router");
+              routesModule.default(router);
+            }
+          }
+        } catch (e) {
+          console.warn("No web routes found or failed to load:", e);
+        }
+      }
+    };
+  }
+});
+
+// ../router/src/index.ts
+var src_exports3 = {};
+__export(src_exports3, {
+  AssetsServiceProvider: () => AssetsServiceProvider,
+  RouteServiceProvider: () => RouteServiceProvider,
+  Router: () => Router
+});
+var init_src4 = __esm({
+  "../router/src/index.ts"() {
+    "use strict";
+    init_Controller();
+    init_Route();
+    init_Router();
+    init_ApiResource2();
+    init_Controller2();
+    init_Get();
+    init_Middleware2();
+    init_Post();
+    init_AssetsServiceProvider();
+    init_RouteServiceProvider();
+  }
+});
+
+// src/Application.ts
+var import_node_path4, Application;
+var init_Application = __esm({
+  "src/Application.ts"() {
+    "use strict";
+    init_Container();
+    init_PathLoader();
+    import_node_path4 = __toESM(require("path"), 1);
+    Application = class _Application extends Container {
+      static {
+        __name(this, "Application");
+      }
+      paths = new 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();
+      }
+      /**
+       * Register core bindings into the container
+       */
+      registerBaseBindings() {
+        this.bind(_Application, () => this);
+        this.bind("path.base", () => this.basePath);
+        this.bind("app.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))).AppServiceProvider,
+          (await Promise.resolve().then(() => (init_src2(), src_exports))).HttpServiceProvider,
+          (await Promise.resolve().then(() => (init_src3(), src_exports2))).ConfigServiceProvider,
+          (await Promise.resolve().then(() => (init_src4(), src_exports3))).RouteServiceProvider,
+          (await Promise.resolve().then(() => (init_src4(), src_exports3))).AssetsServiceProvider,
+          (await Promise.resolve().then(() => (init_index(), index_exports))).ViewServiceProvider,
+          (await this.safeImport("@h3ravel/database"))?.DatabaseServiceProvider,
+          (await this.safeImport("@h3ravel/cache"))?.CacheServiceProvider,
+          (await this.safeImport("@h3ravel/console"))?.ConsoleServiceProvider,
+          (await this.safeImport("@h3ravel/queue"))?.QueueServiceProvider,
+          (await this.safeImport("@h3ravel/mail"))?.MailServiceProvider
+        ];
+      }
+      async getAllProviders() {
+        const coreProviders = await this.getConfiguredProviders();
+        return [
+          ...coreProviders,
+          ...this.externalProviders
+        ];
+      }
+      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_path4.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, path4) {
+        return this.paths.setPath(name, path4, this.basePath);
+      }
+      /**
+       * Returns the installed version of the system core and typescript.
+       *
+       * @returns 
+       */
+      getVersion(key) {
+        return this.versions[key]?.replaceAll(/\^|\~/g, "");
+      }
+    };
+  }
+});
+
+// src/Controller.ts
+var Controller;
+var init_Controller3 = __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;
+      }
+    };
+  }
+});
+
+// src/ServiceProvider.ts
+var ServiceProvider;
+var init_ServiceProvider = __esm({
+  "src/ServiceProvider.ts"() {
+    "use strict";
+    ServiceProvider = class {
+      static {
+        __name(this, "ServiceProvider");
+      }
+      app;
+      constructor(app) {
+        this.app = app;
+      }
+    };
+  }
+});
+
+// src/Contracts/BindingsContract.ts
+var init_BindingsContract = __esm({
+  "src/Contracts/BindingsContract.ts"() {
+    "use strict";
+  }
+});
+
+// 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";
+    init_src2();
+    Kernel = class {
+      static {
+        __name(this, "Kernel");
+      }
+      middleware;
+      constructor(middleware = []) {
+        this.middleware = middleware;
+      }
+      async handle(event, next) {
+        const context = {
+          request: new Request(event),
+          response: new Response(event)
+        };
+        const result = await this.runMiddleware(context, () => next(context));
+        if (result !== void 0 && this.isPlainObject(result)) {
+          event.res.headers.set("Content-Type", "application/json; charset=UTF-8");
+        }
+        return 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);
+      }
+      isPlainObject(value) {
+        return typeof value === "object" && value !== null && (value.constructor === Object || value.constructor === Array);
+      }
+    };
+  }
+});
+
+// src/Providers/AppServiceProvider.ts
+var import_reflect_metadata, AppServiceProvider;
+var init_AppServiceProvider = __esm({
+  "src/Providers/AppServiceProvider.ts"() {
+    "use strict";
+    import_reflect_metadata = require("reflect-metadata");
+    init_ServiceProvider();
+    AppServiceProvider = class extends ServiceProvider {
+      static {
+        __name(this, "AppServiceProvider");
+      }
+      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_index();
+    ViewServiceProvider = class extends ServiceProvider {
+      static {
+        __name(this, "ViewServiceProvider");
+      }
+      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("view", () => edge);
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AppServiceProvider: () => AppServiceProvider,
+  Application: () => Application,
+  Container: () => Container,
+  Controller: () => Controller,
+  Kernel: () => Kernel,
+  PathLoader: () => PathLoader,
+  ServiceProvider: () => ServiceProvider,
+  ViewServiceProvider: () => ViewServiceProvider
+});
+module.exports = __toCommonJS(index_exports);
+var init_index = __esm({
+  "src/index.ts"() {
+    init_Application();
+    init_Container();
+    init_Controller3();
+    init_ServiceProvider();
+    init_BindingsContract();
+    init_Handler();
+    init_Kernel();
+    init_AppServiceProvider();
+    init_ViewServiceProvider();
+    init_PathLoader();
+  }
+});
+init_index();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppServiceProvider,
+  Application,
+  Container,
+  Controller,
+  Kernel,
+  PathLoader,
+  ServiceProvider,
+  ViewServiceProvider
+});
+//# sourceMappingURL=index.cjs.map