@gravito/core 2.0.6 → 3.0.1

package/dist/index.js

@@ -1552,12 +1552,23 @@ var randomBytes = randomBytesFn;
 import { createHash, createHmac } from "crypto";
 
 class HashFallback {
+  blake2bWarned = false;
   sha256(input) {
     return createHash("sha256").update(input).digest("hex");
   }
   hmacSha256(key, data) {
     return createHmac("sha256", key).update(data).digest("hex");
   }
+  sha512(input) {
+    return createHash("sha512").update(input).digest("hex");
+  }
+  blake2b(input) {
+    if (!this.blake2bWarned) {
+      console.warn("[gravito] BLAKE2b not available in node:crypto \u2014 using SHA-256 fallback");
+      this.blake2bWarned = true;
+    }
+    return createHash("sha256").update(input).digest("hex");
+  }
 }
 
 // src/ffi/NativeHasher.ts
@@ -1568,6 +1579,12 @@ class BunCryptoHasher {
   hmacSha256(key, data) {
     return new Bun.CryptoHasher("sha256", key).update(data).digest("hex");
   }
+  sha512(input) {
+    return new Bun.CryptoHasher("sha512").update(input).digest("hex");
+  }
+  blake2b(input) {
+    return new Bun.CryptoHasher("blake2b256").update(input).digest("hex");
+  }
 }
 
 class NativeHasher {
@@ -1601,6 +1618,12 @@ class NativeHasher {
       runtime
     };
   }
+  static sha512(input) {
+    return this.getAccelerator().sha512(input);
+  }
+  static blake2b(input) {
+    return this.getAccelerator().blake2b(input);
+  }
   static sha256(input) {
     return this.getAccelerator().sha256(input);
   }
