@buenojs/bueno 0.8.5 → 0.8.7

package/dist/modules/index.js

@@ -26,6 +26,237 @@ var __legacyMetadataTS = (k, v) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/container/forward-ref.ts
+function forwardRef(fn) {
+  return {
+    __forwardRef: FORWARD_REF_SYMBOL,
+    forwardRef: fn
+  };
+}
+function isForwardRef(value) {
+  return typeof value === "object" && value !== null && "__forwardRef" in value && "forwardRef" in value && typeof value.forwardRef === "function";
+}
+function resolveForwardRef(ref) {
+  if (isForwardRef(ref)) {
+    return ref.forwardRef();
+  }
+  return ref;
+}
+var FORWARD_REF_SYMBOL;
+var init_forward_ref = __esm(() => {
+  FORWARD_REF_SYMBOL = Symbol.for("buno.forwardRef");
+});
+
+// src/container/index.ts
+var exports_container = {};
+__export(exports_container, {
+  setContainerMetadata: () => setContainerMetadata,
+  resolveForwardRef: () => resolveForwardRef,
+  isForwardRef: () => isForwardRef,
+  getInjectTokens: () => getContainerMetadata,
+  getContainerMetadata: () => getContainerMetadata,
+  forwardRef: () => forwardRef,
+  createToken: () => createToken,
+  Token: () => Token,
+  Injectable: () => Injectable,
+  Inject: () => Inject,
+  Container: () => Container2
+});
+function createToken(description) {
+  return Symbol(description);
+}
+
+class ResolutionStack {
+  stack = new Set;
+  lazyResolutions = new Map;
+  push(token) {
+    if (this.stack.has(token)) {
+      throw new Error("Circular dependency detected: Token already in resolution stack");
+    }
+    this.stack.add(token);
+  }
+  pop(token) {
+    this.stack.delete(token);
+  }
+  has(token) {
+    return this.stack.has(token);
+  }
+  markLazy(token, placeholder) {
+    this.lazyResolutions.set(token, placeholder);
+  }
+  hasLazy(token) {
+    return this.lazyResolutions.has(token);
+  }
+  getLazy(token) {
+    return this.lazyResolutions.get(token);
+  }
+  clearLazy(token) {
+    this.lazyResolutions.delete(token);
+  }
+}
+
+class Container2 {
+  providers = new Map;
+  resolutionStack = new ResolutionStack;
+  register(provider) {
+    if (this.providers.has(provider.token)) {
+      throw new Error(`Provider already registered for token: ${String(provider.token)}`);
+    }
+    this.providers.set(provider.token, {
+      provider: {
+        ...provider,
+        scope: provider.scope ?? "singleton"
+      }
+    });
+  }
+  registerAll(providers) {
+    for (const provider of providers) {
+      this.register(provider);
+    }
+  }
+  has(token) {
+    return this.providers.has(token);
+  }
+  resolve(token) {
+    const resolved = this.providers.get(token);
+    if (!resolved) {
+      throw new Error(`No provider registered for token: ${String(token)}`);
+    }
+    const { provider } = resolved;
+    if (this.resolutionStack.has(token)) {
+      return this.createLazyProxy(token, resolved);
+    }
+    if (provider.scope === "singleton" && resolved.instance !== undefined) {
+      return resolved.instance;
+    }
+    this.resolutionStack.push(token);
+    try {
+      const instance = this.createInstance(provider);
+      if (provider.scope === "singleton") {
+        resolved.instance = instance;
+      }
+      return instance;
+    } finally {
+      this.resolutionStack.pop(token);
+    }
+  }
+  createLazyProxy(token, resolved) {
+    const existingLazy = this.resolutionStack.getLazy(token);
+    if (existingLazy && existingLazy.instance) {
+      return existingLazy.instance;
+    }
+    const placeholder = {
+      resolved: false
+    };
+    this.resolutionStack.markLazy(token, placeholder);
+    const proxy = new Proxy({}, {
+      get: (target, prop) => {
+        if (placeholder.resolved && placeholder.instance) {
+          const value = placeholder.instance[prop];
+          return typeof value === "function" ? value.bind(placeholder.instance) : value;
+        }
+        if (resolved.instance !== undefined) {
+          placeholder.instance = resolved.instance;
+          placeholder.resolved = true;
+        } else {
+          if (prop === "then") {
+            return;
+          }
+        }
+        if (placeholder.instance) {
+          const value = placeholder.instance[prop];
+          return typeof value === "function" ? value.bind(placeholder.instance) : value;
+        }
+        return () => {
+          return;
+        };
+      },
+      set: (target, prop, value) => {
+        if (placeholder.instance) {
+          placeholder.instance[prop] = value;
+          return true;
+        }
+        return false;
+      },
+      has: (target, prop) => {
+        if (placeholder.instance) {
+          return prop in placeholder.instance;
+        }
+        return false;
+      }
+    });
+    placeholder.instance = proxy;
+    return proxy;
+  }
+  createInstance(provider) {
+    if (provider.useValue !== undefined) {
+      return provider.useValue;
+    }
+    if (provider.useFactory) {
+      const deps = this.resolveDeps(provider.inject ?? []);
+      return provider.useFactory(...deps);
+    }
+    if (provider.useClass) {
+      const deps = this.resolveDeps(provider.inject ?? []);
+      return new provider.useClass(...deps);
+    }
+    throw new Error(`Invalid provider configuration for token: ${String(provider.token)}`);
+  }
+  resolveDeps(tokens) {
+    return tokens.map((tokenOrRef) => {
+      const token = resolveForwardRef(tokenOrRef);
+      return this.resolve(token);
+    });
+  }
+  clear() {
+    this.providers.clear();
+  }
+  getTokens() {
+    return Array.from(this.providers.keys());
+  }
+  createChild() {
+    const child = new Container2;
+    for (const [token, resolved] of this.providers) {
+      if (resolved.provider.scope === "singleton") {
+        child.providers.set(token, resolved);
+      }
+    }
+    return child;
+  }
+}
+function setContainerMetadata(target, key, value) {
+  if (!containerMetadata.has(target)) {
+    containerMetadata.set(target, new Map);
+  }
+  containerMetadata.get(target)?.set(key, value);
+}
+function getContainerMetadata(target, key) {
+  return containerMetadata.get(target)?.get(key);
+}
+function Injectable(token) {
+  return (target) => {
+    setContainerMetadata(target, "injectable", true);
+    if (token) {
+      setContainerMetadata(target, "token", token);
+    }
+    return target;
+  };
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const targetObj = target;
+    const existingTokens = getContainerMetadata(targetObj, "inject:tokens") ?? [];
+    existingTokens[parameterIndex] = token;
+    setContainerMetadata(targetObj, "inject:tokens", existingTokens);
+  };
+}
+var Token, containerMetadata;
+var init_container = __esm(() => {
+  init_forward_ref();
+  Token = createToken;
+  containerMetadata = new WeakMap;
+});
+
 // src/context/index.ts
 var exports_context = {};
 __export(exports_context, {
@@ -259,369 +490,304 @@ function createPipeline() {
   return new Pipeline;
 }
 
-// src/validation/index.ts
-async function validate(schema, data) {
-  try {
-    const result = await Promise.resolve(schema["~standard"].validate(data));
-    if ("value" in result) {
-      return { success: true, data: result.value };
-    }
-    return {
-      success: false,
-      issues: [...result.issues]
-    };
-  } catch (error) {
-    return {
-      success: false,
-      issues: [
-        {
-          message: error instanceof Error ? error.message : "Validation failed"
-        }
-      ]
-    };
-  }
+// src/modules/guards.ts
+var exports_guards = {};
+__export(exports_guards, {
+  getMethodRoles: () => getMethodRoles,
+  getMethodGuards: () => getMethodGuards,
+  getClassGuards: () => getClassGuards,
+  executeGuards: () => executeGuards,
+  createForbiddenResponse: () => createForbiddenResponse,
+  UseGuards: () => UseGuards,
+  RolesGuard: () => RolesGuard,
+  Roles: () => Roles,
+  AuthGuard: () => AuthGuard
+});
+function setClassGuards(target, guards) {
+  guardsClassMetadata.set(target, guards);
 }
-function validateSync(schema, data) {
-  const result = schema["~standard"].validate(data);
-  if (result instanceof Promise) {
-    throw new Error("Schema uses async validation. Use validate() instead.");
-  }
-  if ("value" in result) {
-    return { success: true, data: result.value };
+function getClassGuards(target) {
+  return guardsClassMetadata.get(target);
+}
+function setMethodGuards(target, propertyKey, guards) {
+  if (!guardsMethodMetadata.has(target)) {
+    guardsMethodMetadata.set(target, new Map);
   }
-  return { success: false, issues: [...result.issues] };
+  guardsMethodMetadata.get(target)?.set(propertyKey, guards);
 }
-async function validateBody(context, schema) {
-  try {
-    const body = await context.body();
-    return validate(schema, body);
-  } catch (error) {
-    return {
-      success: false,
-      issues: [{ message: "Failed to parse request body" }]
-    };
-  }
-}
-function validateQuery(context, schema) {
-  return validateSync(schema, context.query);
-}
-function validateParams(context, schema) {
-  return validateSync(schema, context.params);
-}
-function validateHeaders(context, schema) {
-  const headers = {};
-  context.req.headers.forEach((value, key) => {
-    headers[key] = value;
-  });
-  return validateSync(schema, headers);
+function getMethodGuards(target, propertyKey) {
+  return guardsMethodMetadata.get(target)?.get(propertyKey);
 }
-function createValidator(options) {
-  return async (context, next) => {
-    if (options.body) {
-      const result = await validateBody(context, options.body);
-      if (!result.success) {
-        return context.status(400).json({ error: "Validation failed", issues: result.issues });
-      }
-      context.set("validatedBody", result.data);
-    }
-    if (options.query) {
-      const result = validateQuery(context, options.query);
-      if (!result.success) {
-        return context.status(400).json({ error: "Validation failed", issues: result.issues });
-      }
-      context.set("validatedQuery", result.data);
-    }
-    if (options.params) {
-      const result = validateParams(context, options.params);
-      if (!result.success) {
-        return context.status(400).json({ error: "Validation failed", issues: result.issues });
-      }
-      context.set("validatedParams", result.data);
-    }
-    if (options.headers) {
-      const result = validateHeaders(context, options.headers);
-      if (!result.success) {
-        return context.status(400).json({ error: "Validation failed", issues: result.issues });
-      }
-      context.set("validatedHeaders", result.data);
+function UseGuards(...guards) {
+  const decorator = (target, propertyKey, descriptor) => {
+    if (propertyKey !== undefined && descriptor !== undefined) {
+      const targetObj = target;
+      const existingGuards = getMethodGuards(targetObj, propertyKey) ?? [];
+      setMethodGuards(targetObj, propertyKey, [...existingGuards, ...guards]);
+      return descriptor;
+    } else {
+      const targetClass = target;
+      const existingGuards = getClassGuards(targetClass) ?? [];
+      setClassGuards(targetClass, [...existingGuards, ...guards]);
     }
-    return next();
   };
+  return decorator;
 }
-function WithBody(schema) {
-  return (target, propertyKey, descriptor) => {
-    const original = descriptor.value;
-    descriptor.value = async function(context) {
-      const result = await validateBody(context, schema);
-      if (!result.success) {
-        return context.status(400).json({ error: "Validation failed", issues: result.issues });
-      }
-      context.set("body", result.data);
-      return original.call(this, context);
-    };
-    return descriptor;
-  };
+
+class AuthGuard {
+  canActivate(context) {
+    const authHeader = context.req.headers.get("Authorization");
+    return authHeader !== null && authHeader.length > 0;
+  }
 }
-function WithQuery(schema) {
+function setMethodRoles(target, propertyKey, roles) {
+  if (!rolesMethodMetadata.has(target)) {
+    rolesMethodMetadata.set(target, new Map);
+  }
+  rolesMethodMetadata.get(target)?.set(propertyKey, roles);
+}
+function getMethodRoles(target, propertyKey) {
+  return rolesMethodMetadata.get(target)?.get(propertyKey);
+}
+function Roles(...roles) {
   return (target, propertyKey, descriptor) => {
-    const original = descriptor.value;
-    descriptor.value = async function(context) {
-      const result = validateQuery(context, schema);
-      if (!result.success) {
-        return context.status(400).json({ error: "Validation failed", issues: result.issues });
-      }
-      context.set("query", result.data);
-      return original.call(this, context);
-    };
+    const targetObj = target;
+    setMethodRoles(targetObj, propertyKey, roles);
     return descriptor;
   };
 }
-function isStandardSchema(value) {
-  return typeof value === "object" && value !== null && "~standard" in value && typeof value["~standard"]?.validate === "function";
+
+class RolesGuard {
+  canActivate(context) {
+    const requiredRoles = context.requiredRoles;
+    if (!requiredRoles || requiredRoles.length === 0) {
+      return true;
+    }
+    const user = context.user;
+    if (!user || !user.roles) {
+      return false;
+    }
+    return requiredRoles.some((role) => user.roles?.includes(role));
+  }
 }
-function assertStandardSchema(schema, name = "Schema") {
-  if (!isStandardSchema(schema)) {
-    throw new Error(`${name} must implement Standard Schema interface. Supported: Zod 4+, Valibot v1+, ArkType, Typia 7+`);
+async function executeGuards(context, options) {
+  const {
+    globalGuards = [],
+    classGuards = [],
+    methodGuards = [],
+    resolveGuard
+  } = options;
+  const allGuards = [...globalGuards, ...classGuards, ...methodGuards];
+  for (const guard of allGuards) {
+    let guardInstance = null;
+    if (typeof guard === "function") {
+      const funcGuard = guard;
+      if (funcGuard.prototype && typeof funcGuard.prototype === "object" && "canActivate" in funcGuard.prototype) {
+        guardInstance = resolveGuard ? resolveGuard(guard) : null;
+        if (!guardInstance) {
+          const GuardClass = guard;
+          guardInstance = new GuardClass;
+        }
+      } else {
+        guardInstance = guard;
+      }
+    } else if (typeof guard === "object" && guard !== null) {
+      const objGuard = guard;
+      if ("canActivate" in objGuard && typeof objGuard.canActivate === "function") {
+        guardInstance = guard;
+      } else {
+        guardInstance = resolveGuard ? resolveGuard(guard) : null;
+      }
+    }
+    if (!guardInstance) {
+      console.warn("Guard could not be resolved:", guard);
+      continue;
+    }
+    let result;
+    if (typeof guardInstance === "function") {
+      result = await guardInstance(context);
+    } else {
+      result = await guardInstance.canActivate(context);
+    }
+    if (!result) {
+      return false;
+    }
   }
+  return true;
 }
-function validateEnvSync(schema, envVars) {
+function createForbiddenResponse() {
+  return new Response(JSON.stringify({
+    statusCode: 403,
+    error: "Forbidden",
+    message: "Access denied"
+  }), {
+    status: 403,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+var guardsClassMetadata, guardsMethodMetadata, rolesMethodMetadata;
+var init_guards = __esm(() => {
+  guardsClassMetadata = new WeakMap;
+  guardsMethodMetadata = new WeakMap;
+  rolesMethodMetadata = new WeakMap;
+});
+
+// src/validation/index.ts
+async function validate(schema, data) {
   try {
-    const result = validateSync(schema, envVars);
-    if (!result.success) {
-      const formattedIssues = result.issues.map((issue) => {
-        const path = issue.path?.join(".") || "root";
-        return {
-          ...issue,
-          message: `Environment variable validation failed for ${path}: ${issue.message}`
-        };
-      });
-      return {
-        success: false,
-        issues: formattedIssues
-      };
+    const result = await Promise.resolve(schema["~standard"].validate(data));
+    if ("value" in result) {
+      return { success: true, data: result.value };
     }
-    return result;
+    return {
+      success: false,
+      issues: [...result.issues]
+    };
   } catch (error) {
     return {
       success: false,
       issues: [
         {
-          message: `Environment variable validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+          message: error instanceof Error ? error.message : "Validation failed"
         }
       ]
     };
   }
 }
-
-// src/container/forward-ref.ts
-var FORWARD_REF_SYMBOL = Symbol.for("buno.forwardRef");
-function forwardRef(fn) {
-  return {
-    __forwardRef: FORWARD_REF_SYMBOL,
-    forwardRef: fn
-  };
-}
-function isForwardRef(value) {
-  return typeof value === "object" && value !== null && "__forwardRef" in value && "forwardRef" in value && typeof value.forwardRef === "function";
+function validateSync(schema, data) {
+  const result = schema["~standard"].validate(data);
+  if (result instanceof Promise) {
+    throw new Error("Schema uses async validation. Use validate() instead.");
+  }
+  if ("value" in result) {
+    return { success: true, data: result.value };
+  }
+  return { success: false, issues: [...result.issues] };
 }
-function resolveForwardRef(ref) {
-  if (isForwardRef(ref)) {
-    return ref.forwardRef();
+async function validateBody(context, schema) {
+  try {
+    const body = await context.body();
+    return validate(schema, body);
+  } catch (error) {
+    return {
+      success: false,
+      issues: [{ message: "Failed to parse request body" }]
+    };
   }
-  return ref;
 }
-
-// src/container/index.ts
-function createToken(description) {
-  return Symbol(description);
+function validateQuery(context, schema) {
+  return validateSync(schema, context.query);
 }
-var Token = createToken;
-
-class ResolutionStack {
-  stack = new Set;
-  lazyResolutions = new Map;
-  push(token) {
-    if (this.stack.has(token)) {
-      throw new Error("Circular dependency detected: Token already in resolution stack");
-    }
-    this.stack.add(token);
-  }
-  pop(token) {
-    this.stack.delete(token);
-  }
-  has(token) {
-    return this.stack.has(token);
-  }
-  markLazy(token, placeholder) {
-    this.lazyResolutions.set(token, placeholder);
-  }
-  hasLazy(token) {
-    return this.lazyResolutions.has(token);
-  }
-  getLazy(token) {
-    return this.lazyResolutions.get(token);
-  }
-  clearLazy(token) {
-    this.lazyResolutions.delete(token);
-  }
+function validateParams(context, schema) {
+  return validateSync(schema, context.params);
 }
-
-class Container2 {
-  providers = new Map;
-  resolutionStack = new ResolutionStack;
-  register(provider) {
-    if (this.providers.has(provider.token)) {
-      throw new Error(`Provider already registered for token: ${String(provider.token)}`);
-    }
-    this.providers.set(provider.token, {
-      provider: {
-        ...provider,
-        scope: provider.scope ?? "singleton"
-      }
-    });
-  }
-  registerAll(providers) {
-    for (const provider of providers) {
-      this.register(provider);
-    }
-  }
-  has(token) {
-    return this.providers.has(token);
-  }
-  resolve(token) {
-    const resolved = this.providers.get(token);
-    if (!resolved) {
-      throw new Error(`No provider registered for token: ${String(token)}`);
-    }
-    const { provider } = resolved;
-    if (this.resolutionStack.has(token)) {
-      return this.createLazyProxy(token, resolved);
-    }
-    if (provider.scope === "singleton" && resolved.instance !== undefined) {
-      return resolved.instance;
-    }
-    this.resolutionStack.push(token);
-    try {
-      const instance = this.createInstance(provider);
-      if (provider.scope === "singleton") {
-        resolved.instance = instance;
-      }
-      return instance;
-    } finally {
-      this.resolutionStack.pop(token);
-    }
-  }
-  createLazyProxy(token, resolved) {
-    const existingLazy = this.resolutionStack.getLazy(token);
-    if (existingLazy && existingLazy.instance) {
-      return existingLazy.instance;
-    }
-    const placeholder = {
-      resolved: false
-    };
-    this.resolutionStack.markLazy(token, placeholder);
-    const proxy = new Proxy({}, {
-      get: (target, prop) => {
-        if (placeholder.resolved && placeholder.instance) {
-          const value = placeholder.instance[prop];
-          return typeof value === "function" ? value.bind(placeholder.instance) : value;
-        }
-        if (resolved.instance !== undefined) {
-          placeholder.instance = resolved.instance;
-          placeholder.resolved = true;
-        } else {
-          if (prop === "then") {
-            return;
-          }
-        }
-        if (placeholder.instance) {
-          const value = placeholder.instance[prop];
-          return typeof value === "function" ? value.bind(placeholder.instance) : value;
-        }
-        return () => {
-          return;
-        };
-      },
-      set: (target, prop, value) => {
-        if (placeholder.instance) {
-          placeholder.instance[prop] = value;
-          return true;
-        }
-        return false;
-      },
-      has: (target, prop) => {
-        if (placeholder.instance) {
-          return prop in placeholder.instance;
-        }
-        return false;
+function validateHeaders(context, schema) {
+  const headers = {};
+  context.req.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return validateSync(schema, headers);
+}
+function createValidator(options) {
+  return async (context, next) => {
+    if (options.body) {
+      const result = await validateBody(context, options.body);
+      if (!result.success) {
+        return context.status(400).json({ error: "Validation failed", issues: result.issues });
       }
-    });
-    placeholder.instance = proxy;
-    return proxy;
-  }
-  createInstance(provider) {
-    if (provider.useValue !== undefined) {
-      return provider.useValue;
+      context.set("validatedBody", result.data);
     }
-    if (provider.useFactory) {
-      const deps = this.resolveDeps(provider.inject ?? []);
-      return provider.useFactory(...deps);
+    if (options.query) {
+      const result = validateQuery(context, options.query);
+      if (!result.success) {
+        return context.status(400).json({ error: "Validation failed", issues: result.issues });
+      }
+      context.set("validatedQuery", result.data);
     }
-    if (provider.useClass) {
-      const deps = this.resolveDeps(provider.inject ?? []);
-      return new provider.useClass(...deps);
+    if (options.params) {
+      const result = validateParams(context, options.params);
+      if (!result.success) {
+        return context.status(400).json({ error: "Validation failed", issues: result.issues });
+      }
+      context.set("validatedParams", result.data);
     }
-    throw new Error(`Invalid provider configuration for token: ${String(provider.token)}`);
-  }
-  resolveDeps(tokens) {
-    return tokens.map((tokenOrRef) => {
-      const token = resolveForwardRef(tokenOrRef);
-      return this.resolve(token);
-    });
-  }
-  clear() {
-    this.providers.clear();
-  }
-  getTokens() {
-    return Array.from(this.providers.keys());
-  }
-  createChild() {
-    const child = new Container2;
-    for (const [token, resolved] of this.providers) {
-      if (resolved.provider.scope === "singleton") {
-        child.providers.set(token, resolved);
+    if (options.headers) {
+      const result = validateHeaders(context, options.headers);
+      if (!result.success) {
+        return context.status(400).json({ error: "Validation failed", issues: result.issues });
       }
+      context.set("validatedHeaders", result.data);
     }
-    return child;
-  }
-}
-var containerMetadata = new WeakMap;
-function setContainerMetadata(target, key, value) {
-  if (!containerMetadata.has(target)) {
-    containerMetadata.set(target, new Map);
-  }
-  containerMetadata.get(target)?.set(key, value);
-}
-function getContainerMetadata(target, key) {
-  return containerMetadata.get(target)?.get(key);
+    return next();
+  };
 }
-function Injectable(token) {
-  return (target) => {
-    setContainerMetadata(target, "injectable", true);
-    if (token) {
-      setContainerMetadata(target, "token", token);
-    }
-    return target;
+function WithBody(schema) {
+  return (target, propertyKey, descriptor) => {
+    const original = descriptor.value;
+    descriptor.value = async function(context) {
+      const result = await validateBody(context, schema);
+      if (!result.success) {
+        return context.status(400).json({ error: "Validation failed", issues: result.issues });
+      }
+      context.set("body", result.data);
+      return original.call(this, context);
+    };
+    return descriptor;
   };
 }
-function Inject(token) {
-  return (target, propertyKey, parameterIndex) => {
-    const targetObj = target;
-    const existingTokens = getContainerMetadata(targetObj, "inject:tokens") ?? [];
-    existingTokens[parameterIndex] = token;
-    setContainerMetadata(targetObj, "inject:tokens", existingTokens);
+function WithQuery(schema) {
+  return (target, propertyKey, descriptor) => {
+    const original = descriptor.value;
+    descriptor.value = async function(context) {
+      const result = validateQuery(context, schema);
+      if (!result.success) {
+        return context.status(400).json({ error: "Validation failed", issues: result.issues });
+      }
+      context.set("query", result.data);
+      return original.call(this, context);
+    };
+    return descriptor;
   };
 }
+function isStandardSchema(value) {
+  return typeof value === "object" && value !== null && "~standard" in value && typeof value["~standard"]?.validate === "function";
+}
+function assertStandardSchema(schema, name = "Schema") {
+  if (!isStandardSchema(schema)) {
+    throw new Error(`${name} must implement Standard Schema interface. Supported: Zod 4+, Valibot v1+, ArkType, Typia 7+`);
+  }
+}
+function validateEnvSync(schema, envVars) {
+  try {
+    const result = validateSync(schema, envVars);
+    if (!result.success) {
+      const formattedIssues = result.issues.map((issue) => {
+        const path = issue.path?.join(".") || "root";
+        return {
+          ...issue,
+          message: `Environment variable validation failed for ${path}: ${issue.message}`
+        };
+      });
+      return {
+        success: false,
+        issues: formattedIssues
+      };
+    }
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      issues: [
+        {
+          message: `Environment variable validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+        }
+      ]
+    };
+  }
+}
+
 // src/router/linear.ts
 function patternToRegex(pattern) {
   const paramNames = [];
@@ -1498,6 +1664,9 @@ class NotFoundError extends BuenoError {
   }
 }
 
+// src/modules/index.ts
+init_container();
+
 // src/modules/filters.ts
 var filterMetadataStore = new WeakMap;
 var catchMetadataStore = new WeakMap;
@@ -1698,134 +1867,8 @@ function createInternalErrorResponse(exception) {
   });
 }
 
-// src/modules/guards.ts
-var guardsClassMetadata = new WeakMap;
-var guardsMethodMetadata = new WeakMap;
-function setClassGuards(target, guards) {
-  guardsClassMetadata.set(target, guards);
-}
-function getClassGuards(target) {
-  return guardsClassMetadata.get(target);
-}
-function setMethodGuards(target, propertyKey, guards) {
-  if (!guardsMethodMetadata.has(target)) {
-    guardsMethodMetadata.set(target, new Map);
-  }
-  guardsMethodMetadata.get(target)?.set(propertyKey, guards);
-}
-function getMethodGuards(target, propertyKey) {
-  return guardsMethodMetadata.get(target)?.get(propertyKey);
-}
-function UseGuards(...guards) {
-  const decorator = (target, propertyKey, descriptor) => {
-    if (propertyKey !== undefined && descriptor !== undefined) {
-      const targetObj = target;
-      const existingGuards = getMethodGuards(targetObj, propertyKey) ?? [];
-      setMethodGuards(targetObj, propertyKey, [...existingGuards, ...guards]);
-      return descriptor;
-    } else {
-      const targetClass = target;
-      const existingGuards = getClassGuards(targetClass) ?? [];
-      setClassGuards(targetClass, [...existingGuards, ...guards]);
-    }
-  };
-  return decorator;
-}
-
-class AuthGuard {
-  canActivate(context) {
-    const authHeader = context.req.headers.get("Authorization");
-    return authHeader !== null && authHeader.length > 0;
-  }
-}
-var rolesMethodMetadata = new WeakMap;
-function setMethodRoles(target, propertyKey, roles) {
-  if (!rolesMethodMetadata.has(target)) {
-    rolesMethodMetadata.set(target, new Map);
-  }
-  rolesMethodMetadata.get(target)?.set(propertyKey, roles);
-}
-function getMethodRoles(target, propertyKey) {
-  return rolesMethodMetadata.get(target)?.get(propertyKey);
-}
-function Roles(...roles) {
-  return (target, propertyKey, descriptor) => {
-    const targetObj = target;
-    setMethodRoles(targetObj, propertyKey, roles);
-    return descriptor;
-  };
-}
-
-class RolesGuard {
-  canActivate(context) {
-    const requiredRoles = context.requiredRoles;
-    if (!requiredRoles || requiredRoles.length === 0) {
-      return true;
-    }
-    const user = context.user;
-    if (!user || !user.roles) {
-      return false;
-    }
-    return requiredRoles.some((role) => user.roles?.includes(role));
-  }
-}
-async function executeGuards(context, options) {
-  const {
-    globalGuards = [],
-    classGuards = [],
-    methodGuards = [],
-    resolveGuard
-  } = options;
-  const allGuards = [...globalGuards, ...classGuards, ...methodGuards];
-  for (const guard of allGuards) {
-    let guardInstance = null;
-    if (typeof guard === "function") {
-      const funcGuard = guard;
-      if (funcGuard.prototype && typeof funcGuard.prototype === "object" && "canActivate" in funcGuard.prototype) {
-        guardInstance = resolveGuard ? resolveGuard(guard) : null;
-        if (!guardInstance) {
-          const GuardClass = guard;
-          guardInstance = new GuardClass;
-        }
-      } else {
-        guardInstance = guard;
-      }
-    } else if (typeof guard === "object" && guard !== null) {
-      const objGuard = guard;
-      if ("canActivate" in objGuard && typeof objGuard.canActivate === "function") {
-        guardInstance = guard;
-      } else {
-        guardInstance = resolveGuard ? resolveGuard(guard) : null;
-      }
-    }
-    if (!guardInstance) {
-      console.warn("Guard could not be resolved:", guard);
-      continue;
-    }
-    let result;
-    if (typeof guardInstance === "function") {
-      result = await guardInstance(context);
-    } else {
-      result = await guardInstance.canActivate(context);
-    }
-    if (!result) {
-      return false;
-    }
-  }
-  return true;
-}
-function createForbiddenResponse() {
-  return new Response(JSON.stringify({
-    statusCode: 403,
-    error: "Forbidden",
-    message: "Access denied"
-  }), {
-    status: 403,
-    headers: {
-      "Content-Type": "application/json"
-    }
-  });
-}
+// src/modules/index.ts
+init_guards();
 
 // src/modules/interceptors.ts
 var interceptorsClassMetadata = new WeakMap;
@@ -2700,7 +2743,10 @@ function isPipeTransform(value) {
 function isPipeFn(value) {
   return typeof value === "function" && !isPipeTransform(value);
 }
+
 // src/modules/index.ts
+init_guards();
+init_container();
 function Inject2(token) {
   return (target, propertyKey, parameterIndex) => {
     const targetObj = target;
@@ -2804,6 +2850,7 @@ class Application {
   routeInterceptorMetadata = new Map;
   moduleLoader;
   loadedLazyModules = new Set;
+  websocketHandler = null;
   constructor(moduleClass) {
     this.container = new Container2;
     this.router = new Router;
@@ -2816,6 +2863,15 @@ class Application {
     this.globalGuards.push(...guards);
     return this;
   }
+  getGlobalGuards() {
+    return this.globalGuards;
+  }
+  getGlobalInterceptors() {
+    return this.globalInterceptors;
+  }
+  setWebSocketHandler(handler) {
+    this.websocketHandler = handler;
+  }
   useGlobalPipes(...pipes) {
     this.globalPipes.push(...pipes);
     return this;
@@ -2989,7 +3045,16 @@ class Application {
     this.server = Bun.serve({
       port,
       hostname,
-      fetch: async (request) => {
+      ...this.websocketHandler ? { websocket: this.websocketHandler } : {},
+      fetch: async (request, server) => {
+        if (this.websocketHandler && request.headers.get("upgrade")?.toLowerCase() === "websocket") {
+          const wsUpgradeHandler = this.websocketHandler.__upgradeHandler;
+          if (wsUpgradeHandler) {
+            const response = wsUpgradeHandler(request, server);
+            if (response)
+              return response;
+          }
+        }
         if (this.isShuttingDown) {
           return new Response("Service Unavailable", { status: 503 });
         }