@streamlayer/feature-advertisement 1.1.0 → 1.1.1-rc.1343

package/lib/classic/units/ssai-preload.js

@@ -0,0 +1,68 @@
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { createLogger } from '@streamlayer/sdk-web-logger/classic';
+
+const log = createLogger('ssai:preload');
+/**
+ * How long the overlay is willing to wait for artwork. A slow or dead image host
+ * must never hold the bar back — the ad is already playing, and a bar that shows
+ * late is worse than one that shows without its logo (the logo is hidden on error
+ * anyway). Warming the browser cache is the goal; blocking is not.
+ */
+const DEFAULT_PRELOAD_TIMEOUT_MS = 2000;
+/**
+ * Fetch images into the browser cache and resolve once they are all settled, or
+ * once `timeoutMs` elapses — whichever comes first. Never rejects: a creative
+ * whose artwork fails is still a creative worth showing.
+ */
+const preloadImages = (urls, timeoutMs = DEFAULT_PRELOAD_TIMEOUT_MS) => {
+  const targets = urls.filter(url => !!url);
+  // `Image` is absent in SSR/worker contexts; there is nothing to warm there.
+  if (targets.length === 0 || typeof Image === 'undefined') {
+    return Promise.resolve();
+  }
+  return new Promise(resolve => {
+    let settled = false;
+    let remaining = targets.length;
+    const finish = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      log.debug({
+        remaining
+      }, 'ssai preload timed out, showing anyway');
+      finish();
+    }, timeoutMs);
+    const one = () => {
+      remaining -= 1;
+      if (remaining <= 0) {
+        finish();
+      }
+    };
+    for (const url of targets) {
+      const image = new Image();
+      image.onload = one;
+      image.onerror = one;
+      image.src = url;
+    }
+  });
+};
+/**
+ * Warm every image the creative carries — the overlay's brand logo, and the
+ * companion banner for hosts that render one — so the bar fades in complete
+ * rather than popping its artwork in a beat later.
+ */
+const preloadCreativeAssets = (creative, timeoutMs) => {
+  var _creative$companion;
+  return preloadImages([creative.iconUrl, (_creative$companion = creative.companion) === null || _creative$companion === void 0 ? void 0 : _creative$companion.staticResource], timeoutMs);
+};
+
+export { DEFAULT_PRELOAD_TIMEOUT_MS, preloadCreativeAssets, preloadImages };

package/lib/classic/units/ssai-providers.js

