@depup/h3 2.0.1-depup.0

package/dist/rules/compiler.d.mts

@@ -0,0 +1,94 @@
+import { RouteRuleConfig } from "../h3.mjs";
+import { MatcherMemoizeOptions } from "../match.mjs";
+
+export declare const DEFAULT_RUNTIME_RULES: Readonly<Record<string, RuntimeRuleImport>>;
+/** Module and optional named export for a generated rule-handler import. */
+type RuntimeRuleImport = string | RuntimeRuleImportSpec;
+interface RuntimeRuleImportSpec {
+  source: string;
+  /**
+   * Named export within `source`; must be a valid JS identifier (becomes an
+   * import binding in generated code).
+   * @default the rule key
+   */
+  export?: string;
+}
+interface CompileRouteRulesOptions {
+  /** Base URL prefix for all rule patterns (trailing slash trimmed). */
+  baseURL?: string;
+  /**
+   * Identifier prefix for imported handlers in generated code (handler `name`
+   * binds as `<prefix>$<name>`).
+   * @default "__ruleHandlers__"
+   */
+  handlersImportName?: string;
+  /**
+   * Runtime rules keyed by rule name, merged **over** `DEFAULT_RUNTIME_RULES`
+   * (list only additions/overrides). Keys bind as JS identifiers in generated
+   * code.
+   * @default DEFAULT_RUNTIME_RULES
+   */
+  runtimeRules?: Record<string, RuntimeRuleImport>;
+  /**
+   * Pre-merge each pattern's subsumption chain at compile time (exact, but
+   * requires a **chain-clean** rule set). Unlike the runtime matcher, the
+   * compiler is fail-safe: a non-chain-clean set emits a `console.warn` and
+   * falls back to plain compilation instead of throwing.
+   */
+  preMerge?: boolean;
+}
+/**
+ * Optional generated matcher export. A string sets its name; object form can
+ * also enable memoization.
+ */
+type MatcherExport = boolean | string | {
+  name?: string;
+  memoize?: boolean | MatcherMemoizeOptions;
+};
+/** Options for compiling a complete route-rules module. */
+interface CompileModuleOptions extends CompileRouteRulesOptions {
+  /**
+   * Also emit a ready-to-use matcher export. See {@link MatcherExport}.
+   * @default false
+   */
+  matcher?: MatcherExport;
+}
+/** Compiled module source, also split into composable imports and body. */
+interface CompiledRouteRules {
+  /**
+   * Handler import statements ({@link compileHandlersImport} output); empty
+   * for a data-only rule set. Includes the matcher infra import when one is
+   * requested.
+   */
+  imports: string;
+  /**
+   * `findRouteRules` export declaration (no imports), plus the matcher
+   * declaration when requested. References bindings {@link imports} brings
+   * into scope.
+   */
+  body: string;
+  /** The complete module source — {@link imports} then {@link body}. Same as `toString()`. */
+  code: string;
+  /** The complete module source ({@link code}), so the result interpolates as a string. */
+  toString(): string;
+}
+/**
+ * Compile a rule set into a complete ESM module exporting `findRouteRules`
+ * (and, with `matcher`, a ready-to-use matcher). Input is normalized
+ * internally — pass authored config or already-normalized rules.
+ */
+export declare function compileRouteRules(config: Record<string, RouteRuleConfig>, opts?: CompileModuleOptions): CompiledRouteRules;
+/**
+ * Compile a rule set into the source of a `findRouteRules(method, pathname)`
+ * function expression. Entries reference handler constructors as
+ * `<handlersImportName>$<name>` bindings — pair with
+ * {@link compileHandlersImport} (which imports exactly those names).
+ */
+export declare function compileFindRouteRules(config: Record<string, RouteRuleConfig>, opts?: CompileRouteRulesOptions): string;
+/**
+ * Import statement for exactly the handlers the rule set references (empty
+ * string if none), keeping unused handlers' deps (e.g. ocache) tree-shakeable.
+ * Input is normalized internally, so e.g. an `swr` shortcut counts as `cache`.
+ */
+export declare function compileHandlersImport(config: Record<string, RouteRuleConfig>, opts?: CompileRouteRulesOptions): string;
+export type { CompileModuleOptions, CompileRouteRulesOptions, CompiledRouteRules, MatcherExport, RuntimeRuleImport, RuntimeRuleImportSpec };

