@glomex/integration-analytics 1.1480.0 → 1.1481.0

package/dist/sensic/index.js

@@ -0,0 +1,103 @@
+import { IntegrationEvent } from '@glomex/integration-web-component';
+import { SensicEventMapper } from './sensic-event-mapper.js';
+import { buildDefaultCustomParams, buildDefaultStreamId, createAtCustomParamsBuilder, createAtStreamIdBuilder } from './sensic-metadata.js';
+import { buildSensicScriptUrl, initSensicS2S } from './sensic-sdk-loader.js';
+/** IAB TCF vendor ID for Sensic */
+const IAB_VENDOR_SENSIC = '758';
+/**
+ * Connects Sensic analytics integration to a turbo player integration.
+ *
+ * Sensic (formerly GfK) provides streaming measurement for video content.
+ * This integration automatically tracks playback events and reports them
+ * to Sensic's S2S (Server-to-Server) measurement system.
+ *
+ * @param integration - The integration element to connect to
+ * @param options - Sensic configuration options
+ * @returns A cleanup function to disconnect the integration
+ *
+ * @example
+ * ```ts
+ * import { connectToSensic } from '@glomex/integration-analytics/sensic';
+ *
+ * const disconnect = connectToSensic(integration, {
+ *   media: 'your-media-id',
+ *   platform: 'web',
+ *   country: 'de'
+ * });
+ *
+ * // Later, to disconnect:
+ * disconnect();
+ * ```
+ */
+export const connectToSensic = (integration, options) => {
+    const { media, platform, country, warnCallback } = options;
+    const scriptUrl = buildSensicScriptUrl(country, platform);
+    let initializationPromise;
+    let currentMapper;
+    const onWarn = (error) => {
+        if (warnCallback) {
+            warnCallback(error);
+        }
+        else {
+            setTimeout(() => {
+                // biome-ignore lint/suspicious/noConsole: Fallback error logging
+                console.error(error);
+            }, 0);
+        }
+    };
+    const initializeSensic = () => {
+        if (initializationPromise)
+            return initializationPromise;
+        initializationPromise = initSensicS2S({
+            media,
+            url: scriptUrl,
+            type: 'WEB'
+        }).catch((error) => {
+            onWarn(error instanceof Error ? error : new Error(String(error)));
+            return undefined;
+        });
+        return initializationPromise;
+    };
+    const hasConsent = () => {
+        const hasVendorConsent = Boolean(integration.consent?.vendorConsents?.[IAB_VENDOR_SENSIC]);
+        return hasVendorConsent;
+    };
+    const onContentSelect = () => {
+        if (currentMapper) {
+            currentMapper.destroy();
+            currentMapper = undefined;
+        }
+        if (!hasConsent())
+            return;
+        const customParamsBuilder = createCustomParamsBuilder();
+        if (customParamsBuilder() == null)
+            return;
+        // Start initialization if not already done, but don't await - events will be queued
+        const sdkReadyPromise = initializeSensic();
+        currentMapper = new SensicEventMapper(integration, sdkReadyPromise, onWarn, customParamsBuilder, createStreamIdBuilder());
+    };
+    function createCustomParamsBuilder() {
+        const internalBuilder = country.toLowerCase() === 'at'
+            ? createAtCustomParamsBuilder({ integration })
+            : buildDefaultCustomParams;
+        return () => {
+            const internalResult = internalBuilder();
+            return options.buildCustomParams ? options.buildCustomParams(internalResult) : internalResult;
+        };
+    }
+    function createStreamIdBuilder() {
+        const internalBuilder = country.toLowerCase() === 'at'
+            ? createAtStreamIdBuilder({ integration })
+            : () => buildDefaultStreamId(integration, integration.currentAd !== undefined);
+        return () => {
+            const internalResult = internalBuilder();
+            return options.buildStreamId ? options.buildStreamId(internalResult) : internalResult;
+        };
+    }
+    integration.addEventListener(IntegrationEvent.CONTENT_SELECT, onContentSelect);
+    return () => {
+        integration.removeEventListener(IntegrationEvent.CONTENT_SELECT, onContentSelect);
+        currentMapper?.destroy();
+        currentMapper = undefined;
+    };
+};