@@ -1648,6 +1671,7 @@ class RadixNode {
   paramChild = null;
   wildcardChild = null;
   handlers = new Map;
+  options = new Map;
   paramName = null;
   regex = null;
   constructor(segment = "", type = 0 /* STATIC */) {
@@ -1661,13 +1685,15 @@ class RadixNode {
       children: Array.from(this.children.entries()).map(([k, v]) => [k, v.toJSON()]),
       paramChild: this.paramChild?.toJSON() || null,
       wildcardChild: this.wildcardChild?.toJSON() || null,
+      handlers: Array.from(this.handlers.entries()),
+      options: Array.from(this.options.entries()),
       paramName: this.paramName,
       regex: this.regex ? this.regex.source : null
     };
   }
   static fromJSON(json) {
     const node = new RadixNode(json.segment, json.type);
-    node.paramName = json.paramName;
+    node.paramName = json.paramName ?? null;
     if (json.regex) {
       node.regex = new RegExp(json.regex);
     }
@@ -1682,6 +1708,16 @@ class RadixNode {
     if (json.wildcardChild) {
       node.wildcardChild = RadixNode.fromJSON(json.wildcardChild);
     }
+    if (json.handlers) {
+      for (const [method, handlers] of json.handlers) {
+        node.handlers.set(method, handlers);
+      }
+    }
+    if (json.options) {
+      for (const [method, options2] of json.options) {
+        node.options.set(method, options2);
+      }
+    }
     return node;
   }
 }
@@ -1717,7 +1753,7 @@ class RadixRouter {
   where(param, regex) {
     this.globalConstraints.set(param, regex);
   }
-  add(method, path2, handlers) {
+  add(method, path2, handlers, options2) {
     let node = this.root;
     const segments = this.splitPath(path2);
     for (let i = 0;i < segments.length; i++) {
@@ -1747,7 +1783,11 @@ class RadixRouter {
         node = node.children.get(segment);
       }
     }
-    node.handlers.set(method.toLowerCase(), handlers);
+    const normalizedMethod = method.toLowerCase();
+    node.handlers.set(normalizedMethod, handlers);
+    if (options2) {
+      node.options.set(normalizedMethod, options2);
+    }
     this.routeCache.clear();
   }
   match(method, path2) {
@@ -1755,7 +1795,7 @@ class RadixRouter {
     if (path2 === "/" || path2 === "") {
       const handlers = this.root.handlers.get(normalizedMethod);
       if (handlers) {
-        return { handlers, params: {} };
+        return { handlers, params: {}, options: this.root.options.get(normalizedMethod) };
       }
       return null;
     }
@@ -1772,11 +1812,13 @@ class RadixRouter {
   matchRecursive(node, segments, depth, params, method) {
     if (depth >= segments.length) {
       let handlers = node.handlers.get(method);
+      let options2 = node.options.get(method);
       if (!handlers) {
         handlers = node.handlers.get("all");
+        options2 = node.options.get("all");
       }
       if (handlers) {
-        return { handlers, params };
+        return { handlers, params, options: options2 };
       }
       return null;
     }
@@ -1803,11 +1845,13 @@ class RadixRouter {
     }
     if (node.wildcardChild) {
       let handlers = node.wildcardChild.handlers.get(method);
+      let options2 = node.wildcardChild.options.get(method);
       if (!handlers) {
         handlers = node.wildcardChild.handlers.get("all");
+        options2 = node.wildcardChild.options.get("all");
       }
       if (handlers) {
-        return { handlers, params };
+        return { handlers, params, options: options2 };
       }
     }
     return null;
@@ -2289,7 +2333,7 @@ class RequestScopeManager {
     let servicesCleaned = 0;
     for (const [, instance] of this.scoped) {
       if (instance && typeof instance === "object" && "cleanup" in instance) {
-        const fn = instance.cleanup;
+        const fn = instance["cleanup"];
         if (typeof fn === "function") {
           try {
             await fn.call(instance);
@@ -3300,7 +3344,7 @@ class Gravito {
 // package.json
 var package_default = {
   name: "@gravito/core",
-  version: "2.0.6",
+  version: "3.0.1",
   description: "",
   module: "./dist/index.js",
   main: "./dist/index.js",
@@ -3309,9 +3353,9 @@ var package_default = {
   types: "./dist/index.d.ts",
   exports: {
     ".": {
+      types: "./dist/index.d.ts",
       browser: "./dist/index.browser.js",
       bun: "./dist/index.js",
-      types: "./dist/index.d.ts",
       default: "./dist/index.js"
     },
     "./compat": {
@@ -3357,7 +3401,8 @@ var package_default = {
     typecheck: "bun tsc -p tsconfig.json --noEmit --skipLibCheck",
     prepublishOnly: "bun run typecheck && bun run test && bun run build",
     "test:unit": "bun test $(find tests -name '*.test.ts' ! -name '*.integration.test.ts' 2>/dev/null | tr '\\n' ' ') --timeout=10000",
-    "test:integration": "test $(find tests -name '*.integration.test.ts' 2>/dev/null | wc -l) -gt 0 && find tests -name '*.integration.test.ts' -print0 | xargs -0 bun test --timeout=10000 || echo 'No integration tests found'"
+    "test:integration": "test $(find tests -name '*.integration.test.ts' 2>/dev/null | wc -l) -gt 0 && find tests -name '*.integration.test.ts' -print0 | xargs -0 bun test --timeout=10000 || echo 'No integration tests found'",
+    publint: "publint"
   },
   keywords: [],
   author: "Carl Lee <carllee0520@gmail.com>",
@@ -3755,6 +3800,250 @@ class BunWebSocketHandler {
   }
 }
 
+// src/adapters/bun/FastPathRegistry.ts
+class FastPathRegistry {
+  routes = new Map;
+  register(method, path2, handler) {
+    const upperMethod = method.toUpperCase();
+    let methodRoutes = this.routes.get(upperMethod);
+    if (!methodRoutes) {
+      methodRoutes = new Map;
+      this.routes.set(upperMethod, methodRoutes);
+    }
+    methodRoutes.set(path2, handler);
+  }
+  match(method, path2) {
+    const methodRoutes = this.routes.get(method.toUpperCase());
+    if (!methodRoutes) {
+      return;
+    }
+    return methodRoutes.get(path2);
+  }
+  getAll() {
+    return this.routes;
+  }
+}
+
+// src/exceptions/GravitoException.ts
+class GravitoException extends Error {
+  status;
+  code;
+  i18nKey;
+  i18nParams;
+  constructor(status, code, options2 = {}) {
+    super(options2.message);
+    this.name = "GravitoException";
+    this.status = status;
+    this.cause = options2.cause;
+    this.code = code;
+    if (options2.i18nKey) {
+      this.i18nKey = options2.i18nKey;
+    }
+    if (options2.i18nParams) {
+      this.i18nParams = options2.i18nParams;
+    }
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  getLocalizedMessage(t) {
+    if (this.i18nKey) {
+      return t(this.i18nKey, this.i18nParams);
+    }
+    return this.message;
+  }
+}
+
+// src/exceptions/DomainException.ts
+class DomainException extends GravitoException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "DomainException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/AuthException.ts
+class AuthException extends DomainException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "AuthException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/AuthenticationException.ts
+class AuthenticationException extends DomainException {
+  constructor(message = "Unauthenticated.") {
+    super(401, "UNAUTHENTICATED", {
+      message,
+      i18nKey: "errors.authentication.unauthenticated"
+    });
+    this.name = "AuthenticationException";
+  }
+}
+
+// src/exceptions/AuthorizationException.ts
+class AuthorizationException extends DomainException {
+  constructor(message = "This action is unauthorized.") {
+    super(403, "FORBIDDEN", {
+      message,
+      i18nKey: "errors.authorization.forbidden"
+    });
+    this.name = "AuthorizationException";
+  }
+}
+
+// src/exceptions/InfrastructureException.ts
+class InfrastructureException extends GravitoException {
+  retryable;
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "InfrastructureException";
+    this.retryable = options2.retryable ?? false;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/CacheException.ts
+class CacheException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "CacheException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/SystemException.ts
+class SystemException extends GravitoException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "SystemException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/CircularDependencyException.ts
+class CircularDependencyException extends SystemException {
+  constructor(key, stack) {
+    const path2 = [...stack, key].map(String).join(" -> ");
+    super(500, "system.circular_dependency", {
+      message: `Circular dependency detected: ${path2}`
+    });
+    this.name = "CircularDependencyException";
+  }
+}
+
+// src/exceptions/ConfigurationException.ts
+class ConfigurationException extends SystemException {
+  constructor(message, options2 = {}) {
+    super(500, "system.configuration_error", { ...options2, message });
+    this.name = "ConfigurationException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/ContainerBindingCollisionException.ts
+class ContainerBindingCollisionException extends SystemException {
+  constructor(message, options2 = {}) {
+    super(500, "system.container_binding_collision", { ...options2, message });
+    this.name = "ContainerBindingCollisionException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/DatabaseException.ts
+class DatabaseException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "DatabaseException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/HttpException.ts
+class HttpException extends GravitoException {
+  constructor(status, options2 = {}) {
+    super(status, "HTTP_ERROR", options2);
+    this.name = "HttpException";
+  }
+}
+
+// src/exceptions/MiddlewareDriftException.ts
+class MiddlewareDriftException extends SystemException {
+  constructor(message, options2 = {}) {
+    super(500, "system.middleware_drift", { ...options2, message });
+    this.name = "MiddlewareDriftException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/ModelNotFoundException.ts
+class ModelNotFoundException extends GravitoException {
+  model;
+  id;
+  constructor(model, id) {
+    super(404, "NOT_FOUND", {
+      message: `${model} not found.`,
+      i18nKey: "errors.model.not_found",
+      i18nParams: { model, id: String(id ?? "") }
+    });
+    this.name = "ModelNotFoundException";
+    this.model = model;
+    if (id !== undefined) {
+      this.id = id;
+    }
+  }
+}
+
+// src/exceptions/QueueException.ts
+class QueueException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "QueueException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/StorageException.ts
+class StorageException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "StorageException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/StreamException.ts
+class StreamException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "StreamException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/ValidationException.ts
+class ValidationException extends DomainException {
+  errors;
+  redirectTo;
+  input;
+  constructor(errors, message = "Validation failed") {
+    super(422, "VALIDATION_ERROR", {
+      message,
+      i18nKey: "errors.validation.failed"
+    });
+    this.name = "ValidationException";
+    this.errors = errors;
+  }
+  withRedirect(url) {
+    this.redirectTo = url;
+    return this;
+  }
+  withInput(input) {
+    this.input = input;
+    return this;
+  }
+}
+
 // src/adapters/bun/BunNativeAdapter.ts
 class BunNativeAdapter {
   name = "bun-native";
@@ -3762,7 +4051,9 @@ class BunNativeAdapter {
   get native() {
     return this;
   }
+  isSnapshotLocked = false;
   router = new RadixRouter;
+  fastPathRegistry = new FastPathRegistry;
   middlewares = [];
   errorHandler = null;
   notFoundHandler = null;
@@ -3770,22 +4061,41 @@ class BunNativeAdapter {
   maxPoolSize = 100;
   middlewareChainCache = new Map;
   wsHandler = new BunWebSocketHandler;
+  checkLock() {
+    if (this.isSnapshotLocked && true) {
+      throw new MiddlewareDriftException("FAST_PATH_MIDDLEWARE_DRIFT: Middleware or routes cannot be added after serveConfig() has been called. " + "This ensures the snapshotted configuration remains consistent with the application state.");
+    }
+  }
   route(method, path2, ...handlers) {
-    this.router.add(method, path2, handlers);
+    this.checkLock();
+    const last = handlers[handlers.length - 1];
+    let options2;
+    if (last && typeof last === "object" && !Array.isArray(last) && "excludeMiddleware" in last) {
+      options2 = handlers.pop();
+    }
+    this.router.add(method, path2, handlers, options2);
   }
   routes(routes) {
+    this.checkLock();
     for (const route of routes) {
-      this.route(route.method, route.path, ...route.handlers);
+      const options2 = {};
+      if (route.excludeMiddleware) {
+        options2.excludeMiddleware = route.excludeMiddleware;
+      }
+      this.router.add(route.method, route.path, route.handlers, Object.keys(options2).length > 0 ? options2 : undefined);
     }
   }
   use(path2, ...middleware) {
+    this.checkLock();
     this.middlewares.push({ path: path2, handlers: middleware });
     this.middlewareChainCache.clear();
   }
   useGlobal(...middleware) {
+    this.checkLock();
     this.use("*", ...middleware);
   }
   useScoped(scope, path2, ...middleware) {
+    this.checkLock();
     if (path2 === "*" || path2 === "*/*") {
       throw new Error(`useScoped(): Cannot use wildcard path '*' in Orbit-scoped middleware. ` + `Use regular use('*') for global middleware, or specify explicit paths like '${scope}/*'`);
     }
@@ -3800,6 +4110,9 @@ class BunNativeAdapter {
     if (pattern === "*") {
       return true;
     }
+    if (pattern === "/") {
+      return true;
+    }
     if (pattern.endsWith("/*")) {
       const basePattern = pattern.slice(0, -2);
       return path2 === basePattern || path2.startsWith(`${basePattern}/`);
@@ -3810,17 +4123,25 @@ class BunNativeAdapter {
     }
     return path2 === pattern || path2.startsWith(`${pattern}/`);
   }
-  getCompiledMiddlewareChain(path2) {
-    if (this.middlewareChainCache.has(path2)) {
-      return this.middlewareChainCache.get(path2);
+  getCompiledMiddlewareChain(path2, options2) {
+    const exclude = options2?.excludeMiddleware || [];
+    const cacheKey = exclude.length > 0 ? `${path2}:exclude:${exclude.sort().join(",")}` : path2;
+    if (this.middlewareChainCache.has(cacheKey)) {
+      return this.middlewareChainCache.get(cacheKey);
     }
     const chain = [];
     for (const mw of this.middlewares) {
       if (this.matchesPath(mw.path, path2)) {
-        chain.push(...mw.handlers);
+        for (const handler of mw.handlers) {
+          const name = handler.name || handler.middlewareName;
+          if (name && exclude.includes(name)) {
+            continue;
+          }
+          chain.push(handler);
+        }
       }
     }
-    this.middlewareChainCache.set(path2, chain);
+    this.middlewareChainCache.set(cacheKey, chain);
     return chain;
   }
   acquireContext(request) {
@@ -3862,12 +4183,36 @@ class BunNativeAdapter {
     return BunContext.create(request);
   }
   onError(handler) {
+    this.checkLock();
     this.errorHandler = handler;
   }
   onNotFound(handler) {
+    this.checkLock();
     this.notFoundHandler = handler;
   }
+  registerFastPath(method, path2, handler) {
+    this.checkLock();
+    this.fastPathRegistry.register(method, path2, handler);
+  }
+  serveConfig(baseConfig = {}) {
+    this.isSnapshotLocked = true;
+    const routes = {};
+    for (const [method, pathMap] of this.fastPathRegistry.getAll()) {
+      if (method === "GET") {
+        for (const [path2, handler] of pathMap) {
+          routes[path2] = handler;
+        }
+      }
+    }
+    return {
+      ...baseConfig,
+      routes,
+      fetch: this.fetch.bind(this),
+      websocket: this.websocket
+    };
+  }
   registerWebSocketRoute(path2, handlers) {
+    this.checkLock();
     this.wsHandler.register(path2, handlers);
   }
   get websocket() {
@@ -3882,7 +4227,12 @@ class BunNativeAdapter {
   }
   async fetch(request, _server) {
     const url = new URL(request.url);
-    if (_server != null && typeof _server.upgrade === "function" && request.headers.get("upgrade")?.toLowerCase() === "websocket" && this.wsHandler.hasRoute(url.pathname)) {
+    const path2 = url.pathname;
+    const fastHandler = this.fastPathRegistry.match(request.method, path2);
+    if (fastHandler) {
+      return fastHandler(request);
+    }
+    if (_server != null && typeof _server.upgrade === "function" && request.headers.get("upgrade")?.toLowerCase() === "websocket" && this.wsHandler.hasRoute(path2)) {
       const upgraded = _server.upgrade(request, {
         data: {
           path: url.pathname,
@@ -3896,11 +4246,10 @@ class BunNativeAdapter {
     }
     const ctx = this.acquireContext(request);
     try {
-      const path2 = url.pathname;
       const method = request.method;
       const match = this.router.match(method, path2);
       const handlers = [];
-      const middlewareChain = this.getCompiledMiddlewareChain(path2);
+      const middlewareChain = this.getCompiledMiddlewareChain(path2, match?.options);
       handlers.push(...middlewareChain);
       if (match) {
         if (match.params) {
@@ -4608,7 +4957,8 @@ function createNodeAdapter() {
         },
         resourceUsage: async () => {
           try {
-            const usage = child.resourceUsage?.();
+            const childWithUsage = child;
+            const usage = childWithUsage.resourceUsage?.();
             if (!usage) {
               return;
             }
@@ -4817,6 +5167,78 @@ function createUnknownAdapter() {
     }
   };
 }
+// src/runtime/NativeOrbitDetector.ts
+function probeCryptoHasher(CryptoHasherCtor, algo) {
+  try {
+    const ctor = CryptoHasherCtor;
+    new ctor(algo).update("").digest("hex");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+class NativeOrbitDetector {
+  static cached = null;
+  static detectBunCapabilities() {
+    if (this.cached !== null) {
+      return this.cached;
+    }
+    const kind2 = getRuntimeKind();
+    const B2 = globalThis.Bun;
+    if (kind2 !== "bun" || !B2) {
+      this.cached = Object.freeze({
+        runtime: kind2,
+        bunVersion: null,
+        password: Object.freeze({ available: false, argon2id: false, bcrypt: false }),
+        cryptoHasher: Object.freeze({
+          available: false,
+          sha256: false,
+          sha512: false,
+          blake2b: false
+        }),
+        glob: false
+      });
+      return this.cached;
+    }
+    const hasPassword = typeof B2.password?.hash === "function" && typeof B2.password?.verify === "function";
+    const passwordFeatures = Object.freeze({
+      available: hasPassword,
+      argon2id: hasPassword,
+      bcrypt: hasPassword
+    });
+    const HasherCtor = B2.CryptoHasher;
+    const hasHasher = typeof HasherCtor === "function";
+    const sha256 = hasHasher ? probeCryptoHasher(HasherCtor, "sha256") : false;
+    const sha512 = hasHasher ? probeCryptoHasher(HasherCtor, "sha512") : false;
+    const blake2b = hasHasher ? probeCryptoHasher(HasherCtor, "blake2b256") : false;
+    const cryptoHasherFeatures = Object.freeze({
+      available: hasHasher && sha256,
+      sha256,
+      sha512,
+      blake2b
+    });
+    const hasGlob = typeof B2.Glob === "function";
+    this.cached = Object.freeze({
+      runtime: kind2,
+      bunVersion: B2.version ?? null,
+      password: passwordFeatures,
+      cryptoHasher: cryptoHasherFeatures,
+      glob: hasGlob
+    });
+    return this.cached;
+  }
+  static reset() {
+    this.cached = null;
+  }
+}
+function formatCapabilityReport(f) {
+  const passwordPart = f.password.argon2id ? "Bun.password argon2id \u2713" : "Bun.password argon2id \u2717 (fallback: none)";
+  const hasherPart = f.cryptoHasher.available ? "Bun.CryptoHasher \u2713" : "Bun.CryptoHasher \u2717 (fallback: node:crypto)";
+  const globPart = f.glob ? "Bun.Glob \u2713" : "Bun.Glob \u2717 (fallback: node:fs glob)";
+  return `[gravito] native: ${passwordPart}, ${hasherPart}, ${globPart}`;
+}
+
 // src/runtime/archive.ts
 function createBunArchiveAdapter() {
   return {
@@ -4956,6 +5378,9 @@ async function archiveFromDirectory(dirPath, archivePath, options = {}) {
   let entries = {};
   if (kind === "bun") {
     const B = globalThis.Bun;
+    if (!B?.Glob || !B.file) {
+      throw new Error("[RuntimeArchiveAdapter] Bun global not available for directory scanning");
+    }
     const glob = new B.Glob(options.glob ?? "**/*");
     for await (const file of glob.scan(dirPath)) {
       const pathMod = await eval('import("node:path")');
@@ -5569,6 +5994,9 @@ function getPasswordAdapter() {
   };
   return passwordAdapter;
 }
+function resetPasswordAdapter() {
+  passwordAdapter = null;
+}
 async function createSqliteDatabase(path2) {
   const kind2 = getRuntimeKind();
   const B2 = globalThis.Bun;
@@ -5670,15 +6098,6 @@ class ConfigManager {
   }
 }
 
-// src/exceptions/CircularDependencyException.ts
-class CircularDependencyException extends Error {
-  constructor(key, stack) {
-    const path2 = [...stack, key].map(String).join(" -> ");
-    super(`Circular dependency detected: ${path2}`);
-    this.name = "CircularDependencyException";
-  }
-}
-
 // src/Container.ts
 var scopeStorage = new AsyncLocalStorage;
 
@@ -5703,6 +6122,17 @@ class Container {
       scope: "singleton"
     });
   }
+  singletonInline(namespace, key, factory) {
+    const namespacedKey = `inline:${namespace}:${key}`;
+    if (this.has(namespacedKey)) {
+      if (true) {
+        throw new ContainerBindingCollisionException(`Binding '${namespacedKey}' already registered by plugin '${namespace}'`);
+      }
+      console.warn(`[gravito] Binding '${namespacedKey}' collision detected \u2014 skipping duplicate registration.`);
+      return;
+    }
+    this.singleton(namespacedKey, factory);
+  }
   scoped(key, factory) {
     this.bindings.set(key, {
       factory,
@@ -5840,63 +6270,6 @@ function detectRequestScopeLeaks(context) {
   };
 }
 
-// src/exceptions/GravitoException.ts
-class GravitoException extends Error {
-  status;
-  code;
-  i18nKey;
-  i18nParams;
-  constructor(status, code, options2 = {}) {
-    super(options2.message);
-    this.name = "GravitoException";
-    this.status = status;
-    this.cause = options2.cause;
-    this.code = code;
-    if (options2.i18nKey) {
-      this.i18nKey = options2.i18nKey;
-    }
-    if (options2.i18nParams) {
-      this.i18nParams = options2.i18nParams;
-    }
-  }
-  getLocalizedMessage(t) {
-    if (this.i18nKey) {
-      return t(this.i18nKey, this.i18nParams);
-    }
-    return this.message;
-  }
-}
-
-// src/exceptions/HttpException.ts
-class HttpException extends GravitoException {
-  constructor(status, options2 = {}) {
-    super(status, "HTTP_ERROR", options2);
-    this.name = "HttpException";
-  }
-}
-
-// src/exceptions/ValidationException.ts
-class ValidationException extends GravitoException {
-  errors;
-  redirectTo;
-  input;
-  constructor(errors, message = "Validation failed") {
-    super(422, "VALIDATION_ERROR", {
-      message,
-      i18nKey: "errors.validation.failed"
-    });
-    this.errors = errors;
-  }
-  withRedirect(url) {
-    this.redirectTo = url;
-    return this;
-  }
-  withInput(input) {
-    this.input = input;
-    return this;
-  }
-}
-
 // src/helpers/response.ts
 function ok(data) {
   return { success: true, data };
@@ -9322,59 +9695,60 @@ class EventMetrics {
   circuitBreakerSuccessesCounter;
   circuitBreakerOpenDurationHistogram;
   constructor(registry, prefix = "gravito_event_") {
-    this.dispatchLatency = registry.histogram({
+    const reg = registry;
+    this.dispatchLatency = reg.histogram({
       name: `${prefix}dispatch_latency_seconds`,
       help: "Event dispatch latency in seconds",
       labels: ["event_name", "priority"],
       buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 2, 5]
     });
-    this.listenerExecutionTime = registry.histogram({
+    this.listenerExecutionTime = reg.histogram({
       name: `${prefix}listener_execution_seconds`,
       help: "Listener execution time in seconds",
       labels: ["event_name", "listener_index"],
       buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 2, 5]
     });
-    this.queueDepthGauge = registry.gauge({
+    this.queueDepthGauge = reg.gauge({
       name: `${prefix}queue_depth`,
       help: "Current queue depth by priority",
       labels: ["priority"]
     });
-    this.failureCounter = registry.counter({
+    this.failureCounter = reg.counter({
       name: `${prefix}failures_total`,
       help: "Total number of failed event processing",
       labels: ["event_name", "error_type"]
     });
-    this.timeoutCounter = registry.counter({
+    this.timeoutCounter = reg.counter({
       name: `${prefix}timeouts_total`,
       help: "Total number of event processing timeouts",
       labels: ["event_name"]
     });
-    this.processedCounter = registry.counter({
+    this.processedCounter = reg.counter({
       name: `${prefix}processed_total`,
       help: "Total number of processed events",
       labels: ["event_name", "status"]
     });
-    this.circuitBreakerStateGauge = registry.gauge({
+    this.circuitBreakerStateGauge = reg.gauge({
       name: `${prefix}circuit_breaker_state`,
       help: "Current circuit breaker state (0=CLOSED, 1=HALF_OPEN, 2=OPEN)",
       labels: ["event_name"]
     });
-    this.circuitBreakerTransitionsCounter = registry.counter({
+    this.circuitBreakerTransitionsCounter = reg.counter({
       name: `${prefix}circuit_breaker_transitions_total`,
       help: "Total number of circuit breaker state transitions",
       labels: ["event_name", "from_state", "to_state"]
     });
-    this.circuitBreakerFailuresCounter = registry.counter({
+    this.circuitBreakerFailuresCounter = reg.counter({
       name: `${prefix}circuit_breaker_failures_total`,
       help: "Total number of failures tracked by circuit breaker",
       labels: ["event_name"]
     });
-    this.circuitBreakerSuccessesCounter = registry.counter({
+    this.circuitBreakerSuccessesCounter = reg.counter({
       name: `${prefix}circuit_breaker_successes_total`,
       help: "Total number of successes tracked by circuit breaker",
       labels: ["event_name"]
     });
-    this.circuitBreakerOpenDurationHistogram = registry.histogram({
+    this.circuitBreakerOpenDurationHistogram = reg.histogram({
       name: `${prefix}circuit_breaker_open_duration_seconds`,
       help: "Duration of circuit breaker OPEN state in seconds",
       labels: ["event_name"],
@@ -9767,7 +10141,7 @@ class ObservableHookManager extends HookManager {
     let span;
     if (this.eventTracing) {
       span = this.eventTracing.startDispatchSpan(hook, callbacks.length, "normal");
-      span.setAttributes({ "event.dispatch_mode": "sync" });
+      span?.setAttributes({ "event.dispatch_mode": "sync" });
     } else if (this.eventTracer) {
       span = this.eventTracer.startDispatchSpan(hook, callbacks.length, "normal");
     }
@@ -9912,18 +10286,18 @@ class OTelEventMetrics {
         });
       }
     });
-    this.cbFailuresCounter = meter2.createCounter ? meter2.createCounter(`${prefix}circuit_breaker_failures_total`, {
+    this.cbFailuresCounter = meter2.createCounter(`${prefix}circuit_breaker_failures_total`, {
       description: "Total number of failures recorded by circuit breakers",
       unit: "{failures}"
-    }) : { add: () => {} };
-    this.cbSuccessesCounter = meter2.createCounter ? meter2.createCounter(`${prefix}circuit_breaker_successes_total`, {
+    });
+    this.cbSuccessesCounter = meter2.createCounter(`${prefix}circuit_breaker_successes_total`, {
       description: "Total number of successes recorded by circuit breakers",
       unit: "{successes}"
-    }) : { add: () => {} };
-    this.cbTransitionsCounter = meter2.createCounter ? meter2.createCounter(`${prefix}circuit_breaker_transitions_total`, {
+    });
+    this.cbTransitionsCounter = meter2.createCounter(`${prefix}circuit_breaker_transitions_total`, {
       description: "Total number of state transitions in circuit breakers",
       unit: "{transitions}"
-    }) : { add: () => {} };
+    });
     this.cbOpenDurationHistogram = meter2.createHistogram(`${prefix}circuit_breaker_open_duration_seconds`, {
       description: "Duration that circuit breakers remain in OPEN state",
       unit: "s",
@@ -9931,10 +10305,10 @@ class OTelEventMetrics {
         explicitBucketBoundaries: this.cbOpenDurationBuckets
       }
     });
-    this.backpressureRejectionsCounter = meter2.createCounter ? meter2.createCounter(`${prefix}backpressure_rejections_total`, {
+    this.backpressureRejectionsCounter = meter2.createCounter(`${prefix}backpressure_rejections_total`, {
       description: "Total number of events rejected due to backpressure",
       unit: "{rejections}"
-    }) : { add: () => {} };
+    });
     this.backpressureStateGauge = meter2.createObservableGauge(`${prefix}backpressure_state`, {
       description: "Current backpressure state (0=NORMAL, 1=WARNING, 2=CRITICAL, 3=OVERFLOW)",
       unit: "{state}"
@@ -9948,14 +10322,14 @@ class OTelEventMetrics {
       };
       observableResult.observe(stateMap[this.backpressureStateValue] ?? 0);
     });
-    this.backpressureDegradationsCounter = meter2.createCounter ? meter2.createCounter(`${prefix}backpressure_degradations_total`, {
+    this.backpressureDegradationsCounter = meter2.createCounter(`${prefix}backpressure_degradations_total`, {
       description: "Total number of priority degradations due to backpressure",
       unit: "{degradations}"
-    }) : { add: () => {} };
-    this.dlqEntriesCounter = meter2.createCounter ? meter2.createCounter(`${prefix}dlq_entries_total`, {
+    });
+    this.dlqEntriesCounter = meter2.createCounter(`${prefix}dlq_entries_total`, {
       description: "Total number of events added to Dead Letter Queue",
       unit: "{entries}"
-    }) : { add: () => {} };
+    });
     this.dlqDepthGauge = meter2.createObservableGauge(`${prefix}dlq_depth`, {
       description: "Current Dead Letter Queue depth",
       unit: "{events}"
@@ -9965,18 +10339,18 @@ class OTelEventMetrics {
         observableResult.observe(this.dlqDepthCallback());
       }
     });
-    this.dlqRequeueCounter = meter2.createCounter ? meter2.createCounter(`${prefix}dlq_requeue_total`, {
+    this.dlqRequeueCounter = meter2.createCounter(`${prefix}dlq_requeue_total`, {
       description: "Total number of DLQ requeue attempts",
       unit: "{attempts}"
-    }) : { add: () => {} };
-    this.retryAttemptsCounter = meter2.createCounter ? meter2.createCounter(`${prefix}retry_attempts_total`, {
+    });
+    this.retryAttemptsCounter = meter2.createCounter(`${prefix}retry_attempts_total`, {
       description: "Total number of event retry attempts",
       unit: "{attempts}"
-    }) : { add: () => {} };
-    this.priorityEscalationCounter = meter2.createCounter ? meter2.createCounter(`${prefix}priority_escalation_total`, {
+    });
+    this.priorityEscalationCounter = meter2.createCounter(`${prefix}priority_escalation_total`, {
       description: "Total number of priority escalations",
       unit: "{escalations}"
-    }) : { add: () => {} };
+    });
   }
   recordDispatchDuration(eventName, priority, durationSeconds) {
     this.dispatchDurationHistogram.record(durationSeconds, {
@@ -10911,23 +11285,6 @@ class CookieJar {
   }
 }
 
-// src/exceptions/ModelNotFoundException.ts
-class ModelNotFoundException extends GravitoException {
-  model;
-  id;
-  constructor(model, id) {
-    super(404, "NOT_FOUND", {
-      message: `${model} not found.`,
-      i18nKey: "errors.model.not_found",
-      i18nParams: { model, id: String(id ?? "") }
-    });
-    this.model = model;
-    if (id !== undefined) {
-      this.id = id;
-    }
-  }
-}
-
 // src/Route.ts
 class Route {
   router;
@@ -10944,6 +11301,13 @@ class Route {
     this.router.registerName(name, this.method, this.path, this.options);
     return this;
   }
+  schema(schemas) {
+    this.options.schema = {
+      ...this.options.schema || {},
+      ...schemas
+    };
+    return this;
+  }
   static get(path2, requestOrHandlerOrMiddleware, handler) {
     return router().req("get", path2, requestOrHandlerOrMiddleware, handler);
   }
@@ -11139,18 +11503,20 @@ class Router {
     const compiled = [];
     const nameMap = new Map;
     for (const [name, info] of this.namedRoutes) {
-      nameMap.set(`${info.method.toUpperCase()}:${info.path}`, name);
+      nameMap.set(`${info.method.toUpperCase()}:${info.path}`, { name, options: info.options });
     }
     const compiledKeys = new Set;
     for (const route of this.routes) {
       const method = route.method.toUpperCase();
       const key = `${method}:${route.path}`;
       compiledKeys.add(key);
+      const namedInfo = nameMap.get(key);
       compiled.push({
         method,
         path: route.path,
         domain: route.domain,
-        name: nameMap.get(key)
+        name: namedInfo?.name,
+        schema: route.options?.schema || namedInfo?.options?.schema
       });
     }
     for (const [name, info] of this.namedRoutes) {
@@ -11160,7 +11526,8 @@ class Router {
           name,
           method: info.method.toUpperCase(),
           path: info.path,
-          domain: info.domain
+          domain: info.domain,
+          schema: info.options?.schema
         });
       }
     }
@@ -11171,7 +11538,8 @@ class Router {
     this.namedRoutes.set(name, {
       method: method.toUpperCase(),
       path: fullPath,
-      domain: options2.domain
+      domain: options2.domain,
+      options: options2
     });
   }
   url(name, params = {}, query = {}) {
@@ -11211,7 +11579,7 @@ class Router {
       if (modelClass && typeof modelClass === "object" && "find" in modelClass && typeof modelClass.find === "function") {
         const instance = await modelClass.find(id);
         if (!instance) {
-          throw new Error("ModelNotFound");
+          throw new ModelNotFoundException(param, String(id));
         }
         return instance;
       }
@@ -11233,17 +11601,9 @@ class Router {
         if (!resolver) {
           continue;
         }
-        try {
-          const resolved = await resolver(value2);
-          routeModels[param] = resolved;
-          hasResolvedModels = true;
-        } catch (err) {
-          const message = err instanceof Error ? err.message : undefined;
-          if (message === "ModelNotFound") {
-            throw new ModelNotFoundException(param, value2);
-          }
-          throw err;
-        }
+        const resolved = await resolver(value2);
+        routeModels[param] = resolved;
+        hasResolvedModels = true;
       }
       if (hasResolvedModels) {
         c.set("routeModels", routeModels);
@@ -11307,7 +11667,6 @@ class Router {
   }
   req(method, path2, requestOrHandlerOrMiddleware, handler, options2 = {}) {
     const fullPath = (options2.prefix || "") + path2;
-    console.log(`[Router] Registering ${method.toUpperCase()} ${fullPath}`);
     let formRequestMiddleware = null;
     let routeMiddleware = [];
     let finalRouteHandler;
@@ -11349,11 +11708,16 @@ class Router {
         if (c.req.header("host") !== options2.domain) {
           return c.text("Not Found", 404);
         }
-        await next();
+        return await next();
       };
       handlers.unshift(domainCheck);
     }
-    this.routes.push({ method: method.toUpperCase(), path: fullPath, domain: options2.domain });
+    this.routes.push({
+      method: method.toUpperCase(),
+      path: fullPath,
+      domain: options2.domain,
+      options: options2
+    });
     this.core.adapter.route(method, fullPath, ...handlers);
     return new Route(this, method, fullPath, options2);
   }
@@ -11471,14 +11835,16 @@ class PlanetCore {
   services = new Map;
   encrypter;
   hasher;
+  installedOrbits = [];
   observabilityProvider;
   providers = [];
   deferredProviders = new Map;
   bootedProviders = new Set;
   isShuttingDown = false;
+  static GLOBAL_SHUTDOWN_TIMEOUT = 1e4;
   async initializeObservabilityAsync(obsConfig) {
     try {
-      if (this.observabilityProvider && this.observabilityProvider !== this.observabilityProvider._isNoOp) {
+      if (this.observabilityProvider && this.observabilityProvider._isNoOp !== true) {
         this.logger.info("[Observability] \u2705 Using observability provider from @gravito/monitor");
         if (obsConfig?.prometheus?.enabled !== false) {
           await this.initializePrometheusAsync(obsConfig);
@@ -11520,10 +11886,11 @@ class PlanetCore {
     this.logger.debug("[Observability] Prometheus setup moved to @gravito/monitor. Use monitor package for metrics initialization.");
   }
   register(provider) {
-    if (typeof provider.setCore === "function") {
-      provider.setCore(this);
+    const providerRecord = provider;
+    if (typeof providerRecord["setCore"] === "function") {
+      providerRecord["setCore"](this);
     } else {
-      provider.core = this;
+      providerRecord["core"] = this;
     }
     if (provider.deferred) {
       const services = provider.provides();
@@ -11577,15 +11944,23 @@ class PlanetCore {
     }
     this.isShuttingDown = true;
     this.logger.debug("\uD83D\uDED1 Application shutdown started");
-    for (const provider of [...this.providers].reverse()) {
-      if (provider.onShutdown) {
-        try {
-          this.logger.debug(`  onShutdown: ${provider.constructor.name}`);
-          await provider.onShutdown(this);
-        } catch (error) {
-          this.logger.error(`Error during shutdown of ${provider.constructor.name}:`, error);
+    const shutdownSequence = async () => {
+      for (const provider of [...this.providers].reverse()) {
+        if (provider.onShutdown) {
+          try {
+            this.logger.debug(`  onShutdown: ${provider.constructor.name}`);
+            await provider.onShutdown(this);
+          } catch (error) {
+            this.logger.error(`Error during shutdown of ${provider.constructor.name}:`, error);
+          }
         }
       }
+    };
+    const globalDeadline = new Promise((_, reject) => setTimeout(() => reject(new Error("[PlanetCore] Global shutdown timeout exceeded (10s)")), PlanetCore.GLOBAL_SHUTDOWN_TIMEOUT));
+    try {
+      await Promise.race([shutdownSequence(), globalDeadline]);
+    } catch (err) {
+      this.logger.warn("[PlanetCore] Forced shutdown after global timeout:", err);
     }
     this.hooks.doAction("app:shutdown", this);
     this.logger.debug("\u2705 Application shutdown complete");
@@ -11686,8 +12061,38 @@ class PlanetCore {
     process.on("SIGTERM", () => handleSignal("SIGTERM"));
     process.on("SIGINT", () => handleSignal("SIGINT"));
   }
+  async plugin(config3) {
+    if (!config3.name) {
+      throw new Error('plugin(): Lite Satellites require a "name" property to enable safe service namespacing. Consider naming it based on the feature (e.g., "ping", "health-check").');
+    }
+    const alreadyRegistered = this.installedOrbits.some((orbit) => orbit.name === config3.name);
+    if (alreadyRegistered) {
+      if (true) {
+        throw new ContainerBindingCollisionException(`Lite Satellite name '${config3.name}' already registered`);
+      }
+      this.logger.warn(`[gravito] Lite Satellite '${config3.name}' already registered \u2014 skipping duplicate installation.`);
+      return this;
+    }
+    this.logger.debug(`\uD83D\uDD0C Installing Lite Satellite: ${config3.name}`);
+    this.installedOrbits.push({
+      name: config3.name,
+      dependencies: config3.dependencies || []
+    });
+    await config3.install(this);
+    return this;
+  }
   async orbit(orbit) {
     const instance = typeof orbit === "function" ? new orbit : orbit;
+    const name = instance.name || instance.constructor.name;
+    if (instance.name) {
+      this.logger.debug(`\uD83D\uDEF0\uFE0F Installing Orbit: ${instance.name}`);
+    } else {
+      this.logger.debug(`\uD83D\uDEF0\uFE0F Installing Orbit: ${instance.constructor.name}`);
+    }
+    this.installedOrbits.push({
+      name,
+      dependencies: instance.dependencies || []
+    });
     await instance.install(this);
     return this;
   }
@@ -11712,17 +12117,24 @@ class PlanetCore {
       ...config3.logger && { logger: config3.logger },
       ...config3.config && { config: config3.config },
       ...config3.adapter && { adapter: config3.adapter },
-      ...config3.container && { container: config3.container }
+      ...config3.container && { container: config3.container },
+      ...config3.observabilityProvider && { observabilityProvider: config3.observabilityProvider }
     });
+    const features = NativeOrbitDetector.detectBunCapabilities();
+    core.logger.info(formatCapabilityReport(features));
     if (config3.orbits) {
       for (const OrbitClassOrInstance of config3.orbits) {
-        let orbit;
-        if (typeof OrbitClassOrInstance === "function") {
-          orbit = new OrbitClassOrInstance;
+        if (typeof OrbitClassOrInstance !== "function" && OrbitClassOrInstance.name) {
+          await core.plugin(OrbitClassOrInstance);
         } else {
-          orbit = OrbitClassOrInstance;
+          let orbit;
+          if (typeof OrbitClassOrInstance === "function") {
+            orbit = new OrbitClassOrInstance;
+          } else {
+            orbit = OrbitClassOrInstance;
+          }
+          await orbit.install(core);
         }
-        await orbit.install(core);
       }
     }
     return core;
@@ -12492,7 +12904,8 @@ class MessageQueueBridge {
       throw new Error(`[MessageQueueBridge] No listeners registered for event: ${eventName}`);
     }
     if (this.config.enableCircuitBreaker) {
-      const breaker = this.config.hookManager.getCircuitBreaker?.(eventName);
+      const hm = this.config.hookManager;
+      const breaker = hm.getCircuitBreaker?.(eventName);
       if (breaker?.getState?.() === "OPEN") {
         throw new Error(`[MessageQueueBridge] Circuit breaker is OPEN for event: ${eventName}`);
       }
@@ -12618,9 +13031,9 @@ class RetryScheduler {
     try {
       const queue = this.getOrCreateQueue(eventName);
       const delay = this.calculateDelay(retryCount);
-      const addMethod = queue.add;
-      if (typeof addMethod === "function") {
-        await addMethod.call(queue, "retry", { payload, error: error.message, retryCount }, { delay });
+      const queueObj = queue;
+      if (typeof queueObj.add === "function") {
+        await queueObj.add.call(queue, "retry", { payload, error: error.message, retryCount }, { delay });
       }
     } catch (schedulerError) {
       const err = schedulerError instanceof Error ? schedulerError : new Error(String(schedulerError));
@@ -13189,25 +13602,6 @@ class QueueDashboard {
     return value2.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
   }
 }
-// src/exceptions/AuthenticationException.ts
-class AuthenticationException extends GravitoException {
-  constructor(message = "Unauthenticated.") {
-    super(401, "UNAUTHENTICATED", {
-      message,
-      i18nKey: "errors.authentication.unauthenticated"
-    });
-  }
-}
-
-// src/exceptions/AuthorizationException.ts
-class AuthorizationException extends GravitoException {
-  constructor(message = "This action is unauthorized.") {
-    super(403, "FORBIDDEN", {
-      message,
-      i18nKey: "errors.authorization.forbidden"
-    });
-  }
-}
 // src/ServiceProvider.ts
 class ServiceProvider {
   core;
@@ -13431,15 +13825,19 @@ class TestResponse {
   async assertJsonStructure(structure) {
     const json = await this.getJson();
     const checkKeys = (data2, struct) => {
-      for (const key in struct) {
-        if (Array.isArray(struct[key])) {
-          expect(Array.isArray(data2[key])).toBe(true);
-          if (data2[key].length > 0) {
-            checkKeys(data2[key][0], struct[key][0]);
+      const structObj = struct;
+      const dataObj = data2;
+      for (const key in structObj) {
+        if (Array.isArray(structObj[key])) {
+          expect(Array.isArray(dataObj[key])).toBe(true);
+          const dataArr = dataObj[key];
+          const structArr = structObj[key];
+          if (dataArr.length > 0) {
+            checkKeys(dataArr[0], structArr[0]);
           }
-        } else if (typeof struct[key] === "object") {
-          expect(typeof data2[key]).toBe("object");
-          checkKeys(data2[key], struct[key]);
+        } else if (typeof structObj[key] === "object") {
+          expect(typeof dataObj[key]).toBe("object");
+          checkKeys(dataObj[key], structObj[key]);
         } else {
           expect(data2).toHaveProperty(key);
         }
@@ -13888,6 +14286,7 @@ export {
   runtimeAppendFile,
   router,
   resetRuntimeAdapter,
+  resetPasswordAdapter,
   registerQueueCommands,
   registerGlobalErrorHandlers,
   old,
@@ -13912,6 +14311,7 @@ export {
   getCookie,
   getCompressionAdapter,
   getArchiveAdapter,
+  formatCapabilityReport,
   filled,
   fail,
   extractRequestScopeErrorContext,
@@ -13945,7 +14345,10 @@ export {
   ValidationException,
   VERSION,
   TestResponse,
+  SystemException,
+  StreamException,
   Str,
+  StorageException,
   StarvationProtectionStrategy,
   ServiceProvider,
   Router,
@@ -13961,6 +14364,7 @@ export {
   RateLimitStrategy,
   RadixRouter,
   RadixNode,
+  QueueException,
   QueueDepthStrategy,
   QueueDashboard,
   PriorityRebalanceStrategy,
@@ -13969,7 +14373,9 @@ export {
   ObservableHookManager,
   OTelEventMetrics,
   NodeType,
+  NativeOrbitDetector,
   ModelNotFoundException,
+  InfrastructureException,
   IdempotencyCache,
   HttpTester,
   HttpException,
@@ -13988,18 +14394,22 @@ export {
   ErrorHandler,
   Encrypter,
   DumpDieError,
+  DomainException,
   DeadLetterQueueManager,
   DeadLetterQueue,
+  DatabaseException,
   DEFAULT_EVENT_OPTIONS,
   CookieJar,
   Container,
   ConsoleLogger,
+  ConfigurationException,
   ConfigManager,
   CompositeStrategy,
   CommandKernel,
   CircularDependencyException,
   CircuitBreakerState,
   CircuitBreaker,
+  CacheException,
   BunWebSocketHandler,
   BunRequest,
   BunNativeAdapter,
@@ -14009,8 +14419,9 @@ export {
   BackpressureManager,
   AuthorizationException,
   AuthenticationException,
+  AuthException,
   Arr,
   Application
 };
 
-//# debugId=B420456F9068F67364756E2164756E21
+//# debugId=AFB01087B997521264756E2164756E21