@sentry/nuxt 10.64.0 → 10.66.0

package/build/esm/package.json

@@ -1 +1 @@
-{"type":"module","version":"10.64.0"}
+{"type":"module","version":"10.66.0"}

package/build/module/client/vueIntegration.d.ts

@@ -0,0 +1,12 @@
+import type { VueIntegrationOptions } from '@sentry/vue';
+type Options = Omit<VueIntegrationOptions, 'app' | 'Vue'>;
+export type GlobalObjWithIntegrationOptions = {
+    _sentryNuxtVueIntegrationOptions?: Options;
+};
+/**
+ * Add additional error and span instrumentation specialized for Vue.
+ */
+export declare const vueIntegration: (options?: Options | undefined) => import("@sentry/core").Integration & {
+    name: string;
+};
+export {};

package/build/module/{module.d.mts → common/types.d.ts}

@@ -1,8 +1,23 @@
-import * as _nuxt_schema from '@nuxt/schema';
-import { BuildTimeOptionsBase } from '@sentry/core';
-import { SentryRollupPluginOptions } from '@sentry/rollup-plugin';
-import { SentryVitePluginOptions } from '@sentry/vite-plugin';
-
+import type { BuildTimeOptionsBase } from '@sentry/core';
+import type { init as initNode } from '@sentry/node';
+import type { SentryRollupPluginOptions } from '@sentry/rollup-plugin';
+import type { SentryVitePluginOptions } from '@sentry/vite-plugin';
+import type { init as initVue } from '@sentry/vue';
+export type SentryNuxtClientOptions = Omit<Parameters<typeof initVue>[0] & object, 'app'>;
+export type SentryNuxtServerOptions = Parameters<typeof initNode>[0] & {
+    /**
+     * Enables the Sentry error handler for the Nitro error hook.
+     *
+     * When enabled, exceptions are automatically sent to Sentry with additional data such as the transaction name and Nitro error context.
+     * It's recommended to keep this enabled unless you need to implement a custom error handler.
+     *
+     * If you need a custom implementation, disable this option and refer to the default handler as a reference:
+     * https://github.com/getsentry/sentry-javascript/blob/da8ba8d77a28b43da5014acc8dd98906d2180cc1/packages/nuxt/src/runtime/plugins/sentry.server.ts#L20-L46
+     *
+     * @default true
+     */
+    enableNitroErrorHandler?: boolean;
+};
 type SourceMapsOptions = {
     /**
      * Suppresses all logs.
@@ -144,7 +159,7 @@ type SourceMapsOptions = {
 /**
  *  Build options for the Sentry module. These options are used during build-time by the Sentry SDK.
  */
-type SentryNuxtModuleOptions = BuildTimeOptionsBase & {
+export type SentryNuxtModuleOptions = BuildTimeOptionsBase & {
     /**
      * Enable the Sentry Nuxt Module.
      *
@@ -225,8 +240,4 @@ type SentryNuxtModuleOptions = BuildTimeOptionsBase & {
      */
     unstable_sentryBundlerPluginOptions?: SentryRollupPluginOptions & SentryVitePluginOptions;
 };
-
-type ModuleOptions = SentryNuxtModuleOptions;
-declare const _default: _nuxt_schema.NuxtModule<SentryNuxtModuleOptions, SentryNuxtModuleOptions, false>;
-
-export { type ModuleOptions, _default as default };
+export {};

package/build/module/module.d.ts

@@ -1,232 +1,4 @@
-import * as _nuxt_schema from '@nuxt/schema';
-import { BuildTimeOptionsBase } from '@sentry/core';
-import { SentryRollupPluginOptions } from '@sentry/rollup-plugin';
-import { SentryVitePluginOptions } from '@sentry/vite-plugin';
-
-type SourceMapsOptions = {
-    /**
-     * Suppresses all logs.
-     *
-     * @default false
-     * @deprecated Use option `silent` instead of `sourceMapsUploadOptions.silent`
-     */
-    silent?: boolean;
-    /**
-     * When an error occurs during release creation or sourcemaps upload, the plugin will call this function.
-     *
-     * By default, the plugin will simply throw an error, thereby stopping the bundling process.
-     * If an `errorHandler` callback is provided, compilation will continue, unless an error is
-     * thrown in the provided callback.
-     *
-     * To allow compilation to continue but still emit a warning, set this option to the following:
-     *
-     * ```js
-     * (err) => {
-     *   console.warn(err);
-     * }
-     * ```
-     *
-     * @deprecated Use option `errorHandler` instead of `sourceMapsUploadOptions.errorHandler`
-     */
-    errorHandler?: (err: Error) => void;
-    /**
-     * Options related to managing the Sentry releases for a build.
-     *
-     * More info: https://docs.sentry.io/product/releases/
-     *
-     * @deprecated Use option `release` instead of `sourceMapsUploadOptions.release`
-     */
-    release?: {
-        /**
-         * Unique identifier for the release you want to create.
-         *
-         * This value can also be specified via the `SENTRY_RELEASE` environment variable.
-         *
-         * Defaults to automatically detecting a value for your environment.
-         * This includes values for Cordova, Heroku, AWS CodeBuild, CircleCI, Xcode, and Gradle, and otherwise uses the git `HEAD`'s commit SHA.
-         * (the latter requires access to git CLI and for the root directory to be a valid repository)
-         *
-         * If you didn't provide a value and the plugin can't automatically detect one, no release will be created.
-         *
-         * @deprecated Use `release.name` instead of `sourceMapsUploadOptions.release.name`
-         */
-        name?: string;
-    };
-    /**
-     * If this flag is `true`, and an auth token is detected, the Sentry SDK will
-     * automatically generate and upload source maps to Sentry during a production build.
-     *
-     * @default true
-     * @deprecated Use option `sourcemaps.disable` instead of `sourceMapsUploadOptions.enabled`
-     */
-    enabled?: boolean;
-    /**
-     * The auth token to use when uploading source maps to Sentry.
-     *
-     * Instead of specifying this option, you can also set the `SENTRY_AUTH_TOKEN` environment variable.
-     *
-     * To create an auth token, follow this guide:
-     * @see https://docs.sentry.io/product/accounts/auth-tokens/#organization-auth-tokens
-     * @deprecated Use option `authToken` instead of `sourceMapsUploadOptions.authToken`
-     */
-    authToken?: string;
-    /**
-     * The organization slug of your Sentry organization.
-     * Instead of specifying this option, you can also set the `SENTRY_ORG` environment variable.
-     * @deprecated Use option `org` instead of `sourceMapsUploadOptions.org`
-     */
-    org?: string;
-    /**
-     * The URL of your Sentry instance if you're using self-hosted Sentry.
-     *
-     * @default https://sentry.io by default the plugin will point towards the Sentry SaaS URL
-     * @deprecated Use `sentryUrl` instead of `sourceMapsUploadOptions.url`
-     */
-    url?: string;
-    /**
-     * The project slug of your Sentry project.
-     * Instead of specifying this option, you can also set the `SENTRY_PROJECT` environment variable.
-     *
-     * @deprecated Use option `project` instead of `sourceMapsUploadOptions.project`
-     */
-    project?: string;
-    /**
-     * If this flag is `true`, the Sentry plugin will collect some telemetry data and send it to Sentry.
-     * It will not collect any sensitive or user-specific data.
-     *
-     * @default true
-     * @deprecated Use option `telemetry` instead of `sourceMapsUploadOptions.telemetry`
-     */
-    telemetry?: boolean;
-    /**
-     * Options related to sourcemaps
-     *
-     * @deprecated Use option `sourcemaps` instead of `sourceMapsUploadOptions.sourcemaps`
-     */
-    sourcemaps?: {
-        /**
-         * A glob or an array of globs that specify the build artifacts and source maps that will be uploaded to Sentry.
-         *
-         * If this option is not specified, sensible defaults based on your adapter and nuxt.config.js
-         * setup will be used. Use this option to override these defaults, for instance if you have a
-         * customized build setup that diverges from Nuxt's defaults.
-         *
-         * The globbing patterns must follow the implementation of the `glob` package.
-         * @see https://www.npmjs.com/package/glob#glob-primer
-         *
-         * @deprecated Use option `sourcemaps.assets` instead of `sourceMapsUploadOptions.sourcemaps.assets`
-         */
-        assets?: string | Array<string>;
-        /**
-         * A glob or an array of globs that specifies which build artifacts should not be uploaded to Sentry.
-         *
-         * @default [] - By default no files are ignored. Thus, all files matching the `assets` glob
-         * or the default value for `assets` are uploaded.
-         *
-         * The globbing patterns follow the implementation of the glob package. (https://www.npmjs.com/package/glob)
-         *
-         * @deprecated Use option `sourcemaps.ignore` instead of `sourceMapsUploadOptions.sourcemaps.ignore`
-         */
-        ignore?: string | Array<string>;
-        /**
-         * A glob or an array of globs that specifies the build artifacts that should be deleted after the artifact
-         * upload to Sentry has been completed.
-         *
-         * @default [] - By default no files are deleted.
-         *
-         * The globbing patterns follow the implementation of the glob package. (https://www.npmjs.com/package/glob)
-         *
-         * @deprecated Use option `sourcemaps.filesToDeleteAfterUpload` instead of `sourceMapsUploadOptions.sourcemaps.filesToDeleteAfterUpload`
-         */
-        filesToDeleteAfterUpload?: string | Array<string>;
-    };
-};
-/**
- *  Build options for the Sentry module. These options are used during build-time by the Sentry SDK.
- */
-type SentryNuxtModuleOptions = BuildTimeOptionsBase & {
-    /**
-     * Enable the Sentry Nuxt Module.
-     *
-     * @default true
-     */
-    enabled?: boolean;
-    /**
-     * Options for the Sentry Vite plugin to customize the source maps upload process.
-     *
-     * These options are always read from the `sentry` module options in the `nuxt.config.(js|ts).
-     * Do not define them in the `sentry.client.config.(js|ts)` or `sentry.server.config.(js|ts)` files.
-     *
-     * @deprecated  This option was deprecated as it adds unnecessary nesting.
-     *              Put the options one level higher to the root-level of the `sentry` module options.
-     */
-    sourceMapsUploadOptions?: SourceMapsOptions;
-    /**
-     *
-     * Enables (partial) server tracing by automatically injecting Sentry for environments where modifying the node option `--import` is not possible.
-     *
-     * **DO NOT** add the node CLI flag `--import` in your node start script, when auto-injecting Sentry.
-     * This would initialize Sentry twice on the server-side and this leads to unexpected issues.
-     *
-     * ---
-     *
-     * **"top-level-import"**
-     *
-     * Enabling basic server tracing with top-level import can be used for environments where modifying the node option `--import` is not possible.
-     * However, enabling this option only supports limited tracing instrumentation. Only http traces will be collected (but no database-specific traces etc.).
-     *
-     * If `"top-level-import"` is enabled, the Sentry SDK will import the Sentry server config at the top of the server entry file to load the SDK on the server.
-     *
-     * ---
-     * **"experimental_dynamic-import"**
-     *
-     * Wraps the server entry file with a dynamic `import()`. This will make it possible to preload Sentry and register
-     * necessary hooks before other code runs. (Node docs: https://nodejs.org/api/module.html#enabling)
-     *
-     * If `"experimental_dynamic-import"` is enabled, the Sentry SDK wraps the server entry file with `import()`.
-     *
-     * @default undefined
-     */
-    autoInjectServerSentry?: 'top-level-import' | 'experimental_dynamic-import';
-    /**
-     * Provide the resolved path to a custom Sentry client config file.
-     *
-     * If not provided, the default location (`<projectRoot>/sentry.(client|server).config.(js|ts)`) will be used to look up the config file.
-     * If there is no file at the default location either, the SDK won't be initialized.
-     *
-     * Resolves the full path to a file or directory, respecting Nuxt alias and extensions options.
-     * @example
-     *
-     * ```ts
-     * sentry: {
-     *   configDir: '~/sentry-config',
-     *   // Sentry will search for `<rootDir>/<srcDir>/sentry-config/sentry.(client|server).config.(js|ts)` files.
-     * }
-     * ```
-     */
-    configDir?: string;
-    /**
-     * When `autoInjectServerSentry` is set to `"experimental_dynamic-import"`, the SDK will wrap your Nitro server entrypoint
-     * with a dynamic `import()` to ensure all dependencies can be properly instrumented. Any previous exports from the entrypoint are still exported.
-     * Most exports of the server entrypoint are serverless functions and those are wrapped by Sentry. Other exports stay as-is.
-     *
-     * By default, the SDK will wrap the default export as well as a `handler` or `server` export from the entrypoint.
-     * If your server has a different main export that is used to run the server, you can overwrite this by providing an array of export names to wrap.
-     * Any wrapped export is expected to be an async function.
-     *
-     * @default ['default', 'handler', 'server']
-     */
-    experimental_entrypointWrappedFunctions?: string[];
-    /**
-     * Options to be passed directly to the Sentry Rollup Plugin (`@sentry/rollup-plugin`) and Sentry Vite Plugin (`@sentry/vite-plugin`) that ship with the Sentry Nuxt SDK.
-     * You can use this option to override any options the SDK passes to the Vite (for Nuxt) and Rollup (for Nitro) plugin.
-     *
-     * Please note that this option is unstable and may change in a breaking way in any release.
-     */
-    unstable_sentryBundlerPluginOptions?: SentryRollupPluginOptions & SentryVitePluginOptions;
-};
-
-type ModuleOptions = SentryNuxtModuleOptions;
-declare const _default: _nuxt_schema.NuxtModule<SentryNuxtModuleOptions, SentryNuxtModuleOptions, false>;
-
-export { type ModuleOptions, _default as default };
+import type { SentryNuxtModuleOptions } from './common/types';
+export type ModuleOptions = SentryNuxtModuleOptions;
+declare const _default: import("@nuxt/schema").NuxtModule<SentryNuxtModuleOptions, SentryNuxtModuleOptions, false>;
+export default _default;

package/build/module/module.json

@@ -4,9 +4,5 @@
   "compatibility": {
     "nuxt": ">=3.7.0"
   },
-  "version": "10.64.0",
-  "builder": {
-    "@nuxt/module-builder": "0.8.4",
-    "unbuild": "2.0.0"
-  }
-}
+  "version": "10.66.0"
+}

