@kabyeon/nexusjs 0.6.5

package/dist/index.js

@@ -0,0 +1,2056 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/view/rendu.ts
+import { compileTemplate } from "rendu";
+
+class RenduAdapter {
+  name = "rendu";
+  cache = new Map;
+  render(template, data, context, options) {
+    const safe = {};
+    for (const [k, v] of Object.entries(data)) {
+      safe[k] = typeof v === "string" ? v : v == null ? "" : String(v);
+    }
+    const merged = this.mergeData(safe, context, options);
+    return this.getCompiled(template, options)(merged);
+  }
+  compile(template, options) {
+    const compiled = this.getCompiled(template, options);
+    return (data) => compiled(data);
+  }
+  getCompiled(template, options) {
+    const cacheKey = options ? `${options.stream ? "s" : ""}` : "";
+    let compiled = this.cache.get(cacheKey);
+    if (!compiled) {
+      compiled = compileTemplate(template, {
+        stream: options?.stream ?? false
+      });
+      this.cache.set(cacheKey, compiled);
+    }
+    return compiled;
+  }
+  mergeData(data, context, options) {
+    const merged = { ...data };
+    if (context) {
+      if (context.request)
+        merged.$REQUEST = context.request;
+      if (context.response)
+        merged.$RESPONSE = context.response;
+      if (context.globals)
+        Object.assign(merged, context.globals);
+    }
+    if (options?.layout)
+      merged.$LAYOUT = options.layout;
+    return merged;
+  }
+}
+var init_rendu = () => {};
+
+// src/view/edge.ts
+class EdgeAdapter {
+  edge;
+  name = "edge";
+  constructor(edge) {
+    this.edge = edge;
+  }
+  async render(template, data, context, options) {
+    if (!this.edge) {
+      throw new Error("EdgeAdapter requires an Edge instance. " + "Install `edge.js` and pass it to `new EdgeAdapter(edge)`, " + "or use the default RenduAdapter instead.");
+    }
+    const fn = this.edge.renderRaw ?? this.edge.renderString;
+    if (!fn) {
+      throw new Error("Provided Edge instance does not implement renderRaw/renderString.");
+    }
+    return fn.call(this.edge, template, { ...data, $OPTIONS: options });
+  }
+}
+
+// src/view/eta.ts
+class EtaAdapter {
+  name = "eta";
+  cache = new Map;
+  async render(template, data, _context, _options) {
+    const compiled = this.getCompiled(template);
+    return compiled(data);
+  }
+  compile(template, _options) {
+    const compiled = this.getCompiled(template);
+    return (data) => Promise.resolve(compiled(data));
+  }
+  getCompiled(template) {
+    let fn = this.cache.get(template);
+    if (!fn) {
+      let Eta;
+      try {
+        Eta = __require("eta").Eta;
+      } catch (e) {
+        throw new Error(`[nexus] EtaAdapter: the "eta" package is not installed. ` + `Run \`bun add eta\` (or \`npm install eta\`) to use .eta templates.`);
+      }
+      const eta = new Eta;
+      fn = (data) => eta.renderString(template, data);
+      this.cache.set(template, fn);
+    }
+    return fn;
+  }
+}
+
+// src/view/view-engine.ts
+var exports_view_engine = {};
+__export(exports_view_engine, {
+  setViewPaths: () => setViewPaths,
+  renderView: () => renderView,
+  loadTemplate: () => loadTemplate,
+  getViewPaths: () => getViewPaths
+});
+function setViewPaths(path) {
+  viewPath = path ? path.endsWith("/") || path.endsWith("\\") ? path : `${path}/` : "";
+}
+function getViewPaths() {
+  return viewPath;
+}
+function isViewFilePath(name) {
+  const lower = name.toLowerCase();
+  return VIEW_FILE_EXTS.some((ext) => lower.endsWith(ext));
+}
+function selectAdapter(template) {
+  const lower = template.toLowerCase();
+  if (lower.endsWith(".edge"))
+    return new EdgeAdapter;
+  if (lower.endsWith(".eta"))
+    return new EtaAdapter;
+  return new RenduAdapter;
+}
+async function renderView(template, data, context) {
+  let source = template;
+  if (isViewFilePath(template) && viewPath.length > 0) {
+    const loaded = await loadTemplate(viewPath, template);
+    if (loaded === null) {
+      throw new Error(`[nexus] View file not found: "${template}" (searched: ${viewPath})`);
+    }
+    source = loaded;
+  }
+  const adapter = selectAdapter(source);
+  return adapter.render(source, data, context);
+}
+async function loadTemplate(dir, name) {
+  if (!dir)
+    return null;
+  const full = joinPath(dir, name);
+  try {
+    const file = await readFile(full);
+    if (file !== null)
+      return file;
+  } catch {}
+  return null;
+}
+function joinPath(dir, name) {
+  if (!dir.endsWith("/") && !dir.endsWith("\\"))
+    return `${dir}/${name}`;
+  return `${dir}${name}`;
+}
+async function readFile(path) {
+  if (typeof globalThis.Bun !== "undefined") {
+    try {
+      const file = globalThis.Bun.file(path);
+      if (await file.exists())
+        return file.text();
+    } catch {}
+  }
+  try {
+    const fs = await import("fs/promises");
+    return await fs.readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+var viewPath = "", VIEW_FILE_EXTS;
+var init_view_engine = __esm(() => {
+  init_rendu();
+  VIEW_FILE_EXTS = [".html", ".edge", ".rendu", ".eta"];
+});
+
+// src/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/core/decorators/controller.ts
+import"reflect-metadata";
+function Controller(prefix = "/") {
+  return (target) => {
+    const normalized = normalizePrefix(prefix);
+    const meta = { prefix: normalized };
+    Reflect.defineMetadata(METADATA_KEY.CONTROLLER, meta, target);
+  };
+}
+function getControllerMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.CONTROLLER, target) ?? { prefix: "/" };
+}
+function isController(target) {
+  return Reflect.hasMetadata(METADATA_KEY.CONTROLLER, target);
+}
+function normalizePrefix(prefix) {
+  if (!prefix)
+    return "";
+  if (prefix !== "/" && prefix.endsWith("/")) {
+    return prefix.slice(0, -1);
+  }
+  return prefix;
+}
+var init_controller = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/http-methods.ts
+import"reflect-metadata";
+function defineRoute(method, path) {
+  return (target, propertyKey, descriptor) => {
+    const routes = Reflect.getMetadata(METADATA_KEY.ROUTES, target.constructor) ?? [];
+    routes.push({
+      method,
+      path: normalizePath(path),
+      propertyKey,
+      handler: descriptor.value
+    });
+    Reflect.defineMetadata(METADATA_KEY.ROUTES, routes, target.constructor);
+  };
+}
+function normalizePath(path) {
+  if (!path || path === "/")
+    return "/";
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function getRoutes(target) {
+  return Reflect.getMetadata(METADATA_KEY.ROUTES, target) ?? [];
+}
+var Get = (path = "/") => defineRoute("GET", path), Post = (path = "/") => defineRoute("POST", path), Put = (path = "/") => defineRoute("PUT", path), Delete = (path = "/") => defineRoute("DELETE", path), Patch = (path = "/") => defineRoute("PATCH", path), Options = (path = "/") => defineRoute("OPTIONS", path), Head = (path = "/") => defineRoute("HEAD", path);
+var init_http_methods = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/params.ts
+import"reflect-metadata";
+function createParamDecorator(type, data) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target, propertyKey);
+    } else {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target);
+    }
+  };
+}
+function getParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+}
+var Req = () => createParamDecorator(PARAM_TYPES.REQUEST), Res = () => createParamDecorator(PARAM_TYPES.RESPONSE), Next = () => createParamDecorator(PARAM_TYPES.NEXT), Body = (key) => createParamDecorator(PARAM_TYPES.BODY, key), Query = (key) => createParamDecorator(PARAM_TYPES.QUERY, key), Param = (key) => createParamDecorator(PARAM_TYPES.PARAM, key), Headers2 = (key) => createParamDecorator(PARAM_TYPES.HEADERS, key), Ctx = () => createParamDecorator(PARAM_TYPES.CTX), User = () => createParamDecorator(PARAM_TYPES.USER);
+var init_params = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/validate.ts
+import"reflect-metadata";
+function Validate(options) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(METADATA_KEY.VALIDATE, options, target.constructor, propertyKey);
+  };
+}
+function getValidationMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.VALIDATE, target, propertyKey);
+}
+var init_validate = __esm(() => {
+  init_constants();
+});
+
+// src/core/di/request-scope.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+function newRequestId() {
+  return randomUUID().slice(0, 8);
+}
+function getRequest() {
+  return storage.getStore()?.context;
+}
+function getRequestScope() {
+  return storage.getStore();
+}
+function getRequestState(key) {
+  return storage.getStore()?.state.get(key);
+}
+function setRequestState(key, value) {
+  const s = storage.getStore();
+  if (s)
+    s.state.set(key, value);
+}
+var REQUEST, REQUEST_SCOPE, storage, RequestScopeStorage;
+var init_request_scope = __esm(() => {
+  REQUEST = Symbol.for("nexus:REQUEST");
+  REQUEST_SCOPE = Symbol.for("nexus:REQUEST_SCOPE");
+  storage = new AsyncLocalStorage;
+  RequestScopeStorage = {
+    get() {
+      return storage.getStore();
+    },
+    run(scope, fn) {
+      return storage.run(scope, fn);
+    },
+    create(context, container) {
+      return {
+        id: newRequestId(),
+        context,
+        container,
+        state: new Map
+      };
+    }
+  };
+});
+
+// src/core/di/container.ts
+import"reflect-metadata";
+
+class DIContainer {
+  providers = new Map;
+  singletons = new Map;
+  resolving = new Set;
+  parent;
+  constructor(parent) {
+    this.parent = parent;
+  }
+  createChild() {
+    return new DIContainer(this);
+  }
+  register(providers) {
+    const list = Array.isArray(providers) ? providers : [providers];
+    for (const provider of list) {
+      this.registerOne(provider);
+    }
+  }
+  registerOne(provider) {
+    const record = this.normalizeProvider(provider);
+    if (this.providers.has(record.token)) {
+      throw new Error(`Duplicate provider for token "${this.tokenName(record.token)}". ` + `Each token may only be registered once per container.`);
+    }
+    this.providers.set(record.token, record);
+  }
+  normalizeProvider(provider) {
+    if (this.isClass(provider)) {
+      const dependencies = this.readClassDependencies(provider);
+      const classScope = Reflect.getMetadata("nexus:di:scope", provider);
+      return {
+        token: provider,
+        provider,
+        scope: classScope ?? "singleton",
+        dependencies
+      };
+    }
+    const deps = this.readProviderDependencies(provider);
+    const scope = "scope" in provider && provider.scope || "singleton";
+    return {
+      token: provider.provide,
+      provider,
+      scope,
+      dependencies: deps
+    };
+  }
+  readClassDependencies(cls) {
+    const paramTypes = Reflect.getMetadata(METADATA_KEY.PARAMTYPES, cls) || [];
+    const set = new Set;
+    for (const t of paramTypes) {
+      if (t && t !== Object)
+        set.add(t);
+    }
+    return set;
+  }
+  readProviderDependencies(provider) {
+    const set = new Set;
+    if ("inject" in provider && Array.isArray(provider.inject)) {
+      for (const dep of provider.inject) {
+        if (dep && typeof dep === "object" && "token" in dep) {
+          set.add(dep.token);
+        } else if (dep) {
+          set.add(dep);
+        }
+      }
+    } else if ("useClass" in provider) {
+      const cls = provider.useClass;
+      return this.readClassDependencies(cls);
+    }
+    return set;
+  }
+  resolve(token) {
+    if (this.resolving.has(token)) {
+      throw new Error(`Circular dependency detected while resolving "${this.tokenName(token)}". ` + `Resolution stack: ${[...this.resolving].map((t) => this.tokenName(t)).join(" -> ")}`);
+    }
+    const cached = this.singletons.get(token);
+    if (cached !== undefined)
+      return cached;
+    const record0 = this.providers.get(token);
+    if (record0 && record0.scope === "request") {
+      const scope = RequestScopeStorage.get();
+      if (scope) {
+        const r2 = scope.container.singletons.get(token);
+        if (r2 !== undefined)
+          return r2;
+        const inst = this.instantiate(record0);
+        scope.container.singletons.set(token, inst);
+        return inst;
+      }
+    }
+    const record = this.providers.get(token);
+    if (!record) {
+      if (this.parent) {
+        try {
+          return this.parent.resolve(token);
+        } catch {}
+      }
+      throw new Error(`No provider for "${this.tokenName(token)}". ` + `Register it via DIContainer.register() or @Module({ providers: [...] }).`);
+    }
+    const owningContainer = this.providers.get(token) === record ? this : this;
+    this.resolving.add(token);
+    try {
+      const instance = owningContainer.instantiate(record);
+      if (record.scope === "singleton") {
+        owningContainer.singletons.set(token, instance);
+      }
+      return instance;
+    } finally {
+      this.resolving.delete(token);
+    }
+  }
+  tryResolve(token) {
+    try {
+      return this.resolve(token);
+    } catch {
+      return;
+    }
+  }
+  instantiate(record) {
+    const provider = record.provider;
+    if (this.isClass(provider)) {
+      const paramTypes = Reflect.getMetadata(METADATA_KEY.PARAMTYPES, provider) || [];
+      const injectMap = Reflect.getMetadata(METADATA_KEY.INJECT, provider) ?? new Map;
+      const maxInjectIndex = injectMap.size > 0 ? Math.max(...Array.from(injectMap.keys())) + 1 : 0;
+      const totalParams = Math.max(paramTypes.length, maxInjectIndex);
+      const params2 = new Array(totalParams);
+      for (let index = 0;index < totalParams; index++) {
+        if (injectMap.has(index)) {
+          params2[index] = this.resolve(injectMap.get(index));
+          continue;
+        }
+        const type = paramTypes[index];
+        if (!type || type === Object) {
+          throw new Error(`Cannot inject parameter at index ${index} of "${provider.name || "<anonymous>"}" ` + `(type is "Object" or "undefined"). This usually means ` + `reflect-metadata was not emitted by your toolchain (Bun's ` + `native transpiler doesn't emit decorator metadata). Use the ` + `@Inject(Token) parameter decorator to specify the dependency ` + `explicitly, e.g. \`constructor(@Inject(UserService) private users: UserService)\`.`);
+        }
+        params2[index] = this.resolve(type);
+      }
+      return new provider(...params2);
+    }
+    if ("useValue" in provider) {
+      return provider.useValue;
+    }
+    if ("useClass" in provider) {
+      const ClassRef = provider.useClass;
+      const paramTypes = Reflect.getMetadata(METADATA_KEY.PARAMTYPES, ClassRef) || [];
+      const injectMap = Reflect.getMetadata(METADATA_KEY.INJECT, ClassRef) ?? new Map;
+      const maxInjectIndex = injectMap.size > 0 ? Math.max(...Array.from(injectMap.keys())) + 1 : 0;
+      const totalParams = Math.max(paramTypes.length, maxInjectIndex);
+      const params2 = new Array(totalParams);
+      for (let index = 0;index < totalParams; index++) {
+        if (injectMap.has(index)) {
+          params2[index] = this.resolve(injectMap.get(index));
+          continue;
+        }
+        const type = paramTypes[index];
+        if (!type || type === Object) {
+          throw new Error(`Cannot inject parameter at index ${index} of "${ClassRef.name}" ` + `(type is "Object" or "undefined"). Add explicit type annotations or ` + `use @Inject(Token).`);
+        }
+        params2[index] = this.resolve(type);
+      }
+      return new ClassRef(...params2);
+    }
+    if ("useFactory" in provider) {
+      const factoryProvider = provider;
+      const inject = factoryProvider.inject ?? [];
+      const args = inject.map((dep) => {
+        if (dep && typeof dep === "object" && "token" in dep) {
+          const { token, optional } = dep;
+          return optional ? this.tryResolve(token) : this.resolve(token);
+        }
+        return this.resolve(dep);
+      });
+      return factoryProvider.useFactory(...args);
+    }
+    if ("useExisting" in provider) {
+      const existing = provider.useExisting;
+      return this.resolve(existing);
+    }
+    throw new Error(`Unknown provider shape for token "${this.tokenName(record.token)}"`);
+  }
+  has(token) {
+    return this.providers.has(token);
+  }
+  list() {
+    return [...this.providers.keys()].map((t) => this.tokenName(t));
+  }
+  isClass(value) {
+    return typeof value === "function";
+  }
+  tokenName(token) {
+    if (typeof token === "function")
+      return token.name || "<anonymous class>";
+    if (typeof token === "symbol")
+      return token.toString();
+    return String(token);
+  }
+}
+var ApplicationContainer;
+var init_container = __esm(() => {
+  init_constants();
+  init_request_scope();
+  ApplicationContainer = class ApplicationContainer extends DIContainer {
+    moduleContainers = new Map;
+    registerModule(moduleClass, container) {
+      this.moduleContainers.set(moduleClass, container);
+    }
+    getModuleContainer(moduleClass) {
+      return this.moduleContainers.get(moduleClass);
+    }
+  };
+});
+
+// src/core/di/scanner.ts
+class ModuleScanner {
+  root;
+  scanned = new Map;
+  constructor(root) {
+    this.root = root;
+  }
+  scan(rootModule) {
+    const rootResult = this.scanModule(rootModule, this.root);
+    const all = [...this.scanned.values()];
+    return { root: rootResult, modules: all };
+  }
+  scanModule(moduleClass, parentContainer) {
+    if (this.scanned.has(moduleClass)) {
+      return this.scanned.get(moduleClass);
+    }
+    const options = this.readModuleOptions(moduleClass);
+    const container = parentContainer.createChild();
+    this.root.registerModule(moduleClass, container);
+    const placeholder = {
+      controllers: [],
+      providers: [],
+      exports: [],
+      container
+    };
+    this.scanned.set(moduleClass, placeholder);
+    for (const imported of options.imports ?? []) {
+      const importedResult = this.scanModule(imported, parentContainer);
+      for (const exp of importedResult.exports) {
+        if (!parentContainer.has(exp)) {
+          parentContainer.register({
+            provide: exp,
+            useFactory: () => importedResult.container.resolve(exp)
+          });
+        }
+      }
+    }
+    const providers = [
+      ...options.providers ?? [],
+      ...options.controllers ?? []
+    ];
+    container.register(providers);
+    for (const exp of options.exports ?? []) {
+      if (!parentContainer.has(exp)) {
+        parentContainer.register({
+          provide: exp,
+          useFactory: () => container.resolve(exp)
+        });
+      }
+    }
+    const result = {
+      controllers: options.controllers ?? [],
+      providers: options.providers ?? [],
+      exports: options.exports ?? [],
+      container
+    };
+    this.scanned.set(moduleClass, result);
+    return result;
+  }
+  readModuleOptions(moduleClass) {
+    const meta = Reflect.getMetadata(METADATA_KEY.MODULE, moduleClass);
+    if (!meta) {
+      throw new Error(`Class "${moduleClass.name}" is missing the @Module() decorator.`);
+    }
+    return meta;
+  }
+  get(moduleClass) {
+    return this.scanned.get(moduleClass);
+  }
+}
+var init_scanner = __esm(() => {
+  init_constants();
+});
+
+// src/core/di/request-middleware.ts
+var exports_request_middleware = {};
+__export(exports_request_middleware, {
+  requestScopeMiddleware: () => requestScopeMiddleware,
+  installRequestTokens: () => installRequestTokens
+});
+function installRequestTokens(root) {
+  const existing = root.providers;
+  if (existing && (existing.has(REQUEST) || existing.has(REQUEST_SCOPE)))
+    return;
+  root.register({
+    provide: REQUEST,
+    scope: "transient",
+    useFactory: () => RequestScopeStorage.get()?.context
+  });
+  root.register({
+    provide: REQUEST_SCOPE,
+    scope: "transient",
+    useFactory: () => RequestScopeStorage.get()
+  });
+}
+function requestScopeMiddleware(root) {
+  installRequestTokens(root);
+  return async (c, next) => {
+    const reqContainer = new DIContainer(root);
+    const scope = RequestScopeStorage.create(c, reqContainer);
+    return RequestScopeStorage.run(scope, () => next());
+  };
+}
+var init_request_middleware = __esm(() => {
+  init_container();
+  init_request_scope();
+});
+
+// src/core/http/middleware.ts
+function logger() {
+  return async (c, next) => {
+    const start = performance.now();
+    await next();
+    const ms = (performance.now() - start).toFixed(2);
+    const status = c.res.status;
+    console.log(`[${c.req.method}] ${c.req.path} -> ${status} (${ms}ms)`);
+    return;
+  };
+}
+function cors(options) {
+  const origin = options.origin;
+  const methods = options.methods ?? [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+  const headerList = options.headers ?? ["Content-Type", "Authorization"];
+  const headersValue = Array.isArray(headerList) ? headerList.join(",") : headerList;
+  return async (c, next) => {
+    const set = (key, value) => {
+      c.res.headers.set(key, value);
+    };
+    set("Access-Control-Allow-Origin", Array.isArray(origin) ? origin.join(",") : origin);
+    set("Access-Control-Allow-Methods", methods.join(","));
+    set("Access-Control-Allow-Headers", headersValue);
+    if (options.credentials)
+      set("Access-Control-Allow-Credentials", "true");
+    if (c.req.method === "OPTIONS") {
+      return c.body(null, 204);
+    }
+    await next();
+    return;
+  };
+}
+function errorHandler() {
+  return async (c, next) => {
+    try {
+      await next();
+    } catch (err) {
+      const status = err?.status ?? 500;
+      const body = err?.body ?? {
+        error: err?.message ?? "Internal Server Error"
+      };
+      return c.json(body, status);
+    }
+    return;
+  };
+}
+
+// src/core/validation/validator.ts
+function validateRequest(metadata2, input) {
+  if (!metadata2)
+    return input;
+  const result = {};
+  if (metadata2.body)
+    result.body = runSchema(metadata2.body, input.body, "body");
+  else
+    result.body = input.body;
+  if (metadata2.query)
+    result.query = runSchema(metadata2.query, input.query, "query");
+  else
+    result.query = input.query;
+  if (metadata2.params)
+    result.params = runSchema(metadata2.params, input.params, "params");
+  else
+    result.params = input.params;
+  if (metadata2.headers)
+    result.headers = runSchema(metadata2.headers, input.headers, "headers");
+  else
+    result.headers = input.headers;
+  return result;
+}
+function runSchema(schema, value, part) {
+  if (!isZodSchema(schema)) {
+    if (typeof schema === "function")
+      return schema(value);
+    throw new Error(`@Validate "${part}" must be a Zod schema or validator function. Got ${typeof schema}.`);
+  }
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    throw new ValidationError(parsed.error);
+  }
+  return parsed.data;
+}
+function isZodSchema(value) {
+  return value !== null && typeof value === "object" && typeof value.safeParse === "function";
+}
+function formatValidationError(err) {
+  return {
+    status: err.status,
+    body: {
+      error: err.message,
+      issues: err.issues
+    }
+  };
+}
+var ValidationError;
+var init_validator = __esm(() => {
+  ValidationError = class ValidationError extends Error {
+    status = 400;
+    issues;
+    constructor(zodError) {
+      super("Validation failed");
+      this.name = "ValidationError";
+      this.issues = zodError.issues;
+    }
+  };
+});
+
+// src/core/http/router.ts
+import"reflect-metadata";
+
+class NexusRouterImpl {
+  hono;
+  root;
+  #routeList = [];
+  constructor(hono, root) {
+    this.hono = hono;
+    this.root = root;
+  }
+  getHono() {
+    return this.hono;
+  }
+  getRoutes() {
+    return this.#routeList;
+  }
+  registerController(controller2, container2) {
+    if (!isController(controller2)) {
+      throw new Error(`Class "${controller2.name}" is missing the @Controller() decorator.`);
+    }
+    const { prefix } = getControllerMetadata(controller2);
+    const routes = getRoutes(controller2);
+    const resolvedContainer = container2 ?? this.resolveControllerContainer(controller2);
+    if (routes.length === 0) {
+      return;
+    }
+    for (const route of routes) {
+      const fullPath = this.joinPaths(prefix, route.path);
+      this.mountRoute(controller2, route, fullPath, resolvedContainer);
+    }
+  }
+  add(method, path, handler, methodName, container2) {
+    if (typeof handler === "function" && methodName && handler.prototype && isController(handler)) {
+      const controllerInstance = (container2 ?? this.root).resolve(handler);
+      const handlerFn = controllerInstance[methodName];
+      const fullPath = this.joinPaths(getControllerMetadata(handler).prefix, path);
+      const routes = getRoutes(handler);
+      const route = routes.find((r) => r.propertyKey === methodName);
+      if (!route) {
+        this.raw(method, fullPath, async (c) => handlerFn.call(controllerInstance, c));
+        return;
+      }
+      this.mountRoute(handler, { ...route, handler: handlerFn }, fullPath, container2 ?? this.root);
+      return;
+    }
+    this.raw(method, path, handler);
+  }
+  raw(method, path, handler) {
+    const fn = HTTP_METHOD_TO_HONO[method];
+    if (method === "HEAD") {
+      this.hono.on("HEAD", path, handler);
+      return;
+    }
+    this.hono[fn](path, handler);
+  }
+  mountRoute(controller2, route, fullPath, container2) {
+    const validation = getValidationMetadata(controller2, route.propertyKey);
+    const paramMeta = getParamMetadata(controller2.prototype, route.propertyKey);
+    this.#routeList.push({
+      method: route.method,
+      path: fullPath,
+      target: controller2.prototype,
+      propertyKey: route.propertyKey,
+      validation: validation ?? undefined
+    });
+    const honoHandler = async (c) => {
+      try {
+        const instance = container2.resolve(controller2);
+        const args = await this.buildArgs(c, paramMeta, validation);
+        const result = await Promise.resolve(route.handler.call(instance, ...args));
+        return await this.serialize(c, result);
+      } catch (err) {
+        return this.handleError(c, err);
+      }
+    };
+    const fn = HTTP_METHOD_TO_HONO[route.method];
+    if (route.method === "HEAD") {
+      this.hono.on("HEAD", fullPath, honoHandler);
+      return;
+    }
+    this.hono[fn](fullPath, honoHandler);
+  }
+  async buildArgs(c, params2, validation) {
+    let parsed;
+    const needsValidation = validation && (validation.body || validation.query || validation.params || validation.headers);
+    const hasBodyParam = params2.some((p) => p.type === PARAM_TYPES.BODY);
+    if (needsValidation || hasBodyParam) {
+      const bodyPromise = needsValidation && validation.body ? safeReadBody(c) : hasBodyParam ? safeReadBody(c) : Promise.resolve(undefined);
+      const [body] = await Promise.all([bodyPromise]);
+      parsed = validateRequest(validation ?? {}, {
+        body,
+        query: c.req.query(),
+        params: c.req.param(),
+        headers: c.req.header()
+      });
+    }
+    const positional = [];
+    for (const param of params2) {
+      positional[param.index] = this.resolveParam(c, param, parsed);
+    }
+    return positional;
+  }
+  resolveParam(c, param, parsed) {
+    switch (param.type) {
+      case PARAM_TYPES.REQUEST:
+      case PARAM_TYPES.CTX:
+        return c;
+      case PARAM_TYPES.RESPONSE:
+        return c.res;
+      case PARAM_TYPES.NEXT:
+        return async () => {};
+      case PARAM_TYPES.BODY:
+        if (parsed)
+          return parsed.body;
+        return param.name ? safeReadBody(c)?.[param.name] : safeReadBody(c);
+      case PARAM_TYPES.QUERY:
+        if (parsed) {
+          if (param.name)
+            return parsed.query?.[param.name];
+          return parsed.query;
+        }
+        return param.name ? c.req.query(param.name) : c.req.query();
+      case PARAM_TYPES.PARAM:
+        if (parsed) {
+          if (param.name)
+            return parsed.params?.[param.name];
+          return parsed.params;
+        }
+        return param.name ? c.req.param(param.name) : c.req.param();
+      case PARAM_TYPES.HEADERS:
+        if (parsed) {
+          if (param.name)
+            return parsed.headers?.[param.name] ?? c.req.header(param.name);
+          return parsed.headers ?? c.req.header();
+        }
+        return param.name ? c.req.header(param.name) : c.req.header();
+      case PARAM_TYPES.USER:
+        return c.var?.nexus?.user;
+      default:
+        return;
+    }
+  }
+  async serialize(c, value) {
+    if (value === undefined || value === null) {
+      return c.body(null, 204);
+    }
+    if (value instanceof Response) {
+      const headers = {};
+      value.headers.forEach((v, k) => {
+        headers[k] = v;
+      });
+      const text = await value.text();
+      return c.body(text, value.status, headers);
+    }
+    if (this.isInertiaResponse(value)) {
+      return this.serializeInertia(c, value);
+    }
+    if (typeof value === "object") {
+      if ("view" in value) {
+        return renderViewResponse(c, value);
+      }
+      if ("redirect" in value) {
+        return c.redirect(value.redirect, value.status ?? 302);
+      }
+      if ("status" in value && "body" in value) {
+        return c.json(value.body, value.status);
+      }
+      return c.json(value);
+    }
+    if (typeof value === "string") {
+      return c.html(value);
+    }
+    return c.json(value);
+  }
+  isInertiaResponse(value) {
+    return value !== null && typeof value === "object" && value["__nexus_inertia_response__"] === true && typeof value.toResponse === "function";
+  }
+  async serializeInertia(c, value) {
+    return await value.toResponse(c);
+  }
+  handleError(c, err) {
+    if (err instanceof ValidationError) {
+      const { status, body } = formatValidationError(err);
+      return c.json(body, status);
+    }
+    throw err;
+  }
+  resolveControllerContainer(controller2) {
+    for (const [, container2] of this.root.moduleContainers ?? new Map) {
+      if (container2.has?.(controller2))
+        return container2;
+    }
+    return this.root;
+  }
+  joinPaths(prefix, path) {
+    if (!prefix || prefix === "/")
+      return path || "/";
+    if (!path || path === "/")
+      return prefix;
+    if (prefix.endsWith("/"))
+      return `${prefix}${path}`;
+    return `${prefix}${path}`;
+  }
+}
+async function renderViewResponse(c, value) {
+  const { renderView: renderView2 } = await Promise.resolve().then(() => (init_view_engine(), exports_view_engine));
+  const html = await renderView2(value.view, value.data ?? {});
+  return c.html(html, value.status ?? 200);
+}
+async function safeReadBody(c) {
+  try {
+    const ct = c.req.header("content-type") ?? "";
+    if (ct.includes("application/json")) {
+      return await c.req.json();
+    }
+    if (ct.includes("application/x-www-form-urlencoded") || ct.includes("multipart/form-data")) {
+      return await c.req.parseBody();
+    }
+    return await c.req.text();
+  } catch {
+    return;
+  }
+}
+function createRouter(hono, container2) {
+  return new NexusRouterImpl(hono, container2);
+}
+var HTTP_METHOD_TO_HONO;
+var init_router = __esm(() => {
+  init_constants();
+  init_controller();
+  init_http_methods();
+  init_params();
+  init_validate();
+  init_validator();
+  HTTP_METHOD_TO_HONO = {
+    GET: "get",
+    POST: "post",
+    PUT: "put",
+    DELETE: "delete",
+    PATCH: "patch",
+    OPTIONS: "options",
+    HEAD: "head"
+  };
+});
+
+// src/core/runtime/bun.ts
+var exports_bun = {};
+__export(exports_bun, {
+  bunAdapter: () => bunAdapter
+});
+function bunAdapter(app, port = 3000) {
+  const Bun = globalThis.Bun;
+  if (!Bun || typeof Bun.serve !== "function") {
+    throw new Error("bunAdapter() requires the Bun runtime.");
+  }
+  const server = Bun.serve({
+    port,
+    fetch: (req) => app.fetch(req),
+    error: (err) => {
+      console.error("[bun-adapter] error:", err);
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  });
+  console.log(`[nexus] Listening on http://localhost:${server.port}`);
+  return server;
+}
+
+// src/core/runtime/node.ts
+var exports_node = {};
+__export(exports_node, {
+  nodeAdapter: () => nodeAdapter
+});
+import { createServer } from "http";
+function nodeAdapter(app, port = 3000) {
+  const server = createServer(async (req, res) => {
+    try {
+      const url = `http://${req.headers.host}${req.url}`;
+      const headers = new Headers;
+      for (const [k, v] of Object.entries(req.headers)) {
+        if (v == null)
+          continue;
+        if (Array.isArray(v))
+          headers.set(k, v.join(", "));
+        else
+          headers.set(k, String(v));
+      }
+      const method = req.method ?? "GET";
+      const init = { method, headers };
+      if (method !== "GET" && method !== "HEAD") {
+        const bodyBuf = await new Promise((resolve, reject) => {
+          const chunks = [];
+          req.on("data", (c) => chunks.push(c));
+          req.on("end", () => resolve(Buffer.concat(chunks)));
+          req.on("error", reject);
+        });
+        init.body = new Uint8Array(bodyBuf.buffer, bodyBuf.byteOffset, bodyBuf.byteLength);
+        init.duplex = "half";
+      }
+      const honoRes = await app.fetch(new Request(url, init));
+      res.statusCode = honoRes.status;
+      honoRes.headers.forEach((v, k) => res.setHeader(k, v));
+      const buf = Buffer.from(await honoRes.arrayBuffer());
+      res.end(buf);
+    } catch (err) {
+      console.error("[node-adapter] error:", err);
+      res.statusCode = 500;
+      res.end("Internal Server Error");
+    }
+  });
+  server.listen(port, () => {
+    console.log(`[nexus] Listening on http://localhost:${port}`);
+  });
+  return server;
+}
+var init_node = () => {};
+
+// src/core/runtime/cloudflare.ts
+var exports_cloudflare = {};
+__export(exports_cloudflare, {
+  cloudflareAdapter: () => cloudflareAdapter
+});
+function cloudflareAdapter(app) {
+  return {
+    fetch: (req, env, ctx) => app.fetch(req, env, ctx)
+  };
+}
+
+// src/core/http/server.ts
+import"reflect-metadata";
+import { Hono } from "hono";
+
+class NexusServer {
+  app;
+  container;
+  router;
+  options;
+  constructor(container2, options = {}) {
+    this.container = container2;
+    this.app = new Hono;
+    this.router = createRouter(this.app, container2);
+    this.options = {
+      logging: options.logging ?? true,
+      errorHandler: options.errorHandler ?? true,
+      port: options.port ?? 3000
+    };
+    this.bootstrap();
+  }
+  bootstrap() {
+    const { requestScopeMiddleware: requestScopeMiddleware2 } = (init_request_middleware(), __toCommonJS(exports_request_middleware));
+    this.app.use("*", requestScopeMiddleware2(this.container));
+    if (this.options.errorHandler)
+      this.app.use("*", errorHandler());
+    if (this.options.logging)
+      this.app.use("*", logger());
+  }
+  use(...handlers) {
+    for (const h of handlers)
+      this.app.use("*", h);
+    return this;
+  }
+  setPort(port) {
+    this.options.port = port;
+    return this;
+  }
+  async start() {
+    const runtime = await detectRuntime();
+    if (runtime === "bun") {
+      const { bunAdapter: bunAdapter2 } = await Promise.resolve().then(() => exports_bun);
+      return bunAdapter2(this.app, this.options.port);
+    }
+    if (runtime === "node") {
+      const { nodeAdapter: nodeAdapter2 } = await Promise.resolve().then(() => (init_node(), exports_node));
+      return nodeAdapter2(this.app, this.options.port);
+    }
+    if (runtime === "cloudflare") {
+      const { cloudflareAdapter: cloudflareAdapter2 } = await Promise.resolve().then(() => exports_cloudflare);
+      return cloudflareAdapter2(this.app);
+    }
+    throw new Error("No supported runtime detected (Bun, Node, or Cloudflare Workers).");
+  }
+  get fetch() {
+    return async (req, env, ctx) => this.app.fetch(req, env, ctx);
+  }
+}
+async function detectRuntime() {
+  if (typeof globalThis.Bun !== "undefined")
+    return "bun";
+  if (typeof process !== "undefined" && process.versions?.node)
+    return "node";
+  return "cloudflare";
+}
+var init_server = __esm(() => {
+  init_router();
+});
+// src/view/inertia/helpers.ts
+class DeferredProp {
+  callback;
+  group;
+  __inertiaKind = "deferred";
+  constructor(callback, group = "default") {
+    this.callback = callback;
+    this.group = group;
+  }
+  resolve() {
+    return this.callback();
+  }
+}
+function isInertiaHelper(value) {
+  return value !== null && typeof value === "object" && typeof value.__inertiaKind === "string" && typeof value.resolve === "function";
+}
+
+// src/view/inertia/default-ssr.ts
+async function renderDefaultRoot(adapter, ssr, component, page, c) {
+  const title = adapter.title();
+  const headTags = [];
+  let bodyHtml = "";
+  if (ssr) {
+    try {
+      const result = await ssr.render(component, page.props);
+      bodyHtml = result.html ?? "";
+      if (result.head)
+        headTags.push(...result.head);
+      if (result.data) {
+        Object.assign(page, result.data);
+      }
+    } catch (err) {
+      console.error(`[inertia] SSR render failed for "${component}":`, err);
+    }
+  }
+  if (ssr?.head) {
+    try {
+      const extra = await ssr.head();
+      headTags.push(...extra);
+    } catch {}
+  }
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(title)}</title>
+${headTags.join(`
+`)}
+</head>
+<body>
+<div id="app" data-page="${escapeAttr(JSON.stringify(page))}">${bodyHtml}</div>
+</body>
+</html>`;
+  return c.html(html, 200, {
+    Vary: "X-Inertia"
+  });
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function escapeAttr(s) {
+  return escapeHtml(s).replace(/'/g, "&#39;");
+}
+
+// src/view/inertia/inertia-response.ts
+var INERTIA_RESPONSE_TAG = "__nexus_inertia_response__", InertiaResponse;
+var init_inertia_response = __esm(() => {
+  InertiaResponse = class InertiaResponse {
+    adapter;
+    component;
+    props;
+    [INERTIA_RESPONSE_TAG] = true;
+    options = {};
+    lazyCache = new Map;
+    constructor(adapter, component, props) {
+      this.adapter = adapter;
+      this.component = component;
+      this.props = props;
+    }
+    withEncryptHistory(encrypt = true) {
+      this.options.encryptHistory = encrypt;
+      return this;
+    }
+    withClearHistory(clear = true) {
+      this.options.clearHistory = clear;
+      return this;
+    }
+    async toResponse(c) {
+      const url = c.req.url;
+      const info = this.parseInertiaRequest(c);
+      if (info.isInertia && info.clientVersion !== undefined) {
+        const serverVersion = await this.adapter.resolveVersion();
+        if (serverVersion !== undefined && info.clientVersion !== serverVersion) {
+          return this.assetVersionMismatch(c.req.url);
+        }
+      }
+      const page = await this.buildPage(url, info, c);
+      if (info.isInertia) {
+        return this.jsonResponse(page);
+      }
+      return this.htmlResponse(c, page);
+    }
+    async buildPage(url, info, c) {
+      const shared = await this.adapter.getSharedFor(c);
+      const allProps = { ...shared, ...this.props };
+      const resolved = {};
+      const deferredProps = {};
+      const mergeProps = [];
+      const deepMergeProps = [];
+      const matchPropsOn = [];
+      for (const [key, value] of Object.entries(allProps)) {
+        if (isInertiaHelper(value)) {
+          const helper = value;
+          switch (helper.__inertiaKind) {
+            case "deferred": {
+              const d = helper;
+              const group = d.group ?? "default";
+              (deferredProps[group] ??= []).push(key);
+              resolved[key] = null;
+              break;
+            }
+            case "always": {
+              resolved[key] = await Promise.resolve(helper.resolve());
+              break;
+            }
+            case "optional": {
+              const v = await Promise.resolve(helper.resolve());
+              const o = helper;
+              const threshold = o.threshold ?? 0;
+              if (Array.isArray(v) && v.length <= threshold) {
+                if (this.isPartialReload(info)) {
+                  continue;
+                }
+              }
+              resolved[key] = v;
+              break;
+            }
+            case "merge": {
+              const v = await Promise.resolve(helper.resolve());
+              mergeProps.push(key);
+              const m = helper;
+              if (m.matchPropsOn && m.matchPropsOn.length > 0) {
+                deepMergeProps.push(key);
+                matchPropsOn.push(m.matchPropsOn);
+              }
+              resolved[key] = v;
+              break;
+            }
+            case "deepMerge": {
+              resolved[key] = await Promise.resolve(helper.resolve());
+              mergeProps.push(key);
+              deepMergeProps.push(key);
+              break;
+            }
+            case "once": {
+              if (info.isInertia) {
+                continue;
+              }
+              resolved[key] = await Promise.resolve(helper.resolve());
+              break;
+            }
+            case "lazy": {
+              const lz = helper;
+              const tag = lz.tag;
+              if (this.lazyCache.has(tag)) {
+                resolved[key] = this.lazyCache.get(tag);
+              } else {
+                const v = await Promise.resolve(helper.resolve());
+                this.lazyCache.set(tag, v);
+                resolved[key] = v;
+              }
+              break;
+            }
+            default: {
+              resolved[key] = await Promise.resolve(helper.resolve());
+            }
+          }
+        } else {
+          resolved[key] = value;
+        }
+      }
+      const sharedKeys = new Set(Object.keys(shared));
+      this.applyPartialFilter(resolved, info, sharedKeys);
+      const version = await this.adapter.resolveVersion();
+      return {
+        component: this.component,
+        props: resolved,
+        url,
+        version: version ?? "",
+        encryptHistory: this.options.encryptHistory ?? this.adapter.encryptHistory(),
+        clearHistory: this.options.clearHistory ?? false,
+        deferredProps: Object.keys(deferredProps).length > 0 ? deferredProps : undefined,
+        mergeProps: mergeProps.length > 0 ? mergeProps : undefined,
+        deepMergeProps: deepMergeProps.length > 0 ? deepMergeProps : undefined,
+        matchPropsOn: matchPropsOn.length > 0 ? matchPropsOn : undefined,
+        scrollRegions: {}
+      };
+    }
+    applyPartialFilter(resolved, info, sharedKeys) {
+      if (!this.isPartialReload(info))
+        return;
+      if (info.partialOnly) {
+        for (const key of Object.keys(resolved)) {
+          const isAlways = sharedKeys.has(key);
+          if (!info.partialOnly.includes(key) && !isAlways) {
+            delete resolved[key];
+          }
+        }
+      }
+      if (info.partialExcept) {
+        for (const key of Object.keys(resolved)) {
+          const isAlways = sharedKeys.has(key);
+          if (info.partialExcept.includes(key) && !isAlways) {
+            delete resolved[key];
+          }
+        }
+      }
+    }
+    isPartialReload(info) {
+      return info.isInertia && (!!info.partialOnly || !!info.partialExcept);
+    }
+    parseInertiaRequest(c) {
+      const isInertia = c.req.header("x-inertia") === "true";
+      const partialOnlyHeader = c.req.header("x-inertia-partial-data");
+      const partialExceptHeader = c.req.header("x-inertia-partial-except");
+      const resetHeader = c.req.header("x-inertia-reset");
+      return {
+        isInertia,
+        clientVersion: c.req.header("x-inertia-version") ?? undefined,
+        partialComponent: c.req.header("x-inertia-partial-component") ?? undefined,
+        partialOnly: this.csv(partialOnlyHeader),
+        partialExcept: this.csv(partialExceptHeader),
+        reset: this.csv(resetHeader),
+        isHardReload: c.req.header("x-inertia-hard-reload") === "true"
+      };
+    }
+    csv(value) {
+      if (!value)
+        return;
+      const parts = value.split(",").map((s) => s.trim()).filter(Boolean);
+      return parts.length > 0 ? parts : undefined;
+    }
+    jsonResponse(page) {
+      return new Response(JSON.stringify(page), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json",
+          Vary: "X-Inertia",
+          "X-Inertia": "true"
+        }
+      });
+    }
+    htmlResponse(c, page) {
+      const ssr = this.adapter.ssr();
+      return renderDefaultRoot(this.adapter, ssr ?? null, this.component, page, c);
+    }
+    assetVersionMismatch(url) {
+      return new Response(null, {
+        status: 409,
+        headers: {
+          "X-Inertia-Location": url
+        }
+      });
+    }
+  };
+});
+
+// src/view/inertia/form-helper.ts
+class InertiaFormBuilder {
+  adapter;
+  component;
+  props;
+  errorMap = {};
+  errorBagName;
+  constructor(adapter, component, initialProps = {}) {
+    this.adapter = adapter;
+    this.component = component;
+    this.props = { ...initialProps };
+  }
+  withProps(extra) {
+    Object.assign(this.props, extra);
+    return this;
+  }
+  with(key, value) {
+    this.props[key] = value;
+    return this;
+  }
+  withErrors(errors) {
+    for (const [field, message] of Object.entries(errors)) {
+      const list = Array.isArray(message) ? message : [message];
+      this.errorMap[field] = [...this.errorMap[field] ?? [], ...list];
+    }
+    return this;
+  }
+  withError(field, message) {
+    (this.errorMap[field] ??= []).push(message);
+    return this;
+  }
+  withErrorBag(name) {
+    this.errorBagName = name;
+    return this;
+  }
+  withValues(values) {
+    this.props.values = values;
+    return this;
+  }
+  render() {
+    if (Object.keys(this.errorMap).length > 0) {
+      this.props.errors = { ...this.errorMap };
+    }
+    if (this.errorBagName) {
+      this.props.errorBag = this.errorBagName;
+    }
+    return this.adapter.render(this.component, this.props);
+  }
+  redirect(url) {
+    return new Response(null, {
+      status: 303,
+      headers: { Location: url }
+    });
+  }
+  back(to) {
+    return new Response(null, {
+      status: 303,
+      headers: { Location: to ?? "back" }
+    });
+  }
+  getErrors() {
+    return { ...this.errorMap };
+  }
+  getProps() {
+    return { ...this.props };
+  }
+}
+
+// src/view/inertia/form-middleware.ts
+var FORM_METHODS;
+var init_form_middleware = __esm(() => {
+  FORM_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+});
+
+// src/view/inertia/inertia-adapter.ts
+import"reflect-metadata";
+var INERTIA_TOKEN, Inertia;
+var init_inertia_adapter = __esm(() => {
+  init_inertia_response();
+  INERTIA_TOKEN = Symbol.for("nexus:Inertia");
+  Inertia = class Inertia {
+    config;
+    shared = {};
+    constructor(config = {}) {
+      this.config = {
+        encryptHistory: false,
+        ...config
+      };
+    }
+    render(component, propsOrDeferred, maybeProps) {
+      const { component: comp, props } = this.normalizeRenderArgs(component, propsOrDeferred, maybeProps);
+      return new InertiaResponse(this, comp, props);
+    }
+    location(url) {
+      return new Response(null, {
+        status: 409,
+        headers: {
+          "X-Inertia-Location": url
+        }
+      });
+    }
+    redirect(url, status = 302) {
+      return new Response(null, {
+        status,
+        headers: { Location: url }
+      });
+    }
+    back() {
+      return new Response(null, {
+        status: 302,
+        headers: { Location: "back" }
+      });
+    }
+    form(component, initialProps = {}) {
+      return new InertiaFormBuilder(this, component, initialProps);
+    }
+    setVersion(version) {
+      this.config.version = version;
+      return this;
+    }
+    setSsrAdapter(adapter) {
+      this.config.ssr = adapter ?? undefined;
+      return this;
+    }
+    setTitle(title) {
+      this.config.title = title;
+      return this;
+    }
+    setEncryptHistory(encrypt = true) {
+      this.config.encryptHistory = encrypt;
+      return this;
+    }
+    setSharedProps(shared) {
+      this.config.sharedProps = shared;
+      return this;
+    }
+    share(key, value) {
+      if (typeof key === "string") {
+        this.shared[key] = value;
+      } else if (key && typeof key === "object") {
+        Object.assign(this.shared, key);
+      }
+    }
+    unshare(key) {
+      delete this.shared[key];
+    }
+    getShared() {
+      return { ...this.shared };
+    }
+    title() {
+      return this.config.title ?? "Nexus";
+    }
+    encryptHistory() {
+      return this.config.encryptHistory ?? false;
+    }
+    ssr() {
+      return this.config.ssr ?? null;
+    }
+    async resolveVersion() {
+      const v = this.config.version;
+      if (typeof v === "function")
+        return await v();
+      return v;
+    }
+    async getSharedFor(_c) {
+      const static_ = this.getShared();
+      const configured = this.config.sharedProps;
+      if (typeof configured === "function") {
+        const dyn = await configured();
+        return { ...static_, ...dyn };
+      }
+      return { ...static_, ...configured ?? {} };
+    }
+    static TOKEN = INERTIA_TOKEN;
+    normalizeRenderArgs(component, propsOrDeferred, maybeProps) {
+      if (maybeProps !== undefined) {
+        const deferred = {};
+        for (const [k, v] of Object.entries(propsOrDeferred)) {
+          if (v instanceof DeferredProp)
+            deferred[k] = v;
+          else
+            throw new Error(`Inertia.render: 3-arg form expects the second argument to be a map of deferred props. ` + `Got non-deferred value at key "${k}".`);
+        }
+        return { component, props: { ...deferred, ...maybeProps } };
+      }
+      return { component, props: propsOrDeferred ?? {} };
+    }
+  };
+});
+
+// src/view/inertia/ssr/registry.ts
+class ComponentRegistry {
+  map = new Map;
+  register(name, component) {
+    this.map.set(name, component);
+    return this;
+  }
+  registerAll(components) {
+    for (const [name, component] of Object.entries(components)) {
+      this.map.set(name, component);
+    }
+    return this;
+  }
+  resolve(name) {
+    return this.map.get(name);
+  }
+  has(name) {
+    return this.map.has(name);
+  }
+  unregister(name) {
+    return this.map.delete(name);
+  }
+  names() {
+    return [...this.map.keys()];
+  }
+  get size() {
+    return this.map.size;
+  }
+}
+
+// src/view/inertia/ssr/react-adapter.ts
+var init_react_adapter = () => {};
+
+// src/view/inertia/ssr/vue-adapter.ts
+var init_vue_adapter = () => {};
+
+// src/view/inertia/ssr/svelte-adapter.ts
+var init_svelte_adapter = () => {};
+
+// src/view/inertia/ssr/solid-adapter.ts
+var init_solid_adapter = () => {};
+
+// src/view/inertia/ssr/index.ts
+var init_ssr = __esm(() => {
+  init_react_adapter();
+  init_vue_adapter();
+  init_svelte_adapter();
+  init_solid_adapter();
+});
+
+// src/view/inertia/index.ts
+var init_inertia = __esm(() => {
+  init_inertia_response();
+  init_form_middleware();
+  init_inertia_adapter();
+  init_ssr();
+});
+
+// src/core/application.ts
+var exports_application = {};
+__export(exports_application, {
+  Application: () => Application
+});
+import"reflect-metadata";
+
+class Application {
+  container;
+  server;
+  inertia;
+  viewAdapter;
+  constructor(rootModule, options = {}) {
+    this.container = new ApplicationContainer;
+    const scanner2 = new ModuleScanner(this.container);
+    const { root, modules } = scanner2.scan(rootModule);
+    this.server = new NexusServer(this.container, options);
+    for (const m of modules) {
+      for (const controller2 of m.controllers) {
+        this.server.router.registerController(controller2, m.container);
+      }
+    }
+    for (const controller2 of root.controllers) {
+      this.server.router.registerController(controller2, root.container);
+    }
+    this.viewAdapter = options.viewAdapter ?? new RenduAdapter;
+    if (options.inertia) {
+      this.inertia = new Inertia(options.inertia);
+      this.container.register({
+        provide: Inertia.TOKEN,
+        useValue: this.inertia
+      });
+    } else {
+      this.inertia = null;
+    }
+    this.tryLoadNxConfig();
+    if (process.env["NEXUS_DEBUG"] === "1") {
+      console.log("[nexus] Modules:", modules.length);
+      console.log("[nexus] Controllers:", modules.flatMap((m) => m.controllers).map((c) => c.name));
+      console.log("[nexus] Providers (root):", this.container.list());
+      console.log("[nexus] Inertia:", this.inertia ? "enabled" : "disabled");
+    }
+  }
+  tryLoadNxConfig() {
+    if (false)
+      ;
+    try {
+      const mod = __require(process.cwd() + "/nx.config.ts");
+      const cfg = mod.default ?? mod;
+      if (cfg && typeof cfg.viewPaths === "string" && cfg.viewPaths.length > 0) {
+        setViewPaths(cfg.viewPaths);
+      }
+    } catch {}
+  }
+  setViewAdapter(adapter) {
+    this.viewAdapter = adapter;
+    return this;
+  }
+  setViewPaths(path) {
+    setViewPaths(path);
+    return this;
+  }
+  async render(view, data = {}) {
+    return this.viewAdapter.render(view, data);
+  }
+  async listen(port) {
+    if (port) {
+      this.server.setPort(port);
+    }
+    return this.server.start();
+  }
+  get fetch() {
+    return this.server.fetch;
+  }
+  static bootstrap(rootModule, options) {
+    return new Application(rootModule, options);
+  }
+}
+var init_application = __esm(() => {
+  init_container();
+  init_scanner();
+  init_server();
+  init_rendu();
+  init_view_engine();
+  init_inertia();
+});
+
+// src/view/index.ts
+init_rendu();
+init_view_engine();
+
+// src/index.ts
+import"reflect-metadata";
+
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/core/decorators/index.ts
+init_controller();
+
+// src/core/decorators/injectable.ts
+init_constants();
+import"reflect-metadata";
+function Injectable(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+    if (options.scope) {
+      Reflect.defineMetadata("nexus:di:scope", options.scope, target);
+    }
+  };
+}
+function isInjectable(target) {
+  return Reflect.hasMetadata(METADATA_KEY.INJECTABLE, target);
+}
+function getScope(target) {
+  return Reflect.getMetadata("nexus:di:scope", target);
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(METADATA_KEY.INJECT, target) ?? new Map;
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(METADATA_KEY.INJECT, existing, target);
+  };
+}
+
+// src/core/decorators/index.ts
+init_http_methods();
+init_params();
+init_validate();
+
+// src/core/decorators/repository.ts
+init_constants();
+import"reflect-metadata";
+function Repository(entityToken) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.REPOSITORY, { entity: entityToken }, target);
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+  };
+}
+function getRepositoryMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.REPOSITORY, target);
+}
+function isRepository(target) {
+  return Reflect.hasMetadata(METADATA_KEY.REPOSITORY, target);
+}
+// src/core/decorators/metadata.ts
+init_constants();
+// src/core/di/index.ts
+init_request_middleware();
+init_container();
+init_scanner();
+init_request_scope();
+// src/core/http/context.ts
+function getNexusVar(c) {
+  return c.var.nexus;
+}
+
+// src/core/http/index.ts
+init_router();
+init_server();
+// src/core/validation/index.ts
+init_validator();
+// src/core/orm/drizzle-adapter.ts
+class DrizzleModule {
+  config;
+  token;
+  constructor(token = "DB", config) {
+    this.config = config;
+    this.token = token;
+  }
+  build() {
+    if (this.config.instance)
+      return this.config.instance;
+    if (this.config.driver && this.config.schema) {
+      return this.config.driver({
+        schema: this.config.schema,
+        client: this.config.client
+      });
+    }
+    throw new Error("DrizzleModule requires either `instance` or `driver` + `schema` configuration.");
+  }
+  asModule() {
+    const token = this.token;
+    const builder = () => this.build();
+
+    class DrizzleProvider {
+    }
+    Object.defineProperty(DrizzleProvider, "name", {
+      value: `DrizzleProvider<${token}>`
+    });
+    return DrizzleProvider;
+  }
+  registerInto(container2) {
+    container2.register({
+      provide: this.token,
+      useFactory: () => this.build()
+    });
+  }
+}
+async function getDb(config) {
+  if (config.instance)
+    return config.instance;
+  if (config.driver && config.schema) {
+    return config.driver({ schema: config.schema, client: config.client });
+  }
+  throw new Error("getDb requires either `instance` or `driver` + `schema` configuration.");
+}
+// src/core/runtime/index.ts
+init_node();
+
+// src/core/index.ts
+init_application();
+init_constants();
+
+// src/index.ts
+init_application();
+var src_default = Application;
+export {
+  validateRequest,
+  setViewPaths,
+  setRequestState,
+  requestScopeMiddleware,
+  renderView,
+  nodeAdapter,
+  logger,
+  loadTemplate,
+  isRepository,
+  isInjectable,
+  isController,
+  getViewPaths,
+  getValidationMetadata,
+  getScope,
+  getRoutes,
+  getRequestState,
+  getRequestScope,
+  getRequest,
+  getRepositoryMetadata,
+  getParamMetadata,
+  getNexusVar,
+  getModuleOptions,
+  getDb,
+  getControllerMetadata,
+  formatValidationError,
+  errorHandler,
+  detectRuntime,
+  src_default as default,
+  createRouter,
+  createParamDecorator,
+  cors,
+  cloudflareAdapter,
+  bunAdapter,
+  ValidationError,
+  Validate,
+  User,
+  Res,
+  RequestScopeStorage,
+  Req,
+  Repository,
+  RenduAdapter,
+  REQUEST_SCOPE,
+  REQUEST,
+  Query,
+  Put,
+  Post,
+  Patch,
+  Param,
+  PARAM_TYPES,
+  Options,
+  NexusServer,
+  Next,
+  ModuleScanner,
+  Module,
+  METADATA_KEY,
+  Injectable,
+  Inject,
+  Headers2 as Headers,
+  Head,
+  HTTP_METHODS,
+  Get,
+  EtaAdapter,
+  EdgeAdapter,
+  DrizzleModule,
+  Delete,
+  DIContainer,
+  Ctx,
+  Controller,
+  Body,
+  ApplicationContainer,
+  Application
+};
+
+//# debugId=ABDC5E0F1A95E8AD64756E2164756E21
+//# sourceMappingURL=index.js.map