@nuxt/scripts 1.0.0-beta.7 → 1.0.0-rc.10

package/dist/module.mjs

@@ -1,88 +1,45 @@
-import { useNuxt, extendViteConfig, useLogger, addDevServerHandler, extendRouteRules, tryUseNuxt, logger as logger$1, addTypeTemplate, defineNuxtModule, createResolver, hasNuxtModule, addImports, addComponentsDir, addTemplate, addPluginTemplate, addServerHandler, addBuildPlugin } from '@nuxt/kit';
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join, resolve, relative } from 'pathe';
+import { createHash, randomBytes } from 'node:crypto';
+import { existsSync, readFileSync, appendFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { useNuxt, addDevServerHandler, extendRouteRules, tryUseNuxt, createResolver, extendViteConfig, logger as logger$1, useLogger, addTypeTemplate, defineNuxtModule, addPluginTemplate, addServerHandler, addImports, addComponentsDir, addTemplate, hasNuxtModule, addBuildPlugin, addPlugin } from '@nuxt/kit';
 import { defu } from 'defu';
+import { join, resolve } from 'pathe';
 import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
-import { addCustomTab } from '@nuxt/devtools-kit';
-import { createHash } from 'node:crypto';
-import fsp from 'node:fs/promises';
-import { createUnplugin } from 'unplugin';
-import MagicString from 'magic-string';
-import { parseAndWalk } from 'oxc-walker';
-import { joinURL, parseURL, parseQuery, hasProtocol } from 'ufo';
-import { hash } from 'ohash';
-import { colors } from 'consola/utils';
-import { fetch, $fetch } from 'ofetch';
 import { lazyEventHandler, eventHandler, createError } from 'h3';
+import { fetch, $fetch } from 'ofetch';
+import { joinURL, parseURL, parseQuery, hasProtocol } from 'ufo';
 import { createStorage } from 'unstorage';
 import fsDriver from 'unstorage/drivers/fs-lite';
-import { pathToFileURL } from 'node:url';
 import { isCI, provider } from 'std-env';
-import { registry } from './registry.mjs';
-
-const DEVTOOLS_UI_ROUTE = "/__nuxt-scripts";
-const DEVTOOLS_UI_LOCAL_PORT = 3300;
-
-async function setupDevToolsUI(options, resolve, nuxt = useNuxt()) {
-  const clientPath = await resolve("./client");
-  const isProductionBuild = existsSync(clientPath);
-  if (isProductionBuild) {
-    nuxt.hook("vite:serverCreated", async (server) => {
-      const sirv = await import('sirv').then((r) => r.default || r);
-      server.middlewares.use(
-        DEVTOOLS_UI_ROUTE,
-        sirv(clientPath, { dev: true, single: true })
-      );
-    });
-  } else {
-    extendViteConfig((config) => {
-      config.server = config.server || {};
-      config.server.proxy = config.server.proxy || {};
-      config.server.proxy[DEVTOOLS_UI_ROUTE] = {
-        target: `http://localhost:${DEVTOOLS_UI_LOCAL_PORT}${DEVTOOLS_UI_ROUTE}`,
-        changeOrigin: true,
-        followRedirects: true,
-        rewrite: (path) => path.replace(DEVTOOLS_UI_ROUTE, "")
-      };
-    });
-  }
-  addCustomTab({
-    // unique identifier
-    name: "nuxt-scripts",
-    // title to display in the tab
-    title: "Scripts",
-    // any icon from Iconify, or a URL to an image
-    icon: "carbon:script",
-    // iframe view
-    view: {
-      type: "iframe",
-      src: DEVTOOLS_UI_ROUTE
-    }
-  });
-}
-
-const logger = useLogger("@nuxt/scripts");
+import { parseAndWalk, ScopeTracker, walk, ScopeTrackerFunction, ScopeTrackerIdentifier, ScopeTrackerFunctionParam, ScopeTrackerVariable } from 'oxc-walker';
+import { createUnplugin } from 'unplugin';
+import { pathToFileURL } from 'node:url';
+import fsp from 'node:fs/promises';
+import { colors } from 'consola/utils';
+import MagicString from 'magic-string';
+import { hash } from 'ohash';
+import { getBundleResolve, registry, resolveCapabilities, getPartytownForwards, buildProxyConfigsFromRegistry, generatePartytownResolveUrl } from './registry.mjs';
+import '../dist/runtime/registry/schemas.js';
 
 const renderedScript = /* @__PURE__ */ new Map();
 const ONE_YEAR_IN_SECONDS = 60 * 60 * 24 * 365;
-const bundleStorage = () => {
+function bundleStorage() {
   const nuxt = tryUseNuxt();
   return createStorage({
     driver: fsDriver({
       base: resolve(nuxt?.options.rootDir || "", "node_modules/.cache/nuxt/scripts")
     })
   });
-};
-function setupPublicAssetStrategy(options = {}) {
-  const assetsBaseURL = options.prefix || "/_scripts";
+}
+function setupPublicAssetStrategy(assetsBaseURL) {
   const nuxt = useNuxt();
   const storage = bundleStorage();
   addDevServerHandler({
     route: assetsBaseURL,
     handler: lazyEventHandler(async () => {
       return eventHandler(async (event) => {
-        const filename = event.path.slice(1);
-        const scriptDescriptor = renderedScript.get(join(assetsBaseURL, event.path.slice(1)));
+        const cleanPath = (event.path || "").split("?")[0]?.slice(1) || "";
+        const filename = cleanPath;
+        const scriptDescriptor = renderedScript.get(join(assetsBaseURL, cleanPath));
         if (!scriptDescriptor || scriptDescriptor instanceof Error)
           throw createError({ statusCode: 404 });
         if (scriptDescriptor.content) {
@@ -122,291 +79,258 @@ function setupPublicAssetStrategy(options = {}) {
   };
 }
 
-function buildProxyConfig(collectPrefix) {
-  return {
-    googleAnalytics: {
-      // GA4: screen/timezone/UA needed for device, time, and OS reports; rest anonymized safely
-      privacy: { ip: true, userAgent: false, language: true, screen: false, timezone: false, hardware: true },
-      rewrite: [
-        // Modern gtag.js uses www.google.com/g/collect
-        { from: "www.google.com/g/collect", to: `${collectPrefix}/ga/g/collect` },
-        // Older gtag.js constructs URLs dynamically: "https://"+(subdomain)+".google-analytics.com/g/collect"
-        // We need to catch the suffix pattern with leading dot
-        { from: ".google-analytics.com/g/collect", to: `${collectPrefix}/ga/g/collect` },
-        { from: ".analytics.google.com/g/collect", to: `${collectPrefix}/ga/g/collect` },
-        // Full domain patterns for static URLs
-        { from: "www.google-analytics.com/g/collect", to: `${collectPrefix}/ga/g/collect` },
-        { from: "analytics.google.com/g/collect", to: `${collectPrefix}/ga/g/collect` },
-        // Legacy endpoints still used by some scripts
-        { from: "www.google-analytics.com", to: `${collectPrefix}/ga` },
-        { from: "analytics.google.com", to: `${collectPrefix}/ga` },
-        // DoubleClick tracking (used by GA4 for ads/conversions)
-        { from: "stats.g.doubleclick.net/g/collect", to: `${collectPrefix}/ga/g/collect` },
-        { from: "stats.g.doubleclick.net", to: `${collectPrefix}/ga-dc` },
-        // Google Ads/Syndication tracking
-        { from: "pagead2.googlesyndication.com", to: `${collectPrefix}/ga-syn` },
-        { from: "www.googleadservices.com", to: `${collectPrefix}/ga-ads` },
-        { from: "googleads.g.doubleclick.net", to: `${collectPrefix}/ga-gads` }
-      ],
-      routes: {
-        [`${collectPrefix}/ga/**`]: { proxy: "https://www.google-analytics.com/**" },
-        [`${collectPrefix}/ga-dc/**`]: { proxy: "https://stats.g.doubleclick.net/**" },
-        [`${collectPrefix}/ga-syn/**`]: { proxy: "https://pagead2.googlesyndication.com/**" },
-        [`${collectPrefix}/ga-ads/**`]: { proxy: "https://www.googleadservices.com/**" },
-        [`${collectPrefix}/ga-gads/**`]: { proxy: "https://googleads.g.doubleclick.net/**" }
-      }
-    },
-    googleTagManager: {
-      // GTM: container only, passes data through — downstream tags have their own privacy
-      privacy: { ip: false, userAgent: false, language: false, screen: false, timezone: false, hardware: false },
-      rewrite: [
-        { from: "www.googletagmanager.com", to: `${collectPrefix}/gtm` }
-      ],
-      routes: {
-        [`${collectPrefix}/gtm/**`]: { proxy: "https://www.googletagmanager.com/**" }
-      }
-    },
-    metaPixel: {
-      // Meta: untrusted ad network — full anonymization
-      privacy: { ip: true, userAgent: true, language: true, screen: true, timezone: true, hardware: true },
-      rewrite: [
-        // SDK script loading
-        { from: "connect.facebook.net", to: `${collectPrefix}/meta` },
-        // Tracking pixel endpoint (www and non-www)
-        { from: "www.facebook.com/tr", to: `${collectPrefix}/meta-tr` },
-        { from: "facebook.com/tr", to: `${collectPrefix}/meta-tr` },
-        // Additional Meta tracking domains
-        { from: "pixel.facebook.com", to: `${collectPrefix}/meta-px` },
-        { from: "www.facebook.com/plugins", to: `${collectPrefix}/meta-plugins` }
-      ],
-      routes: {
-        [`${collectPrefix}/meta/**`]: { proxy: "https://connect.facebook.net/**" },
-        [`${collectPrefix}/meta-tr/**`]: { proxy: "https://www.facebook.com/tr/**" },
-        [`${collectPrefix}/meta-px/**`]: { proxy: "https://pixel.facebook.com/**" },
-        [`${collectPrefix}/meta-plugins/**`]: { proxy: "https://www.facebook.com/plugins/**" }
-      }
-    },
-    tiktokPixel: {
-      // TikTok: untrusted ad network — full anonymization
-      privacy: { ip: true, userAgent: true, language: true, screen: true, timezone: true, hardware: true },
-      rewrite: [
-        { from: "analytics.tiktok.com", to: `${collectPrefix}/tiktok` }
-      ],
-      routes: {
-        [`${collectPrefix}/tiktok/**`]: { proxy: "https://analytics.tiktok.com/**" }
-      }
-    },
-    segment: {
-      // Segment: trusted data pipeline — needs maximum fidelity for downstream destinations
-      privacy: { ip: false, userAgent: false, language: false, screen: false, timezone: false, hardware: false },
-      rewrite: [
-        { from: "api.segment.io", to: `${collectPrefix}/segment` },
-        { from: "cdn.segment.com", to: `${collectPrefix}/segment-cdn` }
-      ],
-      routes: {
-        [`${collectPrefix}/segment/**`]: { proxy: "https://api.segment.io/**" },
-        [`${collectPrefix}/segment-cdn/**`]: { proxy: "https://cdn.segment.com/**" }
-      }
-    },
-    xPixel: {
-      // X/Twitter: untrusted ad network — full anonymization
-      privacy: { ip: true, userAgent: true, language: true, screen: true, timezone: true, hardware: true },
-      rewrite: [
-        { from: "analytics.twitter.com", to: `${collectPrefix}/x` },
-        { from: "t.co", to: `${collectPrefix}/x-t` }
-      ],
-      routes: {
-        [`${collectPrefix}/x/**`]: { proxy: "https://analytics.twitter.com/**" },
-        [`${collectPrefix}/x-t/**`]: { proxy: "https://t.co/**" }
-      }
-    },
-    snapchatPixel: {
-      // Snapchat: untrusted ad network — full anonymization
-      privacy: { ip: true, userAgent: true, language: true, screen: true, timezone: true, hardware: true },
-      rewrite: [
-        { from: "tr.snapchat.com", to: `${collectPrefix}/snap` }
-      ],
-      routes: {
-        [`${collectPrefix}/snap/**`]: { proxy: "https://tr.snapchat.com/**" }
-      }
-    },
-    redditPixel: {
-      // Reddit: untrusted ad network — full anonymization
-      privacy: { ip: true, userAgent: true, language: true, screen: true, timezone: true, hardware: true },
-      rewrite: [
-        { from: "alb.reddit.com", to: `${collectPrefix}/reddit` },
-        { from: "pixel-config.reddit.com", to: `${collectPrefix}/reddit-cfg` }
-      ],
-      routes: {
-        [`${collectPrefix}/reddit/**`]: { proxy: "https://alb.reddit.com/**" },
-        [`${collectPrefix}/reddit-cfg/**`]: { proxy: "https://pixel-config.reddit.com/**" }
-      }
-    },
-    clarity: {
-      // Clarity: screen/UA/timezone needed for heatmaps and device filtering; rest anonymized
-      privacy: { ip: true, userAgent: false, language: true, screen: false, timezone: false, hardware: true },
-      rewrite: [
-        // Main clarity domain
-        { from: "www.clarity.ms", to: `${collectPrefix}/clarity` },
-        // Script loader (the actual SDK is loaded from here)
-        { from: "scripts.clarity.ms", to: `${collectPrefix}/clarity-scripts` },
-        // Data collection endpoint
-        { from: "d.clarity.ms", to: `${collectPrefix}/clarity-data` },
-        // Event collection endpoint
-        { from: "e.clarity.ms", to: `${collectPrefix}/clarity-events` }
-      ],
-      routes: {
-        [`${collectPrefix}/clarity/**`]: { proxy: "https://www.clarity.ms/**" },
-        [`${collectPrefix}/clarity-scripts/**`]: { proxy: "https://scripts.clarity.ms/**" },
-        [`${collectPrefix}/clarity-data/**`]: { proxy: "https://d.clarity.ms/**" },
-        [`${collectPrefix}/clarity-events/**`]: { proxy: "https://e.clarity.ms/**" }
-      }
-    },
-    posthog: {
-      // No rewrites needed - PostHog uses NPM mode, SDK URLs are set via api_host config
-      // PostHog: needs real IP for GeoIP enrichment + feature flag targeting
-      privacy: { ip: false, userAgent: false, language: false, screen: false, timezone: false, hardware: false },
-      routes: {
-        // US region
-        [`${collectPrefix}/ph/static/**`]: { proxy: "https://us-assets.i.posthog.com/static/**" },
-        [`${collectPrefix}/ph/**`]: { proxy: "https://us.i.posthog.com/**" },
-        // EU region
-        [`${collectPrefix}/ph-eu/static/**`]: { proxy: "https://eu-assets.i.posthog.com/static/**" },
-        [`${collectPrefix}/ph-eu/**`]: { proxy: "https://eu.i.posthog.com/**" }
-      }
-    },
-    hotjar: {
-      // Hotjar: screen/UA/timezone needed for heatmaps and device segmentation; rest anonymized
-      privacy: { ip: true, userAgent: false, language: true, screen: false, timezone: false, hardware: true },
-      rewrite: [
-        // Static assets
-        { from: "static.hotjar.com", to: `${collectPrefix}/hotjar` },
-        // Script loader (bootstrap script loads the main SDK from here)
-        { from: "script.hotjar.com", to: `${collectPrefix}/hotjar-script` },
-        // Configuration/variables
-        { from: "vars.hotjar.com", to: `${collectPrefix}/hotjar-vars` },
-        // Data ingestion endpoint
-        { from: "in.hotjar.com", to: `${collectPrefix}/hotjar-in` },
-        // Video capture
-        { from: "vc.hotjar.com", to: `${collectPrefix}/hotjar-vc` },
-        // Metrics/telemetry
-        { from: "metrics.hotjar.io", to: `${collectPrefix}/hotjar-metrics` },
-        // Insights (ContentSquare integration)
-        { from: "insights.hotjar.com", to: `${collectPrefix}/hotjar-insights` }
-      ],
-      routes: {
-        [`${collectPrefix}/hotjar/**`]: { proxy: "https://static.hotjar.com/**" },
-        [`${collectPrefix}/hotjar-script/**`]: { proxy: "https://script.hotjar.com/**" },
-        [`${collectPrefix}/hotjar-vars/**`]: { proxy: "https://vars.hotjar.com/**" },
-        [`${collectPrefix}/hotjar-in/**`]: { proxy: "https://in.hotjar.com/**" },
-        [`${collectPrefix}/hotjar-vc/**`]: { proxy: "https://vc.hotjar.com/**" },
-        [`${collectPrefix}/hotjar-metrics/**`]: { proxy: "https://metrics.hotjar.io/**" },
-        [`${collectPrefix}/hotjar-insights/**`]: { proxy: "https://insights.hotjar.com/**" }
-      }
-    },
-    plausible: {
-      privacy: { ip: false, userAgent: false, language: false, screen: false, timezone: false, hardware: false },
-      rewrite: [
-        { from: "plausible.io", to: `${collectPrefix}/plausible` }
-      ],
-      routes: {
-        [`${collectPrefix}/plausible/**`]: { proxy: "https://plausible.io/**" }
-      }
-    },
-    cloudflareWebAnalytics: {
-      privacy: { ip: false, userAgent: false, language: false, screen: false, timezone: false, hardware: false },
-      rewrite: [
-        { from: "static.cloudflareinsights.com", to: `${collectPrefix}/cfwa` },
-        { from: "cloudflareinsights.com", to: `${collectPrefix}/cfwa-beacon` }
-      ],
-      routes: {
-        [`${collectPrefix}/cfwa/**`]: { proxy: "https://static.cloudflareinsights.com/**" },
-        [`${collectPrefix}/cfwa-beacon/**`]: { proxy: "https://cloudflareinsights.com/**" }
-      }
-    },
-    rybbit: {
-      privacy: { ip: false, userAgent: false, language: false, screen: false, timezone: false, hardware: false },
-      rewrite: [
-        { from: "app.rybbit.io", to: `${collectPrefix}/rybbit` }
-      ],
-      routes: {
-        [`${collectPrefix}/rybbit/**`]: { proxy: "https://app.rybbit.io/**" }
+const DEVTOOLS_UI_ROUTE = "/__nuxt-scripts";
+const DEVTOOLS_UI_LOCAL_PORT = 3030;
+const DEVTOOLS_API_STATE_ROUTE = "/__nuxt-scripts-api/state";
+async function setupDevtools(nuxt, options = {}) {
+  const { addCustomTab } = await import('@nuxt/devtools-kit');
+  const { resolve } = createResolver(import.meta.url);
+  const clientPath = resolve("../dist/devtools-client");
+  const isProductionBuild = existsSync(clientPath);
+  if (isProductionBuild) {
+    nuxt.hook("vite:serverCreated", async (server) => {
+      const sirv = await import('sirv').then((r) => r.default || r);
+      server.middlewares.use(DEVTOOLS_UI_ROUTE, sirv(clientPath, { dev: true, single: true }));
+    });
+  } else {
+    extendViteConfig((config) => {
+      config.server = config.server || {};
+      config.server.proxy = config.server.proxy || {};
+      config.server.proxy[DEVTOOLS_UI_ROUTE] = {
+        target: `http://localhost:${DEVTOOLS_UI_LOCAL_PORT}${DEVTOOLS_UI_ROUTE}`,
+        changeOrigin: true,
+        followRedirects: true,
+        rewrite: (path) => path.replace(DEVTOOLS_UI_ROUTE, "")
+      };
+    });
+  }
+  if (options.standalone) {
+    setupStandaloneApi(nuxt);
+  }
+  addCustomTab({
+    name: "nuxt-scripts",
+    title: "Scripts",
+    icon: "carbon:script",
+    view: {
+      type: "iframe",
+      src: DEVTOOLS_UI_ROUTE
+    }
+  });
+}
+function setupStandaloneApi(nuxt) {
+  let scriptsState = {
+    scripts: {},
+    updatedAt: 0
+  };
+  nuxt.hook("vite:serverCreated", (server) => {
+    server.middlewares.use(DEVTOOLS_API_STATE_ROUTE, (req, res) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      if (req.method === "OPTIONS") {
+        res.statusCode = 204;
+        res.end();
+        return;
       }
-    },
-    umami: {
-      privacy: { ip: false, userAgent: false, language: false, screen: false, timezone: false, hardware: false },
-      rewrite: [
-        { from: "cloud.umami.is", to: `${collectPrefix}/umami` }
-      ],
-      routes: {
-        [`${collectPrefix}/umami/**`]: { proxy: "https://cloud.umami.is/**" }
+      if (req.method === "GET") {
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify(scriptsState));
+        return;
       }
-    },
-    databuddy: {
-      privacy: { ip: false, userAgent: false, language: false, screen: false, timezone: false, hardware: false },
-      rewrite: [
-        { from: "cdn.databuddy.cc", to: `${collectPrefix}/databuddy` },
-        { from: "basket.databuddy.cc", to: `${collectPrefix}/databuddy-api` }
-      ],
-      routes: {
-        [`${collectPrefix}/databuddy/**`]: { proxy: "https://cdn.databuddy.cc/**" },
-        [`${collectPrefix}/databuddy-api/**`]: { proxy: "https://basket.databuddy.cc/**" }
+      if (req.method === "POST") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", () => {
+          try {
+            const data = JSON.parse(body);
+            scriptsState = { ...data, updatedAt: Date.now() };
+            res.statusCode = 200;
+            res.end("ok");
+          } catch {
+            res.statusCode = 400;
+            res.end("invalid json");
+          }
+        });
+        return;
       }
-    },
-    fathom: {
-      privacy: { ip: false, userAgent: false, language: false, screen: false, timezone: false, hardware: false },
-      rewrite: [
-        { from: "cdn.usefathom.com", to: `${collectPrefix}/fathom` }
-      ],
-      routes: {
-        [`${collectPrefix}/fathom/**`]: { proxy: "https://cdn.usefathom.com/**" }
+      res.statusCode = 405;
+      res.end("method not allowed");
+    });
+  });
+}
+function computeDevtoolsPrivacyLevel(privacy) {
+  const flags = Object.values(privacy);
+  if (flags.every(Boolean))
+    return "full";
+  if (flags.some(Boolean))
+    return "partial";
+  return "none";
+}
+function buildDevtoolsEntry(key, script, configKey, proxyConfig) {
+  const privacy = proxyConfig.privacy;
+  const normalizedPrivacy = {
+    ip: !!privacy.ip,
+    userAgent: !!privacy.userAgent,
+    language: !!privacy.language,
+    screen: !!privacy.screen,
+    timezone: !!privacy.timezone,
+    hardware: !!privacy.hardware
+  };
+  const logo = script.logo;
+  const logoStr = typeof logo === "object" ? logo.dark || logo.light : logo || "";
+  return {
+    registryKey: key,
+    label: script.label || key,
+    logo: logoStr,
+    category: script.category || "unknown",
+    configKey,
+    mechanism: script.src === false ? "config-injection-proxy" : "bundle-rewrite-intercept",
+    hasAutoInject: !!proxyConfig.autoInject,
+    autoInjectField: proxyConfig.autoInject?.configField,
+    hasPostProcess: !!proxyConfig.sdkPatches?.length,
+    privacy: normalizedPrivacy,
+    privacyLevel: computeDevtoolsPrivacyLevel(normalizedPrivacy),
+    domains: [...proxyConfig.domains]
+  };
+}
+function buildDevtoolsData(proxyPrefix, privacyLabel, scripts) {
+  const allDomains = /* @__PURE__ */ new Set();
+  for (const s of scripts) {
+    for (const d of s.domains)
+      allDomains.add(d);
+  }
+  return {
+    enabled: true,
+    proxyPrefix,
+    privacyMode: privacyLabel,
+    scripts,
+    totalDomains: allDomains.size
+  };
+}
+
+const isStackblitz = provider === "stackblitz";
+async function promptToInstall(name, installCommand, options) {
+  if (await resolvePackageJSON(name).catch(() => null))
+    return true;
+  logger$1.info(`Package ${name} is missing`);
+  if (isCI)
+    return false;
+  if (options.prompt === true || options.prompt !== false && !isStackblitz) {
+    const confirm = await logger$1.prompt(`Do you want to install ${name} package?`, {
+      type: "confirm",
+      name: "confirm",
+      initial: true
+    });
+    if (!confirm)
+      return false;
+  }
+  logger$1.info(`Installing ${name}...`);
+  try {
+    await installCommand();
+    logger$1.success(`Installed ${name}`);
+    return true;
+  } catch (err) {
+    logger$1.error(err);
+    return false;
+  }
+}
+const installPrompts = /* @__PURE__ */ new Set();
+function installNuxtModule(name, options) {
+  if (installPrompts.has(name))
+    return;
+  installPrompts.add(name);
+  const nuxt = tryUseNuxt();
+  if (!nuxt)
+    return;
+  return promptToInstall(name, async () => {
+    const { runCommand } = await import(String("nuxi"));
+    await runCommand("module", ["add", name, "--cwd", nuxt.options.rootDir]);
+  }, { rootDir: nuxt.options.rootDir, searchPaths: nuxt.options.modulesDir, ...options });
+}
+
+const logger = useLogger("@nuxt/scripts");
+
+const SCRIPT_OPTION_KEYS = ["trigger", "proxy", "bundle", "partytown"];
+function extractRequiredFields(schema) {
+  if (!schema)
+    return [];
+  return Object.entries(schema.entries).filter(([, field]) => field?.type !== "optional").map(([key]) => key);
+}
+function migrateDeprecatedRegistryKeys(registry, warn) {
+  for (const key of Object.keys(registry)) {
+    const entry = registry[key];
+    if (!entry || typeof entry !== "object")
+      continue;
+    if (Array.isArray(entry)) {
+      const opts = entry[1];
+      if (opts && typeof opts === "object" && "reverseProxyIntercept" in opts) {
+        warn(`[nuxt-scripts] registry.${key}: \`reverseProxyIntercept\` has been renamed to \`proxy\`. Please update your config. Auto-migrating for now.`);
+        const o = opts;
+        o.proxy ??= o.reverseProxyIntercept;
+        delete o.reverseProxyIntercept;
       }
-    },
-    intercom: {
-      privacy: { ip: true, userAgent: false, language: false, screen: false, timezone: false, hardware: false },
-      rewrite: [
-        { from: "widget.intercom.io", to: `${collectPrefix}/intercom` },
-        { from: "api-iam.intercom.io", to: `${collectPrefix}/intercom-api` },
-        { from: "api-iam.eu.intercom.io", to: `${collectPrefix}/intercom-api-eu` },
-        { from: "api-iam.au.intercom.io", to: `${collectPrefix}/intercom-api-au` }
-      ],
-      routes: {
-        [`${collectPrefix}/intercom/**`]: { proxy: "https://widget.intercom.io/**" },
-        [`${collectPrefix}/intercom-api/**`]: { proxy: "https://api-iam.intercom.io/**" },
-        [`${collectPrefix}/intercom-api-eu/**`]: { proxy: "https://api-iam.eu.intercom.io/**" },
-        [`${collectPrefix}/intercom-api-au/**`]: { proxy: "https://api-iam.au.intercom.io/**" }
+    } else {
+      const obj = entry;
+      if ("reverseProxyIntercept" in obj) {
+        warn(`[nuxt-scripts] registry.${key}: \`reverseProxyIntercept\` has been renamed to \`proxy\`. Please update your config. Auto-migrating for now.`);
+        obj.proxy ??= obj.reverseProxyIntercept;
+        delete obj.reverseProxyIntercept;
       }
-    },
-    crisp: {
-      privacy: { ip: true, userAgent: false, language: false, screen: false, timezone: false, hardware: false },
-      rewrite: [
-        { from: "client.crisp.chat", to: `${collectPrefix}/crisp` }
-      ],
-      routes: {
-        [`${collectPrefix}/crisp/**`]: { proxy: "https://client.crisp.chat/**" }
+      const so = obj.scriptOptions;
+      if (so && typeof so === "object" && "reverseProxyIntercept" in so) {
+        warn(`[nuxt-scripts] registry.${key}: \`scriptOptions.reverseProxyIntercept\` has been renamed to \`proxy\`. Please update your config. Auto-migrating for now.`);
+        const s = so;
+        s.proxy ??= s.reverseProxyIntercept;
+        delete s.reverseProxyIntercept;
       }
     }
-  };
-}
-function getProxyConfig(key, collectPrefix) {
-  const configs = buildProxyConfig(collectPrefix);
-  return configs[key];
-}
-function getAllProxyConfigs(collectPrefix) {
-  return buildProxyConfig(collectPrefix);
+  }
 }
-function routesToInterceptRules(routes) {
-  const rules = [];
-  for (const [localPath, { proxy }] of Object.entries(routes)) {
-    const match = proxy.match(/^https?:\/\/([^/]+)(\/.*)?\/\*\*$/);
-    if (match?.[1]) {
-      const domain = match[1];
-      const pathPrefix = match[2] || "";
-      const target = localPath.replace(/\/\*\*$/, "");
-      rules.push({ pattern: domain, pathPrefix, target });
+function normalizeRegistryConfig(registry, warn) {
+  for (const key of Object.keys(registry)) {
+    const entry = registry[key];
+    if (!entry) {
+      delete registry[key];
+      continue;
+    }
+    if (entry === true) {
+      warn?.(`[nuxt-scripts] registry.${key}: \`true\` shorthand is deprecated. Use \`{ trigger: 'onNuxtReady' }\` instead.`);
+      registry[key] = [{}, { trigger: "onNuxtReady" }];
+      continue;
+    }
+    if (entry === "proxy-only") {
+      throw new Error(
+        `[nuxt-scripts] registry.${key}: \`'proxy-only'\` is no longer supported. Use \`{}\` instead (infrastructure only is now the default behavior).`
+      );
+    }
+    if (entry === "mock") {
+      registry[key] = [{}, { trigger: "manual", skipValidation: true }];
+    } else if (Array.isArray(entry)) {
+      if (!entry[0] && !entry[1]) {
+        delete registry[key];
+        continue;
+      }
+      if (!entry[0])
+        entry[0] = {};
+    } else if (typeof entry === "object") {
+      const { scriptOptions, ...rest } = entry;
+      const input = {};
+      const mergedScriptOptions = {};
+      if (scriptOptions && typeof scriptOptions === "object")
+        Object.assign(mergedScriptOptions, scriptOptions);
+      for (const [k, v] of Object.entries(rest)) {
+        if (SCRIPT_OPTION_KEYS.includes(k))
+          mergedScriptOptions[k] = v;
+        else
+          input[k] = v;
+      }
+      registry[key] = Object.keys(mergedScriptOptions).length > 0 ? [input, mergedScriptOptions] : [input];
+    } else {
+      delete registry[key];
     }
   }
-  return rules;
 }
 
 function isVue(id, opts = {}) {
@@ -430,12 +354,138 @@ function isVue(id, opts = {}) {
   }
   return true;
 }
-const JS_RE = /\.(?:[cm]?j|t)sx?$/;
+const JS_RE$1 = /\.(?:[cm]?j|t)sx?$/;
 function isJS(id) {
   const { pathname } = parseURL(decodeURIComponent(pathToFileURL(id).href));
-  return JS_RE.test(pathname);
+  return JS_RE$1.test(pathname);
 }
 
+const VUE_RE$1 = /\.vue/;
+function NuxtScriptsCheckScripts() {
+  return createUnplugin(() => {
+    return {
+      name: "nuxt-scripts:check-scripts",
+      transform: {
+        filter: {
+          id: VUE_RE$1
+        },
+        handler(code, id) {
+          if (!isVue(id, { type: ["script"] }))
+            return;
+          if (!code.includes("useScript"))
+            return;
+          let nameNode;
+          let errorNode;
+          parseAndWalk(code, id, (_node) => {
+            if (_node.type === "VariableDeclaration" && _node.declarations?.[0]?.id?.type === "ObjectPattern") {
+              const objPattern = _node.declarations[0]?.id;
+              for (const property of objPattern.properties) {
+                if (property.type === "Property" && property.key.type === "Identifier" && property.key.name === "$script" && property.value.type === "Identifier") {
+                  nameNode = _node;
+                }
+              }
+            }
+            if (nameNode) {
+              let sequence = _node.type === "SequenceExpression" ? _node : null;
+              let assignmentExpression;
+              if (_node.type === "VariableDeclaration") {
+                if (_node.declarations[0]?.init?.type === "SequenceExpression") {
+                  sequence = _node.declarations[0]?.init;
+                  assignmentExpression = _node.declarations[0]?.init?.expressions?.[0];
+                }
+              }
+              if (sequence && !assignmentExpression) {
+                assignmentExpression = sequence.expressions[0]?.type === "AssignmentExpression" ? sequence.expressions[0] : null;
+              }
+              if (assignmentExpression) {
+                const right = assignmentExpression?.right;
+                if (right.callee?.name === "_withAsyncContext") {
+                  if (right.arguments[0]?.body?.name === "$script" || right.arguments[0]?.body?.callee?.object?.name === "$script") {
+                    errorNode = nameNode;
+                  }
+                }
+              }
+            }
+          });
+          if (errorNode) {
+            return this.error(new Error("You can't use a top-level await on $script as it will never resolve."));
+          }
+        }
+      }
+    };
+  });
+}
+
+function generateInterceptPluginContents(proxyPrefix, options) {
+  const testMode = options?.testMode ?? false;
+  return `export default defineNuxtPlugin({
+  name: 'nuxt-scripts:intercept',
+  enforce: 'pre',
+  setup() {
+    const proxyPrefix = ${JSON.stringify(proxyPrefix)};
+    const origBeacon = typeof navigator !== 'undefined' && navigator.sendBeacon
+      ? navigator.sendBeacon.bind(navigator)
+      : () => false;
+    const origFetch = globalThis.fetch.bind(globalThis);
+
+    function proxyUrl(url) {
+      try {
+        const parsed = new URL(url, location.origin);
+        if (parsed.origin !== location.origin)
+          return location.origin + proxyPrefix + '/' + parsed.host + parsed.pathname + parsed.search;
+      } catch {}
+      return url;
+    }
+
+    // XMLHttpRequest wrapper \u2014 intercepts .open() to rewrite URL
+    const OrigXHR = XMLHttpRequest;
+    class ProxiedXHR extends OrigXHR {
+      open() {
+        const args = Array.from(arguments);
+        if (typeof args[1] === 'string') args[1] = proxyUrl(args[1]);
+        return super.open.apply(this, args);
+      }
+    }
+    // Image wrapper \u2014 intercepts .src setter to rewrite URL
+    const OrigImage = Image;
+    const origSrcDesc = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'src');
+    function ProxiedImage(w, h) {
+      const img = arguments.length === 2 ? new OrigImage(w, h)
+        : arguments.length === 1 ? new OrigImage(w) : new OrigImage();
+      if (origSrcDesc && origSrcDesc.set) {
+        Object.defineProperty(img, 'src', {
+          get() { return origSrcDesc.get.call(this); },
+          set(v) { origSrcDesc.set.call(this, typeof v === 'string' ? proxyUrl(v) : v); },
+          configurable: true,
+        });
+      }
+      return img;
+    }
+
+    globalThis.__nuxtScripts = {${testMode ? `
+      // Test mode: replace sendBeacon with fetch for immediate, observable requests
+      sendBeacon: (url, data) => {
+        const proxied = proxyUrl(url);
+        origFetch(proxied, { method: 'POST', body: data, keepalive: true }).catch(() => {});
+        return true;
+      },` : `
+      sendBeacon: (url, data) => origBeacon(proxyUrl(url), data),`}
+      fetch: (url, opts) => {
+        if (typeof url === 'string') return origFetch(proxyUrl(url), opts);
+        if (url instanceof Request) return origFetch(new Request(proxyUrl(url.url), url), opts);
+        return origFetch(url, opts);
+      },
+      XMLHttpRequest: ProxiedXHR,
+      Image: ProxiedImage,
+    };
+  },
+})
+`;
+}
+
+const WORD_OR_DOLLAR_RE = /[\w$]/;
+const PROTOCOL_PREFIX_RE = /^https?:$/;
+const BLANK_CANVAS_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQIHWNgAAIABQABNjN9GQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAAA0lEQVQI12NgYGBgAAAABQABXvMqOgAAAABJRU5ErkJggg==";
 function isPropertyKeyAST(parent, ctx) {
   return parent?.type === "Property" && ctx.key === "key" || parent?.type === "SwitchCase" && ctx.key === "test";
 }
@@ -445,7 +495,8 @@ function matchAndRewrite(value, rewrites) {
     const fromSlashIdx = from.indexOf("/");
     const fromHost = fromSlashIdx > 0 ? from.slice(0, fromSlashIdx) : from;
     const fromPath = fromSlashIdx > 0 ? from.slice(fromSlashIdx) : "";
-    if (!value.includes(fromHost)) continue;
+    if (!value.includes(fromHost))
+      continue;
     const url = parseURL(value);
     let shouldRewrite = false;
     let rewriteSuffix = "";
@@ -488,63 +539,240 @@ function matchAndRewrite(value, rewrites) {
   }
   return null;
 }
-function rewriteScriptUrlsAST(content, filename, rewrites) {
-  const s = new MagicString(content);
-  parseAndWalk(content, filename, function(node, parent, ctx) {
-    if (node.type === "Literal" && typeof node.value === "string") {
-      const value = node.value;
-      const rewritten = matchAndRewrite(value, rewrites);
-      if (rewritten === null) return;
-      const quote = content[node.start];
-      if (isPropertyKeyAST(parent, ctx)) {
-        s.overwrite(node.start, node.end, quote + rewritten + quote);
-      } else {
-        s.overwrite(node.start, node.end, "self.location.origin+" + quote + rewritten + quote);
+const WINDOW_GLOBALS = /* @__PURE__ */ new Set(["window", "self", "globalThis"]);
+const NAVIGATOR_GLOBALS = /* @__PURE__ */ new Set(["navigator"]);
+function resolveToGlobal(name, scopeTracker, depth = 0) {
+  if (depth > 10)
+    return null;
+  const decl = scopeTracker.getDeclaration(name);
+  if (!decl)
+    return name;
+  if (decl instanceof ScopeTrackerFunctionParam)
+    return null;
+  if (decl instanceof ScopeTrackerVariable) {
+    const declarators = decl.variableNode.declarations;
+    if (!declarators)
+      return null;
+    for (const declarator of declarators) {
+      const id = declarator.id;
+      if (!id || id.name !== name)
+        continue;
+      const init = declarator.init;
+      if (!init)
+        return null;
+      if (init.type === "Identifier")
+        return resolveToGlobal(init.name, scopeTracker, depth + 1);
+      if (init.type === "MemberExpression" && init.object?.type === "Identifier") {
+        const memberProp = init.computed ? init.property?.type === "Literal" && typeof init.property.value === "string" ? init.property.value : null : init.property?.type === "Identifier" ? init.property.name : null;
+        if (!memberProp)
+          return null;
+        const objGlobal = resolveToGlobal(init.object.name, scopeTracker, depth + 1);
+        if (!objGlobal)
+          return null;
+        if (WINDOW_GLOBALS.has(objGlobal) || objGlobal === "document")
+          return memberProp;
+        return null;
       }
+      return null;
     }
-    if (node.type === "TemplateLiteral" && node.expressions?.length === 0) {
-      const quasis = node.quasis;
-      if (quasis?.length === 1) {
-        const value = quasis[0].value?.cooked ?? quasis[0].value?.raw;
-        if (typeof value !== "string") return;
+  }
+  return null;
+}
+function resolveCalleeTarget(callee, scopeTracker) {
+  if (callee?.type !== "MemberExpression")
+    return null;
+  const propName = callee.computed ? callee.property?.type === "Literal" && typeof callee.property.value === "string" ? callee.property.value : null : callee.property?.name;
+  if (!propName)
+    return null;
+  const obj = callee.object;
+  if (!obj || obj.type !== "Identifier")
+    return null;
+  const resolved = resolveToGlobal(obj.name, scopeTracker);
+  if (!resolved)
+    return null;
+  if (propName === "fetch" && WINDOW_GLOBALS.has(resolved))
+    return "fetch";
+  if (propName === "sendBeacon" && (NAVIGATOR_GLOBALS.has(resolved) || WINDOW_GLOBALS.has(resolved)))
+    return "sendBeacon";
+  if (propName === "sendBeacon" && resolved === "navigator")
+    return "sendBeacon";
+  if (propName === "XMLHttpRequest" && WINDOW_GLOBALS.has(resolved))
+    return "XMLHttpRequest";
+  if (propName === "Image" && WINDOW_GLOBALS.has(resolved))
+    return "Image";
+  return null;
+}
+function rewriteScriptUrlsAST(content, filename, rewrites, sdkPatches, options) {
+  const s = new MagicString(content);
+  function needsLeadingSpace(start) {
+    const prev = content[start - 1];
+    return prev && WORD_OR_DOLLAR_RE.test(prev) ? " " : "";
+  }
+  const scopeTracker = new ScopeTracker({ preserveExitedScopes: true });
+  const { program } = parseAndWalk(content, filename, { scopeTracker });
+  scopeTracker.freeze();
+  walk(program, {
+    scopeTracker,
+    enter(node, parent, ctx) {
+      if (node.type === "Literal" && typeof node.value === "string") {
+        const value = node.value;
         const rewritten = matchAndRewrite(value, rewrites);
-        if (rewritten === null) return;
+        if (rewritten === null)
+          return;
+        const quote = content[node.start];
         if (isPropertyKeyAST(parent, ctx)) {
-          s.overwrite(node.start, node.end, "`" + rewritten + "`");
+          s.overwrite(node.start, node.end, quote + rewritten + quote);
+        } else if (value.startsWith("//") && parent?.type === "BinaryExpression" && parent.operator === "+") {
+          const sibling = ctx.key === "right" ? parent.left : parent.right;
+          if (sibling?.type === "Literal" && typeof sibling.value === "string" && PROTOCOL_PREFIX_RE.test(sibling.value)) {
+            s.overwrite(parent.start, parent.end, `${needsLeadingSpace(parent.start)}self.location.origin+${quote}${rewritten}${quote}`);
+          } else {
+            s.overwrite(node.start, node.end, `${needsLeadingSpace(node.start)}self.location.origin+${quote}${rewritten}${quote}`);
+          }
         } else {
-          s.overwrite(node.start, node.end, "self.location.origin+`" + rewritten + "`");
+          s.overwrite(node.start, node.end, `${needsLeadingSpace(node.start)}self.location.origin+${quote}${rewritten}${quote}`);
+        }
+      }
+      if (node.type === "TemplateLiteral") {
+        const quasis = node.quasis;
+        const expressions = node.expressions;
+        if (expressions?.length === 0 && quasis?.length === 1) {
+          const value = quasis[0].value?.cooked ?? quasis[0].value?.raw;
+          if (typeof value !== "string")
+            return;
+          const rewritten = matchAndRewrite(value, rewrites);
+          if (rewritten === null)
+            return;
+          if (isPropertyKeyAST(parent, ctx)) {
+            s.overwrite(node.start, node.end, `\`${rewritten}\``);
+          } else {
+            s.overwrite(node.start, node.end, `${needsLeadingSpace(node.start)}self.location.origin+\`${rewritten}\``);
+          }
+        } else if (expressions?.length > 0 && quasis?.length > 0) {
+          const firstQuasi = quasis[0];
+          const value = firstQuasi.value?.cooked ?? firstQuasi.value?.raw;
+          if (typeof value !== "string" || isPropertyKeyAST(parent, ctx))
+            return;
+          const rewritten = matchAndRewrite(value, rewrites);
+          if (rewritten === null)
+            return;
+          s.overwrite(node.start, firstQuasi.end, `${needsLeadingSpace(node.start)}self.location.origin+\`${rewritten}`);
+        }
+      }
+      if (node.type === "CallExpression" && !options?.skipApiRewrites) {
+        const callee = node.callee;
+        const shouldNeutralizeCanvas = options?.neutralizeCanvas !== false;
+        const canvasPropName = shouldNeutralizeCanvas && callee?.type === "MemberExpression" ? callee.computed ? callee.property?.type === "Literal" && typeof callee.property.value === "string" ? callee.property.value : null : callee.property?.name : null;
+        if (canvasPropName === "toDataURL" && callee.object) {
+          const blankCanvas = `"${BLANK_CANVAS_DATA_URL}"`;
+          if (callee.object.type === "Identifier") {
+            const decl = scopeTracker.getDeclaration(callee.object.name);
+            if (decl instanceof ScopeTrackerFunction || decl instanceof ScopeTrackerIdentifier) ; else {
+              s.overwrite(node.start, node.end, blankCanvas);
+              return;
+            }
+          } else {
+            s.overwrite(node.start, node.end, blankCanvas);
+            return;
+          }
+        }
+        if (canvasPropName === "getExtension") {
+          const args = node.arguments;
+          if (args?.length === 1 && args[0]?.type === "Literal" && args[0].value === "WEBGL_debug_renderer_info") {
+            s.overwrite(node.start, node.end, "null");
+            return;
+          }
+        }
+        if (callee?.type === "Identifier" && callee.name === "fetch") {
+          if (!scopeTracker.getDeclaration("fetch"))
+            s.overwrite(callee.start, callee.end, "__nuxtScripts.fetch");
+          return;
+        }
+        const target = resolveCalleeTarget(callee, scopeTracker);
+        if (target === "fetch" || target === "sendBeacon") {
+          s.overwrite(callee.start, callee.end, `__nuxtScripts.${target}`);
+          return;
+        }
+        if (callee?.type === "MemberExpression" && !callee.computed && callee.property?.name === "sendBeacon" && callee.object?.type === "Identifier") {
+          const resolved = resolveToGlobal(callee.object.name, scopeTracker);
+          if (resolved === null) {
+            s.overwrite(callee.start, callee.end, "__nuxtScripts.sendBeacon");
+          }
         }
       }
-    }
-    if (node.type === "CallExpression") {
-      const callee = node.callee;
-      if (callee?.type === "MemberExpression" && !callee.computed && callee.object?.type === "Identifier" && callee.object.name === "navigator" && callee.property?.name === "sendBeacon") {
-        s.overwrite(callee.start, callee.end, "__nuxtScripts.sendBeacon");
+      if (sdkPatches?.some((p) => p.type === "neutralize-domain-check") && node.type === "BinaryExpression" && node.operator === "<") {
+        const left = node.left;
+        const right = node.right;
+        if (right?.type === "Literal" && right.value === 0 && left?.type === "CallExpression" && left.callee?.type === "MemberExpression") {
+          const prop = left.callee.computed ? left.callee.property?.type === "Literal" && typeof left.callee.property.value === "string" ? left.callee.property.value : null : left.callee.property?.name;
+          if (prop === "indexOf" && left.arguments?.length === 1) {
+            const arg = left.arguments[0];
+            if (arg?.type === "Literal" && typeof arg.value === "string" && rewrites.some((r) => arg.value.includes(r.from))) {
+              s.overwrite(right.start, right.end, "-1");
+            }
+          }
+        }
       }
-      if (callee?.type === "Identifier" && callee.name === "fetch") {
-        s.overwrite(callee.start, callee.end, "__nuxtScripts.fetch");
+      if (sdkPatches?.some((p) => p.type === "replace-src-split") && node.type === "MemberExpression" && node.computed) {
+        const prop = node.property;
+        const obj = node.object;
+        if (prop?.type === "Literal" && prop.value === 0 && obj?.type === "CallExpression" && obj.callee?.type === "MemberExpression") {
+          const callProp = obj.callee.computed ? obj.callee.property?.type === "Literal" && typeof obj.callee.property.value === "string" ? obj.callee.property.value : null : obj.callee.property?.name;
+          if (callProp === "split" && obj.arguments?.length === 1) {
+            const arg = obj.arguments[0];
+            if (arg?.type === "Literal" && typeof arg.value === "string") {
+              for (const patch of sdkPatches) {
+                if (patch.type !== "replace-src-split" || patch.separator !== arg.value)
+                  continue;
+                const rewrite = rewrites.find((r) => r.from === patch.fromDomain);
+                if (!rewrite)
+                  continue;
+                const proxyPath = patch.appendPath ? `${rewrite.to}/${patch.appendPath}` : rewrite.to;
+                s.overwrite(node.start, node.end, `${needsLeadingSpace(node.start)}self.location.origin+"${proxyPath}"`);
+              }
+            }
+          }
+        }
       }
-      if (callee?.type === "MemberExpression" && !callee.computed && callee.object?.type === "Identifier" && (callee.object.name === "window" || callee.object.name === "self" || callee.object.name === "globalThis") && callee.property?.name === "fetch") {
-        s.overwrite(callee.start, callee.end, "__nuxtScripts.fetch");
+      if (node.type === "NewExpression" && !options?.skipApiRewrites) {
+        const callee = node.callee;
+        if (callee?.type === "Identifier" && callee.name === "XMLHttpRequest") {
+          if (!scopeTracker.getDeclaration("XMLHttpRequest"))
+            s.overwrite(callee.start, callee.end, "__nuxtScripts.XMLHttpRequest");
+          return;
+        }
+        if (callee?.type === "Identifier" && callee.name === "Image") {
+          if (!scopeTracker.getDeclaration("Image"))
+            s.overwrite(callee.start, callee.end, "__nuxtScripts.Image");
+          return;
+        }
+        const target = resolveCalleeTarget(callee, scopeTracker);
+        if (target === "XMLHttpRequest" || target === "Image") {
+          s.overwrite(callee.start, callee.end, `__nuxtScripts.${target}`);
+          return;
+        }
+        if (callee?.type === "MemberExpression" && callee.object?.type === "Identifier") {
+          const propName = callee.computed ? callee.property?.type === "Literal" && typeof callee.property.value === "string" ? callee.property.value : null : callee.property?.name;
+          if (propName === "XMLHttpRequest" || propName === "Image") {
+            const resolved = resolveToGlobal(callee.object.name, scopeTracker);
+            if (resolved === null) {
+              s.overwrite(callee.start, callee.end, `__nuxtScripts.${propName}`);
+            }
+          }
+        }
       }
     }
   });
-  let output = s.toString();
-  const gaRewrite = rewrites.find((r) => r.from.includes("google-analytics.com/g/collect"));
-  if (gaRewrite) {
-    output = output.replace(
-      /"https:\/\/"\+\(.*?\)\+"\.google-analytics\.com\/g\/collect"/g,
-      `self.location.origin+"${gaRewrite.to}"`
-    );
-    output = output.replace(
-      /"https:\/\/"\+\(.*?\)\+"\.analytics\.google\.com\/g\/collect"/g,
-      `self.location.origin+"${gaRewrite.to}"`
-    );
-  }
-  return output;
+  return s.toString();
 }
 
 const SEVEN_DAYS_IN_MS = 7 * 24 * 60 * 60 * 1e3;
+const PROTOCOL_RELATIVE_RE = /^\/\//;
+const VUE_RE = /\.vue/;
+const JS_RE = /\.[cm]?[jt]sx?$/;
+const TEST_RE = /\.(?:test|spec)\./;
+const UPPERCASE_RE = /^[A-Z]$/;
+const USE_SCRIPT_RE = /^useScript/;
 function calculateIntegrity(content, algorithm = "sha384") {
   const hash = createHash(algorithm).update(content).digest("base64");
   return `${algorithm}-${hash}`;
@@ -557,9 +785,9 @@ async function isCacheExpired(storage, filename, cacheMaxAge = SEVEN_DAYS_IN_MS)
   }
   return Date.now() - meta.timestamp > cacheMaxAge;
 }
-function normalizeScriptData(src, assetsBaseURL = "/_scripts") {
+function normalizeScriptData(src, assetsBaseURL = "/_scripts/assets") {
   if (hasProtocol(src, { acceptRelative: true })) {
-    src = src.replace(/^\/\//, "https://");
+    src = src.replace(PROTOCOL_RELATIVE_RE, "https://");
     const url = parseURL(src);
     const h = hash(url);
     const file = `${h.startsWith("-") ? `_${h.slice(1)}` : h}.js`;
@@ -571,7 +799,7 @@ function normalizeScriptData(src, assetsBaseURL = "/_scripts") {
   return { url: src };
 }
 async function downloadScript(opts, renderedScript, fetchOptions, cacheMaxAge) {
-  const { src, url, filename, forceDownload, integrity, proxyRewrites } = opts;
+  const { src, url, filename, forceDownload, integrity, proxyRewrites, sdkPatches, skipApiRewrites, neutralizeCanvas } = opts;
   if (src === url || !filename) {
     return;
   }
@@ -609,7 +837,7 @@ async function downloadScript(opts, renderedScript, fetchOptions, cacheMaxAge) {
     await storage.setItemRaw(`bundle:${filename}`, res);
     if (proxyRewrites?.length && res) {
       const content = res.toString("utf-8");
-      const rewritten = rewriteScriptUrlsAST(content, filename || "script.js", proxyRewrites);
+      const rewritten = rewriteScriptUrlsAST(content, filename || "script.js", proxyRewrites, sdkPatches, { skipApiRewrites, neutralizeCanvas });
       res = Buffer.from(rewritten, "utf-8");
       logger.debug(`Rewrote ${proxyRewrites.length} URL patterns in ${filename}`);
     }
@@ -666,8 +894,8 @@ function NuxtScriptBundleTransformer(options = {
       transform: {
         filter: {
           id: {
-            include: [/\.vue/, /\.[cm]?[jt]sx?$/],
-            exclude: [/\.(?:test|spec)\./]
+            include: [VUE_RE, JS_RE],
+            exclude: [TEST_RE]
           }
         },
         async handler(code, id) {
@@ -677,19 +905,20 @@ function NuxtScriptBundleTransformer(options = {
             return;
           const s = new MagicString(code);
           const deferredOps = [];
-          parseAndWalk(code, id, function(_node) {
+          parseAndWalk(code, id, (_node) => {
             const calleeName = _node.callee?.name;
             if (!calleeName)
               return;
-            const isValidCallee = calleeName === "useScript" || calleeName?.startsWith("useScript") && /^[A-Z]$/.test(calleeName?.charAt(9)) && !calleeName.startsWith("useScriptTrigger") && !calleeName.startsWith("useScriptEvent");
+            const isValidCallee = calleeName === "useScript" || calleeName?.startsWith("useScript") && UPPERCASE_RE.test(calleeName?.charAt(9)) && !calleeName.startsWith("useScriptTrigger") && !calleeName.startsWith("useScriptEvent");
             if (_node.type === "CallExpression" && _node.callee.type === "Identifier" && isValidCallee) {
               const fnName = _node.callee?.name;
               const node = _node;
               let scriptSrcNode;
               let src;
+              let registryConfig = {};
               let registryKey;
               if (fnName !== "useScript") {
-                const baseName = fnName.replace(/^useScript/, "");
+                const baseName = fnName.replace(USE_SCRIPT_RE, "");
                 registryKey = baseName.length > 0 ? baseName.charAt(0).toLowerCase() + baseName.slice(1) : void 0;
               }
               if (fnName === "useScript") {
@@ -706,9 +935,10 @@ function NuxtScriptBundleTransformer(options = {
                 if (!registryNode) {
                   return;
                 }
-                if (!registryNode.scriptBundling && !registryNode.src)
+                const bundleResolve = getBundleResolve(registryNode);
+                if (!bundleResolve && !registryNode.src)
                   return;
-                const registryConfig = options.registryConfig?.[registryKey || ""] || {};
+                registryConfig = options.registryConfig?.[registryKey || ""] || {};
                 const fnArg0 = {};
                 if (node.arguments[0]?.type === "ObjectExpression") {
                   const optionsNode = node.arguments[0];
@@ -725,7 +955,7 @@ function NuxtScriptBundleTransformer(options = {
                 }
                 if (!scriptSrcNode) {
                   const mergedOptions = { ...registryConfig, ...fnArg0 };
-                  src = registryNode.scriptBundling && registryNode.scriptBundling(mergedOptions);
+                  src = bundleResolve && bundleResolve(mergedOptions);
                   if (src === false)
                     return;
                   if (!src && registryNode.src)
@@ -753,14 +983,17 @@ function NuxtScriptBundleTransformer(options = {
               if (scriptSrcNode || src) {
                 src = src || (typeof scriptSrcNode?.value === "string" ? scriptSrcNode?.value : false);
                 if (src) {
-                  let canBundle = options.defaultBundle === true || options.defaultBundle === "force";
-                  let forceDownload = options.defaultBundle === "force";
+                  const registryScript = fnName !== "useScript" ? options.scripts?.find((s2) => s2.import.name === fnName) : void 0;
+                  let canBundle = !!registryScript?.bundle;
+                  let forceDownload = false;
+                  let explicitBundleInCall = false;
                   if (node.arguments[1]?.type === "ObjectExpression") {
                     const scriptOptionsArg = node.arguments[1];
                     const bundleProperty = scriptOptionsArg.properties.find(
                       (p) => (p.key?.name === "bundle" || p.key?.value === "bundle") && p.type === "Property"
                     );
                     if (bundleProperty && bundleProperty.value.type === "Literal") {
+                      explicitBundleInCall = true;
                       const bundleValue = bundleProperty.value.value;
                       if (bundleValue !== true && bundleValue !== "force" && String(bundleValue) !== "true") {
                         canBundle = false;
@@ -785,35 +1018,49 @@ function NuxtScriptBundleTransformer(options = {
                     return prop.type === "Property" && prop.key?.name === "bundle" && prop.value.type === "Literal";
                   });
                   if (bundleOption) {
+                    explicitBundleInCall = true;
                     const bundleValue = bundleOption.value.value;
                     canBundle = bundleValue === true || bundleValue === "force" || String(bundleValue) === "true";
                     forceDownload = bundleValue === "force";
                   }
-                  const firstPartyOption = scriptOptions?.value.properties?.find((prop) => {
-                    return prop.type === "Property" && prop.key?.name === "firstParty" && prop.value.type === "Literal";
+                  if (!explicitBundleInCall && registryConfig?.scriptOptions?.bundle !== void 0) {
+                    const bundleValue = registryConfig.scriptOptions.bundle;
+                    canBundle = bundleValue === true || bundleValue === "force" || String(bundleValue) === "true";
+                    forceDownload = bundleValue === "force";
+                  }
+                  const rpiOption = scriptOptions?.value.properties?.find((prop) => {
+                    return prop.type === "Property" && prop.key?.name === "proxy" && prop.value.type === "Literal";
                   });
-                  let firstPartyOptOut = firstPartyOption?.value.value === false;
+                  let firstPartyOptOut = rpiOption?.value.value === false;
                   if (!firstPartyOptOut && node.arguments[1]?.type === "ObjectExpression") {
-                    const secondArgFirstPartyProp = node.arguments[1].properties.find(
-                      (p) => p.type === "Property" && p.key?.name === "firstParty" && p.value.type === "Literal"
+                    const secondArgProp = node.arguments[1].properties.find(
+                      (p) => p.type === "Property" && p.key?.name === "proxy" && p.value.type === "Literal"
                     );
-                    firstPartyOptOut = secondArgFirstPartyProp?.value.value === false;
+                    firstPartyOptOut = secondArgProp?.value.value === false;
                   }
                   if (!firstPartyOptOut && node.arguments[0]?.type === "ObjectExpression") {
-                    const firstArgFirstPartyProp = node.arguments[0].properties.find(
-                      (p) => p.type === "Property" && p.key?.name === "firstParty" && p.value.type === "Literal"
+                    const firstArgProp = node.arguments[0].properties.find(
+                      (p) => p.type === "Property" && p.key?.name === "proxy" && p.value.type === "Literal"
                     );
-                    firstPartyOptOut = firstArgFirstPartyProp?.value.value === false;
+                    firstPartyOptOut = firstArgProp?.value.value === false;
                   }
                   if (canBundle) {
                     const { url: _url, filename } = normalizeScriptData(src, options.assetsBaseURL);
                     const script = options.scripts?.find((s2) => s2.import.name === fnName);
-                    const proxyConfigKey = script?.proxy !== false ? script?.proxy || registryKey : void 0;
-                    const proxyRewrites = options.firstPartyEnabled && !firstPartyOptOut && proxyConfigKey && options.firstPartyCollectPrefix ? getProxyConfig(proxyConfigKey, options.firstPartyCollectPrefix)?.rewrite : void 0;
+                    const hasReverseProxy = !!script?.proxy;
+                    const proxyConfigKey = hasReverseProxy ? typeof script?.proxy === "string" ? script.proxy : registryKey : void 0;
+                    const proxyConfig = !firstPartyOptOut && proxyConfigKey ? options.proxyConfigs?.[proxyConfigKey] : void 0;
+                    const proxyRewrites = proxyConfig?.domains?.map((domain) => ({
+                      from: domain,
+                      to: `${options.proxyPrefix}/${domain}`
+                    }));
+                    const sdkPatches = proxyConfig?.sdkPatches;
+                    const skipApiRewrites = !!(registryKey && options.partytownScripts?.has(registryKey));
+                    const neutralizeCanvas = proxyConfig?.privacy !== void 0 && typeof proxyConfig.privacy === "object" ? proxyConfig.privacy.hardware ?? true : true;
                     deferredOps.push(async () => {
                       let url = _url;
                       try {
-                        await downloadScript({ src, url, filename, forceDownload, proxyRewrites, integrity: options.integrity }, renderedScript, options.fetchOptions, options.cacheMaxAge);
+                        await downloadScript({ src, url, filename, forceDownload, proxyRewrites, sdkPatches, integrity: options.integrity, skipApiRewrites, neutralizeCanvas }, renderedScript, options.fetchOptions, options.cacheMaxAge);
                       } catch (e) {
                         if (options.fallbackOnSrcOnBundleFail) {
                           logger.warn(`[Nuxt Scripts: Bundle Transformer] Failed to bundle ${src}. Fallback to remote loading.`);
@@ -893,113 +1140,15 @@ function NuxtScriptBundleTransformer(options = {
   });
 }
 
-const isStackblitz = provider === "stackblitz";
-async function promptToInstall(name, installCommand, options) {
-  if (await resolvePackageJSON(name).catch(() => null))
-    return true;
-  logger$1.info(`Package ${name} is missing`);
-  if (isCI)
-    return false;
-  if (options.prompt === true || options.prompt !== false && !isStackblitz) {
-    const confirm = await logger$1.prompt(`Do you want to install ${name} package?`, {
-      type: "confirm",
-      name: "confirm",
-      initial: true
-    });
-    if (!confirm)
-      return false;
-  }
-  logger$1.info(`Installing ${name}...`);
-  try {
-    await installCommand();
-    logger$1.success(`Installed ${name}`);
-    return true;
-  } catch (err) {
-    logger$1.error(err);
-    return false;
-  }
-}
-const installPrompts = /* @__PURE__ */ new Set();
-function installNuxtModule(name, options) {
-  if (installPrompts.has(name))
-    return;
-  installPrompts.add(name);
-  const nuxt = tryUseNuxt();
-  if (!nuxt)
-    return;
-  return promptToInstall(name, async () => {
-    const { runCommand } = await import(String("nuxi"));
-    await runCommand("module", ["add", name, "--cwd", nuxt.options.rootDir]);
-  }, { rootDir: nuxt.options.rootDir, searchPaths: nuxt.options.modulesDir, ...options });
-}
-
-function NuxtScriptsCheckScripts() {
-  return createUnplugin(() => {
-    return {
-      name: "nuxt-scripts:check-scripts",
-      transform: {
-        filter: {
-          id: /\.vue/
-        },
-        handler(code, id) {
-          if (!isVue(id, { type: ["script"] }))
-            return;
-          if (!code.includes("useScript"))
-            return;
-          let nameNode;
-          let errorNode;
-          parseAndWalk(code, id, function(_node) {
-            if (_node.type === "VariableDeclaration" && _node.declarations?.[0]?.id?.type === "ObjectPattern") {
-              const objPattern = _node.declarations[0]?.id;
-              for (const property of objPattern.properties) {
-                if (property.type === "Property" && property.key.type === "Identifier" && property.key.name === "$script" && property.value.type === "Identifier") {
-                  nameNode = _node;
-                }
-              }
-            }
-            if (nameNode) {
-              let sequence = _node.type === "SequenceExpression" ? _node : null;
-              let assignmentExpression;
-              if (_node.type === "VariableDeclaration") {
-                if (_node.declarations[0]?.init?.type === "SequenceExpression") {
-                  sequence = _node.declarations[0]?.init;
-                  assignmentExpression = _node.declarations[0]?.init?.expressions?.[0];
-                }
-              }
-              if (sequence && !assignmentExpression) {
-                assignmentExpression = sequence.expressions[0]?.type === "AssignmentExpression" ? sequence.expressions[0] : null;
-              }
-              if (assignmentExpression) {
-                const right = assignmentExpression?.right;
-                if (right.callee?.name === "_withAsyncContext") {
-                  if (right.arguments[0]?.body?.name === "$script" || right.arguments[0]?.body?.callee?.object?.name === "$script") {
-                    errorNode = nameNode;
-                  }
-                }
-              }
-            }
-          });
-          if (errorNode) {
-            return this.error(new Error("You can't use a top-level await on $script as it will never resolve."));
-          }
-        }
-      }
-    };
-  });
-}
-
-function registerTypeTemplates({ nuxt, config, newScripts }) {
+const TRIGGER_PLACEHOLDER_RE = /"__TRIGGER_PLACEHOLDER__"/g;
+function registerTypeTemplates({ config, newScripts }) {
   addTypeTemplate({
     filename: "types/nuxt-scripts-augments.d.ts",
     getContents: () => {
-      const typesPath = relative(
-        resolve(nuxt.options.rootDir, nuxt.options.buildDir, "types"),
-        resolve("runtime/types")
-      );
       let augments = `// Generated by @nuxt/scripts
 declare module '#app' {
   interface NuxtApp {
-    $scripts: Record<${[...Object.keys(config.globals || {}), ...Object.keys(config.registry || {})].map((k) => `'${k}'`).concat(["string"]).join(" | ")}, import('#nuxt-scripts/types').UseScriptContext<any> | undefined>
+    $scripts: Record<${[...[...Object.keys(config.globals || {}), ...Object.keys(config.registry || {})].map((k) => `'${k}'`), ...["string"]].join(" | ")}, import('#nuxt-scripts/types').UseScriptContext<any> | undefined>
     _scripts: Record<string, import('#nuxt-scripts/types').NuxtDevToolsScriptInstance>
   }
   interface RuntimeNuxtHooks {
@@ -1010,12 +1159,11 @@ declare module '#app' {
       if (newScripts.length) {
         augments += `
 declare module '#nuxt-scripts/types' {
-  type _NuxtScriptOptions = Omit<import('${typesPath}').NuxtUseScriptOptions, 'use' | 'beforeInit'>
   interface ScriptRegistry {
 ${newScripts.map((i) => {
           const key = i.import.name.replace("useScript", "");
           const keyLcFirst = key.substring(0, 1).toLowerCase() + key.substring(1);
-          return `    ${keyLcFirst}?: import('${i.import.from}').${key}Input | [import('${i.import.from}').${key}Input, _NuxtScriptOptions]`;
+          return `    ${keyLcFirst}?: import('${i.import.from}').${key}Input`;
         }).join("\n")}
   }
 }
@@ -1071,7 +1219,7 @@ function resolveTriggerForTemplate(trigger) {
 function templatePlugin(config, registry) {
   if (Array.isArray(config.globals)) {
     config.globals = Object.fromEntries(config.globals.map((i) => [hash(i), i]));
-    logger.warn("The `globals` array option is deprecated, please convert to an object.");
+    logger.warn("The `globals` array option is deprecated. Convert to an object: `globals: { myScript: 'https://example.com/script.js' }`");
   }
   const imports = [];
   const inits = [];
@@ -1080,29 +1228,31 @@ function templatePlugin(config, registry) {
   let needsInteractionImport = false;
   let needsServiceWorkerImport = false;
   for (const [k, c] of Object.entries(config.registry || {})) {
+    if (c === false)
+      continue;
+    const entry = c;
+    const [, scriptOptions] = entry;
+    if (!scriptOptions?.trigger)
+      continue;
     const importDefinition = registry.find((i) => i.import.name.toLowerCase() === `usescript${k.toLowerCase()}`);
     if (importDefinition) {
       resolvedRegistryKeys.push(k);
       imports.unshift(`import { ${importDefinition.import.name} } from '${importDefinition.import.from}'`);
-      if (c === "mock") {
-        inits.push(`const ${k} = ${importDefinition.import.name}({ scriptOptions: { trigger: 'manual', skipValidation: true } })`);
-      } else if (Array.isArray(c) && c.length === 2) {
-        const input = c[0] || {};
-        const scriptOptions = { ...c[1] };
-        const triggerResolved = resolveTriggerForTemplate(scriptOptions?.trigger);
-        if (triggerResolved) {
-          scriptOptions.trigger = "__TRIGGER_PLACEHOLDER__";
-          if (triggerResolved.includes("useScriptTriggerIdleTimeout")) needsIdleTimeoutImport = true;
-          if (triggerResolved.includes("useScriptTriggerInteraction")) needsInteractionImport = true;
-          if (triggerResolved.includes("useScriptTriggerServiceWorker")) needsServiceWorkerImport = true;
-        }
-        const args = { ...input, scriptOptions };
-        const argsJson = triggerResolved ? JSON.stringify(args).replace(/"__TRIGGER_PLACEHOLDER__"/g, triggerResolved) : JSON.stringify(args);
-        inits.push(`const ${k} = ${importDefinition.import.name}(${argsJson})`);
-      } else {
-        const args = (typeof c !== "object" ? {} : c) || {};
-        inits.push(`const ${k} = ${importDefinition.import.name}(${JSON.stringify(args)})`);
+      const [input] = entry;
+      const opts = { ...scriptOptions };
+      const triggerResolved = resolveTriggerForTemplate(opts.trigger);
+      if (triggerResolved) {
+        opts.trigger = "__TRIGGER_PLACEHOLDER__";
+        if (triggerResolved.includes("useScriptTriggerIdleTimeout"))
+          needsIdleTimeoutImport = true;
+        if (triggerResolved.includes("useScriptTriggerInteraction"))
+          needsInteractionImport = true;
+        if (triggerResolved.includes("useScriptTriggerServiceWorker"))
+          needsServiceWorkerImport = true;
       }
+      const args = { ...input, scriptOptions: opts };
+      const argsJson = triggerResolved ? JSON.stringify(args).replace(TRIGGER_PLACEHOLDER_RE, triggerResolved) : JSON.stringify(args);
+      inits.push(`const ${k} = ${importDefinition.import.name}(${argsJson})`);
     }
   }
   for (const [k, c] of Object.entries(config.globals || {})) {
@@ -1112,11 +1262,14 @@ function templatePlugin(config, registry) {
       const options = c[1];
       const triggerResolved = resolveTriggerForTemplate(options?.trigger);
       if (triggerResolved) {
-        if (triggerResolved.includes("useScriptTriggerIdleTimeout")) needsIdleTimeoutImport = true;
-        if (triggerResolved.includes("useScriptTriggerInteraction")) needsInteractionImport = true;
-        if (triggerResolved.includes("useScriptTriggerServiceWorker")) needsServiceWorkerImport = true;
+        if (triggerResolved.includes("useScriptTriggerIdleTimeout"))
+          needsIdleTimeoutImport = true;
+        if (triggerResolved.includes("useScriptTriggerInteraction"))
+          needsInteractionImport = true;
+        if (triggerResolved.includes("useScriptTriggerServiceWorker"))
+          needsServiceWorkerImport = true;
         const resolvedOptions = { ...options, trigger: "__TRIGGER_PLACEHOLDER__" };
-        const optionsJson = JSON.stringify(resolvedOptions).replace(/"__TRIGGER_PLACEHOLDER__"/g, triggerResolved);
+        const optionsJson = JSON.stringify(resolvedOptions).replace(TRIGGER_PLACEHOLDER_RE, triggerResolved);
         inits.push(`const ${k} = useScript(${JSON.stringify({ key: k, ...typeof c[0] === "string" ? { src: c[0] } : c[0] })}, { ...${optionsJson}, use: () => ({ ${k}: window.${k} }) })`);
       } else {
         inits.push(`const ${k} = useScript(${JSON.stringify({ key: k, ...typeof c[0] === "string" ? { src: c[0] } : c[0] })}, { ...${JSON.stringify(c[1])}, use: () => ({ ${k}: window.${k} }) })`);
@@ -1124,11 +1277,14 @@ function templatePlugin(config, registry) {
     } else if (typeof c === "object" && c !== null) {
       const triggerResolved = resolveTriggerForTemplate(c.trigger);
       if (triggerResolved) {
-        if (triggerResolved.includes("useScriptTriggerIdleTimeout")) needsIdleTimeoutImport = true;
-        if (triggerResolved.includes("useScriptTriggerInteraction")) needsInteractionImport = true;
-        if (triggerResolved.includes("useScriptTriggerServiceWorker")) needsServiceWorkerImport = true;
+        if (triggerResolved.includes("useScriptTriggerIdleTimeout"))
+          needsIdleTimeoutImport = true;
+        if (triggerResolved.includes("useScriptTriggerInteraction"))
+          needsInteractionImport = true;
+        if (triggerResolved.includes("useScriptTriggerServiceWorker"))
+          needsServiceWorkerImport = true;
         const resolvedOptions = { ...c, trigger: "__TRIGGER_PLACEHOLDER__" };
-        const argsJson = JSON.stringify({ key: k, ...resolvedOptions }).replace(/"__TRIGGER_PLACEHOLDER__"/g, triggerResolved);
+        const argsJson = JSON.stringify({ key: k, ...resolvedOptions }).replace(TRIGGER_PLACEHOLDER_RE, triggerResolved);
         inits.push(`const ${k} = useScript(${argsJson}, { use: () => ({ ${k}: window.${k} }) })`);
       } else {
         inits.push(`const ${k} = useScript(${JSON.stringify({ key: k, ...c })}, { use: () => ({ ${k}: window.${k} }) })`);
@@ -1157,7 +1313,7 @@ function templatePlugin(config, registry) {
     `  parallel: true,`,
     `  setup() {`,
     ...inits.map((i) => `    ${i}`),
-    `    return { provide: { $scripts: { ${[...Object.keys(config.globals || {}), ...resolvedRegistryKeys].join(", ")} } } }`,
+    `    return { provide: { scripts: { ${[...Object.keys(config.globals || {}), ...resolvedRegistryKeys].join(", ")} } } }`,
     `  }`,
     `})`
   ].join("\n");
@@ -1167,22 +1323,28 @@ const SELF_CLOSING_SCRIPT_RE = /<((?:Script[A-Z]|script-)\w[\w-]*)\b([^>]*?)\/\s
 function fixSelfClosingScriptComponents(nuxt) {
   function expandTags(content) {
     SELF_CLOSING_SCRIPT_RE.lastIndex = 0;
-    if (!SELF_CLOSING_SCRIPT_RE.test(content)) return null;
+    if (!SELF_CLOSING_SCRIPT_RE.test(content))
+      return null;
     SELF_CLOSING_SCRIPT_RE.lastIndex = 0;
     return content.replace(SELF_CLOSING_SCRIPT_RE, (_, tag, attrs) => `<${tag}${attrs.trimEnd()}></${tag}>`);
   }
   function fixFile(filePath) {
-    if (!existsSync(filePath)) return;
+    if (!existsSync(filePath))
+      return;
     const content = readFileSync(filePath, "utf-8");
     const fixed = expandTags(content);
-    if (fixed) nuxt.vfs[filePath] = fixed;
+    if (fixed)
+      nuxt.vfs[filePath] = fixed;
   }
   function scanDir(dir) {
-    if (!existsSync(dir)) return;
+    if (!existsSync(dir))
+      return;
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const fullPath = resolve(dir, entry.name);
-      if (entry.isDirectory()) scanDir(fullPath);
-      else if (entry.name.endsWith(".vue")) fixFile(fullPath);
+      if (entry.isDirectory())
+        scanDir(fullPath);
+      else if (entry.name.endsWith(".vue"))
+        fixFile(fullPath);
     }
   }
   const pagesDirs = /* @__PURE__ */ new Set();
@@ -1195,7 +1357,8 @@ function fixSelfClosingScriptComponents(nuxt) {
   for (const dir of pagesDirs) scanDir(dir);
   if (nuxt.options.dev) {
     nuxt.hook("builder:watch", (_event, relativePath) => {
-      if (!relativePath.endsWith(".vue")) return;
+      if (!relativePath.endsWith(".vue"))
+        return;
       for (const layer of nuxt.options._layers) {
         const fullPath = resolve(layer.config.srcDir, relativePath);
         for (const dir of pagesDirs) {
@@ -1208,20 +1371,73 @@ function fixSelfClosingScriptComponents(nuxt) {
     });
   }
 }
-const PARTYTOWN_FORWARDS = {
-  googleAnalytics: ["dataLayer.push", "gtag"],
-  plausible: ["plausible"],
-  fathom: ["fathom", "fathom.trackEvent", "fathom.trackPageview"],
-  umami: ["umami", "umami.track"],
-  matomo: ["_paq.push"],
-  segment: ["analytics", "analytics.track", "analytics.page", "analytics.identify"],
-  metaPixel: ["fbq"],
-  xPixel: ["twq"],
-  tiktokPixel: ["ttq.track", "ttq.page", "ttq.identify"],
-  snapchatPixel: ["snaptr"],
-  redditPixel: ["rdt"],
-  cloudflareWebAnalytics: ["__cfBeacon"]
-};
+const UPPER_RE = /([A-Z])/g;
+const toScreamingSnake = (s) => s.replace(UPPER_RE, "_$1").toUpperCase();
+const PROXY_SECRET_ENV_KEY = "NUXT_SCRIPTS_PROXY_SECRET";
+const PROXY_SECRET_ENV_LINE_RE = /^NUXT_SCRIPTS_PROXY_SECRET=/m;
+const PROXY_SECRET_ENV_VALUE_RE = /^NUXT_SCRIPTS_PROXY_SECRET=(.+)$/m;
+function resolveProxySecret(rootDir, isDev, configSecret, autoGenerate = true) {
+  if (configSecret)
+    return { secret: configSecret, ephemeral: false, source: "config" };
+  const envSecret = process.env[PROXY_SECRET_ENV_KEY];
+  if (envSecret)
+    return { secret: envSecret, ephemeral: false, source: "env" };
+  if (!isDev || !autoGenerate)
+    return void 0;
+  const secret = randomBytes(32).toString("hex");
+  const envPath = resolve(rootDir, ".env");
+  const line = `${PROXY_SECRET_ENV_KEY}=${secret}
+`;
+  try {
+    if (existsSync(envPath)) {
+      const contents = readFileSync(envPath, "utf-8");
+      if (PROXY_SECRET_ENV_LINE_RE.test(contents)) {
+        const match = contents.match(PROXY_SECRET_ENV_VALUE_RE);
+        if (match?.[1])
+          return { secret: match[1].trim(), ephemeral: false, source: "dotenv-generated" };
+      }
+      appendFileSync(envPath, contents.endsWith("\n") ? line : `
+${line}`);
+    } else {
+      writeFileSync(envPath, `# Generated by @nuxt/scripts
+${line}`);
+    }
+    process.env[PROXY_SECRET_ENV_KEY] = secret;
+    return { secret, ephemeral: false, source: "dotenv-generated" };
+  } catch {
+    process.env[PROXY_SECRET_ENV_KEY] = secret;
+    return { secret, ephemeral: true, source: "memory-generated" };
+  }
+}
+function isProxyDisabled(registryKey, registry2, runtimeConfig) {
+  const entry = registry2?.[registryKey];
+  if (!entry)
+    return true;
+  const [input, scriptOptions] = entry;
+  if (input?.proxy === false || scriptOptions?.proxy === false)
+    return true;
+  if (runtimeConfig) {
+    const rtEntry = runtimeConfig.public?.scripts?.[registryKey];
+    if (rtEntry?.proxy === false)
+      return true;
+  }
+  return false;
+}
+function applyAutoInject(registry2, runtimeConfig, proxyPrefix, registryKey, autoInject) {
+  if (isProxyDisabled(registryKey, registry2, runtimeConfig))
+    return;
+  const entry = registry2[registryKey];
+  const input = entry[0];
+  const rtScripts = runtimeConfig.public?.scripts;
+  const rtEntry = rtScripts?.[registryKey];
+  const config = rtEntry && typeof rtEntry === "object" ? rtEntry : input;
+  if (!config || config[autoInject.configField])
+    return;
+  const value = autoInject.computeValue(proxyPrefix, config);
+  input[autoInject.configField] = value;
+  if (rtEntry && typeof rtEntry === "object" && rtEntry !== input)
+    rtEntry[autoInject.configField] = value;
+}
 const module$1 = defineNuxtModule({
   meta: {
     name: "@nuxt/scripts",
@@ -1231,7 +1447,6 @@ const module$1 = defineNuxtModule({
     }
   },
   defaults: {
-    firstParty: true,
     defaultScriptOptions: {
       trigger: "onNuxtReady"
     },
@@ -1253,86 +1468,90 @@ const module$1 = defineNuxtModule({
     debug: false
   },
   async setup(config, nuxt) {
-    const { resolvePath } = createResolver(import.meta.url);
+    const { resolve: resolveModule, resolvePath } = createResolver(import.meta.url);
     const { version, name } = await readPackageJSON(await resolvePath("../package.json"));
-    nuxt.options.alias["#nuxt-scripts-validator"] = await resolvePath(`./runtime/validation/${nuxt.options.dev || nuxt.options._prepare ? "valibot" : "mock"}`);
     nuxt.options.alias["#nuxt-scripts"] = await resolvePath("./runtime");
     logger.level = config.debug || nuxt.options.debug ? 4 : 3;
     if (!config.enabled) {
       logger.debug("The module is disabled, skipping setup.");
       return;
     }
+    if (nuxt.options.dev) {
+      setupDevtools(nuxt, { standalone: config._standaloneDevtools });
+      if (config._standaloneDevtools) {
+        const bridgePath = resolveModule("./runtime/devtools-standalone-bridge.client");
+        addPluginTemplate({
+          filename: "modules/nuxt-scripts/devtools-standalone-bridge.client.mjs",
+          getContents() {
+            return `export { default } from '${bridgePath}'`;
+          }
+        });
+      }
+    }
     const { version: unheadVersion } = await readPackageJSON("@unhead/vue", {
       from: nuxt.options.modulesDir
     }).catch(() => ({ version: null }));
     if (unheadVersion?.startsWith("1")) {
       logger.error(`Nuxt Scripts requires Unhead >= 2, you are using v${unheadVersion}. Please run \`nuxi upgrade --clean\` to upgrade...`);
     }
+    const scripts = await registry(resolvePath);
+    if (config.registry) {
+      migrateDeprecatedRegistryKeys(config.registry, (msg) => logger.warn(msg));
+      normalizeRegistryConfig(config.registry, (msg) => logger.warn(msg));
+      nuxt.options.runtimeConfig.public = nuxt.options.runtimeConfig.public || {};
+      const registryWithDefaults = {};
+      for (const [key, entry] of Object.entries(config.registry)) {
+        if (entry === false)
+          continue;
+        const input = entry[0];
+        const scriptOptions = entry[1];
+        const envDefaults = scripts.find((s) => s.registryKey === key)?.envDefaults;
+        const base = {};
+        if (!envDefaults || !Object.keys(envDefaults).length) {
+          Object.assign(base, input);
+        } else {
+          const envResolved = {};
+          for (const [field, defaultValue] of Object.entries(envDefaults)) {
+            const envKey = `NUXT_PUBLIC_SCRIPTS_${toScreamingSnake(key)}_${toScreamingSnake(field)}`;
+            envResolved[field] = process.env[envKey] || defaultValue;
+          }
+          Object.assign(base, defu(input, envResolved));
+        }
+        if (scriptOptions && Object.keys(scriptOptions).length > 0) {
+          base.scriptOptions = scriptOptions;
+        }
+        registryWithDefaults[key] = base;
+      }
+      nuxt.options.runtimeConfig.public.scripts = defu(
+        nuxt.options.runtimeConfig.public.scripts || {},
+        registryWithDefaults
+      );
+    }
+    const googleMapsEnabled = config.googleStaticMapsProxy?.enabled || !!config.registry?.googleMaps;
     nuxt.options.runtimeConfig["nuxt-scripts"] = {
       version,
       // Private proxy config with API key (server-side only)
-      googleStaticMapsProxy: config.googleStaticMapsProxy?.enabled ? { apiKey: nuxt.options.runtimeConfig.public.scripts?.googleMaps?.apiKey } : void 0
+      googleStaticMapsProxy: googleMapsEnabled ? { apiKey: nuxt.options.runtimeConfig.public.scripts?.googleMaps?.apiKey } : void 0
     };
     nuxt.options.runtimeConfig.public["nuxt-scripts"] = {
       // expose for devtools
       version: nuxt.options.dev ? version : void 0,
+      prefix: config.prefix || "/_scripts",
       defaultScriptOptions: config.defaultScriptOptions,
       // Only expose enabled and cacheMaxAge to client, not apiKey
-      googleStaticMapsProxy: config.googleStaticMapsProxy?.enabled ? { enabled: true, cacheMaxAge: config.googleStaticMapsProxy.cacheMaxAge } : void 0
+      googleStaticMapsProxy: googleMapsEnabled ? { enabled: true, cacheMaxAge: config.googleStaticMapsProxy?.cacheMaxAge ?? 3600 } : void 0
     };
-    if (config.registry) {
-      nuxt.options.runtimeConfig.public = nuxt.options.runtimeConfig.public || {};
-      nuxt.options.runtimeConfig.public.scripts = defu(
-        nuxt.options.runtimeConfig.public.scripts || {},
-        config.registry
-      );
-    }
-    if (config.defaultScriptOptions?.bundle !== void 0) {
-      logger.warn(
-        "`scripts.defaultScriptOptions.bundle` is deprecated. Use `scripts.firstParty: true` instead. First-party mode is now enabled by default."
-      );
-    }
-    const staticPresets = ["static", "github-pages", "cloudflare-pages-static"];
-    const preset = process.env.NITRO_PRESET || "";
-    const isStaticPreset = staticPresets.includes(preset);
-    const firstPartyEnabled = !!config.firstParty;
-    const firstPartyPrefix = typeof config.firstParty === "object" ? config.firstParty.prefix : void 0;
-    const firstPartyCollectPrefix = typeof config.firstParty === "object" ? config.firstParty.collectPrefix || "/_proxy" : "/_proxy";
-    const firstPartyPrivacy = typeof config.firstParty === "object" ? config.firstParty.privacy : void 0;
-    const assetsPrefix = firstPartyPrefix || config.assets?.prefix || "/_scripts";
-    if (config.partytown?.length) {
-      config.registry = config.registry || {};
-      const requiredForwards = [];
-      for (const scriptKey of config.partytown) {
-        const forwards = PARTYTOWN_FORWARDS[scriptKey];
-        if (forwards) {
-          requiredForwards.push(...forwards);
-        } else if (import.meta.dev) {
-          logger.warn(`[partytown] "${scriptKey}" has no known Partytown forwards configured. It may not work correctly or may require manual forward configuration.`);
-        }
-        const reg = config.registry;
-        const existing = reg[scriptKey];
-        if (Array.isArray(existing)) {
-          existing[1] = { ...existing[1], partytown: true };
-        } else if (existing && typeof existing === "object" && existing !== true && existing !== "mock") {
-          reg[scriptKey] = [existing, { partytown: true }];
-        } else if (existing === true || existing === "mock") {
-          reg[scriptKey] = [{}, { partytown: true }];
-        } else {
-          reg[scriptKey] = [{}, { partytown: true }];
-        }
-      }
-      if (requiredForwards.length && hasNuxtModule("@nuxtjs/partytown")) {
-        const partytownConfig = nuxt.options.partytown || {};
-        const existingForwards = partytownConfig.forward || [];
-        const newForwards = [.../* @__PURE__ */ new Set([...existingForwards, ...requiredForwards])];
-        nuxt.options.partytown = { ...partytownConfig, forward: newForwards };
-        logger.info(`[partytown] Auto-configured forwards: ${requiredForwards.join(", ")}`);
-      }
-    }
+    const scriptsBase = config.prefix || "/_scripts";
+    const proxyPrefix = `${scriptsBase}/p`;
+    const assetsPrefix = `${scriptsBase}/assets`;
+    const proxyConfigs = {};
+    const proxyHandlerPath = await resolvePath("./runtime/server/proxy-handler");
+    addServerHandler({ route: `${proxyPrefix}/**`, handler: proxyHandlerPath });
     const composables = [
       "useScript",
       "useScriptEventPage",
+      "useScriptProxyToken",
+      "useScriptProxyUrl",
       "useScriptTriggerConsent",
       "useScriptTriggerElement",
       "useScriptTriggerIdleTimeout",
@@ -1358,60 +1577,50 @@ const module$1 = defineNuxtModule({
         return templateTriggerResolver(config.defaultScriptOptions);
       }
     });
-    logger.debug("[nuxt-scripts] First-party config:", { firstPartyEnabled, firstPartyPrivacy, firstPartyCollectPrefix });
-    let interceptRules = [];
-    if (firstPartyEnabled) {
-      addPluginTemplate({
-        filename: "nuxt-scripts-intercept.client.mjs",
-        getContents() {
-          const rulesJson = JSON.stringify(interceptRules);
-          return `export default defineNuxtPlugin({
-  name: 'nuxt-scripts:intercept',
-  enforce: 'pre',
-  setup() {
-    const rules = ${rulesJson};
-    const origBeacon = typeof navigator !== 'undefined' && navigator.sendBeacon
-      ? navigator.sendBeacon.bind(navigator)
-      : () => false;
-    const origFetch = globalThis.fetch.bind(globalThis);
-
-    function rewriteUrl(url) {
-      try {
-        const parsed = new URL(url, location.origin);
-        for (const rule of rules) {
-          if (parsed.hostname === rule.pattern || parsed.hostname.endsWith('.' + rule.pattern)) {
-            if (rule.pathPrefix && !parsed.pathname.startsWith(rule.pathPrefix)) continue;
-            const path = rule.pathPrefix ? parsed.pathname.slice(rule.pathPrefix.length) : parsed.pathname;
-            return location.origin + rule.target + (path.startsWith('/') ? '' : '/') + path + parsed.search;
-          }
-        }
-      } catch {}
-      return url;
-    }
-
-    globalThis.__nuxtScripts = {
-      sendBeacon: (url, data) => origBeacon(rewriteUrl(url), data),
-      fetch: (url, opts) => origFetch(typeof url === 'string' ? rewriteUrl(url) : url, opts),
-    };
-  },
-})
-`;
-        }
-      });
-      const proxyHandlerPath = await resolvePath("./runtime/server/proxy-handler");
-      logger.debug("[nuxt-scripts] Registering proxy handler:", `${firstPartyCollectPrefix}/**`, "->", proxyHandlerPath);
-      addServerHandler({
-        route: `${firstPartyCollectPrefix}/**`,
-        handler: proxyHandlerPath
-      });
-    }
-    const scripts = await registry(resolvePath);
+    logger.debug("[nuxt-scripts] Proxy prefix:", proxyPrefix);
     for (const script of scripts) {
       if (script.import?.name) {
         addImports({ priority: 2, ...script.import });
         script._importRegistered = true;
       }
     }
+    if (config.registry) {
+      for (const [key, entry] of Object.entries(config.registry)) {
+        if (!entry)
+          continue;
+        const [input, scriptOptions] = entry;
+        if (scriptOptions?.skipValidation)
+          continue;
+        const script = scripts.find((s) => s.registryKey === key);
+        if (!script?.schema)
+          continue;
+        const isComponentOnly = !script.import;
+        if (isComponentOnly) {
+          if (scriptOptions && "trigger" in scriptOptions && scriptOptions.trigger !== false) {
+            const pascal = key.charAt(0).toUpperCase() + key.slice(1);
+            logger.warn(
+              `[nuxt-scripts] registry.${key}: \`trigger\` has no effect on component-only scripts. Render <Script${pascal}> in your template to load the embed.`
+            );
+          }
+          continue;
+        }
+        const willAutoLoad = scriptOptions && "trigger" in scriptOptions && scriptOptions.trigger !== false;
+        if (willAutoLoad) {
+          const requiredFields = extractRequiredFields(script.schema);
+          const missing = requiredFields.filter((f) => !input[f]);
+          if (missing.length) {
+            logger.warn(`[nuxt-scripts] registry.${key}: missing required field${missing.length > 1 ? "s" : ""} ${missing.map((f) => `'${f}'`).join(", ")}. The script infrastructure is registered but will not function without ${missing.length > 1 ? "them" : "it"}.`);
+          }
+        }
+        const envDefaultKeys = new Set(Object.keys(script.envDefaults || {}));
+        const userProvidedFields = Object.keys(input).filter((f) => !envDefaultKeys.has(f));
+        if (userProvidedFields.length > 0 && (!scriptOptions || !("trigger" in scriptOptions))) {
+          logger.warn(
+            `[nuxt-scripts] registry.${key}: config provided without a \`trigger\`. The script will not auto-load. Add \`trigger: 'onNuxtReady'\` to auto-load, or \`trigger: false\` for infrastructure only. See https://scripts.nuxt.com/docs/migration-guide/v0-to-v1`
+          );
+        }
+      }
+    }
     nuxt.hooks.hook("modules:done", async () => {
       const registryScripts = [...scripts];
       await nuxt.hooks.callHook("scripts:registry", registryScripts);
@@ -1422,7 +1631,7 @@ const module$1 = defineNuxtModule({
       }
       const registryScriptsWithImport = registryScripts.filter((i) => !!i.import?.name);
       const newScripts = registryScriptsWithImport.filter((i) => !scripts.some((r) => r.import?.name === i.import.name));
-      registerTypeTemplates({ nuxt, config, newScripts });
+      registerTypeTemplates({ config, newScripts });
       if (Object.keys(config.globals || {}).length || Object.keys(config.registry || {}).length) {
         addPluginTemplate({
           filename: `modules/${name.replace("/", "-")}/plugin.mjs`,
@@ -1431,79 +1640,123 @@ const module$1 = defineNuxtModule({
           }
         });
       }
-      const { renderedScript } = setupPublicAssetStrategy(config.assets);
-      if (firstPartyEnabled) {
-        const proxyConfigs = getAllProxyConfigs(firstPartyCollectPrefix);
-        const registryKeys = Object.keys(config.registry || {});
-        const neededRoutes = {};
-        const routePrivacyOverrides = {};
+      const { renderedScript } = setupPublicAssetStrategy(assetsPrefix);
+      const scriptByKey = /* @__PURE__ */ new Map();
+      for (const script of registryScripts) {
+        if (script.registryKey)
+          scriptByKey.set(script.registryKey, script);
+      }
+      const partytownScripts = /* @__PURE__ */ new Set();
+      let anyNeedsProxy = false;
+      const registryKeys = Object.keys(config.registry || {});
+      for (const key of registryKeys) {
+        const script = scriptByKey.get(key);
+        if (!script)
+          continue;
+        const entry = config.registry?.[key];
+        const scriptOptions = entry?.[1] || {};
+        const inputOptions = entry?.[0] || {};
+        const mergedOverrides = { ...inputOptions, ...scriptOptions };
+        const resolved = resolveCapabilities(script, mergedOverrides);
+        if (resolved.proxy)
+          anyNeedsProxy = true;
+        if (resolved.partytown) {
+          partytownScripts.add(key);
+          const forwards = getPartytownForwards(script);
+          if (forwards?.length && hasNuxtModule("@nuxtjs/partytown")) {
+            const partytownConfig = nuxt.options.partytown || {};
+            const existingForwards = partytownConfig.forward || [];
+            const newForwards = [.../* @__PURE__ */ new Set([...existingForwards, ...forwards])];
+            nuxt.options.partytown = { ...partytownConfig, forward: newForwards };
+          } else if (!forwards?.length && import.meta.dev) {
+            logger.warn(`[partytown] "${key}" has no known Partytown forwards configured. It may not work correctly or may require manual forward configuration.`);
+          }
+        }
+      }
+      if (anyNeedsProxy) {
+        const builtConfigs = buildProxyConfigsFromRegistry(registryScripts, scriptByKey);
+        Object.assign(proxyConfigs, builtConfigs);
+        const domainPrivacy = {};
         const unsupportedScripts = [];
+        const unmatchedScripts = [];
+        let totalDomains = 0;
+        const devtoolsScripts = [];
         for (const key of registryKeys) {
-          const script = registryScriptsWithImport.find((s) => s.import.name.toLowerCase() === `usescript${key.toLowerCase()}`);
-          const proxyKey = script?.proxy || void 0;
-          if (proxyKey) {
-            const proxyConfig = proxyConfigs[proxyKey];
-            if (proxyConfig?.routes) {
-              Object.assign(neededRoutes, proxyConfig.routes);
-              for (const routePath of Object.keys(proxyConfig.routes)) {
-                routePrivacyOverrides[routePath] = proxyConfig.privacy;
-              }
-            } else {
-              unsupportedScripts.push(key);
-            }
+          const script = scriptByKey.get(key);
+          if (!script) {
+            unmatchedScripts.push(key);
+            continue;
           }
-        }
-        if (config.registry?.posthog && typeof config.registry.posthog === "object") {
-          const phConfig = config.registry.posthog;
-          if (!phConfig.apiHost) {
-            const region = phConfig.region || "us";
-            phConfig.apiHost = region === "eu" ? `${firstPartyCollectPrefix}/ph-eu` : `${firstPartyCollectPrefix}/ph`;
+          if (!script.proxy)
+            continue;
+          if (isProxyDisabled(key, config.registry))
+            continue;
+          const configKey = typeof script.proxy === "string" ? script.proxy : key;
+          const proxyConfig = proxyConfigs[configKey];
+          if (!proxyConfig) {
+            unsupportedScripts.push(key);
+            continue;
+          }
+          const entry = config.registry?.[key];
+          const inputPrivacy = entry?.[0]?.privacy;
+          for (const domain of proxyConfig.domains) {
+            domainPrivacy[domain] = inputPrivacy ?? proxyConfig.privacy;
+            totalDomains++;
           }
+          if (proxyConfig.autoInject && config.registry)
+            applyAutoInject(config.registry, nuxt.options.runtimeConfig, proxyPrefix, key, proxyConfig.autoInject);
+          if (nuxt.options.dev)
+            devtoolsScripts.push(buildDevtoolsEntry(key, script, configKey, proxyConfig));
         }
-        if (unsupportedScripts.length && nuxt.options.dev) {
+        if (unmatchedScripts.length) {
           logger.warn(
-            `First-party mode is enabled but these scripts don't support it yet: ${unsupportedScripts.join(", ")}.
-They will load directly from third-party servers. Request support at https://github.com/nuxt/scripts/issues`
+            `Proxy mode: could not find registry scripts for: ${unmatchedScripts.join(", ")}.
+These scripts will not have proxy routes registered.`
           );
         }
-        interceptRules = routesToInterceptRules(neededRoutes);
-        const flatRoutes = {};
-        for (const [path, config2] of Object.entries(neededRoutes)) {
-          flatRoutes[path] = config2.proxy;
+        if (unsupportedScripts.length && nuxt.options.dev) {
+          logger.warn(
+            `Proxy mode is enabled but these scripts don't support it yet: ${unsupportedScripts.join(", ")}.
+They will load directly from third-party servers.`
+          );
         }
+        addPluginTemplate({
+          filename: "nuxt-scripts-intercept.client.mjs",
+          getContents() {
+            return generateInterceptPluginContents(proxyPrefix, { testMode: !!nuxt.options.test });
+          }
+        });
         nuxt.options.runtimeConfig["nuxt-scripts-proxy"] = {
-          routes: flatRoutes,
-          privacy: firstPartyPrivacy,
-          // undefined = use per-script defaults, set = global override
-          routePrivacy: routePrivacyOverrides
-          // per-script privacy from registry
+          proxyPrefix,
+          domainPrivacy,
+          privacy: config.privacy
         };
-        if (Object.keys(neededRoutes).length) {
-          if (nuxt.options.dev) {
-            const routeCount = Object.keys(neededRoutes).length;
-            const scriptsCount = registryKeys.length;
-            const privacyLabel = firstPartyPrivacy === void 0 ? "per-script" : typeof firstPartyPrivacy === "boolean" ? firstPartyPrivacy ? "anonymize" : "passthrough" : "custom";
-            logger.success(`First-party mode enabled for ${scriptsCount} script(s), ${routeCount} proxy route(s) configured (privacy: ${privacyLabel})`);
-            if (logger.level >= 4) {
-              for (const [path, config2] of Object.entries(neededRoutes)) {
-                logger.debug(`  ${path} \u2192 ${config2.proxy}`);
-              }
-            }
-          }
+        const privacyLabel = config.privacy === void 0 ? "per-script" : typeof config.privacy === "boolean" ? config.privacy ? "anonymize" : "passthrough" : "custom";
+        if (totalDomains > 0 && nuxt.options.dev) {
+          logger.success(`Proxy mode enabled for ${registryKeys.length} script(s), ${totalDomains} domain(s) proxied (privacy: ${privacyLabel})`);
         }
-        if (isStaticPreset) {
+        const proxyStaticPresets = ["static", "github-pages", "cloudflare-pages-static", "netlify-static", "azure-static", "firebase-static"];
+        const proxyPreset = process.env.NITRO_PRESET || "";
+        if (proxyStaticPresets.includes(proxyPreset)) {
           logger.warn(
-            `First-party collection endpoints require a server runtime (detected: ${preset || "static"}).
-Scripts will be bundled, but collection requests will not be proxied.
-
-Options:
-  1. Configure platform rewrites (Vercel, Netlify, Cloudflare)
-  2. Switch to server-rendered mode (ssr: true)
-  3. Disable with firstParty: false
-
-See: https://scripts.nuxt.com/docs/guides/first-party#static-hosting`
+            `Proxy collection endpoints require a server runtime (detected: ${proxyPreset || "static"}).
+Scripts will be bundled, but collection requests will not be proxied and URL signing will be unavailable.
+Options: configure platform rewrites, switch to server-rendered mode, or disable with proxy: false.`
           );
         }
+        if (nuxt.options.dev) {
+          nuxt.options.runtimeConfig.public["nuxt-scripts-devtools"] = buildDevtoolsData(proxyPrefix, privacyLabel, devtoolsScripts);
+        }
+        if (partytownScripts.size && hasNuxtModule("@nuxtjs/partytown")) {
+          const partytownConfig = nuxt.options.partytown || {};
+          if (!partytownConfig.resolveUrl) {
+            partytownConfig.resolveUrl = generatePartytownResolveUrl(proxyPrefix);
+            nuxt.options.partytown = partytownConfig;
+            logger.info("[partytown] Auto-configured resolveUrl for proxy");
+          } else {
+            logger.warn("[partytown] Custom resolveUrl already set. Add proxy rules to your resolveUrl manually.");
+          }
+        }
       }
       const moduleInstallPromises = /* @__PURE__ */ new Map();
       addBuildPlugin(NuxtScriptsCheckScripts(), {
@@ -1512,9 +1765,9 @@ See: https://scripts.nuxt.com/docs/guides/first-party#static-hosting`
       addBuildPlugin(NuxtScriptBundleTransformer({
         scripts: registryScriptsWithImport,
         registryConfig: nuxt.options.runtimeConfig.public.scripts,
-        defaultBundle: firstPartyEnabled || config.defaultScriptOptions?.bundle,
-        firstPartyEnabled,
-        firstPartyCollectPrefix,
+        proxyConfigs,
+        proxyPrefix,
+        partytownScripts,
         moduleDetected(module) {
           if (nuxt.options.dev && module !== "@nuxt/scripts" && !moduleInstallPromises.has(module) && !hasNuxtModule(module))
             moduleInstallPromises.set(module, () => installNuxtModule(module));
@@ -1527,41 +1780,88 @@ See: https://scripts.nuxt.com/docs/guides/first-party#static-hosting`
         renderedScript
       }));
       nuxt.hooks.hook("build:done", async () => {
-        const initPromise = Array.from(moduleInstallPromises.values());
+        const initPromise = [...moduleInstallPromises.values()];
         for (const p of initPromise)
           await p?.();
       });
     });
-    if (config.googleStaticMapsProxy?.enabled) {
-      addServerHandler({
-        route: "/_scripts/google-static-maps-proxy",
-        handler: await resolvePath("./runtime/server/google-static-maps-proxy")
-      });
+    const scriptsPrefix = config.prefix || "/_scripts";
+    const enabledEndpoints = {};
+    let anyHandlerRequiresSigning = false;
+    for (const script of scripts) {
+      if (!script.serverHandlers?.length || !script.registryKey)
+        continue;
+      const isEnabled = script.registryKey === "googleMaps" ? config.googleStaticMapsProxy?.enabled || config.registry?.googleMaps : config.registry?.[script.registryKey];
+      if (!isEnabled)
+        continue;
+      enabledEndpoints[script.registryKey] = true;
+      for (const handler of script.serverHandlers) {
+        const resolvedRoute = handler.route.replace("/_scripts", scriptsPrefix);
+        addServerHandler({
+          route: resolvedRoute,
+          handler: handler.handler,
+          middleware: handler.middleware
+        });
+        if (handler.requiresSigning)
+          anyHandlerRequiresSigning = true;
+      }
+      if (script.registryKey === "gravatar") {
+        const gravatarConfig = config.registry?.gravatar?.[0] || {};
+        nuxt.options.runtimeConfig.public["nuxt-scripts"] = defu(
+          { gravatarProxy: { cacheMaxAge: gravatarConfig.cacheMaxAge ?? 3600 } },
+          nuxt.options.runtimeConfig.public["nuxt-scripts"]
+        );
+      }
+      if (script.registryKey === "googleMaps") {
+        nuxt.options.runtimeConfig["nuxt-scripts"] = defu(
+          { googleMapsGeocodeProxy: { apiKey: nuxt.options.runtimeConfig.public.scripts?.googleMaps?.apiKey } },
+          nuxt.options.runtimeConfig["nuxt-scripts"]
+        );
+      }
     }
-    addServerHandler({
-      route: "/api/_scripts/x-embed",
-      handler: await resolvePath("./runtime/server/x-embed")
-    });
-    addServerHandler({
-      route: "/api/_scripts/x-embed-image",
-      handler: await resolvePath("./runtime/server/x-embed-image")
-    });
-    addServerHandler({
-      route: "/api/_scripts/instagram-embed",
-      handler: await resolvePath("./runtime/server/instagram-embed")
-    });
-    addServerHandler({
-      route: "/api/_scripts/instagram-embed-image",
-      handler: await resolvePath("./runtime/server/instagram-embed-image")
-    });
-    addServerHandler({
-      route: "/api/_scripts/instagram-embed-asset",
-      handler: await resolvePath("./runtime/server/instagram-embed-asset")
-    });
-    if (nuxt.options.dev) {
-      setupDevToolsUI(config, resolvePath);
+    nuxt.options.runtimeConfig.public["nuxt-scripts"] = defu(
+      { endpoints: enabledEndpoints },
+      nuxt.options.runtimeConfig.public["nuxt-scripts"]
+    );
+    const staticPresets = ["static", "github-pages", "cloudflare-pages-static", "netlify-static", "azure-static", "firebase-static"];
+    const nitroPreset = process.env.NITRO_PRESET || "";
+    const isStaticTarget = staticPresets.includes(nitroPreset);
+    const isSpa = nuxt.options.ssr === false;
+    if (anyHandlerRequiresSigning && (isSpa || isStaticTarget)) {
+      logger.warn(
+        `[security] URL signing requires a server runtime${isStaticTarget ? ` (detected preset: ${nitroPreset})` : " (ssr: false)"}.
+  Proxy endpoints will work without signature verification.
+  To enable signing, deploy with a server-rendered target or configure platform-level rewrites.`
+      );
+    } else if (anyHandlerRequiresSigning) {
+      const proxySecretResolved = resolveProxySecret(
+        nuxt.options.rootDir,
+        !!nuxt.options.dev,
+        config.security?.secret,
+        config.security?.autoGenerateSecret !== false
+      );
+      if (proxySecretResolved?.source === "dotenv-generated")
+        logger.info(`[security] Generated ${PROXY_SECRET_ENV_KEY} in .env for signed proxy URLs.`);
+      else if (proxySecretResolved?.source === "memory-generated")
+        logger.warn(`[security] Generated an in-memory ${PROXY_SECRET_ENV_KEY} (could not write .env). Signed URLs will break across restarts.`);
+      if (proxySecretResolved?.secret) {
+        const scriptsRuntime = nuxt.options.runtimeConfig["nuxt-scripts"];
+        scriptsRuntime.proxySecret = proxySecretResolved.secret;
+        if (config.security?.pageTokenMaxAge !== void 0)
+          scriptsRuntime.pageTokenMaxAge = config.security.pageTokenMaxAge;
+        addPlugin({
+          src: await resolvePath("./runtime/plugins/proxy-token.server"),
+          mode: "server"
+        });
+      } else if (!nuxt.options.dev) {
+        logger.warn(
+          `[security] ${PROXY_SECRET_ENV_KEY} is not set. Proxy endpoints will pass requests through without signature verification.
+  Generate one with: npx @nuxt/scripts generate-secret
+  Then set the env var: ${PROXY_SECRET_ENV_KEY}=<secret>`
+        );
+      }
     }
   }
 });
 
-export { module$1 as default };
+export { applyAutoInject, module$1 as default, isProxyDisabled, resolveProxySecret };