package/build/module/module.mjs

@@ -233,8 +233,7 @@ function wrapEntryWithDynamicImport({
       }
       if (options.isEntry && source.includes(".mjs") && !source.includes(`.mjs${SENTRY_WRAPPED_ENTRY}`)) {
         const resolution = await this.resolve(source, importer, options);
-        if (!resolution || resolution?.external)
-          return resolution;
+        if (!resolution || resolution?.external) return resolution;
         const moduleInfo = await this.load(resolution);
         moduleInfo.moduleSideEffects = true;
         return resolution.id.includes(`.mjs${SENTRY_WRAPPED_ENTRY}`) ? resolution.id : `${resolutionIdPrefix}${resolution.id.concat(SENTRY_WRAPPED_ENTRY).concat(
@@ -647,7 +646,7 @@ function addStorageInstrumentation(nuxt, isLegacyNitro) {
   }
 }
 
-const module = defineNuxtModule({
+var module$1 = defineNuxtModule({
   meta: {
     name: "@sentry/nuxt/module",
     configKey: "sentry",
@@ -815,4 +814,4 @@ const module = defineNuxtModule({
   }
 });
 
-export { module as default };
+export { module$1 as default };

package/build/module/runtime/hooks/captureErrorHook.js

@@ -1,7 +1,8 @@
-import { captureException, flushIfServerless, getClient, getCurrentScope } from "@sentry/core";
-import { H3Error } from "h3";
-import { extractErrorContext } from "../utils.js";
-export async function sentryCaptureErrorHook(error, errorContext) {
+import { getClient, getCurrentScope, captureException, flushIfServerless } from '@sentry/core';
+import { H3Error } from 'h3';
+import { extractErrorContext } from '../utils.js';
+
+async function sentryCaptureErrorHook(error, errorContext) {
   const sentryClient = getClient();
   const sentryClientOptions = sentryClient?.getOptions();
   if (sentryClientOptions && "enableNitroErrorHandler" in sentryClientOptions && sentryClientOptions.enableNitroErrorHandler === false) {
@@ -29,3 +30,5 @@ export async function sentryCaptureErrorHook(error, errorContext) {
   });
   await flushIfServerless();
 }
+
+export { sentryCaptureErrorHook };

package/build/module/runtime/hooks/updateRouteBeforeResponse.js

@@ -1,9 +1,10 @@
-import { debug, getActiveSpan, getRootSpan, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from "@sentry/core";
+import { getActiveSpan, getRootSpan, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, isObjectLike, debug } from '@sentry/core';
+
 function getMatchedRoutePath(event) {
   const matchedRoute = event.context.matchedRoute;
   return matchedRoute?.path ?? matchedRoute?.route;
 }
-export function updateRouteBeforeResponse(event) {
+function updateRouteBeforeResponse(event) {
   if (!event.context.matchedRoute) {
     return;
   }
@@ -26,7 +27,7 @@ export function updateRouteBeforeResponse(event) {
       "http.route": matchedRoutePath
     });
     const params = event.context?.params;
-    if (params && typeof params === "object") {
+    if (isObjectLike(params)) {
       Object.entries(params).forEach(([key, value]) => {
         rootSpan.setAttributes({
           [`url.path.parameter.${key}`]: String(value),
@@ -37,3 +38,5 @@ export function updateRouteBeforeResponse(event) {
     debug.log(`Updated transaction name for parametrized route: ${matchedRoutePath}`);
   }
 }
+
+export { updateRouteBeforeResponse };

package/build/module/runtime/hooks/wrapMiddlewareHandler.js

@@ -1,17 +1,6 @@
-import {
-  captureException,
-  debug,
-  flushIfServerless,
-  getClient,
-  httpHeadersToSpanAttributes,
-  SEMANTIC_ATTRIBUTE_SENTRY_OP,
-  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
-  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
-  SPAN_STATUS_ERROR,
-  SPAN_STATUS_OK,
-  startSpan
-} from "@sentry/core";
-export function wrapMiddlewareHandlerWithSentry(handler, fileName) {
+import { debug, httpHeadersToSpanAttributes, getClient, startSpan, SPAN_STATUS_OK, SPAN_STATUS_ERROR, captureException, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, flushIfServerless, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_OP } from '@sentry/core';
+
+function wrapMiddlewareHandlerWithSentry(handler, fileName) {
   if (!isEventHandlerObject(handler)) {
     return wrapEventHandler(handler, fileName);
   }
@@ -112,3 +101,5 @@ function getSpanAttributes(event, middlewareName, hookName, index) {
 function isEventHandlerObject(handler) {
   return typeof handler !== "function";
 }
+
+export { wrapMiddlewareHandlerWithSentry };

package/build/module/runtime/plugins/database-legacy.server.js

@@ -1,6 +1,9 @@
-import { useDatabase } from "nitropack/runtime";
-import { databaseConfig } from "#sentry/database-config.mjs";
-import { createDatabasePlugin } from "../utils/instrumentDatabase.js";
-export default () => {
+import { useDatabase } from 'nitropack/runtime';
+import { databaseConfig } from '#sentry/database-config.mjs';
+import { createDatabasePlugin } from '../utils/instrumentDatabase.js';
+
+var databaseLegacy_server = (() => {
   createDatabasePlugin(useDatabase, databaseConfig);
-};
+});
+
+export { databaseLegacy_server as default };

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

@@ -1,6 +1,9 @@
-import { useDatabase } from "nitro/database";
-import { databaseConfig } from "#sentry/database-config.mjs";
-import { createDatabasePlugin } from "../utils/instrumentDatabase.js";
-export default () => {
+import { useDatabase } from 'nitro/database';
+import { databaseConfig } from '#sentry/database-config.mjs';
+import { createDatabasePlugin } from '../utils/instrumentDatabase.js';
+
+var database_server = (() => {
   createDatabasePlugin(useDatabase, databaseConfig);
-};
+});
+
+export { database_server as default };

package/build/module/runtime/plugins/handler-legacy.server.js

@@ -1,4 +1,7 @@
-import { patchEventHandler } from "../utils/patchEventHandler.js";
-export default (nitroApp) => {
+import { patchEventHandler } from '../utils/patchEventHandler.js';
+
+var handlerLegacy_server = ((nitroApp) => {
   nitroApp.h3App.handler = patchEventHandler(nitroApp.h3App.handler);
-};
+});
+
+export { handlerLegacy_server as default };

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

@@ -1,6 +1,9 @@
-import { patchEventHandler } from "../utils/patchEventHandler.js";
-export default (nitroApp) => {
+import { patchEventHandler } from '../utils/patchEventHandler.js';
+
+var handler_server = ((nitroApp) => {
   if (nitroApp?.h3?.handler) {
     nitroApp.h3.handler = patchEventHandler(nitroApp.h3.handler);
   }
-};
+});
+
+export { handler_server as default };

package/build/module/runtime/plugins/index.d.ts

@@ -1 +1 @@
-export { sentryCloudflareNitroPlugin } from './sentry-cloudflare.server.js';
+export { sentryCloudflareNitroPlugin } from './sentry-cloudflare.server';

package/build/module/runtime/plugins/index.js

@@ -1 +1 @@
-export { sentryCloudflareNitroPlugin } from "./sentry-cloudflare.server.js";
+export { sentryCloudflareNitroPlugin } from './sentry-cloudflare.server.js';

package/build/module/runtime/plugins/route-detector-legacy.server.js

@@ -1,11 +1,12 @@
-import { debug, getActiveSpan, getRootSpan, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from "@sentry/core";
-import { defineNuxtPlugin } from "nuxt/app";
-import { extractParametrizedRouteFromContext } from "../utils/route-extraction.js";
-export default defineNuxtPlugin((nuxtApp) => {
+import { debug, getActiveSpan, getRootSpan, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
+import { defineNuxtPlugin } from 'nuxt/app';
+import { extractParametrizedRouteFromContext } from '../utils/route-extraction.js';
+
+var routeDetectorLegacy_server = defineNuxtPlugin((nuxtApp) => {
   nuxtApp.hooks.hook("app:rendered", async (renderContext) => {
     let buildTimePagesData;
     try {
-      const { default: importedPagesData } = await import("#build/sentry--nuxt-pages-data.mjs");
+      const { default: importedPagesData } = await import('#build/sentry--nuxt-pages-data.mjs');
       buildTimePagesData = importedPagesData || [];
       debug.log("Imported build-time pages data:", buildTimePagesData);
     } catch (error) {
@@ -35,3 +36,5 @@ export default defineNuxtPlugin((nuxtApp) => {
     }
   });
 });
+
+export { routeDetectorLegacy_server as default };

package/build/module/runtime/plugins/route-detector.server.js

@@ -1,11 +1,12 @@
-import { debug, getActiveSpan, getRootSpan, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from "@sentry/core";
-import { defineNuxtPlugin } from "nuxt/app";
-import { extractParametrizedRouteFromContext } from "../utils/route-extraction.js";
-export default defineNuxtPlugin((nuxtApp) => {
+import { debug, getActiveSpan, getRootSpan, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
+import { defineNuxtPlugin } from 'nuxt/app';
+import { extractParametrizedRouteFromContext } from '../utils/route-extraction.js';
+
+var routeDetector_server = defineNuxtPlugin((nuxtApp) => {
   nuxtApp.hooks.hook("app:rendered", async (renderContext) => {
     let buildTimePagesData;
     try {
-      const { default: importedPagesData } = await import("#sentry/nuxt-pages-data.mjs");
+      const { default: importedPagesData } = await import('#sentry/nuxt-pages-data.mjs');
       buildTimePagesData = importedPagesData || [];
       debug.log("Imported build-time pages data:", buildTimePagesData);
     } catch (error) {
@@ -35,3 +36,5 @@ export default defineNuxtPlugin((nuxtApp) => {
     }
   });
 });
+
+export { routeDetector_server as default };

package/build/module/runtime/plugins/sentry-cloudflare.server.js

@@ -1,10 +1,11 @@
-import { setAsyncLocalStorageAsyncContextStrategy, wrapRequestHandler } from "@sentry/cloudflare";
-import { debug, getDefaultIsolationScope, getIsolationScope, getTraceData } from "@sentry/core";
-import { sentryCaptureErrorHook } from "../hooks/captureErrorHook.js";
-import { updateRouteBeforeResponse } from "../hooks/updateRouteBeforeResponse.js";
-import { addSentryTracingMetaTags } from "../utils.js";
-import { getCfProperties, getCloudflareProperties, hasCfProperty, isEventType } from "../utils/event-type-check.js";
-export const sentryCloudflareNitroPlugin = (optionsOrFn) => (nitroApp) => {
+import { setAsyncLocalStorageAsyncContextStrategy, wrapRequestHandler } from '@sentry/cloudflare';
+import { debug, getIsolationScope, getDefaultIsolationScope, getTraceData } from '@sentry/core';
+import { sentryCaptureErrorHook } from '../hooks/captureErrorHook.js';
+import { updateRouteBeforeResponse } from '../hooks/updateRouteBeforeResponse.js';
+import { addSentryTracingMetaTags } from '../utils.js';
+import { isEventType, getCfProperties, getCloudflareProperties, hasCfProperty } from '../utils/event-type-check.js';
+
+const sentryCloudflareNitroPlugin = (optionsOrFn) => (nitroApp) => {
   const traceDataMap = /* @__PURE__ */ new WeakMap();
   nitroApp.localFetch = new Proxy(nitroApp.localFetch, {
     async apply(handlerTarget, handlerThisArg, handlerArgs) {
@@ -61,3 +62,5 @@ export const sentryCloudflareNitroPlugin = (optionsOrFn) => (nitroApp) => {
   });
   nitroApp.hooks.hook("error", sentryCaptureErrorHook);
 };
+
+export { sentryCloudflareNitroPlugin };

package/build/module/runtime/plugins/sentry.client.js

@@ -1,8 +1,9 @@
-import { getClient, GLOBAL_OBJ } from "@sentry/core";
-import { browserTracingIntegration, vueIntegration } from "@sentry/vue";
-import { defineNuxtPlugin, isNuxtError } from "nuxt/app";
-import { reportNuxtError } from "../utils.js";
-export default defineNuxtPlugin({
+import { getClient, GLOBAL_OBJ } from '@sentry/core';
+import { browserTracingIntegration, vueIntegration } from '@sentry/vue';
+import { defineNuxtPlugin, isNuxtError } from 'nuxt/app';
+import { reportNuxtError } from '../utils.js';
+
+var sentry_client = defineNuxtPlugin({
   name: "sentry-client-integrations",
   dependsOn: ["sentry-client-config"],
   async setup(nuxtApp) {
@@ -40,3 +41,5 @@ export default defineNuxtPlugin({
     });
   }
 });
+
+export { sentry_client as default };

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

@@ -1,7 +1,8 @@
-import { debug } from "@sentry/core";
-import { sentryCaptureErrorHook } from "../hooks/captureErrorHook.js";
-import { addSentryTracingMetaTags } from "../utils.js";
-export default (nitroApp) => {
+import { debug } from '@sentry/core';
+import { sentryCaptureErrorHook } from '../hooks/captureErrorHook.js';
+import { addSentryTracingMetaTags } from '../utils.js';
+
+var sentry_server = ((nitroApp) => {
   nitroApp.hooks.hook("error", sentryCaptureErrorHook);
   nitroApp.hooks.hook("render:html", (html, { event }) => {
     const nodeResHeadersH3v1 = event.node?.res?.getHeaders() || {};
@@ -23,4 +24,6 @@ export default (nitroApp) => {
       );
     }
   });
-};
+});
+
+export { sentry_server as default };

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

@@ -1,6 +1,9 @@
-import { useStorage } from "nitropack/runtime";
-import { userStorageMounts } from "#sentry/storage-config.mjs";
-import { createStoragePlugin } from "../utils/instrumentStorage.js";
-export default async (_nitroApp) => {
+import { useStorage } from 'nitropack/runtime';
+import { userStorageMounts } from '#sentry/storage-config.mjs';
+import { createStoragePlugin } from '../utils/instrumentStorage.js';
+
+var storageLegacy_server = (async (_nitroApp) => {
   await createStoragePlugin(useStorage, userStorageMounts);
-};
+});
+
+export { storageLegacy_server as default };

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

@@ -1,6 +1,9 @@
-import { useStorage } from "nitro/storage";
-import { userStorageMounts } from "#sentry/storage-config.mjs";
-import { createStoragePlugin } from "../utils/instrumentStorage.js";
-export default async (_nitroApp) => {
+import { useStorage } from 'nitro/storage';
+import { userStorageMounts } from '#sentry/storage-config.mjs';
+import { createStoragePlugin } from '../utils/instrumentStorage.js';
+
+var storage_server = (async (_nitroApp) => {
   await createStoragePlugin(useStorage, userStorageMounts);
-};
+});
+
+export { storage_server as default };

package/build/module/runtime/plugins/update-route-name-legacy.server.js

@@ -1,4 +1,7 @@
-import { updateRouteBeforeResponse } from "../hooks/updateRouteBeforeResponse.js";
-export default (nitroApp) => {
+import { updateRouteBeforeResponse } from '../hooks/updateRouteBeforeResponse.js';
+
+var updateRouteNameLegacy_server = ((nitroApp) => {
   nitroApp.hooks.hook("beforeResponse", updateRouteBeforeResponse);
-};
+});
+
+export { updateRouteNameLegacy_server as default };

package/build/module/runtime/plugins/update-route-name.server.js

@@ -1,4 +1,7 @@
-import { updateRouteBeforeResponse } from "../hooks/updateRouteBeforeResponse.js";
-export default (nitroApp) => {
+import { updateRouteBeforeResponse } from '../hooks/updateRouteBeforeResponse.js';
+
+var updateRouteName_server = ((nitroApp) => {
   nitroApp.hooks.hook("response", (_response, event) => updateRouteBeforeResponse(event));
-};
+});
+
+export { updateRouteName_server as default };

package/build/module/runtime/utils/database-span-data.js

@@ -1,4 +1,4 @@
-export function getDatabaseSpanData(config) {
+function getDatabaseSpanData(config) {
   try {
     if (!config?.connector) {
       return {
@@ -27,3 +27,5 @@ export function getDatabaseSpanData(config) {
     return {};
   }
 }
+
+export { getDatabaseSpanData };

package/build/module/runtime/utils/event-type-check.js

@@ -2,14 +2,14 @@ function hasCloudflareProperty(context) {
   return context !== null && typeof context === "object" && // context.cloudflare properties
   "cloudflare" in context && typeof context.cloudflare === "object" && context.cloudflare !== null && "context" in context.cloudflare;
 }
-export function hasCfProperty(context) {
+function hasCfProperty(context) {
   return context !== null && typeof context === "object" && // context.cf properties
   "cf" in context && typeof context.cf === "object" && context.cf !== null;
 }
 function hasCfAndCloudflare(context) {
   return hasCfProperty(context) && hasCloudflareProperty(context);
 }
-export function isEventType(event) {
+function isEventType(event) {
   if (event === null || typeof event !== "object") return false;
   return (
     // basic properties
@@ -18,15 +18,17 @@ export function isEventType(event) {
     (hasCfAndCloudflare(event.context) || "_platform" in event.context && hasCfAndCloudflare(event.context._platform))
   );
 }
-export function getCfProperties(event) {
+function getCfProperties(event) {
   if ("cf" in event.context) {
     return event.context.cf;
   }
   return event.context._platform.cf;
 }
-export function getCloudflareProperties(event) {
+function getCloudflareProperties(event) {
   if ("cloudflare" in event.context) {
     return event.context.cloudflare;
   }
   return event.context._platform.cloudflare;
 }
+
+export { getCfProperties, getCloudflareProperties, hasCfProperty, isEventType };

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

@@ -1,5 +1,5 @@
 import type { Database } from 'db0';
-import { type DatabaseConnectionConfig } from './database-span-data.js';
+import { type DatabaseConnectionConfig } from './database-span-data';
 /**
  * Creates the Nitro database plugin setup by instrumenting the configured database instances.
  *

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

@@ -1,17 +1,9 @@
-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";
+import { debug, startSpan, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SPAN_STATUS_ERROR, captureException, flushIfServerless, addBreadcrumb } 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) {
+function createDatabasePlugin(useDatabase, databaseConfig) {
   try {
     const databaseInstances = Object.keys(databaseConfig);
     debug.log("[Nitro Database Plugin]: Instrumenting databases...");
@@ -145,3 +137,5 @@ function createStartSpanOptions(query, data) {
     }
   };
 }
+
+export { createDatabasePlugin };

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

@@ -1,17 +1,7 @@
-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 { debug, startSpan, SPAN_STATUS_OK, SEMANTIC_ATTRIBUTE_CACHE_HIT, SPAN_STATUS_ERROR, captureException, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, flushIfServerless, SEMANTIC_ATTRIBUTE_CACHE_KEY, SEMANTIC_ATTRIBUTE_SENTRY_OP, isObjectLike } from '@sentry/core';
+
 const CACHE_HIT_METHODS = /* @__PURE__ */ new Set(["hasItem", "getItem", "getItemRaw"]);
-export async function createStoragePlugin(useStorage, userStorageMounts) {
+async function createStoragePlugin(useStorage, userStorageMounts) {
   const storage = useStorage();
   const userMounts = new Set(userStorageMounts.map((m) => `${m}:`));
   debug.log("[storage] Starting to instrument storage drivers...");
@@ -99,9 +89,6 @@ function wrapStorageMount(storage) {
 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 = {
@@ -127,15 +114,15 @@ function normalizeKey(key, prefix) {
   if (typeof key === "string") {
     return `${prefix}${key}`;
   }
-  if (typeof key === "object" && key !== null && "key" in key) {
+  if (isObjectLike(key) && "key" in key) {
     return `${prefix}${key.key}`;
   }
-  return `${prefix}${isEmptyValue(key) ? "" : String(key)}`;
+  return `${prefix}${key == null ? "" : String(key)}`;
 }
 const CACHED_FN_HANDLERS_RE = /^nitro:(functions|handlers):/i;
 function isCacheHit(key, value) {
   try {
-    const isEmpty = isEmptyValue(value);
+    const isEmpty = value == null;
     if (isEmpty || typeof key !== "string" || !CACHED_FN_HANDLERS_RE.test(key)) {
       return !isEmpty;
     }
@@ -145,13 +132,13 @@ function isCacheHit(key, value) {
   }
 }
 function validateCacheEntry(key, entry) {
-  if (isEmptyValue(entry.value)) {
+  if (entry.value == null) {
     return false;
   }
   if (Date.now() > (entry.expires || 0)) {
     return false;
   }
-  if (isResponseCacheEntry(key, entry)) {
+  if (isResponseCacheEntry(key)) {
     if ((entry.value.status ?? 0) >= 400) {
       return false;
     }
@@ -167,3 +154,5 @@ function validateCacheEntry(key, entry) {
 function isResponseCacheEntry(key, _) {
   return key.startsWith("nitro:handlers:");
 }
+
+export { createStoragePlugin };

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

@@ -1,11 +1,6 @@
-import {
-  debug,
-  flushIfServerless,
-  getDefaultIsolationScope,
-  getIsolationScope,
-  withIsolationScope
-} from "@sentry/core";
-export function patchEventHandler(handler) {
+import { getIsolationScope, getDefaultIsolationScope, debug, withIsolationScope, flushIfServerless } from '@sentry/core';
+
+function patchEventHandler(handler) {
   return new Proxy(handler, {
     async apply(handlerTarget, handlerThisArg, handlerArgs) {
       const isolationScope = getIsolationScope();
@@ -23,3 +18,5 @@ export function patchEventHandler(handler) {
     }
   });
 }
+
+export { patchEventHandler };

package/build/module/runtime/utils/route-extraction.js

@@ -1,6 +1,7 @@
-import { debug } from "@sentry/core";
+import { debug } from '@sentry/core';
+
 const extractionResultCache = /* @__PURE__ */ new Map();
-export function extractParametrizedRouteFromContext(ssrContextModules, requestedUrl, buildTimePagesData = []) {
+function extractParametrizedRouteFromContext(ssrContextModules, requestedUrl, buildTimePagesData = []) {
   if (!ssrContextModules || !requestedUrl) {
     return null;
   }
@@ -35,3 +36,5 @@ export function extractParametrizedRouteFromContext(ssrContextModules, requested
   extractionResultCache.set(cacheKey, null);
   return null;
 }
+
+export { extractParametrizedRouteFromContext };

package/build/module/runtime/utils.js

@@ -1,5 +1,6 @@
-import { captureException, debug, getClient, getTraceMetaTags } from "@sentry/core";
-export function extractErrorContext(errorContext) {
+import { getClient, captureException, getTraceMetaTags, debug } from '@sentry/core';
+
+function extractErrorContext(errorContext) {
   const ctx = {};
   if (!errorContext) {
     return ctx;
@@ -13,7 +14,7 @@ export function extractErrorContext(errorContext) {
   }
   return ctx;
 }
-export function addSentryTracingMetaTags(head, traceData) {
+function addSentryTracingMetaTags(head, traceData) {
   const metaTags = getTraceMetaTags(traceData);
   if (head.some((tag) => tag.includes("meta") && tag.includes("sentry-trace"))) {
     debug.warn(
@@ -26,7 +27,7 @@ export function addSentryTracingMetaTags(head, traceData) {
     head.push(metaTags);
   }
 }
-export function reportNuxtError(options) {
+function reportNuxtError(options) {
   const { error, instance, info } = options;
   const metadata = {
     info
@@ -46,3 +47,5 @@ export function reportNuxtError(options) {
     });
   });
 }
+
+export { addSentryTracingMetaTags, extractErrorContext, reportNuxtError };

package/build/module/vendor/server-template.d.ts

@@ -0,0 +1,7 @@
+import type { NuxtTemplate } from '@nuxt/schema';
+/**
+ * Adds a virtual file that can be used within the Nuxt Nitro server build.
+ * Available in NuxtKit v4, so we are porting it here.
+ * https://github.com/nuxt/nuxt/blob/d6df732eec1a3bd442bdb325b0335beb7e10cd64/packages/kit/src/template.ts#L55-L62
+ */
+export declare function addServerTemplate(template: NuxtTemplate): NuxtTemplate;

package/build/module/vite/addServerConfig.d.ts

@@ -0,0 +1,22 @@
+import type { Nitro } from 'nitropack';
+import type { SentryNuxtModuleOptions } from '../common/types';
+/**
+ *  Adds the `sentry.server.config.ts` file as `sentry.server.config.mjs` to the `.output` directory to be able to reference this file in the node --import option.
+ *
+ *  By adding a Rollup plugin to the Nitro Rollup options, the Sentry server config is transpiled and emitted to the server build.
+ */
+export declare function addServerConfigToBuild(moduleOptions: SentryNuxtModuleOptions, nitro: Nitro, serverConfigFile: string): void;
+/**
+ *  Adds the Sentry server config import at the top of the server entry file to load the SDK on the server.
+ *  This is necessary for environments where modifying the node option `--import` is not possible.
+ *  However, only limited tracing instrumentation is supported when doing this.
+ */
+export declare function addSentryTopImport(moduleOptions: SentryNuxtModuleOptions, nitro: Nitro): void;
+/**
+ * This function modifies the Rollup configuration to include a plugin that wraps the entry file with a dynamic import (`import()`)
+ * and adds the Sentry server config with the static `import` declaration.
+ *
+ * With this, the Sentry server config can be loaded before all other modules of the application (which is needed for import-in-the-middle).
+ * See: https://nodejs.org/api/module.html#enabling
+ */
+export declare function addDynamicImportEntryFileWrapper(nitro: Nitro, serverConfigFile: string, moduleOptions: Omit<SentryNuxtModuleOptions, 'experimental_entrypointWrappedFunctions'> & Required<Pick<SentryNuxtModuleOptions, 'experimental_entrypointWrappedFunctions'>>): void;

package/build/module/vite/databaseConfig.d.ts

@@ -0,0 +1,6 @@
+import type { NitroConfig } from 'nitropack/types';
+import type { SentryNuxtModuleOptions } from '../common/types';
+/**
+ * Sets up the database instrumentation.
+ */
+export declare function addDatabaseInstrumentation(nitro: NitroConfig, isLegacyNitro: boolean, moduleOptions?: SentryNuxtModuleOptions): void;

package/build/module/vite/middlewareConfig.d.ts

@@ -0,0 +1,11 @@
+import type { Nitro } from 'nitropack/types';
+/**
+ * Adds a server import for the middleware instrumentation.
+ */
+export declare function addMiddlewareImports(): void;
+/**
+ * Adds middleware instrumentation to the Nitro build.
+ *
+ * @param nitro Nitro instance
+ */
+export declare function addMiddlewareInstrumentation(nitro: Nitro): void;

package/build/module/vite/sentryVitePlugin.d.ts

@@ -0,0 +1,11 @@
+import type { Nuxt } from '@nuxt/schema';
+import type { Plugin } from 'vite';
+import type { SentryNuxtModuleOptions } from '../common/types';
+/**
+ * Creates a Vite plugin that adds the Sentry Vite plugin and validates source map settings.
+ */
+export declare function validateSourceMapsOptionsPlugin(options: {
+    nuxt: Nuxt;
+    moduleOptions: SentryNuxtModuleOptions;
+    sourceMapsEnabled: boolean;
+}): Plugin;

package/build/module/vite/sourceMaps.d.ts

@@ -0,0 +1,66 @@
+import type { Nuxt } from '@nuxt/schema';
+import { type SentryRollupPluginOptions } from '@sentry/rollup-plugin';
+import { type SentryVitePluginOptions } from '@sentry/vite-plugin';
+import type { NitroConfig } from 'nitropack';
+import type { Plugin } from 'vite';
+import type { SentryNuxtModuleOptions } from '../common/types';
+/**
+ * Whether the user enabled (true, 'hidden', 'inline') or disabled (false) source maps
+ */
+export type UserSourceMapSetting = 'enabled' | 'disabled' | 'unset' | undefined;
+/** A valid source map setting */
+export type SourceMapSetting = boolean | 'hidden' | 'inline';
+/**
+ *  Setup source maps for Sentry inside the Nuxt module during build time (in Vite for Nuxt and Rollup for Nitro).
+ */
+export declare function setupSourceMaps(moduleOptions: SentryNuxtModuleOptions, nuxt: Nuxt, addVitePlugin: (plugin: Plugin[], options?: {
+    dev?: boolean;
+    build?: boolean;
+}) => void): void;
+/**
+ *  Generates source maps upload options for the Sentry Vite and Rollup plugin.
+ *
+ *  Only exported for Testing purposes.
+ */
+export declare function getPluginOptions(moduleOptions: SentryNuxtModuleOptions, shouldDeleteFilesFallback?: {
+    client: boolean;
+    server: boolean;
+}): SentryVitePluginOptions | SentryRollupPluginOptions;
+/** only exported for tests */
+export declare function extractNuxtSourceMapSetting(nuxt: {
+    options: {
+        sourcemap?: SourceMapSetting | {
+            server?: SourceMapSetting;
+            client?: SourceMapSetting;
+        };
+    };
+}, runtime: 'client' | 'server' | undefined): SourceMapSetting | undefined;
+/** only exported for testing  */
+export declare function changeNuxtSourceMapSettings(nuxt: Nuxt, sentryModuleOptions: SentryNuxtModuleOptions): {
+    client: UserSourceMapSetting;
+    server: UserSourceMapSetting;
+};
+/** Logs warnings about potentially conflicting source map settings.
+ *  Configures `sourcemapExcludeSources` in Nitro to make source maps usable in Sentry.
+ *
+ * only exported for testing
+ */
+export declare function validateNitroSourceMapSettings(nuxt: {
+    options: {
+        sourcemap?: SourceMapSetting | {
+            server?: SourceMapSetting;
+        };
+    };
+}, nitroConfig: NitroConfig, sentryModuleOptions: SentryNuxtModuleOptions): void;
+/**
+ * Validates that source map settings are consistent between Nuxt and Vite/Nitro configurations.
+ * Logs a warning if conflicting settings are detected.
+ *
+ * @internal Only exported for testing.
+ */
+export declare function validateDifferentSourceMapSettings({ nuxtSettingKey, nuxtSettingValue, otherSettingKey, otherSettingValue, }: {
+    nuxtSettingKey: string;
+    nuxtSettingValue?: SourceMapSetting;
+    otherSettingKey: string;
+    otherSettingValue?: SourceMapSetting;
+}): void;

package/build/module/vite/storageConfig.d.ts

@@ -0,0 +1,5 @@
+import type { Nuxt } from '@nuxt/schema';
+/**
+ * Prepares the storage config export to be used in the runtime storage instrumentation.
+ */
+export declare function addStorageInstrumentation(nuxt: Nuxt, isLegacyNitro: boolean): void;

package/build/module/vite/utils.d.ts

@@ -0,0 +1,58 @@
+import type { Nuxt } from '@nuxt/schema';
+import type { SentryNuxtModuleOptions } from '../common/types';
+/**
+ * Gets the major version of the installed nitro package.
+ * Returns 2 as the default if nitro is not found or the version cannot be determined.
+ */
+export declare function getNitroMajorVersion(): Promise<number>;
+/**
+ *  Find the default SDK init file for the given type (client or server).
+ *  The sentry.server.config file is prioritized over the instrument.server file.
+ */
+export declare function findDefaultSdkInitFile(type: 'server' | 'client', nuxt?: Nuxt, options?: SentryNuxtModuleOptions): Promise<string | undefined>;
+/**
+ *  Extracts the filename from a node command with a path.
+ */
+export declare function getFilenameFromNodeStartCommand(nodeCommand: string): string | null;
+export declare const SENTRY_WRAPPED_ENTRY = "?sentry-query-wrapped-entry";
+export declare const SENTRY_WRAPPED_FUNCTIONS = "?sentry-query-wrapped-functions=";
+export declare const SENTRY_REEXPORTED_FUNCTIONS = "?sentry-query-reexported-functions=";
+export declare const QUERY_END_INDICATOR = "SENTRY-QUERY-END";
+/**
+ * Strips the Sentry query part from a path.
+ * Example: example/path?sentry-query-wrapped-entry?sentry-query-functions-reexport=foo,SENTRY-QUERY-END -> /example/path
+ *
+ * Only exported for testing.
+ */
+export declare function removeSentryQueryFromPath(url: string): string;
+/**
+ * Extracts and sanitizes function re-export and function wrap query parameters from a query string.
+ * If it is a default export, it is not considered for re-exporting.
+ *
+ * Only exported for testing.
+ */
+export declare function extractFunctionReexportQueryParameters(query: string): {
+    wrap: string[];
+    reexport: string[];
+};
+/**
+ *  Constructs a comma-separated string with all functions that need to be re-exported later from the server entry.
+ *  It uses Rollup's `exportedBindings` to determine the functions to re-export. Functions which should be wrapped
+ *  (e.g. serverless handlers) are wrapped by Sentry.
+ */
+export declare function constructWrappedFunctionExportQuery(exportedBindings: Record<string, string[]> | null, entrypointWrappedFunctions: string[], debug?: boolean): string;
+/**
+ * Constructs a code snippet with function reexports (can be used in Rollup plugins as a return value for `load()`)
+ */
+export declare function constructFunctionReExport(pathWithQuery: string, entryId: string): string;
+/**
+ * Sets up alias to work around OpenTelemetry's incomplete ESM imports.
+ * https://github.com/getsentry/sentry-javascript/issues/15204
+ *
+ * OpenTelemetry's @opentelemetry/resources package has incomplete imports missing
+ * the .js file extensions (like execAsync for machine-id detection). This causes module resolution
+ * errors in certain Nuxt configurations, particularly when local Nuxt modules in Nuxt 4 are present.
+ *
+ * @see https://nuxt.com/docs/guide/concepts/esm#aliasing-libraries
+ */
+export declare function addOTelCommonJSImportAlias(nuxt: Nuxt, isNitroV3?: boolean): void;

package/build/types/runtime/utils/instrumentStorage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentStorage.d.ts","sourceRoot":"","sources":["../../../../src/runtime/utils/instrumentStorage.ts"],"names":[],"mappings":"AAwDA;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,UAAU,EAAE,MAAM,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA6B/G"}
+{"version":3,"file":"instrumentStorage.d.ts","sourceRoot":"","sources":["../../../../src/runtime/utils/instrumentStorage.ts"],"names":[],"mappings":"AAyDA;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,UAAU,EAAE,MAAM,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA6B/G"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/nuxt",
-  "version": "10.64.0",
+  "version": "10.66.0",
   "description": "Official Sentry SDK for Nuxt",
   "repository": "git://github.com/getsentry/sentry-javascript.git",
   "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/nuxt",
@@ -33,8 +33,7 @@
     },
     "./module": {
       "types": "./build/module/types.d.ts",
-      "import": "./build/module/module.mjs",
-      "require": "./build/module/module.cjs"
+      "import": "./build/module/module.mjs"
     },
     "./module/plugins": {
       "types": "./build/module/runtime/plugins/index.d.ts",
@@ -55,18 +54,17 @@
   },
   "dependencies": {
     "@nuxt/kit": "^3.13.2",
-    "@sentry/browser": "10.64.0",
-    "@sentry/cloudflare": "10.64.0",
-    "@sentry/core": "10.64.0",
-    "@sentry/node": "10.64.0",
-    "@sentry/node-core": "10.64.0",
+    "@sentry/browser": "10.66.0",
+    "@sentry/cloudflare": "10.66.0",
+    "@sentry/core": "10.66.0",
+    "@sentry/node": "10.66.0",
+    "@sentry/node-core": "10.66.0",
     "@sentry/rollup-plugin": "^5.3.0",
     "@sentry/vite-plugin": "^5.3.0",
-    "@sentry/vue": "10.64.0",
+    "@sentry/vue": "10.66.0",
     "local-pkg": "^1.1.2"
   },
   "devDependencies": {
-    "@nuxt/module-builder": "^0.8.4",
     "@nuxt/nitro-server": "^3.21.6",
     "nitro": "^3.0.260311-beta",
     "nuxi": "^3.25.1",
@@ -76,7 +74,7 @@
   "scripts": {
     "build": "run-s build:types build:transpile",
     "build:dev": "yarn build",
-    "build:nuxt-module": "bash ./generate-build-stubs.bash && nuxt-module-build build --outDir build/module",
+    "build:nuxt-module": "rollup -c rollup.module.config.mjs && tsc -p tsconfig.module.json && node scripts/build-module-meta.mjs",
     "build:transpile": "rollup -c rollup.npm.config.mjs && yarn build:nuxt-module",
     "build:types": "tsc -p tsconfig.types.json",
     "build:watch": "run-p build:transpile:watch",
@@ -87,7 +85,7 @@
     "clean": "rimraf build coverage sentry-nuxt-*.tgz",
     "lint:fix": "OXLINT_TSGOLINT_DANGEROUSLY_SUPPRESS_PROGRAM_DIAGNOSTICS=true oxlint . --fix --type-aware",
     "lint": "OXLINT_TSGOLINT_DANGEROUSLY_SUPPRESS_PROGRAM_DIAGNOSTICS=true oxlint . --type-aware",
-    "lint:es-compatibility": "es-check es2020 ./build/cjs/*.js && es-check es2020 ./build/esm/*.js --module && es-check es2020 ./build/module/*.cjs && es-check es2020 ./build/module/*.mjs --module",
+    "lint:es-compatibility": "es-check es2020 ./build/cjs/*.js && es-check es2020 ./build/esm/*.js --module && es-check es2020 ./build/module/*.mjs --module",
     "test": "yarn test:unit",
     "test:unit": "vitest run",
     "test:watch": "vitest --watch",

package/build/module/module.cjs

@@ -1,5 +0,0 @@
-module.exports = function(...args) {
-  return import('./module.mjs').then(m => m.default.call(this, ...args))
-}
-const _meta = module.exports.meta = require('./module.json')
-module.exports.getMeta = () => Promise.resolve(_meta)

package/build/module/types.d.mts

@@ -1 +0,0 @@
-export { type ModuleOptions, default } from './module.js'