nextrush 3.0.5 → 4.0.0-beta.0

package/dist/class.d.ts

@@ -1,3 +1,105 @@
-export { AutoInjectable, ClassProvider, Config, ConfigOptions, ContainerInterface, FactoryProvider, Injectable, Optional, Provider, Repository, Scope, Service, ServiceOptions, Token, ValueProvider, container, createContainer, delay, inject } from '@nextrush/di';
-export { All, Body, BodyOptions, CanActivate, Controller, ControllerMetadata, ControllerOptions, Ctx, CustomParamExtractor, Delete, Get, GuardContext, GuardFn, Head, Header, HeaderOptions, Options, Param, ParamMetadata, ParamOptions, ParamSource, Patch, Post, Put, Query, QueryOptions, Redirect, Req, Res, RouteMetadata, RouteOptions, SetHeader, TransformFn, UseGuard, createCustomParamDecorator } from '@nextrush/decorators';
-export { ControllersPluginOptions, controllersPlugin } from '@nextrush/controllers';
+import * as _nextrush_class from '@nextrush/class';
+export { BodyOptions, CanActivate, ControllerMetadata, ControllerOptions, ControllerRouteMetadata, ControllersOptions, CustomParamExtractor, ExceptionFilter, GuardContext, GuardFn, HeaderOptions, Interceptor, ModuleMetadata, ModuleOptions, ModuleProvider, ModuleProviderConfig, ModuleRegistrationOptions, OnInit, OnShutdown, ParamMetadata, ParamOptions, ParamSource, QueryOptions, RouteMetadata, RouteOptions, TransformFn } from '@nextrush/class';
+import * as _nextrush_types from '@nextrush/types';
+import * as _nextrush_di from '@nextrush/di';
+export { ClassProvider, ConfigOptions, Container, FactoryProvider, Provider, Scope, ServiceOptions, Token, ValueProvider } from '@nextrush/di';
+
+/**
+ * NextRush Class-Based API — Decorators, DI, and Controllers
+ *
+ * Import from `nextrush/class` when using the class-based paradigm.
+ * This entry point auto-loads `reflect-metadata` and re-exports all
+ * DI, decorator, and controller APIs in a single import.
+ *
+ * Functional users who only need `createApp` / `createRouter` should
+ * import from `nextrush` (the default entry) — no reflect-metadata overhead.
+ *
+ * @packageDocumentation
+ * @module nextrush/class
+ *
+ * @example
+ * ```typescript
+ * import { createApp, listen } from 'nextrush';
+ * import { Controller, Get, Service, registerControllers } from 'nextrush/class';
+ *
+ * @Service()
+ * class UserService {
+ *   findAll() { return [{ id: 1, name: 'Alice' }]; }
+ * }
+ *
+ * @Controller('/users')
+ * class UserController {
+ *   constructor(private users: UserService) {}
+ *
+ *   @Get()
+ *   findAll() { return this.users.findAll(); }
+ * }
+ *
+ * const app = createApp();
+ * await registerControllers(app, { root: './src' });
+ * await listen(app, 8080);
+ * ```
+ */
+declare const Config: typeof _nextrush_di.Config;
+declare const container: _nextrush_types.Container;
+declare const createContainer: typeof _nextrush_di.createContainer;
+declare const delay: typeof _nextrush_di.delay;
+declare const inject: typeof _nextrush_di.inject;
+declare const Injectable: typeof _nextrush_di.Injectable;
+declare const Optional: typeof _nextrush_di.Optional;
+declare const Repository: typeof _nextrush_di.Repository;
+declare const Service: typeof _nextrush_di.Service;
+
+declare const All: (pathOrOptions?: string | _nextrush_class.RouteOptions, options?: _nextrush_class.RouteOptions) => MethodDecorator;
+declare const Body: {
+    (): ParameterDecorator;
+    (property: string): ParameterDecorator;
+    (options: _nextrush_class.BodyOptions): ParameterDecorator;
+    (property: string, options: _nextrush_class.BodyOptions): ParameterDecorator;
+};
+declare const Controller: typeof _nextrush_class.Controller;
+declare const Module: typeof _nextrush_class.Module;
+declare const createCustomParamDecorator: typeof _nextrush_class.createCustomParamDecorator;
+declare const Ctx: typeof _nextrush_class.Ctx;
+declare const Delete: (pathOrOptions?: string | _nextrush_class.RouteOptions, options?: _nextrush_class.RouteOptions) => MethodDecorator;
+declare const Get: (pathOrOptions?: string | _nextrush_class.RouteOptions, options?: _nextrush_class.RouteOptions) => MethodDecorator;
+declare const Head: (pathOrOptions?: string | _nextrush_class.RouteOptions, options?: _nextrush_class.RouteOptions) => MethodDecorator;
+declare const Header: {
+    (): ParameterDecorator;
+    (name: string): ParameterDecorator;
+    (options: _nextrush_class.HeaderOptions): ParameterDecorator;
+    (name: string, options: _nextrush_class.HeaderOptions): ParameterDecorator;
+};
+declare const HttpCode: typeof _nextrush_class.HttpCode;
+declare const Options: (pathOrOptions?: string | _nextrush_class.RouteOptions, options?: _nextrush_class.RouteOptions) => MethodDecorator;
+declare const Param: {
+    (): ParameterDecorator;
+    (name: string): ParameterDecorator;
+    (options: _nextrush_class.ParamOptions): ParameterDecorator;
+    (name: string, options: _nextrush_class.ParamOptions): ParameterDecorator;
+};
+declare const Patch: (pathOrOptions?: string | _nextrush_class.RouteOptions, options?: _nextrush_class.RouteOptions) => MethodDecorator;
+declare const Post: (pathOrOptions?: string | _nextrush_class.RouteOptions, options?: _nextrush_class.RouteOptions) => MethodDecorator;
+declare const Put: (pathOrOptions?: string | _nextrush_class.RouteOptions, options?: _nextrush_class.RouteOptions) => MethodDecorator;
+declare const Query: {
+    (): ParameterDecorator;
+    (name: string): ParameterDecorator;
+    (options: _nextrush_class.QueryOptions): ParameterDecorator;
+    (name: string, options: _nextrush_class.QueryOptions): ParameterDecorator;
+};
+declare const Redirect: typeof _nextrush_class.Redirect;
+declare const Req: typeof _nextrush_class.Req;
+declare const Res: typeof _nextrush_class.Res;
+declare const SetHeader: typeof _nextrush_class.SetHeader;
+declare const UseGuard: typeof _nextrush_class.UseGuard;
+declare const Catch: typeof _nextrush_class.Catch;
+declare const UseFilter: typeof _nextrush_class.UseFilter;
+declare const UseInterceptor: typeof _nextrush_class.UseInterceptor;
+declare const isOnInit: typeof _nextrush_class.isOnInit;
+declare const isOnShutdown: typeof _nextrush_class.isOnShutdown;
+declare const getModuleMetadata: typeof _nextrush_class.getModuleMetadata;
+declare const isModule: typeof _nextrush_class.isModule;
+declare const registerControllers: typeof _nextrush_class.registerControllers;
+declare const registerModule: typeof _nextrush_class.registerModule;
+
+export { All, Body, Catch, Config, Controller, Ctx, Delete, Get, Head, Header, HttpCode, Injectable, Module, Optional, Options, Param, Patch, Post, Put, Query, Redirect, Repository, Req, Res, Service, SetHeader, UseFilter, UseGuard, UseInterceptor, container, createContainer, createCustomParamDecorator, delay, getModuleMetadata, inject, isModule, isOnInit, isOnShutdown, registerControllers, registerModule };

