nitro 3.0.1-alpha.2 → 3.0.260415-beta

package/dist/runtime/internal/route-rules.mjs

@@ -1,13 +1,13 @@
-import { proxyRequest, redirect as sendRedirect } from "h3";
+import { proxyRequest, redirect as sendRedirect, requireBasicAuth } from "h3";
 import { joinURL, withQuery, withoutBase } from "ufo";
 import { defineCachedHandler } from "./cache.mjs";
-// Headers route rule
+
 export const headers = ((m) => function headersRouteRule(event) {
 	for (const [key, value] of Object.entries(m.options || {})) {
 		event.res.headers.set(key, value);
 	}
 });
-// Redirect route rule
+
 export const redirect = ((m) => function redirectRouteRule(event) {
 	let target = m.options?.to;
 	if (!target) {
@@ -25,7 +25,7 @@ export const redirect = ((m) => function redirectRouteRule(event) {
 	}
 	return sendRedirect(target, m.options?.status);
 });
-// Proxy route rule
+
 export const proxy = ((m) => function proxyRouteRule(event) {
 	let target = m.options?.to;
 	if (!target) {
@@ -43,7 +43,7 @@ export const proxy = ((m) => function proxyRouteRule(event) {
 	}
 	return proxyRequest(event, target, { ...m.options });
 });
-// Cache route rule
+
 export const cache = ((m) => function cacheRouteRule(event, next) {
 	if (!event.context.matchedRoute) {
 		return next();
@@ -62,3 +62,13 @@ export const cache = ((m) => function cacheRouteRule(event, next) {
 	}
 	return cachedHandler(event);
 });
+
+
+
+export const basicAuth = /* @__PURE__ */ Object.assign(((m) => async function authRouteRule(event, next) {
+	if (!m.options) {
+		return;
+	}
+	await requireBasicAuth(event, m.options);
+	return next();
+}), { order: -1 });

package/dist/runtime/internal/routes/dev-tasks.d.mts

@@ -1,2 +1,3 @@
-declare const _default;
-export default _default;
+import { H3 } from "h3";
+declare const app: H3;
+export default app;

package/dist/runtime/internal/routes/dev-tasks.mjs

@@ -1,7 +1,19 @@
 import { H3 } from "h3";
 import { runTask } from "../task.mjs";
 import { scheduledTasks, tasks } from "#nitro/virtual/tasks";
-export default new H3().get("/_nitro/tasks", async () => {
+const taskHandler = async (event) => {
+	const name = event.context.params?.name;
+	const body = await event.req.json().catch(() => ({}));
+	const payload = {
+		...Object.fromEntries(event.url.searchParams.entries()),
+		...body.payload ?? body
+	};
+	return await runTask(name, {
+		context: { waitUntil: event.req.waitUntil },
+		payload
+	});
+};
+const app = new H3().get("/_nitro/tasks", async () => {
 	const _tasks = await Promise.all(Object.entries(tasks).map(async ([name, task]) => {
 		const _task = await task.resolve?.();
 		return [name, { description: _task?.meta?.description }];
@@ -10,12 +22,5 @@ export default new H3().get("/_nitro/tasks", async () => {
 		tasks: Object.fromEntries(_tasks),
 		scheduledTasks
 	};
-}).get("/_nitro/tasks/:name", async (event) => {
-	const name = event.context.params?.name;
-	const body = await event.req.json().catch(() => ({}));
-	const payload = {
-		...Object.fromEntries(event.url.searchParams.entries()),
-		...body
-	};
-	return await runTask(name, { payload });
-});
+}).get("/_nitro/tasks/:name", taskHandler).post("/_nitro/tasks/:name", taskHandler);
+export default app;

package/dist/runtime/internal/routes/openapi.mjs

@@ -3,7 +3,7 @@ import { joinURL } from "ufo";
 import { defu } from "defu";
 import { handlersMeta } from "#nitro/virtual/routing-meta";
 import { useRuntimeConfig } from "../runtime-config.mjs";
-// Served as /_openapi.json
+
 export default defineHandler((event) => {
 	const runtimeConfig = useRuntimeConfig();
 	const base = runtimeConfig.app?.baseURL;
@@ -46,7 +46,7 @@ function getHandlersMeta() {
 			...openAPI
 		} };
 		if ($global) {
-			// TODO: Warn on conflicting global definitions?
+			
 			globals = defu($global, globals);
 		}
 		if (paths[route] === undefined) {

package/dist/runtime/internal/routes/renderer-template.d.mts

@@ -1,2 +1,2 @@
 import type { H3Event } from "h3";
-export default function renderIndexHTML(event: H3Event);
+export default function renderIndexHTML(event: H3Event): any;

package/dist/runtime/internal/routes/renderer-template.dev.d.mts

@@ -1,2 +1,3 @@
 import type { H3Event } from "h3";
-export default function renderIndexHTML(event: H3Event);
+import { HTTPResponse } from "h3";
+export default function renderIndexHTML(event: H3Event): Promise<HTTPResponse | Response>;

package/dist/runtime/internal/routes/scalar.mjs

@@ -1,12 +1,12 @@
 import { defineHandler } from "h3";
 import { useRuntimeConfig } from "../runtime-config.mjs";
-// Served as /_scalar
+
 export default defineHandler((event) => {
 	const runtimeConfig = useRuntimeConfig();
 	const title = runtimeConfig.nitro?.openAPI?.meta?.title || "API Reference";
 	const description = runtimeConfig.nitro?.openAPI?.meta?.description || "";
 	const openAPIEndpoint = runtimeConfig.nitro?.openAPI?.route || "./_openapi.json";
-	// https://github.com/scalar/scalar
+	
 	const _config = runtimeConfig.nitro?.openAPI?.ui?.scalar;
 	const scalarConfig = {
 		..._config,
@@ -16,7 +16,7 @@ export default defineHandler((event) => {
 			..._config?.spec
 		}
 	};
-	// The default page title
+	
 	event.res.headers.set("Content-Type", "text/html");
 	return `<!doctype html>
     <html lang="en">

package/dist/runtime/internal/routes/swagger.mjs

@@ -1,11 +1,13 @@
 import { defineHandler } from "h3";
 import { useRuntimeConfig } from "../runtime-config.mjs";
-// https://github.com/swagger-api/swagger-ui
+
 export default defineHandler((event) => {
 	const runtimeConfig = useRuntimeConfig();
 	const title = runtimeConfig.nitro?.openAPI?.meta?.title || "API Reference";
 	const description = runtimeConfig.nitro?.openAPI?.meta?.description || "";
 	const openAPIEndpoint = runtimeConfig.nitro?.openAPI?.route || "./_openapi.json";
+	const { route: _route, ...swaggerConfig } = runtimeConfig.nitro?.openAPI?.ui?.swagger || {};
+	const safeSwaggerConfig = JSON.stringify(swaggerConfig).replace(/<\//g, "<\\/");
 	const CDN_BASE = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@^5";
 	event.res.headers.set("Content-Type", "text/html");
 	return `<!doctype html>
@@ -27,13 +29,14 @@ export default defineHandler((event) => {
         <script>
           window.onload = () => {
             window.ui = SwaggerUIBundle({
-              url: ${JSON.stringify(openAPIEndpoint)},
-              dom_id: "#swagger-ui",
               presets: [
                 SwaggerUIBundle.presets.apis,
                 SwaggerUIStandalonePreset,
               ],
-              layout2: "StandaloneLayout",
+              layout: "StandaloneLayout",
+              ...${safeSwaggerConfig},
+              url: ${JSON.stringify(openAPIEndpoint)},
+              dom_id: "#swagger-ui",
             });
           };
         <\/script>

package/dist/runtime/internal/runtime-config.d.mts

@@ -5,5 +5,5 @@ type EnvOptions = {
 	altPrefix?: string;
 	envExpansion?: boolean;
 };
-export declare function applyEnv(obj: Record<string, any>, opts: EnvOptions, parentKey?: string);
+export declare function applyEnv(obj: Record<string, any>, opts: EnvOptions, parentKey?: string): Record<string, any>;
 export {};

package/dist/runtime/internal/runtime-config.mjs

@@ -17,7 +17,7 @@ export function applyEnv(obj, opts, parentKey = "") {
 		const subKey = parentKey ? `${parentKey}_${key}` : key;
 		const envValue = getEnv(subKey, opts);
 		if (_isObject(obj[key])) {
-			// Same as before
+			
 			if (_isObject(envValue)) {
 				obj[key] = {
 					...obj[key],
@@ -32,7 +32,7 @@ export function applyEnv(obj, opts, parentKey = "") {
 		} else {
 			obj[key] = envValue ?? obj[key];
 		}
-		// Experimental env expansion
+		
 		if (opts.envExpansion && typeof obj[key] === "string") {
 			obj[key] = _expandFromEnv(obj[key]);
 		}

package/dist/runtime/internal/static.mjs

@@ -4,7 +4,8 @@ import { getAsset, isPublicAssetURL, readAsset } from "#nitro/virtual/public-ass
 const METHODS = new Set(["HEAD", "GET"]);
 const EncodingMap = {
 	gzip: ".gz",
-	br: ".br"
+	br: ".br",
+	zstd: ".zst"
 };
 export default defineHandler((event) => {
 	if (event.req.method && !METHODS.has(event.req.method)) {
@@ -14,9 +15,6 @@ export default defineHandler((event) => {
 	let asset;
 	const encodingHeader = event.req.headers.get("accept-encoding") || "";
 	const encodings = [...encodingHeader.split(",").map((e) => EncodingMap[e.trim()]).filter(Boolean).sort(), ""];
-	if (encodings.length > 1) {
-		event.res.headers.append("Vary", "Accept-Encoding");
-	}
 	for (const encoding of encodings) {
 		for (const _id of [id + encoding, joinURL(id, "index.html" + encoding)]) {
 			const _asset = getAsset(_id);
@@ -34,6 +32,9 @@ export default defineHandler((event) => {
 		}
 		return;
 	}
+	if (encodings.length > 1) {
+		event.res.headers.append("Vary", "Accept-Encoding");
+	}
 	const ifNotMatch = event.req.headers.get("if-none-match") === asset.etag;
 	if (ifNotMatch) {
 		event.res.status = 304;

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

@@ -7,7 +7,9 @@ export declare function runTask<RT = unknown>(name: string, { payload, context }
 	context?: TaskContext;
 }): Promise<TaskResult<RT>>;
 /** @experimental */
-export declare function startScheduleRunner();
+export declare function startScheduleRunner({ waitUntil }?: {
+	waitUntil?: ((promise: Promise<unknown>) => void) | undefined;
+}): void;
 /** @experimental */
 export declare function getCronTasks(cron: string): string[];
 /** @experimental */

package/dist/runtime/internal/task.mjs

@@ -1,7 +1,7 @@
 import { Cron } from "croner";
 import { HTTPError } from "h3";
 import { scheduledTasks, tasks } from "#nitro/virtual/tasks";
-/** @experimental */
+
 export function defineTask(def) {
 	if (typeof def.run !== "function") {
 		def.run = () => {
@@ -11,7 +11,7 @@ export function defineTask(def) {
 	return def;
 }
 const __runningTasks__ = {};
-/** @experimental */
+
 export async function runTask(name, { payload = {}, context = {} } = {}) {
 	if (__runningTasks__[name]) {
 		return __runningTasks__[name];
@@ -42,8 +42,8 @@ export async function runTask(name, { payload = {}, context = {} } = {}) {
 		delete __runningTasks__[name];
 	}
 }
-/** @experimental */
-export function startScheduleRunner() {
+
+export function startScheduleRunner({ waitUntil } = {}) {
 	if (!scheduledTasks || scheduledTasks.length === 0 || process.env.TEST) {
 		return;
 	}
@@ -52,18 +52,18 @@ export function startScheduleRunner() {
 		new Cron(schedule.cron, async () => {
 			await Promise.all(schedule.tasks.map((name) => runTask(name, {
 				payload,
-				context: {}
+				context: { waitUntil }
 			}).catch((error) => {
 				console.error(`Error while running scheduled task "${name}"`, error);
 			})));
 		});
 	}
 }
-/** @experimental */
+
 export function getCronTasks(cron) {
 	return (scheduledTasks || []).find((task) => task.cron === cron)?.tasks || [];
 }
-/** @experimental */
+
 export function runCronTasks(cron, ctx) {
 	return Promise.all(getCronTasks(cron).map((name) => runTask(name, ctx)));
 }

package/dist/runtime/internal/vite/dev-entry.mjs

@@ -3,13 +3,16 @@ import wsAdapter from "crossws/adapters/node";
 
 import { useNitroApp } from "nitro/app";
 import { resolveWebsocketHooks } from "#nitro/runtime/app";
+import { startScheduleRunner } from "#nitro/runtime/task";
 
 const nitroApp = useNitroApp();
 
 export const fetch = nitroApp.fetch;
 
-const ws = import.meta._websocket
-  ? wsAdapter({ resolve: resolveWebsocketHooks })
-  : undefined;
+const ws = import.meta._websocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
+
+if (import.meta._tasks) {
+  startScheduleRunner({});
+}
 
 export const handleUpgrade = ws?.handleUpgrade;

package/dist/runtime/internal/vite/dev-worker.mjs

@@ -0,0 +1,264 @@
+import { ModuleRunner, ESModulesEvaluator } from "vite/module-runner";
+import { createViteTransport } from "env-runner/vite";
+
+// Custom evaluator for workerd where `new AsyncFunction()` is disallowed.
+// Uses the unsafeEvalBinding exposed by the env-runner miniflare wrapper.
+class WorkerdModuleEvaluator {
+  startOffset = 0;
+
+  async runInlinedModule(context, code) {
+    const unsafeEval = globalThis.__ENV_RUNNER_UNSAFE_EVAL__;
+    const keys = Object.keys(context);
+    const fn = unsafeEval.newAsyncFunction('"use strict";' + code, "runInlinedModule", ...keys);
+    await fn(...keys.map((k) => context[k]));
+    Object.seal(context[Object.keys(context)[0]]);
+  }
+
+  runExternalModule(filepath) {
+    return import(filepath);
+  }
+}
+
+// ----- IPC -----
+
+let sendMessage;
+const messageListeners = new Set();
+
+// ----- Environment runners -----
+
+const envs = (globalThis.__nitro_vite_envs__ ??= {
+  nitro: undefined,
+  ssr: undefined,
+});
+
+class ViteEnvRunner {
+  constructor({ name, entry }) {
+    this.name = name;
+    this.entryPath = entry;
+
+    this.entry = undefined;
+    this.entryError = undefined;
+
+    // Create Vite Module Runner
+    // https://vite.dev/guide/api-environment-runtimes.html#modulerunner
+    const onMessage = (listener) => messageListeners.add(listener);
+    const transport = createViteTransport((data) => sendMessage?.(data), onMessage, name);
+    const evaluator = globalThis.__ENV_RUNNER_UNSAFE_EVAL__
+      ? new WorkerdModuleEvaluator()
+      : new ESModulesEvaluator();
+    const debug =
+      typeof process !== "undefined" && process.env?.NITRO_DEBUG ? console.debug : undefined;
+    this.runner = new ModuleRunner({ transport }, evaluator, debug);
+
+    this.reload();
+  }
+
+  async reload() {
+    try {
+      this.entry = await this.runner.import(this.entryPath);
+      this.entryError = undefined;
+    } catch (error) {
+      console.error(error);
+      this.entryError = error;
+    }
+  }
+
+  async fetch(req, init) {
+    if (this.entryError) {
+      return renderError(req, this.entryError);
+    }
+    for (let i = 0; i < 5 && !(this.entry || this.entryError); i++) {
+      await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
+    }
+    if (this.entryError) {
+      return renderError(req, this.entryError);
+    }
+    if (!this.entry) {
+      throw httpError(503, `Vite environment "${this.name}" is unavailable`);
+    }
+    try {
+      const entryFetch = this.entry.fetch || this.entry.default?.fetch;
+      if (!entryFetch) {
+        throw httpError(500, `No fetch handler exported from ${this.entryPath}`);
+      }
+      return await entryFetch(req, init);
+    } catch (error) {
+      return renderError(req, error);
+    }
+  }
+}
+
+// ----- RPC -----
+
+const rpcRequests = new Map();
+
+function rpc(name, data, timeout = 3000) {
+  const id = Math.random().toString(36).slice(2);
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      rpcRequests.delete(id);
+      reject(new Error(`RPC "${name}" timed out`));
+    }, timeout);
+    rpcRequests.set(id, { resolve, reject, timer });
+    sendMessage?.({ __rpc: name, __rpc_id: id, data });
+  });
+}
+
+// Trap unhandled errors to avoid worker crash
+if (typeof process !== "undefined" && typeof process.on === "function") {
+  process.on("unhandledRejection", (error) => console.error(error));
+  process.on("uncaughtException", (error) => console.error(error));
+}
+
+// ----- RSC Support -----
+
+// define __VITE_ENVIRONMENT_RUNNER_IMPORT__ for RSC support
+// https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-rsc/README.md#__vite_environment_runner_import__
+
+globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__ = async function (environmentName, id) {
+  const env = envs[environmentName];
+  if (!env) {
+    throw new Error(`Vite environment "${environmentName}" is not registered`);
+  }
+  return env.runner.import(id);
+};
+
+// ----- Reload -----
+
+async function reload() {
+  try {
+    await Promise.all(Object.values(envs).map((env) => env?.reload()));
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+// eslint-disable-next-line unicorn/prefer-top-level-await
+reload();
+
+// ----- HTML Transform -----
+
+globalThis.__transform_html__ = async function (html) {
+  html = await rpc("transformHTML", html).catch((error) => {
+    console.warn("Failed to transform HTML via Vite:", error);
+    return html;
+  });
+  return html;
+};
+
+// ----- Exports (env-runner AppEntry) -----
+
+export function fetch(req) {
+  const viteEnv = req?.headers.get("x-vite-env") || "nitro";
+  const env = envs[viteEnv];
+  if (!env) {
+    return renderError(req, httpError(500, `Unknown vite environment "${viteEnv}"`));
+  }
+  return env.fetch(req);
+}
+
+export function upgrade(context) {
+  const handleUpgrade = envs.nitro?.entry?.handleUpgrade;
+  if (handleUpgrade) {
+    handleUpgrade(context.node.req, context.node.socket, context.node.head);
+  }
+}
+
+export const ipc = {
+  onOpen(ctx) {
+    sendMessage = ctx.sendMessage;
+  },
+  onMessage(message) {
+    if (message?.__rpc_id) {
+      const req = rpcRequests.get(message.__rpc_id);
+      if (req) {
+        clearTimeout(req.timer);
+        rpcRequests.delete(message.__rpc_id);
+        if (message.error) {
+          req.reject(typeof message.error === "string" ? new Error(message.error) : message.error);
+        } else {
+          req.resolve(message.data);
+        }
+      }
+      return;
+    }
+    if (message?.type === "custom") {
+      if (message.event === "nitro:vite-env") {
+        const { name, entry } = message.data;
+        if (!envs[name]) {
+          envs[name] = new ViteEnvRunner({ name, entry });
+        }
+        return;
+      }
+    }
+    if (message?.type === "full-reload") {
+      reload();
+      return;
+    }
+    for (const listener of messageListeners) {
+      listener(message);
+    }
+  },
+  onClose() {},
+};
+
+// ----- Error handling -----
+
+function httpError(status, message) {
+  const error = new Error(message || `HTTP Error ${status}`);
+  error.status = status;
+  error.name = "NitroViteError";
+  return error;
+}
+
+async function renderError(req, error) {
+  if (req.headers.get("accept")?.includes("application/json")) {
+    return new Response(
+      JSON.stringify(
+        {
+          status: error.status || 500,
+          name: error.name || "Error",
+          message: error.message,
+          stack: (error.stack || "")
+            .split("\n")
+            .splice(1)
+            .map((l) => l.trim()),
+        },
+        null,
+        2
+      ),
+      {
+        status: error.status || 500,
+        headers: {
+          "Content-Type": "application/json",
+          "Cache-Control": "no-store, max-age=0, must-revalidate",
+          Pragma: "no-cache",
+          Expires: "0",
+        },
+      }
+    );
+  }
+  try {
+    const { Youch } = await import("youch");
+    const youch = new Youch();
+    return new Response(await youch.toHTML(error), {
+      status: error.status || 500,
+      headers: {
+        "Content-Type": "text/html",
+        "Cache-Control": "no-store, max-age=0, must-revalidate",
+        Pragma: "no-cache",
+        Expires: "0",
+      },
+    });
+  } catch {
+    return new Response(`<pre>${error.stack || error.message || error}</pre>`, {
+      status: error.status || 500,
+      headers: {
+        "Content-Type": "text/html",
+        "Cache-Control": "no-store, max-age=0, must-revalidate",
+        Pragma: "no-cache",
+        Expires: "0",
+      },
+    });
+  }
+}

package/dist/runtime/meta.d.mts

@@ -2,4 +2,5 @@ export declare const version: string;
 export declare const runtimeDir: string;
 export declare const presetsDir: string;
 export declare const pkgDir: string;
+export declare const docsDir: string | undefined;
 export declare const runtimeDependencies: string[];

package/dist/runtime/meta.mjs

@@ -5,6 +5,7 @@ const resolve = (path) => fileURLToPath(new URL(path, import.meta.url));
 export const runtimeDir = /* @__PURE__ */ resolve("./");
 export const presetsDir = /* @__PURE__ */ resolve("../presets/");
 export const pkgDir = /* @__PURE__ */ resolve("../../");
+export const docsDir = /* @__PURE__ */ resolve("../docs");
 export const runtimeDependencies = [
 	"crossws",
 	"croner",
@@ -15,6 +16,7 @@ export const runtimeDependencies = [
 	"rou3",
 	"hookable",
 	"ofetch",
+	"ocache",
 	"ohash",
 	"rendu",
 	"scule",

package/dist/runtime/nitro.d.mts

@@ -5,5 +5,7 @@ export declare function defineConfig(config: Omit<NitroConfig, "rootDir">): Omit
 export { defineNitroPlugin as definePlugin } from "./internal/plugin.mjs";
 export { defineRouteMeta } from "./internal/meta.mjs";
 export { defineNitroErrorHandler as defineErrorHandler } from "./internal/error/utils.mjs";
+export { defineHandler, defineMiddleware, defineWebSocketHandler, html, HTTPError, HTTPResponse } from "h3";
+export type { H3Event } from "h3";
 export declare function serverFetch(resource: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext): Promise<Response>;
 export declare function fetch(resource: string | URL | Request, init?: RequestInit, context?: ServerRequestContext | H3EventContext): Promise<Response>;

package/dist/runtime/nitro.mjs

@@ -2,11 +2,13 @@ import { toRequest } from "h3";
 export function defineConfig(config) {
 	return config;
 }
-// Type (only) helpers
+
 export { defineNitroPlugin as definePlugin } from "./internal/plugin.mjs";
 export { defineRouteMeta } from "./internal/meta.mjs";
 export { defineNitroErrorHandler as defineErrorHandler } from "./internal/error/utils.mjs";
-// Runtime
+
+export { defineHandler, defineMiddleware, defineWebSocketHandler, html, HTTPError, HTTPResponse } from "h3";
+
 export function serverFetch(resource, init, context) {
 	const nitro = globalThis.__nitro__?.default || globalThis.__nitro__?.prerender || globalThis.__nitro_builder__;
 	if (!nitro) {

package/dist/runtime/virtual/error-handler.mjs

@@ -1,5 +1,5 @@
 import "./_runtime_warn.mjs";
-import { toResponse } from "h3";
+import { H3Event, toResponse } from "h3";
 const errorHandler = (error, event) => {
 	if (error.status !== 404) {
 		console.error(error);

package/dist/runtime/virtual/renderer-template.mjs

@@ -2,6 +2,6 @@ import "./_runtime_warn.mjs";
 export function rendererTemplate(_req) {
 	return `<!-- Renderer template not available -->`;
 }
-// dev only
+
 export const rendererTemplateFile = undefined;
 export const isStaticTemplate = undefined;

package/dist/runtime/virtual/server-assets.d.mts

@@ -1,6 +1,7 @@
 import "./_runtime_warn.mjs";
+import { type Storage } from "unstorage";
 import type { AssetMeta } from "nitro/types";
-export declare const assets: unknown;
+export declare const assets: Storage;
 export declare function readAsset<T = any>(_id: string): Promise<T>;
 export declare function statAsset(_id: string): Promise<AssetMeta>;
 export declare function getKeys(): Promise<string[]>;

package/dist/runtime/virtual/tracing.d.mts

@@ -0,0 +1,5 @@
+import "./_runtime_warn.mjs";
+import type { NitroAppPlugin } from "nitro/types";
+declare const plugin: NitroAppPlugin;
+export default plugin;
+export declare const tracingSrvxPlugins: Array<() => any>;

package/dist/runtime/virtual/tracing.mjs

@@ -0,0 +1 @@
+import "./_runtime_warn.mjs";