@nuxt/scripts 1.0.6 → 1.1.1

package/dist/runtime/components/ScriptCalendlyInlineWidget.vue.d.ts

@@ -0,0 +1,59 @@
+import type { HTMLAttributes } from 'vue';
+import type { ElementScriptTrigger } from '../types.js';
+interface CalendlyPrefill {
+    name?: string;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    customAnswers?: Record<string, string>;
+}
+interface CalendlyUtm {
+    utmCampaign?: string;
+    utmSource?: string;
+    utmMedium?: string;
+    utmContent?: string;
+    utmTerm?: string;
+}
+interface CalendlyPageSettings {
+    backgroundColor?: string;
+    hideEventTypeDetails?: boolean;
+    hideLandingPageDetails?: boolean;
+    hideGdprBanner?: boolean;
+    primaryColor?: string;
+    textColor?: string;
+}
+type __VLS_Props = {
+    url: string;
+    trigger?: ElementScriptTrigger;
+    prefill?: CalendlyPrefill;
+    utm?: CalendlyUtm;
+    pageSettings?: CalendlyPageSettings;
+    rootAttrs?: HTMLAttributes;
+    aboveTheFold?: boolean;
+    minHeight?: string;
+};
+type __VLS_Slots = {
+    default?: () => any;
+    loading?: () => any;
+    awaitingLoad?: () => any;
+    error?: () => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    error: () => any;
+    ready: (api: {
+        Calendly: typeof window.Calendly;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onError?: (() => any) | undefined;
+    onReady?: ((api: {
+        Calendly: typeof window.Calendly;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ScriptPayPalButtons.d.vue.ts

@@ -64,8 +64,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     onError?: ((error: unknown) => any) | undefined;
     onReady?: ((instance: SdkInstance<Components[]>) => any) | undefined;
 }>, {
-    trigger: ElementScriptTrigger;
     clientId: string;
+    trigger: ElementScriptTrigger;
     components: Components[];
     paypalScriptOptions: Partial<PayPalInput>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/components/ScriptPayPalButtons.vue.d.ts

@@ -64,8 +64,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     onError?: ((error: unknown) => any) | undefined;
     onReady?: ((instance: SdkInstance<Components[]>) => any) | undefined;
 }>, {
-    trigger: ElementScriptTrigger;
     clientId: string;
+    trigger: ElementScriptTrigger;
     components: Components[];
     paypalScriptOptions: Partial<PayPalInput>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/components/ScriptPayPalMessages.d.vue.ts

@@ -62,8 +62,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     onError?: ((error: unknown) => any) | undefined;
     onReady?: ((session: PayPalMessagesSession) => any) | undefined;
 }>, {
-    trigger: ElementScriptTrigger;
     clientId: string;
+    trigger: ElementScriptTrigger;
     paypalScriptOptions: Partial<PayPalInput>;
     messagesOptions: PayPalMessagesOptions;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/components/ScriptPayPalMessages.vue.d.ts

@@ -62,8 +62,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     onError?: ((error: unknown) => any) | undefined;
     onReady?: ((session: PayPalMessagesSession) => any) | undefined;
 }>, {
-    trigger: ElementScriptTrigger;
     clientId: string;
+    trigger: ElementScriptTrigger;
     paypalScriptOptions: Partial<PayPalInput>;
     messagesOptions: PayPalMessagesOptions;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/composables/useScript.js

@@ -3,6 +3,7 @@ import { defu } from "defu";
 import { injectHead, onNuxtReady, useHead, useNuxtApp, useRuntimeConfig } from "nuxt/app";
 import { markRaw, ref } from "vue";
 import { resolveTrigger } from "#build/nuxt-scripts-trigger-resolver";
+import { debugEnabled } from "../debug.js";
 import { logger } from "../logger.js";
 function resolveProxyPrefix() {
   const devtoolsConfig = useRuntimeConfig().public["nuxt-scripts-devtools"];
@@ -227,6 +228,53 @@ export function useScript(input, options) {
     return reloaded.load();
   };
   nuxtApp.$scripts[id] = instance;
+  if (import.meta.client && debugEnabled) {
+    const registryKey = options?.devtools?.registryKey;
+    const src = input?.src;
+    const trigger = options?.trigger;
+    const loadedFrom = options?.devtools?.loadedFrom;
+    const ctx = {
+      id: instance.id,
+      ...registryKey ? { registryKey } : {},
+      ...src ? { src } : {},
+      ...loadedFrom ? { loadedFrom } : {}
+    };
+    const log = logger.withTag(registryKey || instance.id);
+    const t0 = performance.now();
+    let tLoadStart = 0;
+    log.debug("registered", {
+      ...ctx,
+      trigger: typeof trigger === "object" ? trigger instanceof Promise ? "promise" : JSON.stringify(trigger) : trigger
+    });
+    options.head.hooks.hook("script:updated", (entry) => {
+      if (entry.script.id !== instance.id)
+        return;
+      const status = entry.script.status;
+      const elapsed = Math.round(performance.now() - t0);
+      if (status === "loading")
+        tLoadStart = performance.now();
+      const payload = { ...ctx, status, elapsedMs: elapsed };
+      if (status === "loaded" && tLoadStart)
+        payload.loadMs = Math.round(performance.now() - tLoadStart);
+      const fn = status === "error" ? log.warn : log.debug;
+      fn(`status: ${status}`, payload);
+    });
+    const _origLoad = instance.load;
+    instance.load = () => {
+      log.debug("load() called", ctx);
+      return _origLoad();
+    };
+    const _origRemove = instance.remove;
+    instance.remove = () => {
+      log.debug("remove() called", ctx);
+      return _origRemove();
+    };
+    const _origReload = instance.reload;
+    instance.reload = async () => {
+      log.debug("reload() called", ctx);
+      return _origReload();
+    };
+  }
   if (import.meta.dev && import.meta.client) {
     let syncScripts = function() {
       nuxtApp._scripts[instance.id] = payload;

package/dist/runtime/debug.d.ts

@@ -0,0 +1 @@
+export declare const debugEnabled: boolean;

package/dist/runtime/debug.js

@@ -0,0 +1 @@
+export const debugEnabled = typeof __NUXT_SCRIPTS_DEBUG__ !== "undefined" && __NUXT_SCRIPTS_DEBUG__;

package/dist/runtime/devtools-standalone-bridge.client.js

@@ -20,7 +20,9 @@ export default defineNuxtPlugin(() => {
         firstPartyData,
         route: route ? { path: route.path, fullPath: route.fullPath, query: route.query } : null
       })
-    }).catch(() => {
+    }).catch((error) => {
+      if (import.meta.dev)
+        console.warn("[nuxt-scripts] Failed to sync standalone devtools state:", error);
     });
   }
   nuxtApp.hooks.hook("scripts:updated", (ctx) => {

package/dist/runtime/logger.js

@@ -1,5 +1,9 @@
 import { createConsola } from "consola";
+import { debugEnabled } from "./debug.js";
 export const logger = createConsola({
+  // 4 = debug, 3 = info (consola defaults). Lift the threshold so `logger.debug`
+  // fires when debug is opted-in at build time or in dev.
+  level: debugEnabled ? 4 : 3,
   defaults: {
     tag: "nuxt-scripts"
   }

package/dist/runtime/registry/_gcm-consent.d.ts

@@ -0,0 +1,14 @@
+import type { ConsentState, GcmConsentApi, UseScriptContext } from '../types.js';
+import { logger } from '../logger.js';
+export type { GcmConsentApi };
+/**
+ * GCMv2 consent contract returned by registry scripts (GA, GTM, future Google Ads, …).
+ * `useRegistryScript` wires the `consent.default/update` API when present.
+ */
+export interface GcmConsentContract {
+    /** Forward a `consent`,`<action>`, `<state>` call to the script's transport (dataLayer or gtag). */
+    push: (proxy: any, action: 'default' | 'update', state: ConsentState) => void;
+}
+/** Validate a partial GCMv2 consent state. Logs each issue via the registry-scoped logger. */
+export declare function validateConsentState(log: typeof logger, state: ConsentState, source: string): void;
+export declare function attachGcmConsent(instance: UseScriptContext<any, GcmConsentApi>, contract: GcmConsentContract, registryKey: string): void;

package/dist/runtime/registry/_gcm-consent.js

@@ -0,0 +1,24 @@
+import { safeParse, strictObject } from "valibot";
+import { logger } from "../logger.js";
+import { gcmConsentState } from "./schemas.js";
+const gcmConsentStateStrict = strictObject(gcmConsentState.entries);
+export function validateConsentState(log, state, source) {
+  const result = safeParse(gcmConsentStateStrict, state);
+  if (result.success)
+    return;
+  for (const issue of result.issues)
+    log.warn(`${source}: ${issue.message} (path: ${issue.path?.map((p) => p.key).join(".") || "<root>"})`);
+}
+export function attachGcmConsent(instance, contract, registryKey) {
+  if (instance.consent)
+    return;
+  const log = logger.withTag(registryKey);
+  const push = (action, state) => {
+    validateConsentState(log, state, `consent.${action}()`);
+    contract.push(instance.proxy, action, state);
+  };
+  instance.consent = {
+    default: (state) => push("default", state),
+    update: (state) => push("update", state)
+  };
+}

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

@@ -0,0 +1,39 @@
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
+import { AhrefsAnalyticsOptions } from './schemas.js';
+export { AhrefsAnalyticsOptions };
+export type AhrefsAnalyticsInput = RegistryScriptInput<typeof AhrefsAnalyticsOptions, true, false>;
+export interface AhrefsAnalyticsSendEventOptions {
+    /** Custom dimensions sent under `props`. */
+    props?: Record<string, string>;
+    /** Arbitrary metadata sent under `meta`. */
+    meta?: Record<string, unknown>;
+    /** Optional callback invoked once the beacon request completes. */
+    callback?: (result?: {
+        status?: number;
+    }) => void;
+}
+export interface AhrefsAnalyticsInstance {
+    /**
+     * Manually send an event to Ahrefs Analytics. The script auto-fires
+     * page-view events on initial load and on `history.pushState`/`popstate`,
+     * so SPA navigations are tracked without calling this.
+     */
+    sendEvent: (name: string, options?: AhrefsAnalyticsSendEventOptions) => void;
+}
+export interface AhrefsAnalyticsApi {
+    AhrefsAnalytics: AhrefsAnalyticsInstance;
+}
+declare global {
+    interface Window extends AhrefsAnalyticsApi {
+    }
+}
+/**
+ * Load Ahrefs Web Analytics and expose its `sendEvent` API.
+ *
+ * The script attaches `window.AhrefsAnalytics` once loaded, fires an initial
+ * page-view, and tracks SPA navigations natively by patching
+ * `history.pushState` and listening to `popstate`.
+ *
+ * @see https://ahrefs.com/web-analytics
+ */
+export declare function useScriptAhrefsAnalytics<T extends AhrefsAnalyticsApi>(_options?: AhrefsAnalyticsInput): UseScriptContext<T>;

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

@@ -0,0 +1,18 @@
+import { useRegistryScript } from "../utils.js";
+import { AhrefsAnalyticsOptions } from "./schemas.js";
+export { AhrefsAnalyticsOptions };
+export function useScriptAhrefsAnalytics(_options) {
+  return useRegistryScript("ahrefsAnalytics", (options) => ({
+    scriptInput: {
+      "src": "https://analytics.ahrefs.com/analytics.js",
+      "data-key": options.key,
+      "crossorigin": false
+    },
+    schema: import.meta.dev ? AhrefsAnalyticsOptions : void 0,
+    scriptOptions: {
+      use() {
+        return { AhrefsAnalytics: window.AhrefsAnalytics };
+      }
+    }
+  }), _options);
+}

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

@@ -0,0 +1,76 @@
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
+import { CalendlyOptions } from './schemas.js';
+export { CalendlyOptions };
+export type CalendlyInput = RegistryScriptInput<typeof CalendlyOptions, true, false>;
+interface CalendlyPrefill {
+    name?: string;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    customAnswers?: Record<string, string>;
+}
+interface CalendlyUtm {
+    utmCampaign?: string;
+    utmSource?: string;
+    utmMedium?: string;
+    utmContent?: string;
+    utmTerm?: string;
+}
+interface CalendlyPageSettings {
+    backgroundColor?: string;
+    hideEventTypeDetails?: boolean;
+    hideLandingPageDetails?: boolean;
+    hideGdprBanner?: boolean;
+    primaryColor?: string;
+    textColor?: string;
+}
+export interface CalendlyInlineWidgetOptions {
+    url: string;
+    parentElement: HTMLElement;
+    prefill?: CalendlyPrefill;
+    utm?: CalendlyUtm;
+    pageSettings?: CalendlyPageSettings;
+}
+export interface CalendlyPopupWidgetOptions {
+    url: string;
+    rootElement?: HTMLElement;
+    text?: string;
+    color?: string;
+    textColor?: string;
+    branding?: boolean;
+    prefill?: CalendlyPrefill;
+    utm?: CalendlyUtm;
+    pageSettings?: CalendlyPageSettings;
+}
+export interface CalendlyBadgeWidgetOptions {
+    url: string;
+    text?: string;
+    color?: string;
+    textColor?: string;
+    branding?: boolean;
+    prefill?: CalendlyPrefill;
+    utm?: CalendlyUtm;
+    pageSettings?: CalendlyPageSettings;
+}
+export interface CalendlyApi {
+    Calendly: {
+        initInlineWidget: (options: CalendlyInlineWidgetOptions) => void;
+        initPopupWidget: (options: CalendlyPopupWidgetOptions) => void;
+        initBadgeWidget: (options: CalendlyBadgeWidgetOptions) => void;
+        showPopupWidget: (url: string) => void;
+        closePopupWidget: () => void;
+        initPopupWidgetWithText: (options: CalendlyPopupWidgetOptions) => void;
+        q?: unknown[];
+    };
+}
+declare global {
+    interface Window extends CalendlyApi {
+    }
+}
+/**
+ * Load the Calendly widget script and expose a typed `Calendly` proxy for
+ * inline, popup, and badge bookings.
+ *
+ * @see https://help.calendly.com/hc/en-us/articles/223147027
+ */
+export declare function useScriptCalendly<T extends CalendlyApi>(_options?: CalendlyInput): UseScriptContext<T>;

package/dist/runtime/registry/calendly.js

@@ -0,0 +1,63 @@
+import { useHead } from "@unhead/vue";
+import { useRegistryScript } from "../utils.js";
+import { CalendlyOptions } from "./schemas.js";
+export { CalendlyOptions };
+const CALENDLY_CSS_KEY = "nuxt-scripts-calendly-css";
+const CALENDLY_CLOSE_ICON = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(
+  '<svg width="22" height="22" xmlns="http://www.w3.org/2000/svg"><path d="M11.192 9.071l7.779-7.778a1.5 1.5 0 0 1 2.12 2.121l-7.777 7.778 7.778 7.779a1.5 1.5 0 1 1-2.121 2.12l-7.779-7.777-7.778 7.778a1.5 1.5 0 1 1-2.121-2.121l7.778-7.779-7.778-7.778a1.5 1.5 0 0 1 2.121-2.121l7.778 7.778z" fill="#FFF" fill-rule="nonzero"/></svg>'
+)}`;
+const CALENDLY_CSS = `.calendly-badge-widget,.calendly-badge-widget *,.calendly-inline-widget,.calendly-inline-widget *,.calendly-overlay,.calendly-overlay *{font-size:16px;line-height:1.2em}.calendly-badge-widget iframe,.calendly-inline-widget iframe,.calendly-overlay iframe{display:inline;height:100%;width:100%}.calendly-popup-content{position:relative}.calendly-popup-content.calendly-mobile{-webkit-overflow-scrolling:touch;overflow-y:auto}.calendly-overlay{background-color:#a5a5a5;background-color:rgba(31,31,31,.4);bottom:0;left:0;overflow:hidden;position:fixed;right:0;top:0;z-index:9999}.calendly-overlay .calendly-close-overlay{bottom:0;left:0;position:absolute;right:0;top:0}.calendly-overlay .calendly-popup{box-sizing:border-box;height:90%;left:50%;max-height:700px!important;max-width:1000px;min-width:900px;position:absolute;top:50%;transform:translateY(-50%) translateX(-50%);width:80%}@media (max-width:975px){.calendly-overlay .calendly-popup{bottom:0;height:auto;left:0;max-height:none;min-width:0;position:fixed;right:0;top:50px;transform:none;width:100%}}.calendly-overlay .calendly-popup .calendly-popup-content{height:100%}.calendly-overlay .calendly-popup-close{background:url(${CALENDLY_CLOSE_ICON}) no-repeat;background-size:contain;color:#fff;cursor:pointer;height:19px;position:absolute;right:25px;top:25px;width:19px}@media (max-width:975px){.calendly-overlay .calendly-popup-close{right:15px;top:15px}}.calendly-badge-widget{bottom:15px;position:fixed;right:20px;z-index:9998}.calendly-badge-widget .calendly-badge-content{border-radius:25px;box-shadow:0 2px 5px rgba(0,0,0,.25);color:#fff;cursor:pointer;display:table-cell;font-family:sans-serif;font-size:14px;font-weight:700;height:45px;padding:0 30px;text-align:center;vertical-align:middle;width:auto}.calendly-badge-widget .calendly-badge-content.calendly-white{color:#666a73}.calendly-badge-widget .calendly-badge-content span{display:block;font-size:12px}.calendly-spinner{left:0;position:absolute;right:0;text-align:center;top:50%;transform:translateY(-50%);z-index:-1}.calendly-spinner>div{animation:calendly-bouncedelay 1.4s ease-in-out infinite;animation-fill-mode:both;background-color:#e1e1e1;border-radius:50%;display:inline-block;height:18px;vertical-align:middle;width:18px}.calendly-spinner .calendly-bounce1{animation-delay:-.32s}.calendly-spinner .calendly-bounce2{animation-delay:-.16s}@keyframes calendly-bouncedelay{0%,80%,to{transform:scale(0)}40%{transform:scale(1)}}`;
+function ensureCalendlyStylesheet() {
+  if (import.meta.server)
+    return;
+  useHead({
+    style: [
+      {
+        key: CALENDLY_CSS_KEY,
+        innerHTML: CALENDLY_CSS
+      }
+    ]
+  });
+}
+export function useScriptCalendly(_options) {
+  ensureCalendlyStylesheet();
+  return useRegistryScript("calendly", () => ({
+    scriptInput: {
+      src: "https://assets.calendly.com/assets/external/widget.js",
+      crossorigin: false
+    },
+    schema: import.meta.dev ? CalendlyOptions : void 0,
+    scriptOptions: {
+      use() {
+        return { Calendly: window.Calendly };
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      if (window.Calendly)
+        return;
+      const queue = [];
+      const stub = {
+        q: queue,
+        initInlineWidget(...args) {
+          queue.push(["initInlineWidget", ...args]);
+        },
+        initPopupWidget(...args) {
+          queue.push(["initPopupWidget", ...args]);
+        },
+        initBadgeWidget(...args) {
+          queue.push(["initBadgeWidget", ...args]);
+        },
+        initPopupWidgetWithText(...args) {
+          queue.push(["initPopupWidgetWithText", ...args]);
+        },
+        showPopupWidget(...args) {
+          queue.push(["showPopupWidget", ...args]);
+        },
+        closePopupWidget(...args) {
+          queue.push(["closePopupWidget", ...args]);
+        }
+      };
+      window.Calendly = stub;
+    }
+  }), _options);
+}

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

@@ -1,4 +1,5 @@
-import type { ConsentState, RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
+import type { GcmConsentApi } from './_gcm-consent.js';
 import { GoogleAnalyticsOptions } from './schemas.js';
 export type GtagCustomParams = Record<string, any>;
 export type ConsentStatus = 'granted' | 'denied';
@@ -58,10 +59,8 @@ export interface GoogleAnalyticsApi {
 }
 export { GoogleAnalyticsOptions };
 export type GoogleAnalyticsInput = RegistryScriptInput<typeof GoogleAnalyticsOptions>;
-export interface GoogleAnalyticsConsent {
-    /** Send `gtag('consent','update', state)` with GCMv2 partial state. */
-    update: (state: ConsentState) => void;
-}
+/** @deprecated Use {@link GcmConsentApi} from `#nuxt-scripts/types` instead. */
+export type GoogleAnalyticsConsent = GcmConsentApi;
 export declare function useScriptGoogleAnalytics<T extends GoogleAnalyticsApi>(_options?: GoogleAnalyticsInput & {
     onBeforeGtagStart?: (gtag: GTag) => void;
-}): UseScriptContext<T, GoogleAnalyticsConsent>;
+}): UseScriptContext<T, GcmConsentApi>;

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

@@ -3,7 +3,7 @@ import { useRegistryScript } from "#nuxt-scripts/utils";
 import { GoogleAnalyticsOptions } from "./schemas.js";
 export { GoogleAnalyticsOptions };
 export function useScriptGoogleAnalytics(_options) {
-  const instance = useRegistryScript(_options?.key || "googleAnalytics", (options) => {
+  return useRegistryScript(_options?.key || "googleAnalytics", (options) => {
     const dataLayerName = options?.l ?? "dataLayer";
     const w = import.meta.client ? window : {};
     return {
@@ -19,6 +19,9 @@ export function useScriptGoogleAnalytics(_options) {
           };
         }
       },
+      gcmConsent: {
+        push: (proxy, action, state) => proxy.gtag("consent", action, state)
+      },
       clientInit: import.meta.server ? void 0 : () => {
         w[dataLayerName] = w[dataLayerName] || [];
         w.gtag = function() {
@@ -37,13 +40,4 @@ export function useScriptGoogleAnalytics(_options) {
       }
     };
   }, _options);
-  if (import.meta.client && !instance.consent) {
-    instance.consent = {
-      update: (state) => {
-        ;
-        instance.proxy.gtag("consent", "update", state);
-      }
-    };
-  }
-  return instance;
 }

package/dist/runtime/registry/google-tag-manager.d.ts

@@ -1,4 +1,5 @@
-import type { ConsentState, NuxtUseScriptOptions, RegistryScriptInput, UseFunctionType, UseScriptContext } from '#nuxt-scripts/types';
+import type { NuxtUseScriptOptions, RegistryScriptInput, UseFunctionType, UseScriptContext } from '#nuxt-scripts/types';
+import type { GcmConsentApi } from './_gcm-consent.js';
 import type { GTag } from './google-analytics.js';
 import { GoogleTagManagerOptions } from './schemas.js';
 /**
@@ -68,10 +69,8 @@ declare global {
 }
 export { GoogleTagManagerOptions };
 export type GoogleTagManagerInput = RegistryScriptInput<typeof GoogleTagManagerOptions>;
-export interface GoogleTagManagerConsent {
-    /** Push `['consent','update', state]` onto dataLayer with GCMv2 partial state. */
-    update: (state: ConsentState) => void;
-}
+/** @deprecated Use {@link GcmConsentApi} from `#nuxt-scripts/types` instead. */
+export type GoogleTagManagerConsent = GcmConsentApi;
 /**
  * Hook to use Google Tag Manager in Nuxt applications
  */
@@ -81,4 +80,4 @@ export declare function useScriptGoogleTagManager<T extends GoogleTagManagerApi>
      * Allows for custom initialization or configuration
      */
     onBeforeGtmStart?: (gtag: DataLayerPush) => void;
-}): UseScriptContext<UseFunctionType<NuxtUseScriptOptions<T>, T>, GoogleTagManagerConsent>;
+}): UseScriptContext<UseFunctionType<NuxtUseScriptOptions<T>, T>, GcmConsentApi>;

package/dist/runtime/registry/google-tag-manager.js

@@ -3,7 +3,7 @@ import { useRegistryScript } from "#nuxt-scripts/utils";
 import { GoogleTagManagerOptions } from "./schemas.js";
 export { GoogleTagManagerOptions };
 export function useScriptGoogleTagManager(options) {
-  const instance = useRegistryScript(
+  return useRegistryScript(
     options?.key || "googleTagManager",
     (opts) => {
       const dataLayerName = opts?.l ?? opts?.dataLayer ?? "dataLayer";
@@ -31,10 +31,20 @@ export function useScriptGoogleTagManager(options) {
             };
           }
         },
+        gcmConsent: {
+          // Match the gtag.js contract: enqueue an `Arguments` object, not a plain Array,
+          // so GTM/Tag Assistant/Analytics Debugger recognise the consent command. See #770/#771.
+          push: (_proxy, action, state) => {
+            const dl = window[dataLayerName] = window[dataLayerName] || [];
+            (function(..._args) {
+              dl.push(arguments);
+            })("consent", action, state);
+          }
+        },
         clientInit: import.meta.server ? void 0 : () => {
           window[dataLayerName] = window[dataLayerName] || [];
-          function gtag(...args) {
-            window[dataLayerName].push(args);
+          function gtag(..._args) {
+            window[dataLayerName].push(arguments);
           }
           window.gtag = gtag;
           if (opts.defaultConsent) {
@@ -52,19 +62,4 @@ export function useScriptGoogleTagManager(options) {
     },
     options
   );
-  if (import.meta.client && options?.onBeforeGtmStart) {
-    const gtag = window.gtag;
-    if (gtag)
-      options.onBeforeGtmStart(gtag);
-  }
-  const typed = instance;
-  if (import.meta.client && !typed.consent) {
-    typed.consent = {
-      update: (state) => {
-        ;
-        typed.proxy.dataLayer.push(["consent", "update", state]);
-      }
-    };
-  }
-  return typed;
 }

package/dist/runtime/registry/linkedin-insight.d.ts

@@ -0,0 +1,35 @@
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
+import { LinkedInInsightOptions } from './schemas.js';
+export { LinkedInInsightOptions };
+export type LinkedInInsightInput = RegistryScriptInput<typeof LinkedInInsightOptions, true, false>;
+interface LintrkTrackParams {
+    conversion_id?: number;
+    event_id?: string;
+    commandCallback?: () => void;
+    [key: string]: any;
+}
+interface LintrkUserData {
+    /** Plain email; the script SHA-256 hashes it before sending. */
+    email: string;
+}
+type LintrkFns = ((cmd: 'track', params?: LintrkTrackParams) => void) & ((cmd: 'setUserData', data: LintrkUserData) => void) & ((cmd: (string & {}), ...args: any[]) => void);
+export interface LinkedInInsightApi {
+    lintrk: LintrkFns & {
+        q?: unknown[];
+    };
+}
+declare global {
+    interface Window extends LinkedInInsightApi {
+        _linkedin_partner_id?: string;
+        _linkedin_data_partner_ids?: string[];
+        _linkedin_event_id?: string;
+        _wait_for_lintrk?: boolean;
+    }
+}
+/**
+ * Load the LinkedIn Insight Tag and expose a typed `lintrk` proxy.
+ *
+ * @see https://www.linkedin.com/help/lms/answer/a418880
+ * @see https://learn.microsoft.com/en-us/linkedin/marketing/conversions/deduplication
+ */
+export declare function useScriptLinkedInInsight<T extends LinkedInInsightApi>(_options?: LinkedInInsightInput): UseScriptContext<T>;

package/dist/runtime/registry/linkedin-insight.js

@@ -0,0 +1,49 @@
+import { useScriptEventPage } from "../composables/useScriptEventPage.js";
+import { useRegistryScript } from "../utils.js";
+import { LinkedInInsightOptions } from "./schemas.js";
+export { LinkedInInsightOptions };
+export function useScriptLinkedInInsight(_options) {
+  let enableAutoSpaTracking = false;
+  const instance = useRegistryScript("linkedinInsight", (options) => {
+    enableAutoSpaTracking = !!options.enableAutoSpaTracking;
+    return {
+      scriptInput: {
+        src: "https://snap.licdn.com/li.lms-analytics/insight.min.js",
+        crossorigin: false
+      },
+      schema: import.meta.dev ? LinkedInInsightOptions : void 0,
+      scriptOptions: {
+        use() {
+          return { lintrk: window.lintrk };
+        }
+      },
+      clientInit: import.meta.server ? void 0 : () => {
+        const ids = Array.isArray(options.id) ? options.id : [options.id];
+        if (options.eventId)
+          window._linkedin_event_id = options.eventId;
+        if (options.enableAutoSpaTracking)
+          window._wait_for_lintrk = true;
+        window._linkedin_partner_id = ids[0];
+        window._linkedin_data_partner_ids = window._linkedin_data_partner_ids || [];
+        for (const id of ids) {
+          if (!window._linkedin_data_partner_ids.includes(id))
+            window._linkedin_data_partner_ids.push(id);
+        }
+        if (!window.lintrk) {
+          const lintrk = function(cmd, ...args) {
+            ;
+            lintrk.q.push([cmd, ...args]);
+          };
+          lintrk.q = [];
+          window.lintrk = lintrk;
+        }
+      }
+    };
+  }, _options);
+  if (import.meta.client && enableAutoSpaTracking) {
+    useScriptEventPage(() => {
+      window.lintrk?.("track");
+    });
+  }
+  return instance;
+}