package/dist/class.js

@@ -1,33 +1,75 @@
-// src/class.ts
-import "reflect-metadata";
-import { AutoInjectable, Config, container, createContainer, delay, inject, Injectable, Optional, Repository, Service } from "@nextrush/di";
 import {
-  All,
-  Body,
-  Controller,
-  createCustomParamDecorator,
-  Ctx,
-  Delete,
-  Get,
-  Head,
-  Header,
-  Options,
-  Param,
-  Patch,
-  Post,
-  Put,
-  Query,
-  Redirect,
-  Req,
-  Res,
-  SetHeader,
-  UseGuard
-} from "@nextrush/decorators";
-import { controllersPlugin } from "@nextrush/controllers";
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/class-peer-guard.ts
+var MISSING_MODULE_PATTERN = /Cannot find (?:module|package) '(@nextrush\/class|@nextrush\/di|reflect-metadata)'/;
+function describeMissingClassPeerError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (!MISSING_MODULE_PATTERN.test(message)) {
+    return null;
+  }
+  return "nextrush/class requires @nextrush/class and reflect-metadata as optional peer dependencies, which are not installed in this project. Install them:\n  pnpm add @nextrush/class reflect-metadata";
+}
+__name(describeMissingClassPeerError, "describeMissingClassPeerError");
+
+// src/class.ts
+var di;
+var cls;
+try {
+  await import("reflect-metadata");
+  di = await import("@nextrush/di");
+  cls = await import("@nextrush/class");
+} catch (err) {
+  const guardedMessage = describeMissingClassPeerError(err);
+  throw guardedMessage ? new Error(guardedMessage, {
+    cause: err
+  }) : err;
+}
+var Config = di.Config;
+var container = di.container;
+var createContainer = di.createContainer;
+var delay = di.delay;
+var inject = di.inject;
+var Injectable = di.Injectable;
+var Optional = di.Optional;
+var Repository = di.Repository;
+var Service = di.Service;
+var All = cls.All;
+var Body = cls.Body;
+var Controller = cls.Controller;
+var Module = cls.Module;
+var createCustomParamDecorator = cls.createCustomParamDecorator;
+var Ctx = cls.Ctx;
+var Delete = cls.Delete;
+var Get = cls.Get;
+var Head = cls.Head;
+var Header = cls.Header;
+var HttpCode = cls.HttpCode;
+var Options = cls.Options;
+var Param = cls.Param;
+var Patch = cls.Patch;
+var Post = cls.Post;
+var Put = cls.Put;
+var Query = cls.Query;
+var Redirect = cls.Redirect;
+var Req = cls.Req;
+var Res = cls.Res;
+var SetHeader = cls.SetHeader;
+var UseGuard = cls.UseGuard;
+var Catch = cls.Catch;
+var UseFilter = cls.UseFilter;
+var UseInterceptor = cls.UseInterceptor;
+var isOnInit = cls.isOnInit;
+var isOnShutdown = cls.isOnShutdown;
+var getModuleMetadata = cls.getModuleMetadata;
+var isModule = cls.isModule;
+var registerControllers = cls.registerControllers;
+var registerModule = cls.registerModule;
 export {
   All,
-  AutoInjectable,
   Body,
+  Catch,
   Config,
   Controller,
   Ctx,
@@ -35,7 +77,9 @@ export {
   Get,
   Head,
   Header,
+  HttpCode,
   Injectable,
+  Module,
   Optional,
   Options,
   Param,
@@ -49,12 +93,19 @@ export {
   Res,
   Service,
   SetHeader,
+  UseFilter,
   UseGuard,
+  UseInterceptor,
   container,
-  controllersPlugin,
   createContainer,
   createCustomParamDecorator,
   delay,
-  inject
+  getModuleMetadata,
+  inject,
+  isModule,
+  isOnInit,
+  isOnShutdown,
+  registerControllers,
+  registerModule
 };
 //# sourceMappingURL=class.js.map

package/dist/class.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/class.ts"],"sourcesContent":["/**\n * NextRush Class-Based API — Decorators, DI, and Controllers\n *\n * Import from `nextrush/class` when using the class-based paradigm.\n * This entry point auto-loads `reflect-metadata` and re-exports all\n * DI, decorator, and controller APIs in a single import.\n *\n * Functional users who only need `createApp` / `createRouter` should\n * import from `nextrush` (the default entry) — no reflect-metadata overhead.\n *\n * @packageDocumentation\n * @module nextrush/class\n *\n * @example\n * ```typescript\n * import { createApp, listen } from 'nextrush';\n * import { Controller, Get, Service, controllersPlugin } from 'nextrush/class';\n *\n * @Service()\n * class UserService {\n *   findAll() { return [{ id: 1, name: 'Alice' }]; }\n * }\n *\n * @Controller('/users')\n * class UserController {\n *   constructor(private users: UserService) {}\n *\n *   @Get()\n *   findAll() { return this.users.findAll(); }\n * }\n *\n * const app = createApp();\n * app.plugin(controllersPlugin({ root: './src' }));\n * listen(app, 3000);\n * ```\n */\n\n// Side-effect: ensure reflect-metadata polyfill is loaded for DI/decorators.\n// This runs once when 'nextrush/class' is imported — no manual import needed.\nimport 'reflect-metadata';\n\n// ============================================\n// DI: Dependency Injection Container\n// ============================================\nexport {\n  AutoInjectable,\n  Config,\n  container,\n  createContainer,\n  delay,\n  inject,\n  Injectable,\n  Optional,\n  Repository,\n  Service,\n} from '@nextrush/di';\nexport type {\n  ClassProvider,\n  ConfigOptions,\n  ContainerInterface,\n  FactoryProvider,\n  Provider,\n  Scope,\n  ServiceOptions,\n  Token,\n  ValueProvider,\n} from '@nextrush/di';\n\n// ============================================\n// DECORATORS: Controller, Route & Parameter\n// ============================================\nexport {\n  // Route decorators\n  All,\n  // Parameter decorators\n  Body,\n  // Class decorators\n  Controller,\n  // Custom param decorator factory\n  createCustomParamDecorator,\n  Ctx,\n  Delete,\n  Get,\n  Head,\n  Header,\n  Options,\n  Param,\n  Patch,\n  Post,\n  Put,\n  Query,\n  // Response decorators\n  Redirect,\n  Req,\n  Res,\n  SetHeader,\n  // Guard decorators\n  UseGuard,\n} from '@nextrush/decorators';\nexport type {\n  BodyOptions,\n  CanActivate,\n  ControllerMetadata,\n  ControllerOptions,\n  CustomParamExtractor,\n  GuardContext,\n  GuardFn,\n  HeaderOptions,\n  ParamMetadata,\n  ParamOptions,\n  ParamSource,\n  QueryOptions,\n  RouteMetadata,\n  RouteOptions,\n  TransformFn,\n} from '@nextrush/decorators';\n\n// ============================================\n// CONTROLLERS: Auto-discovery Plugin\n// ============================================\nexport { controllersPlugin } from '@nextrush/controllers';\nexport type { ControllersPluginOptions } from '@nextrush/controllers';\n"],"mappings":";AAuCA,OAAO;AAKP,SACEA,gBACAC,QACAC,WACAC,iBACAC,OACAC,QACAC,YACAC,UACAC,YACAC,eACK;AAgBP;EAEEC;EAEAC;EAEAC;EAEAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EAEAC;EACAC;EACAC;EACAC;EAEAC;OACK;AAsBP,SAASC,yBAAyB;","names":["AutoInjectable","Config","container","createContainer","delay","inject","Injectable","Optional","Repository","Service","All","Body","Controller","createCustomParamDecorator","Ctx","Delete","Get","Head","Header","Options","Param","Patch","Post","Put","Query","Redirect","Req","Res","SetHeader","UseGuard","controllersPlugin"]}
+{"version":3,"sources":["../src/class-peer-guard.ts","../src/class.ts"],"sourcesContent":["/**\n * Resolution guard for the `nextrush/class` subpath's optional peer dependencies.\n *\n * `@nextrush/class`, `@nextrush/di`, and `reflect-metadata` are OPTIONAL peer dependencies of\n * `nextrush` (see docs/RFC/framework-composition/020-framework-composition-integrity.md) — a\n * functional-only install never resolves them. When a consumer imports `nextrush/class`\n * without having installed the peer, the resulting module-not-found error is opaque. This\n * module recognizes that specific failure and rewrites it into an actionable message naming\n * the missing package and the exact install command, without swallowing unrelated errors.\n */\n\nconst MISSING_MODULE_PATTERN = /Cannot find (?:module|package) '(@nextrush\\/class|@nextrush\\/di|reflect-metadata)'/;\n\n/**\n * Given an error thrown while loading `nextrush/class`, return an actionable message if it is\n * the specific \"the optional class/DI peer is not installed\" case, or `null` if the error is\n * unrelated (in which case the caller should re-throw the original error unchanged).\n */\nexport function describeMissingClassPeerError(err: unknown): string | null {\n  const message = err instanceof Error ? err.message : String(err);\n  if (!MISSING_MODULE_PATTERN.test(message)) {\n    return null;\n  }\n\n  return (\n    'nextrush/class requires @nextrush/class and reflect-metadata as optional peer ' +\n    'dependencies, which are not installed in this project. Install them:\\n' +\n    '  pnpm add @nextrush/class reflect-metadata'\n  );\n}\n","/**\n * NextRush Class-Based API — Decorators, DI, and Controllers\n *\n * Import from `nextrush/class` when using the class-based paradigm.\n * This entry point auto-loads `reflect-metadata` and re-exports all\n * DI, decorator, and controller APIs in a single import.\n *\n * Functional users who only need `createApp` / `createRouter` should\n * import from `nextrush` (the default entry) — no reflect-metadata overhead.\n *\n * @packageDocumentation\n * @module nextrush/class\n *\n * @example\n * ```typescript\n * import { createApp, listen } from 'nextrush';\n * import { Controller, Get, Service, registerControllers } from 'nextrush/class';\n *\n * @Service()\n * class UserService {\n *   findAll() { return [{ id: 1, name: 'Alice' }]; }\n * }\n *\n * @Controller('/users')\n * class UserController {\n *   constructor(private users: UserService) {}\n *\n *   @Get()\n *   findAll() { return this.users.findAll(); }\n * }\n *\n * const app = createApp();\n * await registerControllers(app, { root: './src' });\n * await listen(app, 8080);\n * ```\n */\n\n// ============================================\n// OPTIONAL-PEER LOADING (framework-composition-integrity)\n// ============================================\n//\n// @nextrush/class, @nextrush/di, and reflect-metadata are OPTIONAL peer dependencies of\n// `nextrush` (see docs/RFC/framework-composition/020-framework-composition-integrity.md) — a\n// functional-only install never resolves them. A STATIC `export { X } from '@nextrush/class'`\n// would fail module LINKING (before any module body runs) with an opaque Node error the moment\n// that package is unresolvable — there is no way to catch a static specifier's resolution\n// failure from inside the module. So every RUNTIME (value) export below is loaded dynamically\n// and re-exported by re-assignment, letting this try/catch convert a missing-peer failure into\n// an actionable message. `export type` declarations stay static: type-only specifiers are\n// erased before runtime and never cause a module-resolution failure, so they are unaffected.\nimport { describeMissingClassPeerError } from './class-peer-guard.js';\n\ntype DiModule = typeof import('@nextrush/di');\ntype ClassModule = typeof import('@nextrush/class');\n\nlet di: DiModule;\nlet cls: ClassModule;\n\ntry {\n  await import('reflect-metadata');\n  di = await import('@nextrush/di');\n  cls = await import('@nextrush/class');\n} catch (err) {\n  const guardedMessage = describeMissingClassPeerError(err);\n  throw guardedMessage ? new Error(guardedMessage, { cause: err }) : err;\n}\n\n// ============================================\n// DI: Dependency Injection Container\n// ============================================\nexport const Config = di.Config;\nexport const container = di.container;\nexport const createContainer = di.createContainer;\nexport const delay = di.delay;\nexport const inject = di.inject;\nexport const Injectable = di.Injectable;\nexport const Optional = di.Optional;\nexport const Repository = di.Repository;\nexport const Service = di.Service;\n\nexport type {\n  ClassProvider,\n  ConfigOptions,\n  Container,\n  FactoryProvider,\n  Provider,\n  Scope,\n  ServiceOptions,\n  Token,\n  ValueProvider,\n} from '@nextrush/di';\n\n// ============================================\n// DECORATORS & CONTROLLERS: From @nextrush/class\n// ============================================\nexport const All = cls.All;\nexport const Body = cls.Body;\nexport const Controller = cls.Controller;\nexport const Module = cls.Module;\nexport const createCustomParamDecorator = cls.createCustomParamDecorator;\nexport const Ctx = cls.Ctx;\nexport const Delete = cls.Delete;\nexport const Get = cls.Get;\nexport const Head = cls.Head;\nexport const Header = cls.Header;\nexport const HttpCode = cls.HttpCode;\nexport const Options = cls.Options;\nexport const Param = cls.Param;\nexport const Patch = cls.Patch;\nexport const Post = cls.Post;\nexport const Put = cls.Put;\nexport const Query = cls.Query;\nexport const Redirect = cls.Redirect;\nexport const Req = cls.Req;\nexport const Res = cls.Res;\nexport const SetHeader = cls.SetHeader;\nexport const UseGuard = cls.UseGuard;\nexport const Catch = cls.Catch;\nexport const UseFilter = cls.UseFilter;\nexport const UseInterceptor = cls.UseInterceptor;\nexport const isOnInit = cls.isOnInit;\nexport const isOnShutdown = cls.isOnShutdown;\nexport const getModuleMetadata = cls.getModuleMetadata;\nexport const isModule = cls.isModule;\nexport const registerControllers = cls.registerControllers;\nexport const registerModule = cls.registerModule;\n\nexport type {\n  // Decorators\n  BodyOptions,\n  CanActivate,\n  ControllerMetadata,\n  ControllerOptions,\n  ControllerRouteMetadata,\n  CustomParamExtractor,\n  ExceptionFilter,\n  GuardContext,\n  GuardFn,\n  HeaderOptions,\n  Interceptor,\n  ModuleMetadata,\n  ModuleOptions,\n  ModuleProvider,\n  ModuleProviderConfig,\n  ParamMetadata,\n  ParamOptions,\n  ParamSource,\n  QueryOptions,\n  /** @deprecated Use ControllerRouteMetadata. Removed in the next major. */\n  RouteMetadata,\n  RouteOptions,\n  TransformFn,\n  OnInit,\n  OnShutdown,\n  // Controllers\n  ControllersOptions,\n  ModuleRegistrationOptions,\n} from '@nextrush/class';\n"],"mappings":";;;;;AAWA,IAAMA,yBAAyB;AAOxB,SAASC,8BAA8BC,KAAY;AACxD,QAAMC,UAAUD,eAAeE,QAAQF,IAAIC,UAAUE,OAAOH,GAAAA;AAC5D,MAAI,CAACF,uBAAuBM,KAAKH,OAAAA,GAAU;AACzC,WAAO;EACT;AAEA,SACE;AAIJ;AAXgBF;;;ACqChB,IAAIM;AACJ,IAAIC;AAEJ,IAAI;AACF,QAAM,OAAO,kBAAA;AACbD,OAAK,MAAM,OAAO,cAAA;AAClBC,QAAM,MAAM,OAAO,iBAAA;AACrB,SAASC,KAAK;AACZ,QAAMC,iBAAiBC,8BAA8BF,GAAAA;AACrD,QAAMC,iBAAiB,IAAIE,MAAMF,gBAAgB;IAAEG,OAAOJ;EAAI,CAAA,IAAKA;AACrE;AAKO,IAAMK,SAASP,GAAGO;AAClB,IAAMC,YAAYR,GAAGQ;AACrB,IAAMC,kBAAkBT,GAAGS;AAC3B,IAAMC,QAAQV,GAAGU;AACjB,IAAMC,SAASX,GAAGW;AAClB,IAAMC,aAAaZ,GAAGY;AACtB,IAAMC,WAAWb,GAAGa;AACpB,IAAMC,aAAad,GAAGc;AACtB,IAAMC,UAAUf,GAAGe;AAiBnB,IAAMC,MAAMf,IAAIe;AAChB,IAAMC,OAAOhB,IAAIgB;AACjB,IAAMC,aAAajB,IAAIiB;AACvB,IAAMC,SAASlB,IAAIkB;AACnB,IAAMC,6BAA6BnB,IAAImB;AACvC,IAAMC,MAAMpB,IAAIoB;AAChB,IAAMC,SAASrB,IAAIqB;AACnB,IAAMC,MAAMtB,IAAIsB;AAChB,IAAMC,OAAOvB,IAAIuB;AACjB,IAAMC,SAASxB,IAAIwB;AACnB,IAAMC,WAAWzB,IAAIyB;AACrB,IAAMC,UAAU1B,IAAI0B;AACpB,IAAMC,QAAQ3B,IAAI2B;AAClB,IAAMC,QAAQ5B,IAAI4B;AAClB,IAAMC,OAAO7B,IAAI6B;AACjB,IAAMC,MAAM9B,IAAI8B;AAChB,IAAMC,QAAQ/B,IAAI+B;AAClB,IAAMC,WAAWhC,IAAIgC;AACrB,IAAMC,MAAMjC,IAAIiC;AAChB,IAAMC,MAAMlC,IAAIkC;AAChB,IAAMC,YAAYnC,IAAImC;AACtB,IAAMC,WAAWpC,IAAIoC;AACrB,IAAMC,QAAQrC,IAAIqC;AAClB,IAAMC,YAAYtC,IAAIsC;AACtB,IAAMC,iBAAiBvC,IAAIuC;AAC3B,IAAMC,WAAWxC,IAAIwC;AACrB,IAAMC,eAAezC,IAAIyC;AACzB,IAAMC,oBAAoB1C,IAAI0C;AAC9B,IAAMC,WAAW3C,IAAI2C;AACrB,IAAMC,sBAAsB5C,IAAI4C;AAChC,IAAMC,iBAAiB7C,IAAI6C;","names":["MISSING_MODULE_PATTERN","describeMissingClassPeerError","err","message","Error","String","test","di","cls","err","guardedMessage","describeMissingClassPeerError","Error","cause","Config","container","createContainer","delay","inject","Injectable","Optional","Repository","Service","All","Body","Controller","Module","createCustomParamDecorator","Ctx","Delete","Get","Head","Header","HttpCode","Options","Param","Patch","Post","Put","Query","Redirect","Req","Res","SetHeader","UseGuard","Catch","UseFilter","UseInterceptor","isOnInit","isOnShutdown","getModuleMetadata","isModule","registerControllers","registerModule"]}

package/dist/dev-cli-launcher.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Thin launcher for the `nextrush` meta-package's `bin`.
+ *
+ * `@nextrush/dev` is an optional dev-time toolkit, not a runtime dependency of `nextrush`
+ * (docs/RFC/framework-composition/020-framework-composition-integrity.md §21; ADR-0013). This
+ * launcher resolves it on demand: when present it delegates to its CLI transparently; when absent
+ * it prints an actionable, package-manager-aware install message and exits non-zero, instead of the
+ * shell's raw "command not found". All logic lives inside the exported functions — importing this
+ * module has no side effect, so it never executes at install time.
+ *
+ * @see docs/adr/ADR-0013-nextrush-cli-launcher-discoverability.md
+ */
+/** The `@nextrush/dev` CLI surface this launcher depends on. `cli()` reads `process.argv` itself. */
+interface DevCliModule {
+    readonly cli: (argv?: string[]) => void;
+}
+/** Package managers whose install command the launcher can name precisely; `null` = inconclusive. */
+type LauncherPackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
+/** Injectable seams — the defaults hit the real module loader / environment; tests substitute them. */
+interface DevCliLauncherDeps {
+    readonly importDevCli?: () => Promise<DevCliModule>;
+    readonly detectPackageManager?: () => LauncherPackageManager | null;
+    readonly writeError?: (message: string) => void;
+    /**
+     * Directory `@nextrush/dev` must resolve relative to — the CONSUMING app's own directory,
+     * never this package's. Defaults to `process.cwd()` at the real call site. A bare
+     * `import('@nextrush/dev')` from inside this file would resolve against `nextrush`'s own
+     * `node_modules`, which deliberately never has `@nextrush/dev` linked (ADR-0013) — so every
+     * consumer, regardless of what THEY have installed, would see "not installed." See ADR-0013
+     * addendum and the regression test covering this.
+     */
+    readonly baseDir?: string;
+}
+/**
+ * True only when the error is specifically "@nextrush/dev is not installed" — not when
+ * `@nextrush/dev` is present but one of ITS OWN dependencies is missing (whose message names that
+ * other specifier, even though the `@nextrush/dev` path may appear in the "imported from" clause).
+ */
+declare function isMissingDevToolkitError(err: unknown): boolean;
+/** The exact `-D`/`-d` install command for a package manager (design D4). */
+declare function installCommand(pm: LauncherPackageManager | null): string;
+/**
+ * The actionable message shown when the toolkit is absent: brands `@nextrush/dev` as the
+ * Development Toolkit, gives the exact install command for the detected package manager, a one-line
+ * description of what it provides, and a "then run" hint reflecting the command the user attempted
+ * (fed.md Option 1).
+ */
+declare function buildMissingToolkitMessage(pm: LauncherPackageManager | null, attemptedArgv?: readonly string[]): string;
+/**
+ * Resolve `@nextrush/dev`'s CLI and delegate; on the specific "toolkit not installed" case, print
+ * an actionable message and return a non-zero exit code. Any other error propagates unchanged.
+ *
+ * On the success path the underlying `cli()` reads `process.argv` and self-exits with its own code,
+ * so the launcher does not need to re-propagate it; the returned `0` is reached only when `cli()`
+ * returns without exiting (e.g. `--help`).
+ *
+ * @param argv - The CLI arguments (`process.argv.slice(2)`), passed through to the delegate.
+ * @param deps - Injectable seams for testing; defaults use the real loader and environment.
+ * @returns The exit code the launcher itself controls (non-zero when the toolkit is absent).
+ */
+declare function runDevCliLauncher(argv: string[], deps?: DevCliLauncherDeps): Promise<number>;
+
+export { type DevCliLauncherDeps, type DevCliModule, type LauncherPackageManager, buildMissingToolkitMessage, installCommand, isMissingDevToolkitError, runDevCliLauncher };

package/dist/dev-cli-launcher.js

@@ -0,0 +1,112 @@
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/dev-cli-launcher.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+var MISSING_DEV_TOOLKIT_PATTERN = /Cannot find (?:module|package) ['"]@nextrush\/dev['"]/;
+function isMissingDevToolkitError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return MISSING_DEV_TOOLKIT_PATTERN.test(message);
+}
+__name(isMissingDevToolkitError, "isMissingDevToolkitError");
+function installCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return "pnpm add -D @nextrush/dev";
+    case "yarn":
+      return "yarn add -D @nextrush/dev";
+    case "bun":
+      return "bun add -d @nextrush/dev";
+    case "npm":
+      return "npm install -D @nextrush/dev";
+    default:
+      return "install @nextrush/dev as a dev dependency (e.g. `npm install -D @nextrush/dev`)";
+  }
+}
+__name(installCommand, "installCommand");
+function runHint(pm, attemptedArgv) {
+  const prefix = pm === "npm" ? "npx" : pm ?? "";
+  return [
+    prefix,
+    "nextrush",
+    ...attemptedArgv
+  ].filter(Boolean).join(" ");
+}
+__name(runHint, "runHint");
+function buildMissingToolkitMessage(pm, attemptedArgv = []) {
+  const lines = [
+    "The NextRush Development Toolkit (@nextrush/dev) is not installed in this project.",
+    "",
+    "Install it:",
+    `  ${installCommand(pm)}`,
+    "",
+    "It provides the hot-reload dev server, production builds, and code generators (nextrush dev / build / generate)."
+  ];
+  const hint = runHint(pm, attemptedArgv);
+  if (attemptedArgv.length > 0) {
+    lines.push("", "Then run:", `  ${hint}`);
+  }
+  return lines.join("\n");
+}
+__name(buildMissingToolkitMessage, "buildMissingToolkitMessage");
+function detectPackageManagerFromEnv() {
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  if (userAgent.startsWith("pnpm")) return "pnpm";
+  if (userAgent.startsWith("yarn")) return "yarn";
+  if (userAgent.startsWith("bun")) return "bun";
+  if (userAgent.startsWith("npm")) return "npm";
+  return null;
+}
+__name(detectPackageManagerFromEnv, "detectPackageManagerFromEnv");
+async function importDevCliModule(baseDir) {
+  const manifestPath = path.join(baseDir, "node_modules", "@nextrush", "dev", "package.json");
+  let manifestContents;
+  try {
+    manifestContents = await readFile(manifestPath, "utf8");
+  } catch {
+    throw new Error(`Cannot find package '@nextrush/dev' imported from ${baseDir}`);
+  }
+  const manifest = JSON.parse(manifestContents);
+  const entryRelativePath = manifest.exports?.["."]?.import;
+  if (!entryRelativePath) {
+    throw new Error(`@nextrush/dev's package.json at ${manifestPath} has no "exports['.'].import" entry`);
+  }
+  const packageDir = path.dirname(manifestPath);
+  const entryAbsolutePath = path.join(packageDir, entryRelativePath);
+  return await import(pathToFileURL(entryAbsolutePath).href);
+}
+__name(importDevCliModule, "importDevCliModule");
+function defaultWriteError(message) {
+  process.stderr.write(`${message}
+`);
+}
+__name(defaultWriteError, "defaultWriteError");
+async function runDevCliLauncher(argv, deps = {}) {
+  const baseDir = deps.baseDir ?? process.cwd();
+  const importDevCli = deps.importDevCli ?? (() => importDevCliModule(baseDir));
+  const detectPm = deps.detectPackageManager ?? detectPackageManagerFromEnv;
+  const writeError = deps.writeError ?? defaultWriteError;
+  let devCli;
+  try {
+    devCli = await importDevCli();
+  } catch (err) {
+    if (isMissingDevToolkitError(err)) {
+      writeError(buildMissingToolkitMessage(detectPm(), argv));
+      return 1;
+    }
+    throw err;
+  }
+  devCli.cli(argv);
+  return 0;
+}
+__name(runDevCliLauncher, "runDevCliLauncher");
+export {
+  buildMissingToolkitMessage,
+  installCommand,
+  isMissingDevToolkitError,
+  runDevCliLauncher
+};
+//# sourceMappingURL=dev-cli-launcher.js.map

