@nuxt/scripts 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/module.mjs

@@ -1,79 +1,36 @@
-import { useNuxt, extendViteConfig, useLogger, addDevServerHandler, extendRouteRules, tryUseNuxt, logger as logger$1, addTypeTemplate, defineNuxtModule, createResolver, hasNuxtModule, addImports, addComponentsDir, addTemplate, addServerHandler, addPluginTemplate, addBuildPlugin } from '@nuxt/kit';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { useNuxt, addDevServerHandler, extendRouteRules, tryUseNuxt, extendViteConfig, useLogger, addPluginTemplate, addServerHandler, logger as logger$1, addTypeTemplate, defineNuxtModule, createResolver, hasNuxtModule, addImports, addComponentsDir, addTemplate, addBuildPlugin } from '@nuxt/kit';
 import { defu } from 'defu';
+import { join, resolve, relative } from 'pathe';
 import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
+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 { addCustomTab } from '@nuxt/devtools-kit';
+import { isCI, provider } from 'std-env';
+import { parseAndWalk, ScopeTracker, walk, ScopeTrackerFunctionParam, ScopeTrackerVariable } from 'oxc-walker';
+import { createUnplugin } from 'unplugin';
+import { pathToFileURL } from 'node:url';
 import { createHash } from 'node:crypto';
 import fsp from 'node:fs/promises';
-import { createUnplugin } from 'unplugin';
+import { colors } from 'consola/utils';
 import MagicString from 'magic-string';
-import { parseAndWalk } from 'oxc-walker';
-import { joinURL, parseURL, parseQuery, hasProtocol } from 'ufo';
 import { hash } from 'ohash';
-import { join, resolve, relative } from 'pathe';
-import { colors } from 'consola/utils';
-import { fetch, $fetch } from 'ofetch';
-import { lazyEventHandler, eventHandler, createError } from 'h3';
-import { createStorage } from 'unstorage';
-import fsDriver from 'unstorage/drivers/fs-lite';
-import { rewriteScriptUrls } from '../dist/runtime/utils/pure.js';
-import { pathToFileURL } from 'node:url';
-import { isCI, provider } from 'std-env';
+import { g as getAllProxyConfigs, r as routesToInterceptRules, a as getProxyConfig } from './shared/scripts.Crpn87WB.mjs';
 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");
-
 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";
   const nuxt = useNuxt();
@@ -123,179 +80,291 @@ function setupPublicAssetStrategy(options = {}) {
   };
 }
 