package/dist/sensic/sensic-event-mapper.d.ts

@@ -0,0 +1,25 @@
+import { type IntegrationElement } from '@glomex/integration-web-component';
+import { BaseEventMapper } from '../base-event-mapper.js';
+import type { SensicGlobal } from './sensic-types.js';
+export declare class SensicEventMapper extends BaseEventMapper {
+    #private;
+    constructor(integration: IntegrationElement, sdkReadyPromise: Promise<SensicGlobal | undefined>, onWarn: (error: Error) => void, buildCustomParams: () => Record<string, string> | null | undefined, buildStreamId?: () => string);
+    protected onContentStart(): void;
+    protected onContentImpression(): void;
+    protected onContentPlay(): void;
+    protected onContentPause(): void;
+    protected onContentSeeking(): void;
+    protected onContentSeeked(): void;
+    protected onContentBufferingStart(): void;
+    protected onContentBufferingEnd(): void;
+    protected onContentEnded(): void;
+    protected onAdImpression(): void;
+    protected onAdPaused(): void;
+    protected onAdResumed(): void;
+    protected onAdBufferingStart(): void;
+    protected onAdBufferingEnd(): void;
+    protected onAdEnd(): void;
+    protected onPresentationModeChange(): void;
+    protected onVolumeChange(): void;
+    protected onDestroy(): void;
+}

package/dist/sensic/sensic-event-mapper.js