@@ -0,0 +1,289 @@
+import { asyncToGenerator as _asyncToGenerator, objectSpread2 as _objectSpread2 } from '../_virtual/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.error.cause.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.iterator.find.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/web.dom-exception.stack.js';
+import { createLogger } from '@streamlayer/sdk-web-logger/classic';
+import { VASTClient } from '@dailymotion/vast-client';
+
+const log = createLogger('ssai:provider');
+const DEFAULT_CREATIVE_API_BASE = 'https://hls.next.streamlayer.io/api/creatives/';
+/**
+ * Shared low-level beacon helper. Prefers `navigator.sendBeacon` and falls back
+ * to a no-cors `fetch`. Used by the default impression path and available to
+ * providers that fire URL-based tracking pixels.
+ */
+const fireBeacon = url => {
+  try {
+    if (typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function') {
+      navigator.sendBeacon(url);
+    } else {
+      void fetch(url, {
+        mode: 'no-cors'
+      }).catch(error => {
+        log.warn(error, 'ssai beacon failed');
+      });
+    }
+  } catch (error) {
+    log.warn(error, 'ssai beacon failed');
+  }
+};
+const resolveAdvertiser = (advertiser, title) => {
+  if (advertiser) {
+    return advertiser;
+  }
+  if (title) {
+    return title;
+  }
+  return 'Ad';
+};
+const buildCreativeUrl = (base, creativeId) => {
+  const normalizedBase = base.endsWith('/') ? base : `${base}/`;
+  return `${normalizedBase}${encodeURIComponent(creativeId)}`;
+};
+const mapApiResponse = raw => {
+  const trackingEvents = Array.isArray(raw.trackingEvents) ? raw.trackingEvents.filter(entry => Boolean((entry === null || entry === void 0 ? void 0 : entry.event) && (entry === null || entry === void 0 ? void 0 : entry.url))).map(entry => ({
+    event: entry.event,
+    url: entry.url
+  })) : [];
+  const rawCompanion = Array.isArray(raw.companions) ? raw.companions.find(entry => !!(entry !== null && entry !== void 0 && entry.staticResource)) : undefined;
+  const companion = rawCompanion !== null && rawCompanion !== void 0 && rawCompanion.staticResource ? {
+    staticResource: rawCompanion.staticResource,
+    width: Number(rawCompanion.width) || 0,
+    height: Number(rawCompanion.height) || 0,
+    clickThrough: rawCompanion.clickThrough,
+    clickTracking: Array.isArray(rawCompanion.clickTracking) ? rawCompanion.clickTracking.filter(url => typeof url === 'string' && !!url) : []
+  } : undefined;
+  return {
+    creativeId: raw.creativeId,
+    advertiser: resolveAdvertiser(raw.advertiser, raw.title),
+    title: raw.title || resolveAdvertiser(raw.advertiser, raw.title),
+    iconUrl: raw.iconUrl || undefined,
+    clickThroughUrl: raw.clickThroughUrl || undefined,
+    trackingEvents,
+    companion
+  };
+};
+/**
+ * Fire every tracking event with the given name, and report how many went out.
+ *
+ * ALL matches, not the first: the creative contract states that a creative may
+ * repeat an `event` value to carry several URLs, and that consumers must not
+ * assume uniqueness. Today's payloads carry one URL per event, so this is not a
+ * change in what goes on the wire — it just stops being wrong the day a server
+ * sends two.
+ */
+const fireTrackingEvents = (creative, event) => {
+  const matches = creative.trackingEvents.filter(entry => entry.event === event);
+  for (const match of matches) {
+    fireBeacon(match.url);
+  }
+  return matches.length;
+};
+/**
+ * Shared default impression behavior: fire the `impression` tracking events.
+ * Used by the StreamLayer provider and as the fallback in
+ * {@link SsaiCreativeCache} when a provider doesn't override `fireImpression`.
+ * Exported so both call sites share one definition.
+ */
+const fireDefaultImpression = creative => {
+  fireTrackingEvents(creative, 'impression');
+};
+/**
+ * StreamLayer's internal creative provider. Resolves creatives from the JSON
+ * creative API (`GET {creativeApiBase}{encodeURIComponent(creativeId)}`) and
+ * fires impressions from the `'impression'` tracking event via `sendBeacon`.
+ */
+const createStreamLayerProvider = (config = {}) => {
+  var _config$creativeApiBa;
+  const creativeApiBase = (_config$creativeApiBa = config.creativeApiBase) !== null && _config$creativeApiBa !== void 0 ? _config$creativeApiBa : DEFAULT_CREATIVE_API_BASE;
+  return {
+    id: 'streamlayer',
+    resolve: function () {
+      var _ref = _asyncToGenerator(function* (creativeId, signal) {
+        const url = buildCreativeUrl(creativeApiBase, creativeId);
+        const response = yield fetch(url, {
+          signal
+        });
+        if (!response.ok) {
+          throw new Error(`creative request failed: ${response.status}`);
+        }
+        const raw = yield response.json();
+        return mapApiResponse(_objectSpread2(_objectSpread2({}, raw), {}, {
+          creativeId: raw.creativeId || creativeId
+        }));
+      });
+      return function resolve(_x, _x2) {
+        return _ref.apply(this, arguments);
+      };
+    }(),
+    fireImpression: fireDefaultImpression
+  };
+};
+const buildQuortexUrl = (base, tenantName, adId) => {
+  // Deliberately string concatenation rather than `URL`/`URLSearchParams`: this
+  // package ships to 2016-era TV engines (see the chrome-32 classic build).
+  const separator = base.indexOf('?') === -1 ? '?' : '&';
+  const tenant = tenantName ? `TenantName=${encodeURIComponent(tenantName)}&` : '';
+  return `${base}${separator}${tenant}adID=${encodeURIComponent(adId)}&info=1`;
+};
+/**
+ * Quortex / Synamedia DAI ad metadata provider.
+ *
+ * `GET {adApiBase}?TenantName={tenantName}&adID={adId}&info=1` (the `TenantName`
+ * part omitted when `adApiBase` already carries it) — the ad id comes
+ * from the manifest's `X-AD-ID` DATERANGE attribute (see `ssai-detector.ts`, which
+ * reconstructs the ad window from the tracking-marker burst those tags form).
+ *
+ * The response is byte-compatible with the StreamLayer creative API, so the same
+ * `mapApiResponse` normalizes both.
+ *
+ * Known limitation: impressions fire the `impression` tracking event from the API
+ * response, not the per-session beacon the manifest carries in `X-AD-URL`. The two
+ * differ in `trackingid`/`USERID`, so Quortex-side attribution will see the
+ * generic id rather than the viewer's session until the manifest beacons are
+ * plumbed through to the provider.
+ */
+const createQuortexProvider = (config = {}) => {
+  const {
+    adApiBase,
+    tenantName
+  } = config;
+  if (!adApiBase) {
+    // Loud, but not thrown: this runs inside the host's render effect via
+    // `startSsaiMonitoring`, and taking the app down over a config typo is worse
+    // than an overlay that never appears and says why.
+    log.error({
+      adApiBase,
+      tenantName
+    }, 'quortex provider requires `adApiBase`');
+  }
+  return {
+    id: 'quortex',
+    resolve: function () {
+      var _ref2 = _asyncToGenerator(function* (adId, signal) {
+        if (!adApiBase) {
+          throw new Error('quortex provider is missing `adApiBase`');
+        }
+        const response = yield fetch(buildQuortexUrl(adApiBase, tenantName, adId), {
+          signal
+        });
+        if (!response.ok) {
+          throw new Error(`quortex creative request failed: ${response.status}`);
+        }
+        const raw = yield response.json();
+        return mapApiResponse(_objectSpread2(_objectSpread2({}, raw), {}, {
+          creativeId: raw.creativeId || adId
+        }));
+      });
+      return function resolve(_x3, _x4) {
+        return _ref2.apply(this, arguments);
+      };
+    }(),
+    fireImpression: fireDefaultImpression
+  };
+};
+// --- VAST provider ---------------------------------------------------------
+const mapVastResponse = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator(function* (creativeId, signal) {
+    var _validAd$advertiser$f;
+    const vastClient = new VASTClient();
+    const parsedVAST = yield vastClient.get(creativeId, {
+      timeout: 8000
+    });
+    if (signal.aborted) {
+      throw new DOMException('aborted', 'AbortError');
+    }
+    const validAd = parsedVAST.ads.find(ad => ad.creatives.length > 0);
+    if (!validAd) {
+      throw new Error('no_valid_ad');
+    }
+    const advertiserValue = Array.isArray(validAd.advertiser) ? (_validAd$advertiser$f = validAd.advertiser.find(entry => !!(entry !== null && entry !== void 0 && entry.value))) === null || _validAd$advertiser$f === void 0 ? void 0 : _validAd$advertiser$f.value : undefined;
+    const advertiser = resolveAdvertiser(advertiserValue, validAd.title || undefined);
+    let iconUrl;
+    let clickThroughUrl;
+    let companion;
+    for (const creative of validAd.creatives) {
+      if (creative.type === 'linear') {
+        var _linear$icons, _linear$videoClickThr;
+        const linear = creative;
+        iconUrl = iconUrl || ((_linear$icons = linear.icons) === null || _linear$icons === void 0 || (_linear$icons = _linear$icons.find(icon => !!(icon !== null && icon !== void 0 && icon.staticResource))) === null || _linear$icons === void 0 ? void 0 : _linear$icons.staticResource) || undefined;
+        clickThroughUrl = clickThroughUrl || ((_linear$videoClickThr = linear.videoClickThroughURLTemplate) === null || _linear$videoClickThr === void 0 ? void 0 : _linear$videoClickThr.url);
+      }
+      if (creative.type === 'companion') {
+        var _creative$variations, _variation$staticReso;
+        const variation = (_creative$variations = creative.variations) === null || _creative$variations === void 0 ? void 0 : _creative$variations[0];
+        const staticResource = variation === null || variation === void 0 || (_variation$staticReso = variation.staticResources) === null || _variation$staticReso === void 0 || (_variation$staticReso = _variation$staticReso[0]) === null || _variation$staticReso === void 0 ? void 0 : _variation$staticReso.url;
+        if (staticResource && !companion) {
+          var _variation$companionC, _variation$companionC2;
+          companion = {
+            staticResource,
+            width: Number(variation === null || variation === void 0 ? void 0 : variation.width) || 0,
+            height: Number(variation === null || variation === void 0 ? void 0 : variation.height) || 0,
+            clickThrough: variation === null || variation === void 0 || (_variation$companionC = variation.companionClickThroughURLTemplate) === null || _variation$companionC === void 0 ? void 0 : _variation$companionC.url,
+            clickTracking: ((_variation$companionC2 = variation === null || variation === void 0 ? void 0 : variation.companionClickTrackingURLTemplates) !== null && _variation$companionC2 !== void 0 ? _variation$companionC2 : []).map(entry => entry === null || entry === void 0 ? void 0 : entry.url).filter(url => !!url)
+          };
+        }
+      }
+    }
+    return {
+      creativeId,
+      advertiser,
+      title: validAd.title || advertiser,
+      iconUrl,
+      clickThroughUrl,
+      trackingEvents: [],
+      companion
+    };
+  });
+  return function mapVastResponse(_x5, _x6) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+/**
+ * Maps a VAST tag into the normalized SsaiCreative shape.
+ *
+ * Note: `fireImpression` is intentionally left to the shared default for now.
+ * Proper VAST impression/tracking wiring through `VASTTracker` is a documented
+ * follow-up; it requires retaining the parsed ad/tracker per creative.
+ */
+const createVastProvider = (_config = {}) => {
+  return {
+    id: 'vast',
+    resolve: mapVastResponse
+  };
+};
+/** Built-in provider factories keyed by name. */
+const BUILTIN_PROVIDERS = {
+  streamlayer: config => createStreamLayerProvider(config),
+  quortex: config => createQuortexProvider(config),
+  vast: () => createVastProvider()
+};
+const isProviderInstance = option => {
+  return typeof option === 'object' && typeof option.resolve === 'function';
+};
+/**
+ * Resolve a {@link SsaiProviderOption} into a concrete {@link SsaiCreativeProvider}.
+ * Defaults to the StreamLayer provider (using `fallbackConfig`) when no option is
+ * supplied.
+ */
+const resolveProvider = (option, fallbackConfig) => {
+  var _option$config;
+  if (!option) {
+    return createStreamLayerProvider(fallbackConfig);
+  }
+  if (typeof option === 'string') {
+    return BUILTIN_PROVIDERS[option](fallbackConfig);
+  }
+  if (isProviderInstance(option)) {
+    return option;
+  }
+  return BUILTIN_PROVIDERS[option.name]((_option$config = option.config) !== null && _option$config !== void 0 ? _option$config : fallbackConfig);
+};
+
+export { BUILTIN_PROVIDERS, DEFAULT_CREATIVE_API_BASE, createQuortexProvider, createStreamLayerProvider, createVastProvider, fireBeacon, fireDefaultImpression, fireTrackingEvents, resolveProvider };

