@nuxt/scripts 1.0.6 → 1.1.1

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

@@ -1,3 +1,22 @@
+export declare const gcmConsentState: import("valibot").ObjectSchema<{
+    readonly ad_storage: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+    readonly ad_user_data: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+    readonly ad_personalization: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+    readonly analytics_storage: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+    readonly functionality_storage: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+    readonly personalization_storage: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+    readonly security_storage: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
+    readonly wait_for_update: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    readonly region: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+}, undefined>;
+export declare const AhrefsAnalyticsOptions: import("valibot").ObjectSchema<{
+    /**
+     * Your Ahrefs Web Analytics project key. Set as the `data-key` attribute
+     * on the loaded `analytics.js` script tag.
+     * @see https://ahrefs.com/web-analytics
+     */
+    readonly key: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
+}, undefined>;
 export declare const BlueskyEmbedOptions: import("valibot").ObjectSchema<{
     /**
      * The Bluesky post URL to embed.
@@ -808,6 +827,105 @@ export declare const BingUetOptions: import("valibot").ObjectSchema<{
         readonly ad_storage: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>], undefined>, undefined>;
     }, undefined>, undefined>;
 }, undefined>;
+export declare const LinkedInInsightOptions: import("valibot").ObjectSchema<{
+    /**
+     * Your LinkedIn Insight Tag Partner ID, or an array of Partner IDs to push
+     * onto window._linkedin_data_partner_ids. The first ID is used as the
+     * primary _linkedin_partner_id global.
+     * @example '111143'
+     * @example ['111143', '111154']
+     * @see https://www.linkedin.com/help/lms/answer/a417869/access-your-linkedin-partner-id
+     */
+    readonly id: import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>, undefined>, import("valibot").MinLengthAction<string[], 1, undefined>]>], undefined>;
+    /**
+     * Optional page-load event ID for Conversions API deduplication. Assigned
+     * to window._linkedin_event_id BEFORE the Insight Tag base code runs. Must
+     * match the eventId sent with the corresponding server-side Conversions
+     * API event.
+     *
+     * Per-event conversion deduplication uses the per-call event_id passed to
+     * lintrk('track', { conversion_id, event_id }) instead.
+     * @see https://learn.microsoft.com/en-us/linkedin/marketing/conversions/deduplication
+     */
+    readonly eventId: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /**
+     * Auto-fire lintrk('track') on Vue Router route changes (SPA virtual page
+     * views). When true, suppresses the script's built-in auto-page-view via
+     * window._wait_for_lintrk and tracks every navigation including the
+     * initial page through Nuxt's page:finish hook. When false, the script
+     * fires its own page-view exactly once on load and SPA navigations are
+     * not tracked unless lintrk('track') is called manually.
+     * @default false
+     */
+    readonly enableAutoSpaTracking: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+}, undefined>;
+export declare const UsercentricsOptions: import("valibot").ObjectSchema<{
+    /**
+     * Your Usercentrics CMP v3 ruleset ID. Find it in the admin under
+     * Implementation; the snippet's `data-ruleset-id` value.
+     */
+    readonly rulesetId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
+    /**
+     * Inject the Usercentrics autoblocker (`autoblocker.js`) ahead of the loader.
+     * Enable when your ruleset relies on Auto Blocking (vs. Manual Blocking) to
+     * gate third-party scripts before consent is granted.
+     * @default false
+     */
+    readonly autoblocker: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Override the language displayed by the CMP UI (BCP-47 code, e.g. `'en'`, `'de'`).
+     */
+    readonly language: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
+export declare const CalendlyOptions: import("valibot").ObjectSchema<{
+    /**
+     * The Calendly event URL to embed.
+     * Required for inline, popup, and badge widgets when called via the composable.
+     * @example 'https://calendly.com/your-name/30min'
+     * @see https://help.calendly.com/hc/en-us/articles/223147027
+     */
+    readonly url: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /**
+     * Pre-fill invitee fields on the booking form.
+     * @see https://help.calendly.com/hc/en-us/articles/360020052833
+     */
+    readonly prefill: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        readonly name: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly email: 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>;
+        /** Custom answers keyed by `a1`, `a2`, ... matching custom question order. */
+        readonly customAnswers: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").StringSchema<undefined>, undefined>, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * UTM parameters appended to the booking URL for marketing attribution.
+     * @see https://help.calendly.com/hc/en-us/articles/360020052833
+     */
+    readonly utm: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        readonly utmCampaign: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly utmSource: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly utmMedium: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly utmContent: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly utmTerm: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * Theme and layout overrides applied to the booking page.
+     * @see https://help.calendly.com/hc/en-us/articles/360020052833
+     */
+    readonly pageSettings: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        readonly backgroundColor: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly hideEventTypeDetails: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        readonly hideLandingPageDetails: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        readonly primaryColor: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        readonly textColor: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * CSS selector for the element that hosts the inline widget.
+     * Required when the widget is initialised inline; the element should have a
+     * minimum height of around 700px so the booking iframe is fully visible.
+     */
+    readonly parentElement: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
 export declare const SegmentOptions: import("valibot").ObjectSchema<{
     /**
      * Your Segment write key.
@@ -957,6 +1075,12 @@ export declare const TikTokPixelOptions: import("valibot").ObjectSchema<{
      * @see https://business-api.tiktok.com/portal/docs?id=1739585600931842
      */
     readonly defaultConsent: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"granted", undefined>, import("valibot").LiteralSchema<"denied", undefined>, import("valibot").LiteralSchema<"hold", undefined>], undefined>, undefined>;
+    /**
+     * Data residency region for the Pixel SDK.
+     * - `'global'` (default) -> `analytics.tiktok.com`
+     * - `'us'` -> `analytics.us.tiktok.com` (US enterprise data residency)
+     */
+    readonly region: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"global", undefined>, import("valibot").LiteralSchema<"us", undefined>], undefined>, undefined>;
 }, undefined>;
 export declare const UmamiAnalyticsOptions: import("valibot").ObjectSchema<{
     /**

package/dist/runtime/registry/schemas.js

@@ -1,6 +1,6 @@
 import { any, array, boolean, custom, literal, minLength, number, object, optional, pipe, record, string, union } from "valibot";
 const consentCategoryValue = union([literal("granted"), literal("denied")]);
-const gcmConsentState = object({
+export const gcmConsentState = object({
   ad_storage: optional(consentCategoryValue),
   ad_user_data: optional(consentCategoryValue),
   ad_personalization: optional(consentCategoryValue),
@@ -11,6 +11,14 @@ const gcmConsentState = object({
   wait_for_update: optional(number()),
   region: optional(array(string()))
 });
+export const AhrefsAnalyticsOptions = object({
+  /**
+   * Your Ahrefs Web Analytics project key. Set as the `data-key` attribute
+   * on the loaded `analytics.js` script tag.
+   * @see https://ahrefs.com/web-analytics
+   */
+  key: pipe(string(), minLength(1))
+});
 export const BlueskyEmbedOptions = object({
   /**
    * The Bluesky post URL to embed.
@@ -778,6 +786,105 @@ export const BingUetOptions = object({
     ad_storage: optional(consentCategoryValue)
   }))
 });
+export const LinkedInInsightOptions = object({
+  /**
+   * Your LinkedIn Insight Tag Partner ID, or an array of Partner IDs to push
+   * onto window._linkedin_data_partner_ids. The first ID is used as the
+   * primary _linkedin_partner_id global.
+   * @example '111143'
+   * @example ['111143', '111154']
+   * @see https://www.linkedin.com/help/lms/answer/a417869/access-your-linkedin-partner-id
+   */
+  id: union([pipe(string(), minLength(1)), pipe(array(pipe(string(), minLength(1))), minLength(1))]),
+  /**
+   * Optional page-load event ID for Conversions API deduplication. Assigned
+   * to window._linkedin_event_id BEFORE the Insight Tag base code runs. Must
+   * match the eventId sent with the corresponding server-side Conversions
+   * API event.
+   *
+   * Per-event conversion deduplication uses the per-call event_id passed to
+   * lintrk('track', { conversion_id, event_id }) instead.
+   * @see https://learn.microsoft.com/en-us/linkedin/marketing/conversions/deduplication
+   */
+  eventId: optional(string()),
+  /**
+   * Auto-fire lintrk('track') on Vue Router route changes (SPA virtual page
+   * views). When true, suppresses the script's built-in auto-page-view via
+   * window._wait_for_lintrk and tracks every navigation including the
+   * initial page through Nuxt's page:finish hook. When false, the script
+   * fires its own page-view exactly once on load and SPA navigations are
+   * not tracked unless lintrk('track') is called manually.
+   * @default false
+   */
+  enableAutoSpaTracking: optional(boolean())
+});
+export const UsercentricsOptions = object({
+  /**
+   * Your Usercentrics CMP v3 ruleset ID. Find it in the admin under
+   * Implementation; the snippet's `data-ruleset-id` value.
+   */
+  rulesetId: pipe(string(), minLength(1)),
+  /**
+   * Inject the Usercentrics autoblocker (`autoblocker.js`) ahead of the loader.
+   * Enable when your ruleset relies on Auto Blocking (vs. Manual Blocking) to
+   * gate third-party scripts before consent is granted.
+   * @default false
+   */
+  autoblocker: optional(boolean()),
+  /**
+   * Override the language displayed by the CMP UI (BCP-47 code, e.g. `'en'`, `'de'`).
+   */
+  language: optional(string())
+});
+export const CalendlyOptions = object({
+  /**
+   * The Calendly event URL to embed.
+   * Required for inline, popup, and badge widgets when called via the composable.
+   * @example 'https://calendly.com/your-name/30min'
+   * @see https://help.calendly.com/hc/en-us/articles/223147027
+   */
+  url: optional(string()),
+  /**
+   * Pre-fill invitee fields on the booking form.
+   * @see https://help.calendly.com/hc/en-us/articles/360020052833
+   */
+  prefill: optional(object({
+    name: optional(string()),
+    email: optional(string()),
+    firstName: optional(string()),
+    lastName: optional(string()),
+    /** Custom answers keyed by `a1`, `a2`, ... matching custom question order. */
+    customAnswers: optional(record(string(), string()))
+  })),
+  /**
+   * UTM parameters appended to the booking URL for marketing attribution.
+   * @see https://help.calendly.com/hc/en-us/articles/360020052833
+   */
+  utm: optional(object({
+    utmCampaign: optional(string()),
+    utmSource: optional(string()),
+    utmMedium: optional(string()),
+    utmContent: optional(string()),
+    utmTerm: optional(string())
+  })),
+  /**
+   * Theme and layout overrides applied to the booking page.
+   * @see https://help.calendly.com/hc/en-us/articles/360020052833
+   */
+  pageSettings: optional(object({
+    backgroundColor: optional(string()),
+    hideEventTypeDetails: optional(boolean()),
+    hideLandingPageDetails: optional(boolean()),
+    primaryColor: optional(string()),
+    textColor: optional(string())
+  })),
+  /**
+   * CSS selector for the element that hosts the inline widget.
+   * Required when the widget is initialised inline; the element should have a
+   * minimum height of around 700px so the booking iframe is fully visible.
+   */
+  parentElement: optional(string())
+});
 export const SegmentOptions = object({
   /**
    * Your Segment write key.
@@ -879,7 +986,13 @@ export const TikTokPixelOptions = object({
    * - `'hold'` fires `ttq.holdConsent()` to defer until an explicit update
    * @see https://business-api.tiktok.com/portal/docs?id=1739585600931842
    */
-  defaultConsent: optional(union([literal("granted"), literal("denied"), literal("hold")]))
+  defaultConsent: optional(union([literal("granted"), literal("denied"), literal("hold")])),
+  /**
+   * Data residency region for the Pixel SDK.
+   * - `'global'` (default) -> `analytics.tiktok.com`
+   * - `'us'` -> `analytics.us.tiktok.com` (US enterprise data residency)
+   */
+  region: optional(union([literal("global"), literal("us")]))
 });
 export const UmamiAnalyticsOptions = object({
   /**

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

@@ -1,6 +1,6 @@
 import type { RegistryScriptInput, UseScriptContext } 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';
+type StandardEvents = 'ViewContent' | 'ClickButton' | 'Search' | 'AddToWishlist' | 'AddToCart' | 'InitiateCheckout' | 'AddPaymentInfo' | 'CompletePayment' | 'PlaceAnOrder' | 'Purchase' | 'Contact' | 'Download' | 'SubmitForm' | 'CompleteRegistration' | 'Subscribe' | 'StartTrial' | 'ApplicationApproval' | 'CustomizeProduct' | 'FindLocation' | 'Schedule' | 'SubmitApplication';
 interface EventProperties {
     content_id?: string;
     content_type?: string;
@@ -16,34 +16,99 @@ interface EventProperties {
     value?: number;
     description?: string;
     query?: string;
+    /** Order/transaction identifier; complements `event_id` for transaction-level dedup. */
+    order_id?: string;
     [key: string]: any;
 }
+/**
+ * Advanced matching parameters. TikTok requires SHA-256-hashed values for `email`,
+ * `phone_number`, `external_id`, and the name/address fields to enable matching.
+ * Passing raw values disables matching silently; a dev-mode warning is logged.
+ * @see https://business-api.tiktok.com/portal/docs?id=1739585702922241
+ */
 interface IdentifyProperties {
     email?: string;
     phone_number?: string;
     external_id?: string;
+    first_name?: string;
+    last_name?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    zip_code?: string;
 }
-type TtqFns = ((cmd: 'track', event: StandardEvents | (string & {}), properties?: EventProperties) => void) & ((cmd: 'page') => void) & ((cmd: 'identify', properties: IdentifyProperties) => void) & ((cmd: (string & {}), ...args: any[]) => void);
+interface TrackOptions {
+    /** Used to deduplicate events sent from both the browser Pixel and the server-side Events API. */
+    event_id?: string;
+    /**
+     * Sandbox test-event identifier. When set, events route to TikTok's Test Events panel
+     * without affecting production reporting.
+     */
+    test_event_code?: string;
+    [key: string]: any;
+}
+/**
+ * The deferred methods TikTok's base code installs on `ttq`. Calling one before
+ * `events.js` loads pushes a `[method, ...args]` tuple onto the queue; afterwards
+ * `events.js` rebinds them to live implementations.
+ */
+export interface TtqInstance {
+    /** Track a page view. */
+    page: () => void;
+    /** Track a standard or custom conversion event. */
+    track: (event: StandardEvents | (string & {}), properties?: EventProperties, options?: TrackOptions) => void;
+    /** Associate advanced-matching identifiers with the current user. */
+    identify: (properties: IdentifyProperties) => void;
+    /** Opt user in to tracking. Queued before the script loads; live once `events.js` binds. */
+    grantConsent: () => void;
+    /** Opt user out of tracking. Queued before the script loads; live once `events.js` binds. */
+    revokeConsent: () => void;
+    /** Defer consent until an explicit grant/revoke. Queued before the script loads; live once `events.js` binds. */
+    holdConsent: () => void;
+    enableCookie: () => void;
+    disableCookie: () => void;
+}
+/**
+ * Legacy callable signature. Pre-1.2 `useScriptTikTokPixel` exposed `ttq` as an
+ * `fbq`-style callable (`ttq('page')`, `ttq('track', …)`); the adapter keeps it
+ * working alongside the method form.
+ */
+type TtqCallable = ((cmd: 'track', event: StandardEvents | (string & {}), properties?: EventProperties, options?: TrackOptions) => void) & ((cmd: 'page') => void) & ((cmd: 'identify', properties: IdentifyProperties) => void) & ((cmd: (string & {}), ...args: any[]) => void);
+/**
+ * The public `ttq` returned by the composable: a callable adapter (legacy form)
+ * that also carries the deferred methods (`ttq.page()`, `ttq.track(…)`). The
+ * adapter forwards to `window.ttq`, which is TikTok's real array protocol.
+ */
+export type Ttq = TtqCallable & TtqInstance & {
+    /** Resolve the per-pixel method bag for a specific pixel id. */
+    instance: (id: string) => TtqInstance;
+};
 export interface TikTokPixelApi {
-    ttq: TtqFns & {
-        push: TtqFns;
-        loaded: boolean;
-        queue: any[];
-        /** Opt user in to tracking. Queued before the script loads; live once `events.js` binds. */
-        grantConsent: () => void;
-        /** Opt user out of tracking. Queued before the script loads; live once `events.js` binds. */
-        revokeConsent: () => void;
-        /** Defer consent until an explicit grant/revoke. Queued before the script loads; live once `events.js` binds. */
-        holdConsent: () => void;
-    };
+    ttq: Ttq;
 }
+/**
+ * TikTok's `window.ttq` is an Array, not a callable: `events.js` reads it as a
+ * queue of `[method, ...args]` tuples and replays them, with the deferred
+ * methods installed as own properties on the array.
+ */
+type TtqArray = TtqInstance & Array<any[]> & {
+    methods: string[];
+    setAndDefer: (target: any, method: string) => void;
+    instance: (id: string) => TtqInstance;
+    _i?: Record<string, any[]>;
+    _t?: Record<string, number>;
+    _o?: Record<string, any>;
+};
 declare global {
-    interface Window extends TikTokPixelApi {
+    interface Window {
+        ttq: TtqArray;
         TiktokAnalyticsObject: string;
     }
 }
 export { TikTokPixelOptions };
 export type TikTokPixelInput = RegistryScriptInput<typeof TikTokPixelOptions, true, false>;
+/** Resolve the Pixel SDK URL for a given data-residency region. */
+export declare function tiktokPixelSrc(region?: 'global' | 'us'): string;
 export interface TikTokPixelConsent {
     /** Call `ttq.grantConsent()`. */
     grant: () => void;

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

@@ -1,11 +1,38 @@
 import { withQuery } from "ufo";
+import { logger } from "../logger.js";
 import { useRegistryScript } from "../utils.js";
 import { TikTokPixelOptions } from "./schemas.js";
 export { TikTokPixelOptions };
+export function tiktokPixelSrc(region) {
+  return region === "us" ? "https://analytics.us.tiktok.com/i18n/pixel/events.js" : "https://analytics.tiktok.com/i18n/pixel/events.js";
+}
+const TTQ_METHODS = ["page", "track", "identify", "instances", "debug", "on", "off", "once", "ready", "alias", "group", "enableCookie", "disableCookie", "holdConsent", "revokeConsent", "grantConsent"];
+const SHA256_HEX = /^[a-f0-9]{64}$/i;
+function warnUnhashedIdentify(props) {
+  const hashFields = ["email", "phone_number", "external_id", "first_name", "last_name", "city", "state", "country", "zip_code"];
+  const offenders = hashFields.filter((f) => {
+    const v = props[f];
+    return typeof v === "string" && v.length > 0 && !SHA256_HEX.test(v);
+  });
+  if (offenders.length) {
+    logger.withTag("tiktokPixel").warn(`identify() received unhashed value(s) for ${offenders.join(", ")}. TikTok requires SHA-256 hashing for advanced matching; raw values will be ignored. See https://business-api.tiktok.com/portal/docs?id=1739585702922241`);
+  }
+}
+function createTtqAdapter() {
+  const dispatch = (method, ...args) => {
+    if (import.meta.dev && method === "identify" && args[0])
+      warnUnhashedIdentify(args[0]);
+    return window.ttq[method]?.(...args);
+  };
+  const adapter = ((method, ...args) => dispatch(method, ...args));
+  for (const method of [...TTQ_METHODS, "instance"])
+    adapter[method] = (...args) => dispatch(method, ...args);
+  return adapter;
+}
 export function useScriptTikTokPixel(_options) {
   const instance = useRegistryScript("tiktokPixel", (options) => ({
     scriptInput: {
-      src: withQuery("https://analytics.tiktok.com/i18n/pixel/events.js", {
+      src: withQuery(tiktokPixelSrc(options?.region), {
         sdkid: options?.id,
         lib: "ttq"
       }),
@@ -14,39 +41,46 @@ export function useScriptTikTokPixel(_options) {
     schema: import.meta.dev ? TikTokPixelOptions : void 0,
     scriptOptions: {
       use() {
-        return { ttq: window.ttq };
+        return { ttq: createTtqAdapter() };
       }
     },
+    // TikTok's `events.js` consumes the official array-based snippet protocol:
+    // `window.ttq` is an Array of `[method, ...args]` tuples that `events.js`
+    // drains once loaded. (It does NOT understand the Facebook `fbq` callable
+    // protocol — using that shape silently drops every browser Pixel event.)
     clientInit: import.meta.server ? void 0 : () => {
       window.TiktokAnalyticsObject = "ttq";
-      const ttq = window.ttq = function(...params) {
-        if (ttq.callMethod) {
-          ttq.callMethod(...params);
-        } else {
-          ttq.queue.push(params);
-        }
-      };
-      ttq.push = ttq;
-      ttq.loaded = true;
-      ttq.queue = [];
-      const consentMethods = ["grantConsent", "revokeConsent", "holdConsent"];
-      for (const name of consentMethods) {
-        ;
-        ttq[name] = function(...params) {
-          ttq.queue.push([name, ...params]);
+      const ttq = window.ttq = window.ttq || [];
+      ttq.methods = TTQ_METHODS;
+      ttq.setAndDefer = function(target, method) {
+        target[method] = function(...args) {
+          target.push([method, ...args]);
         };
-      }
-      if (options?.defaultConsent === "granted")
-        ttq.grantConsent();
-      else if (options?.defaultConsent === "denied")
-        ttq.revokeConsent();
-      else if (options?.defaultConsent === "hold")
-        ttq.holdConsent();
+      };
+      for (const method of ttq.methods)
+        ttq.setAndDefer(ttq, method);
+      ttq.instance = function(id) {
+        const bag = ttq._i?.[id] || [];
+        for (const method of ttq.methods)
+          ttq.setAndDefer(bag, method);
+        return bag;
+      };
       if (options?.id) {
-        ttq("init", options.id);
-        if (options?.trackPageView !== false) {
-          ttq("page");
-        }
+        ttq._i = ttq._i || {};
+        ttq._i[options.id] = ttq._i[options.id] || [];
+        ttq._i[options.id]._u = tiktokPixelSrc(options?.region);
+        ttq._t = ttq._t || {};
+        ttq._t[options.id] = Date.now();
+        ttq._o = ttq._o || {};
+        ttq._o[options.id] = {};
+        if (options?.defaultConsent === "granted")
+          ttq.grantConsent();
+        else if (options?.defaultConsent === "denied")
+          ttq.revokeConsent();
+        else if (options?.defaultConsent === "hold")
+          ttq.holdConsent();
+        if (options?.trackPageView !== false)
+          ttq.page();
       }
     }
   }), _options);

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

@@ -0,0 +1,85 @@
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
+import { UsercentricsOptions } from './schemas.js';
+export { UsercentricsOptions };
+export type UsercentricsInput = RegistryScriptInput<typeof UsercentricsOptions, false, false>;
+export interface UsercentricsCmpEventDetail {
+    type: string;
+    source?: string;
+    [key: string]: any;
+}
+/**
+ * The Usercentrics CMP v3 programmatic API exposed on `window.__ucCmp`.
+ * Each method returns a Promise resolved once the CMP is ready.
+ */
+export interface UsercentricsCmp {
+    isInitialized: () => Promise<boolean>;
+    isConsentRequired: () => Promise<boolean>;
+    showFirstLayer: () => Promise<void>;
+    showSecondLayer: () => Promise<void>;
+    showServiceDetails: (id: string) => Promise<void>;
+    showAutoblockerMoreInfoView: () => Promise<void>;
+    closeCmp: () => Promise<void>;
+    acceptAllConsents: () => Promise<void>;
+    denyAllConsents: () => Promise<void>;
+    saveConsents: () => Promise<void>;
+    updateCategoriesConsents: (consents: Array<{
+        categorySlug: string;
+        consent: boolean;
+    }>) => Promise<void>;
+    updateServicesConsents: (consents: Array<{
+        templateId: string;
+        consent: boolean;
+    }>) => Promise<void>;
+    updateTcfConsents: (...args: unknown[]) => Promise<void>;
+    refreshScripts: () => Promise<void>;
+    clearUserSession: () => Promise<void>;
+    getConsentDetails: () => Promise<Record<string, any>>;
+    getCmpConfig: () => Promise<Record<string, any>>;
+    getActiveLanguage: () => Promise<string>;
+    getControllerId: () => Promise<string>;
+    changeLanguage: (lang: string) => Promise<void>;
+    [key: string]: any;
+}
+export interface UsercentricsApi {
+    ucCmp: UsercentricsCmp;
+}
+declare global {
+    interface Window {
+        __ucCmp?: UsercentricsCmp;
+    }
+}
+/**
+ * Vendor-native Usercentrics consent helpers exposed on the composable result.
+ * Use these to drive `useScript` consent triggers from CMP events.
+ */
+export interface UsercentricsConsent {
+    /**
+     * Resolves once the CMP API is ready (`UC_CMP_API_READY`) or immediately if
+     * it already is. Resolves with `window.__ucCmp` so callers can query
+     * consent state without polling.
+     */
+    whenReady: () => Promise<UsercentricsCmp>;
+    /**
+     * Subscribe to `UC_UI_CMP_EVENT` browser events (the v3 consent change
+     * event). Returns a teardown function. The callback receives the event
+     * detail, e.g. `{ type: 'ACCEPT_ALL' | 'DENY_ALL' | 'SAVE', ... }`.
+     */
+    onConsentChange: (cb: (detail: UsercentricsCmpEventDetail, event: Event) => void) => () => void;
+    /** Open the privacy settings (first layer banner). */
+    showFirstLayer: () => Promise<void> | void;
+    /** Open the detailed settings (second layer modal). */
+    showSecondLayer: () => Promise<void> | void;
+    /** Accept all consents. */
+    acceptAll: () => Promise<void> | void;
+    /** Reject all consents. */
+    denyAll: () => Promise<void> | void;
+}
+/**
+ * Load the Usercentrics CMP v3 ("Web CMP") loader and expose typed access to
+ * the `window.__ucCmp` programmatic API plus a `consent` helper with
+ * `onConsentChange` for wiring consent triggers (`useScript({ trigger: ... })`)
+ * to Usercentrics events.
+ *
+ * @see https://usercentrics.com/knowledge-hub/usercentrics-cmp-v3-migrations/
+ */
+export declare function useScriptUsercentrics<T extends UsercentricsApi>(_options?: UsercentricsInput): UseScriptContext<T, UsercentricsConsent>;

package/dist/runtime/registry/usercentrics.js

@@ -0,0 +1,54 @@
+import { useHead } from "@unhead/vue";
+import { useRegistryScript } from "../utils.js";
+import { UsercentricsOptions } from "./schemas.js";
+export { UsercentricsOptions };
+export function useScriptUsercentrics(_options) {
+  const instance = useRegistryScript("usercentrics", (options) => {
+    if (import.meta.client && options.autoblocker) {
+      useHead({
+        script: [{
+          src: "https://web.cmp.usercentrics.eu/modules/autoblocker.js",
+          tagPosition: "head",
+          tagPriority: "high"
+        }]
+      });
+    }
+    return {
+      scriptInput: {
+        "src": "https://web.cmp.usercentrics.eu/ui/loader.js",
+        "id": "usercentrics-cmp",
+        "data-ruleset-id": options.rulesetId,
+        "data-language": options.language,
+        "crossorigin": false
+      },
+      schema: import.meta.dev ? UsercentricsOptions : void 0,
+      scriptOptions: {
+        use() {
+          return { ucCmp: window.__ucCmp };
+        }
+      }
+    };
+  }, _options);
+  if (import.meta.client && !instance.consent) {
+    const whenReady = () => new Promise((resolve) => {
+      const onReady = () => {
+        window.removeEventListener("UC_CMP_API_READY", onReady);
+        resolve(window.__ucCmp);
+      };
+      window.addEventListener("UC_CMP_API_READY", onReady);
+    });
+    instance.consent = {
+      whenReady,
+      onConsentChange(cb) {
+        const handler = (e) => cb(e.detail, e);
+        window.addEventListener("UC_UI_CMP_EVENT", handler);
+        return () => window.removeEventListener("UC_UI_CMP_EVENT", handler);
+      },
+      showFirstLayer: () => window.__ucCmp?.showFirstLayer?.(),
+      showSecondLayer: () => window.__ucCmp?.showSecondLayer?.(),
+      acceptAll: () => window.__ucCmp?.acceptAllConsents?.(),
+      denyAll: () => window.__ucCmp?.denyAllConsents?.()
+    };
+  }
+  return instance;
+}