@@ -0,0 +1,147 @@
+import { PlaybackMode, PresentationMode } from '@glomex/integration-web-component';
+import { BaseEventMapper } from '../base-event-mapper.js';
+export class SensicEventMapper extends BaseEventMapper {
+    #sensicSdk;
+    #buildCustomParams;
+    #buildStreamId;
+    #agent;
+    #isLive = false;
+    constructor(integration, sdkReadyPromise, onWarn, buildCustomParams, buildStreamId) {
+        super(integration, onWarn);
+        this.#buildCustomParams = buildCustomParams;
+        this.#buildStreamId = buildStreamId;
+        sdkReadyPromise.then((sensicSdk) => {
+            if (this.isStopped)
+                return;
+            if (!sensicSdk) {
+                this.onWarn(new Error('Sensic SDK not available after initialization'));
+                return;
+            }
+            this.#sensicSdk = sensicSdk;
+            this.markSdkReady();
+        });
+    }
+    onContentStart() {
+        if (!this.#sensicSdk)
+            return;
+        this.#isLive = this.integration.source?.playbackMode === PlaybackMode.LIVE;
+        // Create agent with position callback
+        this.#agent = this.#sensicSdk.getAgent(() => this.#isLive ? undefined : this.#currentTimeInMilliseconds);
+    }
+    onContentImpression() {
+        this.#triggerPlay(this.#currentTimeInMilliseconds);
+    }
+    onContentPlay() {
+        if (this.integration.seeking)
+            return;
+        this.#triggerPlay(this.#currentTimeInMilliseconds);
+    }
+    onContentPause() {
+        if (this.integration.seeking)
+            return;
+        this.#triggerStop(this.#currentTimeInMilliseconds);
+    }
+    onContentSeeking() {
+        if (!this.integration.paused) {
+            this.#triggerStop(this.#currentTimeInMilliseconds);
+        }
+    }
+    onContentSeeked() {
+        if (!this.integration.paused) {
+            this.#triggerPlay(this.#currentTimeInMilliseconds);
+        }
+    }
+    onContentBufferingStart() {
+        if (this.integration.seeking)
+            return;
+        this.#triggerStop(this.#currentTimeInMilliseconds);
+    }
+    onContentBufferingEnd() {
+        if (this.integration.seeking)
+            return;
+        this.#triggerPlay(this.#currentTimeInMilliseconds);
+    }
+    onContentEnded() {
+        this.#triggerStop(this.#currentTimeInMilliseconds);
+    }
+    onAdImpression() {
+        this.#triggerPlay(0);
+    }
+    onAdPaused() {
+        this.#triggerStop(this.#adCurrentTimeInMilliseconds);
+    }
+    onAdResumed() {
+        this.#triggerPlay(this.#adCurrentTimeInMilliseconds);
+    }
+    onAdBufferingStart() {
+        this.#triggerStop(this.#adCurrentTimeInMilliseconds);
+    }
+    onAdBufferingEnd() {
+        this.#triggerPlay(this.#adCurrentTimeInMilliseconds);
+    }
+    onAdEnd() {
+        this.#triggerStop(this.#adCurrentTimeInMilliseconds);
+    }
+    onPresentationModeChange() {
+        if (!this.#agent)
+            return;
+        this.#agent.screen(this.#isFullscreen ? '1' : '0');
+    }
+    onVolumeChange() {
+        if (!this.#agent)
+            return;
+        this.#agent.volume(this.#volume.toString());
+    }
+    #triggerPlay(position) {
+        if (!this.#agent)
+            return;
+        const customParams = this.#buildCustomParams() ?? {};
+        const contentId = 'default'; // Always 'default' as per integration guide
+        const isAd = this.isInAd;
+        const streamId = this.#buildStreamId
+            ? this.#buildStreamId()
+            : (() => {
+                const sourceOrContentId = this.integration.source?.id || this.integration.content?.id || '';
+                return isAd ? `${sourceOrContentId}-ad` : sourceOrContentId;
+            })();
+        const options = {
+            screen: this.#isFullscreen ? '1' : '0',
+            volume: this.#volume.toString()
+        };
+        if (this.#isLive && !isAd) {
+            const streamOffset = Math.round(Date.now() - position);
+            const contentStart = ''; // Always empty string
+            this.#agent.playStreamLive(contentId, contentStart, streamOffset, streamId, options, customParams);
+        }
+        else {
+            this.#agent.playStreamOnDemand(contentId, streamId, position, options, customParams);
+        }
+    }
+    #triggerStop(position) {
+        if (!this.#agent)
+            return;
+        this.#agent.stop(this.#isLive ? undefined : position);
+    }
+    get #currentTimeInMilliseconds() {
+        if (this.#isLive) {
+            return this.integration.wallClockTime * 1000;
+        }
+        return this.integration.currentTime * 1000;
+    }
+    get #adCurrentTimeInMilliseconds() {
+        const adTime = this.integration.adCurrentTime;
+        return (Number.isNaN(adTime) ? 0 : adTime) * 1000;
+    }
+    get #isFullscreen() {
+        return this.integration.presentationMode === PresentationMode.FULLSCREEN;
+    }
+    get #volume() {
+        return this.integration.muted ? 0 : Math.round(this.integration.volume * 100);
+    }
+    onDestroy() {
+        // Stop any ongoing playback tracking
+        if (this.#agent) {
+            this.#triggerStop(this.#currentTimeInMilliseconds);
+        }
+    }
+}

package/dist/sensic/sensic-metadata.d.ts