-function buildProxyConfig(collectPrefix) {
-  return {
-    googleAnalytics: {
-      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: {
-      rewrite: [
-        { from: "www.googletagmanager.com", to: `${collectPrefix}/gtm` }
-      ],
-      routes: {
-        [`${collectPrefix}/gtm/**`]: { proxy: "https://www.googletagmanager.com/**" }
-      }
-    },
-    metaPixel: {
-      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: {
-      rewrite: [
-        { from: "analytics.tiktok.com", to: `${collectPrefix}/tiktok` }
-      ],
-      routes: {
-        [`${collectPrefix}/tiktok/**`]: { proxy: "https://analytics.tiktok.com/**" }
-      }
-    },
-    segment: {
-      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: {
-      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: {
-      rewrite: [
-        { from: "tr.snapchat.com", to: `${collectPrefix}/snap` }
-      ],
-      routes: {
-        [`${collectPrefix}/snap/**`]: { proxy: "https://tr.snapchat.com/**" }
-      }
-    },
-    redditPixel: {
-      rewrite: [
-        { from: "alb.reddit.com", to: `${collectPrefix}/reddit` }
-      ],
-      routes: {
-        [`${collectPrefix}/reddit/**`]: { proxy: "https://alb.reddit.com/**" }
-      }
-    },
-    clarity: {
-      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/**" }
+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");
+
+const AUTO_INJECT_DEFS = [
+  {
+    registryKey: "posthog",
+    configField: "apiHost",
+    computeValue: (collectPrefix, config) => {
+      const region = config.region || "us";
+      return region === "eu" ? `${collectPrefix}/ph-eu` : `${collectPrefix}/ph`;
+    }
+  },
+  {
+    registryKey: "plausibleAnalytics",
+    configField: "endpoint",
+    computeValue: (collectPrefix) => `${collectPrefix}/plausible/api/event`
+  },
+  {
+    registryKey: "umamiAnalytics",
+    configField: "hostUrl",
+    computeValue: (collectPrefix) => `${collectPrefix}/umami`
+  },
+  {
+    registryKey: "rybbitAnalytics",
+    configField: "analyticsHost",
+    computeValue: (collectPrefix) => `${collectPrefix}/rybbit/api`
+  },
+  {
+    registryKey: "databuddyAnalytics",
+    configField: "apiUrl",
+    computeValue: (collectPrefix) => `${collectPrefix}/databuddy-api`
+  }
+];
+function autoInjectProxyEndpoints(registry, runtimeConfig, collectPrefix) {
+  for (const def of AUTO_INJECT_DEFS) {
+    const entry = registry[def.registryKey];
+    if (!entry || typeof entry !== "object")
+      continue;
+    const config = Array.isArray(entry) ? entry[0] : entry;
+    if (!config || config[def.configField])
+      continue;
+    config[def.configField] = def.computeValue(collectPrefix, config);
+    const rtScripts = runtimeConfig.public?.scripts;
+    const rtEntry = rtScripts?.[def.registryKey];
+    if (rtEntry && typeof rtEntry === "object") {
+      const rtConfig = Array.isArray(rtEntry) ? rtEntry[0] : rtEntry;
+      if (rtConfig)
+        rtConfig[def.configField] = config[def.configField];
+    }
+  }
+}
+
+function generateInterceptPluginContents(interceptRules) {
+  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;
+    }
+
+    // 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] = rewriteUrl(args[1]);
+        return super.open.apply(this, args);
       }
-    },
-    hotjar: {
-      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/**" }
+    }
+    // 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' ? rewriteUrl(v) : v); },
+          configurable: true,
+        });
       }
+      return img;
     }
-  };
+
+    globalThis.__nuxtScripts = {
+      sendBeacon: (url, data) => origBeacon(rewriteUrl(url), data),
+      fetch: (url, opts) => origFetch(typeof url === 'string' ? rewriteUrl(url) : url, opts),
+      XMLHttpRequest: ProxiedXHR,
+      Image: ProxiedImage,
+    };
+  },
+})
+`;
 }
-function getProxyConfig(key, collectPrefix) {
-  const configs = buildProxyConfig(collectPrefix);
-  return configs[key];
+
+function resolveFirstPartyConfig(config) {
+  const enabled = !!config.firstParty;
+  const prefix = typeof config.firstParty === "object" ? config.firstParty.prefix : void 0;
+  const collectPrefix = typeof config.firstParty === "object" ? config.firstParty.collectPrefix || "/_proxy" : "/_proxy";
+  const privacy = typeof config.firstParty === "object" ? config.firstParty.privacy : void 0;
+  const assetsPrefix = prefix || config.assets?.prefix || "/_scripts";
+  return { enabled, prefix, collectPrefix, privacy, assetsPrefix };
 }
-function getAllProxyConfigs(collectPrefix) {
-  return buildProxyConfig(collectPrefix);
+async function setupFirstPartyHandlers(firstParty, resolvePath) {
+  const interceptRules = [];
+  addPluginTemplate({
+    filename: "nuxt-scripts-intercept.client.mjs",
+    getContents() {
+      return generateInterceptPluginContents(interceptRules);
+    }
+  });
+  const proxyHandlerPath = await resolvePath("./runtime/server/proxy-handler");
+  logger.debug("[nuxt-scripts] Registering proxy handler:", `${firstParty.collectPrefix}/**`, "->", proxyHandlerPath);
+  addServerHandler({
+    route: `${firstParty.collectPrefix}/**`,
+    handler: proxyHandlerPath
+  });
+  return interceptRules;
 }
-function getSWInterceptRules(collectPrefix) {
-  const configs = buildProxyConfig(collectPrefix);
-  const rules = [];
-  for (const config of Object.values(configs)) {
-    if (!config.routes)
-      continue;
-    for (const [localPath, { proxy }] of Object.entries(config.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 finalizeFirstParty(opts) {
+  const { firstParty, interceptRules, registryScriptsWithImport, nuxtOptions } = opts;
+  const proxyConfigs = getAllProxyConfigs(firstParty.collectPrefix);
+  const registryKeys = Object.keys(opts.registry || {});
+  const neededRoutes = {};
+  const routePrivacyOverrides = {};
+  const unsupportedScripts = [];
+  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);
+      }
+    }
+  }
+  if (opts.registry) {
+    autoInjectProxyEndpoints(opts.registry, nuxtOptions.runtimeConfig, firstParty.collectPrefix);
+  }
+  if (unsupportedScripts.length && nuxtOptions.dev) {
+    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`
+    );
+  }
+  interceptRules.push(...routesToInterceptRules(neededRoutes));
+  const flatRoutes = {};
+  for (const [path, config] of Object.entries(neededRoutes)) {
+    flatRoutes[path] = config.proxy;
+  }
+  nuxtOptions.runtimeConfig["nuxt-scripts-proxy"] = {
+    routes: flatRoutes,
+    privacy: firstParty.privacy,
+    routePrivacy: routePrivacyOverrides
+  };
+  if (Object.keys(neededRoutes).length && nuxtOptions.dev) {
+    const routeCount = Object.keys(neededRoutes).length;
+    const scriptsCount = registryKeys.length;
+    const privacyLabel = firstParty.privacy === void 0 ? "per-script" : typeof firstParty.privacy === "boolean" ? firstParty.privacy ? "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, config] of Object.entries(neededRoutes)) {
+        logger.debug(`  ${path} \u2192 ${config.proxy}`);
       }
     }
   }
-  return rules;
+  const staticPresets = ["static", "github-pages", "cloudflare-pages-static"];
+  const preset = process.env.NITRO_PRESET || "";
+  if (staticPresets.includes(preset)) {
+    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`
+    );
+  }
+}
+
+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 isVue(id, opts = {}) {
@@ -319,13 +388,301 @@ 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."));
+          }
+        }
+      }
+    };
+  });
+}
+
+const WORD_OR_DOLLAR_RE = /[\w$]/;
+const GA_COLLECT_RE = /([\w$])?"https:\/\/"\+\(.*?\)\+"\.google-analytics\.com\/g\/collect"/g;
+const GA_ANALYTICS_COLLECT_RE = /([\w$])?"https:\/\/"\+\(.*?\)\+"\.analytics\.google\.com\/g\/collect"/g;
+const FATHOM_SELF_HOSTED_RE = /\.src\.indexOf\("cdn\.usefathom\.com"\)\s*<\s*0/;
+function isPropertyKeyAST(parent, ctx) {
+  return parent?.type === "Property" && ctx.key === "key" || parent?.type === "SwitchCase" && ctx.key === "test";
+}
+function matchAndRewrite(value, rewrites) {
+  for (const { from, to } of rewrites) {
+    const isSuffixMatch = from.startsWith(".");
+    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;
+    const url = parseURL(value);
+    let shouldRewrite = false;
+    let rewriteSuffix = "";
+    if (url.host) {
+      const hostMatches = isSuffixMatch ? url.host.endsWith(fromHost) : url.host === fromHost;
+      if (hostMatches) {
+        const fullPath = url.pathname + (url.search || "") + (url.hash || "");
+        if (fromPath && fullPath.startsWith(fromPath)) {
+          shouldRewrite = true;
+          rewriteSuffix = fullPath.slice(fromPath.length);
+        } else if (!fromPath) {
+          shouldRewrite = true;
+          rewriteSuffix = fullPath;
+        }
+      }
+    } else if (value.startsWith("//")) {
+      const hostPart = value.slice(2).split("/")[0];
+      const hostMatches = isSuffixMatch ? hostPart?.endsWith(fromHost) ?? false : hostPart === fromHost;
+      if (hostMatches) {
+        const remainder = value.slice(2 + (hostPart?.length ?? 0));
+        if (fromPath && remainder.startsWith(fromPath)) {
+          shouldRewrite = true;
+          rewriteSuffix = remainder.slice(fromPath.length);
+        } else if (!fromPath) {
+          shouldRewrite = true;
+          rewriteSuffix = remainder;
+        }
+      }
+    } else if (fromPath && (value.startsWith(from) || isSuffixMatch && value.includes(from))) {
+      const domainEnd = value.indexOf(from) + from.length;
+      const nextChar = value[domainEnd];
+      if (!nextChar || nextChar === "/" || nextChar === "?" || nextChar === "#") {
+        shouldRewrite = true;
+        rewriteSuffix = value.slice(domainEnd);
+      }
+    }
+    if (shouldRewrite) {
+      return rewriteSuffix === "/" || rewriteSuffix.startsWith("?") || rewriteSuffix.startsWith("#") ? to + rewriteSuffix : joinURL(to, rewriteSuffix);
+    }
+  }
+  return null;
+}
+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.computed && init.object?.type === "Identifier" && init.property?.type === "Identifier") {
+        const objGlobal = resolveToGlobal(init.object.name, scopeTracker, depth + 1);
+        if (!objGlobal)
+          return null;
+        if (WINDOW_GLOBALS.has(objGlobal) || objGlobal === "document")
+          return init.property.name;
+        return null;
+      }
+      return null;
+    }
+  }
+  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) {
+  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;
+        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, `${needsLeadingSpace(node.start)}self.location.origin+${quote}${rewritten}${quote}`);
+        }
+      }
+      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;
+          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}\``);
+          }
+        }
+      }
+      if (node.type === "CallExpression") {
+        const callee = node.callee;
+        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 === "NewExpression") {
+        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(
+      GA_COLLECT_RE,
+      (_, prevChar) => `${prevChar ? `${prevChar} ` : ""}self.location.origin+"${gaRewrite.to}"`
+    );
+    output = output.replace(
+      GA_ANALYTICS_COLLECT_RE,
+      (_, prevChar) => `${prevChar ? `${prevChar} ` : ""}self.location.origin+"${gaRewrite.to}"`
+    );
+  }
+  if (rewrites.some((r) => r.from === "cdn.usefathom.com")) {
+    output = output.replace(
+      FATHOM_SELF_HOSTED_RE,
+      '.src.indexOf("cdn.usefathom.com")<-1'
+    );
+  }
+  return output;
 }
 
 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}`;
@@ -340,12 +697,10 @@ async function isCacheExpired(storage, filename, cacheMaxAge = SEVEN_DAYS_IN_MS)
 }
 function normalizeScriptData(src, assetsBaseURL = "/_scripts") {
   if (hasProtocol(src, { acceptRelative: true })) {
-    src = src.replace(/^\/\//, "https://");
+    src = src.replace(PROTOCOL_RELATIVE_RE, "https://");
     const url = parseURL(src);
-    const file = [
-      `${hash(url)}.js`
-      // force an extension
-    ].filter(Boolean).join("-");
+    const h = hash(url);
+    const file = `${h.startsWith("-") ? `_${h.slice(1)}` : h}.js`;
     const nuxt = tryUseNuxt();
     const cdnURL = nuxt?.options.runtimeConfig?.app?.cdnURL || nuxt?.options.app?.cdnURL || "";
     const baseURL = cdnURL || nuxt?.options.app.baseURL || "";
@@ -392,7 +747,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 = rewriteScriptUrls(content, proxyRewrites);
+      const rewritten = rewriteScriptUrlsAST(content, filename || "script.js", proxyRewrites);
       res = Buffer.from(rewritten, "utf-8");
       logger.debug(`Rewrote ${proxyRewrites.length} URL patterns in ${filename}`);
     }
@@ -449,8 +804,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) {
@@ -460,11 +815,11 @@ 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;
@@ -472,7 +827,7 @@ function NuxtScriptBundleTransformer(options = {
               let src;
               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") {
@@ -652,7 +1007,7 @@ function NuxtScriptBundleTransformer(options = {
                             s.appendRight(node.arguments[0].start + 1, ` scriptInput: { src: '${url}'${integrityProps} }, `);
                           }
                         } else {
-                          s.appendRight(node.callee.end, `({ scriptInput: { src: '${url}'${integrityProps} } })`);
+                          s.overwrite(node.callee.end, node.end, `({ scriptInput: { src: '${url}'${integrityProps} } })`);
                         }
                       }
                     });
@@ -676,101 +1031,7 @@ 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."));
-          }
-        }
-      }
-    };
-  });
-}
-
+const TRIGGER_PLACEHOLDER_RE = /"__TRIGGER_PLACEHOLDER__"/g;
 function registerTypeTemplates({ nuxt, config, newScripts }) {
   addTypeTemplate({
     filename: "types/nuxt-scripts-augments.d.ts",
@@ -782,7 +1043,7 @@ function registerTypeTemplates({ nuxt, config, newScripts }) {
       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 {
@@ -863,7 +1124,7 @@ function templatePlugin(config, registry) {
   let needsInteractionImport = false;
   let needsServiceWorkerImport = false;
   for (const [k, c] of Object.entries(config.registry || {})) {
-    const importDefinition = registry.find((i) => i.proxy === k || i.import.name === `useScript${k.substring(0, 1).toUpperCase() + k.substring(1)}`);
+    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}'`);
@@ -875,12 +1136,15 @@ function templatePlugin(config, registry) {
         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;
+          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);
+        const argsJson = triggerResolved ? JSON.stringify(args).replace(TRIGGER_PLACEHOLDER_RE, triggerResolved) : JSON.stringify(args);
         inits.push(`const ${k} = ${importDefinition.import.name}(${argsJson})`);
       } else {
         const args = (typeof c !== "object" ? {} : c) || {};
@@ -895,11 +1159,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} }) })`);
@@ -907,11 +1174,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} }) })`);
@@ -940,12 +1210,93 @@ 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");
 }
 
+const SELF_CLOSING_SCRIPT_RE = /<((?:Script[A-Z]|script-)\w[\w-]*)\b([^>]*?)\/\s*>/g;
+function fixSelfClosingScriptComponents(nuxt) {
+  function expandTags(content) {
+    SELF_CLOSING_SCRIPT_RE.lastIndex = 0;
+    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;
+    const content = readFileSync(filePath, "utf-8");
+    const fixed = expandTags(content);
+    if (fixed)
+      nuxt.vfs[filePath] = fixed;
+  }
+  function scanDir(dir) {
+    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);
+    }
+  }
+  const pagesDirs = /* @__PURE__ */ new Set();
+  for (const layer of nuxt.options._layers) {
+    pagesDirs.add(resolve(
+      layer.config.srcDir,
+      layer.config.dir?.pages || "pages"
+    ));
+  }
+  for (const dir of pagesDirs) scanDir(dir);
+  if (nuxt.options.dev) {
+    nuxt.hook("builder:watch", (_event, relativePath) => {
+      if (!relativePath.endsWith(".vue"))
+        return;
+      for (const layer of nuxt.options._layers) {
+        const fullPath = resolve(layer.config.srcDir, relativePath);
+        for (const dir of pagesDirs) {
+          if (fullPath.startsWith(`${dir}/`)) {
+            fixFile(fullPath);
+            return;
+          }
+        }
+      }
+    });
+  }
+}
+const REGISTRY_ENV_DEFAULTS = {
+  clarity: { id: "" },
+  cloudflareWebAnalytics: { token: "" },
+  crisp: { id: "" },
+  databuddyAnalytics: { clientId: "" },
+  fathomAnalytics: { site: "" },
+  googleAdsense: { client: "" },
+  googleAnalytics: { id: "" },
+  googleMaps: { apiKey: "" },
+  googleRecaptcha: { siteKey: "" },
+  googleSignIn: { clientId: "" },
+  googleTagManager: { id: "" },
+  hotjar: { id: "" },
+  intercom: { app_id: "" },
+  matomoAnalytics: { matomoUrl: "" },
+  metaPixel: { id: "" },
+  paypal: { clientId: "" },
+  plausibleAnalytics: { domain: "" },
+  posthog: { apiKey: "" },
+  redditPixel: { id: "" },
+  rybbitAnalytics: { siteId: "" },
+  segment: { writeKey: "" },
+  snapchatPixel: { id: "" },
+  stripe: {},
+  tiktokPixel: { id: "" },
+  umamiAnalytics: { websiteId: "" },
+  vercelAnalytics: {},
+  xPixel: { id: "" }
+};
 const PARTYTOWN_FORWARDS = {
   googleAnalytics: ["dataLayer.push", "gtag"],
   plausible: ["plausible"],
@@ -1009,8 +1360,7 @@ const module$1 = defineNuxtModule({
     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,
-      swTemplate: readFileSync(await resolvePath("./runtime/sw/proxy-sw.template.js"), "utf-8")
+      googleStaticMapsProxy: config.googleStaticMapsProxy?.enabled ? { apiKey: nuxt.options.runtimeConfig.public.scripts?.googleMaps?.apiKey } : void 0
     };
     nuxt.options.runtimeConfig.public["nuxt-scripts"] = {
       // expose for devtools
@@ -1021,9 +1371,26 @@ const module$1 = defineNuxtModule({
     };
     if (config.registry) {
       nuxt.options.runtimeConfig.public = nuxt.options.runtimeConfig.public || {};
+      const registryWithDefaults = {};
+      for (const [key, value] of Object.entries(config.registry)) {
+        if (value && REGISTRY_ENV_DEFAULTS[key]) {
+          const envDefaults = REGISTRY_ENV_DEFAULTS[key];
+          if (value === true || value === "mock") {
+            registryWithDefaults[key] = { ...envDefaults };
+          } else if (typeof value === "object" && !Array.isArray(value)) {
+            registryWithDefaults[key] = defu(value, envDefaults);
+          } else if (Array.isArray(value)) {
+            registryWithDefaults[key] = defu(value[0] || {}, envDefaults);
+          } else {
+            registryWithDefaults[key] = value;
+          }
+        } else {
+          registryWithDefaults[key] = value;
+        }
+      }
       nuxt.options.runtimeConfig.public.scripts = defu(
         nuxt.options.runtimeConfig.public.scripts || {},
-        config.registry
+        registryWithDefaults
       );
     }
     if (config.defaultScriptOptions?.bundle !== void 0) {
@@ -1031,14 +1398,8 @@ const module$1 = defineNuxtModule({
         "`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 ?? "anonymize" : "anonymize";
-    const assetsPrefix = firstPartyPrefix || config.assets?.prefix || "/_scripts";
+    const firstParty = resolveFirstPartyConfig(config);
+    const assetsPrefix = firstParty.assetsPrefix;
     if (config.partytown?.length) {
       config.registry = config.registry || {};
       const requiredForwards = [];
@@ -1090,109 +1451,17 @@ const module$1 = defineNuxtModule({
       path: await resolvePath("./runtime/components"),
       pathPrefix: false
     });
+    fixSelfClosingScriptComponents(nuxt);
     addTemplate({
       filename: "nuxt-scripts-trigger-resolver.mjs",
       getContents() {
         return templateTriggerResolver(config.defaultScriptOptions);
       }
     });
-    const swHandlerPath = await resolvePath("./runtime/server/sw-handler");
-    logger.debug("[nuxt-scripts] First-party config:", { firstPartyEnabled, firstPartyPrivacy, firstPartyCollectPrefix });
-    if (firstPartyEnabled && !nuxt.options.dev) {
-      const swPath = "/_nuxt-scripts-sw.js";
-      const swRules = getSWInterceptRules(firstPartyCollectPrefix);
-      addServerHandler({
-        route: swPath,
-        handler: swHandlerPath
-      });
-      addPluginTemplate({
-        filename: "nuxt-scripts-sw-register.client.mjs",
-        getContents() {
-          return `import { defineNuxtPlugin } from 'nuxt/app'
-
-export default defineNuxtPlugin({
-  name: 'nuxt-scripts:sw-register',
-  enforce: 'pre',
-  async setup() {
-    if (!('serviceWorker' in navigator)) return;
-
-    try {
-      const reg = await navigator.serviceWorker.register('${swPath}', { scope: '/' });
-
-      // Wait for SW to be active and controlling this page
-      if (!navigator.serviceWorker.controller) {
-        await new Promise((resolve) => {
-          const onControllerChange = () => {
-            navigator.serviceWorker.removeEventListener('controllerchange', onControllerChange);
-            resolve();
-          };
-          navigator.serviceWorker.addEventListener('controllerchange', onControllerChange);
-
-          // Fallback timeout
-          setTimeout(resolve, 2000);
-        });
-      }
-    } catch (err) {
-      console.warn('[nuxt-scripts] SW registration failed:', err);
-    }
-  },
-})
-`;
-        }
-      });
-      addPluginTemplate({
-        filename: "nuxt-scripts-beacon-intercept.client.mjs",
-        getContents() {
-          const rulesJson = JSON.stringify(swRules);
-          return `export default defineNuxtPlugin({
-  name: 'nuxt-scripts:beacon-intercept',
-  enforce: 'pre',
-  setup() {
-    if (typeof navigator === 'undefined' || !navigator.sendBeacon) return;
-
-    const rules = ${rulesJson};
-    const originalBeacon = navigator.sendBeacon.bind(navigator);
-
-    navigator.sendBeacon = (url, data) => {
-      try {
-        const parsed = new URL(url, window.location.origin);
-
-        // Check if this URL matches any of our proxy rules
-        for (const rule of rules) {
-          if (parsed.hostname === rule.pattern || parsed.hostname.endsWith('.' + rule.pattern)) {
-            // Check path prefix if specified
-            if (rule.pathPrefix && !parsed.pathname.startsWith(rule.pathPrefix)) {
-              continue;
-            }
-
-            // Rewrite to proxy: strip pathPrefix from original, prepend target
-            const pathWithoutPrefix = rule.pathPrefix
-              ? parsed.pathname.slice(rule.pathPrefix.length)
-              : parsed.pathname;
-            const separator = pathWithoutPrefix.startsWith('/') ? '' : '/';
-            const proxyUrl = rule.target + separator + pathWithoutPrefix + parsed.search;
-
-            return originalBeacon(proxyUrl, data);
-          }
-        }
-      } catch (e) {
-        // URL parsing failed, pass through
-      }
-
-      return originalBeacon(url, data);
-    };
-  },
-})
-`;
-        }
-      });
-      nuxt.options.runtimeConfig.public["nuxt-scripts-sw"] = { path: swPath };
-      const proxyHandlerPath = await resolvePath("./runtime/server/proxy-handler");
-      logger.debug("[nuxt-scripts] Registering proxy handler:", `${firstPartyCollectPrefix}/**`, "->", proxyHandlerPath);
-      addServerHandler({
-        route: `${firstPartyCollectPrefix}/**`,
-        handler: proxyHandlerPath
-      });
+    logger.debug("[nuxt-scripts] First-party config:", firstParty);
+    let interceptRules = [];
+    if (firstParty.enabled) {
+      interceptRules = await setupFirstPartyHandlers(firstParty, resolvePath);
     }
     const scripts = await registry(resolvePath);
     for (const script of scripts) {
@@ -1221,74 +1490,14 @@ export default defineNuxtPlugin({
         });
       }
       const { renderedScript } = setupPublicAssetStrategy(config.assets);
-      if (firstPartyEnabled) {
-        const proxyConfigs = getAllProxyConfigs(firstPartyCollectPrefix);
-        const registryKeys = Object.keys(config.registry || {});
-        const neededRoutes = {};
-        const unsupportedScripts = [];
-        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);
-            } else {
-              unsupportedScripts.push(key);
-            }
-          }
-        }
-        if (unsupportedScripts.length && nuxt.options.dev) {
-          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`
-          );
-        }
-        const flatRoutes = {};
-        for (const [path, config2] of Object.entries(neededRoutes)) {
-          flatRoutes[path] = config2.proxy;
-        }
-        const allRewrites = [];
-        for (const key of registryKeys) {
-          const script = registryScriptsWithImport.find((s) => s.import.name.toLowerCase() === `usescript${key.toLowerCase()}`);
-          const proxyKey = script?.proxy !== false ? script?.proxy || key : void 0;
-          if (proxyKey) {
-            const proxyConfig = proxyConfigs[proxyKey];
-            if (proxyConfig?.rewrite) {
-              allRewrites.push(...proxyConfig.rewrite);
-            }
-          }
-        }
-        nuxt.options.runtimeConfig["nuxt-scripts-proxy"] = {
-          routes: flatRoutes,
-          privacy: firstPartyPrivacy,
-          rewrites: allRewrites
-        };
-        if (Object.keys(neededRoutes).length) {
-          if (nuxt.options.dev) {
-            const routeCount = Object.keys(neededRoutes).length;
-            const scriptsCount = registryKeys.length;
-            logger.success(`First-party mode enabled for ${scriptsCount} script(s), ${routeCount} proxy route(s) configured (privacy: ${firstPartyPrivacy})`);
-            if (logger.level >= 4) {
-              for (const [path, config2] of Object.entries(neededRoutes)) {
-                logger.debug(`  ${path} \u2192 ${config2.proxy}`);
-              }
-            }
-          }
-        }
-        if (isStaticPreset) {
-          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`
-          );
-        }
+      if (firstParty.enabled) {
+        finalizeFirstParty({
+          firstParty,
+          interceptRules,
+          registry: config.registry,
+          registryScriptsWithImport,
+          nuxtOptions: nuxt.options
+        });
       }
       const moduleInstallPromises = /* @__PURE__ */ new Map();
       addBuildPlugin(NuxtScriptsCheckScripts(), {
@@ -1297,9 +1506,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,
+        defaultBundle: firstParty.enabled || config.defaultScriptOptions?.bundle,
+        firstPartyEnabled: firstParty.enabled,
+        firstPartyCollectPrefix: firstParty.collectPrefix,
         moduleDetected(module) {
           if (nuxt.options.dev && module !== "@nuxt/scripts" && !moduleInstallPromises.has(module) && !hasNuxtModule(module))
             moduleInstallPromises.set(module, () => installNuxtModule(module));
@@ -1312,7 +1521,7 @@ 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?.();
       });
@@ -1323,6 +1532,17 @@ See: https://scripts.nuxt.com/docs/guides/first-party#static-hosting`
         handler: await resolvePath("./runtime/server/google-static-maps-proxy")
       });
     }
+    if (config.registry?.gravatar) {
+      const gravatarConfig = typeof config.registry.gravatar === "object" && !Array.isArray(config.registry.gravatar) ? config.registry.gravatar : {};
+      nuxt.options.runtimeConfig.public["nuxt-scripts"] = defu(
+        { gravatarProxy: { cacheMaxAge: gravatarConfig.cacheMaxAge ?? 3600 } },
+        nuxt.options.runtimeConfig.public["nuxt-scripts"]
+      );
+      addServerHandler({
+        route: "/_scripts/gravatar-proxy",
+        handler: await resolvePath("./runtime/server/gravatar-proxy")
+      });
+    }
     addServerHandler({
       route: "/api/_scripts/x-embed",
       handler: await resolvePath("./runtime/server/x-embed")