nitro-nightly 3.1.0-20251026-124439-6ad28278 → 3.1.0-20251026-232057-ce388de2

package/dist/_chunks/build.mjs

@@ -3,7 +3,6 @@ import { isTest } from 'std-env';
 import './index.mjs';
 import 'consola';
 import 'hookable';
-import 'nitro/runtime/meta';
 import 'node:fs';
 import 'node:fs/promises';
 import 'node:url';
@@ -41,6 +40,7 @@ import 'youch';
 import 'source-map';
 import 'srvx';
 import 'klona/full';
+import 'nitro/runtime/meta';
 import 'node:module';
 import 'ofetch';
 import 'klona';

package/dist/_chunks/detect-acorn.mjs

@@ -4,7 +4,6 @@ import 'node:process';
 import 'scule';
 import 'consola';
 import 'hookable';
-import 'nitro/runtime/meta';
 import 'node:fs';
 import 'node:fs/promises';
 import 'node:url';
@@ -41,6 +40,7 @@ import 'youch';
 import 'source-map';
 import 'srvx';
 import 'klona/full';
+import 'nitro/runtime/meta';
 import 'node:module';
 import 'ofetch';
 import 'klona';

package/dist/_chunks/index.mjs

@@ -1,6 +1,5 @@
 import consola, { consola as consola$1 } from 'consola';
