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

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

@@ -1,8 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const SegmentOptions: import("valibot").ObjectSchema<{
-    readonly writeKey: import("valibot").StringSchema<undefined>;
-    readonly analyticsKey: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-}, undefined>;
+import { SegmentOptions } from './schemas.js';
+export { SegmentOptions };
 export type SegmentInput = RegistryScriptInput<typeof SegmentOptions>;
 interface AnalyticsApi {
     track: (event: string, properties?: Record<string, any>) => void;
@@ -30,4 +28,3 @@ declare global {
     }
 }
 export declare function useScriptSegment<T extends SegmentApi>(_options?: SegmentInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

package/dist/runtime/registry/segment.js

@@ -1,10 +1,7 @@
 import { joinURL } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { object, optional, string } from "#nuxt-scripts-validator";
-export const SegmentOptions = object({
-  writeKey: string(),
-  analyticsKey: optional(string())
-});
+import { SegmentOptions } from "./schemas.js";
+export { SegmentOptions };
 const methods = ["track", "page", "identify", "group", "alias", "reset"];
 export function useScriptSegment(_options) {
   return useRegistryScript("segment", (options) => {

package/dist/runtime/registry/snapchat-pixel.d.ts

@@ -1,5 +1,7 @@
-import type { InferInput } from '#nuxt-scripts-validator';
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { InferInput } from 'valibot';
+import { InitObjectPropertiesSchema, SnapTrPixelOptions } from './schemas.js';
+export { InitObjectPropertiesSchema, SnapTrPixelOptions };
 type StandardEvents = 'PAGE_VIEW' | 'VIEW_CONTENT' | 'ADD_CART' | 'SIGN_UP' | 'SAVE' | 'START_CHECKOUT' | 'APP_OPEN' | 'ADD_BILLING' | 'SEARCH' | 'SUBSCRIBE' | 'AD_CLICK' | 'AD_VIEW' | 'COMPLETE_TUTORIAL' | 'LEVEL_COMPLETE' | 'INVITE' | 'LOGIN' | 'SHARE' | 'RESERVE' | 'ACHIEVEMENT_UNLOCKED' | 'ADD_TO_WISHLIST' | 'SPENT_CREDITS' | 'RATE' | 'START_TRIAL' | 'LIST_VIEW';
 interface EventObjectProperties {
     price?: number;
@@ -20,22 +22,8 @@ interface EventObjectProperties {
     event_tag?: string;
     [key: string]: any;
 }
-export declare const InitObjectPropertiesSchema: import("valibot").ObjectSchema<{
-    readonly user_email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly ip_address: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_phone_number: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_hashed_email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_hashed_phone_number: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly firstname: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly lastname: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_city: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_region: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_postal_code: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_country: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly age: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-}, undefined>;
 type InitObjectProperties = InferInput<typeof InitObjectPropertiesSchema>;
-type SnapTrFns = ((event: 'track', eventName: StandardEvents | '', data?: EventObjectProperties) => void) & ((event: 'init', id: string, data?: Record<string, any>) => void) & ((event: 'init', id: string, data?: InitObjectProperties) => void) & ((event: string, ...params: any[]) => void);
+type SnapTrFns = ((event: 'track', eventName: StandardEvents | (string & {}), data?: EventObjectProperties) => void) & ((event: 'init', id: string, data?: Record<string, any>) => void) & ((event: 'init', id: string, data?: InitObjectProperties) => void) & ((event: (string & {}), ...params: any[]) => void);
 export interface SnapPixelApi {
     snaptr: SnapTrFns & {
         push: SnapTrFns;
@@ -50,22 +38,5 @@ declare global {
     interface Window extends SnapPixelApi {
     }
 }
-export declare const SnapTrPixelOptions: import("valibot").ObjectSchema<{
-    readonly user_email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly ip_address: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_phone_number: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_hashed_email: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly user_hashed_phone_number: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly firstname: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly lastname: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_city: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_region: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_postal_code: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly geo_country: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly age: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    readonly id: import("valibot").StringSchema<undefined>;
-    readonly trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
-export type SnapTrPixelInput = RegistryScriptInput<typeof SnapTrPixelOptions, true, false, false>;
+export type SnapTrPixelInput = RegistryScriptInput<typeof SnapTrPixelOptions, true, false>;
 export declare function useScriptSnapchatPixel<T extends SnapPixelApi>(_options?: SnapTrPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

package/dist/runtime/registry/snapchat-pixel.js

@@ -1,24 +1,6 @@
 import { useRegistryScript } from "../utils.js";
-import { boolean, object, optional, string } from "#nuxt-scripts-validator";
-export const InitObjectPropertiesSchema = object({
-  user_email: optional(string()),
-  ip_address: optional(string()),
-  user_phone_number: optional(string()),
-  user_hashed_email: optional(string()),
-  user_hashed_phone_number: optional(string()),
-  firstname: optional(string()),
-  lastname: optional(string()),
-  geo_city: optional(string()),
-  geo_region: optional(string()),
-  geo_postal_code: optional(string()),
-  geo_country: optional(string()),
-  age: optional(string())
-});
-export const SnapTrPixelOptions = object({
-  id: string(),
-  trackPageView: optional(boolean()),
-  ...InitObjectPropertiesSchema?.entries || {}
-});
+import { InitObjectPropertiesSchema, SnapTrPixelOptions } from "./schemas.js";
+export { InitObjectPropertiesSchema, SnapTrPixelOptions };
 export function useScriptSnapchatPixel(_options) {
   return useRegistryScript("snapchatPixel", (options) => ({
     scriptInput: {

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

@@ -1,8 +1,7 @@
-import type { StripeConstructor } from '@stripe/stripe-js';
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const StripeOptions: import("valibot").ObjectSchema<{
-    readonly advancedFraudSignals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
+import type { StripeConstructor } from '@stripe/stripe-js';
+import { StripeOptions } from './schemas.js';
+export { StripeOptions };
 export type StripeInput = RegistryScriptInput<typeof StripeOptions, false>;
 export interface StripeApi {
     Stripe: StripeConstructor;

package/dist/runtime/registry/stripe.js

@@ -1,9 +1,7 @@
 import { withQuery } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { boolean, object, optional } from "#nuxt-scripts-validator";
-export const StripeOptions = object({
-  advancedFraudSignals: optional(boolean())
-});
+import { StripeOptions } from "./schemas.js";
+export { StripeOptions };
 export function useScriptStripe(_options) {
   return useRegistryScript("stripe", (options) => ({
     scriptInput: {

package/dist/runtime/registry/tiktok-pixel.d.ts

@@ -1,4 +1,5 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { TikTokPixelOptions } from './schemas.js';
 type StandardEvents = 'ViewContent' | 'ClickButton' | 'Search' | 'AddToWishlist' | 'AddToCart' | 'InitiateCheckout' | 'AddPaymentInfo' | 'CompletePayment' | 'PlaceAnOrder' | 'Contact' | 'Download' | 'SubmitForm' | 'CompleteRegistration' | 'Subscribe';
 interface EventProperties {
     content_id?: string;
@@ -22,7 +23,7 @@ interface IdentifyProperties {
     phone_number?: string;
     external_id?: string;
 }
-type TtqFns = ((cmd: 'track', event: StandardEvents | string, properties?: EventProperties) => void) & ((cmd: 'page') => void) & ((cmd: 'identify', properties: IdentifyProperties) => void) & ((cmd: string, ...args: any[]) => void);
+type TtqFns = ((cmd: 'track', event: StandardEvents | (string & {}), properties?: EventProperties) => void) & ((cmd: 'page') => void) & ((cmd: 'identify', properties: IdentifyProperties) => void) & ((cmd: (string & {}), ...args: any[]) => void);
 export interface TikTokPixelApi {
     ttq: TtqFns & {
         push: TtqFns;
@@ -35,10 +36,6 @@ declare global {
         TiktokAnalyticsObject: string;
     }
 }
-export declare const TikTokPixelOptions: import("valibot").ObjectSchema<{
-    readonly id: import("valibot").StringSchema<undefined>;
-    readonly trackPageView: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-}, undefined>;
-export type TikTokPixelInput = RegistryScriptInput<typeof TikTokPixelOptions, true, false, false>;
+export { TikTokPixelOptions };
+export type TikTokPixelInput = RegistryScriptInput<typeof TikTokPixelOptions, true, false>;
 export declare function useScriptTikTokPixel<T extends TikTokPixelApi>(_options?: TikTokPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

package/dist/runtime/registry/tiktok-pixel.js

@@ -1,11 +1,7 @@
 import { withQuery } from "ufo";
 import { useRegistryScript } from "../utils.js";
-import { object, string, optional, boolean } from "#nuxt-scripts-validator";
-export const TikTokPixelOptions = object({
-  id: string(),
-  trackPageView: optional(boolean())
-  // default true
-});
+import { TikTokPixelOptions } from "./schemas.js";
+export { TikTokPixelOptions };
 export function useScriptTikTokPixel(_options) {
   return useRegistryScript("tiktokPixel", (options) => ({
     scriptInput: {

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

@@ -1,35 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
-export declare const UmamiAnalyticsOptions: import("valibot").ObjectSchema<{
-    readonly websiteId: import("valibot").StringSchema<undefined>;
-    /**
-     * By default, Umami will send data to wherever the script is located.
-     * You can override this to send data to another location.
-     */
-    readonly hostUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /**
-     * By default, Umami tracks all pageviews and events for you automatically.
-     * You can disable this behavior and track events yourself using the tracker functions.
-     * https://umami.is/docs/tracker-functions
-     */
-    readonly autoTrack: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
-    /**
-     * If you want the tracker to only run on specific domains, you can add them to your tracker script.
-     * This is a comma delimited list of domain names.
-     * Helps if you are working in a staging/development environment.
-     */
-    readonly domains: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-    /**
-     * If you want the tracker to collect events under a specific tag.
-     * Events can be filtered in the dashboard by a specific tag.
-     */
-    readonly tag: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /**
-     * Function that will be called before data is sent to Umami.
-     * The function takes two parameters: type and payload.
-     * Return the payload to continue sending, or return a falsy value to cancel.
-     */
-    readonly beforeSend: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").CustomSchema<(type: string, payload: Record<string, any>) => Record<string, any> | null | false, undefined>, import("valibot").StringSchema<undefined>], undefined>, undefined>;
-}, undefined>;
+import { UmamiAnalyticsOptions } from './schemas.js';
+export { UmamiAnalyticsOptions };
 export type UmamiAnalyticsInput = RegistryScriptInput<typeof UmamiAnalyticsOptions, false>;
 export interface UmamiAnalyticsApi {
     track: ((payload?: Record<string, any>) => void) & ((event_name: string, event_data: Record<string, any>) => void);

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

@@ -1,40 +1,6 @@
 import { useRegistryScript } from "../utils.js";
-import { object, optional, string, boolean, array, union, custom } from "#nuxt-scripts-validator";
-export const UmamiAnalyticsOptions = object({
-  websiteId: string(),
-  // required
-  /**
-   * By default, Umami will send data to wherever the script is located.
-   * You can override this to send data to another location.
-   */
-  hostUrl: optional(string()),
-  /**
-   * By default, Umami tracks all pageviews and events for you automatically.
-   * You can disable this behavior and track events yourself using the tracker functions.
-   * https://umami.is/docs/tracker-functions
-   */
-  autoTrack: optional(boolean()),
-  /**
-   * If you want the tracker to only run on specific domains, you can add them to your tracker script.
-   * This is a comma delimited list of domain names.
-   * Helps if you are working in a staging/development environment.
-   */
-  domains: optional(array(string())),
-  /**
-   * If you want the tracker to collect events under a specific tag.
-   * Events can be filtered in the dashboard by a specific tag.
-   */
-  tag: optional(string()),
-  /**
-   * Function that will be called before data is sent to Umami.
-   * The function takes two parameters: type and payload.
-   * Return the payload to continue sending, or return a falsy value to cancel.
-   */
-  beforeSend: optional(union([
-    custom((input) => typeof input === "function"),
-    string()
-  ]))
-});
+import { UmamiAnalyticsOptions } from "./schemas.js";
+export { UmamiAnalyticsOptions };
 export function useScriptUmamiAnalytics(_options) {
   return useRegistryScript("umamiAnalytics", (options) => {
     const domains = Array.isArray(options?.domains) ? options.domains.join(",") : options?.domains;

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

@@ -0,0 +1,29 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { VercelAnalyticsOptions } from './schemas.js';
+export { VercelAnalyticsOptions };
+export type AllowedPropertyValues = string | number | boolean | null;
+export type VercelAnalyticsMode = 'auto' | 'development' | 'production';
+export interface BeforeSendEvent {
+    type: 'pageview' | 'event';
+    url: string;
+}
+export type BeforeSend = (event: BeforeSendEvent) => BeforeSendEvent | null;
+export type VercelAnalyticsInput = RegistryScriptInput<typeof VercelAnalyticsOptions, false, false> & {
+    beforeSend?: BeforeSend;
+};
+export interface VercelAnalyticsApi {
+    va: (event: string, properties?: unknown) => void;
+    track: (name: string, properties?: Record<string, AllowedPropertyValues>) => void;
+    pageview: (options?: {
+        route?: string | null;
+        path?: string;
+    }) => void;
+}
+declare global {
+    interface Window {
+        va?: (event: string, properties?: unknown) => void;
+        vaq?: [string, unknown?][];
+        vam?: VercelAnalyticsMode;
+    }
+}
+export declare function useScriptVercelAnalytics<T extends VercelAnalyticsApi>(_options?: VercelAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;

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

@@ -0,0 +1,84 @@
+import { useRegistryScript } from "../utils.js";
+import { VercelAnalyticsOptions } from "./schemas.js";
+export { VercelAnalyticsOptions };
+function parseProperties(properties, options) {
+  let props = properties;
+  const errorProperties = [];
+  for (const [key, value] of Object.entries(properties)) {
+    if (typeof value === "object" && value !== null) {
+      if (options.strip) {
+        const { [key]: _, ...rest } = props;
+        props = rest;
+      } else {
+        errorProperties.push(key);
+      }
+    }
+  }
+  if (errorProperties.length > 0 && !options.strip) {
+    throw new Error(
+      `The following properties are not valid: ${errorProperties.join(", ")}. Only strings, numbers, booleans, and null are allowed.`
+    );
+  }
+  return props;
+}
+export function useScriptVercelAnalytics(_options) {
+  const beforeSend = _options?.beforeSend;
+  return useRegistryScript("vercelAnalytics", (options) => {
+    const scriptInput = {
+      "src": import.meta.dev ? "https://va.vercel-scripts.com/v1/script.debug.js" : "https://va.vercel-scripts.com/v1/script.js",
+      "defer": true,
+      "data-sdkn": "@nuxt/scripts"
+    };
+    if (options?.dsn)
+      scriptInput["data-dsn"] = options.dsn;
+    if (options?.disableAutoTrack)
+      scriptInput["data-disable-auto-track"] = "1";
+    if (options?.endpoint)
+      scriptInput["data-endpoint"] = options.endpoint;
+    if (import.meta.dev && options?.debug === false)
+      scriptInput["data-debug"] = "false";
+    return {
+      scriptInput,
+      schema: import.meta.dev ? VercelAnalyticsOptions : void 0,
+      scriptOptions: {
+        // Load on client hydration for accurate web vitals
+        trigger: "client",
+        use: () => ({
+          va: (...args) => window.va?.(...args),
+          track(name, properties) {
+            if (!properties) {
+              window.va?.("event", { name });
+              return;
+            }
+            try {
+              const props = parseProperties(properties, { strip: !import.meta.dev });
+              window.va?.("event", { name, data: props });
+            } catch (err) {
+              if (err instanceof Error && import.meta.dev)
+                console.error(err);
+            }
+          },
+          pageview(opts) {
+            window.va?.("pageview", opts);
+          }
+        })
+      },
+      clientInit: import.meta.server ? void 0 : () => {
+        if (window.va)
+          return;
+        window.va = function(...params) {
+          ;
+          (window.vaq = window.vaq || []).push(params);
+        };
+        if (options?.mode === "auto" || !options?.mode) {
+          window.vam = import.meta.dev ? "development" : "production";
+        } else {
+          window.vam = options.mode;
+        }
+        if (beforeSend) {
+          window.va("beforeSend", beforeSend);
+        }
+      }
+    };
+  }, _options);
+}

package/dist/runtime/registry/vimeo-player.d.ts

@@ -1,6 +1,6 @@
-import type Vimeo from '@vimeo/player';
-import type { UseScriptContext } from '@unhead/vue';
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import type { UseScriptContext } from '@unhead/vue';
+import type Vimeo from '@vimeo/player';
 type Constructor<T extends new (...args: any) => any> = T extends new (...args: infer A) => infer R ? new (...args: A) => R : never;
 export interface VimeoPlayerApi {
     Vimeo: {

package/dist/runtime/registry/vimeo-player.js

@@ -1,5 +1,5 @@
-import { watch } from "vue";
 import { useHead } from "@unhead/vue";
+import { watch } from "vue";
 import { useRegistryScript } from "../utils.js";
 export function useScriptVimeoPlayer(_options) {
   const instance = useRegistryScript("vimeoPlayer", () => ({

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

@@ -1,4 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { XEmbedOptions } from './schemas.js';
+export { XEmbedOptions };
 export interface XEmbedTweetData {
     id_str: string;
     text: string;
@@ -46,23 +48,7 @@ export interface XEmbedTweetData {
         };
     };
 }
-export declare const XEmbedOptions: import("valibot").ObjectSchema<{
-    /**
-     * The tweet ID to embed
-     */
-    readonly tweetId: import("valibot").StringSchema<undefined>;
-    /**
-     * Optional: Custom API endpoint for fetching tweet data
-     * @default '/api/_scripts/x-embed'
-     */
-    readonly apiEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-    /**
-     * Optional: Custom image proxy endpoint
-     * @default '/api/_scripts/x-embed-image'
-     */
-    readonly imageProxyEndpoint: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-}, undefined>;
-export type XEmbedInput = RegistryScriptInput<typeof XEmbedOptions, false, false, false>;
+export type XEmbedInput = RegistryScriptInput<typeof XEmbedOptions, false, false>;
 /**
  * Proxy an X/Twitter image URL through the server
  */

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

@@ -1,21 +1,6 @@
-import { object, optional, string } from "#nuxt-scripts-validator";
-export const XEmbedOptions = object({
-  /**
-   * The tweet ID to embed
-   */
-  tweetId: string(),
-  /**
-   * Optional: Custom API endpoint for fetching tweet data
-   * @default '/api/_scripts/x-embed'
-   */
-  apiEndpoint: optional(string()),
-  /**
-   * Optional: Custom image proxy endpoint
-   * @default '/api/_scripts/x-embed-image'
-   */
-  imageProxyEndpoint: optional(string())
-});
-export function proxyXImageUrl(url, proxyEndpoint = "/api/_scripts/x-embed-image") {
+import { XEmbedOptions } from "./schemas.js";
+export { XEmbedOptions };
+export function proxyXImageUrl(url, proxyEndpoint = "/_scripts/embed/x-image") {
   const separator = proxyEndpoint.includes("?") ? "&" : "?";
   return `${proxyEndpoint}${separator}url=${encodeURIComponent(url)}`;
 }

package/dist/runtime/registry/x-pixel.d.ts

@@ -1,4 +1,5 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { XPixelOptions } from './schemas.js';
 interface ContentProperties {
     content_type?: string | null;
     content_id?: string | number | null;
@@ -15,7 +16,7 @@ interface EventObjectProperties {
     phone_number?: string | null;
     contents: ContentProperties[];
 }
-type TwqFns = ((event: 'event', eventId: string, data?: EventObjectProperties) => void) & ((event: 'config', id: string) => void) & ((event: string, ...params: any[]) => void);
+type TwqFns = ((event: 'event', eventId: string, data?: EventObjectProperties) => void) & ((event: 'config', id: string) => void) & ((event: (string & {}), ...params: any[]) => void);
 export interface XPixelApi {
     twq: TwqFns & {
         loaded: boolean;
@@ -27,10 +28,6 @@ declare global {
     interface Window extends XPixelApi {
     }
 }
-export declare const XPixelOptions: import("valibot").ObjectSchema<{
-    readonly id: import("valibot").StringSchema<undefined>;
-    readonly version: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
-}, undefined>;
-export type XPixelInput = RegistryScriptInput<typeof XPixelOptions, true, false, false>;
+export { XPixelOptions };
+export type XPixelInput = RegistryScriptInput<typeof XPixelOptions, true, false>;
 export declare function useScriptXPixel<T extends XPixelApi>(_options?: XPixelInput): import("#nuxt-scripts/types").UseScriptContext<T>;
-export {};

package/dist/runtime/registry/x-pixel.js

@@ -1,9 +1,6 @@
 import { useRegistryScript } from "../utils.js";
-import { object, optional, string } from "#nuxt-scripts-validator";
-export const XPixelOptions = object({
-  id: string(),
-  version: optional(string())
-});
+import { XPixelOptions } from "./schemas.js";
+export { XPixelOptions };
 export function useScriptXPixel(_options) {
   return useRegistryScript("xPixel", (options) => {
     return {

package/dist/runtime/registry/youtube-player.d.ts

@@ -1,18 +1,18 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
 import type { UseScriptContext } from '@unhead/vue';
 import type { MaybePromise } from '../utils.js';
-import type { RegistryScriptInput } from '#nuxt-scripts/types';
 export interface YouTubePlayerApi {
     YT: MaybePromise<{
         Player: YT.Player;
         PlayerState: YT.PlayerState;
-        get(k: string): any;
+        get: (k: string) => any;
         loaded: 0 | 1;
         loading: 0 | 1;
-        ready(f: () => void): void;
-        scan(): void;
-        setConfig(config: YT.PlayerOptions): void;
-        subscribe<EventName extends keyof YT.Events>(event: EventName, listener: YT.Events[EventName], context?: any): void;
-        unsubscribe<EventName extends keyof YT.Events>(event: EventName, listener: YT.Events[EventName], context?: any): void;
+        ready: (f: () => void) => void;
+        scan: () => void;
+        setConfig: (config: YT.PlayerOptions) => void;
+        subscribe: <EventName extends keyof YT.Events>(event: EventName, listener: YT.Events[EventName], context?: any) => void;
+        unsubscribe: <EventName extends keyof YT.Events>(event: EventName, listener: YT.Events[EventName], context?: any) => void;
     }>;
 }
 declare global {

package/dist/runtime/registry/youtube-player.js

@@ -1,5 +1,5 @@
-import { watch } from "vue";
 import { useHead } from "@unhead/vue";
+import { watch } from "vue";
 import { useRegistryScript } from "../utils.js";
 export function useScriptYouTubePlayer(_options) {
   let readyPromise = Promise.resolve();

package/dist/runtime/server/bluesky-embed-image.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

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

@@ -0,0 +1,7 @@
+import { createImageProxyHandler } from "./utils/image-proxy.js";
+export default createImageProxyHandler({
+  allowedDomains: [
+    "cdn.bsky.app",
+    "av-cdn.bsky.app"
+  ]
+});

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

@@ -0,0 +1,16 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    uri: string;
+    cid: string;
+    author: Record<string, any>;
+    record: Record<string, any>;
+    embed?: Record<string, any>;
+    likeCount: number;
+    repostCount: number;
+    replyCount: number;
+    quoteCount: number;
+    indexedAt: string;
+    labels: Array<{
+        val: string;
+    }>;
+}>>;
+export default _default;

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

@@ -0,0 +1,59 @@
+import { createError, defineEventHandler, getQuery, setHeader } from "h3";
+import { $fetch } from "ofetch";
+const BSKY_POST_URL_RE = /^https:\/\/bsky\.app\/profile\/([^/]+)\/post\/([^/?]+)$/;
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const postUrl = query.url;
+  if (!postUrl) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Post URL is required"
+    });
+  }
+  const match = postUrl.match(BSKY_POST_URL_RE);
+  if (!match) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid Bluesky post URL"
+    });
+  }
+  const [, actor, rkey] = match;
+  let did = actor;
+  if (!actor.startsWith("did:")) {
+    const profile = await $fetch(
+      `https://public.api.bsky.app/xrpc/app.bsky.actor.getProfile?actor=${encodeURIComponent(actor)}`
+    ).catch((error) => {
+      throw createError({
+        statusCode: error.statusCode || 500,
+        statusMessage: "Failed to resolve Bluesky handle"
+      });
+    });
+    did = profile.did;
+  }
+  const uri = `at://${did}/app.bsky.feed.post/${rkey}`;
+  const response = await $fetch(
+    `https://public.api.bsky.app/xrpc/app.bsky.feed.getPostThread?uri=${encodeURIComponent(uri)}&depth=0&parentHeight=0`
+  ).catch((error) => {
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.statusMessage || "Failed to fetch Bluesky post"
+    });
+  });
+  if (response.thread.$type !== "app.bsky.feed.defs#threadViewPost") {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Post not found"
+    });
+  }
+  const post = response.thread.post;
+  const hasOptOut = post.labels?.some((l) => l.val === "!no-unauthenticated") || post.author?.labels?.some((l) => l.val === "!no-unauthenticated");
+  if (hasOptOut) {
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Author has opted out of external embedding"
+    });
+  }
+  setHeader(event, "Content-Type", "application/json");
+  setHeader(event, "Cache-Control", "public, max-age=600, s-maxage=600");
+  return post;
+});

package/dist/runtime/server/google-maps-geocode-proxy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;