@nuxt/scripts 1.1.0 → 1.2.0

package/dist/runtime/components/ScriptYouTubePlayer.vue

@@ -115,12 +115,33 @@ onMounted(() => {
 defineExpose({
   player
 });
+const keyboardTriggerable = computed(() => {
+  if (isTriggered.value)
+    return false;
+  const triggers = Array.isArray(props.trigger) ? props.trigger : [props.trigger];
+  return triggers.some((t) => typeof t === "string" && !["immediate", "onNuxtReady", "visibility", "visible"].includes(t));
+});
+function onPlaceholderKeydown(e) {
+  if (e.key !== "Enter" && e.key !== " ")
+    return;
+  e.preventDefault();
+  if (!rootEl.value)
+    return;
+  const triggers = (Array.isArray(props.trigger) ? props.trigger : [props.trigger]).filter(Boolean);
+  for (const t of triggers) {
+    if (["immediate", "onNuxtReady", "visibility", "visible"].includes(t))
+      continue;
+    rootEl.value.dispatchEvent(new Event(t, { bubbles: false }));
+  }
+}
 const rootAttrs = computed(() => {
+  const interactive = keyboardTriggerable.value;
   return defu(props.rootAttrs, {
     "aria-busy": status.value === "loading",
-    "aria-label": status.value === "awaitingLoad" ? "YouTube Player - Placeholder" : status.value === "loading" ? "YouTube Player - Loading" : "YouTube Player - Loaded",
+    "aria-label": status.value === "awaitingLoad" ? interactive ? "Play video" : "YouTube Player - Placeholder" : status.value === "loading" ? "YouTube Player - Loading" : "YouTube Player - Loaded",
     "aria-live": "polite",
-    "role": "application",
+    "role": interactive ? "button" : "application",
+    "tabindex": interactive ? 0 : void 0,
     "style": {
       cursor: "pointer",
       position: "relative",
@@ -154,7 +175,7 @@ if (import.meta.server) {
 const placeholderAttrs = computed(() => {
   return defu(props.placeholderAttrs, {
     src: isFallbackPlaceHolder.value ? fallbackPlaceHolder.value : placeholder.value,
-    alt: "",
+    alt: "Play video",
     loading: props.aboveTheFold ? "eager" : "lazy",
     // @ts-expect-error untyped
     fetchpriority: props.aboveTheFold ? "high" : void 0,
@@ -174,7 +195,7 @@ const placeholderAttrs = computed(() => {
 </script>
 
 <template>
-  <div ref="rootEl" v-bind="rootAttrs">
+  <div ref="rootEl" v-bind="rootAttrs" @keydown="keyboardTriggerable ? onPlaceholderKeydown($event) : void 0">
     <div ref="youtubeEl" style="width: 100%; height: 100%; position: absolute; top: 0; left: 0;" />
     <slot v-if="!ready" :placeholder="placeholder" name="placeholder">
       <img v-bind="placeholderAttrs">

package/dist/runtime/composables/useScript.js

@@ -181,6 +181,7 @@ export function useScript(input, options) {
   if (!options.head) {
     throw new Error("useScript() has been called without Nuxt context.");
   }
+  const headHooks = options.head.hooks;
   ensureScripts(nuxtApp);
   const exists = !!nuxtApp.$scripts?.[id];
   const err = options._validate?.();
@@ -246,7 +247,7 @@ export function useScript(input, options) {
       ...ctx,
       trigger: typeof trigger === "object" ? trigger instanceof Promise ? "promise" : JSON.stringify(trigger) : trigger
     });
-    options.head.hooks.hook("script:updated", (entry) => {
+    headHooks.hook("script:updated", (entry) => {
       if (entry.script.id !== instance.id)
         return;
       const status = entry.script.status;
@@ -292,7 +293,7 @@ export function useScript(input, options) {
     };
     nuxtApp._scripts = nuxtApp._scripts || {};
     if (!nuxtApp._scripts[instance.id]) {
-      options.head.hooks.hook("script:updated", (ctx) => {
+      headHooks.hook("script:updated", (ctx) => {
         if (ctx.script.id !== instance.id)
           return;
         payload.events.push({
@@ -303,7 +304,7 @@ export function useScript(input, options) {
         payload.$script = instance;
         syncScripts();
       });
-      options.head.hooks.hook("script:instance-fn", (ctx) => {
+      headHooks.hook("script:instance-fn", (ctx) => {
         if (ctx.script.id !== instance.id || String(ctx.fn).startsWith("__v_"))
           return;
         payload.events.push({

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

@@ -988,6 +988,75 @@ export declare const InitObjectPropertiesSchema: import("valibot").ObjectSchema<
      */
     readonly age: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
 }, undefined>;
+export declare const SpeedCurveOptions: import("valibot").ObjectSchema<{
+    /**
+     * Your SpeedCurve customer ID.
+     * @see https://support.speedcurve.com/docs/add-rum-to-your-site
+     */
+    readonly id: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
+    /**
+     * Enable SPA (single-page application) mode.
+     * When true, lux.js tracks soft navigations instead of full page loads.
+     * @see https://support.speedcurve.com/docs/single-page-applications
+     */
+    readonly spaMode: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Automatically wire Vue Router hooks for SPA tracking when spaMode is true.
+     * Set to false to instrument navigations manually.
+     * @default true (when spaMode is true)
+     */
+    readonly autoTrackSpaNavigations: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Page label shown in the SpeedCurve dashboard.
+     * Accepts a static string, a function `(to) => string | false` for per-navigation labels,
+     * or `false` to disable labeling entirely. A callback returning `false` skips updating
+     * the label for that navigation.
+     * @default String(to.name ?? to.path)
+     */
+    readonly label: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").FunctionSchema<undefined>, import("valibot").LiteralSchema<false, undefined>], undefined>, undefined>;
+    /**
+     * Sampling rate (0–100). Percentage of sessions that send beacons.
+     * Upstream spelling is lowercase — matches LUX UserConfig.
+     */
+    readonly samplerate: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 100, undefined>]>, undefined>;
+    /**
+     * Send the beacon when the page is hidden (pagehide event).
+     * @default true
+     */
+    readonly sendBeaconOnPageHidden: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Track JavaScript errors.
+     * @default true
+     */
+    readonly trackErrors: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Maximum number of errors to track per page view.
+     * @default 5
+     */
+    readonly maxErrors: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    /**
+     * Minimum time (ms) before a beacon can be sent.
+     */
+    readonly minMeasureTime: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    /**
+     * Maximum time (ms) after which the beacon is sent regardless of load state.
+     * @default 60000
+     */
+    readonly maxMeasureTime: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+    /**
+     * Start a new beacon when the page becomes visible after being hidden.
+     */
+    readonly newBeaconOnPageShow: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Track pages loaded in background tabs.
+     * @default false
+     */
+    readonly trackHiddenPages: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Cookie domain for cross-subdomain session tracking.
+     */
+    readonly cookieDomain: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+}, undefined>;
 export declare const SnapTrPixelOptions: import("valibot").ObjectSchema<{
     /**
      * The user's email address (for matching).
@@ -1055,6 +1124,13 @@ export declare const StripeOptions: import("valibot").ObjectSchema<{
      * @see https://docs.stripe.com/disputes/prevention/advanced-fraud-detection
      */
     readonly advancedFraudSignals: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * The Stripe.js SDK version to load.
+     * Named releases get autocomplete; any future codename is also accepted.
+     * @default 'basil'
+     * @see https://docs.stripe.com/sdks/stripejs-versioning
+     */
+    readonly version: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"v3", undefined>, import("valibot").LiteralSchema<"acacia", undefined>, import("valibot").LiteralSchema<"basil", undefined>, import("valibot").LiteralSchema<"clover", undefined>, import("valibot").LiteralSchema<"dahlia", undefined>, import("valibot").StringSchema<undefined>], undefined>, undefined>;
 }, undefined>;
 export declare const TikTokPixelOptions: import("valibot").ObjectSchema<{
     /**

package/dist/runtime/registry/schemas.js

@@ -1,4 +1,4 @@
-import { any, array, boolean, custom, literal, minLength, number, object, optional, pipe, record, string, union } from "valibot";
+import { any, array, boolean, custom, function_, literal, maxValue, minLength, minValue, number, object, optional, pipe, record, string, union } from "valibot";
 const consentCategoryValue = union([literal("granted"), literal("denied")]);
 export const gcmConsentState = object({
   ad_storage: optional(consentCategoryValue),
@@ -947,6 +947,79 @@ export const InitObjectPropertiesSchema = object({
    */
   age: optional(string())
 });
+export const SpeedCurveOptions = object({
+  // -- Composable-only options (consumed by useScriptSpeedCurve, not forwarded to LUX) --
+  /**
+   * Your SpeedCurve customer ID.
+   * @see https://support.speedcurve.com/docs/add-rum-to-your-site
+   */
+  id: pipe(string(), minLength(1)),
+  /**
+   * Enable SPA (single-page application) mode.
+   * When true, lux.js tracks soft navigations instead of full page loads.
+   * @see https://support.speedcurve.com/docs/single-page-applications
+   */
+  spaMode: optional(boolean()),
+  /**
+   * Automatically wire Vue Router hooks for SPA tracking when spaMode is true.
+   * Set to false to instrument navigations manually.
+   * @default true (when spaMode is true)
+   */
+  autoTrackSpaNavigations: optional(boolean()),
+  // -- LUX UserConfig passthrough (forwarded onto window.LUX before lux.js loads) --
+  // Property names match upstream LUX UserConfig casing exactly. Keep this list in
+  // sync with the LUX_USER_CONFIG_KEYS filter in speedcurve.ts.
+  /**
+   * Page label shown in the SpeedCurve dashboard.
+   * Accepts a static string, a function `(to) => string | false` for per-navigation labels,
+   * or `false` to disable labeling entirely. A callback returning `false` skips updating
+   * the label for that navigation.
+   * @default String(to.name ?? to.path)
+   */
+  label: optional(union([string(), function_(), literal(false)])),
+  /**
+   * Sampling rate (0–100). Percentage of sessions that send beacons.
+   * Upstream spelling is lowercase — matches LUX UserConfig.
+   */
+  samplerate: optional(pipe(number(), minValue(0), maxValue(100))),
+  /**
+   * Send the beacon when the page is hidden (pagehide event).
+   * @default true
+   */
+  sendBeaconOnPageHidden: optional(boolean()),
+  /**
+   * Track JavaScript errors.
+   * @default true
+   */
+  trackErrors: optional(boolean()),
+  /**
+   * Maximum number of errors to track per page view.
+   * @default 5
+   */
+  maxErrors: optional(number()),
+  /**
+   * Minimum time (ms) before a beacon can be sent.
+   */
+  minMeasureTime: optional(number()),
+  /**
+   * Maximum time (ms) after which the beacon is sent regardless of load state.
+   * @default 60000
+   */
+  maxMeasureTime: optional(number()),
+  /**
+   * Start a new beacon when the page becomes visible after being hidden.
+   */
+  newBeaconOnPageShow: optional(boolean()),
+  /**
+   * Track pages loaded in background tabs.
+   * @default false
+   */
+  trackHiddenPages: optional(boolean()),
+  /**
+   * Cookie domain for cross-subdomain session tracking.
+   */
+  cookieDomain: optional(string())
+});
 export const SnapTrPixelOptions = object({
   /**
    * Your Snapchat Pixel ID.
@@ -966,7 +1039,14 @@ export const StripeOptions = object({
    * @default true
    * @see https://docs.stripe.com/disputes/prevention/advanced-fraud-detection
    */
-  advancedFraudSignals: optional(boolean())
+  advancedFraudSignals: optional(boolean()),
+  /**
+   * The Stripe.js SDK version to load.
+   * Named releases get autocomplete; any future codename is also accepted.
+   * @default 'basil'
+   * @see https://docs.stripe.com/sdks/stripejs-versioning
+   */
+  version: optional(union([literal("v3"), literal("acacia"), literal("basil"), literal("clover"), literal("dahlia"), string()]))
 });
 export const TikTokPixelOptions = object({
   /**

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

@@ -0,0 +1,21 @@
+import type { LuxGlobal, UserConfig } from '@speedcurve/lux';
+import type { RouteLocationNormalized } from 'vue-router';
+import type { RegistryScriptInput, UseScriptContext } from '#nuxt-scripts/types';
+import { SpeedCurveOptions } from './schemas.js';
+export { SpeedCurveOptions };
+export interface SpeedCurveApi {
+    LUX: LuxGlobal;
+}
+declare global {
+    interface Window {
+        LUX?: LuxGlobal;
+        LUX_ae?: ErrorEvent[];
+        LUX_al?: PerformanceEntry[];
+    }
+}
+export type SpeedCurveInput = Omit<RegistryScriptInput<typeof SpeedCurveOptions>, 'label'> & Omit<UserConfig, 'label'> & {
+    label?: string | ((to: RouteLocationNormalized) => string | false) | false;
+};
+export declare function useScriptSpeedCurve<T extends SpeedCurveApi>(_options?: SpeedCurveInput): UseScriptContext<T>;
+export declare function applyConfig(options: SpeedCurveInput): void;
+export declare function installAutoTracker(options?: SpeedCurveInput): void;

package/dist/runtime/registry/speedcurve.js

@@ -0,0 +1,93 @@
+import { useHead, useNuxtApp, useRouter } from "nuxt/app";
+import { luxSnippetSource } from "#build/nuxt-scripts-speedcurve-snippet";
+import { useRegistryScript } from "../utils.js";
+import { afterNextPaint } from "../utils/after-next-paint.js";
+import { SpeedCurveOptions } from "./schemas.js";
+export { SpeedCurveOptions };
+const LUX_USER_CONFIG_KEYS = Object.keys(SpeedCurveOptions.entries).filter(
+  (k) => k !== "id" && k !== "autoTrackSpaNavigations" && k !== "spaMode"
+);
+let luxWired = false;
+export function useScriptSpeedCurve(_options) {
+  return useRegistryScript("speedcurve", (options) => ({
+    scriptInput: {
+      src: `https://cdn.speedcurve.com/js/lux.js?id=${options.id}`,
+      crossorigin: "anonymous"
+    },
+    schema: import.meta.dev ? SpeedCurveOptions : void 0,
+    scriptOptions: {
+      trigger: "client",
+      use: () => ({ LUX: window.LUX }),
+      beforeInit: () => {
+        useHead({
+          script: [{
+            key: "speedcurve-lux-primer",
+            tagPosition: "head",
+            tagPriority: "critical",
+            innerHTML: luxSnippetSource
+          }]
+        });
+      }
+    },
+    clientInit: import.meta.server ? void 0 : () => {
+      const input = options;
+      applyConfig(input);
+      if (options.spaMode && options.autoTrackSpaNavigations !== false)
+        installAutoTracker(input);
+    }
+  }), _options);
+}
+export function applyConfig(options) {
+  const lux = window.LUX;
+  if (!lux)
+    return;
+  for (const k of LUX_USER_CONFIG_KEYS) {
+    const v = options[k];
+    if (v === void 0)
+      continue;
+    if (k === "label" && typeof v !== "string")
+      continue;
+    lux[k] = v;
+  }
+}
+export function installAutoTracker(options) {
+  if (luxWired)
+    return;
+  luxWired = true;
+  const router = useRouter();
+  const nuxt = useNuxtApp();
+  let pendingInitial = nuxt.payload?.serverRendered === false;
+  const label = options?.label === false ? null : typeof options?.label === "function" ? options.label : (to) => String(to.name ?? to.path);
+  router.beforeEach((to) => {
+    const lux = window.LUX;
+    if (!lux)
+      return;
+    if (pendingInitial) {
+      pendingInitial = false;
+      if (label) {
+        const nextLabel = label(to);
+        if (nextLabel !== false)
+          lux.label = nextLabel;
+      }
+      return;
+    }
+    lux.startSoftNavigation();
+    if (label) {
+      const nextLabel = label(to);
+      if (nextLabel !== false)
+        lux.label = nextLabel;
+    }
+  });
+  router.afterEach((_to, _from, failure) => {
+    if (!failure)
+      return;
+    const lux = window.LUX;
+    if (!lux)
+      return;
+    lux.markLoadTime();
+    lux.addData("luxNavFailed", "1");
+  });
+  nuxt.hook("page:finish", () => {
+    afterNextPaint(() => window.LUX?.markLoadTime());
+  });
+}

package/dist/runtime/registry/stripe.js

@@ -6,7 +6,7 @@ export function useScriptStripe(_options) {
   return useRegistryScript("stripe", (options) => ({
     scriptInput: {
       src: withQuery(
-        `https://js.stripe.com/basil/stripe.js`,
+        `https://js.stripe.com/${options?.version || "basil"}/stripe.js`,
         typeof options?.advancedFraudSignals === "boolean" && !options?.advancedFraudSignals ? { advancedFraudSignals: false } : {}
       ),
       // opt-out of privacy defaults

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

@@ -47,22 +47,61 @@ interface TrackOptions {
     test_event_code?: string;
     [key: string]: any;
 }
-type TtqFns = ((cmd: 'track', event: StandardEvents | (string & {}), properties?: EventProperties, options?: TrackOptions) => void) & ((cmd: 'page') => void) & ((cmd: 'identify', properties: IdentifyProperties) => void) & ((cmd: (string & {}), ...args: any[]) => void);
+/**
+ * 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;
     }
 }

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

@@ -6,6 +6,7 @@ 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"];
@@ -17,6 +18,17 @@ function warnUnhashedIdentify(props) {
     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: {
@@ -29,41 +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 (import.meta.dev && params[0] === "identify" && params[1])
-          warnUnhashedIdentify(params[1]);
-        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/server/instagram-embed.js

@@ -1,16 +1,41 @@
 import { createError, defineEventHandler, getQuery, setHeader } from "h3";
-import { useRuntimeConfig } from "nitropack/runtime";
+import { defineCachedFunction, useRuntimeConfig } from "nitropack/runtime";
+import { $fetch } from "ofetch";
 import { ELEMENT_NODE, parse, renderSync, TEXT_NODE, walkSync } from "ultrahtml";
 import { createCachedJsonFetch } from "./utils/cached-upstream.js";
-import { proxyAssetUrl, rewriteUrl, rewriteUrlsInText, RSRC_RE, scopeCss } from "./utils/instagram-embed.js";
+import { isEmbedShell, proxyAssetUrl, rewriteUrl, rewriteUrlsInText, RSRC_RE, scopeCss } from "./utils/instagram-embed.js";
 import { withSigning } from "./utils/withSigning.js";
 export { proxyAssetUrl, proxyImageUrl, rewriteUrl, rewriteUrlsInText, scopeCss } from "./utils/instagram-embed.js";
 const EMBED_INSTAGRAM_SUFFIX_RE = /\/embed\/instagram$/;
 const SRCSET_SPLIT_RE = /\s+/;
-const cachedEmbedFetch = createCachedJsonFetch(
-  "nuxt-scripts-instagram-embed",
-  600,
-  (url) => url
+const cachedEmbedFetch = defineCachedFunction(
+  async (url, headers) => {
+    const html = await $fetch(url, { timeout: 1e4, headers });
+    if (isEmbedShell(html)) {
+      throw createError({
+        statusCode: 502,
+        statusMessage: "Instagram returned an empty embed shell (post unavailable or upstream rate-limiting)"
+      });
+    }
+    return html;
+  },
+  {
+    // v2 — bump to evict any v1 entries that cached the empty JS shell
+    // before the shell-detection / UA fix landed.
+    name: "nuxt-scripts-instagram-embed-v2",
+    maxAge: 600,
+    swr: true,
+    staleMaxAge: 600,
+    // Vary on headers too — Instagram's response is UA-dependent, so
+    // different callers (e.g. unit tests, future UA changes) must not
+    // collide on the same key.
+    getKey: (url, headers) => {
+      const parts = [url];
+      for (const [k, v] of Object.entries(headers).sort(([a], [b]) => a.localeCompare(b)))
+        parts.push(`${k}=${v}`);
+      return parts.join("|");
+    }
+  }
 );
 const cachedCssFetch = createCachedJsonFetch(
   "nuxt-scripts-instagram-css",
@@ -56,10 +81,12 @@ export default withSigning(defineEventHandler(async (event) => {
   const cleanUrl = parsedUrl.origin + pathname;
   const embedUrl = `${cleanUrl}embed/${captions ? "captioned/" : ""}`;
   const html = await cachedEmbedFetch(embedUrl, {
-    headers: {
-      "Accept": "text/html",
-      "User-Agent": "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
-    }
+    "Accept": "text/html",
+    // Meta's own crawler UA. Googlebot's UA is also accepted by Instagram
+    // but is IP-verified, so it fails from hosts outside Google's ranges
+    // (e.g. Cloudflare/Vercel) and Instagram serves the JS shell instead
+    // of the SSR'd post.
+    "User-Agent": "facebookexternalhit/1.1 (+http://www.facebook.com/externalhit_uatext.php)"
   }).catch((error) => {
     throw createError({
       statusCode: error.statusCode || 500,

package/dist/runtime/server/proxy-handler.d.ts

@@ -1,3 +1,4 @@
+export declare const SKIP_REQUEST_HEADERS: Set<string>;
 /**
  * Privacy-aware proxy handler for first-party script collection endpoints.
  * Routes requests to third-party analytics while protecting user privacy.