@@ -0,0 +1,34 @@
+import { type IntegrationElement } from '@glomex/integration-web-component';
+/**
+ * Build the default stream ID for Sensic tracking.
+ * Uses source ID if available, otherwise falls back to content ID.
+ *
+ * @param integration - The integration element containing source and content data
+ * @param isAd - Whether this is for an ad stream
+ * @returns The stream ID to use for tracking
+ */
+export declare function buildDefaultStreamId(integration: IntegrationElement, isAd: boolean): string;
+/**
+ * Build default custom parameters for Sensic tracking.
+ * Returns an empty object by default - consumers can provide their own buildCustomParams callback.
+ *
+ * @returns Empty custom parameters object
+ */
+export declare function buildDefaultCustomParams(): Record<string, string>;
+export interface SensicAtBuilderOptions {
+    integration: IntegrationElement;
+}
+/**
+ * Creates a custom params builder for Austria (GfK AT).
+ *
+ * @param options - The builder options containing integration and platform
+ * @returns A function that builds custom params for Sensic tracking, or undefined if tracking should be skipped
+ */
+export declare function createAtCustomParamsBuilder(options: SensicAtBuilderOptions): () => Record<string, string>;
+/**
+ * Creates a stream ID builder for Austria (GfK AT).
+ *
+ * @param options - The builder options containing integration
+ * @returns A function that builds the stream ID for Sensic tracking
+ */
+export declare function createAtStreamIdBuilder(options: SensicAtBuilderOptions): () => string;

package/dist/sensic/sensic-metadata.js

@@ -0,0 +1,102 @@
+import { PlaybackMode } from '@glomex/integration-web-component';
+/**
+ * Build the default stream ID for Sensic tracking.
+ * Uses source ID if available, otherwise falls back to content ID.
+ *
+ * @param integration - The integration element containing source and content data
+ * @param isAd - Whether this is for an ad stream
+ * @returns The stream ID to use for tracking
+ */
+export function buildDefaultStreamId(integration, isAd) {
+    const sourceId = integration.source?.id ?? '';
+    const contentId = integration.content?.id ?? '';
+    const baseId = sourceId || contentId;
+    return isAd ? `${baseId}-ad` : baseId;
+}
+/**
+ * Build default custom parameters for Sensic tracking.
+ * Returns an empty object by default - consumers can provide their own buildCustomParams callback.
+ *
+ * @returns Empty custom parameters object
+ */
+export function buildDefaultCustomParams() {
+    return {};
+}
+/**
+ * Creates a custom params builder for Austria (GfK AT).
+ *
+ * @param options - The builder options containing integration and platform
+ * @returns A function that builds custom params for Sensic tracking, or undefined if tracking should be skipped
+ */
+export function createAtCustomParamsBuilder(options) {
+    const { integration } = options;
+    return () => {
+        const content = integration.content;
+        const source = integration.source;
+        const isLive = source?.playbackMode === PlaybackMode.LIVE;
+        const channelName = content?.channel?.name || '';
+        const tvShowId = content?.show?.id ||
+            content?.competition?.id ||
+            content?.compilation?.id ||
+            content?.additionalIds?.originId ||
+            content?.id;
+        const programName = content?.show?.name ||
+            content?.competition?.name ||
+            content?.compilation?.name ||
+            content?.title;
+        const duration = Math.floor(content?.duration === undefined ? integration.duration : content.duration) || '-1';
+        const livestreamId = isLive ? content?.id : content?.liveOnDemandChannel?.id;
+        const mediaId = isLive ? content?.id : source?.id || content?.id;
+        const mediaTitle = content?.title;
+        const externalId = content?.additionalIds?.externalId;
+        const ad = integration.currentAd;
+        const isAd = ad !== undefined;
+        const adDuration = ad?.duration?.toString() || '-1';
+        // GfK AT specific custom parameters
+        return {
+            /** Each channel gets a playerid assigned by Sensic */
+            playerid: '',
+            /** Channel/brand title */
+            channel: channelName,
+            /** Device identifier (e.g., 'WEB') */
+            deviceid: 'WEB',
+            /** Type of clip: 'Live', 'Sendung', 'preroll', 'midroll', 'postroll' */
+            cliptype: isAd ? ad.breakName || '' : isLive ? 'Live' : 'Sendung',
+            /** Video identifier */
+            videoid: isLive ? `${livestreamId}-24x7` : mediaId || '',
+            /** Episode external identifier */
+            episodeid: isLive ? '' : externalId || '',
+            /** Player duration in milliseconds, '-1' for live */
+            playerduration: isAd ? adDuration : isLive ? '-1' : duration.toString(),
+            /** Video duration in seconds, '-1' for live */
+            videoduration: isAd ? adDuration : isLive ? '-1' : duration.toString(),
+            /** Episode duration in milliseconds, '-1' for live */
+            episodeduration: isAd ? adDuration : isLive ? '-1' : duration.toString(),
+            /** Video title (asset title + media title) */
+            videotitle: isLive ? '' : [programName, mediaTitle].filter(Boolean).join(' '),
+            /** Program/show name */
+            programname: isLive ? '' : programName || '',
+            /** TV show/asset identifier */
+            tvshowid: isLive ? '' : tvShowId || ''
+        };
+    };
+}
+/**
+ * Creates a stream ID builder for Austria (GfK AT).
+ *
+ * @param options - The builder options containing integration
+ * @returns A function that builds the stream ID for Sensic tracking
+ */
+export function createAtStreamIdBuilder(options) {
+    const { integration } = options;
+    return () => {
+        const ad = integration.currentAd;
+        if (ad) {
+            return `${ad.breakName || ''}${ad.breakIndex == null ? '' : ad.breakIndex}-${ad.positionIndex == null ? '' : ad.positionIndex}`;
+        }
+        const content = integration.content;
+        const source = integration.source;
+        const isLive = source?.playbackMode === PlaybackMode.LIVE;
+        return isLive ? content?.channel?.name || '' : content?.title || '';
+    };
+}