package/lib/classic/units/vast-tracker.js

@@ -0,0 +1,77 @@
+import { VASTTracker } from '@dailymotion/vast-client';
+
+/**
+ * One place that constructs a `VASTTracker`.
+ *
+ * Every StreamLayer surface that reports VAST beacons — the GAM video player, both pause-ad
+ * renderers and the Standard Ad sidebar — needs the same `(ad, creative, variation)` triple, and
+ * each was assembling it by hand behind its own `@ts-ignore`. The parsed shapes those triples
+ * come from (`AdData` / `AdCompanion` / `AdNonLinear`) are defined in this package, so the
+ * mapping belongs here too.
+ *
+ * Deliberately *only* construction: when a beacon may fire, and how a surface de-duplicates its
+ * impression, stays with that surface. Those policies differ on purpose (per-ad-id in module
+ * scope for the sidebar, per component instance for the pause ads, per tracker identity for the
+ * player) and they are billing-visible, so collapsing them here would silently change counts.
+ */
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="../module.d.ts" />
+const createVastTracker = ({
+  ad,
+  creative,
+  variation
+}) =>
+// The first argument is the `VASTClient` the tracker may update; every surface here drives
+// playback itself and only wants the beacons, so it is always `null`.
+//
+// The type shim declares the 3rd argument as `VastCreativeLinear` and the 4th as another
+// *creative*. At runtime `vast-client` accepts any creative in the 3rd and expects the
+// `<Companion>` / `<NonLinear>` *variation* in the 4th. The casts encode that runtime contract
+// once here rather than at every call site.
+new VASTTracker(null, ad, creative, variation);
+/**
+ * A tracker for a single `<Companion>`. A `<CompanionAds>` creative has no creative-level
+ * `<TrackingEvents>` — each variation owns its own `creativeView` — so a companion is reported
+ * through its own tracker. `undefined` when the companion was parsed without them (nothing to
+ * report against).
+ */
+const createCompanionTracker = (ad, companion) => companion.creative && companion.variation ? createVastTracker({
+  ad,
+  creative: companion.creative,
+  variation: companion.variation
+}) : undefined;
+/**
+ * The creative a parsed ad reports its impression / playback beacons through, in the order the
+ * shells draw them: the `<Linear>` creative first, then the `<NonLinear>` still, then — for a tag
+ * whose only creative is `<CompanionAds>` — the companion that was actually drawn.
+ *
+ * `drawnCompanion` is a parameter rather than `adData.companion` because only the rendering shell
+ * knows which companion reached the screen, and reporting one that did not is a false view.
+ */
+const resolveVastTrackerTarget = (adData, drawnCompanion) => {
+  // `AdData.creative` is not optional in the type but `getCreative` can return nothing: a
+  // programmatic tag does not have to carry a `<Linear>` creative.
+  if (adData.creative) {
+    return {
+      ad: adData.ad,
+      creative: adData.creative
+    };
+  }
+  if (adData.nonLinear) {
+    return {
+      ad: adData.ad,
+      creative: adData.nonLinear.creative,
+      variation: adData.nonLinear.variation
+    };
+  }
+  if (drawnCompanion !== null && drawnCompanion !== void 0 && drawnCompanion.creative && drawnCompanion.variation) {
+    return {
+      ad: adData.ad,
+      creative: drawnCompanion.creative,
+      variation: drawnCompanion.variation
+    };
+  }
+  return undefined;
+};
+
+export { createCompanionTracker, createVastTracker, resolveVastTrackerTarget };

