@nuxt/scripts 1.0.0-beta.26 → 1.0.0-beta.28

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsOverlayView.d.vue.ts

@@ -0,0 +1,40 @@
+type OverlayAnchor = 'center' | 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'left-center' | 'right-center';
+type OverlayPane = 'mapPane' | 'overlayLayer' | 'markerLayer' | 'overlayMouseTarget' | 'floatPane';
+type __VLS_Props = {
+    position?: google.maps.LatLngLiteral;
+    anchor?: OverlayAnchor;
+    offset?: {
+        x: number;
+        y: number;
+    };
+    pane?: OverlayPane;
+    zIndex?: number;
+    blockMapInteraction?: boolean;
+};
+type __VLS_ModelProps = {
+    'open'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    overlay: import("vue").ShallowRef<google.maps.OverlayView | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean | undefined) => any) | undefined;
+}>, {
+    anchor: OverlayAnchor;
+    pane: OverlayPane;
+    blockMapInteraction: boolean;
+}, {}, {}, {}, 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/GoogleMaps/ScriptGoogleMapsOverlayView.vue

@@ -0,0 +1,168 @@
+<script setup>
+import { inject, useTemplateRef, watch } from "vue";
+import { ADVANCED_MARKER_ELEMENT_INJECTION_KEY, MARKER_INJECTION_KEY } from "./injectionKeys";
+import { useGoogleMapsResource } from "./useGoogleMapsResource";
+const props = defineProps({
+  position: { type: null, required: false },
+  anchor: { type: String, required: false, default: "bottom-center" },
+  offset: { type: Object, required: false },
+  pane: { type: String, required: false, default: "floatPane" },
+  zIndex: { type: Number, required: false },
+  blockMapInteraction: { type: Boolean, required: false, default: true }
+});
+const open = defineModel("open", { type: Boolean });
+const markerContext = inject(MARKER_INJECTION_KEY, void 0);
+const advancedMarkerElementContext = inject(ADVANCED_MARKER_ELEMENT_INJECTION_KEY, void 0);
+function getResolvedPosition() {
+  if (props.position)
+    return props.position;
+  if (markerContext?.marker.value) {
+    const pos = markerContext.marker.value.getPosition();
+    if (pos)
+      return { lat: pos.lat(), lng: pos.lng() };
+  }
+  if (advancedMarkerElementContext?.advancedMarkerElement.value) {
+    const pos = advancedMarkerElementContext.advancedMarkerElement.value.position;
+    if (pos) {
+      if ("lat" in pos && typeof pos.lat === "function")
+        return { lat: pos.lat(), lng: pos.lng() };
+      return pos;
+    }
+  }
+  return void 0;
+}
+const ANCHOR_TRANSFORMS = {
+  "center": "translate(-50%, -50%)",
+  "top-left": "translate(0, 0)",
+  "top-center": "translate(-50%, 0)",
+  "top-right": "translate(-100%, 0)",
+  "bottom-left": "translate(0, -100%)",
+  "bottom-center": "translate(-50%, -100%)",
+  "bottom-right": "translate(-100%, -100%)",
+  "left-center": "translate(0, -50%)",
+  "right-center": "translate(-100%, -50%)"
+};
+const overlayContent = useTemplateRef("overlay-content");
+const listeners = [];
+const overlay = useGoogleMapsResource({
+  // ready condition accesses .value on ShallowRefs — tracked by whenever() in useGoogleMapsResource
+  ready: () => !!overlayContent.value && !!(props.position || markerContext?.marker.value || advancedMarkerElementContext?.advancedMarkerElement.value),
+  create({ mapsApi, map }) {
+    const el = overlayContent.value;
+    class CustomOverlay extends mapsApi.OverlayView {
+      onAdd() {
+        const panes = this.getPanes();
+        if (panes) {
+          panes[props.pane].appendChild(el);
+          if (props.blockMapInteraction)
+            mapsApi.OverlayView.preventMapHitsAndGesturesFrom(el);
+        }
+      }
+      draw() {
+        if (open.value === false) {
+          el.style.visibility = "hidden";
+          return;
+        }
+        const position = getResolvedPosition();
+        if (!position) {
+          el.style.visibility = "hidden";
+          return;
+        }
+        const projection = this.getProjection();
+        if (!projection) {
+          el.style.visibility = "hidden";
+          return;
+        }
+        const pos = projection.fromLatLngToDivPixel(
+          new mapsApi.LatLng(position.lat, position.lng)
+        );
+        if (!pos) {
+          el.style.visibility = "hidden";
+          return;
+        }
+        el.style.position = "absolute";
+        el.style.left = `${pos.x + (props.offset?.x ?? 0)}px`;
+        el.style.top = `${pos.y + (props.offset?.y ?? 0)}px`;
+        el.style.transform = ANCHOR_TRANSFORMS[props.anchor];
+        if (props.zIndex !== void 0)
+          el.style.zIndex = String(props.zIndex);
+        el.style.visibility = "visible";
+      }
+      onRemove() {
+        el.parentNode?.removeChild(el);
+      }
+    }
+    el.style.visibility = "hidden";
+    const ov = new CustomOverlay();
+    ov.setMap(map);
+    if (markerContext?.marker.value) {
+      listeners.push(
+        markerContext.marker.value.addListener("position_changed", () => ov.draw())
+      );
+    } else if (advancedMarkerElementContext?.advancedMarkerElement.value) {
+      const ame = advancedMarkerElementContext.advancedMarkerElement.value;
+      listeners.push(
+        ame.addListener("drag", () => ov.draw()),
+        ame.addListener("dragend", () => ov.draw())
+      );
+    }
+    return ov;
+  },
+  cleanup(ov) {
+    listeners.forEach((l) => l.remove());
+    listeners.length = 0;
+    ov.setMap(null);
+  }
+});
+if (advancedMarkerElementContext) {
+  watch(
+    () => {
+      const pos = advancedMarkerElementContext.advancedMarkerElement.value?.position;
+      if (!pos)
+        return void 0;
+      if ("lat" in pos && typeof pos.lat === "function")
+        return { lat: pos.lat(), lng: pos.lng() };
+      return pos;
+    },
+    () => {
+      overlay.value?.draw();
+    }
+  );
+}
+watch(
+  () => [props.position?.lat, props.position?.lng, props.offset?.x, props.offset?.y, props.zIndex, props.anchor],
+  () => {
+    overlay.value?.draw();
+  }
+);
+watch(() => open.value, () => {
+  if (!overlay.value)
+    return;
+  overlay.value.draw();
+});
+watch(() => props.pane, () => {
+  if (overlay.value) {
+    const map = overlay.value.getMap();
+    overlay.value.setMap(null);
+    if (map)
+      overlay.value.setMap(map);
+  }
+});
+watch(() => props.blockMapInteraction, () => {
+  if (overlay.value) {
+    const map = overlay.value.getMap();
+    overlay.value.setMap(null);
+    if (map)
+      overlay.value.setMap(map);
+  }
+});
+defineExpose({ overlay });
+</script>
+
+<template>
+  <div style="display: none;">
+    <div ref="overlay-content">
+      <slot />
+    </div>
+  </div>
+</template>

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsOverlayView.vue.d.ts

