@nuxt/scripts 1.0.0-beta.1 → 1.0.0-beta.12

package/dist/module.mjs

@@ -1,79 +1,36 @@
-import { useNuxt, extendViteConfig, useLogger, addDevServerHandler, tryUseNuxt, logger as logger$1, addTypeTemplate, defineNuxtModule, createResolver, addImports, addComponentsDir, addTemplate, addPluginTemplate, addBuildPlugin, addServerHandler, hasNuxtModule } from '@nuxt/kit';
+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 { defu } from 'defu';
-import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
-import { existsSync } from 'node:fs';
-import { createHash } from 'node:crypto';
-import fsp from 'node:fs/promises';
-import { createUnplugin } from 'unplugin';
-import MagicString from 'magic-string';
-import { asyncWalk, walk } from 'estree-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 { 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 { pathToFileURL } from 'node:url';
+import { addCustomTab } from '@nuxt/devtools-kit';
 import { isCI, provider } from 'std-env';
+import { parseAndWalk } from 'oxc-walker';
+import { createUnplugin } from 'unplugin';
+import { pathToFileURL } from 'node:url';
+import { createHash } from 'node:crypto';
+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.DLRgvHQg.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, "")
-      };
-    });
-  }
-  nuxt.hook("devtools:customTabs", (tabs) => {
-    tabs.push({
-      // 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();
@@ -86,6 +43,9 @@ function setupPublicAssetStrategy(options = {}) {
         const scriptDescriptor = renderedScript.get(join(assetsBaseURL, event.path.slice(1)));
         if (!scriptDescriptor || scriptDescriptor instanceof Error)
           throw createError({ statusCode: 404 });
+        if (scriptDescriptor.content) {
+          return scriptDescriptor.content;
+        }
         const key = `bundle:${filename}`;
         let res = await storage.getItemRaw(key);
         if (!res) {
@@ -97,31 +57,112 @@ function setupPublicAssetStrategy(options = {}) {
     })
   });
   if (nuxt.options.dev) {
-    nuxt.options.routeRules ||= {};
-    nuxt.options.routeRules[joinURL(assetsBaseURL, "**")] = {
+    extendRouteRules(joinURL(assetsBaseURL, "**"), {
       cache: {
         maxAge: ONE_YEAR_IN_SECONDS
       }
-    };
+    });
   }
-  nuxt.options.nitro.publicAssets ||= [];
   const cacheDir = join(nuxt.options.buildDir, "cache", "scripts");
-  nuxt.options.nitro.publicAssets.push();
-  nuxt.options.nitro = defu(nuxt.options.nitro, {
-    publicAssets: [{
+  nuxt.hook("nitro:config", (nitroConfig) => {
+    nitroConfig.publicAssets ||= [];
+    nitroConfig.publicAssets.push({
       dir: cacheDir,
       maxAge: ONE_YEAR_IN_SECONDS,
       baseURL: assetsBaseURL
-    }],
-    prerender: {
-      ignore: [assetsBaseURL]
-    }
+    });
+    nitroConfig.prerender ||= {};
+    nitroConfig.prerender.ignore ||= [];
+    nitroConfig.prerender.ignore.push(assetsBaseURL);
   });
   return {
     renderedScript
   };
 }
 
+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 isStackblitz = provider === "stackblitz";
+async function promptToInstall(name, installCommand, options) {
+  if (await resolvePackageJSON(name).catch(() => null))
+    return true;
+  logger$1.info(`Package ${name} is missing`);
+  if (isCI)
+    return false;
+  if (options.prompt === true || options.prompt !== false && !isStackblitz) {
+    const confirm = await logger$1.prompt(`Do you want to install ${name} package?`, {
+      type: "confirm",
+      name: "confirm",
+      initial: true
+    });
+    if (!confirm)
+      return false;
+  }
+  logger$1.info(`Installing ${name}...`);
+  try {
+    await installCommand();
+    logger$1.success(`Installed ${name}`);
+    return true;
+  } catch (err) {
+    logger$1.error(err);
+    return false;
+  }
+}
+const installPrompts = /* @__PURE__ */ new Set();
+function installNuxtModule(name, options) {
+  if (installPrompts.has(name))
+    return;
+  installPrompts.add(name);
+  const nuxt = tryUseNuxt();
+  if (!nuxt)
+    return;
+  return promptToInstall(name, async () => {
+    const { runCommand } = await import(String("nuxi"));
+    await runCommand("module", ["add", name, "--cwd", nuxt.options.rootDir]);
+  }, { rootDir: nuxt.options.rootDir, searchPaths: nuxt.options.modulesDir, ...options });
+}
+
+const logger = useLogger("@nuxt/scripts");
+
 function isVue(id, opts = {}) {
   const { search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
   if (id.endsWith(".vue") && !search) {
@@ -149,6 +190,173 @@ function isJS(id) {
   return JS_RE.test(pathname);
 }
 
+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, (_node) => {
+            if (_node.type === "VariableDeclaration" && _node.declarations?.[0]?.id?.type === "ObjectPattern") {
+              const objPattern = _node.declarations[0]?.id;
+              for (const property of objPattern.properties) {
+                if (property.type === "Property" && property.key.type === "Identifier" && property.key.name === "$script" && property.value.type === "Identifier") {
+                  nameNode = _node;
+                }
+              }
+            }
+            if (nameNode) {
+              let sequence = _node.type === "SequenceExpression" ? _node : null;
+              let assignmentExpression;
+              if (_node.type === "VariableDeclaration") {
+                if (_node.declarations[0]?.init?.type === "SequenceExpression") {
+                  sequence = _node.declarations[0]?.init;
+                  assignmentExpression = _node.declarations[0]?.init?.expressions?.[0];
+                }
+              }
+              if (sequence && !assignmentExpression) {
+                assignmentExpression = sequence.expressions[0]?.type === "AssignmentExpression" ? sequence.expressions[0] : null;
+              }
+              if (assignmentExpression) {
+                const right = assignmentExpression?.right;
+                if (right.callee?.name === "_withAsyncContext") {
+                  if (right.arguments[0]?.body?.name === "$script" || right.arguments[0]?.body?.callee?.object?.name === "$script") {
+                    errorNode = nameNode;
+                  }
+                }
+              }
+            }
+          });
+          if (errorNode) {
+            return this.error(new Error("You can't use a top-level await on $script as it will never resolve."));
+          }
+        }
+      }
+    };
+  });
+}
+
+function 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;
+}
+function rewriteScriptUrlsAST(content, filename, rewrites) {
+  const s = new MagicString(content);
+  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, `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, `self.location.origin+\`${rewritten}\``);
+        }
+      }
+    }
+    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 (callee?.type === "Identifier" && callee.name === "fetch") {
+        s.overwrite(callee.start, callee.end, "__nuxtScripts.fetch");
+      }
+      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");
+      }
+    }
+  });
+  let output = s.toString();
+  const gaRewrite = rewrites.find((r) => r.from.includes("google-analytics.com/g/collect"));
+  if (gaRewrite) {
+    output = output.replace(
+      /"https:\/\/"\+\(.*?\)\+"\.google-analytics\.com\/g\/collect"/g,
+      `self.location.origin+"${gaRewrite.to}"`
+    );
+    output = output.replace(
+      /"https:\/\/"\+\(.*?\)\+"\.analytics\.google\.com\/g\/collect"/g,
+      `self.location.origin+"${gaRewrite.to}"`
+    );
+  }
+  return output;
+}
+
 const SEVEN_DAYS_IN_MS = 7 * 24 * 60 * 60 * 1e3;
 function calculateIntegrity(content, algorithm = "sha384") {
   const hash = createHash(algorithm).update(content).digest("base64");
@@ -166,10 +374,8 @@ function normalizeScriptData(src, assetsBaseURL = "/_scripts") {
   if (hasProtocol(src, { acceptRelative: true })) {
     src = src.replace(/^\/\//, "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 || "";
@@ -178,7 +384,7 @@ function normalizeScriptData(src, assetsBaseURL = "/_scripts") {
   return { url: src };
 }
 async function downloadScript(opts, renderedScript, fetchOptions, cacheMaxAge) {
-  const { src, url, filename, forceDownload, integrity } = opts;
+  const { src, url, filename, forceDownload, integrity, proxyRewrites } = opts;
   if (src === url || !filename) {
     return;
   }
@@ -186,7 +392,8 @@ async function downloadScript(opts, renderedScript, fetchOptions, cacheMaxAge) {
   const scriptContent = renderedScript.get(src);
   let res = scriptContent instanceof Error ? void 0 : scriptContent?.content;
   if (!res) {
-    const cacheKey = `bundle:${filename}`;
+    const proxyRewritesHash = proxyRewrites?.length ? `-${hash(proxyRewrites)}` : "";
+    const cacheKey = proxyRewrites?.length ? `bundle-proxy:${filename.replace(".js", `${proxyRewritesHash}.js`)}` : `bundle:${filename}`;
     const shouldUseCache = !forceDownload && await storage.hasItem(cacheKey) && !await isCacheExpired(storage, filename, cacheMaxAge);
     if (shouldUseCache) {
       const cachedContent = await storage.getItemRaw(cacheKey);
@@ -212,8 +419,15 @@ async function downloadScript(opts, renderedScript, fetchOptions, cacheMaxAge) {
       size = contentLength ? Number(contentLength) / 1024 : 0;
       return Buffer.from(r._data || await r.arrayBuffer());
     });
-    const integrityHash = integrity && res ? calculateIntegrity(res, integrity === true ? "sha384" : integrity) : void 0;
     await storage.setItemRaw(`bundle:${filename}`, res);
+    if (proxyRewrites?.length && res) {
+      const content = res.toString("utf-8");
+      const rewritten = rewriteScriptUrlsAST(content, filename || "script.js", proxyRewrites);
+      res = Buffer.from(rewritten, "utf-8");
+      logger.debug(`Rewrote ${proxyRewrites.length} URL patterns in ${filename}`);
+    }
+    const integrityHash = integrity && res ? calculateIntegrity(res, integrity === true ? "sha384" : integrity) : void 0;
+    await storage.setItemRaw(cacheKey, res);
     await storage.setItem(`bundle-meta:${filename}`, {
       timestamp: Date.now(),
       src,
@@ -262,16 +476,21 @@ function NuxtScriptBundleTransformer(options = {
   return createUnplugin(() => {
     return {
       name: "nuxt:scripts:bundler-transformer",
-      transformInclude(id) {
-        return isVue(id, { type: ["template", "script"] }) || isJS(id);
-      },
-      async transform(code, id) {
-        if (!code.includes("useScript"))
-          return;
-        const ast = this.parse(code);
-        const s = new MagicString(code);
-        await asyncWalk(ast, {
-          async enter(_node) {
+      transform: {
+        filter: {
+          id: {
+            include: [/\.vue/, /\.[cm]?[jt]sx?$/],
+            exclude: [/\.(?:test|spec)\./]
+          }
+        },
+        async handler(code, id) {
+          if (!isVue(id, { type: ["template", "script"] }) && !isJS(id))
+            return;
+          if (!code.includes("useScript"))
+            return;
+          const s = new MagicString(code);
+          const deferredOps = [];
+          parseAndWalk(code, id, (_node) => {
             const calleeName = _node.callee?.name;
             if (!calleeName)
               return;
@@ -281,6 +500,11 @@ function NuxtScriptBundleTransformer(options = {
               const node = _node;
               let scriptSrcNode;
               let src;
+              let registryKey;
+              if (fnName !== "useScript") {
+                const baseName = fnName.replace(/^useScript/, "");
+                registryKey = baseName.length > 0 ? baseName.charAt(0).toLowerCase() + baseName.slice(1) : void 0;
+              }
               if (fnName === "useScript") {
                 if (node.arguments[0]?.type === "Literal") {
                   scriptSrcNode = node.arguments[0];
@@ -297,9 +521,7 @@ function NuxtScriptBundleTransformer(options = {
                 }
                 if (!registryNode.scriptBundling && !registryNode.src)
                   return;
-                const baseName = fnName.replace(/^useScript/, "");
-                const registryKey = baseName.length > 0 ? baseName.charAt(0).toLowerCase() + baseName.slice(1) : "";
-                const registryConfig = options.registryConfig?.[registryKey] || {};
+                const registryConfig = options.registryConfig?.[registryKey || ""] || {};
                 const fnArg0 = {};
                 if (node.arguments[0]?.type === "ObjectExpression") {
                   const optionsNode = node.arguments[0];
@@ -319,6 +541,8 @@ function NuxtScriptBundleTransformer(options = {
                   src = registryNode.scriptBundling && registryNode.scriptBundling(mergedOptions);
                   if (src === false)
                     return;
+                  if (!src && registryNode.src)
+                    src = registryNode.src;
                 }
               }
               if (!scriptSrcNode && !src) {
@@ -333,8 +557,7 @@ function NuxtScriptBundleTransformer(options = {
                   if (bundleProperty && bundleProperty.value.type === "Literal") {
                     const bundleValue = bundleProperty.value.value;
                     if (bundleValue === true || bundleValue === "force" || String(bundleValue) === "true") {
-                      const valueNode = bundleProperty.value;
-                      s.overwrite(valueNode.start, valueNode.end, `'unsupported'`);
+                      s.overwrite(bundleProperty.value.start, bundleProperty.value.end, `'unsupported'`);
                     }
                   }
                 }
@@ -351,8 +574,7 @@ function NuxtScriptBundleTransformer(options = {
                       (p) => (p.key?.name === "bundle" || p.key?.value === "bundle") && p.type === "Property"
                     );
                     if (bundleProperty && bundleProperty.value.type === "Literal") {
-                      const value = bundleProperty.value;
-                      const bundleValue = value.value;
+                      const bundleValue = bundleProperty.value.value;
                       if (bundleValue !== true && bundleValue !== "force" && String(bundleValue) !== "true") {
                         canBundle = false;
                         return;
@@ -380,175 +602,104 @@ function NuxtScriptBundleTransformer(options = {
                     canBundle = bundleValue === true || bundleValue === "force" || String(bundleValue) === "true";
                     forceDownload = bundleValue === "force";
                   }
+                  const firstPartyOption = scriptOptions?.value.properties?.find((prop) => {
+                    return prop.type === "Property" && prop.key?.name === "firstParty" && prop.value.type === "Literal";
+                  });
+                  let firstPartyOptOut = firstPartyOption?.value.value === false;
+                  if (!firstPartyOptOut && node.arguments[1]?.type === "ObjectExpression") {
+                    const secondArgFirstPartyProp = node.arguments[1].properties.find(
+                      (p) => p.type === "Property" && p.key?.name === "firstParty" && p.value.type === "Literal"
+                    );
+                    firstPartyOptOut = secondArgFirstPartyProp?.value.value === false;
+                  }
+                  if (!firstPartyOptOut && node.arguments[0]?.type === "ObjectExpression") {
+                    const firstArgFirstPartyProp = node.arguments[0].properties.find(
+                      (p) => p.type === "Property" && p.key?.name === "firstParty" && p.value.type === "Literal"
+                    );
+                    firstPartyOptOut = firstArgFirstPartyProp?.value.value === false;
+                  }
                   if (canBundle) {
                     const { url: _url, filename } = normalizeScriptData(src, options.assetsBaseURL);
-                    let url = _url;
-                    try {
-                      await downloadScript({ src, url, filename, forceDownload, integrity: options.integrity }, renderedScript, options.fetchOptions, options.cacheMaxAge);
-                    } catch (e) {
-                      if (options.fallbackOnSrcOnBundleFail) {
-                        logger.warn(`[Nuxt Scripts: Bundle Transformer] Failed to bundle ${src}. Fallback to remote loading.`);
-                        url = src;
-                      } else {
-                        const errorMessage = e?.message || "Unknown error";
-                        if (errorMessage.includes("timeout") || errorMessage.includes("network") || errorMessage.includes("ENOTFOUND")) {
-                          logger.error(`[Nuxt Scripts: Bundle Transformer] Network issue while bundling ${src}: ${errorMessage}`);
-                          logger.error(`[Nuxt Scripts: Bundle Transformer] Tip: Set 'fallbackOnSrcOnBundleFail: true' in module options or disable bundling in Docker environments`);
+                    const script = options.scripts?.find((s2) => s2.import.name === fnName);
+                    const proxyConfigKey = script?.proxy !== false ? script?.proxy || registryKey : void 0;
+                    const proxyRewrites = options.firstPartyEnabled && !firstPartyOptOut && proxyConfigKey && options.firstPartyCollectPrefix ? getProxyConfig(proxyConfigKey, options.firstPartyCollectPrefix)?.rewrite : void 0;
+                    deferredOps.push(async () => {
+                      let url = _url;
+                      try {
+                        await downloadScript({ src, url, filename, forceDownload, proxyRewrites, integrity: options.integrity }, renderedScript, options.fetchOptions, options.cacheMaxAge);
+                      } catch (e) {
+                        if (options.fallbackOnSrcOnBundleFail) {
+                          logger.warn(`[Nuxt Scripts: Bundle Transformer] Failed to bundle ${src}. Fallback to remote loading.`);
+                          url = src;
+                        } else {
+                          const errorMessage = e?.message || "Unknown error";
+                          if (errorMessage.includes("timeout") || errorMessage.includes("network") || errorMessage.includes("ENOTFOUND") || errorMessage.includes("certificate")) {
+                            logger.error(`[Nuxt Scripts: Bundle Transformer] Network issue while bundling ${src}: ${errorMessage}`);
+                            logger.error(`[Nuxt Scripts: Bundle Transformer] Tip: Set 'fallbackOnSrcOnBundleFail: true' in module options or disable bundling in Docker environments`);
+                          }
+                          throw e;
                         }
-                        throw e;
                       }
-                    }
-                    if (src === url) {
-                      if (src && src.startsWith("/"))
-                        logger.warn(`[Nuxt Scripts: Bundle Transformer] Relative scripts are already bundled. Skipping bundling for \`${src}\`.`);
-                      else
-                        logger.warn(`[Nuxt Scripts: Bundle Transformer] Failed to bundle ${src}.`);
-                    }
-                    const scriptMeta = renderedScript.get(url);
-                    const integrityHash = scriptMeta instanceof Error ? void 0 : scriptMeta?.integrity;
-                    if (scriptSrcNode) {
-                      if (integrityHash && fnName === "useScript" && node.arguments[0]?.type === "Literal") {
-                        s.overwrite(scriptSrcNode.start, scriptSrcNode.end, `{ src: '${url}', integrity: '${integrityHash}', crossorigin: 'anonymous' }`);
-                      } else if (integrityHash && fnName === "useScript" && node.arguments[0]?.type === "ObjectExpression") {
-                        s.overwrite(scriptSrcNode.start, scriptSrcNode.end, `'${url}'`);
-                        const objArg = node.arguments[0];
-                        s.appendLeft(objArg.end - 1, `, integrity: '${integrityHash}', crossorigin: 'anonymous'`);
-                      } else {
-                        s.overwrite(scriptSrcNode.start, scriptSrcNode.end, `'${url}'`);
+                      if (src === url) {
+                        if (src && src.startsWith("/"))
+                          logger.warn(`[Nuxt Scripts: Bundle Transformer] Relative scripts are already bundled. Skipping bundling for \`${src}\`.`);
+                        else
+                          logger.warn(`[Nuxt Scripts: Bundle Transformer] Failed to bundle ${src}.`);
                       }
-                    } else {
-                      const integrityProps = integrityHash ? `, integrity: '${integrityHash}', crossorigin: 'anonymous'` : "";
-                      if (node.arguments[0]) {
-                        const optionsNode = node.arguments[0];
-                        const scriptInputProperty = optionsNode.properties.find(
-                          (p) => p.key?.name === "scriptInput" || p.key?.value === "scriptInput"
-                        );
-                        if (scriptInputProperty) {
-                          const scriptInput = scriptInputProperty.value;
-                          if (scriptInput.type === "ObjectExpression") {
-                            const srcProperty = scriptInput.properties.find(
-                              (p) => p.key?.name === "src" || p.key?.value === "src"
-                            );
-                            if (srcProperty) {
-                              s.overwrite(srcProperty.value.start, srcProperty.value.end, `'${url}'`);
-                              if (integrityHash)
-                                s.appendLeft(scriptInput.end - 1, integrityProps);
-                            } else {
-                              s.appendRight(scriptInput.end - 1, `, src: '${url}'${integrityProps}`);
+                      const scriptMeta = renderedScript.get(url);
+                      const integrityHash = scriptMeta instanceof Error ? void 0 : scriptMeta?.integrity;
+                      if (scriptSrcNode) {
+                        if (integrityHash && fnName === "useScript" && node.arguments[0]?.type === "Literal") {
+                          s.overwrite(scriptSrcNode.start, scriptSrcNode.end, `{ src: '${url}', integrity: '${integrityHash}', crossorigin: 'anonymous' }`);
+                        } else if (integrityHash && fnName === "useScript" && node.arguments[0]?.type === "ObjectExpression") {
+                          s.overwrite(scriptSrcNode.start, scriptSrcNode.end, `'${url}'`);
+                          s.appendLeft(node.arguments[0].end - 1, `, integrity: '${integrityHash}', crossorigin: 'anonymous'`);
+                        } else {
+                          s.overwrite(scriptSrcNode.start, scriptSrcNode.end, `'${url}'`);
+                        }
+                      } else {
+                        const integrityProps = integrityHash ? `, integrity: '${integrityHash}', crossorigin: 'anonymous'` : "";
+                        if (node.arguments[0]) {
+                          const optionsNode = node.arguments[0];
+                          const scriptInputProperty = optionsNode.properties.find(
+                            (p) => p.key?.name === "scriptInput" || p.key?.value === "scriptInput"
+                          );
+                          if (scriptInputProperty) {
+                            const scriptInput = scriptInputProperty.value;
+                            if (scriptInput.type === "ObjectExpression") {
+                              const srcProperty = scriptInput.properties.find(
+                                (p) => p.key?.name === "src" || p.key?.value === "src"
+                              );
+                              if (srcProperty) {
+                                s.overwrite(srcProperty.value.start, srcProperty.value.end, `'${url}'`);
+                                if (integrityHash)
+                                  s.appendLeft(scriptInput.end - 1, integrityProps);
+                              } else {
+                                s.appendRight(scriptInput.end - 1, `, src: '${url}'${integrityProps}`);
+                              }
                             }
+                          } else {
+                            s.appendRight(node.arguments[0].start + 1, ` scriptInput: { src: '${url}'${integrityProps} }, `);
                           }
                         } else {
-                          s.appendRight(node.arguments[0].start + 1, ` scriptInput: { src: '${url}'${integrityProps} }, `);
+                          s.overwrite(node.callee.end, node.end, `({ scriptInput: { src: '${url}'${integrityProps} } })`);
                         }
-                      } else {
-                        s.appendRight(node.callee.end, `({ scriptInput: { src: '${url}'${integrityProps} } })`);
                       }
-                    }
+                    });
                   }
                 }
               }
             }
+          });
+          for (const op of deferredOps) {
+            await op();
           }
-        });
-        if (s.hasChanged()) {
-          return {
-            code: s.toString(),
-            map: s.generateMap({ includeContent: true, source: id })
-          };
-        }
-      }
-    };
-  });
-}
-
-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",
-      transformInclude(id) {
-        return isVue(id, { type: ["script"] });
-      },
-      async transform(code) {
-        if (!code.includes("useScript"))
-          return;
-        const ast = this.parse(code);
-        let nameNode;
-        let errorNode;
-        walk(ast, {
-          enter(_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 (s.hasChanged()) {
+            return {
+              code: s.toString(),
+              map: s.generateMap({ includeContent: true, source: id })
+            };
           }
-        });
-        if (errorNode) {
-          return this.error(new Error("You can't use a top-level await on $script as it will never resolve."));
         }
       }
     };
@@ -596,6 +747,7 @@ export {}`;
 function templateTriggerResolver(defaultScriptOptions) {
   const needsIdleTimeout = defaultScriptOptions?.trigger && typeof defaultScriptOptions.trigger === "object" && "idleTimeout" in defaultScriptOptions.trigger;
   const needsInteraction = defaultScriptOptions?.trigger && typeof defaultScriptOptions.trigger === "object" && "interaction" in defaultScriptOptions.trigger;
+  const needsServiceWorker = defaultScriptOptions?.trigger && typeof defaultScriptOptions.trigger === "object" && "serviceWorker" in defaultScriptOptions.trigger;
   const imports = [];
   if (needsIdleTimeout) {
     imports.push(`import { useScriptTriggerIdleTimeout } from '#nuxt-scripts/composables/useScriptTriggerIdleTimeout'`);
@@ -603,11 +755,15 @@ function templateTriggerResolver(defaultScriptOptions) {
   if (needsInteraction) {
     imports.push(`import { useScriptTriggerInteraction } from '#nuxt-scripts/composables/useScriptTriggerInteraction'`);
   }
+  if (needsServiceWorker) {
+    imports.push(`import { useScriptTriggerServiceWorker } from '#nuxt-scripts/composables/useScriptTriggerServiceWorker'`);
+  }
   return [
     ...imports,
     `export function resolveTrigger(trigger) {`,
     needsIdleTimeout ? `  if ('idleTimeout' in trigger) return useScriptTriggerIdleTimeout({ timeout: trigger.idleTimeout })` : "",
     needsInteraction ? `  if ('interaction' in trigger) return useScriptTriggerInteraction({ events: trigger.interaction })` : "",
+    needsServiceWorker ? `  if ('serviceWorker' in trigger) return useScriptTriggerServiceWorker()` : "",
     `  return null`,
     `}`
   ].filter(Boolean).join("\n");
@@ -624,6 +780,9 @@ function resolveTriggerForTemplate(trigger) {
     if ("interaction" in trigger) {
       return `useScriptTriggerInteraction({ events: ${JSON.stringify(trigger.interaction)} })`;
     }
+    if ("serviceWorker" in trigger) {
+      return `useScriptTriggerServiceWorker()`;
+    }
   }
   return null;
 }
@@ -634,27 +793,37 @@ function templatePlugin(config, registry) {
   }
   const imports = [];
   const inits = [];
+  const resolvedRegistryKeys = [];
   let needsIdleTimeoutImport = false;
   let needsInteractionImport = false;
+  let needsServiceWorkerImport = false;
   for (const [k, c] of Object.entries(config.registry || {})) {
-    const importDefinition = registry.find((i) => 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}'`);
-      const args = (typeof c !== "object" ? {} : c) || {};
       if (c === "mock") {
-        args.scriptOptions = { trigger: "manual", skipValidation: true };
-      } else if (Array.isArray(c) && c.length === 2 && c[1]?.trigger) {
-        const triggerResolved = resolveTriggerForTemplate(c[1].trigger);
+        inits.push(`const ${k} = ${importDefinition.import.name}({ scriptOptions: { trigger: 'manual', skipValidation: true } })`);
+      } else if (Array.isArray(c) && c.length === 2) {
+        const input = c[0] || {};
+        const scriptOptions = { ...c[1] };
+        const triggerResolved = resolveTriggerForTemplate(scriptOptions?.trigger);
         if (triggerResolved) {
-          args.scriptOptions = { ...c[1] };
-          if (args.scriptOptions) {
-            args.scriptOptions.trigger = `__TRIGGER_${triggerResolved}__`;
-          }
-          if (triggerResolved.includes("useScriptTriggerIdleTimeout")) needsIdleTimeoutImport = true;
-          if (triggerResolved.includes("useScriptTriggerInteraction")) needsInteractionImport = true;
+          scriptOptions.trigger = "__TRIGGER_PLACEHOLDER__";
+          if (triggerResolved.includes("useScriptTriggerIdleTimeout"))
+            needsIdleTimeoutImport = true;
+          if (triggerResolved.includes("useScriptTriggerInteraction"))
+            needsInteractionImport = true;
+          if (triggerResolved.includes("useScriptTriggerServiceWorker"))
+            needsServiceWorkerImport = true;
         }
+        const args = { ...input, scriptOptions };
+        const argsJson = triggerResolved ? JSON.stringify(args).replace(/"__TRIGGER_PLACEHOLDER__"/g, triggerResolved) : JSON.stringify(args);
+        inits.push(`const ${k} = ${importDefinition.import.name}(${argsJson})`);
+      } else {
+        const args = (typeof c !== "object" ? {} : c) || {};
+        inits.push(`const ${k} = ${importDefinition.import.name}(${JSON.stringify(args)})`);
       }
-      inits.push(`const ${k} = ${importDefinition.import.name}(${JSON.stringify(args).replace(/"__TRIGGER_(.*?)__"/g, "$1")})`);
     }
   }
   for (const [k, c] of Object.entries(config.globals || {})) {
@@ -664,20 +833,30 @@ 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;
-        const resolvedOptions = { ...options, trigger: `__TRIGGER_${triggerResolved}__` };
-        inits.push(`const ${k} = useScript(${JSON.stringify({ key: k, ...typeof c[0] === "string" ? { src: c[0] } : c[0] })}, { ...${JSON.stringify(resolvedOptions).replace(/"__TRIGGER_(.*?)__"/g, "$1")}, use: () => ({ ${k}: window.${k} }) })`);
+        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);
+        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} }) })`);
       }
     } 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;
-        const resolvedOptions = { ...c, trigger: `__TRIGGER_${triggerResolved}__` };
-        inits.push(`const ${k} = useScript(${JSON.stringify({ key: k, ...resolvedOptions }).replace(/"__TRIGGER_(.*?)__"/g, "$1")}, { use: () => ({ ${k}: window.${k} }) })`);
+        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);
+        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} }) })`);
       }
@@ -690,6 +869,9 @@ function templatePlugin(config, registry) {
   if (needsInteractionImport) {
     triggerImports.push(`import { useScriptTriggerInteraction } from '#nuxt-scripts/composables/useScriptTriggerInteraction'`);
   }
+  if (needsServiceWorkerImport) {
+    triggerImports.push(`import { useScriptTriggerServiceWorker } from '#nuxt-scripts/composables/useScriptTriggerServiceWorker'`);
+  }
   return [
     `import { useScript } from '#nuxt-scripts/composables/useScript'`,
     `import { defineNuxtPlugin } from 'nuxt/app'`,
@@ -702,12 +884,78 @@ function templatePlugin(config, registry) {
     `  parallel: true,`,
     `  setup() {`,
     ...inits.map((i) => `    ${i}`),
-    `    return { provide: { $scripts: { ${[...Object.keys(config.globals || {}), ...Object.keys(config.registry || {})].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 PARTYTOWN_FORWARDS = {
+  googleAnalytics: ["dataLayer.push", "gtag"],
+  plausible: ["plausible"],
+  fathom: ["fathom", "fathom.trackEvent", "fathom.trackPageview"],
+  umami: ["umami", "umami.track"],
+  matomo: ["_paq.push"],
+  segment: ["analytics", "analytics.track", "analytics.page", "analytics.identify"],
+  metaPixel: ["fbq"],
+  xPixel: ["twq"],
+  tiktokPixel: ["ttq.track", "ttq.page", "ttq.identify"],
+  snapchatPixel: ["snaptr"],
+  redditPixel: ["rdt"],
+  cloudflareWebAnalytics: ["__cfBeacon"]
+};
 const module$1 = defineNuxtModule({
   meta: {
     name: "@nuxt/scripts",
@@ -717,6 +965,7 @@ const module$1 = defineNuxtModule({
     }
   },
   defaults: {
+    firstParty: true,
     defaultScriptOptions: {
       trigger: "onNuxtReady"
     },
@@ -772,13 +1021,57 @@ const module$1 = defineNuxtModule({
         config.registry
       );
     }
+    if (config.defaultScriptOptions?.bundle !== void 0) {
+      logger.warn(
+        "`scripts.defaultScriptOptions.bundle` is deprecated. Use `scripts.firstParty: true` instead. First-party mode is now enabled by default."
+      );
+    }
+    const staticPresets = ["static", "github-pages", "cloudflare-pages-static"];
+    const preset = process.env.NITRO_PRESET || "";
+    const isStaticPreset = staticPresets.includes(preset);
+    const firstPartyEnabled = !!config.firstParty;
+    const firstPartyPrefix = typeof config.firstParty === "object" ? config.firstParty.prefix : void 0;
+    const firstPartyCollectPrefix = typeof config.firstParty === "object" ? config.firstParty.collectPrefix || "/_proxy" : "/_proxy";
+    const firstPartyPrivacy = typeof config.firstParty === "object" ? config.firstParty.privacy : void 0;
+    const assetsPrefix = firstPartyPrefix || config.assets?.prefix || "/_scripts";
+    if (config.partytown?.length) {
+      config.registry = config.registry || {};
+      const requiredForwards = [];
+      for (const scriptKey of config.partytown) {
+        const forwards = PARTYTOWN_FORWARDS[scriptKey];
+        if (forwards) {
+          requiredForwards.push(...forwards);
+        } else if (import.meta.dev) {
+          logger.warn(`[partytown] "${scriptKey}" has no known Partytown forwards configured. It may not work correctly or may require manual forward configuration.`);
+        }
+        const reg = config.registry;
+        const existing = reg[scriptKey];
+        if (Array.isArray(existing)) {
+          existing[1] = { ...existing[1], partytown: true };
+        } else if (existing && typeof existing === "object" && existing !== true && existing !== "mock") {
+          reg[scriptKey] = [existing, { partytown: true }];
+        } else if (existing === true || existing === "mock") {
+          reg[scriptKey] = [{}, { partytown: true }];
+        } else {
+          reg[scriptKey] = [{}, { partytown: true }];
+        }
+      }
+      if (requiredForwards.length && hasNuxtModule("@nuxtjs/partytown")) {
+        const partytownConfig = nuxt.options.partytown || {};
+        const existingForwards = partytownConfig.forward || [];
+        const newForwards = [.../* @__PURE__ */ new Set([...existingForwards, ...requiredForwards])];
+        nuxt.options.partytown = { ...partytownConfig, forward: newForwards };
+        logger.info(`[partytown] Auto-configured forwards: ${requiredForwards.join(", ")}`);
+      }
+    }
     const composables = [
       "useScript",
       "useScriptEventPage",
       "useScriptTriggerConsent",
       "useScriptTriggerElement",
       "useScriptTriggerIdleTimeout",
-      "useScriptTriggerInteraction"
+      "useScriptTriggerInteraction",
+      "useScriptTriggerServiceWorker"
     ];
     for (const composable of composables) {
       addImports({
@@ -792,12 +1085,60 @@ 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);
       }
     });
+    logger.debug("[nuxt-scripts] First-party config:", { firstPartyEnabled, firstPartyPrivacy, firstPartyCollectPrefix });
+    let interceptRules = [];
+    if (firstPartyEnabled) {
+      addPluginTemplate({
+        filename: "nuxt-scripts-intercept.client.mjs",
+        getContents() {
+          const rulesJson = JSON.stringify(interceptRules);
+          return `export default defineNuxtPlugin({
+  name: 'nuxt-scripts:intercept',
+  enforce: 'pre',
+  setup() {
+    const rules = ${rulesJson};
+    const origBeacon = typeof navigator !== 'undefined' && navigator.sendBeacon
+      ? navigator.sendBeacon.bind(navigator)
+      : () => false;
+    const origFetch = globalThis.fetch.bind(globalThis);
+
+    function rewriteUrl(url) {
+      try {
+        const parsed = new URL(url, location.origin);
+        for (const rule of rules) {
+          if (parsed.hostname === rule.pattern || parsed.hostname.endsWith('.' + rule.pattern)) {
+            if (rule.pathPrefix && !parsed.pathname.startsWith(rule.pathPrefix)) continue;
+            const path = rule.pathPrefix ? parsed.pathname.slice(rule.pathPrefix.length) : parsed.pathname;
+            return location.origin + rule.target + (path.startsWith('/') ? '' : '/') + path + parsed.search;
+          }
+        }
+      } catch {}
+      return url;
+    }
+
+    globalThis.__nuxtScripts = {
+      sendBeacon: (url, data) => origBeacon(rewriteUrl(url), data),
+      fetch: (url, opts) => origFetch(typeof url === 'string' ? rewriteUrl(url) : url, opts),
+    };
+  },
+})
+`;
+        }
+      });
+      const proxyHandlerPath = await resolvePath("./runtime/server/proxy-handler");
+      logger.debug("[nuxt-scripts] Registering proxy handler:", `${firstPartyCollectPrefix}/**`, "->", proxyHandlerPath);
+      addServerHandler({
+        route: `${firstPartyCollectPrefix}/**`,
+        handler: proxyHandlerPath
+      });
+    }
     const scripts = await registry(resolvePath);
     for (const script of scripts) {
       if (script.import?.name) {
@@ -825,6 +1166,79 @@ 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 = config.registry.posthog;
+          if (!phConfig.apiHost) {
+            const region = phConfig.region || "us";
+            phConfig.apiHost = region === "eu" ? `${firstPartyCollectPrefix}/ph-eu` : `${firstPartyCollectPrefix}/ph`;
+          }
+        }
+        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`
+          );
+        }
+      }
       const moduleInstallPromises = /* @__PURE__ */ new Map();
       addBuildPlugin(NuxtScriptsCheckScripts(), {
         dev: true
@@ -832,12 +1246,14 @@ const module$1 = defineNuxtModule({
       addBuildPlugin(NuxtScriptBundleTransformer({
         scripts: registryScriptsWithImport,
         registryConfig: nuxt.options.runtimeConfig.public.scripts,
-        defaultBundle: config.defaultScriptOptions?.bundle,
+        defaultBundle: firstPartyEnabled || config.defaultScriptOptions?.bundle,
+        firstPartyEnabled,
+        firstPartyCollectPrefix,
         moduleDetected(module) {
           if (nuxt.options.dev && module !== "@nuxt/scripts" && !moduleInstallPromises.has(module) && !hasNuxtModule(module))
             moduleInstallPromises.set(module, () => installNuxtModule(module));
         },
-        assetsBaseURL: config.assets?.prefix,
+        assetsBaseURL: assetsPrefix,
         fallbackOnSrcOnBundleFail: config.assets?.fallbackOnSrcOnBundleFail,
         fetchOptions: config.assets?.fetchOptions,
         cacheMaxAge: config.assets?.cacheMaxAge,
@@ -856,8 +1272,29 @@ const module$1 = defineNuxtModule({
         handler: await resolvePath("./runtime/server/google-static-maps-proxy")
       });
     }
-    if (nuxt.options.dev)
+    addServerHandler({
+      route: "/api/_scripts/x-embed",
+      handler: await resolvePath("./runtime/server/x-embed")
+    });
+    addServerHandler({
+      route: "/api/_scripts/x-embed-image",
+      handler: await resolvePath("./runtime/server/x-embed-image")
+    });
+    addServerHandler({
+      route: "/api/_scripts/instagram-embed",
+      handler: await resolvePath("./runtime/server/instagram-embed")
+    });
+    addServerHandler({
+      route: "/api/_scripts/instagram-embed-image",
+      handler: await resolvePath("./runtime/server/instagram-embed-image")
+    });
+    addServerHandler({
+      route: "/api/_scripts/instagram-embed-asset",
+      handler: await resolvePath("./runtime/server/instagram-embed-asset")
+    });
+    if (nuxt.options.dev) {
       setupDevToolsUI(config, resolvePath);
+    }
   }
 });