@nuxt/scripts 1.0.0-beta.3 → 1.0.0-beta.31

package/dist/runtime/server/x-embed-image.js

@@ -1,53 +1,9 @@
-import { createError, defineEventHandler, getQuery, setHeader } from "h3";
-import { $fetch } from "ofetch";
-export default defineEventHandler(async (event) => {
-  const query = getQuery(event);
-  const url = query.url;
-  if (!url) {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Image URL is required"
-    });
-  }
-  let parsedUrl;
-  try {
-    parsedUrl = new URL(url);
-  } catch {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Invalid image URL"
-    });
-  }
-  if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Invalid URL scheme"
-    });
-  }
-  const allowedDomains = [
+import { createImageProxyHandler } from "./utils/image-proxy.js";
+export default createImageProxyHandler({
+  allowedDomains: [
     "pbs.twimg.com",
     "abs.twimg.com",
     "video.twimg.com"
-  ];
-  if (!allowedDomains.includes(parsedUrl.hostname)) {
-    throw createError({
-      statusCode: 403,
-      statusMessage: "Domain not allowed"
-    });
-  }
-  const response = await $fetch.raw(url, {
-    timeout: 5e3,
-    headers: {
-      "Accept": "image/webp,image/jpeg,image/png,image/*,*/*;q=0.8",
-      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
-    }
-  }).catch((error) => {
-    throw createError({
-      statusCode: error.statusCode || 500,
-      statusMessage: error.statusMessage || "Failed to fetch image"
-    });
-  });
-  setHeader(event, "Content-Type", response.headers.get("content-type") || "image/jpeg");
-  setHeader(event, "Cache-Control", "public, max-age=3600, s-maxage=3600");
-  return response._data;
+  ],
+  userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
 });

package/dist/runtime/server/x-embed.js

@@ -1,15 +1,16 @@
 import { createError, defineEventHandler, getQuery, setHeader } from "h3";
 import { $fetch } from "ofetch";