package/dist/rules/compiler.mjs

@@ -0,0 +1,173 @@
+import { createRulesRouter, normalizeRouteRules, parseRouteKey } from "../normalize.mjs";
+import { compareRoutes } from "rou3";
+import { compileRouterToString } from "rou3/compiler";
+const DEFAULT_RUNTIME_RULES = Object.freeze({
+	headers: "h3/rules",
+	redirect: "h3/rules",
+	proxy: "h3/rules/proxy",
+	cache: "h3/rules/cache",
+	cors: "h3/rules"
+});
+function resolveRuntimeRules(runtimeRules) {
+	return runtimeRules ? {
+		...DEFAULT_RUNTIME_RULES,
+		...runtimeRules
+	} : DEFAULT_RUNTIME_RULES;
+}
+function isRuntimeRule(name, runtimeRules) {
+	return Object.hasOwn(runtimeRules, name);
+}
+function resolveRuntimeRule(name, runtimeRules) {
+	const entry = runtimeRules[name];
+	return typeof entry === "string" ? {
+		source: entry,
+		export: name
+	} : {
+		source: entry.source,
+		export: entry.export ?? name
+	};
+}
+function serializePreMergedRouteRules(data, ns, runtimeRules) {
+	const resets = data.resets?.length ? `,resets:${JSON.stringify(data.resets)}` : "";
+	return `{route:${JSON.stringify(data.route)},rank:${data.rank}${resets},rules:${serializeRouteRuleEntries(data.rules, ns, runtimeRules)}}`;
+}
+function serializeRouteRuleEntries(entries, ns, runtimeRules) {
+	return `[${entries.map((entry) => {
+		const runtime = isRuntimeRule(entry.name, runtimeRules);
+		if (runtime) assertHandlerBinding(entry.name, "runtime rule name");
+		assertSerializableOptions(entry.options, entry, "options");
+		return [
+			`name:${JSON.stringify(entry.name)}`,
+			`route:${JSON.stringify(entry.route)}`,
+			runtime && `handler:${ns}$${entry.name}`,
+			`options:${JSON.stringify(entry.options)}`,
+			entry.rank && `rank:${entry.rank}`,
+			entry.paramRoutes && `paramRoutes:${JSON.stringify(entry.paramRoutes)}`
+		].filter(Boolean).join(",");
+	}).map((fields) => `{${fields}}`).join(",")}]`;
+}
+const DEFAULT_MATCHER_EXPORT_NAME = "matcher";
+function compileMatcherExport(matcher, overridePredicate) {
+	if (!matcher) return null;
+	const spec = typeof matcher === "string" ? { name: matcher } : matcher === true ? {} : matcher;
+	const name = spec.name || DEFAULT_MATCHER_EXPORT_NAME;
+	assertHandlerBinding(name, "matcher export name");
+	const { memoize } = spec;
+	let expr = `createMatcherFromFind(findRouteRules, ${overridePredicate})`;
+	if (memoize) {
+		const max = memoize === true ? void 0 : memoize.max;
+		expr = max === void 0 ? `memoizeRouteRulesMatcher(${expr})` : `memoizeRouteRulesMatcher(${expr}, { max: ${JSON.stringify(max)} })`;
+	}
+	return {
+		imports: `import { createMatcherFromFind${memoize ? ", memoizeRouteRulesMatcher" : ""} } from "h3/rules";`,
+		body: `export const ${name} = ${expr};\n`
+	};
+}
+function compileOverridePredicate(routes) {
+	const sorted = [...routes].sort();
+	const allowed = /* @__PURE__ */ new Map();
+	for (const current of sorted) for (const incoming of sorted) {
+		if (current === incoming) continue;
+		const rel = compareRoutes(current, incoming);
+		if (rel === "superset" || rel === "equal") {
+			let list = allowed.get(current);
+			if (!list) allowed.set(current, list = []);
+			list.push(incoming);
+		}
+	}
+	if (allowed.size === 0) return "(a, b) => a === b";
+	return `/* @__PURE__ */ (() => { const t = new Map([${[...allowed].map(([current, list]) => `[${JSON.stringify(current)}, new Set(${JSON.stringify(list)})]`).join(", ")}]); return (a, b) => a === b || (t.get(a)?.has(b) ?? false); })()`;
+}
+function assertHandlerBinding(name, what) {
+	if (!JS_IDENTIFIER_RE.test(name)) throw new Error(`[h3] rules: compiler: ${what} \`${name}\` is not a valid JS identifier — it is used as a binding in generated code`);
+}
+const JS_IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/;
+function assertSerializableOptions(value, entry, path) {
+	if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return;
+	if (Array.isArray(value)) {
+		for (const [i, item] of value.entries()) assertSerializableOptions(item, entry, `${path}[${i}]`);
+		return;
+	}
+	const proto = typeof value === "object" ? Object.getPrototypeOf(value) : void 0;
+	if (proto === Object.prototype || proto === null) {
+		for (const [key, item] of Object.entries(value)) {
+			if (key === "__proto__") throw new Error(`[h3] rules: compiler: \`${entry.name}\` rule for \`${entry.route}\` has a \`__proto__\` key at \`${path}\` — it cannot be embedded as a JS object literal without changing the object's prototype (its JSON.stringify output would diverge from the runtime matcher); rename or remove it`);
+			assertSerializableOptions(item, entry, `${path}.${key}`);
+		}
+		return;
+	}
+	const kind = typeof value === "object" ? value.constructor?.name || "object" : typeof value;
+	throw new Error(`[h3] rules: compiler: \`${entry.name}\` rule for \`${entry.route}\` has a non-JSON-serializable value at \`${path}\` (${kind}) — compiled rule options must survive a JSON round-trip`);
+}
+function compileRouteRules(config, opts = {}) {
+	const ctx = resolveCompileCtx(config, opts);
+	const handlerImports = emitHandlersImport(ctx);
+	const matcherExport = opts.matcher ? compileMatcherExport(opts.matcher, compileOverridePredicate(collectRoutes(ctx))) : null;
+	const imports = [handlerImports, matcherExport?.imports].filter(Boolean).join("\n");
+	const find = `export const findRouteRules = ${emitFindRouteRules(ctx)};\n`;
+	const body = matcherExport ? find + matcherExport.body : find;
+	const code = `${imports ? imports + "\n" : ""}${body}`;
+	return {
+		imports,
+		body,
+		code,
+		toString: () => code
+	};
+}
+function compileFindRouteRules(config, opts = {}) {
+	return emitFindRouteRules(resolveCompileCtx(config, opts));
+}
+function compileHandlersImport(config, opts = {}) {
+	return emitHandlersImport(resolveCompileCtx(config, opts));
+}
+function resolveCompileCtx(config, opts) {
+	const rules = normalizeRouteRules(config);
+	const ns = opts.handlersImportName || "__ruleHandlers__";
+	assertHandlerBinding(ns, "handlersImportName");
+	const ctx = {
+		rules,
+		preMerge: false,
+		runtimeRules: resolveRuntimeRules(opts.runtimeRules),
+		ns,
+		baseURL: opts.baseURL
+	};
+	if (opts.preMerge) try {
+		ctx.router = createRulesRouter(rules, {}, opts.baseURL, true);
+		ctx.preMerge = true;
+	} catch (error) {
+		console.warn(`[h3] rules: compiler: preMerge could not be applied — falling back to plain compilation.\n  ${error.message}`);
+	}
+	return ctx;
+}
+function emitFindRouteRules(ctx) {
+	const router = ctx.router ?? createRulesRouter(ctx.rules, {}, ctx.baseURL, ctx.preMerge);
+	return compileRouterToString(router, {
+		matchAll: true,
+		serialize: (data) => Array.isArray(data) ? serializeRouteRuleEntries(data, ctx.ns, ctx.runtimeRules) : serializePreMergedRouteRules(data, ctx.ns, ctx.runtimeRules)
+	});
+}
+function emitHandlersImport(ctx) {
+	const names = usedRuleHandlerNames(ctx);
+	if (names.length === 0) return "";
+	const bySource = /* @__PURE__ */ new Map();
+	for (const name of names) {
+		assertHandlerBinding(name, "runtime rule name");
+		const { source, export: exportName } = resolveRuntimeRule(name, ctx.runtimeRules);
+		assertHandlerBinding(exportName, "runtime rule export");
+		let specs = bySource.get(source);
+		if (!specs) bySource.set(source, specs = []);
+		specs.push(`${exportName} as ${ctx.ns}$${name}`);
+	}
+	return [...bySource.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([source, specs]) => `import { ${specs.join(", ")} } from ${JSON.stringify(source)};`).join("\n");
+}
+function collectRoutes(ctx) {
+	const routes = /* @__PURE__ */ new Set();
+	for (const key in ctx.rules) routes.add(parseRouteKey(key).path);
+	return [...routes];
+}
+function usedRuleHandlerNames(ctx) {
+	const used = /* @__PURE__ */ new Set();
+	for (const key in ctx.rules) for (const [name, options] of Object.entries(ctx.rules[key])) if (options !== void 0 && (options !== false || !ctx.preMerge) && isRuntimeRule(name, ctx.runtimeRules)) used.add(name);
+	return [...used].sort();
+}
+export { DEFAULT_RUNTIME_RULES, compileFindRouteRules, compileHandlersImport, compileRouteRules };