-import { createHooks, createDebugger } from 'hookable';
-import { runtimeDir, pkgDir } from 'nitro/runtime/meta';
+import { Hookable, createDebugger } from 'hookable';
 import fs, { promises, statSync, realpathSync, lstatSync, readFileSync, existsSync, accessSync, constants as constants$1 } from 'node:fs';
 import fsp, { readFile as readFile$1, rm, stat, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
 import { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL as URL$1 } from 'node:url';
@@ -21,6 +20,7 @@ import require$$2 from 'os';
 import require$$3 from 'crypto';
 import { g as getDefaultExportFromCjs, b as getAugmentedNamespace, d as debounce } from './app.mjs';
 import { klona } from 'klona/full';
+import { runtimeDir, pkgDir } from 'nitro/runtime/meta';
 import { isDebug, isTest } from 'std-env';
 import { joinURL, withLeadingSlash, withoutTrailingSlash, withTrailingSlash, withBase } from 'ufo';
 import { builtinModules, createRequire as createRequire$1 } from 'node:module';
@@ -20679,6 +20679,9 @@ class Router {
       addRoute(this.#router, route.method, route.route, route.data);
     }
   }
+  hasRoutes() {
+    return this.#routes.length > 0;
+  }
   compileToString(opts) {
     return this.#compiled || (this.#compiled = compileRouterToString(this.#router, void 0, opts));
   }
@@ -20696,7 +20699,7 @@ async function createNitro(config = {}, opts = {}) {
   const options = await loadOptions(config, opts);
   const nitro = {
     options,
-    hooks: createHooks(),
+    hooks: new Hookable(),
     vfs: {},
     routing: {},
     logger: consola$1.withTag("nitro"),
@@ -20715,7 +20718,6 @@ async function createNitro(config = {}, opts = {}) {
   });
   if (nitro.options.debug) {
     createDebugger(nitro.hooks, { tag: "nitro" });
-    nitro.options.plugins.push(join(runtimeDir, "internal/debug"));
   }
   if (nitro.options.logLevel !== void 0) {
     nitro.logger.level = nitro.options.logLevel;

package/dist/_chunks/info.mjs

@@ -10360,6 +10360,7 @@ import * as __routeRules__ from "nitro/runtime/internal/route-rules";
 ${nitro.options.serverEntry ? `import __serverEntry__ from ${JSON.stringify(nitro.options.serverEntry)};` : ""}
 import {${h3Imports.join(", ")}} from "nitro/deps/h3";
 
+export const hasRouteRules = ${nitro.routing.routeRules.hasRoutes() ? "true" : "false"};
 export const findRouteRules = ${nitro.routing.routeRules.compileToString({ serialize: serializeRouteRule, matchAll: true })}
 
 ${allHandlers.filter((h) => !h.lazy).map((h) => (
@@ -10374,10 +10375,13 @@ ${allHandlers.filter((h) => h.lazy).map(
             )
           ).join("\n")}
 
+export const hasRoutes = ${nitro.routing.routes.hasRoutes() ? "true" : "false"};
 export const findRoute = ${nitro.routing.routes.compileToString({ serialize: serializeHandler })}
 
+export const hasRoutedMiddleware = ${nitro.routing.routedMiddleware.hasRoutes() ? "true" : "false"};
 export const findRoutedMiddleware = ${nitro.routing.routedMiddleware.compileToString({ serialize: serializeHandler, matchAll: true })};
 
+export const hasGlobalMiddleware = ${nitro.routing.globalMiddleware.length > 0 || nitro.options.serverEntry ? "true" : "false"};
 export const globalMiddleware = [${nitro.routing.globalMiddleware.map((h) => h.lazy ? h._importHash : `toEventHandler(${h._importHash})`).join(",")}];
 
 ${nitro.options.serverEntry && /* js */

package/dist/_chunks/json5.mjs

@@ -1,7 +1,6 @@
 import { N } from './index.mjs';
 import 'consola';
 import 'hookable';
-import 'nitro/runtime/meta';
 import 'node:fs';
 import 'node:fs/promises';
 import 'node:url';
@@ -40,6 +39,7 @@ import 'youch';
 import 'source-map';
 import 'srvx';
 import 'klona/full';
+import 'nitro/runtime/meta';
 import 'node:module';
 import 'ofetch';
 import 'klona';

package/dist/_chunks/jsonc.mjs

@@ -1,7 +1,6 @@
 export { h as parseJSONC } from './index.mjs';
 import 'consola';
 import 'hookable';
-import 'nitro/runtime/meta';
 import 'node:fs';
 import 'node:fs/promises';
 import 'node:url';
@@ -40,6 +39,7 @@ import 'youch';
 import 'source-map';
 import 'srvx';
 import 'klona/full';
+import 'nitro/runtime/meta';
 import 'node:module';
 import 'ofetch';
 import 'klona';

package/dist/_chunks/toml.mjs

@@ -1,7 +1,6 @@
 import { N } from './index.mjs';
 import 'consola';
 import 'hookable';
-import 'nitro/runtime/meta';
 import 'node:fs';
 import 'node:fs/promises';
 import 'node:url';
@@ -40,6 +39,7 @@ import 'youch';
 import 'source-map';
 import 'srvx';
 import 'klona/full';
+import 'nitro/runtime/meta';
 import 'node:module';
 import 'ofetch';
 import 'klona';

package/dist/_chunks/yaml.mjs

@@ -1,7 +1,6 @@
 import { C as C$1, N as N$1 } from './index.mjs';
 import 'consola';
 import 'hookable';
-import 'nitro/runtime/meta';
 import 'node:fs';
 import 'node:fs/promises';
 import 'node:url';
@@ -40,6 +39,7 @@ import 'youch';
 import 'source-map';
 import 'srvx';
 import 'klona/full';
+import 'nitro/runtime/meta';
 import 'node:module';
 import 'ofetch';
 import 'klona';

package/dist/index.mjs

@@ -3,7 +3,6 @@ export { b as build, p as prerender, w as writeTypes } from './_chunks/index3.mj
 export { c as createDevServer } from './_chunks/server.mjs';
 import 'consola';
 import 'hookable';
-import 'nitro/runtime/meta';
 import 'node:fs';
 import 'node:fs/promises';
 import 'node:url';
@@ -42,6 +41,7 @@ import 'youch';
 import 'source-map';
 import 'srvx';
 import 'klona/full';
+import 'nitro/runtime/meta';
 import 'node:module';
 import 'ofetch';
 import 'klona';

package/dist/node_modules/hookable/dist/index.mjs

@@ -1,290 +1,267 @@
+//#region src/utils.ts
 function flatHooks(configHooks, hooks = {}, parentName) {
-  for (const key in configHooks) {
-    const subHook = configHooks[key];
-    const name = parentName ? `${parentName}:${key}` : key;
-    if (typeof subHook === "object" && subHook !== null) {
-      flatHooks(subHook, hooks, name);
-    } else if (typeof subHook === "function") {
-      hooks[name] = subHook;
-    }
-  }
-  return hooks;
+	for (const key in configHooks) {
+		const subHook = configHooks[key];
+		const name = parentName ? `${parentName}:${key}` : key;
+		if (typeof subHook === "object" && subHook !== null) flatHooks(subHook, hooks, name);
+		else if (typeof subHook === "function") hooks[name] = subHook;
+	}
+	return hooks;
 }
 function mergeHooks(...hooks) {
-  const finalHooks = {};
-  for (const hook of hooks) {
-    const flatenHook = flatHooks(hook);
-    for (const key in flatenHook) {
-      if (finalHooks[key]) {
-        finalHooks[key].push(flatenHook[key]);
-      } else {
-        finalHooks[key] = [flatenHook[key]];
-      }
-    }
-  }
-  for (const key in finalHooks) {
-    if (finalHooks[key].length > 1) {
-      const array = finalHooks[key];
-      finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
-    } else {
-      finalHooks[key] = finalHooks[key][0];
-    }
-  }
-  return finalHooks;
+	const finalHooks = {};
+	for (const hook of hooks) {
+		const flatenHook = flatHooks(hook);
+		for (const key in flatenHook) if (finalHooks[key]) finalHooks[key].push(flatenHook[key]);
+		else finalHooks[key] = [flatenHook[key]];
+	}
+	for (const key in finalHooks) if (finalHooks[key].length > 1) {
+		const array = finalHooks[key];
+		finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
+	} else finalHooks[key] = finalHooks[key][0];
+	return finalHooks;
 }
 function serial(tasks, function_) {
-  return tasks.reduce(
-    (promise, task) => promise.then(() => function_(task)),
-    Promise.resolve()
-  );
+	return tasks.reduce((promise, task) => promise.then(() => function_(task)), Promise.resolve());
+}
+const createTask = /* @__PURE__ */ (() => {
+	if (console.createTask) return console.createTask;
+	const defaultTask = { run: (fn) => fn() };
+	return () => defaultTask;
+})();
+function callHooks(hooks, args, startIndex, task) {
+	for (let i = startIndex; i < hooks.length; i += 1) try {
+		const result = task ? task.run(() => hooks[i](...args)) : hooks[i](...args);
+		if (result instanceof Promise) return result.then(() => callHooks(hooks, args, i + 1, task));
+	} catch (error) {
+		return Promise.reject(error);
+	}
 }
-const defaultTask = { run: (function_) => function_() };
-const _createTask = () => defaultTask;
-const createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
 function serialTaskCaller(hooks, args) {
-  const name = args.shift();
-  const task = createTask(name);
-  return hooks.reduce(
-    (promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
-    Promise.resolve()
-  );
+	if (hooks.length > 0) return callHooks(hooks, args, 0, createTask(args.shift()));
 }
 function parallelTaskCaller(hooks, args) {
-  const name = args.shift();
-  const task = createTask(name);
-  return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
+	if (hooks.length > 0) {
+		const task = createTask(args.shift());
+		return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
+	}
 }
+/** @deprecated */
 function serialCaller(hooks, arguments_) {
-  return hooks.reduce(
-    (promise, hookFunction) => promise.then(() => hookFunction(...arguments_ || [])),
-    Promise.resolve()
-  );
+	return hooks.reduce((promise, hookFunction) => promise.then(() => hookFunction(...arguments_ || [])), Promise.resolve());
 }
+/** @deprecated */
 function parallelCaller(hooks, args) {
-  return Promise.all(hooks.map((hook) => hook(...args || [])));
+	return Promise.all(hooks.map((hook) => hook(...args || [])));
 }
 function callEachWith(callbacks, arg0) {
-  for (const callback of [...callbacks]) {
-    callback(arg0);
-  }
+	for (const callback of [...callbacks]) callback(arg0);
 }
 
-class Hookable {
-  constructor() {
-    this._hooks = {};
-    this._before = void 0;
-    this._after = void 0;
-    this._deprecatedMessages = void 0;
-    this._deprecatedHooks = {};
-    this.hook = this.hook.bind(this);
-    this.callHook = this.callHook.bind(this);
-    this.callHookWith = this.callHookWith.bind(this);
-  }
-  hook(name, function_, options = {}) {
-    if (!name || typeof function_ !== "function") {
-      return () => {
-      };
-    }
-    const originalName = name;
-    let dep;
-    while (this._deprecatedHooks[name]) {
-      dep = this._deprecatedHooks[name];
-      name = dep.to;
-    }
-    if (dep && !options.allowDeprecated) {
-      let message = dep.message;
-      if (!message) {
-        message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
-      }
-      if (!this._deprecatedMessages) {
-        this._deprecatedMessages = /* @__PURE__ */ new Set();
-      }
-      if (!this._deprecatedMessages.has(message)) {
-        console.warn(message);
-        this._deprecatedMessages.add(message);
-      }
-    }
-    if (!function_.name) {
-      try {
-        Object.defineProperty(function_, "name", {
-          get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
-          configurable: true
-        });
-      } catch {
-      }
-    }
-    this._hooks[name] = this._hooks[name] || [];
-    this._hooks[name].push(function_);
-    return () => {
-      if (function_) {
-        this.removeHook(name, function_);
-        function_ = void 0;
-      }
-    };
-  }
-  hookOnce(name, function_) {
-    let _unreg;
-    let _function = (...arguments_) => {
-      if (typeof _unreg === "function") {
-        _unreg();
-      }
-      _unreg = void 0;
-      _function = void 0;
-      return function_(...arguments_);
-    };
-    _unreg = this.hook(name, _function);
-    return _unreg;
-  }
-  removeHook(name, function_) {
-    if (this._hooks[name]) {
-      const index = this._hooks[name].indexOf(function_);
-      if (index !== -1) {
-        this._hooks[name].splice(index, 1);
-      }
-      if (this._hooks[name].length === 0) {
-        delete this._hooks[name];
-      }
-    }
-  }
-  deprecateHook(name, deprecated) {
-    this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
-    const _hooks = this._hooks[name] || [];
-    delete this._hooks[name];
-    for (const hook of _hooks) {
-      this.hook(name, hook);
-    }
-  }
-  deprecateHooks(deprecatedHooks) {
-    Object.assign(this._deprecatedHooks, deprecatedHooks);
-    for (const name in deprecatedHooks) {
-      this.deprecateHook(name, deprecatedHooks[name]);
-    }
-  }
-  addHooks(configHooks) {
-    const hooks = flatHooks(configHooks);
-    const removeFns = Object.keys(hooks).map(
-      (key) => this.hook(key, hooks[key])
-    );
-    return () => {
-      for (const unreg of removeFns.splice(0, removeFns.length)) {
-        unreg();
-      }
-    };
-  }
-  removeHooks(configHooks) {
-    const hooks = flatHooks(configHooks);
-    for (const key in hooks) {
-      this.removeHook(key, hooks[key]);
-    }
-  }
-  removeAllHooks() {
-    for (const key in this._hooks) {
-      delete this._hooks[key];
-    }
-  }
-  callHook(name, ...arguments_) {
-    arguments_.unshift(name);
-    return this.callHookWith(serialTaskCaller, name, ...arguments_);
-  }
-  callHookParallel(name, ...arguments_) {
-    arguments_.unshift(name);
-    return this.callHookWith(parallelTaskCaller, name, ...arguments_);
-  }
-  callHookWith(caller, name, ...arguments_) {
-    const event = this._before || this._after ? { name, args: arguments_, context: {} } : void 0;
-    if (this._before) {
-      callEachWith(this._before, event);
-    }
-    const result = caller(
-      name in this._hooks ? [...this._hooks[name]] : [],
-      arguments_
-    );
-    if (result instanceof Promise) {
-      return result.finally(() => {
-        if (this._after && event) {
-          callEachWith(this._after, event);
-        }
-      });
-    }
-    if (this._after && event) {
-      callEachWith(this._after, event);
-    }
-    return result;
-  }
-  beforeEach(function_) {
-    this._before = this._before || [];
-    this._before.push(function_);
-    return () => {
-      if (this._before !== void 0) {
-        const index = this._before.indexOf(function_);
-        if (index !== -1) {
-          this._before.splice(index, 1);
-        }
-      }
-    };
-  }
-  afterEach(function_) {
-    this._after = this._after || [];
-    this._after.push(function_);
-    return () => {
-      if (this._after !== void 0) {
-        const index = this._after.indexOf(function_);
-        if (index !== -1) {
-          this._after.splice(index, 1);
-        }
-      }
-    };
-  }
-}
+//#endregion
+//#region src/hookable.ts
+var Hookable = class {
+	_hooks;
+	_before;
+	_after;
+	_deprecatedHooks;
+	_deprecatedMessages;
+	constructor() {
+		this._hooks = {};
+		this._before = void 0;
+		this._after = void 0;
+		this._deprecatedMessages = void 0;
+		this._deprecatedHooks = {};
+		this.hook = this.hook.bind(this);
+		this.callHook = this.callHook.bind(this);
+		this.callHookWith = this.callHookWith.bind(this);
+	}
+	hook(name, function_, options = {}) {
+		if (!name || typeof function_ !== "function") return () => {};
+		const originalName = name;
+		let dep;
+		while (this._deprecatedHooks[name]) {
+			dep = this._deprecatedHooks[name];
+			name = dep.to;
+		}
+		if (dep && !options.allowDeprecated) {
+			let message = dep.message;
+			if (!message) message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+			if (!this._deprecatedMessages) this._deprecatedMessages = /* @__PURE__ */ new Set();
+			if (!this._deprecatedMessages.has(message)) {
+				console.warn(message);
+				this._deprecatedMessages.add(message);
+			}
+		}
+		if (!function_.name) try {
+			Object.defineProperty(function_, "name", {
+				get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+				configurable: true
+			});
+		} catch {}
+		this._hooks[name] = this._hooks[name] || [];
+		this._hooks[name].push(function_);
+		return () => {
+			if (function_) {
+				this.removeHook(name, function_);
+				function_ = void 0;
+			}
+		};
+	}
+	hookOnce(name, function_) {
+		let _unreg;
+		let _function = (...arguments_) => {
+			if (typeof _unreg === "function") _unreg();
+			_unreg = void 0;
+			_function = void 0;
+			return function_(...arguments_);
+		};
+		_unreg = this.hook(name, _function);
+		return _unreg;
+	}
+	removeHook(name, function_) {
+		const hooks = this._hooks[name];
+		if (hooks) {
+			const index = hooks.indexOf(function_);
+			if (index !== -1) hooks.splice(index, 1);
+			if (hooks.length === 0) this._hooks[name] = void 0;
+		}
+	}
+	deprecateHook(name, deprecated) {
+		this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
+		const _hooks = this._hooks[name] || [];
+		this._hooks[name] = void 0;
+		for (const hook of _hooks) this.hook(name, hook);
+	}
+	deprecateHooks(deprecatedHooks) {
+		for (const name in deprecatedHooks) this.deprecateHook(name, deprecatedHooks[name]);
+	}
+	addHooks(configHooks) {
+		const hooks = flatHooks(configHooks);
+		const removeFns = Object.keys(hooks).map((key) => this.hook(key, hooks[key]));
+		return () => {
+			for (const unreg of removeFns) unreg();
+			removeFns.length = 0;
+		};
+	}
+	removeHooks(configHooks) {
+		const hooks = flatHooks(configHooks);
+		for (const key in hooks) this.removeHook(key, hooks[key]);
+	}
+	removeAllHooks() {
+		this._hooks = {};
+	}
+	callHook(name, ...args) {
+		return this.callHookWith(serialTaskCaller, name, args);
+	}
+	callHookParallel(name, ...args) {
+		return this.callHookWith(parallelTaskCaller, name, args);
+	}
+	callHookWith(caller, name, args) {
+		const event = this._before || this._after ? {
+			name,
+			args,
+			context: {}
+		} : void 0;
+		if (this._before) callEachWith(this._before, event);
+		const _args = args?.length ? [name, ...args] : [name];
+		const result = caller(this._hooks[name] ? [...this._hooks[name]] : [], _args);
+		if (result instanceof Promise) return result.finally(() => {
+			if (this._after && event) callEachWith(this._after, event);
+		});
+		if (this._after && event) callEachWith(this._after, event);
+		return result;
+	}
+	beforeEach(function_) {
+		this._before = this._before || [];
+		this._before.push(function_);
+		return () => {
+			if (this._before !== void 0) {
+				const index = this._before.indexOf(function_);
+				if (index !== -1) this._before.splice(index, 1);
+			}
+		};
+	}
+	afterEach(function_) {
+		this._after = this._after || [];
+		this._after.push(function_);
+		return () => {
+			if (this._after !== void 0) {
+				const index = this._after.indexOf(function_);
+				if (index !== -1) this._after.splice(index, 1);
+			}
+		};
+	}
+};
 function createHooks() {
-  return new Hookable();
+	return new Hookable();
 }
+var HookableCore = class {
+	_hooks;
+	constructor() {
+		this._hooks = {};
+	}
+	hook(name, fn) {
+		if (!name || typeof fn !== "function") return () => {};
+		this._hooks[name] = this._hooks[name] || [];
+		this._hooks[name].push(fn);
+		return () => {
+			if (fn) {
+				this.removeHook(name, fn);
+				fn = void 0;
+			}
+		};
+	}
+	removeHook(name, function_) {
+		const hooks = this._hooks[name];
+		if (hooks) {
+			const index = hooks.indexOf(function_);
+			if (index !== -1) hooks.splice(index, 1);
+			if (hooks.length === 0) this._hooks[name] = void 0;
+		}
+	}
+	callHook(name, ...args) {
+		const hooks = this._hooks[name];
+		if (!hooks || hooks.length === 0) return;
+		return callHooks(hooks, args, 0);
+	}
+};
 
+//#endregion
+//#region src/debugger.ts
 const isBrowser = typeof window !== "undefined";
+/** Start debugging hook names and timing in console */
 function createDebugger(hooks, _options = {}) {
-  const options = {
-    inspect: isBrowser,
-    group: isBrowser,
-    filter: () => true,
-    ..._options
-  };
-  const _filter = options.filter;
-  const filter = typeof _filter === "string" ? (name) => name.startsWith(_filter) : _filter;
-  const _tag = options.tag ? `[${options.tag}] ` : "";
-  const logPrefix = (event) => _tag + event.name + "".padEnd(event._id, "\0");
-  const _idCtr = {};
-  const unsubscribeBefore = hooks.beforeEach((event) => {
-    if (filter !== void 0 && !filter(event.name)) {
-      return;
-    }
-    _idCtr[event.name] = _idCtr[event.name] || 0;
-    event._id = _idCtr[event.name]++;
-    console.time(logPrefix(event));
-  });
-  const unsubscribeAfter = hooks.afterEach((event) => {
-    if (filter !== void 0 && !filter(event.name)) {
-      return;
-    }
-    if (options.group) {
-      console.groupCollapsed(event.name);
-    }
-    if (options.inspect) {
-      console.timeLog(logPrefix(event), event.args);
-    } else {
-      console.timeEnd(logPrefix(event));
-    }
-    if (options.group) {
-      console.groupEnd();
-    }
-    _idCtr[event.name]--;
-  });
-  return {
-    /** Stop debugging and remove listeners */
-    close: () => {
-      unsubscribeBefore();
-      unsubscribeAfter();
-    }
-  };
+	const options = {
+		inspect: isBrowser,
+		group: isBrowser,
+		filter: () => true,
+		..._options
+	};
+	const _filter = options.filter;
+	const filter = typeof _filter === "string" ? (name) => name.startsWith(_filter) : _filter;
+	const _tag = options.tag ? `[${options.tag}] ` : "";
+	const logPrefix = (event) => _tag + event.name + "".padEnd(event._id, "\0");
+	const _idCtr = {};
+	const unsubscribeBefore = hooks.beforeEach((event) => {
+		if (filter !== void 0 && !filter(event.name)) return;
+		_idCtr[event.name] = _idCtr[event.name] || 0;
+		event._id = _idCtr[event.name]++;
+		console.time(logPrefix(event));
+	});
+	const unsubscribeAfter = hooks.afterEach((event) => {
+		if (filter !== void 0 && !filter(event.name)) return;
+		if (options.group) console.groupCollapsed(event.name);
+		if (options.inspect) console.timeLog(logPrefix(event), event.args);
+		else console.timeEnd(logPrefix(event));
+		if (options.group) console.groupEnd();
+		_idCtr[event.name]--;
+	});
+	return { close: () => {
+		unsubscribeBefore();
+		unsubscribeAfter();
+	} };
 }
 
-export { Hookable, createDebugger, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };
+//#endregion
+export { Hookable, HookableCore, createDebugger, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };

package/dist/node_modules/hookable/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hookable",
-  "version": "5.5.3",
+  "version": "6.0.0-rc.1",
   "description": "Awaitable hook system",
   "keywords": [
     "hook",
@@ -11,39 +11,42 @@
   ],
   "repository": "unjs/hookable",
   "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
   "exports": {
-    "import": "./dist/index.mjs",
-    "types": "./dist/index.d.ts",
-    "require": "./dist/index.cjs"
+    ".": "./dist/index.mjs"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "files": [
     "dist"
   ],
-  "devDependencies": {
-    "@types/node": "^18.15.11",
-    "@vitest/coverage-c8": "^0.29.8",
-    "changelogen": "^0.5.2",
-    "eslint": "^8.37.0",
-    "eslint-config-unjs": "^0.1.0",
-    "expect-type": "^0.15.0",
-    "prettier": "^2.8.7",
-    "typescript": "^5.0.2",
-    "unbuild": "^1.1.2",
-    "vite": "^4.2.1",
-    "vitest": "^0.29.8"
-  },
-  "packageManager": "pnpm@8.0.0",
   "scripts": {
-    "build": "unbuild",
+    "bench": "node --expose-gc --allow-natives-syntax test/bench.ts",
+    "build": "obuild src/index.ts",
     "dev": "vitest",
-    "lint": "eslint --cache --ext .ts,.js,.mjs,.cjs . && prettier -c src test",
-    "lint:fix": "eslint --cache --ext .ts,.js,.mjs,.cjs . --fix && prettier -c src test -w",
+    "lint": "eslint --cache . && prettier -c src test",
+    "lint:fix": "eslint --cache . --fix && prettier -c src test -w",
     "prepublish": "pnpm build",
-    "release": "pnpm test && pnpm build && changelogen --release --push && pnpm publish",
+    "release": "pnpm test && pnpm build && changelogen --release --prerelease --publish --publishTag rc --push",
     "test": "pnpm lint && vitest run --coverage",
     "test:types": "tsc --noEmit"
-  }
+  },
+  "devDependencies": {
+    "@types/node": "^24.9.1",
+    "@vitest/coverage-v8": "^4.0.3",
+    "changelogen": "^0.6.2",
+    "esbuild": "^0.25.11",
+    "eslint": "^9.38.0",
+    "eslint-config-unjs": "^0.5.0",
+    "expect-type": "^1.2.2",
+    "hookable-prev": "npm:hookable@^5.0.0",
+    "mitata": "^1.0.34",
+    "obuild": "^0.3.0",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.3",
+    "vite": "^7.1.12",
+    "vitest": "^4.0.3"
+  },
+  "packageManager": "pnpm@10.19.0"
 }

package/dist/runtime/internal/app.mjs

@@ -1,13 +1,17 @@
 import { H3Core, toRequest } from "h3";
-import { createHooks } from "hookable";
+import { HookableCore } from "hookable";
 import { nitroAsyncContext } from "./context.mjs";
 import errorHandler from "#nitro-internal-virtual/error-handler";
 import { plugins } from "#nitro-internal-virtual/plugins";
 import {
+  hasRouteRules,
   findRoute,
   findRouteRules,
   globalMiddleware,
-  findRoutedMiddleware
+  findRoutedMiddleware,
+  hasRoutedMiddleware,
+  hasGlobalMiddleware,
+  hasRoutes
 } from "#nitro-internal-virtual/routing";
 export function useNitroApp() {
   return useNitroApp.__instance__ ??= initNitroApp();
@@ -25,9 +29,9 @@ function initNitroApp() {
   return nitroApp;
 }
 function createNitroApp() {
-  const hooks = createHooks();
+  const hooks = new HookableCore();
   const captureError = (error, errorCtx) => {
-    const promise = hooks.callHookParallel("error", error, errorCtx).catch((hookError) => {
+    const promise = hooks.callHook("error", error, errorCtx)?.catch?.((hookError) => {
       console.error("Error while capturing another error", hookError);
     });
     if (errorCtx?.event) {
@@ -40,20 +44,26 @@ function createNitroApp() {
       }
     }
   };
-  const h3App = createH3App(captureError);
-  let fetchHandler = async (req) => {
+  const h3App = createH3App({
+    onError(error, event) {
+      captureError(error, { event });
+      return errorHandler(error, event);
+    },
+    onRequest(event) {
+      return hooks.callHook("request", event)?.catch?.((error) => {
+        captureError(error, { event, tags: ["request"] });
+      });
+    },
+    onResponse(res, event) {
+      return hooks.callHook("response", res, event)?.catch?.((error) => {
+        captureError(error, { event, tags: ["response"] });
+      });
+    }
+  });
+  let fetchHandler = (req) => {
     req.context ??= {};
     req.context.nitro = req.context.nitro || { errors: [] };
-    const event = { req };
-    const nitroApp = useNitroApp();
-    await nitroApp.hooks.callHook("request", event).catch((error) => {
-      captureError(error, { event, tags: ["request"] });
-    });
-    const response = await h3App.request(req, void 0, req.context);
-    await nitroApp.hooks.callHook("response", response, event).catch((error) => {
-      captureError(error, { event, tags: ["request", "response"] });
-    });
-    return response;
+    return h3App.request(req, void 0, req.context);
   };
   if (import.meta._asyncContext) {
     const originalFetchHandler = fetchHandler;
@@ -89,27 +99,35 @@ function createNitroApp() {
   };
   return app;
 }
-function createH3App(captureError) {
-  const DEBUG_MODE = ["1", "true", "TRUE"].includes(process.env.DEBUG + "");
-  const h3App = new H3Core({
-    debug: DEBUG_MODE,
-    onError: (error, event) => {
-      captureError(error, { event, tags: ["request"] });
-      return errorHandler(error, event);
-    }
-  });
-  h3App._findRoute = (event) => findRoute(event.req.method, event.url.pathname);
+function createH3App(config) {
+  const h3App = new H3Core(config);
+  if (hasRoutes) {
+    h3App._findRoute = (event) => findRoute(event.req.method, event.url.pathname);
+  }
   h3App._getMiddleware = (event, route) => {
-    const pathname = event.url.pathname;
-    const method = event.req.method;
-    const { routeRules, routeRuleMiddleware } = getRouteRules(method, pathname);
-    event.context.routeRules = routeRules;
-    return [
-      ...routeRuleMiddleware,
-      ...globalMiddleware,
-      ...findRoutedMiddleware(method, pathname).map((r) => r.data),
-      ...route?.data?.middleware || []
-    ].filter(Boolean);
+    const needsRouting = hasRouteRules || hasRoutedMiddleware;
+    const pathname = needsRouting ? event.url.pathname : void 0;
+    const method = needsRouting ? event.req.method : void 0;
+    const middleware = [];
+    if (hasRouteRules) {
+      const routeRules = getRouteRules(method, pathname);
+      event.context.routeRules = routeRules?.routeRules;
+      if (routeRules?.routeRuleMiddleware.length) {
+        middleware.push(...routeRules.routeRuleMiddleware);
+      }
+    }
+    if (hasGlobalMiddleware) {
+      middleware.push(...globalMiddleware);
+    }
+    if (hasRoutedMiddleware) {
+      middleware.push(
+        ...findRoutedMiddleware(method, pathname).map((r) => r.data)
+      );
+    }
+    if (route?.data?.middleware?.length) {
+      middleware.push(...route.data.middleware);
+    }
+    return middleware;
   };
   return h3App;
 }

package/dist/runtime/internal/shutdown.mjs

@@ -22,7 +22,7 @@ export function setupGracefulShutdown(listener, nitroApp) {
           console.warn("Graceful shutdown timeout, force exiting...");
           resolve();
         }, shutdownConfig.timeout);
-        nitroApp.hooks.callHook("close").catch((error) => {
+        Promise.resolve(nitroApp.hooks.callHook("close")).catch((error) => {
           console.error(error);
         }).finally(() => {
           clearTimeout(timeout);

package/dist/types/index.d.mts

@@ -1,6 +1,6 @@
 import { HTTPMethod, HTTPEvent, H3Core, H3EventContext, HTTPHandler, HTTPError, ProxyOptions, Middleware } from 'h3';
 import { FetchRequest, FetchOptions, FetchResponse } from 'ofetch';
-import { Hookable, NestedHooks } from 'hookable';
+import { HookableCore, Hookable, NestedHooks } from 'hookable';
 import { ServerRequestContext, ServerRequest } from 'srvx';
 import { Jiti, JitiOptions } from 'jiti';
 import { Stats } from 'fs';
@@ -147,7 +147,7 @@ interface CachedEventHandlerOptions extends Omit<CacheOptions<ResponseCacheEntry
 
 interface NitroApp {
     _h3?: H3Core;
-    hooks: Hookable<NitroRuntimeHooks>;
+    hooks: HookableCore<NitroRuntimeHooks>;
     fetch: (req: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext) => Promise<Response>;
     captureError: CaptureError;
 }
@@ -3817,6 +3817,7 @@ declare class Router<T> {
     constructor(matchAll?: boolean);
     get routes(): Route<T>[];
     _update(routes: Route<T>[]): void;
+    hasRoutes(): boolean;
     compileToString(opts?: RouterCompilerOptions): string;
     match(method: string, path: string): undefined | T;
     matchAll(method: string, path: string): T[];

package/dist/vite.mjs

@@ -2,7 +2,6 @@ export { n as nitro } from './_chunks/plugin.mjs';
 import './_chunks/index.mjs';
 import 'consola';
 import 'hookable';
-import 'nitro/runtime/meta';
 import 'node:fs';
 import 'node:fs/promises';
 import 'node:url';
@@ -41,6 +40,7 @@ import 'youch';
 import 'source-map';
 import 'srvx';
 import 'klona/full';
+import 'nitro/runtime/meta';
 import 'node:module';
 import 'ofetch';
 import 'klona';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitro-nightly",
-  "version": "3.1.0-20251026-124439-6ad28278",
+  "version": "3.1.0-20251026-232057-ce388de2",
   "description": "Build and Deploy Universal JavaScript Servers",
   "homepage": "https://nitro.build",
   "repository": "nitrojs/nitro",
@@ -120,7 +120,7 @@
     "fs-extra": "^11.3.2",
     "get-port-please": "^3.2.0",
     "gzip-size": "^7.0.0",
-    "hookable": "^5.5.3",
+    "hookable": "^6.0.0-rc.1",
     "httpxy": "^0.1.7",
     "klona": "^2.0.6",
     "knitwork": "^1.2.0",

package/dist/runtime/internal/debug.d.mts

@@ -1,2 +0,0 @@
-declare const _default: NitroAppPlugin;
-export default _default;

package/dist/runtime/internal/debug.mjs

@@ -1,5 +0,0 @@
-import { createDebugger } from "hookable";
-import { defineNitroPlugin } from "./plugin.mjs";
-export default defineNitroPlugin((nitro) => {
-  createDebugger(nitro.hooks, { tag: "nitro-runtime" });
-});