@sentry/nuxt 10.44.0 → 10.46.0

package/build/module/runtime/plugins/storage.server.js

@@ -1,171 +1,6 @@
-import {
-  captureException,
-  debug,
-  flushIfServerless,
-  SEMANTIC_ATTRIBUTE_CACHE_HIT,
-  SEMANTIC_ATTRIBUTE_CACHE_KEY,
-  SEMANTIC_ATTRIBUTE_SENTRY_OP,
-  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
-  SPAN_STATUS_ERROR,
-  SPAN_STATUS_OK,
-  startSpan
-} from "@sentry/core";
-import { useStorage } from "nitropack/runtime";
+import { useStorage } from "nitro/storage";
 import { userStorageMounts } from "#sentry/storage-config.mjs";
-const CACHE_HIT_METHODS = /* @__PURE__ */ new Set(["hasItem", "getItem", "getItemRaw"]);
+import { createStoragePlugin } from "../utils/instrumentStorage.js";
 export default async (_nitroApp) => {
-  const storage = useStorage();
-  const userMounts = new Set(userStorageMounts.map((m) => `${m}:`));
-  debug.log("[storage] Starting to instrument storage drivers...");
-  userMounts.add("cache:");
-  userMounts.add("");
-  const mounts = storage.getMounts();
-  for (const mount of mounts) {
-    if (!userMounts.has(mount.base)) {
-      continue;
-    }
-    instrumentDriver(mount.driver, mount.base);
-  }
-  storage.mount = wrapStorageMount(storage);
+  await createStoragePlugin(useStorage, userStorageMounts);
 };