package/dist/rules/index.d.mts

@@ -0,0 +1,77 @@
+import { BuiltinRouteRules, CacheRuleOptions, EventHandler, H3Event, HTTPStatus, MatchResult, MatchedRouteRule, MatchedRouteRules, Middleware, NormalizedRouteRules, ProxyRuleOptions, RedirectRuleOptions, ResolvedRouteRules, RouteRuleConfig, RouteRules, RuleHandler, RuleHandlers } from "../h3.mjs";
+import { FindRouteRules, MatcherMemoizeOptions, RouteRuleEntry, RouteRuleLayer, RouteRulesMatcher, RouteRulesMatcherOptions, createMatcherFromFind, createRouteRulesMatcher, memoizeRouteRulesMatcher, mergeMatchedRouteRules } from "../match.mjs";
+
+interface RouteRulesOptions extends RouteRulesMatcherOptions {
+  /**
+   * Memoize matches by method and pathname. Enabled by default with a 1024-entry
+   * cap; shared results must be treated as read-only.
+   * @default true
+   */
+  memoize?: boolean | MatcherMemoizeOptions;
+}
+/**
+ * Match route rules, expose merged options on `event.context.routeRules`, and
+ * run their middleware before the route handler.
+ *
+ * Results are memoized and shared by default; treat exposed rule options as
+ * read-only or disable memoization.
+ */
+export declare function routeRules(config: Record<string, RouteRuleConfig>, opts?: RouteRulesOptions): Middleware;
+/**
+ * Normalize authored route rules by expanding shortcuts, canonicalizing keys,
+ * and validating built-in options. Custom rules pass through unchanged.
+ */
+export declare function normalizeRouteRules(config: Record<string, RouteRuleConfig>): Record<string, NormalizedRouteRules>;
+/**
+ * Default handler registry. Cache and proxy handlers are opt-in from their
+ * subpath exports; set either to `undefined` explicitly for data-only rules.
+ */
+export declare const ruleHandlers: RuleHandlers;
+export declare const headers: RuleHandler<"headers">;
+export declare const redirect: RuleHandler<"redirect">;
+export declare const cors: RuleHandler<"cors">;
+/** Wrap an event handler with an injected cache implementation. */
+type DefineCachedHandler = (handler: EventHandler, opts: CacheRuleOptions) => EventHandler;
+/** Options for {@link createCacheRuleHandler}. */
+interface CacheRuleHandlerOptions {
+  /** Creates the cached wrapper for a matched route handler. */
+  defineCachedHandler: DefineCachedHandler;
+  /**
+   * Requests the implementation never reads or writes a cache entry for.
+   * The rule continues the middleware chain for them instead of dispatching the
+   * matched route itself, so an uncacheable request reaches the rest of the app
+   * the way a CDN passes one through to its origin. Without it, *every* request
+   * to a matched route terminates the chain, whether or not it is cached.
+   */
+  shouldBypass?: (event: H3Event) => boolean;
+  /** Default options merged into every cache rule (rule options win). */
+  defaults?: CacheRuleOptions;
+  /**
+   * Stable cache-key scope. By default, a process-unique scope isolates apps
+   * but prevents persistent cache sharing across processes.
+   */
+  id?: string;
+}
+/**
+ * Create a `cache` rule handler from an injected cache wrapper.
+ *
+ * Cache keys are isolated by handler, method, and route unless `id` or an
+ * explicit cache `name` opts into sharing.
+ *
+ * Registering `routeRules()` as *route* middleware puts this rule inside the
+ * handler it dispatches; the re-entrant pass falls through (see {@link dispatching}).
+ *
+ * Register `routeRules()` after every global middleware that must run for a
+ * cached route: this handler dispatches the matched route handler itself rather
+ * than calling `next()`, so global middleware registered after `routeRules()` is
+ * skipped on *every* cacheable request to a `cache`-matched route — misses
+ * included, not only hits. Per-route middleware is unaffected (it is part of the
+ * dispatched `~composed` pair).
+ *
+ * Requests the implementation reports as uncacheable through
+ * {@link CacheRuleHandlerOptions.shouldBypass} continue down the chain instead
+ * of being dispatched from inside the rule, so which global middleware runs for
+ * a matched route can depend on the request.
+ */
+export declare function createCacheRuleHandler(opts: CacheRuleHandlerOptions): RuleHandler<"cache">;
+export { type BuiltinRouteRules, type CacheRuleHandlerOptions, type CacheRuleOptions, type DefineCachedHandler, type FindRouteRules, type HTTPStatus, type MatchResult, type MatchedRouteRule, type MatchedRouteRules, type MatcherMemoizeOptions, type NormalizedRouteRules, type ProxyRuleOptions, type RedirectRuleOptions, type ResolvedRouteRules, type RouteRuleConfig, type RouteRuleEntry, type RouteRuleLayer, type RouteRules, type RouteRulesMatcher, type RouteRulesMatcherOptions, type RouteRulesOptions, type RuleHandler, type RuleHandlers, createMatcherFromFind, createRouteRulesMatcher, memoizeRouteRulesMatcher, mergeMatchedRouteRules };

