@nuxt/scripts 1.0.0-beta.6 → 1.0.0-rc.1

package/dist/runtime/registry/bing-uet.js

@@ -0,0 +1,29 @@
+import { useRegistryScript } from "../utils.js";
+import { BingUetOptions } from "./schemas.js";
+export { BingUetOptions };
+export function useScriptBingUet(_options) {
+  return useRegistryScript("bingUet", (options) => ({
+    scriptInput: {
+      src: "https://bat.bing.com/bat.js",
+      crossorigin: false
+    },
+    schema: import.meta.dev ? BingUetOptions : void 0,
+    scriptOptions: {
+      use() {
+        if (options?.id && typeof window.UET === "function" && Array.isArray(window.uetq)) {
+          const uetOptions = {
+            ti: options.id,
+            enableAutoSpaTracking: options.enableAutoSpaTracking ?? true,
+            q: window.uetq
+          };
+          window.uetq = new window.UET(uetOptions);
+          window.uetq.push("pageLoad");
+        }
+        return { uetq: window.uetq };
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      window.uetq = window.uetq || [];
+    }
+  }), _options);
+}

package/dist/runtime/registry/bluesky-embed.d.ts

@@ -0,0 +1,116 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { BlueskyEmbedOptions } from './schemas.js';
+export { BlueskyEmbedOptions };
+export interface BlueskyEmbedPostData {
+    uri: string;
+    cid: string;
+    author: {
+        did: string;
+        handle: string;
+        displayName: string;
+        avatar: string;
+        labels: Array<{
+            val: string;
+        }>;
+        verification?: {
+            verifiedStatus: string;
+        };
+    };
+    record: {
+        $type: string;
+        createdAt: string;
+        text: string;
+        langs?: string[];
+        facets?: Array<{
+            features: Array<{
+                $type: string;
+                uri?: string;
+                did?: string;
+                tag?: string;
+            }>;
+            index: {
+                byteStart: number;
+                byteEnd: number;
+            };
+        }>;
+        embed?: {
+            $type: string;
+            images?: Array<{
+                alt: string;
+                image: {
+                    ref: {
+                        $link: string;
+                    };
+                    mimeType: string;
+                    size: number;
+                };
+                aspectRatio?: {
+                    width: number;
+                    height: number;
+                };
+            }>;
+            external?: {
+                uri: string;
+                title: string;
+                description: string;
+                thumb?: {
+                    ref: {
+                        $link: string;
+                    };
+                    mimeType: string;
+                    size: number;
+                };
+            };
+        };
+    };
+    embed?: {
+        $type: string;
+        images?: Array<{
+            thumb: string;
+            fullsize: string;
+            alt: string;
+            aspectRatio?: {
+                width: number;
+                height: number;
+            };
+        }>;
+        external?: {
+            uri: string;
+            title: string;
+            description: string;
+            thumb?: string;
+        };
+    };
+    likeCount: number;
+    repostCount: number;
+    replyCount: number;
+    quoteCount: number;
+    indexedAt: string;
+    labels: Array<{
+        val: string;
+    }>;
+}
+export type BlueskyEmbedInput = RegistryScriptInput<typeof BlueskyEmbedOptions, false, false>;
+/**
+ * Extract the handle/DID and post rkey from a Bluesky post URL
+ */
+export declare function extractBlueskyPostId(url: string): {
+    actor: string;
+    rkey: string;
+} | undefined;
+/**
+ * Proxy a Bluesky image URL through the server
+ */
+export declare function proxyBlueskyImageUrl(url: string, proxyEndpoint?: string): string;
+/**
+ * Format a Bluesky post date for display
+ */
+export declare function formatBlueskyDate(dateString: string): string;
+/**
+ * Format a number for display (e.g., 1234 -> 1.2K)
+ */
+export declare function formatCount(count: number): string;
+/**
+ * Convert Bluesky facets (byte-range rich text annotations) to HTML
+ */
+export declare function facetsToHtml(text: string, facets?: BlueskyEmbedPostData['record']['facets']): string;

package/dist/runtime/registry/bluesky-embed.js

@@ -0,0 +1,72 @@
+import { BlueskyEmbedOptions } from "./schemas.js";
+export { BlueskyEmbedOptions };
+const BSKY_POST_URL_RE = /bsky\.app\/profile\/([^/]+)\/post\/([^/?]+)/;
+export function extractBlueskyPostId(url) {
+  const match = url.match(BSKY_POST_URL_RE);
+  if (!match)
+    return void 0;
+  return { actor: match[1], rkey: match[2] };
+}
+export function proxyBlueskyImageUrl(url, proxyEndpoint = "/_scripts/embed/bluesky-image") {
+  const separator = proxyEndpoint.includes("?") ? "&" : "?";
+  return `${proxyEndpoint}${separator}url=${encodeURIComponent(url)}`;
+}
+export function formatBlueskyDate(dateString) {
+  const date = new Date(dateString);
+  const time = date.toLocaleString("en-US", {
+    hour: "numeric",
+    minute: "numeric",
+    hour12: true,
+    timeZone: "UTC"
+  });
+  const month = date.toLocaleString("en-US", { month: "short", timeZone: "UTC" });
+  return `${time} \xB7 ${month} ${date.getUTCDate()}, ${date.getUTCFullYear()}`;
+}
+export function formatCount(count) {
+  if (count >= 1e6) {
+    return `${(count / 1e6).toFixed(1)}M`;
+  }
+  if (count >= 1e3) {
+    return `${(count / 1e3).toFixed(1)}K`;
+  }
+  return count.toString();
+}
+export function facetsToHtml(text, facets) {
+  if (!facets?.length)
+    return escapeHtml(text);
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  const bytes = encoder.encode(text);
+  const sorted = facets.toSorted((a, b) => a.index.byteStart - b.index.byteStart);
+  const parts = [];
+  let lastEnd = 0;
+  for (const facet of sorted) {
+    if (facet.index.byteStart > lastEnd) {
+      parts.push(escapeHtml(decoder.decode(bytes.slice(lastEnd, facet.index.byteStart))));
+    }
+    const facetText = escapeHtml(decoder.decode(bytes.slice(facet.index.byteStart, facet.index.byteEnd)));
+    for (const feature of facet.features) {
+      if (feature.$type === "app.bsky.richtext.facet#link" && feature.uri) {
+        parts.push(`<a href="${escapeHtml(feature.uri)}" target="_blank" rel="noopener noreferrer">${facetText}</a>`);
+      } else if (feature.$type === "app.bsky.richtext.facet#mention" && feature.did) {
+        parts.push(`<a href="https://bsky.app/profile/${escapeHtml(feature.did)}" target="_blank" rel="noopener noreferrer">${facetText}</a>`);
+      } else if (feature.$type === "app.bsky.richtext.facet#tag" && feature.tag) {
+        parts.push(`<a href="https://bsky.app/hashtag/${escapeHtml(feature.tag)}" target="_blank" rel="noopener noreferrer">${facetText}</a>`);
+      } else {
+        parts.push(facetText);
+      }
+    }
+    lastEnd = facet.index.byteEnd;
+  }
+  if (lastEnd < bytes.length) {
+    parts.push(escapeHtml(decoder.decode(bytes.slice(lastEnd))));
+  }
+  return parts.join("");
+}
+const AMP_RE = /&/g;
+const LT_RE = /</g;
+const GT_RE = />/g;
+const QUOT_RE = /"/g;
+function escapeHtml(str) {
+  return str.replace(AMP_RE, "&amp;").replace(LT_RE, "&lt;").replace(GT_RE, "&gt;").replace(QUOT_RE, "&quot;");
+}

package/dist/runtime/registry/clarity.d.ts

@@ -1,17 +1,19 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-type ClarityFunctions = ((fn: 'start', options: {
-    content: boolean;
-    cookies: string[];
-    dob: number;
-    expire: number;
-    projectId: string;
-    upload: string;
+import { ClarityOptions } from './schemas.js';
+export { ClarityOptions };
+type ClarityFunctions = ((fn: 'start', options?: {
+    content?: boolean;
+    cookies?: string[];
+    dob?: number;
+    expire?: number;
+    projectId?: string;
+    upload?: string;
 }) => void) & ((fn: 'identify', id: string, session?: string, page?: string, userHint?: string) => Promise<{
     id: string;
     session: string;
     page: string;
     userHint: string;
-}>) & ((fn: 'consent', enabled?: boolean) => void) & ((fn: 'set', key: any, value: any) => void) & ((fn: 'event', value: any) => void) & ((fn: 'upgrade', upgradeReason: any) => void) & ((fn: string, ...args: any[]) => void);
+}>) & ((fn: 'consent', enabled?: boolean | Record<string, string>) => void) & ((fn: 'set', key: string, value: string | string[]) => void) & ((fn: 'event', value: string) => void) & ((fn: 'upgrade', upgradeReason: string) => void) & ((fn: (string & {}), ...args: any[]) => void);
 export interface ClarityApi {
     clarity: ClarityFunctions & {
         q: any[];
@@ -22,12 +24,5 @@ declare global {
     interface Window extends ClarityApi {
     }
 }
-export declare const ClarityOptions: import("valibot").ObjectSchema<{
-    /**
-     * The Clarity token.
-     */
-    readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 10, undefined>]>;
-}, undefined>;
 export type ClarityInput = RegistryScriptInput<typeof ClarityOptions>;
 export declare function useScriptClarity<T extends ClarityApi>(_options?: ClarityInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

package/dist/runtime/registry/clarity.js

@@ -1,36 +1,27 @@
 import { useRegistryScript } from "../utils.js";
-import { minLength, object, string, pipe } from "#nuxt-scripts-validator";
-export const ClarityOptions = object({
-  /**
-   * The Clarity token.
-   */
-  id: pipe(string(), minLength(10))
-});
+import { ClarityOptions } from "./schemas.js";
+export { ClarityOptions };
 export function useScriptClarity(_options) {
-  return useRegistryScript(
-    "clarity",
-    (options) => ({
-      scriptInput: {
-        src: `https://www.clarity.ms/tag/${options.id}`
-      },
-      schema: import.meta.dev ? ClarityOptions : void 0,
-      scriptOptions: {
-        use() {
-          return {
-            // @ts-expect-error untyped
-            clarity: Object.assign(function(...params) {
-              const clarity = window.clarity;
-              return clarity.apply(this, params);
-            }, window.clarity)
-          };
-        }
-      },
-      clientInit: import.meta.server ? void 0 : () => {
-        window.clarity = window.clarity || function(...params) {
-          (window.clarity.q = window.clarity.q || []).push(params);
+  return useRegistryScript("clarity", (options) => ({
+    scriptInput: {
+      src: `https://www.clarity.ms/tag/${options.id}`
+    },
+    schema: import.meta.dev ? ClarityOptions : void 0,
+    scriptOptions: {
+      use() {
+        return {
+          // @ts-expect-error untyped
+          clarity: Object.assign(function(...params) {
+            const clarity = window.clarity;
+            return clarity.apply(this, params);
+          }, window.clarity)
         };
       }
-    }),
-    _options
-  );
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      window.clarity = window.clarity || function(...params) {
+        (window.clarity.q = window.clarity.q || []).push(params);
+      };
+    }
+  }), _options);
 }

package/dist/runtime/registry/cloudflare-web-analytics.d.ts

@@ -1,4 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { CloudflareWebAnalyticsOptions } from './schemas.js';
+export { CloudflareWebAnalyticsOptions };
 /**
  * Sample:
  * <!-- Cloudflare Web Analytics -->
@@ -16,18 +18,5 @@ declare global {
     interface Window extends CloudflareWebAnalyticsApi {
     }
 }
-export declare const CloudflareWebAnalyticsOptions: import("valibot").ObjectSchema<{
-    /**
-     * The Cloudflare Web Analytics token.
-     */
-    readonly token: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 32, undefined>]>;
-    /**
-     * Cloudflare Web Analytics enables measuring SPAs automatically by overriding the History API’s pushState function
-     * and listening to the onpopstate. Hash-based router is not supported.
-     *
-     * @default true
-     */
-    readonly spa: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
 export type CloudflareWebAnalyticsInput = RegistryScriptInput<typeof CloudflareWebAnalyticsOptions>;
 export declare function useScriptCloudflareWebAnalytics<T extends CloudflareWebAnalyticsApi>(_options?: CloudflareWebAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;

package/dist/runtime/registry/cloudflare-web-analytics.js

@@ -1,18 +1,6 @@
 import { useRegistryScript } from "../utils.js";
-import { boolean, minLength, object, optional, pipe, string } from "#nuxt-scripts-validator";
-export const CloudflareWebAnalyticsOptions = object({
-  /**
-   * The Cloudflare Web Analytics token.
-   */
-  token: pipe(string(), minLength(32)),
-  /**
-   * Cloudflare Web Analytics enables measuring SPAs automatically by overriding the History API’s pushState function
-   * and listening to the onpopstate. Hash-based router is not supported.
-   *
-   * @default true
-   */
-  spa: optional(boolean())
-});
+import { CloudflareWebAnalyticsOptions } from "./schemas.js";
+export { CloudflareWebAnalyticsOptions };
 export function useScriptCloudflareWebAnalytics(_options) {
   return useRegistryScript("cloudflareWebAnalytics", (options) => ({
     scriptInput: {

package/dist/runtime/registry/crisp.d.ts

@@ -1,46 +1,16 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const CrispOptions: import("valibot").ObjectSchema<{
-    /**
-     * The Crisp ID.
-     */
-    readonly id: import("valibot").StringSchema<undefined>;
-    /**
-     * Extra configuration options. Used to configure the locale.
-     * Same as CRISP_RUNTIME_CONFIG.
-     * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/language-customization/
-     */
-    readonly runtimeConfig: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
-        readonly locale: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    }, undefined>, undefined>;
-    /**
-     * Associated a session, equivalent to using CRISP_TOKEN_ID variable.
-     * Same as CRISP_TOKEN_ID.
-     * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/session-continuity/
-     */
-    readonly tokenId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /**
-     * Restrict the domain that the Crisp cookie is set on.
-     * Same as CRISP_COOKIE_DOMAIN.
-     * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/cookie-policies/
-     */
-    readonly cookieDomain: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /**
-     * The cookie expiry in seconds.
-     * Same as CRISP_COOKIE_EXPIRATION.
-     * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/cookie-policies/#change-cookie-expiration-date
-     */
-    readonly cookieExpiry: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
-}, undefined>;
-export type CrispInput = RegistryScriptInput<typeof CrispOptions, false, false, false>;
+import { CrispOptions } from './schemas.js';
+export { CrispOptions };
+export type CrispInput = RegistryScriptInput<typeof CrispOptions, false, false>;
 export interface CrispApi {
     push: (...args: any[]) => void;
-    is: (name: 'chat:opened' | 'chat:closed' | 'chat:visible' | 'chat:hidden' | 'chat:small' | 'chat:large' | 'session:ongoing' | 'website:available' | 'overlay:opened' | 'overlay:closed' | string) => boolean;
-    set: (name: 'message:text' | 'session:data' | 'session:segments' | 'session:event' | 'user:email' | 'user:phone' | 'user:nickname' | 'user:avatar' | 'user:company' | string, value: any) => void;
-    get: (name: 'chat:unread:count' | 'message:text' | 'session:identifier' | 'session:data' | 'user:email' | 'user:phone' | 'user:nickname' | 'user:avatar' | 'user:company' | string) => any;
-    do: (name: 'chat:open' | 'chat:close' | 'chat:toggle' | 'chat:show' | 'chat:hide' | 'helpdesk:search' | 'helpdesk:article:open' | 'helpdesk:query' | 'overlay:open' | 'overlay:close' | 'message:send' | 'message:show' | 'message:read' | 'message:thread:start' | 'message:thread:end' | 'session:reset' | 'trigger:run' | string, arg2?: any) => any;
-    on: (name: 'session:loaded' | 'chat:initiated' | 'chat:opened' | 'chat:closed' | 'message:sent' | 'message:received' | 'message:compose:sent' | 'message:compose:received' | 'user:email:changed' | 'user:phone:changed' | 'user:nickname:changed' | 'user:avatar:changed' | 'website:availability:changed' | 'helpdesk:queried' | string, callback: (...args: any[]) => any) => void;
-    off: (name: 'session:loaded' | 'chat:initiated' | 'chat:opened' | 'chat:closed' | 'message:sent' | 'message:received' | 'message:compose:sent' | 'message:compose:received' | 'user:email:changed' | 'user:phone:changed' | 'user:nickname:changed' | 'user:avatar:changed' | 'website:availability:changed' | 'helpdesk:queried' | string, callback: (...args: any[]) => any) => void;
-    config: (options: any) => void;
+    is: (name: 'chat:opened' | 'chat:closed' | 'chat:visible' | 'chat:hidden' | 'chat:small' | 'chat:large' | 'session:ongoing' | 'website:available' | 'overlay:opened' | 'overlay:closed' | (string & {})) => boolean;
+    set: ((name: 'message:text' | 'user:email' | 'user:phone' | 'user:nickname' | 'user:avatar' | 'user:company', value: string) => void) & ((name: 'session:data', value: [[string, string | number | boolean], ...[string, string | number | boolean][]]) => void) & ((name: 'session:segments', value: string[]) => void) & ((name: 'session:event', value: [[string, Record<string, any>?, string?]]) => void) & ((name: (string & {}), value: any) => void);
+    get: ((name: 'chat:unread:count') => number) & ((name: 'message:text' | 'session:identifier' | 'user:email' | 'user:phone' | 'user:nickname' | 'user:avatar' | 'user:company') => string) & ((name: 'session:data', key: string) => string | number | boolean) & ((name: (string & {})) => any);
+    do: (name: 'chat:open' | 'chat:close' | 'chat:toggle' | 'chat:show' | 'chat:hide' | 'helpdesk:search' | 'helpdesk:article:open' | 'helpdesk:query' | 'overlay:open' | 'overlay:close' | 'message:send' | 'message:show' | 'message:read' | 'message:thread:start' | 'message:thread:end' | 'session:reset' | 'trigger:run', arg2?: any) => any;
+    on: (name: 'session:loaded' | 'chat:initiated' | 'chat:opened' | 'chat:closed' | 'message:sent' | 'message:received' | 'message:compose:sent' | 'message:compose:received' | 'user:email:changed' | 'user:phone:changed' | 'user:nickname:changed' | 'user:avatar:changed' | 'website:availability:changed' | 'helpdesk:queried' | (string & {}), callback: (...args: any[]) => any) => void;
+    off: (name: 'session:loaded' | 'chat:initiated' | 'chat:opened' | 'chat:closed' | 'message:sent' | 'message:received' | 'message:compose:sent' | 'message:compose:received' | 'user:email:changed' | 'user:phone:changed' | 'user:nickname:changed' | 'user:avatar:changed' | 'website:availability:changed' | 'helpdesk:queried' | (string & {}), callback: (...args: any[]) => any) => void;
+    config: ((name: 'container:index', value: number) => void) & ((name: 'color:theme', value: 'default' | 'amber' | 'black' | 'blue' | 'blue_grey' | 'light_blue' | 'brown' | 'cyan' | 'green' | 'light_green' | 'grey' | 'indigo' | 'orange' | 'deep_orange' | 'pink' | 'purple' | 'deep_purple' | 'red' | 'teal') => void) & ((name: 'position:reverse' | 'hide:on:mobile' | 'hide:on:away' | 'lock:maximized' | 'lock:fullview' | 'show:operator:count' | 'sound:mute', value: boolean) => void) & ((name: (string & {}), value: any) => void);
     help: () => void;
     [key: string]: any;
 }

package/dist/runtime/registry/crisp.js

@@ -1,37 +1,6 @@
 import { useRegistryScript } from "../utils.js";
-import { object, string, optional, number } from "#nuxt-scripts-validator";
-export const CrispOptions = object({
-  /**
-   * The Crisp ID.
-   */
-  id: string(),
-  /**
-   * Extra configuration options. Used to configure the locale.
-   * Same as CRISP_RUNTIME_CONFIG.
-   * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/language-customization/
-   */
-  runtimeConfig: optional(object({
-    locale: optional(string())
-  })),
-  /**
-   * Associated a session, equivalent to using CRISP_TOKEN_ID variable.
-   * Same as CRISP_TOKEN_ID.
-   * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/session-continuity/
-   */
-  tokenId: optional(string()),
-  /**
-   * Restrict the domain that the Crisp cookie is set on.
-   * Same as CRISP_COOKIE_DOMAIN.
-   * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/cookie-policies/
-   */
-  cookieDomain: optional(string()),
-  /**
-   * The cookie expiry in seconds.
-   * Same as CRISP_COOKIE_EXPIRATION.
-   * @see https://docs.crisp.chat/guides/chatbox-sdks/web-sdk/cookie-policies/#change-cookie-expiration-date
-   */
-  cookieExpiry: optional(number())
-});
+import { CrispOptions } from "./schemas.js";
+export { CrispOptions };
 export function useScriptCrisp(_options) {
   let readyPromise = Promise.resolve();
   return useRegistryScript("crisp", (options) => ({

package/dist/runtime/registry/databuddy-analytics.d.ts

@@ -1,39 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const DatabuddyAnalyticsOptions: import("valibot").ObjectSchema<{
-    readonly clientId: import("valibot").StringSchema<undefined>;
-    readonly scriptUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly apiUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly disabled: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackScreenViews: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackPerformance: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackSessions: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackWebVitals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackErrors: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackOutgoingLinks: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackScrollDepth: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackEngagement: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackInteractions: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackAttributes: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackHashChanges: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackExitIntent: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly trackBounceRate: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly enableBatching: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly batchSize: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
-    readonly batchTimeout: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
-    readonly enableRetries: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly maxRetries: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
-    readonly initialRetryDelay: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
-    readonly samplingRate: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
-    readonly sdk: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly sdkVersion: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly enableObservability: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly observabilityService: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly observabilityEnvironment: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly observabilityVersion: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly enableLogging: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly enableTracing: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    readonly enableErrorTracking: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
+import { DatabuddyAnalyticsOptions } from './schemas.js';
+export { DatabuddyAnalyticsOptions };
 export type DatabuddyAnalyticsInput = RegistryScriptInput<typeof DatabuddyAnalyticsOptions, false>;
 export interface DatabuddyAnalyticsApi {
     /**

package/dist/runtime/registry/databuddy-analytics.js

@@ -1,49 +1,6 @@
 import { useRegistryScript } from "../utils.js";
-import { object, optional, string, boolean, number } from "#nuxt-scripts-validator";
-export const DatabuddyAnalyticsOptions = object({
-  // Required
-  clientId: string(),
-  // Advanced
-  scriptUrl: optional(string()),
-  // defaults to https://cdn.databuddy.cc/databuddy.js
-  apiUrl: optional(string()),
-  // defaults to https://basket.databuddy.cc
-  disabled: optional(boolean()),
-  // Core tracking (enabled by default by SDK)
-  trackScreenViews: optional(boolean()),
-  trackPerformance: optional(boolean()),
-  trackSessions: optional(boolean()),
-  // Optional tracking
-  trackWebVitals: optional(boolean()),
-  trackErrors: optional(boolean()),
-  trackOutgoingLinks: optional(boolean()),
-  trackScrollDepth: optional(boolean()),
-  trackEngagement: optional(boolean()),
-  trackInteractions: optional(boolean()),
-  trackAttributes: optional(boolean()),
-  trackHashChanges: optional(boolean()),
-  trackExitIntent: optional(boolean()),
-  trackBounceRate: optional(boolean()),
-  // Performance options
-  enableBatching: optional(boolean()),
-  batchSize: optional(number()),
-  batchTimeout: optional(number()),
-  enableRetries: optional(boolean()),
-  maxRetries: optional(number()),
-  initialRetryDelay: optional(number()),
-  samplingRate: optional(number()),
-  // SDK metadata
-  sdk: optional(string()),
-  sdkVersion: optional(string()),
-  // Observability & logging (accepted by SDK config)
-  enableObservability: optional(boolean()),
-  observabilityService: optional(string()),
-  observabilityEnvironment: optional(string()),
-  observabilityVersion: optional(string()),
-  enableLogging: optional(boolean()),
-  enableTracing: optional(boolean()),
-  enableErrorTracking: optional(boolean())
-});
+import { DatabuddyAnalyticsOptions } from "./schemas.js";
+export { DatabuddyAnalyticsOptions };
 export function useScriptDatabuddyAnalytics(_options) {
   return useRegistryScript("databuddyAnalytics", (options) => {
     return {
@@ -96,6 +53,24 @@ export function useScriptDatabuddyAnalytics(_options) {
             return null;
           }
           return window.db || window.databuddy || null;
+        },
+        // The SDK finds config by searching for a <script> with src containing
+        // "/databuddy.js". When first-party bundling rewrites the src to
+        // /_scripts/<hash>.js, the lookup fails. Set window.databuddyConfig
+        // so the SDK picks up the config regardless of script src.
+        clientInit: import.meta.server ? void 0 : () => {
+          const cfg = { clientId: options.clientId };
+          if (options?.apiUrl)
+            cfg.apiUrl = options.apiUrl;
+          if (options?.disabled)
+            cfg.disabled = options.disabled;
+          if (options?.trackScreenViews)
+            cfg.trackScreenViews = options.trackScreenViews;
+          if (options?.trackPerformance)
+            cfg.trackPerformance = options.trackPerformance;
+          if (options?.trackSessions)
+            cfg.trackSessions = options.trackSessions;
+          window.databuddyConfig = cfg;
         }
       }
     };

package/dist/runtime/registry/fathom-analytics.d.ts

@@ -1,27 +1,7 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const FathomAnalyticsOptions: import("valibot").ObjectSchema<{
-    /**
-     * The Fathom Analytics site ID.
-     */
-    readonly site: import("valibot").StringSchema<undefined>;
-    /**
-     * The Fathom Analytics tracking mode.
-     */
-    readonly spa: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"auto", undefined>, import("valibot").LiteralSchema<"history", undefined>, import("valibot").LiteralSchema<"hash", undefined>], undefined>, undefined>;
-    /**
-     * Automatically track page views.
-     */
-    readonly auto: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    /**
-     * Enable canonical URL tracking.
-     */
-    readonly canonical: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    /**
-     * Honor Do Not Track requests.
-     */
-    readonly honorDnt: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
-export type FathomAnalyticsInput = RegistryScriptInput<typeof FathomAnalyticsOptions, false, false, false>;
+import { FathomAnalyticsOptions } from './schemas.js';
+export { FathomAnalyticsOptions };
+export type FathomAnalyticsInput = RegistryScriptInput<typeof FathomAnalyticsOptions, false, false>;
 export interface FathomAnalyticsApi {
     beacon: (ctx: {
         url: string;
@@ -32,14 +12,15 @@ export interface FathomAnalyticsApi {
     isTrackingEnabled: () => boolean;
     send: (type: string, data: unknown) => void;
     setSite: (siteId: string) => void;
-    sideId: string;
+    siteId: string;
     trackPageview: (ctx?: {
         url: string;
         referrer?: string;
     }) => void;
     trackGoal: (goalId: string, cents: number) => void;
-    trackEvent: (eventName: string, value: {
-        _value: number;
+    trackEvent: (eventName: string, value?: {
+        _value?: number;
+        _site_id?: string;
     }) => void;
 }
 declare global {