package/dist/dev-cli-launcher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dev-cli-launcher.ts"],"sourcesContent":["/**\n * Thin launcher for the `nextrush` meta-package's `bin`.\n *\n * `@nextrush/dev` is an optional dev-time toolkit, not a runtime dependency of `nextrush`\n * (docs/RFC/framework-composition/020-framework-composition-integrity.md §21; ADR-0013). This\n * launcher resolves it on demand: when present it delegates to its CLI transparently; when absent\n * it prints an actionable, package-manager-aware install message and exits non-zero, instead of the\n * shell's raw \"command not found\". All logic lives inside the exported functions — importing this\n * module has no side effect, so it never executes at install time.\n *\n * @see docs/adr/ADR-0013-nextrush-cli-launcher-discoverability.md\n */\n\nimport { readFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport { pathToFileURL } from 'node:url';\n\n/** The `@nextrush/dev` CLI surface this launcher depends on. `cli()` reads `process.argv` itself. */\nexport interface DevCliModule {\n  readonly cli: (argv?: string[]) => void;\n}\n\n/** Package managers whose install command the launcher can name precisely; `null` = inconclusive. */\nexport type LauncherPackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';\n\n/** Injectable seams — the defaults hit the real module loader / environment; tests substitute them. */\nexport interface DevCliLauncherDeps {\n  readonly importDevCli?: () => Promise<DevCliModule>;\n  readonly detectPackageManager?: () => LauncherPackageManager | null;\n  readonly writeError?: (message: string) => void;\n  /**\n   * Directory `@nextrush/dev` must resolve relative to — the CONSUMING app's own directory,\n   * never this package's. Defaults to `process.cwd()` at the real call site. A bare\n   * `import('@nextrush/dev')` from inside this file would resolve against `nextrush`'s own\n   * `node_modules`, which deliberately never has `@nextrush/dev` linked (ADR-0013) — so every\n   * consumer, regardless of what THEY have installed, would see \"not installed.\" See ADR-0013\n   * addendum and the regression test covering this.\n   */\n  readonly baseDir?: string;\n}\n\nconst MISSING_DEV_TOOLKIT_PATTERN = /Cannot find (?:module|package) ['\"]@nextrush\\/dev['\"]/;\n\n/**\n * True only when the error is specifically \"@nextrush/dev is not installed\" — not when\n * `@nextrush/dev` is present but one of ITS OWN dependencies is missing (whose message names that\n * other specifier, even though the `@nextrush/dev` path may appear in the \"imported from\" clause).\n */\nexport function isMissingDevToolkitError(err: unknown): boolean {\n  const message = err instanceof Error ? err.message : String(err);\n  return MISSING_DEV_TOOLKIT_PATTERN.test(message);\n}\n\n/** The exact `-D`/`-d` install command for a package manager (design D4). */\nexport function installCommand(pm: LauncherPackageManager | null): string {\n  switch (pm) {\n    case 'pnpm':\n      return 'pnpm add -D @nextrush/dev';\n    case 'yarn':\n      return 'yarn add -D @nextrush/dev';\n    case 'bun':\n      return 'bun add -d @nextrush/dev';\n    case 'npm':\n      return 'npm install -D @nextrush/dev';\n    default:\n      // Inconclusive detection → package-manager-agnostic phrasing (design D4 fallback).\n      return 'install @nextrush/dev as a dev dependency (e.g. `npm install -D @nextrush/dev`)';\n  }\n}\n\n/** The `<prefix> nextrush …` invocation to suggest re-running, matching the invoking package manager. */\nfunction runHint(pm: LauncherPackageManager | null, attemptedArgv: readonly string[]): string {\n  const prefix = pm === 'npm' ? 'npx' : (pm ?? '');\n  return [prefix, 'nextrush', ...attemptedArgv].filter(Boolean).join(' ');\n}\n\n/**\n * The actionable message shown when the toolkit is absent: brands `@nextrush/dev` as the\n * Development Toolkit, gives the exact install command for the detected package manager, a one-line\n * description of what it provides, and a \"then run\" hint reflecting the command the user attempted\n * (fed.md Option 1).\n */\nexport function buildMissingToolkitMessage(\n  pm: LauncherPackageManager | null,\n  attemptedArgv: readonly string[] = []\n): string {\n  const lines = [\n    'The NextRush Development Toolkit (@nextrush/dev) is not installed in this project.',\n    '',\n    'Install it:',\n    `  ${installCommand(pm)}`,\n    '',\n    'It provides the hot-reload dev server, production builds, and code generators ' +\n      '(nextrush dev / build / generate).',\n  ];\n  const hint = runHint(pm, attemptedArgv);\n  if (attemptedArgv.length > 0) {\n    lines.push('', 'Then run:', `  ${hint}`);\n  }\n  return lines.join('\\n');\n}\n\n/** Reads the invoking package manager from `npm_config_user_agent`; `null` when inconclusive. */\nfunction detectPackageManagerFromEnv(): LauncherPackageManager | null {\n  const userAgent = process.env.npm_config_user_agent ?? '';\n  if (userAgent.startsWith('pnpm')) return 'pnpm';\n  if (userAgent.startsWith('yarn')) return 'yarn';\n  // capability-exempt: 'bun' here identifies a PACKAGE MANAGER (npm/pnpm/yarn/bun), not a NextRush\n  // JS-runtime capability — this never branches on which runtime is executing (mirrors\n  // create-nextrush's detectPackageManager()).\n  if (userAgent.startsWith('bun')) return 'bun';\n  if (userAgent.startsWith('npm')) return 'npm';\n  return null;\n}\n\nasync function importDevCliModule(baseDir: string): Promise<DevCliModule> {\n  // Resolve relative to `baseDir` (the consuming app's own directory), never this file's own\n  // location — a bare `import('@nextrush/dev')` here would resolve against `nextrush`'s own\n  // node_modules, which never has `@nextrush/dev` linked by design (see DevCliLauncherDeps.baseDir).\n  //\n  // Neither `createRequire(baseDir).resolve()` (CJS-only — `@nextrush/dev`'s `exports` map has no\n  // `require` condition, per the repo's ESM-only rule) nor `import.meta.resolve(specifier, parent)`\n  // (the `parent` override is unreliable across Node versions — verified empirically: it silently\n  // resolves against THIS file's own URL instead of `parent` on the Node version this was built\n  // against) can do this correctly. Reading the target package's own `package.json` `exports` map\n  // directly is the same information Node's resolver would use, without either broken path.\n  const manifestPath = path.join(baseDir, 'node_modules', '@nextrush', 'dev', 'package.json');\n  let manifestContents: string;\n  try {\n    manifestContents = await readFile(manifestPath, 'utf8');\n  } catch {\n    throw new Error(`Cannot find package '@nextrush/dev' imported from ${baseDir}`);\n  }\n\n  const manifest = JSON.parse(manifestContents) as { exports?: { '.'?: { import?: string } } };\n  const entryRelativePath = manifest.exports?.['.']?.import;\n  if (!entryRelativePath) {\n    throw new Error(`@nextrush/dev's package.json at ${manifestPath} has no \"exports['.'].import\" entry`);\n  }\n\n  const packageDir = path.dirname(manifestPath);\n  const entryAbsolutePath = path.join(packageDir, entryRelativePath);\n  return (await import(pathToFileURL(entryAbsolutePath).href)) as DevCliModule;\n}\n\nfunction defaultWriteError(message: string): void {\n  process.stderr.write(`${message}\\n`);\n}\n\n/**\n * Resolve `@nextrush/dev`'s CLI and delegate; on the specific \"toolkit not installed\" case, print\n * an actionable message and return a non-zero exit code. Any other error propagates unchanged.\n *\n * On the success path the underlying `cli()` reads `process.argv` and self-exits with its own code,\n * so the launcher does not need to re-propagate it; the returned `0` is reached only when `cli()`\n * returns without exiting (e.g. `--help`).\n *\n * @param argv - The CLI arguments (`process.argv.slice(2)`), passed through to the delegate.\n * @param deps - Injectable seams for testing; defaults use the real loader and environment.\n * @returns The exit code the launcher itself controls (non-zero when the toolkit is absent).\n */\nexport async function runDevCliLauncher(argv: string[], deps: DevCliLauncherDeps = {}): Promise<number> {\n  const baseDir = deps.baseDir ?? process.cwd();\n  const importDevCli = deps.importDevCli ?? (() => importDevCliModule(baseDir));\n  const detectPm = deps.detectPackageManager ?? detectPackageManagerFromEnv;\n  const writeError = deps.writeError ?? defaultWriteError;\n\n  let devCli: DevCliModule;\n  try {\n    devCli = await importDevCli();\n  } catch (err: unknown) {\n    if (isMissingDevToolkitError(err)) {\n      writeError(buildMissingToolkitMessage(detectPm(), argv));\n      return 1;\n    }\n    throw err;\n  }\n\n  devCli.cli(argv);\n  return 0;\n}\n"],"mappings":"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","names":["readFile","path","pathToFileURL","MISSING_DEV_TOOLKIT_PATTERN","isMissingDevToolkitError","err","message","Error","String","test","installCommand","pm","runHint","attemptedArgv","prefix","filter","Boolean","join","buildMissingToolkitMessage","lines","hint","length","push","detectPackageManagerFromEnv","userAgent","process","env","npm_config_user_agent","startsWith","importDevCliModule","baseDir","manifestPath","path","manifestContents","readFile","manifest","JSON","parse","entryRelativePath","exports","import","packageDir","dirname","entryAbsolutePath","pathToFileURL","href","defaultWriteError","stderr","write","runDevCliLauncher","argv","deps","cwd","importDevCli","detectPm","detectPackageManager","writeError","devCli","cli"]}

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-export { Application, ApplicationOptions, ComposedMiddleware, compose, createApp } from '@nextrush/core';
-export { Router, RouterOptions, createRouter } from '@nextrush/router';
+import { ApplicationOptions, Application } from '@nextrush/core';
+export { Application, ApplicationOptions, ComposedMiddleware, compose } from '@nextrush/core';
+export { Router, RouterOptions, createRouter, endpoint } from '@nextrush/router';
 export { ServeOptions, ServerInstance, createHandler, listen, serve } from '@nextrush/adapter-node';