package/lib/index.d.ts

@@ -1,19 +1,19 @@
 import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
 declare module '@streamlayer/sdk-web-interfaces' {
     interface StreamLayerSDK {
-        advertisement: import('./advertisement').Advertisement;
+        advertisement: import('./advertisement.js').Advertisement;
     }
 }
-export { type ExternalAdStore, type ExternalPauseAdStore, type SsaiMonitorOptions } from './advertisement';
-export { type GAMStaticCore, type PauseAdTemplate, isFullbleedVideoTemplate } from './units/external-pause-ad';
-export { INSIGHT_BODY_MAX_LENGTH, type PauseAdCard, type PauseAdKind, type PauseAdMediaMode, } from './units/pause-ad-card';
-export { type PauseAdStore } from './units/pause-ad';
-export { type AdStore, type AdData, type AdCompanion, type AdNonLinear } from './units/external-ad';
-export { gam, type GamNonceResult, type PalNonceManager } from './units/gam';
-export { createCompanionTracker, createVastTracker, resolveVastTrackerTarget, type VastTrackerTarget, } from './units/vast-tracker';
-export { type SsaiCreative, type SsaiTrackingEvent, type SsaiCompanion, type SsaiProgressEvent, DEFAULT_CREATIVE_API_BASE, } from './units/ssai-creative';
-export { type SsaiCreativeProvider, type SsaiProviderOption, type SsaiProviderName, type SsaiProviderConfig, type StreamLayerProviderConfig, type QuortexProviderConfig, createStreamLayerProvider, createQuortexProvider, createVastProvider, resolveProvider, fireBeacon, fireTrackingEvents, BUILTIN_PROVIDERS, } from './units/ssai-providers';
-export { type SsaiDateRange, type SsaiTrackingMarker, type HlsLike, type SsaiClockSource, type SsaiDebugEvent, type SsaiDebugRange, type SsaiDebugSnapshot, } from './units/ssai-detector';
-export { preloadImages, preloadCreativeAssets, DEFAULT_PRELOAD_TIMEOUT_MS } from './units/ssai-preload';
-export { type SsaiAdBreakState, type SsaiAdBreakStatus, type SsaiAdBreakStore } from './units/ssai-ad-break';
+export { type ExternalAdStore, type ExternalPauseAdStore, type SsaiMonitorOptions } from './advertisement.js';
+export { type GAMStaticCore, type PauseAdTemplate, isFullbleedVideoTemplate } from './units/external-pause-ad.js';
+export { INSIGHT_BODY_MAX_LENGTH, type PauseAdCard, type PauseAdKind, type PauseAdMediaMode, } from './units/pause-ad-card.js';
+export { type PauseAdStore } from './units/pause-ad.js';
+export { type AdStore, type AdData, type AdCompanion, type AdNonLinear } from './units/external-ad.js';
+export { gam, type GamNonceResult, type PalNonceManager } from './units/gam.js';
+export { createCompanionTracker, createVastTracker, resolveVastTrackerTarget, type VastTrackerTarget, } from './units/vast-tracker.js';
+export { type SsaiCreative, type SsaiTrackingEvent, type SsaiCompanion, type SsaiProgressEvent, DEFAULT_CREATIVE_API_BASE, } from './units/ssai-creative.js';
+export { type SsaiCreativeProvider, type SsaiProviderOption, type SsaiProviderName, type SsaiProviderConfig, type StreamLayerProviderConfig, type QuortexProviderConfig, createStreamLayerProvider, createQuortexProvider, createVastProvider, resolveProvider, fireBeacon, fireTrackingEvents, BUILTIN_PROVIDERS, } from './units/ssai-providers.js';
+export { type SsaiDateRange, type SsaiTrackingMarker, type HlsLike, type SsaiClockSource, type SsaiDebugEvent, type SsaiDebugRange, type SsaiDebugSnapshot, } from './units/ssai-detector.js';
+export { preloadImages, preloadCreativeAssets, DEFAULT_PRELOAD_TIMEOUT_MS } from './units/ssai-preload.js';
+export { type SsaiAdBreakState, type SsaiAdBreakStatus, type SsaiAdBreakStore } from './units/ssai-ad-break.js';
 export declare const advertisement: (instance: StreamLayerContext, _opts: unknown, done: () => void) => void;