package/dist/rules/index.mjs

@@ -0,0 +1,34 @@
+import { callMiddleware } from "../middleware.mjs";
+import { isPreflightRequest } from "../cors.mjs";
+import { HTTP_METHODS, buildRouteRuleMiddleware, cors, createMatcherFromFind, createRouteRulesMatcher, headers, memoizeRouteRulesMatcher, mergeMatchedRouteRules, normalizeRouteRules, redirect, ruleHandlers } from "../normalize.mjs";
+import { createCacheRuleHandler } from "../cache2.mjs";
+function routeRules(config, opts) {
+	const memoize = opts?.memoize ?? true;
+	const matcher = createRouteRulesMatcher(normalizeRouteRules(config), opts);
+	const match = memoize ? memoizeRouteRulesMatcher(matcher, memoize === true ? void 0 : memoize) : matcher;
+	return function routeRulesMiddleware(event, next) {
+		const pathname = event.url.pathname;
+		const method = event.req.method.toUpperCase();
+		let matched = match(method, pathname);
+		if (method === "OPTIONS" && isPreflightRequest(event)) matched = liftPreflightCors(matched, match, event, pathname);
+		const { routeRules, routeRuleMiddleware } = matched;
+		const prev = event.context.routeRules;
+		event.context.routeRules = prev ? Object.assign(Object.create(null), prev, routeRules) : routeRules;
+		return routeRuleMiddleware.length > 0 ? callMiddleware(event, routeRuleMiddleware, () => next()) : next();
+	};
+}
+function liftPreflightCors(matched, match, event, pathname) {
+	const requested = event.req.headers.get("access-control-request-method");
+	if (!requested) return matched;
+	const method = requested.toUpperCase();
+	if (method === "OPTIONS" || !HTTP_METHODS.has(method)) return matched;
+	const cors = match(method, pathname).matchedRules.cors;
+	if (!cors || cors === matched.matchedRules.cors) return matched;
+	const matchedRules = Object.assign(Object.create(null), matched.matchedRules, { cors });
+	return {
+		routeRules: Object.assign(Object.create(null), matched.routeRules, { cors: cors.options }),
+		matchedRules,
+		routeRuleMiddleware: buildRouteRuleMiddleware(matchedRules)
+	};
+}
+export { cors, createCacheRuleHandler, createMatcherFromFind, createRouteRulesMatcher, headers, memoizeRouteRulesMatcher, mergeMatchedRouteRules, normalizeRouteRules, redirect, routeRules, ruleHandlers };