-export { BadGatewayError, BadRequestError, ConflictError, ErrorHandlerOptions, ForbiddenError, GatewayTimeoutError, HttpError, HttpErrorOptions, InternalServerError, MethodNotAllowedError, NextRushError, NotFoundError, NotImplementedError, ServiceUnavailableError, TooManyRequestsError, UnauthorizedError, UnprocessableEntityError, catchAsync, createError, errorHandler, isHttpError, notFoundHandler } from '@nextrush/errors';
-export { ContentType, Context, HttpMethod, HttpStatus, HttpStatusCode, Middleware, Next, Plugin, RouteHandler, Runtime } from '@nextrush/types';
+export { BadGatewayError, BadRequestError, ConflictError, ERROR_CODES, ErrorHandlerOptions, ForbiddenError, GatewayTimeoutError, HttpError, HttpErrorOptions, InternalServerError, MethodNotAllowedError, NextRushError, NotFoundError, NotImplementedError, ServiceUnavailableError, TooManyRequestsError, UnauthorizedError, UnprocessableEntityError, ValidationError, ValidationIssue, codeForStatus, createError, errorHandler, isHttpError, notFoundHandler } from '@nextrush/errors';
+export { ContentType, Context, Extension, ExtensionContext, HttpMethod, HttpStatus, HttpStatusCode, Middleware, Next, RouteDefinition, RouteHandler, RouteMetadata, Runtime } from '@nextrush/types';
 
 /**
  * NextRush - Minimal, Modular, Blazing Fast Node.js Framework
@@ -44,7 +45,7 @@ export { ContentType, Context, HttpMethod, HttpStatus, HttpStatusCode, Middlewar
  * });
  *
  * app.route('/', router);
- * listen(app, 3000);
+ * listen(app, 8080);
  * ```
  *
  * @example With Middleware (install separately)
@@ -57,13 +58,13 @@ export { ContentType, Context, HttpMethod, HttpStatus, HttpStatusCode, Middlewar
  * app.use(cors());
  * app.use(json());
  *
- * listen(app, 3000);
+ * listen(app, 8080);
  * ```
  *
  * @example Class-Based (import from nextrush/class)
  * ```typescript
  * import { createApp, listen } from 'nextrush';
- * import { Controller, Get, Service, controllersPlugin } from 'nextrush/class';
+ * import { Controller, Get, Service, registerControllers } from 'nextrush/class';
  *
  * @Service()
  * class UserService {
@@ -79,11 +80,30 @@ export { ContentType, Context, HttpMethod, HttpStatus, HttpStatusCode, Middlewar
  * }
  *
  * const app = createApp();
- * app.plugin(controllersPlugin({ root: './src' }));
- * listen(app, 3000);
+ * await registerControllers(app, { root: './src' });
+ * await listen(app, 8080);
  * ```
  */
 