package/dist/sensic/sensic-sdk-loader.d.ts

@@ -0,0 +1,16 @@
+import type { SensicConfig, SensicGlobal } from './sensic-types.js';
+/**
+ * Builds the Sensic script URL based on country and platform.
+ * Script URLs:
+ * - AT Web: https://at-config.sensic.net/s2s-web.js
+ * - AT TV:  https://at-config.sensic.net/ctv/s2s-web.js
+ * - DE Web: https://de-config.sensic.net/s2s-web.js
+ * - DE TV:  https://de-config.sensic.net/ctv/s2s-web.js
+ */
+export declare function buildSensicScriptUrl(country: string, platform: 'web' | 'tv'): string;
+/**
+ * Initializes the Sensic S2S library.
+ * Loads the script and sets up the global gfkS2s object.
+ * This is the original implementation from Sensic with minimal TypeScript types.
+ */
+export declare function initSensicS2S(gfkS2sConf: SensicConfig): Promise<SensicGlobal>;

package/dist/sensic/sensic-sdk-loader.js

@@ -0,0 +1,102 @@
+/**
+ * Builds the Sensic script URL based on country and platform.
+ * Script URLs:
+ * - AT Web: https://at-config.sensic.net/s2s-web.js
+ * - AT TV:  https://at-config.sensic.net/ctv/s2s-web.js
+ * - DE Web: https://de-config.sensic.net/s2s-web.js
+ * - DE TV:  https://de-config.sensic.net/ctv/s2s-web.js
+ */
+export function buildSensicScriptUrl(country, platform) {
+    const path = platform === 'web' ? 's2s-web.js' : 'ctv/s2s-web.js';
+    return `https://${country}-config.sensic.net/${path}`;
+}
+/**
+ * Initializes the Sensic S2S library.
+ * Loads the script and sets up the global gfkS2s object.
+ * This is the original implementation from Sensic with minimal TypeScript types.
+ */
+export function initSensicS2S(gfkS2sConf) {
+    return ((w, d, c, s, id) => {
+        if (w[id]) {
+            return Promise.resolve(w[id]);
+        }
+        w.gfkS2sConf = c;
+        if (d.getElementById(id)) {
+            return Promise.resolve(w[id]);
+        }
+        w[id] = {};
+        w[id].agents = [];
+        const api = [
+            'playStreamLive',
+            'playLive',
+            'playStreamOnDemand',
+            'playVOD',
+            'stop',
+            'skip',
+            'screen',
+            'volume',
+            'impression'
+        ];
+        w.gfks = (() => {
+            function f(sA, e, cb) {
+                return (...args) => {
+                    sA.p = cb();
+                    sA.queue.push({ f: e, a: args });
+                };
+            }
+            function s(c, pId, cb) {
+                const sA = { queue: [], config: c, cb: cb, pId: pId };
+                for (let i = 0; i < api.length; i++) {
+                    const e = api[i];
+                    sA[e] = f(sA, e, cb);
+                }
+                return sA;
+            }
+            return s;
+        })();
+        w[id].getAgent = (cb, pId) => {
+            // Use 'new' to call gfks as a constructor - the Sensic script replaces gfks
+            // with a constructor function that expects to be called with 'new'
+            const GfksConstructor = w.gfks;
+            const innerAgent = new GfksConstructor(c, pId || '', cb || (() => 0));
+            // Use Proxy to pass through all method calls to the inner agent
+            // This ensures that when gfks is replaced by the real Sensic implementation,
+            // all methods (including setStreamPositionCallback) are accessible
+            const agentProxy = new Proxy({ a: innerAgent }, {
+                get(target, prop) {
+                    if (prop === 'a')
+                        return target.a;
+                    // Pass through all other property access to the inner agent
+                    const value = target.a[prop];
+                    if (typeof value === 'function') {
+                        return (...args) => value.apply(target.a, args);
+                    }
+                    return value;
+                }
+            });
+            w[id].agents.push(agentProxy);
+            return agentProxy;
+        };
+        const lJS = (eId, url) => new Promise((resolve, reject) => {
+            const existingTag = d.querySelector(`script[src="${url}"]`);
+            let tag = existingTag;
+            if (!existingTag) {
+                tag = d.createElement(s);
+                tag.async = true;
+                tag.type = 'text/javascript';
+                tag.src = url;
+                tag.id = eId;
+            }
+            const el = d.getElementsByTagName(s)[0];
+            if (tag) {
+                tag.onload = () => resolve(w[id]);
+                tag.onerror = () => reject(new Error('Failed to load Sensic S2S script'));
+                tag.onabort = () => reject(new Error('Sensic S2S script load aborted'));
+            }
+            if (!existingTag && tag && el?.parentNode) {
+                el.parentNode.insertBefore(tag, el);
+            }
+        });
+        return lJS(id, c.url);
+    })(window, document, gfkS2sConf, 'script', 'gfkS2s');
+}