package/dist/rules/proxy.d.mts

@@ -0,0 +1,3 @@
+import { RuleHandler } from "../h3.mjs";
+
+export declare const proxy: RuleHandler<"proxy">;

package/dist/rules/proxy.mjs

@@ -0,0 +1,14 @@
+import { proxyRequest } from "../proxy.mjs";
+import { prepareRuleTarget } from "../_utils.mjs";
+const proxy = {
+	order: 2,
+	handler: (m) => {
+		const options = m.options;
+		const resolveTarget = prepareRuleTarget(options);
+		if (!resolveTarget) return function proxyRouteRule() {};
+		return function proxyRouteRule(event) {
+			return proxyRequest(event, resolveTarget(event), { ...options });
+		};
+	}
+};
+export { proxy };

package/dist/tracing.d.mts

@@ -0,0 +1,33 @@
+import { EventHandler, H3Event, H3Plugin } from "./h3.mjs";
+
+export interface TracingRequestEvent {
+  type: "middleware" | "route";
+  event: H3Event;
+}
+/**
+ * Options for the tracing plugin.
+ */
+export interface TracingPluginOptions {
+  /**
+   * Whether to trace middleware executions.
+   */
+  traceMiddleware?: boolean;
+  /**
+   * Whether to trace route executions.
+   */
+  traceRoutes?: boolean;
+}
+/**
+ * Enables tracing for H3 apps.
+ */
+export declare function tracingPlugin(traceOpts?: TracingPluginOptions): H3Plugin;
+/**
+ * Wraps an event handler so its execution is traced via the `h3.request`
+ * diagnostics channel with `type: "route"`. Intended to be called once per
+ * handler at initialization time (e.g. during codegen or module load), not
+ * per request.
+ *
+ * Returns the handler unchanged when `diagnostics_channel` is unavailable
+ * or the handler is already traced.
+ */
+export declare function wrapHandlerWithTracing(handler: EventHandler): EventHandler;