-function instrumentDriver(driver, mountBase) {
-  if (driver.__sentry_instrumented__) {
-    debug.log(`[storage] Driver already instrumented: "${driver.name}". Skipping...`);
-    return driver;
-  }
-  debug.log(`[storage] Instrumenting driver: "${driver.name}" on mount: "${mountBase}"`);
-  const methodsToInstrument = [
-    "hasItem",
-    "getItem",
-    "getItemRaw",
-    "getItems",
-    "setItem",
-    "setItemRaw",
-    "setItems",
-    "removeItem",
-    "getKeys",
-    "clear"
-  ];
-  for (const methodName of methodsToInstrument) {
-    const original = driver[methodName];
-    if (typeof original !== "function") {
-      continue;
-    }
-    driver[methodName] = createMethodWrapper(original, methodName, driver, mountBase);
-  }
-  driver.__sentry_instrumented__ = true;
-  return driver;
-}
-function createMethodWrapper(original, methodName, driver, mountBase) {
-  return new Proxy(original, {
-    async apply(target, thisArg, args) {
-      const options = createSpanStartOptions(methodName, driver, mountBase, args);
-      debug.log(`[storage] Running method: "${methodName}" on driver: "${driver.name ?? "unknown"}"`);
-      return startSpan(options, async (span) => {
-        try {
-          const result = await target.apply(thisArg, args);
-          span.setStatus({ code: SPAN_STATUS_OK });
-          if (CACHE_HIT_METHODS.has(methodName)) {
-            span.setAttribute(SEMANTIC_ATTRIBUTE_CACHE_HIT, isCacheHit(args[0], result));
-          }
-          return result;
-        } catch (error) {
-          span.setStatus({ code: SPAN_STATUS_ERROR, message: "internal_error" });
-          captureException(error, {
-            mechanism: {
-              handled: false,
-              type: options.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]
-            }
-          });
-          throw error;
-        } finally {
-          await flushIfServerless();
-        }
-      });
-    }
-  });
-}
-function wrapStorageMount(storage) {
-  const original = storage.mount;
-  if (original.__sentry_instrumented__) {
-    return original;
-  }
-  function mountWithInstrumentation(base, driver) {
-    debug.log(`[storage] Instrumenting mount: "${base}"`);
-    const instrumentedDriver = instrumentDriver(driver, base);
-    return original(base, instrumentedDriver);
-  }
-  mountWithInstrumentation.__sentry_instrumented__ = true;
-  return mountWithInstrumentation;
-}
-function normalizeMethodName(methodName) {
-  return methodName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-function isEmptyValue(value) {
-  return value === null || value === void 0;
-}
-function createSpanStartOptions(methodName, driver, mountBase, args) {
-  const keys = getCacheKeys(args?.[0], mountBase);
-  const attributes = {
-    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `cache.${normalizeMethodName(methodName)}`,
-    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.cache.nuxt",
-    [SEMANTIC_ATTRIBUTE_CACHE_KEY]: keys.length > 1 ? keys : keys[0],
-    "db.operation.name": methodName,
-    "db.collection.name": mountBase.replace(/:$/, ""),
-    "db.system.name": driver.name ?? "unknown"
-  };
-  return {
-    name: keys.join(", "),
-    attributes
-  };
-}
-function getCacheKeys(key, prefix) {
-  if (Array.isArray(key)) {
-    return key.map((k) => normalizeKey(k, prefix));
-  }
-  return [normalizeKey(key, prefix)];
-}
-function normalizeKey(key, prefix) {
-  if (typeof key === "string") {
-    return `${prefix}${key}`;
-  }
-  if (typeof key === "object" && key !== null && "key" in key) {
-    return `${prefix}${key.key}`;
-  }
-  return `${prefix}${isEmptyValue(key) ? "" : String(key)}`;
-}
-const CACHED_FN_HANDLERS_RE = /^nitro:(functions|handlers):/i;
-function isCacheHit(key, value) {
-  try {
-    const isEmpty = isEmptyValue(value);
-    if (isEmpty || !CACHED_FN_HANDLERS_RE.test(key)) {
-      return !isEmpty;
-    }
-    return validateCacheEntry(key, JSON.parse(String(value)));
-  } catch {
-    return false;
-  }
-}
-function validateCacheEntry(key, entry) {
-  if (isEmptyValue(entry.value)) {
-    return false;
-  }
-  if (Date.now() > (entry.expires || 0)) {
-    return false;
-  }
-  if (isResponseCacheEntry(key, entry)) {
-    if (entry.value.status >= 400) {
-      return false;
-    }
-    if (entry.value.body === void 0) {
-      return false;
-    }
-    if (entry.value.headers.etag === "undefined" || entry.value.headers["last-modified"] === "undefined") {
-      return false;
-    }
-  }
-  return true;
-}
-function isResponseCacheEntry(key, _) {
-  return key.startsWith("nitro:handlers:");
-}

package/build/module/runtime/utils/database-span-data.d.ts

@@ -1,8 +1,22 @@
-import type { DatabaseConnectionConfig as DatabaseConfig } from 'nitropack/types';
+import type { ConnectorName } from 'db0';
 export interface DatabaseSpanData {
     [key: string]: string | number | undefined;
 }
+/**
+ * A minimal database connection configuration type compatible with both nitropack (Nitro v2) and nitro (Nitro v3+).
+ * Mirrors the shape of `DatabaseConnectionConfig` from both packages.
+ */
+export interface DatabaseConnectionConfig {
+    connector?: ConnectorName;
+    options?: {
+        host?: string;
+        port?: number;
+        dataDir?: string;
+        name?: string;
+        [key: string]: unknown;
+    };
+}
 /**
  * Extracts span attributes from the database configuration.
  */
-export declare function getDatabaseSpanData(config?: DatabaseConfig): Partial<DatabaseSpanData>;
+export declare function getDatabaseSpanData(config?: DatabaseConnectionConfig): Partial<DatabaseSpanData>;

package/build/module/runtime/utils/instrumentDatabase.d.ts

@@ -0,0 +1,9 @@
+import type { Database } from 'db0';
+import { type DatabaseConnectionConfig } from './database-span-data.js';
+/**
+ * Creates the Nitro database plugin setup by instrumenting the configured database instances.
+ *
+ * Called from the version-specific plugin entry points (database.server.ts / database-legacy.server.ts)
+ * which supply the correct `useDatabase` import for their respective Nitro version.
+ */
+export declare function createDatabasePlugin(useDatabase: (name: string) => Database, databaseConfig: Record<string, DatabaseConnectionConfig>): void;

package/build/module/runtime/utils/instrumentDatabase.js

@@ -0,0 +1,147 @@
+import {
+  addBreadcrumb,
+  captureException,
+  debug,
+  flushIfServerless,
+  SEMANTIC_ATTRIBUTE_SENTRY_OP,
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  SPAN_STATUS_ERROR,
+  startSpan
+} from "@sentry/core";
+import { getDatabaseSpanData } from "./database-span-data.js";
+const patchedStatement = /* @__PURE__ */ new WeakSet();
+const SENTRY_ORIGIN = "auto.db.nuxt";
+export function createDatabasePlugin(useDatabase, databaseConfig) {
+  try {
+    const databaseInstances = Object.keys(databaseConfig);
+    debug.log("[Nitro Database Plugin]: Instrumenting databases...");
+    for (const instance of databaseInstances) {
+      debug.log("[Nitro Database Plugin]: Instrumenting database instance:", instance);
+      const db = useDatabase(instance);
+      instrumentDatabase(db, databaseConfig[instance]);
+    }
+    debug.log("[Nitro Database Plugin]: Databases instrumented.");
+  } catch (error) {
+    if (error instanceof Error && /Cannot access 'instances'/.test(error.message)) {
+      debug.log("[Nitro Database Plugin]: Database instrumentation skipped during build time.");
+      return;
+    }
+    debug.error("[Nitro Database Plugin]: Failed to instrument database:", error);
+  }
+}
+function instrumentDatabase(db, config) {
+  if (db.__sentry_instrumented__) {
+    debug.log("[Nitro Database Plugin]: Database already instrumented. Skipping...");
+    return;
+  }
+  const metadata = {
+    "db.system.name": config?.connector ?? db.dialect,
+    ...getDatabaseSpanData(config)
+  };
+  db.prepare = new Proxy(db.prepare, {
+    apply(target, thisArg, args) {
+      const [query] = args;
+      return instrumentPreparedStatement(target.apply(thisArg, args), query, metadata);
+    }
+  });
+  db.sql = new Proxy(db.sql, {
+    apply(target, thisArg, args) {
+      const query = args[0]?.[0] ?? "";
+      const opts = createStartSpanOptions(query, metadata);
+      return startSpan(
+        opts,
+        handleSpanStart(() => target.apply(thisArg, args))
+      );
+    }
+  });
+  db.exec = new Proxy(db.exec, {
+    apply(target, thisArg, args) {
+      return startSpan(
+        createStartSpanOptions(args[0], metadata),
+        handleSpanStart(() => target.apply(thisArg, args), { query: args[0] })
+      );
+    }
+  });
+  db.__sentry_instrumented__ = true;
+}
+function instrumentPreparedStatement(statement, query, data) {
+  statement.bind = new Proxy(statement.bind, {
+    apply(target, thisArg, args) {
+      return instrumentPreparedStatementQueries(target.apply(thisArg, args), query, data);
+    }
+  });
+  return instrumentPreparedStatementQueries(statement, query, data);
+}
+function instrumentPreparedStatementQueries(statement, query, data) {
+  if (patchedStatement.has(statement)) {
+    return statement;
+  }
+  statement.get = new Proxy(statement.get, {
+    apply(target, thisArg, args) {
+      return startSpan(
+        createStartSpanOptions(query, data),
+        handleSpanStart(() => target.apply(thisArg, args), { query })
+      );
+    }
+  });
+  statement.run = new Proxy(statement.run, {
+    apply(target, thisArg, args) {
+      return startSpan(
+        createStartSpanOptions(query, data),
+        handleSpanStart(() => target.apply(thisArg, args), { query })
+      );
+    }
+  });
+  statement.all = new Proxy(statement.all, {
+    apply(target, thisArg, args) {
+      return startSpan(
+        createStartSpanOptions(query, data),
+        handleSpanStart(() => target.apply(thisArg, args), { query })
+      );
+    }
+  });
+  patchedStatement.add(statement);
+  return statement;
+}
+function handleSpanStart(fn, breadcrumbOpts) {
+  return async (span) => {
+    try {
+      const result = await fn();
+      if (breadcrumbOpts) {
+        createBreadcrumb(breadcrumbOpts.query);
+      }
+      return result;
+    } catch (error) {
+      span.setStatus({ code: SPAN_STATUS_ERROR, message: "internal_error" });
+      captureException(error, {
+        mechanism: {
+          handled: false,
+          type: SENTRY_ORIGIN
+        }
+      });
+      throw error;
+    } finally {
+      await flushIfServerless();
+    }
+  };
+}
+function createBreadcrumb(query) {
+  addBreadcrumb({
+    category: "query",
+    message: query,
+    data: {
+      "db.query.text": query
+    }
+  });
+}
+function createStartSpanOptions(query, data) {
+  return {
+    name: query,
+    attributes: {
+      "db.query.text": query,
+      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: SENTRY_ORIGIN,
+      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: "db.query",
+      ...data
+    }
+  };
+}

package/build/module/runtime/utils/instrumentStorage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates the Nitro storage plugin setup by instrumenting all relevant storage drivers.
+ *
+ * The `useStorage` parameter is typed as `() => unknown` because nitropack (Nitro v2) and nitro (Nitro v3+) define `StorageValue` differently.
+ * Cast to `NitroStorage` is safe since all Nitro versions expose `getMounts()` at runtime.
+ */
+export declare function createStoragePlugin(useStorage: () => unknown, userStorageMounts: string[]): Promise<void>;

package/build/module/runtime/utils/instrumentStorage.js

@@ -0,0 +1,169 @@
+import {
+  captureException,
+  debug,
+  flushIfServerless,
+  SEMANTIC_ATTRIBUTE_CACHE_HIT,
+  SEMANTIC_ATTRIBUTE_CACHE_KEY,
+  SEMANTIC_ATTRIBUTE_SENTRY_OP,
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  SPAN_STATUS_ERROR,
+  SPAN_STATUS_OK,
+  startSpan
+} from "@sentry/core";
+const CACHE_HIT_METHODS = /* @__PURE__ */ new Set(["hasItem", "getItem", "getItemRaw"]);
+export async function createStoragePlugin(useStorage, userStorageMounts) {
+  const storage = useStorage();
+  const userMounts = new Set(userStorageMounts.map((m) => `${m}:`));
+  debug.log("[storage] Starting to instrument storage drivers...");
+  userMounts.add("cache:");
+  userMounts.add("");
+  const mounts = storage.getMounts();
+  for (const mount of mounts) {
+    if (!userMounts.has(mount.base)) {
+      continue;
+    }
+    instrumentDriver(mount.driver, mount.base);
+  }
+  storage.mount = wrapStorageMount(storage);
+}
+function instrumentDriver(driver, mountBase) {
+  if (driver.__sentry_instrumented__) {
+    debug.log(`[storage] Driver already instrumented: "${driver.name}". Skipping...`);
+    return driver;
+  }
+  debug.log(`[storage] Instrumenting driver: "${driver.name}" on mount: "${mountBase}"`);
+  const methodsToInstrument = [
+    "hasItem",
+    "getItem",
+    "getItemRaw",
+    "getItems",
+    "setItem",
+    "setItemRaw",
+    "setItems",
+    "removeItem",
+    "getKeys",
+    "clear"
+  ];
+  for (const methodName of methodsToInstrument) {
+    const original = driver[methodName];
+    if (typeof original !== "function") {
+      continue;
+    }
+    driver[methodName] = createMethodWrapper(original, methodName, driver, mountBase);
+  }
+  driver.__sentry_instrumented__ = true;
+  return driver;
+}
+function createMethodWrapper(original, methodName, driver, mountBase) {
+  return new Proxy(original, {
+    async apply(target, thisArg, args) {
+      const options = createSpanStartOptions(methodName, driver, mountBase, args);
+      debug.log(`[storage] Running method: "${methodName}" on driver: "${driver.name ?? "unknown"}"`);
+      return startSpan(options, async (span) => {
+        try {
+          const result = await target.apply(thisArg, args);
+          span.setStatus({ code: SPAN_STATUS_OK });
+          if (CACHE_HIT_METHODS.has(methodName)) {
+            span.setAttribute(SEMANTIC_ATTRIBUTE_CACHE_HIT, isCacheHit(args[0], result));
+          }
+          return result;
+        } catch (error) {
+          span.setStatus({ code: SPAN_STATUS_ERROR, message: "internal_error" });
+          captureException(error, {
+            mechanism: {
+              handled: false,
+              type: options.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]
+            }
+          });
+          throw error;
+        } finally {
+          await flushIfServerless();
+        }
+      });
+    }
+  });
+}
+function wrapStorageMount(storage) {
+  const original = storage.mount;
+  if (original.__sentry_instrumented__) {
+    return original;
+  }
+  function mountWithInstrumentation(base, driver) {
+    debug.log(`[storage] Instrumenting mount: "${base}"`);
+    const instrumentedDriver = instrumentDriver(driver, base);
+    return original(base, instrumentedDriver);
+  }
+  mountWithInstrumentation.__sentry_instrumented__ = true;
+  return mountWithInstrumentation;
+}
+function normalizeMethodName(methodName) {
+  return methodName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function isEmptyValue(value) {
+  return value === null || value === void 0;
+}
+function createSpanStartOptions(methodName, driver, mountBase, args) {
+  const keys = getCacheKeys(args?.[0], mountBase);
+  const attributes = {
+    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `cache.${normalizeMethodName(methodName)}`,
+    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.cache.nuxt",
+    [SEMANTIC_ATTRIBUTE_CACHE_KEY]: keys.length > 1 ? keys : keys[0],
+    "db.operation.name": methodName,
+    "db.collection.name": mountBase.replace(/:$/, ""),
+    "db.system.name": driver.name ?? "unknown"
+  };
+  return {
+    name: keys.join(", "),
+    attributes
+  };
+}
+function getCacheKeys(key, prefix) {
+  if (Array.isArray(key)) {
+    return key.map((k) => normalizeKey(k, prefix));
+  }
+  return [normalizeKey(key, prefix)];
+}
+function normalizeKey(key, prefix) {
+  if (typeof key === "string") {
+    return `${prefix}${key}`;
+  }
+  if (typeof key === "object" && key !== null && "key" in key) {
+    return `${prefix}${key.key}`;
+  }
+  return `${prefix}${isEmptyValue(key) ? "" : String(key)}`;
+}
+const CACHED_FN_HANDLERS_RE = /^nitro:(functions|handlers):/i;
+function isCacheHit(key, value) {
+  try {
+    const isEmpty = isEmptyValue(value);
+    if (isEmpty || typeof key !== "string" || !CACHED_FN_HANDLERS_RE.test(key)) {
+      return !isEmpty;
+    }
+    return validateCacheEntry(key, JSON.parse(String(value)));
+  } catch {
+    return false;
+  }
+}
+function validateCacheEntry(key, entry) {
+  if (isEmptyValue(entry.value)) {
+    return false;
+  }
+  if (Date.now() > (entry.expires || 0)) {
+    return false;
+  }
+  if (isResponseCacheEntry(key, entry)) {
+    if ((entry.value.status ?? 0) >= 400) {
+      return false;
+    }
+    if (entry.value.body === void 0) {
+      return false;
+    }
+    if (entry.value.headers?.etag === "undefined" || entry.value.headers?.["last-modified"] === "undefined") {
+      return false;
+    }
+  }
+  return true;
+}
+function isResponseCacheEntry(key, _) {
+  return key.startsWith("nitro:handlers:");
+}

package/build/module/runtime/utils/patchEventHandler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Patches the H3 event handler of Nitro.
+ *
+ * Uses a TypeScript generic type to ensure the returned handler type fits different versions of Nitro.
+ */
+export declare function patchEventHandler<H3EventHandler extends Function>(handler: H3EventHandler): H3EventHandler;

package/build/module/runtime/utils/patchEventHandler.js

@@ -0,0 +1,25 @@
+import {
+  debug,
+  flushIfServerless,
+  getDefaultIsolationScope,
+  getIsolationScope,
+  withIsolationScope
+} from "@sentry/core";
+export function patchEventHandler(handler) {
+  return new Proxy(handler, {
+    async apply(handlerTarget, handlerThisArg, handlerArgs) {
+      const isolationScope = getIsolationScope();
+      const newIsolationScope = isolationScope === getDefaultIsolationScope() ? isolationScope.clone() : isolationScope;
+      debug.log(
+        `Patched h3 event handler. ${isolationScope === newIsolationScope ? "Using existing" : "Created new"} isolation scope.`
+      );
+      return withIsolationScope(newIsolationScope, async () => {
+        try {
+          return await handlerTarget.apply(handlerThisArg, handlerArgs);
+        } finally {
+          await flushIfServerless();
+        }
+      });
+    }
+  });
+}

package/build/types/module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/module.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAQ9D,MAAM,MAAM,aAAa,GAAG,uBAAuB,CAAC;;AAEpD,wBA0MG"}
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/module.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAQ9D,MAAM,MAAM,aAAa,GAAG,uBAAuB,CAAC;;AAEpD,wBA+MG"}

package/build/types/runtime/plugins/database-legacy.server.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Nitro plugin that instruments database calls for Nuxt v3/v4 (Nitro v2)
+ */
+declare const _default: () => void;
+export default _default;
+//# sourceMappingURL=database-legacy.server.d.ts.map

package/build/types/runtime/plugins/database-legacy.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-legacy.server.d.ts","sourceRoot":"","sources":["../../../../src/runtime/plugins/database-legacy.server.ts"],"names":[],"mappings":"AAOA;;GAEG;;AACH,wBAE4B"}

package/build/types/runtime/plugins/database.server.d.ts

@@ -1,5 +1,5 @@
 /**
- * Creates a Nitro plugin that instruments the database calls.
+ * Nitro plugin that instruments database calls for Nuxt v5+ (Nitro v3+)
  */
 declare const _default: () => void;
 export default _default;

package/build/types/runtime/plugins/database.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database.server.d.ts","sourceRoot":"","sources":["../../../../src/runtime/plugins/database.server.ts"],"names":[],"mappings":"AAkCA;;GAEG;;AACH,wBAsB4B"}
+{"version":3,"file":"database.server.d.ts","sourceRoot":"","sources":["../../../../src/runtime/plugins/database.server.ts"],"names":[],"mappings":"AAOA;;GAEG;;AACH,wBAE4B"}

package/build/types/runtime/plugins/handler-legacy.server.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (nitroApp: import("nitropack").NitroApp) => void;
+export default _default;
+//# sourceMappingURL=handler-legacy.server.d.ts.map

package/build/types/runtime/plugins/handler-legacy.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler-legacy.server.d.ts","sourceRoot":"","sources":["../../../../src/runtime/plugins/handler-legacy.server.ts"],"names":[],"mappings":";AAIA,wBAE4B"}

package/build/types/runtime/plugins/handler.server.d.ts

@@ -0,0 +1,7 @@
+import type { NitroApp } from 'nitro/types';
+/**
+ * This plugin patches the h3 event handler for Nuxt v5+ (Nitro v3+).
+ */
+declare const _default: (nitroApp: NitroApp) => void;
+export default _default;
+//# sourceMappingURL=handler.server.d.ts.map

package/build/types/runtime/plugins/handler.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.server.d.ts","sourceRoot":"","sources":["../../../../src/runtime/plugins/handler.server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAkB,QAAQ,EAAE,MAAM,aAAa,CAAC;AAG5D;;GAEG;mCACwB,QAAQ;AAAnC,wBAK4B"}

package/build/types/runtime/plugins/sentry.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sentry.server.d.ts","sourceRoot":"","sources":["../../../../src/runtime/plugins/sentry.server.ts"],"names":[],"mappings":";AAcA,wBAwB4B"}
+{"version":3,"file":"sentry.server.d.ts","sourceRoot":"","sources":["../../../../src/runtime/plugins/sentry.server.ts"],"names":[],"mappings":";AAQA,wBA6B4B"}

package/build/types/runtime/plugins/storage-legacy.server.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Nitro plugin that instruments storage driver calls for Nuxt v3/v4 (Nitro v2)
+ */
+declare const _default: (_nitroApp: import("nitropack").NitroApp) => Promise<void>;
+export default _default;
+//# sourceMappingURL=storage-legacy.server.d.ts.map

package/build/types/runtime/plugins/storage-legacy.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-legacy.server.d.ts","sourceRoot":"","sources":["../../../../src/runtime/plugins/storage-legacy.server.ts"],"names":[],"mappings":"AAMA;;GAEG;;AACH,wBAE4B"}

package/build/types/runtime/plugins/storage.server.d.ts

@@ -1,6 +1,8 @@
 /**
- * Creates a Nitro plugin that instruments the storage driver.
+ * Nitro plugin that instruments storage driver calls for Nuxt v5+ (Nitro v3+)
  */
-declare const _default: (_nitroApp: import("nitropack").NitroApp) => Promise<void>;
+declare const _default: (_nitroApp: import("nitro/types").NitroApp & {
+    hooks: NonNullable<import("nitro/types").NitroApp["hooks"]>;
+}) => Promise<void>;
 export default _default;
 //# sourceMappingURL=storage.server.d.ts.map

package/build/types/runtime/plugins/storage.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage.server.d.ts","sourceRoot":"","sources":["../../../../src/runtime/plugins/storage.server.ts"],"names":[],"mappings":"AAkCA;;GAEG;;AACH,wBA6B4B"}
+{"version":3,"file":"storage.server.d.ts","sourceRoot":"","sources":["../../../../src/runtime/plugins/storage.server.ts"],"names":[],"mappings":"AAMA;;GAEG;;;;AACH,wBAE4B"}