package/dist/sensic/sensic-types.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Sensic S2S (Server-to-Server) TypeScript Definitions
+ * Types for the GfK Sensic streaming measurement SDK
+ * @see https://at-config.sensic.net/s2s-web.js
+ */
+/**
+ * Options passed to play methods for screen and volume state
+ */
+export interface SensicOptions {
+    /** Fullscreen state: '1' for fullscreen, '0' for not fullscreen */
+    screen: string;
+    /** Volume level as string (0-100) */
+    volume: string;
+}
+/**
+ * Custom parameters sent with each play event.
+ * The specific keys and values depend on the integration.
+ */
+export type SensicCustomParams = Record<string, string>;
+/**
+ * Sensic streaming agent instance for tracking playback
+ */
+export interface SensicAgent {
+    /**
+     * Update the volume state
+     * @param volume - Volume level as string (0-100)
+     */
+    volume: (volume: string) => void;
+    /**
+     * Update the fullscreen state
+     * @param isFullscreen - '1' for fullscreen, '0' for not fullscreen
+     */
+    screen: (isFullscreen: string) => void;
+    /**
+     * Start tracking a live stream
+     * @param contentId - Content identifier (usually 'default')
+     * @param contentStart - Content start time (usually empty string)
+     * @param streamOffset - Offset from live edge in milliseconds
+     * @param streamId - Stream/content title
+     * @param options - Screen and volume options
+     * @param customParams - Custom tracking parameters
+     */
+    playStreamLive: (contentId: string, contentStart: string, streamOffset: number, streamId: string, options: SensicOptions, customParams: Record<string, string>) => void;
+    /**
+     * Start tracking an on-demand stream
+     * @param contentId - Content identifier (usually 'default')
+     * @param streamId - Stream/content title
+     * @param position - Current playback position in milliseconds
+     * @param options - Screen and volume options
+     * @param customParams - Custom tracking parameters
+     */
+    playStreamOnDemand: (contentId: string, streamId: string, position: number, options: SensicOptions, customParams: Record<string, string>) => void;
+    /**
+     * Stop tracking playback
+     * @param position - Current playback position in milliseconds (undefined for live)
+     */
+    stop: (position?: number) => void;
+}
+/**
+ * Configuration for initializing the Sensic SDK
+ */
+export interface SensicConfig {
+    /** Media identifier provided by Sensic */
+    media: string;
+    /** URL to the Sensic S2S script */
+    url: string;
+    /** Device type (e.g., 'WEB') */
+    type: string;
+}
+/**
+ * Global Sensic SDK interface
+ */
+export interface SensicGlobal {
+    /**
+     * Get a streaming agent for tracking playback
+     * @param agentArg - Callback that returns current position (undefined for live)
+     * @returns A SensicAgent instance for tracking
+     */
+    getAgent: (agentArg: () => number | undefined) => SensicAgent;
+}