package/dist/tracing.mjs

@@ -0,0 +1,89 @@
+function tracingPlugin(traceOpts) {
+	return (h3) => {
+		const { tracingChannel } = globalThis.process?.getBuiltinModule?.("diagnostics_channel") ?? {};
+		if (!tracingChannel) return;
+		const requestHandlerChannel = tracingChannel("h3.request");
+		function wrapMiddleware(middleware) {
+			if (middleware.__traced__ || traceOpts?.traceMiddleware === false) return middleware;
+			const wrappedMiddleware = (...args) => {
+				return requestHandlerChannel.tracePromise(async () => middleware(...args), {
+					event: args[0],
+					type: "middleware"
+				});
+			};
+			wrappedMiddleware.__traced__ = true;
+			return wrappedMiddleware;
+		}
+		function wrapEventHandler(handler) {
+			if (handler.__traced__ || traceOpts?.traceRoutes === false) return handler;
+			const wrappedHandler = (...args) => {
+				return requestHandlerChannel.tracePromise(async () => handler(...args), {
+					event: args[0],
+					type: "route"
+				});
+			};
+			wrappedHandler.__traced__ = true;
+			return wrappedHandler;
+		}
+		h3["~middleware"] = h3["~middleware"].map((m) => wrapMiddleware(m));
+		h3["~routes"] = h3["~routes"].map((route) => {
+			return {
+				...route,
+				handler: wrapEventHandler(route.handler),
+				middleware: route.middleware ? route.middleware.map((m) => wrapMiddleware(m)) : void 0
+			};
+		});
+		if ("on" in h3 && typeof h3.on === "function") {
+			const originalOn = h3.on;
+			h3.on = (...args) => {
+				const instance = originalOn.apply(h3, args);
+				const lastRoute = instance["~routes"][instance["~routes"].length - 1];
+				if (lastRoute) {
+					lastRoute.handler = wrapEventHandler(lastRoute.handler);
+					lastRoute.middleware = lastRoute.middleware?.map((m) => wrapMiddleware(m));
+				}
+				return instance;
+			};
+		}
+		if ("use" in h3 && typeof h3.use === "function") {
+			const originalUse = h3.use;
+			h3.use = (arg1, arg2, arg3) => {
+				let route;
+				let fn;
+				let opts;
+				if (typeof arg1 === "string") {
+					route = arg1;
+					fn = arg2;
+					opts = arg3;
+					return originalUse.call(h3, route, wrapMiddleware(fn), opts);
+				}
+				fn = arg1;
+				opts = arg2;
+				return originalUse.call(h3, wrapMiddleware(fn), opts);
+			};
+		}
+		if ("mount" in h3 && typeof h3.mount === "function") {
+			const originalMount = h3.mount;
+			h3.mount = (base, input) => {
+				if ("register" in input) input.register(tracingPlugin(traceOpts));
+				return originalMount.call(h3, base, input);
+			};
+		}
+		return h3;
+	};
+}
+function wrapHandlerWithTracing(handler) {
+	const { tracingChannel } = globalThis.process?.getBuiltinModule?.("diagnostics_channel") ?? {};
+	if (!tracingChannel) return handler;
+	if (handler.__traced__) return handler;
+	const channel = tracingChannel("h3.request");
+	const wrapped = (...args) => {
+		return channel.tracePromise(async () => handler(...args), {
+			event: args[0],
+			type: "route"
+		});
+	};
+	wrapped.__traced__ = true;
+	return wrapped;
+}
+export { tracingPlugin, wrapHandlerWithTracing };

