@nuxt/scripts 1.3.3 → 1.3.4

package/dist/module.d.mts

@@ -30,7 +30,7 @@ interface ResolvedProxySecret {
  * 3. Dev-only auto-generation: write to `.env` (or keep in memory as last resort)
  * 4. Empty string (prod without secret; caller decides whether this is fatal)
  */
-declare function resolveProxySecret(rootDir: string, isDev: boolean, configSecret?: string, autoGenerate?: boolean): ResolvedProxySecret | undefined;
+declare function resolveProxySecret(rootDir: string, isDev: boolean, configSecret?: string, autoGenerate?: boolean): Promise<ResolvedProxySecret | undefined>;
 declare function isProxyDisabled(registryKey: string, registry?: NuxtConfigScriptRegistry, runtimeConfig?: Record<string, any>): boolean;
 declare function applyAutoInject(registry: NuxtConfigScriptRegistry, runtimeConfig: Record<string, any>, proxyPrefix: string, registryKey: string, autoInject: ResolvedProxyAutoInject, alias?: ProxyAliasConfig): void;
 declare function resolveConfiguredProxyDomains(config: Record<string, any> | undefined, proxyConfig?: Pick<ProxyConfig, 'autoInject' | 'configDomainFields'>): string[];

package/dist/module.d.ts

@@ -30,7 +30,7 @@ interface ResolvedProxySecret {
  * 3. Dev-only auto-generation: write to `.env` (or keep in memory as last resort)
  * 4. Empty string (prod without secret; caller decides whether this is fatal)
  */
-declare function resolveProxySecret(rootDir: string, isDev: boolean, configSecret?: string, autoGenerate?: boolean): ResolvedProxySecret | undefined;
+declare function resolveProxySecret(rootDir: string, isDev: boolean, configSecret?: string, autoGenerate?: boolean): Promise<ResolvedProxySecret | undefined>;
 declare function isProxyDisabled(registryKey: string, registry?: NuxtConfigScriptRegistry, runtimeConfig?: Record<string, any>): boolean;
 declare function applyAutoInject(registry: NuxtConfigScriptRegistry, runtimeConfig: Record<string, any>, proxyPrefix: string, registryKey: string, autoInject: ResolvedProxyAutoInject, alias?: ProxyAliasConfig): void;
 declare function resolveConfiguredProxyDomains(config: Record<string, any> | undefined, proxyConfig?: Pick<ProxyConfig, 'autoInject' | 'configDomainFields'>): string[];

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.16"
   },
-  "version": "1.3.3",
+  "version": "1.3.4",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,23 +1,27 @@
 import { createHash, randomBytes } from 'node:crypto';
-import { existsSync, readFileSync, appendFileSync, writeFileSync, readdirSync } from 'node:fs';
-import { useNuxt, addDevServerHandler, extendRouteRules, tryUseNuxt, createResolver, extendViteConfig, logger as logger$1, useLogger, addTypeTemplate, defineNuxtModule, addPluginTemplate, addServerHandler, addImports, addComponentsDir, addTemplate, hasNuxtModule, addBuildPlugin, addPlugin } from '@nuxt/kit';
+import { existsSync, readFileSync, writeFileSync, appendFileSync, readdirSync } from 'node:fs';
+import fsp, { open, stat, unlink } from 'node:fs/promises';
+import { setTimeout } from 'node:timers/promises';
+import { useNuxt, addDevServerHandler, extendRouteRules, tryUseNuxt, createResolver, extendViteConfig, logger as logger$1, useLogger, getNuxtVersion, addTypeTemplate, resolvePath, defineNuxtModule, addPluginTemplate, addServerHandler, addImports, addComponentsDir, addTemplate, hasNuxtModule, addBuildPlugin, addPlugin } from '@nuxt/kit';
 import { defu } from 'defu';
-import { join, resolve } from 'pathe';
+import { join, resolve, dirname } from 'pathe';
 import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
 import { lazyEventHandler, eventHandler, createError, setHeader } 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 { Buffer as Buffer$1 } from 'node:buffer';
 import { isCI, provider } from 'std-env';
+import { pathToFileURL } from 'node:url';
 import { parseAndWalk, ScopeTracker, walk, ScopeTrackerFunction, ScopeTrackerIdentifier, ScopeTrackerFunctionParam, ScopeTrackerVariable } from 'oxc-walker';
 import { createUnplugin } from 'unplugin';
-import { pathToFileURL } from 'node:url';
-import fsp from 'node:fs/promises';
 import { colors } from 'consola/utils';
 import MagicString from 'magic-string';
 import { hash } from 'ohash';
 import { getBundleResolve, registry, resolveCapabilities, getPartytownForwards, buildProxyConfigsFromRegistry, generatePartytownResolveUrl } from './registry.mjs';
+import { ensureNuxtScriptsCacheStorage } from '../dist/runtime/server/utils/cache-config.js';
+import { isPublicNetworkHostname } from '../dist/runtime/server/utils/network-host.js';
 import '../dist/runtime/registry/schemas.js';
 
 const renderedScript = /* @__PURE__ */ new Map();
@@ -83,6 +87,7 @@ function setupPublicAssetStrategy(assetsBaseURL) {
 const DEVTOOLS_UI_ROUTE = "/__nuxt-scripts";
 const DEVTOOLS_UI_LOCAL_PORT = 3030;
 const DEVTOOLS_API_STATE_ROUTE = "/__nuxt-scripts-api/state";
+const DEVTOOLS_API_MAX_BODY_SIZE = 2 * 1024 * 1024;
 async function setupDevtools(nuxt, options = {}) {
   const { addCustomTab } = await import('@nuxt/devtools-kit');
   const { resolve } = createResolver(import.meta.url);
@@ -139,13 +144,38 @@ function setupStandaloneApi(nuxt) {
         return;
       }
       if (req.method === "POST") {
-        let body = "";
-        req.on("data", (chunk) => {
-          body += chunk.toString();
-        });
-        req.on("end", () => {
+        let cleanup = function() {
+          req.off("data", onData);
+          req.off("end", onEnd);
+          req.off("aborted", onAborted);
+          req.off("error", onAborted);
+        }, onAborted = function() {
+          finished = true;
+          chunks = [];
+          cleanup();
+        }, onData = function(chunk) {
+          if (finished)
+            return;
+          size += chunk.byteLength;
+          if (size > DEVTOOLS_API_MAX_BODY_SIZE) {
+            finished = true;
+            chunks = [];
+            cleanup();
+            req.once("error", () => {
+            });
+            req.resume();
+            res.statusCode = 413;
+            res.end("payload too large");
+            return;
+          }
+          chunks.push(chunk);
+        }, onEnd = function() {
+          if (finished)
+            return;
+          finished = true;
+          cleanup();
           try {
-            const data = JSON.parse(body);
+            const data = JSON.parse(Buffer$1.concat(chunks, size).toString("utf8"));
             scriptsState = { ...data, updatedAt: Date.now() };
             res.statusCode = 200;
             res.end("ok");
@@ -153,7 +183,15 @@ function setupStandaloneApi(nuxt) {
             res.statusCode = 400;
             res.end("invalid json");
           }
-        });
+          chunks = [];
+        };
+        let chunks = [];
+        let size = 0;
+        let finished = false;
+        req.on("data", onData);
+        req.on("end", onEnd);
+        req.on("aborted", onAborted);
+        req.on("error", onAborted);
         return;
       }
       res.statusCode = 405;
@@ -214,8 +252,11 @@ function buildDevtoolsData(proxyPrefix, privacyLabel, scripts, aliasToDomain) {
 
 const isStackblitz = provider === "stackblitz";
 async function promptToInstall(name, installCommand, options) {
-  if (await resolvePackageJSON(name).catch(() => null))
+  if (await resolvePackageJSON(name).catch(() => {
+    return null;
+  })) {
     return true;
+  }
   logger$1.info(`Package ${name} is missing`);
   if (isCI)
     return false;
@@ -254,6 +295,89 @@ function installNuxtModule(name, options) {
 
 const logger = useLogger("@nuxt/scripts");
 
+const NITRO_RUNTIME_MODULE = "#nuxt-scripts/nitro";
+const H3_RUNTIME_MODULE = "#nuxt-scripts/h3";
+const TYPE_TEMPLATE_FILENAME = "types/nuxt-scripts-nitro.d.ts";
+const defaultDependencies = {
+  addTypeTemplate,
+  getNuxtVersion
+};
+const nitroV2Runtime = `export {
+  defineCachedFunction,
+  useNitroApp,
+  useRuntimeConfig,
+} from 'nitropack/runtime'
+`;
+const nitroV3RuntimeTypes = `export { useNitroApp } from 'nitro/app'
+export { defineCachedFunction } from 'nitro/cache'
+export function useRuntimeConfig(event?: import('nitro/h3').H3Event): ReturnType<typeof import('nitro/runtime-config').useRuntimeConfig>
+`;
+function indent(value, spaces) {
+  const padding = " ".repeat(spaces);
+  return value.split("\n").map((line) => `${padding}${line}`).join("\n");
+}
+function renderRuntimeDeclarations(compatibility) {
+  const nitroRuntime = compatibility._tag === "nitro-v3" ? nitroV3RuntimeTypes : nitroV2Runtime;
+  const h3Runtime = compatibility._tag === "nitro-v3" ? `export * from 'nitro/h3'
+` : `export * from 'h3'
+`;
+  return `declare module '${NITRO_RUNTIME_MODULE}' {
+${indent(nitroRuntime.trim(), 2)}
+}
+
+declare module '${H3_RUNTIME_MODULE}' {
+${indent(h3Runtime.trim(), 2)}
+}
+`;
+}
+function renderNitroV3Runtime(compatibility) {
+  return `export { useNitroApp } from ${JSON.stringify(compatibility.app)}
+export { defineCachedFunction } from ${JSON.stringify(compatibility.cache)}
+import { useRuntimeConfig as _useRuntimeConfig } from ${JSON.stringify(compatibility.runtimeConfig)}
+export function useRuntimeConfig(_event) { return _useRuntimeConfig() }
+`;
+}
+function applyNitroRuntimeCompatibility(nuxt, compatibility) {
+  const nuxtOptions = nuxt.options;
+  const nitroOptions = nuxtOptions.nitro ||= {};
+  const h3Runtime = compatibility._tag === "nitro-v3" ? compatibility.h3 : "h3";
+  nitroOptions.alias ||= {};
+  nitroOptions.virtual ||= {};
+  const nuxtAliases = nuxtOptions.alias ||= {};
+  delete nuxtAliases[H3_RUNTIME_MODULE];
+  nuxtOptions.alias = { [H3_RUNTIME_MODULE]: h3Runtime, ...nuxtAliases };
+  nitroOptions.alias[H3_RUNTIME_MODULE] = h3Runtime;
+  nitroOptions.virtual[NITRO_RUNTIME_MODULE] = compatibility._tag === "nitro-v3" ? renderNitroV3Runtime(compatibility) : nitroV2Runtime;
+}
+async function createNuxtNitroImportResolver() {
+  const nuxtDir = dirname(await resolvePath("nuxt/package.json"));
+  const nitroDir = dirname(await resolvePath("@nuxt/nitro-server/package.json", { cwd: nuxtDir }));
+  return async (id) => {
+    const resolved = await resolvePath(id, { cwd: nitroDir });
+    if (!existsSync(resolved))
+      throw new Error(`[nuxt-scripts] Could not resolve Nitro runtime helper "${id}" from "${nitroDir}".`);
+    return pathToFileURL(resolved).href;
+  };
+}
+async function resolveNitroV3Compatibility(resolveNitroImport) {
+  const [app, cache, h3, runtimeConfig] = await Promise.all([
+    resolveNitroImport("nitro/app"),
+    resolveNitroImport("nitro/cache"),
+    resolveNitroImport("nitro/h3"),
+    resolveNitroImport("nitro/runtime-config")
+  ]);
+  return { _tag: "nitro-v3", app, cache, h3, runtimeConfig };
+}
+async function setupNitroRuntimeCompatibility(nuxt, dependencies = defaultDependencies) {
+  const compatibility = Number.parseInt(dependencies.getNuxtVersion(nuxt), 10) >= 5 ? await resolveNitroV3Compatibility(dependencies.resolveNitroImport || await createNuxtNitroImportResolver()) : { _tag: "nitro-v2" };
+  applyNitroRuntimeCompatibility(nuxt, compatibility);
+  nuxt.hooks.hookOnce("modules:done", () => applyNitroRuntimeCompatibility(nuxt, compatibility));
+  dependencies.addTypeTemplate({
+    filename: TYPE_TEMPLATE_FILENAME,
+    getContents: async () => renderRuntimeDeclarations(compatibility)
+  }, { nitro: true, node: true, nuxt: true });
+}
+
 const SCRIPT_OPTION_KEYS = ["trigger", "proxy", "bundle", "partytown"];
 function extractRequiredFields(schema) {
   if (!schema)
@@ -424,12 +548,14 @@ function NuxtScriptsCheckScripts() {
 
 function generateInterceptPluginContents(proxyPrefix, options) {
   const testMode = options?.testMode ?? false;
-  return `export default defineNuxtPlugin({
+  return `import { defineNuxtPlugin } from 'nuxt/app'
+
+export default defineNuxtPlugin({
   name: 'nuxt-scripts:intercept',
   enforce: 'pre',
   setup() {
     const proxyPrefix = ${JSON.stringify(proxyPrefix)};
-    const domainAliases = ${JSON.stringify(options?.domainAliases ?? {})};
+    const domainAliases = Object.assign(Object.create(null), ${JSON.stringify(options?.domainAliases ?? {})});
     const origBeacon = typeof navigator !== 'undefined' && navigator.sendBeacon
       ? navigator.sendBeacon.bind(navigator)
       : () => false;
@@ -438,11 +564,11 @@ function generateInterceptPluginContents(proxyPrefix, options) {
     function proxyUrl(url) {
       try {
         const parsed = new URL(url, location.origin);
-        if (parsed.origin !== location.origin) {
+        if ((parsed.protocol === 'http:' || parsed.protocol === 'https:') && parsed.origin !== location.origin) {
           const seg = domainAliases[parsed.host] || parsed.host;
           return location.origin + proxyPrefix + '/' + seg + parsed.pathname + parsed.search;
         }
-      } catch {}
+      } catch { /* Invalid URL inputs retain native behavior. */ }
       return url;
     }
 
@@ -1339,7 +1465,7 @@ function NuxtScriptBundleTransformer(options = {
 const WILDCARD_RE = /\*/;
 const SAFE_ALIAS_SEGMENT_RE = /^[\w.-]+$/;
 function isSafeAliasSegment(alias) {
-  return SAFE_ALIAS_SEGMENT_RE.test(alias);
+  return alias !== "." && alias !== ".." && SAFE_ALIAS_SEGMENT_RE.test(alias);
 }
 function aliasForDomain(domain, alias) {
   if (!alias || WILDCARD_RE.test(domain))
@@ -1349,19 +1475,16 @@ function aliasForDomain(domain, alias) {
   return Object.hasOwn(alias, domain) ? alias[domain] || void 0 : void 0;
 }
 function buildDomainAliasMap(domains, alias) {
-  const map = {};
+  const entries = [];
   for (const domain of domains) {
     const value = aliasForDomain(domain, alias);
     if (value)
-      map[domain] = value;
+      entries.push([domain, value]);
   }
-  return map;
+  return Object.fromEntries(entries);
 }
 function invertAliasMap(map) {
-  const out = {};
-  for (const [domain, alias] of Object.entries(map))
-    out[alias] = domain;
-  return out;
+  return Object.fromEntries(Object.entries(map).map(([domain, alias]) => [alias, domain]));
 }
 function aliasProxyValue(value, proxyPrefix, alias) {
   const prefix = `${proxyPrefix}/`;
@@ -1595,6 +1718,20 @@ function templatePlugin(config, registry) {
   ].join("\n");
 }
 
+const SOURCE_LESS_SCRIPT_LOADER_TYPE = /\bUseScriptLoaderInput\b/;
+function hasUnheadSourceLessScriptLoader(typesSource) {
+  return SOURCE_LESS_SCRIPT_LOADER_TYPE.test(typesSource);
+}
+function hasUnheadSourceLessScriptLoaderFile(typesPath) {
+  if (!typesPath || !existsSync(typesPath))
+    return false;
+  try {
+    return hasUnheadSourceLessScriptLoader(readFileSync(typesPath, "utf8"));
+  } catch {
+    return false;
+  }
+}
+
 const UPPER_RE$1 = /([A-Z])/g;
 const toScreamingSnake$1 = (s) => s.replace(UPPER_RE$1, "_$1").toUpperCase();
 const ENV_PREFIX = "NUXT_PUBLIC_SCRIPTS_";
@@ -1802,9 +1939,57 @@ function fixSelfClosingScriptComponents(nuxt) {
 const UPPER_RE = /([A-Z])/g;
 const toScreamingSnake = (s) => s.replace(UPPER_RE, "_$1").toUpperCase();
 const PROXY_SECRET_ENV_KEY = "NUXT_SCRIPTS_PROXY_SECRET";
-const PROXY_SECRET_ENV_LINE_RE = /^NUXT_SCRIPTS_PROXY_SECRET=/m;
+const PROXY_SECRET_ENV_LINE_RE = /^NUXT_SCRIPTS_PROXY_SECRET=.*$/m;
 const PROXY_SECRET_ENV_VALUE_RE = /^NUXT_SCRIPTS_PROXY_SECRET=(.+)$/m;
-function resolveProxySecret(rootDir, isDev, configSecret, autoGenerate = true) {
+const PROXY_SECRET_LOCK_RETRY_MS = 10;
+const PROXY_SECRET_LOCK_TIMEOUT_MS = 2e3;
+async function withProxySecretFileLock(envPath, effect) {
+  const lockPath = `${envPath}.nuxt-scripts.lock`;
+  const deadline = Date.now() + PROXY_SECRET_LOCK_TIMEOUT_MS;
+  let lockHandle;
+  while (!lockHandle) {
+    const acquisition = await open(lockPath, "wx").then((handle) => ({ _tag: "Acquired", handle })).catch((error) => {
+      if (error.code === "EEXIST")
+        return { _tag: "Busy" };
+      throw error;
+    });
+    if (acquisition._tag === "Acquired") {
+      lockHandle = acquisition.handle;
+      break;
+    }
+    const existingLock = await stat(lockPath).then((lockStat) => ({ _tag: "Found", mtimeMs: lockStat.mtimeMs })).catch((error) => {
+      if (error.code === "ENOENT")
+        return { _tag: "Missing" };
+      throw error;
+    });
+    if (existingLock._tag === "Found" && Date.now() - existingLock.mtimeMs >= PROXY_SECRET_LOCK_TIMEOUT_MS) {
+      await unlink(lockPath).catch((error) => {
+        if (error.code !== "ENOENT")
+          throw error;
+      });
+      continue;
+    }
+    if (Date.now() >= deadline)
+      throw Object.assign(new Error("Timed out waiting for proxy secret file lock"), { code: "ETIMEDOUT" });
+    await setTimeout(PROXY_SECRET_LOCK_RETRY_MS);
+  }
+  let effectResult;
+  try {
+    effectResult = { _tag: "Success", value: effect() };
+  } catch (error) {
+    effectResult = { _tag: "Failure", error };
+  }
+  const closeResult = await lockHandle.close().then(() => ({ _tag: "Success" })).catch((error) => ({ _tag: "Failure", error }));
+  const unlinkResult = await unlink(lockPath).then(() => ({ _tag: "Success" })).catch((error) => error.code === "ENOENT" ? { _tag: "Success" } : { _tag: "Failure", error });
+  if (closeResult._tag === "Failure")
+    logger.warn(`[security] Failed to close the proxy secret lock: ${closeResult.error.message}`);
+  if (unlinkResult._tag === "Failure")
+    logger.warn(`[security] Failed to remove the proxy secret lock: ${unlinkResult.error.message}`);
+  if (effectResult._tag === "Failure")
+    throw effectResult.error;
+  return effectResult.value;
+}
+async function resolveProxySecret(rootDir, isDev, configSecret, autoGenerate = true) {
   if (configSecret)
     return { secret: configSecret, ephemeral: false, source: "config" };
   const envSecret = process.env[PROXY_SECRET_ENV_KEY];
@@ -1817,21 +2002,26 @@ function resolveProxySecret(rootDir, isDev, configSecret, autoGenerate = true) {
   const line = `${PROXY_SECRET_ENV_KEY}=${secret}
 `;
   try {
-    if (existsSync(envPath)) {
-      const contents = readFileSync(envPath, "utf-8");
-      if (PROXY_SECRET_ENV_LINE_RE.test(contents)) {
-        const match = contents.match(PROXY_SECRET_ENV_VALUE_RE);
-        if (match?.[1])
-          return { secret: match[1].trim(), ephemeral: false, source: "dotenv-generated" };
-      }
-      appendFileSync(envPath, contents.endsWith("\n") ? line : `
+    const persistedSecret = await withProxySecretFileLock(envPath, () => {
+      if (existsSync(envPath)) {
+        const contents = readFileSync(envPath, "utf-8");
+        const existingSecret = contents.match(PROXY_SECRET_ENV_VALUE_RE)?.[1]?.trim();
+        if (existingSecret)
+          return existingSecret;
+        if (PROXY_SECRET_ENV_LINE_RE.test(contents)) {
+          writeFileSync(envPath, contents.replace(PROXY_SECRET_ENV_LINE_RE, `${PROXY_SECRET_ENV_KEY}=${secret}`));
+        } else {
+          appendFileSync(envPath, contents.endsWith("\n") ? line : `
 ${line}`);
-    } else {
-      writeFileSync(envPath, `# Generated by @nuxt/scripts
+        }
+      } else {
+        writeFileSync(envPath, `# Generated by @nuxt/scripts
 ${line}`);
-    }
-    process.env[PROXY_SECRET_ENV_KEY] = secret;
-    return { secret, ephemeral: false, source: "dotenv-generated" };
+      }
+      return secret;
+    });
+    process.env[PROXY_SECRET_ENV_KEY] = persistedSecret;
+    return { secret: persistedSecret, ephemeral: false, source: "dotenv-generated" };
   } catch {
     process.env[PROXY_SECRET_ENV_KEY] = secret;
     return { secret, ephemeral: true, source: "memory-generated" };
@@ -1874,7 +2064,10 @@ function resolveConfiguredProxyDomain(value) {
   if (!trimmed || !ABSOLUTE_URL_RE.test(trimmed) && !trimmed.startsWith("//"))
     return;
   try {
-    return new URL(trimmed, "https://nuxt-scripts.local").hostname || void 0;
+    const url = new URL(trimmed, "https://nuxt-scripts.local");
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+      return;
+    return isPublicNetworkHostname(url.hostname) ? url.hostname : void 0;
   } catch {
   }
 }
@@ -1939,6 +2132,7 @@ const module$1 = defineNuxtModule({
       logger.debug("The module is disabled, skipping setup.");
       return;
     }
+    await setupNitroRuntimeCompatibility(nuxt);
     if (nuxt.options.dev) {
       setupDevtools(nuxt, { standalone: config._standaloneDevtools });
       if (config._standaloneDevtools) {
@@ -1951,9 +2145,21 @@ const module$1 = defineNuxtModule({
         });
       }
     }
-    const { version: unheadVersion } = await readPackageJSON("@unhead/vue", {
-      from: nuxt.options.modulesDir
-    }).catch(() => ({ version: null }));
+    const unheadScriptsAlias = nuxt.options.alias["@unhead/vue/scripts"];
+    const unheadPackagePath = await (typeof unheadScriptsAlias === "string" ? resolvePackageJSON(unheadScriptsAlias) : Promise.reject(new Error("No Unhead scripts alias"))).catch(() => resolvePackageJSON("@unhead/vue", {
+      // Match the package instance imported by the built runtime. An app can
+      // contain another Unhead version with different loader capabilities.
+      from: [resolveModule("./runtime")]
+    })).catch(() => {
+      return null;
+    });
+    const unheadPackage = unheadPackagePath ? await readPackageJSON(unheadPackagePath).catch(() => {
+      return null;
+    }) : null;
+    const unheadVersion = unheadPackage?.version;
+    const scriptsTypesExport = unheadPackage?.exports?.["./scripts"]?.types;
+    const scriptsTypesPath = unheadPackagePath && typeof scriptsTypesExport === "string" ? resolve(dirname(unheadPackagePath), scriptsTypesExport) : null;
+    const unheadSourceLessScriptLoader = hasUnheadSourceLessScriptLoaderFile(scriptsTypesPath);
     if (unheadVersion?.startsWith("1")) {
       logger.error(`Nuxt Scripts requires Unhead >= 2, you are using v${unheadVersion}. Please run \`nuxi upgrade --clean\` to upgrade...`);
     }
@@ -2012,10 +2218,19 @@ const module$1 = defineNuxtModule({
       googleStaticMapsProxy: googleMapsEnabled ? { enabled: true, cacheMaxAge: config.googleStaticMapsProxy?.cacheMaxAge ?? 3600 } : void 0
     };
     const debugConst = JSON.stringify(!!config.debug);
+    const unheadSourceLessConst = JSON.stringify(unheadSourceLessScriptLoader);
     nuxt.options.vite ||= {};
-    nuxt.options.vite.define = { ...nuxt.options.vite.define, __NUXT_SCRIPTS_DEBUG__: debugConst };
+    nuxt.options.vite.define = {
+      ...nuxt.options.vite.define,
+      __NUXT_SCRIPTS_DEBUG__: debugConst,
+      __NUXT_SCRIPTS_UNHEAD_SOURCELESS__: unheadSourceLessConst
+    };
     nuxt.options.nitro ||= {};
-    nuxt.options.nitro.replace = { ...nuxt.options.nitro.replace, __NUXT_SCRIPTS_DEBUG__: debugConst };
+    nuxt.options.nitro.replace = {
+      ...nuxt.options.nitro.replace,
+      __NUXT_SCRIPTS_DEBUG__: debugConst,
+      __NUXT_SCRIPTS_UNHEAD_SOURCELESS__: unheadSourceLessConst
+    };
     const scriptsBase = config.prefix || "/_scripts";
     const proxyPrefix = `${scriptsBase}/p`;
     const assetsPrefix = `${scriptsBase}/assets`;
@@ -2369,6 +2584,7 @@ Options: configure platform rewrites, switch to server-rendered mode, or disable
         );
       }
     }
+    ensureNuxtScriptsCacheStorage(nuxt.options.nitro);
     nuxt.options.runtimeConfig.public["nuxt-scripts"] = defu(
       { endpoints: enabledEndpoints },
       nuxt.options.runtimeConfig.public["nuxt-scripts"]
@@ -2388,7 +2604,7 @@ Options: configure platform rewrites, switch to server-rendered mode, or disable
   To enable signing, deploy with a server-rendered target or configure platform-level rewrites.`
       );
     } else if (anyHandlerRequiresSigning) {
-      const proxySecretResolved = resolveProxySecret(
+      const proxySecretResolved = await resolveProxySecret(
         nuxt.options.rootDir,
         !!nuxt.options.dev,
         config.security?.secret,

package/dist/registry.mjs

@@ -808,8 +808,8 @@ async function registry(resolve) {
 }
 function generatePartytownResolveUrl(proxyPrefix, domainAliases = {}) {
   return `function(url, location, type) {
-  if (url.origin !== location.origin) {
-    var aliases = ${JSON.stringify(domainAliases)};
+  if ((url.protocol === 'http:' || url.protocol === 'https:') && url.origin !== location.origin) {
+    var aliases = Object.assign(Object.create(null), ${JSON.stringify(domainAliases)});
     var seg = aliases[url.host] || url.host;
     return new URL(${JSON.stringify(proxyPrefix)} + '/' + seg + url.pathname + url.search, location.origin);
   }