-declare const VERSION = "3.0.4";
+/**
+ * Create an application with a default router wired in, so `app.get`/`app.post`
+ * work out of the box.
+ *
+ * The functional `nextrush` entry is deliberately DI-free: it does NOT import or
+ * attach a `@nextrush/di` container. Doing so would transitively load
+ * `reflect-metadata` + tsyringe, making functional users pay a cost that belongs
+ * only to the class-based paradigm (see NEW-1 in
+ * docs/audits/class-based-master-audit.md).
+ *
+ * The container is bring-your-own: pass `options.container` to attach one. Class
+ * users are unaffected — they import from `nextrush/class`, and
+ * `registerControllers` supplies the global `@nextrush/di` container fallback
+ * itself (`options.container ?? app.container ?? globalContainer`). See
+ * docs/RFC/class-runtime/006-di-container-ownership.md.
+ *
+ * Import `createApp` from `@nextrush/core` for a minimal engine where the router
+ * is also bring-your-own.
+ */
+declare function createApp(options?: ApplicationOptions): Application;
 
-export { VERSION };
+export { createApp };

package/dist/index.js

@@ -1,37 +1,52 @@
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
 // src/index.ts
-import { Application, compose, createApp } from "@nextrush/core";
-import { createRouter, Router } from "@nextrush/router";
+import { Application, compose, createApp as createBareApp } from "@nextrush/core";
+import { createRouter as createDefaultRouter } from "@nextrush/router";
+import { Router, createRouter, endpoint } from "@nextrush/router";
 import { createHandler, listen, serve } from "@nextrush/adapter-node";
 import {
   BadGatewayError,
   BadRequestError,
-  catchAsync,
   ConflictError,
-  createError,
-  errorHandler,
   ForbiddenError,
   GatewayTimeoutError,
   HttpError,
   InternalServerError,
-  isHttpError,
   MethodNotAllowedError,
   NextRushError,
   NotFoundError,
-  notFoundHandler,
   NotImplementedError,
   ServiceUnavailableError,
   TooManyRequestsError,
   UnauthorizedError,
-  UnprocessableEntityError
+  UnprocessableEntityError,
+  createError,
+  errorHandler,
+  isHttpError,
+  notFoundHandler,
+  ERROR_CODES,
+  codeForStatus,
+  ValidationError
 } from "@nextrush/errors";
 import { ContentType, HttpStatus } from "@nextrush/types";
-var VERSION = "3.0.4";
+function createApp(options) {
+  const router = options?.router ?? createDefaultRouter();
+  return createBareApp({
+    ...options,
+    router
+  });
+}
+__name(createApp, "createApp");
 export {
   Application,
   BadGatewayError,
   BadRequestError,
   ConflictError,
   ContentType,
+  ERROR_CODES,
   ForbiddenError,
   GatewayTimeoutError,
   HttpError,
@@ -46,13 +61,14 @@ export {
   TooManyRequestsError,
   UnauthorizedError,
   UnprocessableEntityError,
-  VERSION,
-  catchAsync,
+  ValidationError,
+  codeForStatus,
   compose,
   createApp,
   createError,
   createHandler,
   createRouter,
+  endpoint,
   errorHandler,
   isHttpError,
   listen,