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

package/dist/module.mjs

@@ -1,5 +1,5 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { useNuxt, addDevServerHandler, extendRouteRules, tryUseNuxt, extendViteConfig, logger as logger$1, useLogger, addTypeTemplate, defineNuxtModule, createResolver, hasNuxtModule, addImports, addComponentsDir, addTemplate, addPluginTemplate, addServerHandler, addBuildPlugin } from '@nuxt/kit';
+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';
@@ -10,7 +10,7 @@ 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 } from 'oxc-walker';
+import { parseAndWalk, ScopeTracker, walk, ScopeTrackerFunctionParam, ScopeTrackerVariable } from 'oxc-walker';
 import { createUnplugin } from 'unplugin';
 import { pathToFileURL } from 'node:url';
 import { createHash } from 'node:crypto';
@@ -18,7 +18,7 @@ import fsp from 'node:fs/promises';
 import { colors } from 'consola/utils';
 import MagicString from 'magic-string';
 import { hash } from 'ohash';
-import { a as getProxyConfig, g as getAllProxyConfigs, r as routesToInterceptRules } from './shared/scripts.Bg4pl9Yo.mjs';
+import { g as getAllProxyConfigs, r as routesToInterceptRules, a as getProxyConfig } from './shared/scripts.Crpn87WB.mjs';
 import { registry } from './registry.mjs';
 
 const renderedScript = /* @__PURE__ */ new Map();
@@ -121,6 +121,212 @@ async function setupDevToolsUI(options, resolve, nuxt = useNuxt()) {
   });
 }
 
+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);
+      }
+    }
+    // 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 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 };
+}
+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 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}`);
+      }
+    }
+  }
+  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))
@@ -161,8 +367,6 @@ function installNuxtModule(name, options) {
   }, { rootDir: nuxt.options.rootDir, searchPaths: nuxt.options.modulesDir, ...options });
 }
 
-const logger = useLogger("@nuxt/scripts");
-
 function isVue(id, opts = {}) {
   const { search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
   if (id.endsWith(".vue") && !search) {
@@ -184,19 +388,20 @@ 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/
+          id: VUE_RE$1
         },
         handler(code, id) {
           if (!isVue(id, { type: ["script"] }))
@@ -245,6 +450,10 @@ function NuxtScriptsCheckScripts() {
   });
 }
 
+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";
 }
@@ -298,51 +507,151 @@ function matchAndRewrite(value, rewrites) {
   }
   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 && /[\w$]/.test(prev) ? " " : "";
+    return prev && WORD_OR_DOLLAR_RE.test(prev) ? " " : "";
   }
-  parseAndWalk(content, filename, (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 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, `\`${rewritten}\``);
+          s.overwrite(node.start, node.end, quote + rewritten + quote);
         } else {
-          s.overwrite(node.start, node.end, `${needsLeadingSpace(node.start)}self.location.origin+\`${rewritten}\``);
+          s.overwrite(node.start, node.end, `${needsLeadingSpace(node.start)}self.location.origin+${quote}${rewritten}${quote}`);
         }
       }