package/package.json

@@ -0,0 +1,148 @@
+{
+  "name": "@depup/h3",
+  "version": "2.0.1-depup.0",
+  "description": "Minimal H(TTP) framework built for high performance and portability. (with updated dependencies)",
+  "homepage": "https://h3.dev",
+  "license": "MIT",
+  "repository": "h3js/h3",
+  "bin": {
+    "h3": "./bin/h3.mjs"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "changes.json",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/_entries/generic.d.mts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "deno": "./dist/_entries/deno.mjs",
+      "bun": "./dist/_entries/bun.mjs",
+      "workerd": "./dist/_entries/cloudflare.mjs",
+      "browser": "./dist/_entries/service-worker.mjs",
+      "node": "./dist/_entries/node.mjs",
+      "default": "./dist/_entries/generic.mjs"
+    },
+    "./deno": "./dist/_entries/deno.mjs",
+    "./bun": "./dist/_entries/bun.mjs",
+    "./cloudflare": "./dist/_entries/cloudflare.mjs",
+    "./service-worker": "./dist/_entries/service-worker.mjs",
+    "./node": "./dist/_entries/node.mjs",
+    "./generic": "./dist/_entries/generic.mjs",
+    "./tracing": "./dist/tracing.mjs",
+    "./rules": "./dist/rules/index.mjs",
+    "./rules/cache": "./dist/rules/cache.mjs",
+    "./rules/proxy": "./dist/rules/proxy.mjs",
+    "./rules/compiler": "./dist/rules/compiler.mjs"
+  },
+  "scripts": {
+    "bench:bun": "bun run ./test/bench/bench.ts",
+    "bench:node": "node --expose-gc --allow-natives-syntax ./test/bench/bench.ts",
+    "build": "obuild",
+    "dev": "vitest",
+    "fmt": "automd && oxlint --fix . && oxfmt .",
+    "lint": "oxlint . && oxfmt --check .",
+    "play:bun": "bun ./test/fixture/bun.ts",
+    "play:node": "pnpm test/fixture/node.ts",
+    "play:plain": "pnpm test/fixture/plain.ts",
+    "play:web": "pnpm test/fixture/web.ts",
+    "release": "pnpm build && pnpm test && changelogen --release --prerelease && pnpm publish --tag latest && git push --follow-tags",
+    "test": "pnpm lint && pnpm typecheck && vitest --run --coverage",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "rou3": "^1.0.0",
+    "srvx": "^1.0.5"
+  },
+  "devDependencies": {
+    "@happy-dom/global-registrator": "^20.14.5",
+    "@mitata/counters": "^0.0.8",
+    "@types/connect": "^3.4.38",
+    "@types/express": "^5.0.6",
+    "@types/node": "^26.6.4",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@typescript/native-preview": "latest",
+    "@vitest/coverage-v8": "^5.0.3",
+    "automd": "^0.4.3",
+    "changelogen": "^0.6.2",
+    "connect": "^3.7.0",
+    "cookie-es": "^3.1.1",
+    "crossws": "^0.4.12",
+    "elysia": "^1.4.30",
+    "esbuild": "^0.28.2",
+    "express": "^5.2.1",
+    "fetchdts": "^0.2.0",
+    "get-port-please": "^3.2.0",
+    "h3": "workspace:*",
+    "h3-nightly": "latest",
+    "happy-dom": "^20.14.5",
+    "hono": "^4.13.12",
+    "magic-string": "^1.4.2",
+    "mdzilla": "^0.2.1",
+    "memoirist": "^1.2.2",
+    "mitata": "^1.0.34",
+    "obuild": "^0.4.43",
+    "ocache": "^0.3.0",
+    "oxc-parser": "^0.152.0",
+    "oxfmt": ">=0.71.0",
+    "oxlint": "^1.86.0",
+    "pkg-pr-new": "^0.0.88",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.2",
+    "vitest": "^5.0.3",
+    "zod": "^4.6.5"
+  },
+  "peerDependencies": {
+    "crossws": "^0.4.12",
+    "ocache": ">=0.3.0"
+  },
+  "peerDependenciesMeta": {
+    "crossws": {
+      "optional": true
+    },
+    "ocache": {
+      "optional": true
+    }
+  },
+  "resolutions": {
+    "h3": "link:.",
+    "h3-nightly": "latest"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": "12.3.4",
+      "onFail": "warn"
+    },
+    "runtime": {
+      "name": "node",
+      "version": "^24"
+    }
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "keywords": [
+    "h3",
+    "depup",
+    "updated-dependencies",
+    "security",
+    "latest",
+    "patched"
+  ],
+  "depup": {
+    "changes": {},
+    "depsUpdated": 0,
+    "originalPackage": "h3",
+    "originalVersion": "2.0.1",
+    "processedAt": "2026-10-03T17:22:51.553Z",
+    "smokeTest": "failed"
+  }
+}