package/lib/index.js

@@ -1,16 +1,16 @@
-import { Advertisement } from './advertisement';
-export { isFullbleedVideoTemplate } from './units/external-pause-ad';
+import { Advertisement } from './advertisement.js';
+export { isFullbleedVideoTemplate } from './units/external-pause-ad.js';
 // Card shapes come straight from the pure module rather than through `units/pause-ad`. NOT a bundle
 // guarantee for barrel consumers — this file value-imports `Advertisement` on line 3, which imports
 // the store module anyway, and the package declares no `sideEffects: false`. What it does buy: the
 // unit spec and any deep importer get the card shapes without the store, and dropping the
 // `export *` keeps `units/pause-ad` from silently re-exporting `parsePauseAdCards`.
-export { INSIGHT_BODY_MAX_LENGTH, } from './units/pause-ad-card';
-export { gam } from './units/gam';
-export { createCompanionTracker, createVastTracker, resolveVastTrackerTarget, } from './units/vast-tracker';
-export { DEFAULT_CREATIVE_API_BASE, } from './units/ssai-creative';
-export { createStreamLayerProvider, createQuortexProvider, createVastProvider, resolveProvider, fireBeacon, fireTrackingEvents, BUILTIN_PROVIDERS, } from './units/ssai-providers';
-export { preloadImages, preloadCreativeAssets, DEFAULT_PRELOAD_TIMEOUT_MS } from './units/ssai-preload';
+export { INSIGHT_BODY_MAX_LENGTH, } from './units/pause-ad-card.js';
+export { gam } from './units/gam.js';
+export { createCompanionTracker, createVastTracker, resolveVastTrackerTarget, } from './units/vast-tracker.js';
+export { DEFAULT_CREATIVE_API_BASE, } from './units/ssai-creative.js';
+export { createStreamLayerProvider, createQuortexProvider, createVastProvider, resolveProvider, fireBeacon, fireTrackingEvents, BUILTIN_PROVIDERS, } from './units/ssai-providers.js';
+export { preloadImages, preloadCreativeAssets, DEFAULT_PRELOAD_TIMEOUT_MS } from './units/ssai-preload.js';
 export const advertisement = (instance, _opts, done) => {
     instance.sdk.advertisement = new Advertisement(instance);
     instance.sdk.onMount({ name: 'advertisement' }, () => {

package/lib/units/external-ad.d.ts

@@ -1,8 +1,8 @@
 import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
 import { VastAd, VastCompanionAd, VastCreativeCompanion, VastCreativeLinear, VastCreativeNonLinear, VastNonLinearAd, VastResponse } from '@dailymotion/vast-client';
 import '@streamlayer/sdk-web-api';
-import { type PalNonceManager } from './gam';
-import { VastCreative } from './parse-vast-extensions';
+import { type PalNonceManager } from './gam.js';
+import { VastCreative } from './parse-vast-extensions.js';
 export type AdCompanion = {
     imageUrl?: string;
     clickUrl?: string;

package/lib/units/external-ad.js

@@ -7,8 +7,8 @@ import { createLogger } from '@streamlayer/sdk-web-logger';
 import { VASTClient, VASTParser, } from '@dailymotion/vast-client';
 import '@streamlayer/sdk-web-api';
 import VMAP from 'vmap';
-import { gam } from './gam';
-import { parseVastExtension } from './parse-vast-extensions';
+import { gam } from './gam.js';
+import { parseVastExtension } from './parse-vast-extensions.js';
 const log = createLogger('ui:gam-external-ad');
 /** Default budget for a single VAST resolution before it is treated as "no ad". */
 const VAST_FETCH_TIMEOUT_MS = 10_000;

package/lib/units/pause-ad.d.ts

@@ -1,7 +1,7 @@
 import { createSingleStore, StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
 import '@streamlayer/sdk-web-api';
 import '@streamlayer/sdk-web-core/store';
-import { type PauseAdCard } from './pause-ad-card';
+import { type PauseAdCard } from './pause-ad-card.js';
 export type PauseAdListOptions = {
     refetchInterval: number;
     $enabled: boolean;

package/lib/units/pause-ad.js

@@ -3,7 +3,7 @@ import { atom } from 'nanostores';
 import '@streamlayer/sdk-web-api';
 import '@streamlayer/sdk-web-core/store';
 import { Feed } from '@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb';
-import { parsePauseAdCards } from './pause-ad-card';
+import { parsePauseAdCards } from './pause-ad-card.js';
 const log = createLogger('advertisement:pause-ad');
 export const pauseAdListStore = (instance) => {
     const $slStreamId = instance.stores.slStreamId.getAtomStore();

package/lib/units/ssai-ad-break.d.ts

@@ -1,5 +1,5 @@
 import { createSingleStore } from '@streamlayer/sdk-web-interfaces';
-import type { SsaiCreative } from './ssai-creative';
+import type { SsaiCreative } from './ssai-creative.js';
 /**
  * 'ending' = the ad's window closes within the detector's lead (~0.5s): the
  * overlay's cue to play its closing animation so it completes AT the boundary

package/lib/units/ssai-creative.d.ts

@@ -1,4 +1,4 @@
-import { DEFAULT_CREATIVE_API_BASE, type SsaiCreativeProvider } from './ssai-providers';
+import { DEFAULT_CREATIVE_API_BASE, type SsaiCreativeProvider } from './ssai-providers.js';
 export { DEFAULT_CREATIVE_API_BASE };
 export type SsaiTrackingEvent = {
     event: string;

package/lib/units/ssai-creative.js

@@ -1,4 +1,4 @@
-import { fireBeacon, fireDefaultImpression, fireTrackingEvents, DEFAULT_CREATIVE_API_BASE, } from './ssai-providers';
+import { fireBeacon, fireDefaultImpression, fireTrackingEvents, DEFAULT_CREATIVE_API_BASE, } from './ssai-providers.js';
 export { DEFAULT_CREATIVE_API_BASE };
 /**
  * Per-instance cache + impression-firing wrapper around a SsaiCreativeProvider.

package/lib/units/ssai-detector.d.ts

@@ -1,4 +1,4 @@
-import type { SsaiProgressEvent } from './ssai-creative';
+import type { SsaiProgressEvent } from './ssai-creative.js';
 export type SsaiDateRange = {
     id: string;
     creativeId: string;

package/lib/units/ssai-preload.d.ts

@@ -1,4 +1,4 @@
-import type { SsaiCreative } from './ssai-creative';
+import type { SsaiCreative } from './ssai-creative.js';
 /**
  * How long the overlay is willing to wait for artwork. A slow or dead image host
  * must never hold the bar back — the ad is already playing, and a bar that shows

package/lib/units/ssai-providers.d.ts

@@ -1,4 +1,4 @@
-import type { SsaiCreative } from './ssai-creative';
+import type { SsaiCreative } from './ssai-creative.js';
 export declare const DEFAULT_CREATIVE_API_BASE = "https://hls.next.streamlayer.io/api/creatives/";
 /**
  * A creative provider encapsulates everything that differs between ad sources:

package/lib/units/vast-tracker.d.ts

@@ -13,7 +13,7 @@
  * player) and they are billing-visible, so collapsing them here would silently change counts.
  */
 import { VASTTracker, VastAd, VastCompanionAd, VastCreativeCompanion, VastCreativeLinear, VastCreativeNonLinear, VastNonLinearAd } from '@dailymotion/vast-client';
-import type { AdCompanion, AdData } from './external-ad';
+import type { AdCompanion, AdData } from './external-ad.js';
 /** The creative (and, for non-linear creatives, the variation) a tracker reports through. */
 export type VastTrackerTarget = {
     ad: VastAd;