@@ -0,0 +1,40 @@
+type OverlayAnchor = 'center' | 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'left-center' | 'right-center';
+type OverlayPane = 'mapPane' | 'overlayLayer' | 'markerLayer' | 'overlayMouseTarget' | 'floatPane';
+type __VLS_Props = {
+    position?: google.maps.LatLngLiteral;
+    anchor?: OverlayAnchor;
+    offset?: {
+        x: number;
+        y: number;
+    };
+    pane?: OverlayPane;
+    zIndex?: number;
+    blockMapInteraction?: boolean;
+};
+type __VLS_ModelProps = {
+    'open'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    overlay: import("vue").ShallowRef<google.maps.OverlayView | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean | undefined) => any) | undefined;
+}>, {
+    anchor: OverlayAnchor;
+    pane: OverlayPane;
+    blockMapInteraction: boolean;
+}, {}, {}, {}, 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/GoogleMaps/ScriptGoogleMapsPolygon.vue

@@ -1,5 +1,6 @@
 <script setup>
 import { watch } from "vue";
+import { bindGoogleMapsEvents } from "./bindGoogleMapsEvents";
 import { useGoogleMapsResource } from "./useGoogleMapsResource";
 const props = defineProps({
   options: { type: Object, required: false }
@@ -23,7 +24,9 @@ const eventsWithMapMouseEventPayload = [
 const polygon = useGoogleMapsResource({
   create({ mapsApi, map }) {
     const p = new mapsApi.Polygon({ map, ...props.options });
-    setupEventListeners(p);
+    bindGoogleMapsEvents(p, emit, {
+      withPayload: [...eventsWithPolyMouseEventPayload, ...eventsWithMapMouseEventPayload]
+    });
     return p;
   },
   cleanup(p, { mapsApi }) {
@@ -36,14 +39,6 @@ watch(() => props.options, (options) => {
     polygon.value.setOptions(options);
   }
 }, { deep: true });
-function setupEventListeners(p) {
-  eventsWithPolyMouseEventPayload.forEach((event) => {
-    p.addListener(event, (payload) => emit(event, payload));
-  });
-  eventsWithMapMouseEventPayload.forEach((event) => {
-    p.addListener(event, (payload) => emit(event, payload));
-  });
-}
 </script>
 
 <template>

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsPolyline.vue

@@ -1,5 +1,6 @@
 <script setup>
 import { watch } from "vue";
+import { bindGoogleMapsEvents } from "./bindGoogleMapsEvents";
 import { useGoogleMapsResource } from "./useGoogleMapsResource";
 const props = defineProps({
   options: { type: Object, required: false }
@@ -23,7 +24,9 @@ const eventsWithMapMouseEventPayload = [
 const polyline = useGoogleMapsResource({
   create({ mapsApi, map }) {
     const p = new mapsApi.Polyline({ map, ...props.options });
-    setupEventListeners(p);
+    bindGoogleMapsEvents(p, emit, {
+      withPayload: [...eventsWithPolyMouseEventPayload, ...eventsWithMapMouseEventPayload]
+    });
     return p;
   },
   cleanup(p, { mapsApi }) {
@@ -36,14 +39,6 @@ watch(() => props.options, (options) => {
     polyline.value.setOptions(options);
   }
 }, { deep: true });
-function setupEventListeners(p) {
-  eventsWithPolyMouseEventPayload.forEach((event) => {
-    p.addListener(event, (payload) => emit(event, payload));
-  });
-  eventsWithMapMouseEventPayload.forEach((event) => {
-    p.addListener(event, (payload) => emit(event, payload));
-  });
-}
 </script>
 
 <template>

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsRectangle.vue

@@ -1,5 +1,6 @@
 <script setup>
 import { watch } from "vue";
+import { bindGoogleMapsEvents } from "./bindGoogleMapsEvents";
 import { useGoogleMapsResource } from "./useGoogleMapsResource";
 const props = defineProps({
   options: { type: Object, required: false }
@@ -24,7 +25,10 @@ const eventsWithMapMouseEventPayload = [
 const rectangle = useGoogleMapsResource({
   create({ mapsApi, map }) {
     const r = new mapsApi.Rectangle({ map, ...props.options });
-    setupEventListeners(r);
+    bindGoogleMapsEvents(r, emit, {
+      noPayload: eventsWithoutPayload,
+      withPayload: eventsWithMapMouseEventPayload
+    });
     return r;
   },
   cleanup(r, { mapsApi }) {
@@ -37,14 +41,6 @@ watch(() => props.options, (options) => {
     rectangle.value.setOptions(options);
   }
 }, { deep: true });
-function setupEventListeners(r) {
-  eventsWithoutPayload.forEach((event) => {
-    r.addListener(event, () => emit(event));
-  });
-  eventsWithMapMouseEventPayload.forEach((event) => {
-    r.addListener(event, (payload) => emit(event, payload));
-  });
-}
 </script>
 
 <template>

package/dist/runtime/components/GoogleMaps/bindGoogleMapsEvents.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Bind Google Maps event listeners that forward to Vue emit.
+ *
+ * Two categories:
+ * - `noPayload`: emits with no arguments (state-change events like `position_changed`)
+ * - `withPayload`: forwards the first argument from the listener (mouse events, etc.)
+ */
+export declare function bindGoogleMapsEvents(instance: {
+    addListener: (event: string, handler: (...args: any[]) => void) => void;
+}, emit: (...args: any[]) => void, config: {
+    noPayload?: readonly string[];
+    withPayload?: readonly string[];
+}): void;

package/dist/runtime/components/GoogleMaps/bindGoogleMapsEvents.js

@@ -0,0 +1,8 @@
+export function bindGoogleMapsEvents(instance, emit, config) {
+  config.noPayload?.forEach((event) => {
+    instance.addListener(event, () => emit(event));
+  });
+  config.withPayload?.forEach((event) => {
+    instance.addListener(event, (payload) => emit(event, payload));
+  });
+}

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

@@ -1,5 +1,6 @@
 import type { RegistryScriptInput } from '#nuxt-scripts/types';
 import { GravatarOptions } from './schemas.js';
+export { GravatarOptions } from './schemas.js';
 export type GravatarInput = RegistryScriptInput<typeof GravatarOptions>;
 export interface GravatarApi {
     /**

package/dist/runtime/registry/gravatar.js

@@ -1,5 +1,6 @@
 import { useRegistryScript } from "#nuxt-scripts/utils";
 import { GravatarOptions } from "./schemas.js";
+export { GravatarOptions } from "./schemas.js";
 export function useScriptGravatar(_options) {
   return useRegistryScript(_options?.key || "gravatar", (options) => {
     const size = options?.size ?? 80;

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

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

package/dist/runtime/server/gravatar-proxy.js

@@ -29,7 +29,6 @@ export default defineEventHandler(async (event) => {
     r: rating
   });
   const response = await $fetch.raw(gravatarUrl, {
-    responseType: "arrayBuffer",
     headers: {
       "User-Agent": "Nuxt Scripts Gravatar Proxy"
     }

package/dist/stats.d.mts

@@ -54,17 +54,49 @@ interface ScriptApis {
     performanceObserver: boolean;
     intersectionObserver: boolean;
 }
-interface ApiPrivacyScore {
+type PrivacyGrade = 'A+' | 'A' | 'B' | 'C' | 'D' | 'F';
+interface PrivacyRating {
+    /** Overall letter grade */
+    grade: PrivacyGrade;
     /** 0–100, higher = more invasive */
     score: number;
-    /** Persistence APIs used (cookies, localStorage, sessionStorage, indexedDB) */
-    persistence: number;
-    /** Fingerprinting APIs used (canvas, webgl, audioContext, deviceMemory, hardwareConcurrency, plugins, screen, userAgent, languages, timezone, platform, vendor, connection, maxTouchPoints, devicePixelRatio, mediaDevices, getBattery) */
-    fingerprinting: number;
-    /** Tracking APIs used (referrer, windowName, rtcPeerConnection, geolocation, serviceWorker, cacheApi) */
-    tracking: number;
-    /** Behavioral monitoring APIs used (mutationObserver, intersectionObserver) */
-    monitoring: number;
+    /** Breakdown by privacy concern category */
+    breakdown: {
+        /** Browser fingerprinting APIs — entropy-weighted per AmIUnique/Panopticlick research (0–30) */
+        fingerprinting: {
+            score: number;
+            apis: string[];
+        };
+        /** Persistent storage + cookie tracking (0–25) */
+        persistence: {
+            score: number;
+            thirdPartyCookies: number;
+            longLivedCookies: number;
+            storageApis: string[];
+        };
+        /** Cross-domain data exfiltration & tracking network (0–25) */
+        network: {
+            score: number;
+            domains: number;
+            outboundBytes: number;
+            trackingPixels: number;
+        };
+        /** Behavioral observation APIs (0–10) */
+        monitoring: {
+            score: number;
+            apis: string[];
+        };
+        /** Data collection scope — what types of data are tracked (0–10) */
+        dataScope: {
+            score: number;
+            types: string[];
+        };
+        /** Fingerprint exfiltration — heavy FP APIs combined with outbound channels (0–25) */
+        fpExfiltration: {
+            score: number;
+            heavyApis: string[];
+        };
+    };
 }
 interface ScriptCookie {
     name: string;
@@ -102,6 +134,44 @@ interface PerformanceSummary {
     scriptDurationMs: number;
     heapDeltaKb: number;
 }
+type PerformanceGrade = 'A+' | 'A' | 'B' | 'C' | 'D' | 'F';
+interface PerformanceRating {
+    /** Overall letter grade */
+    grade: PerformanceGrade;
+    /** 0–100, higher = worse performance impact */
+    score: number;
+    /** Breakdown by impact area */
+    breakdown: {
+        /** Network cost — transfer size relative to performance budgets (0–30) */
+        networkCost: {
+            score: number;
+            transferKb: number;
+        };
+        /** Main thread blocking — task duration that delays interactivity (0–30) */
+        mainThread: {
+            score: number;
+            taskDurationMs: number;
+            scriptDurationMs: number;
+        };
+        /** Memory pressure — heap allocation impact (0–20) */
+        memory: {
+            score: number;
+            heapDeltaKb: number;
+        };
+        /** Connection overhead — additional HTTP requests (0–10) */
+        connections: {
+            score: number;
+            requestCount: number;
+        };
+        /** CWV risk — estimated Core Web Vitals impact (0–10) */
+        cwvRisk: {
+            score: number;
+            lcpImpactMs: number;
+            clsRisk: boolean;
+            inpRiskLevel: string;
+        };
+    };
+}
 interface ScriptStats {
     id: string;
     label: string;
@@ -112,10 +182,11 @@ interface ScriptStats {
     trackedData: TrackedDataType[];
     collectsWebVitals: boolean;
     apis: ScriptApis;
-    apiPrivacyScore: ApiPrivacyScore;
+    privacyRating: PrivacyRating;
     cookies: ScriptCookie[];
     network: NetworkSummary;
     performance: PerformanceSummary;
+    performanceRating: PerformanceRating;
     cwvEstimate: CwvEstimate;
     hasBundling: boolean;
     hasProxy: boolean;
@@ -128,4 +199,4 @@ interface ScriptStats {
 declare function getScriptStats(): Promise<ScriptStats[]>;
 
 export { getScriptStats };
-export type { ApiPrivacyScore, CwvEstimate, NetworkSummary, PerformanceSummary, ScriptApis, ScriptCookie, ScriptPrivacy, ScriptSizeDetail, ScriptStats, TrackedDataType };
+export type { CwvEstimate, NetworkSummary, PerformanceGrade, PerformanceRating, PerformanceSummary, PrivacyGrade, PrivacyRating, ScriptApis, ScriptCookie, ScriptPrivacy, ScriptSizeDetail, ScriptStats, TrackedDataType };

package/dist/stats.d.ts

@@ -54,17 +54,49 @@ interface ScriptApis {
     performanceObserver: boolean;
     intersectionObserver: boolean;
 }
-interface ApiPrivacyScore {
+type PrivacyGrade = 'A+' | 'A' | 'B' | 'C' | 'D' | 'F';
+interface PrivacyRating {
+    /** Overall letter grade */
+    grade: PrivacyGrade;
     /** 0–100, higher = more invasive */
     score: number;
-    /** Persistence APIs used (cookies, localStorage, sessionStorage, indexedDB) */
-    persistence: number;
-    /** Fingerprinting APIs used (canvas, webgl, audioContext, deviceMemory, hardwareConcurrency, plugins, screen, userAgent, languages, timezone, platform, vendor, connection, maxTouchPoints, devicePixelRatio, mediaDevices, getBattery) */
-    fingerprinting: number;
-    /** Tracking APIs used (referrer, windowName, rtcPeerConnection, geolocation, serviceWorker, cacheApi) */
-    tracking: number;
-    /** Behavioral monitoring APIs used (mutationObserver, intersectionObserver) */
-    monitoring: number;
+    /** Breakdown by privacy concern category */
+    breakdown: {
+        /** Browser fingerprinting APIs — entropy-weighted per AmIUnique/Panopticlick research (0–30) */
+        fingerprinting: {
+            score: number;
+            apis: string[];
+        };
+        /** Persistent storage + cookie tracking (0–25) */
+        persistence: {
+            score: number;
+            thirdPartyCookies: number;
+            longLivedCookies: number;
+            storageApis: string[];
+        };
+        /** Cross-domain data exfiltration & tracking network (0–25) */
+        network: {
+            score: number;
+            domains: number;
+            outboundBytes: number;
+            trackingPixels: number;
+        };
+        /** Behavioral observation APIs (0–10) */
+        monitoring: {
+            score: number;
+            apis: string[];
+        };
+        /** Data collection scope — what types of data are tracked (0–10) */
+        dataScope: {
+            score: number;
+            types: string[];
+        };
+        /** Fingerprint exfiltration — heavy FP APIs combined with outbound channels (0–25) */
+        fpExfiltration: {
+            score: number;
+            heavyApis: string[];
+        };
+    };
 }
 interface ScriptCookie {
     name: string;
@@ -102,6 +134,44 @@ interface PerformanceSummary {
     scriptDurationMs: number;
     heapDeltaKb: number;
 }
+type PerformanceGrade = 'A+' | 'A' | 'B' | 'C' | 'D' | 'F';
+interface PerformanceRating {
+    /** Overall letter grade */
+    grade: PerformanceGrade;
+    /** 0–100, higher = worse performance impact */
+    score: number;
+    /** Breakdown by impact area */
+    breakdown: {
+        /** Network cost — transfer size relative to performance budgets (0–30) */
+        networkCost: {
+            score: number;
+            transferKb: number;
+        };
+        /** Main thread blocking — task duration that delays interactivity (0–30) */
+        mainThread: {
+            score: number;
+            taskDurationMs: number;
+            scriptDurationMs: number;
+        };
+        /** Memory pressure — heap allocation impact (0–20) */
+        memory: {
+            score: number;
+            heapDeltaKb: number;
+        };
+        /** Connection overhead — additional HTTP requests (0–10) */
+        connections: {
+            score: number;
+            requestCount: number;
+        };
+        /** CWV risk — estimated Core Web Vitals impact (0–10) */
+        cwvRisk: {
+            score: number;
+            lcpImpactMs: number;
+            clsRisk: boolean;
+            inpRiskLevel: string;
+        };
+    };
+}
 interface ScriptStats {
     id: string;
     label: string;
@@ -112,10 +182,11 @@ interface ScriptStats {
     trackedData: TrackedDataType[];
     collectsWebVitals: boolean;
     apis: ScriptApis;
-    apiPrivacyScore: ApiPrivacyScore;
+    privacyRating: PrivacyRating;
     cookies: ScriptCookie[];
     network: NetworkSummary;
     performance: PerformanceSummary;
+    performanceRating: PerformanceRating;
     cwvEstimate: CwvEstimate;
     hasBundling: boolean;
     hasProxy: boolean;
@@ -128,4 +199,4 @@ interface ScriptStats {
 declare function getScriptStats(): Promise<ScriptStats[]>;
 
 export { getScriptStats };
-export type { ApiPrivacyScore, CwvEstimate, NetworkSummary, PerformanceSummary, ScriptApis, ScriptCookie, ScriptPrivacy, ScriptSizeDetail, ScriptStats, TrackedDataType };
+export type { CwvEstimate, NetworkSummary, PerformanceGrade, PerformanceRating, PerformanceSummary, PrivacyGrade, PrivacyRating, ScriptApis, ScriptCookie, ScriptPrivacy, ScriptSizeDetail, ScriptStats, TrackedDataType };