package/dist/sensic/sensic-types.js

@@ -0,0 +1,6 @@
+/**
+ * Sensic S2S (Server-to-Server) TypeScript Definitions
+ * Types for the GfK Sensic streaming measurement SDK
+ * @see https://at-config.sensic.net/s2s-web.js
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glomex/integration-analytics",
-  "version": "1.1480.0",
+  "version": "1.1481.0",
   "description": "Analytics integrations for the turbo player",
   "documentation": "https://docs.glomex.com",
   "homepage": "https://glomex.com",
@@ -25,6 +25,18 @@
     "./npaw": {
       "types": "./dist/npaw/index.d.ts",
       "import": "./dist/npaw/index.js"
+    },
+    "./comscore": {
+      "types": "./dist/comscore/index.d.ts",
+      "import": "./dist/comscore/index.js"
+    },
+    "./sensic": {
+      "types": "./dist/sensic/index.d.ts",
+      "import": "./dist/sensic/index.js"
+    },
+    "./nielsen": {
+      "types": "./dist/nielsen/index.d.ts",
+      "import": "./dist/nielsen/index.js"
     }
   },
   "files": [
@@ -34,23 +46,22 @@
   ],
   "scripts": {
     "prepack": "npm run build",
-    "build": "rm -rf dist && npm run build:ts --force && npm run build:tsup",
-    "build:ts": "tsc --build",
-    "build:tsup": "tsup",
+    "build": "rm -rf dist && tsc --build --force",
     "lint": "tsc --noEmit && biome ci",
-    "watch": "npm run build:ts --force && tsup --watch"
+    "watch": "tsc --build --watch"
   },
   "dependencies": {
-    "@glomex/integration-web-component": "workspace:*",
+    "@comscore/analytics": "^7.13.2",
+    "@glomex/integration-web-component": "1.1481.0",
     "npaw-plugin": "^7.3.18"
   },
   "devDependencies": {
     "@biomejs/biome": "catalog:",
-    "tsup": "catalog:",
     "typescript": "catalog:"
   },
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT"
+  "license": "MIT",
+  "gitHead": "a25482ec869f700c6735db24bda8c69eb3ba7c88"
 }