-    }
-    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 (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 (callee?.type === "Identifier" && callee.name === "fetch") {
-        s.overwrite(callee.start, callee.end, "__nuxtScripts.fetch");
+      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 (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") {
+        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}`);
+            }
+          }
+        }
       }
     }
   });
@@ -350,18 +659,30 @@ function rewriteScriptUrlsAST(content, filename, rewrites) {
   const gaRewrite = rewrites.find((r) => r.from.includes("google-analytics.com/g/collect"));
   if (gaRewrite) {
     output = output.replace(
-      /([\w$])?"https:\/\/"\+\(.*?\)\+"\.google-analytics\.com\/g\/collect"/g,
+      GA_COLLECT_RE,
       (_, prevChar) => `${prevChar ? `${prevChar} ` : ""}self.location.origin+"${gaRewrite.to}"`
     );
     output = output.replace(
-      /([\w$])?"https:\/\/"\+\(.*?\)\+"\.analytics\.google\.com\/g\/collect"/g,
+      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}`;
@@ -376,7 +697,7 @@ 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 h = hash(url);
     const file = `${h.startsWith("-") ? `_${h.slice(1)}` : h}.js`;
@@ -483,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) {
@@ -498,7 +819,7 @@ function NuxtScriptBundleTransformer(options = {
             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;
@@ -506,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") {
@@ -710,6 +1031,7 @@ function NuxtScriptBundleTransformer(options = {
   });
 }
 
+const TRIGGER_PLACEHOLDER_RE = /"__TRIGGER_PLACEHOLDER__"/g;
 function registerTypeTemplates({ nuxt, config, newScripts }) {
   addTypeTemplate({
     filename: "types/nuxt-scripts-augments.d.ts",
@@ -721,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 {
@@ -822,7 +1144,7 @@ function templatePlugin(config, registry) {
             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) || {};
@@ -844,7 +1166,7 @@ function templatePlugin(config, registry) {
         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} }) })`);
@@ -859,7 +1181,7 @@ function templatePlugin(config, registry) {
         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} }) })`);
@@ -1076,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 : void 0;
-    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 = [];
@@ -1142,52 +1458,10 @@ const module$1 = defineNuxtModule({
         return templateTriggerResolver(config.defaultScriptOptions);
       }
     });
-    logger.debug("[nuxt-scripts] First-party config:", { firstPartyEnabled, firstPartyPrivacy, firstPartyCollectPrefix });
+    logger.debug("[nuxt-scripts] First-party config:", firstParty);
     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
-      });
+    if (firstParty.enabled) {
+      interceptRules = await setupFirstPartyHandlers(firstParty, resolvePath);
     }
     const scripts = await registry(resolvePath);
     for (const script of scripts) {
@@ -1216,96 +1490,14 @@ 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 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 (config.registry?.posthog && typeof config.registry.posthog === "object") {
-          const phConfig = Array.isArray(config.registry.posthog) ? config.registry.posthog[0] : config.registry.posthog;
-          if (phConfig && !phConfig.apiHost) {
-            const region = phConfig.region || "us";
-            phConfig.apiHost = region === "eu" ? `${firstPartyCollectPrefix}/ph-eu` : `${firstPartyCollectPrefix}/ph`;
-            const rtScripts = nuxt.options.runtimeConfig.public.scripts;
-            if (rtScripts?.posthog && typeof rtScripts.posthog === "object") {
-              const rtPhConfig = Array.isArray(rtScripts.posthog) ? rtScripts.posthog[0] : rtScripts.posthog;
-              if (rtPhConfig)
-                rtPhConfig.apiHost = phConfig.apiHost;
-            }
-          }
-        }
-        if (config.registry?.plausibleAnalytics && typeof config.registry.plausibleAnalytics === "object") {
-          const paConfig = Array.isArray(config.registry.plausibleAnalytics) ? config.registry.plausibleAnalytics[0] : config.registry.plausibleAnalytics;
-          if (paConfig && !paConfig.endpoint) {
-            paConfig.endpoint = `${firstPartyCollectPrefix}/plausible/api/event`;
-            const rtScripts = nuxt.options.runtimeConfig.public.scripts;
-            if (rtScripts?.plausibleAnalytics && typeof rtScripts.plausibleAnalytics === "object") {
-              const rtPaConfig = Array.isArray(rtScripts.plausibleAnalytics) ? rtScripts.plausibleAnalytics[0] : rtScripts.plausibleAnalytics;
-              if (rtPaConfig)
-                rtPaConfig.endpoint = paConfig.endpoint;
-            }
-          }
-        }
-        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`
-          );
-        }
-        interceptRules = routesToInterceptRules(neededRoutes);
-        const flatRoutes = {};
-        for (const [path, config2] of Object.entries(neededRoutes)) {
-          flatRoutes[path] = config2.proxy;
-        }
-        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
-        };
-        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}`);
-              }
-            }
-          }
-        }
-        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(), {
@@ -1314,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));
@@ -1329,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?.();
       });