+const TWEET_ID_RE = /^\d+$/;
 export default defineEventHandler(async (event) => {
   const query = getQuery(event);
   const tweetId = query.id;
-  if (!tweetId || !/^\d+$/.test(tweetId)) {
+  if (!tweetId || !TWEET_ID_RE.test(tweetId)) {
     throw createError({
       statusCode: 400,
       statusMessage: "Valid Tweet ID is required"
     });
   }
-  const randomToken = [...Array(11)].map(() => (Math.random() * 36).toString(36)[2]).join("");
+  const randomToken = Array.from(Array.from({ length: 11 }), () => (Math.random() * 36).toString(36)[2]).join("");
   const params = new URLSearchParams({ id: tweetId, token: randomToken });
   const tweetData = await $fetch(
     `https://cdn.syndication.twimg.com/tweet-result?${params.toString()}`,

package/dist/runtime/types.d.ts

@@ -1,37 +1,45 @@
+import type { UseScriptInput, UseScriptOptions, VueScriptInstance } from '@unhead/vue';
 import type { Script } from '@unhead/vue/types';
-import type { UseScriptInput, VueScriptInstance, UseScriptOptions } from '@unhead/vue';
-import type { ComputedRef, Ref } from 'vue';
-import type { InferInput, ObjectSchema, ValiError } from 'valibot';
 import type { Import } from 'unimport';
-import type { SegmentInput } from './registry/segment.js';
+import type { InferInput, ObjectSchema, UnionSchema, ValiError } from 'valibot';
+import type { ComputedRef, Ref } from 'vue';
+import type { BingUetInput } from './registry/bing-uet.js';
+import type { BlueskyEmbedInput } from './registry/bluesky-embed.js';
+import type { ClarityInput } from './registry/clarity.js';
 import type { CloudflareWebAnalyticsInput } from './registry/cloudflare-web-analytics.js';
+import type { CrispInput } from './registry/crisp.js';
 import type { DatabuddyAnalyticsInput } from './registry/databuddy-analytics.js';
-import type { MetaPixelInput } from './registry/meta-pixel.js';
 import type { FathomAnalyticsInput } from './registry/fathom-analytics.js';
+import type { GoogleAdsenseInput } from './registry/google-adsense.js';
+import type { GoogleAnalyticsInput } from './registry/google-analytics.js';
+import type { GoogleMapsInput } from './registry/google-maps.js';
+import type { GoogleRecaptchaInput } from './registry/google-recaptcha.js';
+import type { GoogleSignInInput } from './registry/google-sign-in.js';
+import type { GoogleTagManagerInput } from './registry/google-tag-manager.js';
+import type { GravatarInput } from './registry/gravatar.js';
 import type { HotjarInput } from './registry/hotjar.js';
+import type { InstagramEmbedInput } from './registry/instagram-embed.js';
 import type { IntercomInput } from './registry/intercom.js';
-import type { GoogleMapsInput } from './registry/google-maps.js';
+import type { LemonSqueezyInput } from './registry/lemon-squeezy.js';
 import type { MatomoAnalyticsInput } from './registry/matomo-analytics.js';
-import type { StripeInput } from './registry/stripe.js';
-import type { VimeoPlayerInput } from './registry/vimeo-player.js';
-import type { XPixelInput } from './registry/x-pixel.js';
-import type { SnapTrPixelInput } from './registry/snapchat-pixel.js';
-import type { YouTubePlayerInput } from './registry/youtube-player.js';
-import type { PlausibleAnalyticsInput } from './registry/plausible-analytics.js';
+import type { MetaPixelInput } from './registry/meta-pixel.js';
+import type { MixpanelAnalyticsInput } from './registry/mixpanel-analytics.js';
 import type { NpmInput } from './registry/npm.js';
-import type { LemonSqueezyInput } from './registry/lemon-squeezy.js';
-import type { GoogleAdsenseInput } from './registry/google-adsense.js';
-import type { ClarityInput } from './registry/clarity.js';
-import type { CrispInput } from './registry/crisp.js';
-import type { GoogleAnalyticsInput } from './registry/google-analytics.js';
-import type { GoogleTagManagerInput } from './registry/google-tag-manager.js';
-import type { UmamiAnalyticsInput } from './registry/umami-analytics.js';
-import type { RybbitAnalyticsInput } from './registry/rybbit-analytics.js';
-import type { RedditPixelInput } from './registry/reddit-pixel.js';
 import type { PayPalInput } from './registry/paypal.js';
+import type { PlausibleAnalyticsInput } from './registry/plausible-analytics.js';
 import type { PostHogInput } from './registry/posthog.js';
-import type { GoogleRecaptchaInput } from './registry/google-recaptcha.js';
+import type { RedditPixelInput } from './registry/reddit-pixel.js';
+import type { RybbitAnalyticsInput } from './registry/rybbit-analytics.js';
+import type { SegmentInput } from './registry/segment.js';
+import type { SnapTrPixelInput } from './registry/snapchat-pixel.js';
+import type { StripeInput } from './registry/stripe.js';
 import type { TikTokPixelInput } from './registry/tiktok-pixel.js';
+import type { UmamiAnalyticsInput } from './registry/umami-analytics.js';
+import type { VercelAnalyticsInput } from './registry/vercel-analytics.js';
+import type { VimeoPlayerInput } from './registry/vimeo-player.js';
+import type { XEmbedInput } from './registry/x-embed.js';
+import type { XPixelInput } from './registry/x-pixel.js';
+import type { YouTubePlayerInput } from './registry/youtube-player.js';
 export type WarmupStrategy = false | 'preload' | 'preconnect' | 'dns-prefetch';
 export type UseScriptContext<T extends Record<symbol | string, any>> = VueScriptInstance<T> & {
     /**
@@ -152,17 +160,22 @@ export interface NuxtDevToolsScriptInstance {
     }[];
 }
 export interface ScriptRegistry {
+    bingUet?: BingUetInput;
+    blueskyEmbed?: BlueskyEmbedInput;
+    carbonAds?: true;
     crisp?: CrispInput;
     clarity?: ClarityInput;
     cloudflareWebAnalytics?: CloudflareWebAnalyticsInput;
     databuddyAnalytics?: DatabuddyAnalyticsInput;
     metaPixel?: MetaPixelInput;
     fathomAnalytics?: FathomAnalyticsInput;
+    instagramEmbed?: InstagramEmbedInput;
     plausibleAnalytics?: PlausibleAnalyticsInput;
     googleAdsense?: GoogleAdsenseInput;
     googleAnalytics?: GoogleAnalyticsInput;
     googleMaps?: GoogleMapsInput;
     googleRecaptcha?: GoogleRecaptchaInput;
+    googleSignIn?: GoogleSignInInput;
     lemonSqueezy?: LemonSqueezyInput;
     googleTagManager?: GoogleTagManagerInput;
     hotjar?: HotjarInput;
@@ -170,58 +183,75 @@ export interface ScriptRegistry {
     paypal?: PayPalInput;
     posthog?: PostHogInput;
     matomoAnalytics?: MatomoAnalyticsInput;
+    mixpanelAnalytics?: MixpanelAnalyticsInput;
     rybbitAnalytics?: RybbitAnalyticsInput;
     redditPixel?: RedditPixelInput;
     segment?: SegmentInput;
     stripe?: StripeInput;
     tiktokPixel?: TikTokPixelInput;
+    xEmbed?: XEmbedInput;
     xPixel?: XPixelInput;
     snapchatPixel?: SnapTrPixelInput;
     youtubePlayer?: YouTubePlayerInput;
+    vercelAnalytics?: VercelAnalyticsInput;
     vimeoPlayer?: VimeoPlayerInput;
     umamiAnalytics?: UmamiAnalyticsInput;
+    gravatar?: GravatarInput;
+    npm?: NpmInput;
     [key: `${string}-npm`]: NpmInput;
 }
-export type NuxtConfigScriptRegistryEntry<T> = true | 'mock' | T | [T, NuxtUseScriptOptionsSerializable];
+/**
+ * Built-in registry script keys — not affected by module augmentation.
+ * Use this to type-check records that must enumerate all built-in scripts (logos, meta, etc.).
+ */
+export type BuiltInRegistryScriptKey = 'bingUet' | 'blueskyEmbed' | 'carbonAds' | 'crisp' | 'clarity' | 'cloudflareWebAnalytics' | 'databuddyAnalytics' | 'metaPixel' | 'fathomAnalytics' | 'instagramEmbed' | 'plausibleAnalytics' | 'googleAdsense' | 'googleAnalytics' | 'googleMaps' | 'googleRecaptcha' | 'googleSignIn' | 'lemonSqueezy' | 'googleTagManager' | 'hotjar' | 'intercom' | 'paypal' | 'posthog' | 'matomoAnalytics' | 'mixpanelAnalytics' | 'rybbitAnalytics' | 'redditPixel' | 'segment' | 'stripe' | 'tiktokPixel' | 'xEmbed' | 'xPixel' | 'snapchatPixel' | 'youtubePlayer' | 'vercelAnalytics' | 'vimeoPlayer' | 'umamiAnalytics' | 'gravatar' | 'npm';
+/**
+ * Union of all explicit registry script keys (excludes npm pattern).
+ * Includes both built-in and augmented keys.
+ */
+export type RegistryScriptKey = Exclude<keyof ScriptRegistry, `${string}-npm`>;
+export type NuxtConfigScriptRegistryEntry<T> = true | false | 'mock' | T | [T, NuxtUseScriptOptionsSerializable];
 export type NuxtConfigScriptRegistry<T extends keyof ScriptRegistry = keyof ScriptRegistry> = Partial<{
     [key in T]: NuxtConfigScriptRegistryEntry<ScriptRegistry[key]>;
-}>;
+}> & Record<string & {}, NuxtConfigScriptRegistryEntry<any>>;
 export type UseFunctionType<T, U> = T extends {
     use: infer V;
 } ? V extends (...args: any) => any ? ReturnType<V> : U : U;
 declare const _emptyOptions: ObjectSchema<{}, undefined>;
 export type EmptyOptionsSchema = typeof _emptyOptions;
 type ScriptInput = Script;
-export type InferIfSchema<T> = T extends ObjectSchema<any, any> ? InferInput<T> : T;
-export type RegistryScriptInput<T = EmptyOptionsSchema, Bundelable extends boolean = true, Usable extends boolean = false, CanBypassOptions extends boolean = true> = (InferIfSchema<T> & {
+export type InferIfSchema<T> = T extends ObjectSchema<any, any> | UnionSchema<any, any> ? InferInput<T> : T;
+export interface RegistryScriptInputExtras<Bundelable extends boolean = true, Usable extends boolean = false> {
     /**
      * A unique key to use for the script, this can be used to load multiple of the same script with different options.
      */
     key?: string;
     scriptInput?: ScriptInput;
     scriptOptions?: Omit<NuxtUseScriptOptions, Bundelable extends true ? '' : 'bundle' | Usable extends true ? '' : 'use'>;
-}) | Partial<InferIfSchema<T>> & (CanBypassOptions extends true ? {
+}
+export type RegistryScriptInput<T = EmptyOptionsSchema, Bundelable extends boolean = true, Usable extends boolean = false> = Partial<InferIfSchema<T>> & RegistryScriptInputExtras<Bundelable, Usable>;
+export interface RegistryScriptServerHandler {
+    route: string;
+    handler: string;
+    middleware?: boolean;
+}
+export interface RegistryScript {
     /**
-     * A unique key to use for the script, this can be used to load multiple of the same script with different options.
+     * The config key used in `scripts.registry` in nuxt.config (e.g., 'googleAnalytics', 'plausibleAnalytics').
+     * Used for direct lookup from config to script — avoids fragile import name convention matching.
      */
-    key?: string;
-    scriptInput: Required<Pick<ScriptInput, 'src'>> & ScriptInput;
-    scriptOptions?: Omit<NuxtUseScriptOptions, Bundelable extends true ? '' : 'bundle' | Usable extends true ? '' : 'use'>;
-} : never);
-export interface RegistryScript {
+    registryKey?: RegistryScriptKey;
     import?: Import;
     scriptBundling?: false | ((options?: any) => string | false);
     /**
-     * First-party routing configuration for this script.
-     * - `string` - The proxy config key to use (e.g., 'googleAnalytics', 'metaPixel')
-     * - `false` - Explicitly disable first-party routing for this script
-     * - `undefined` - Use the default key derived from the function name
+     * First-party proxy config alias. Only needed when a script shares another script's
+     * proxy config (e.g., googleAdsense uses `proxy: 'googleAnalytics'`).
      *
-     * When set to a string, the script's URLs will be rewritten and collection
-     * endpoints will be routed through your server when `scripts.firstParty` is enabled.
+     * By default, the proxy config is looked up by `registryKey`. Set to `false` to
+     * explicitly disable first-party routing for this script.
      * @internal
      */
-    proxy?: string | false;
+    proxy?: RegistryScriptKey | false;
     label?: string;
     src?: string | false;
     category?: string;
@@ -229,6 +259,10 @@ export interface RegistryScript {
         light: string;
         dark: string;
     };
+    /**
+     * Server handlers (routes/middleware) to register when this script is enabled via registry config.
+     */
+    serverHandlers?: RegistryScriptServerHandler[];
 }
 export type ElementScriptTrigger = 'immediate' | 'visible' | string | string[] | false;
 export type RegistryScripts = RegistryScript[];

package/dist/runtime/utils/pure.d.ts

@@ -4,10 +4,6 @@
 export interface ProxyRewrite {
     /** Domain and path to match (e.g., 'www.google-analytics.com/g/collect') */
     from: string;
-    /** Local path to rewrite to (e.g., '/_scripts/c/ga/g/collect') */
+    /** Local path to rewrite to (e.g., '/_scripts/p/ga/g/collect') */
     to: string;
 }
-/**
- * Rewrite URLs in script content based on proxy config.
- */
-export declare function rewriteScriptUrls(content: string, rewrites: ProxyRewrite[]): string;

package/dist/runtime/utils/pure.js

@@ -1,67 +0,0 @@
-import { parseURL, joinURL } from "ufo";
-export function rewriteScriptUrls(content, rewrites) {
-  let result = content;
-  const literalRegex = /(['"`])(.*?)\1/g;
-  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) : "";
-    result = result.replace(literalRegex, (match, quote, inner) => {
-      if (!inner.includes(fromHost)) return match;
-      const url = parseURL(inner);
-      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 (inner.startsWith("//")) {
-        const hostPart = inner.slice(2).split("/")[0];
-        const hostMatches = isSuffixMatch ? hostPart?.endsWith(fromHost) ?? false : hostPart === fromHost;
-        if (hostMatches) {
-          const remainder = inner.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 && (inner.startsWith(from) || isSuffixMatch && inner.includes(from))) {
-        const domainEnd = inner.indexOf(from) + from.length;
-        const nextChar = inner[domainEnd];
-        if (!nextChar || nextChar === "/" || nextChar === "?" || nextChar === "#") {
-          shouldRewrite = true;
-          rewriteSuffix = inner.slice(domainEnd);
-        }
-      }
-      if (shouldRewrite) {
-        const rewritten = rewriteSuffix === "/" || rewriteSuffix.startsWith("?") || rewriteSuffix.startsWith("#") ? to + rewriteSuffix : joinURL(to, rewriteSuffix);
-        return quote + rewritten + quote;
-      }
-      return match;
-    });
-  }
-  const gaRewrite = rewrites.find((r) => r.from.includes("google-analytics.com/g/collect"));
-  if (gaRewrite) {
-    result = result.replace(
-      /"https:\/\/"\+\(.*?\)\+"\.google-analytics\.com\/g\/collect"/g,
-      `"${gaRewrite.to}"`
-    );
-    result = result.replace(
-      /"https:\/\/"\+\(.*?\)\+"\.analytics\.google\.com\/g\/collect"/g,
-      `"${gaRewrite.to}"`
-    );
-  }
-  return result;
-}

package/dist/runtime/utils.d.ts

@@ -1,6 +1,6 @@
-import type { ObjectSchema } from 'valibot';
+import type { EmptyOptionsSchema, InferIfSchema, NuxtUseScriptOptions, RegistryScriptInput, ScriptRegistry, UseFunctionType, UseScriptContext } from '#nuxt-scripts/types';
 import type { UseScriptInput } from '@unhead/vue';
-import type { EmptyOptionsSchema, InferIfSchema, NuxtUseScriptOptions, RegistryScriptInput, UseFunctionType, ScriptRegistry, UseScriptContext } from '#nuxt-scripts/types';
+import type { ObjectSchema, UnionSchema } from 'valibot';
 export type MaybePromise<T> = Promise<T> | T;
 type OptionsFn<O> = (options: InferIfSchema<O>, ctx: {
     scriptInput?: UseScriptInput & {
@@ -9,10 +9,11 @@ type OptionsFn<O> = (options: InferIfSchema<O>, ctx: {
 }) => ({
     scriptInput?: UseScriptInput;
     scriptOptions?: NuxtUseScriptOptions;
-    schema?: O extends ObjectSchema<any, any> ? O : undefined;
+    schema?: O extends ObjectSchema<any, any> | UnionSchema<any, any> ? O : undefined;
     clientInit?: () => void | Promise<any>;
     scriptMode?: 'external' | 'npm';
 });
 export declare function scriptRuntimeConfig<T extends keyof ScriptRegistry>(key: T): ScriptRegistry[T];
+export declare function requireRegistryEndpoint(componentName: string, registryKey: string): void;
 export declare function useRegistryScript<T extends Record<string | symbol, any>, O = EmptyOptionsSchema>(registryKey: keyof ScriptRegistry | string, optionsFn: OptionsFn<O>, _userOptions?: RegistryScriptInput<O>): UseScriptContext<UseFunctionType<NuxtUseScriptOptions<T>, T>>;
 export * from './utils/pure.js';

package/dist/runtime/utils.js

@@ -1,9 +1,13 @@
+import { parse } from "#nuxt-scripts-validator";
 import { defu } from "defu";
-import { useRuntimeConfig } from "nuxt/app";
-import { parseURL, withQuery, parseQuery } from "ufo";
+import { createError, useRuntimeConfig } from "nuxt/app";
+import { parseQuery, parseURL, withQuery } from "ufo";
 import { useScript } from "./composables/useScript.js";
 import { createNpmScriptStub } from "./npm-script-stub.js";
-import { parse } from "#nuxt-scripts-validator";
+const URL_MATCH_RE = /https?:\/\/[^/]+\/_nuxt\/(.+\.vue)(?:\?[^)]*)?:(\d+):(\d+)/;
+const URL_PAREN_MATCH_RE = /\(https?:\/\/[^/]+\/_nuxt\/(.+\.vue)(?:\?[^)]*)?:(\d+):(\d+)\)/;
+const VUE_MATCH_RE = /([^/\s]+\.vue):(\d+):(\d+)/;
+const CLEAN_CALLER_RE = /^\s*at\s+/;
 function validateScriptInputSchema(key, schema, options) {
   if (import.meta.dev) {
     try {
@@ -17,9 +21,18 @@ function validateScriptInputSchema(key, schema, options) {
 export function scriptRuntimeConfig(key) {
   return (useRuntimeConfig().public.scripts || {})[key];
 }
+export function requireRegistryEndpoint(componentName, registryKey) {
+  const endpoints = useRuntimeConfig().public["nuxt-scripts"]?.endpoints;
+  if (!endpoints?.[registryKey]) {
+    throw createError({
+      message: `${componentName} requires \`scripts.registry.${registryKey}\` to be enabled in nuxt.config`,
+      fatal: import.meta.dev
+    });
+  }
+}
 export function useRegistryScript(registryKey, optionsFn, _userOptions) {
   const scriptConfig = scriptRuntimeConfig(registryKey);
-  const userOptions = Object.assign(_userOptions || {}, typeof scriptConfig === "object" ? scriptConfig : {});
+  const userOptions = defu(_userOptions || {}, typeof scriptConfig === "object" ? scriptConfig : {});
   const options = optionsFn(userOptions, { scriptInput: userOptions.scriptInput });
   if (options.scriptMode === "npm") {
     return createNpmScriptStub({
@@ -45,7 +58,7 @@ export function useRegistryScript(registryKey, optionsFn, _userOptions) {
     };
   }
   const scriptInput = defu(finalScriptInput, userOptions.scriptInput, { key: registryKey });
-  const scriptOptions = Object.assign(userOptions?.scriptOptions || {}, options.scriptOptions || {});
+  const scriptOptions = { ...userOptions?.scriptOptions, ...options.scriptOptions };
   if (import.meta.dev) {
     const error = new Error("Stack trace for component location");
     const stack = error.stack?.split("\n");
@@ -54,25 +67,26 @@ export function useRegistryScript(registryKey, optionsFn, _userOptions) {
     );
     let loadedFrom = "unknown";
     if (callerLine) {
-      const urlMatch = callerLine.match(/https?:\/\/[^/]+\/_nuxt\/(.+\.vue)(?:\?[^)]*)?:(\d+):(\d+)/) || callerLine.match(/\(https?:\/\/[^/]+\/_nuxt\/(.+\.vue)(?:\?[^)]*)?:(\d+):(\d+)\)/);
+      const urlMatch = callerLine.match(URL_MATCH_RE) || callerLine.match(URL_PAREN_MATCH_RE);
       if (urlMatch) {
         const [, filePath, line, column] = urlMatch;
         loadedFrom = `./${filePath}:${line}:${column}`;
       } else {
-        const vueMatch = callerLine.match(/([^/\s]+\.vue):(\d+):(\d+)/);
+        const vueMatch = callerLine.match(VUE_MATCH_RE);
         if (vueMatch) {
           const [, fileName, line, column] = vueMatch;
           loadedFrom = `./${fileName}:${line}:${column}`;
         } else {
-          loadedFrom = callerLine.trim().replace(/^\s*at\s+/, "");
+          loadedFrom = callerLine.trim().replace(CLEAN_CALLER_RE, "");
         }
       }
     }
     scriptOptions.devtools = defu(scriptOptions.devtools, { registryKey, loadedFrom });
     if (options.schema) {
       const registryMeta = {};
-      for (const k in options.schema.entries) {
-        if (options.schema.entries[k].type !== "optional") {
+      const entries = "entries" in options.schema ? options.schema.entries : void 0;
+      for (const k in entries) {
+        if (entries[k]?.type !== "optional") {
           registryMeta[k] = String(userOptions[k]);
         }
       }

package/dist/shared/scripts.D7e2ENu6.mjs

@@ -0,0 +1,211 @@
+const FATHOM_SELF_HOSTED_RE = /\.src\.indexOf\("cdn\.usefathom\.com"\)\s*<\s*0/;
+const RYBBIT_HOST_SPLIT_RE = /\w+\.split\(["']\/script\.js["']\)\[0\]/g;
+const PRIVACY_NONE = { ip: false, userAgent: false, language: false, screen: false, timezone: false, hardware: false };
+const PRIVACY_FULL = { ip: true, userAgent: true, language: true, screen: true, timezone: true, hardware: true };
+const PRIVACY_HEATMAP = { ip: true, userAgent: false, language: true, screen: false, timezone: false, hardware: true };
+const PRIVACY_IP_ONLY = { ip: true, userAgent: false, language: false, screen: false, timezone: false, hardware: false };
+function buildProxyConfig(_proxyPrefix) {
+  return {
+    googleAnalytics: {
+      domains: [
+        "www.google-analytics.com",
+        "analytics.google.com",
+        "stats.g.doubleclick.net",
+        "pagead2.googlesyndication.com",
+        "www.googleadservices.com",
+        "googleads.g.doubleclick.net"
+      ],
+      privacy: PRIVACY_HEATMAP
+    },
+    googleTagManager: {
+      domains: ["www.googletagmanager.com"],
+      privacy: PRIVACY_NONE
+    },
+    metaPixel: {
+      domains: [
+        "connect.facebook.net",
+        "www.facebook.com",
+        "facebook.com",
+        "pixel.facebook.com"
+      ],
+      privacy: PRIVACY_FULL
+    },
+    tiktokPixel: {
+      domains: ["analytics.tiktok.com"],
+      privacy: PRIVACY_FULL
+    },
+    segment: {
+      domains: ["api.segment.io", "cdn.segment.com"],
+      privacy: PRIVACY_NONE
+    },
+    xPixel: {
+      domains: ["analytics.twitter.com", "static.ads-twitter.com", "t.co"],
+      privacy: PRIVACY_FULL
+    },
+    snapchatPixel: {
+      domains: ["sc-static.net", "tr.snapchat.com", "pixel.tapad.com"],
+      privacy: PRIVACY_FULL
+    },
+    redditPixel: {
+      domains: ["www.redditstatic.com", "alb.reddit.com", "pixel-config.reddit.com"],
+      privacy: PRIVACY_FULL
+    },
+    clarity: {
+      domains: [
+        "www.clarity.ms",
+        "scripts.clarity.ms",
+        "d.clarity.ms",
+        "e.clarity.ms",
+        "k.clarity.ms"
+      ],
+      privacy: PRIVACY_HEATMAP
+    },
+    posthog: {
+      domains: [
+        "us-assets.i.posthog.com",
+        "us.i.posthog.com",
+        "eu-assets.i.posthog.com",
+        "eu.i.posthog.com"
+      ],
+      privacy: PRIVACY_NONE,
+      autoInject: {
+        configField: "apiHost",
+        computeValue: (proxyPrefix, config) => {
+          const region = config.region || "us";
+          const host = region === "eu" ? "eu.i.posthog.com" : "us.i.posthog.com";
+          return `${proxyPrefix}/${host}`;
+        }
+      }
+    },
+    hotjar: {
+      domains: [
+        "static.hotjar.com",
+        "script.hotjar.com",
+        "vars.hotjar.com",
+        "in.hotjar.com",
+        "vc.hotjar.com",
+        "vc.hotjar.io",
+        "metrics.hotjar.io",
+        "insights.hotjar.com",
+        "ask.hotjar.io",
+        "events.hotjar.io",
+        "identify.hotjar.com",
+        "surveystats.hotjar.io"
+      ],
+      privacy: PRIVACY_HEATMAP
+    },
+    plausibleAnalytics: {
+      domains: ["plausible.io"],
+      privacy: PRIVACY_NONE,
+      autoInject: {
+        configField: "endpoint",
+        computeValue: (proxyPrefix) => `${proxyPrefix}/plausible.io/api/event`
+      }
+    },
+    cloudflareWebAnalytics: {
+      domains: ["static.cloudflareinsights.com", "cloudflareinsights.com"],
+      privacy: PRIVACY_NONE
+    },
+    rybbitAnalytics: {
+      domains: ["app.rybbit.io"],
+      privacy: PRIVACY_NONE,
+      autoInject: {
+        configField: "analyticsHost",
+        computeValue: (proxyPrefix) => `${proxyPrefix}/app.rybbit.io/api`
+      },
+      postProcess(output, rewrites) {
+        const rybbitRewrite = rewrites.find((r) => r.from === "app.rybbit.io");
+        if (rybbitRewrite) {
+          output = output.replace(
+            RYBBIT_HOST_SPLIT_RE,
+            `self.location.origin+"${rybbitRewrite.to}/api"`
+          );
+        }
+        return output;
+      }
+    },
+    umamiAnalytics: {
+      domains: ["cloud.umami.is", "api-gateway.umami.dev"],
+      privacy: PRIVACY_NONE,
+      autoInject: {
+        configField: "hostUrl",
+        computeValue: (proxyPrefix) => `${proxyPrefix}/cloud.umami.is`
+      }
+    },
+    databuddyAnalytics: {
+      domains: ["cdn.databuddy.cc", "basket.databuddy.cc"],
+      privacy: PRIVACY_NONE,
+      autoInject: {
+        configField: "apiUrl",
+        computeValue: (proxyPrefix) => `${proxyPrefix}/basket.databuddy.cc`
+      }
+    },
+    fathomAnalytics: {
+      domains: ["cdn.usefathom.com"],
+      privacy: PRIVACY_NONE,
+      postProcess(output) {
+        return output.replace(
+          FATHOM_SELF_HOSTED_RE,
+          '.src.indexOf("cdn.usefathom.com")<-1'
+        );
+      }
+    },
+    intercom: {
+      domains: [
+        "widget.intercom.io",
+        "api-iam.intercom.io",
+        "api-iam.eu.intercom.io",
+        "api-iam.au.intercom.io",
+        "js.intercomcdn.com",
+        "downloads.intercomcdn.com",
+        "video-messages.intercomcdn.com"
+      ],
+      privacy: PRIVACY_IP_ONLY
+    },
+    crisp: {
+      domains: [
+        "client.crisp.chat",
+        "client.relay.crisp.chat",
+        "assets.crisp.chat",
+        "go.crisp.chat",
+        "image.crisp.chat"
+      ],
+      privacy: PRIVACY_IP_ONLY
+    },
+    vercelAnalytics: {
+      domains: ["va.vercel-scripts.com"],
+      privacy: PRIVACY_NONE
+    },
+    gravatar: {
+      domains: ["secure.gravatar.com", "gravatar.com"],
+      privacy: PRIVACY_IP_ONLY
+    },
+    carbonAds: {
+      domains: ["cdn.carbonads.com"],
+      privacy: PRIVACY_NONE
+    },
+    lemonSqueezy: {
+      domains: ["assets.lemonsqueezy.com"],
+      privacy: PRIVACY_NONE
+    },
+    matomoAnalytics: {
+      domains: ["cdn.matomo.cloud"],
+      privacy: PRIVACY_NONE
+    },
+    // stripe, paypal: proxy: false in registry (need fingerprinting for fraud detection)
+    youtubePlayer: {
+      domains: ["www.youtube.com"],
+      privacy: PRIVACY_IP_ONLY
+    },
+    vimeoPlayer: {
+      domains: ["player.vimeo.com"],
+      privacy: PRIVACY_IP_ONLY
+    }
+    // googleRecaptcha, googleSignIn: proxy: false in registry (need fingerprinting for bot detection / auth)
+  };
+}
+function getAllProxyConfigs(proxyPrefix) {
+  return buildProxyConfig();
+}
+
+export { getAllProxyConfigs as g };