@streamlayer/feature-advertisement 1.1.1-rc.1350 → 1.1.1-rc.2.pf58ff685

package/lib/classic/units/external-ad.js

@@ -27,6 +27,7 @@ import '@streamlayer/sdk-web-api/classic';
 import VMAP from 'vmap';
 import { gam } from './gam.js';
 import { parseVastExtension } from './parse-vast-extensions.js';
+import { collectAssets, selectCardLogo } from './sponsor-logo.js';
 
 const log = createLogger('ui:gam-external-ad');
 /** Default budget for a single VAST resolution before it is treated as "no ad". */
@@ -54,7 +55,7 @@ const withTimeout = (promise, ms) => {
  * Get the first valid creative from an ad
  */
 const getCreative = ad => {
-  return ad.creatives.find(creative => creative.mediaFiles);
+  return ad.creatives.find(creative => getMediaFileUrl(creative));
 };
 /**
  * Get the URL of the first media file in the creative
@@ -77,32 +78,10 @@ const getClickThrough = creative => {
   // @ts-ignore — vast-client types `videoClickThroughURLTemplate` loosely
   return (creative === null || creative === void 0 || (_creative$videoClickT = creative.videoClickThroughURLTemplate) === null || _creative$videoClickT === void 0 ? void 0 : _creative$videoClickT.url) || undefined;
 };
-/**
- * Extract every `<Companion>` variation of the first `<CompanionAds>` creative that carries a
- * `<StaticResource>`, in document order. `width`/`height` are XML attributes (strings at
- * runtime), normalised to numbers so the size mapping can compare them.
- */
-const getCompanions = ad => {
-  const creative = ad.creatives.find(item => item.type === 'companion');
-  return ((creative === null || creative === void 0 ? void 0 : creative.variations) || []).reduce((acc, variation) => {
-    var _variation$staticReso, _variation$companionC;
-    const imageUrl = 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 (!imageUrl) {
-      return acc;
-    }
-    return acc.concat({
-      imageUrl,
-      clickUrl: (_variation$companionC = variation.companionClickThroughURLTemplate) !== null && _variation$companionC !== void 0 ? _variation$companionC : undefined,
-      width: Number(variation.width) || undefined,
-      height: Number(variation.height) || undefined,
-      creative,
-      variation
-    });
-  }, []);
-};
 /** Product companion mapping: the 300x75 companion is the logo, the banner-sized one the media. */
 const LOGO_COMPANION_WIDTH = 300;
 const LOGO_COMPANION_HEIGHT = 75;
+const isLogoSized = companion => (companion === null || companion === void 0 ? void 0 : companion.width) === LOGO_COMPANION_WIDTH && (companion === null || companion === void 0 ? void 0 : companion.height) === LOGO_COMPANION_HEIGHT;
 const companionArea = companion => (companion.width || 0) * (companion.height || 0);
 /**
  * Split a `<CompanionAds>` creative's variations into the logo and media slots.
@@ -110,9 +89,18 @@ const companionArea = companion => (companion.width || 0) * (companion.height ||
  * The pair mapping activates only for a tag that ships an exact 300x75 companion next to at
  * least one other. Deliberately conservative pending broader product sizes: on any other tag
  * no companion is promoted to the logo slot and the first one stays the media/strip candidate.
+ *
+ * Both halves of that gate are load-bearing and neither is an aspect rule: a 320x80 companion is
+ * the same 4:1 shape as 300x75 and is still rejected, and a lone 300x75 companion is rejected too
+ * (the Standard Ad Sidebar recovers that one as `AdData.loneLogo` when a Linear / NonLinear is
+ * the media, so it is not needed here).
+ * This is **narrower than iOS**, which has no size rule at all and fills its logo slot from a
+ * single companion — see `docs/wiki/programmatic-ads-display-ios-parity.md`. Exported for
+ * `external-ad.spec.ts` only; `src/index.ts` re-exports names explicitly, so this stays out of the
+ * package's public API.
  */
 const selectCompanions = companions => {
-  const logo = companions.length > 1 ? companions.find(companion => companion.width === LOGO_COMPANION_WIDTH && companion.height === LOGO_COMPANION_HEIGHT) : undefined;
+  const logo = companions.length > 1 ? companions.find(companion => isLogoSized(companion)) : undefined;
   if (!logo) {
     return {
       logo: undefined,
@@ -125,42 +113,27 @@ const selectCompanions = companions => {
     media
   };
 };
-/**
- * Extract the first `<NonLinearAds>` creative's static-image variation. Both the creative (which
- * owns the `<TrackingEvents>`) and the variation (which owns the click-through) are kept —
- * `VASTTracker` needs both.
- *
- * `@dailymotion/vast-client` 6.4.2 emits `nonlinearClickThroughURLTemplate` (lower-case `l`),
- * which the `@types/vast-client` shim declares as `nonLinearClickThroughURLTemplate` — the
- * runtime spelling is authoritative.
- */
-const getNonLinear = ad => {
-  var _creative$variations, _variation$nonlinearC;
-  const creative = ad.creatives.find(item => item.type === 'nonlinear');
-  const variation = creative === null || creative === void 0 || (_creative$variations = creative.variations) === null || _creative$variations === void 0 ? void 0 : _creative$variations[0];
-  const imageUrl = variation === null || variation === void 0 ? void 0 : variation.staticResource;
-  if (!creative || !variation || !imageUrl) {
-    return undefined;
-  }
-  return {
-    imageUrl,
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore — see the runtime-vs-shim spelling note above
-    clickUrl: (_variation$nonlinearC = variation.nonlinearClickThroughURLTemplate) !== null && _variation$nonlinearC !== void 0 ? _variation$nonlinearC : undefined,
-    width: Number(variation.width) || undefined,
-    height: Number(variation.height) || undefined,
-    creative,
-    variation
-  };
-};
 /**
  * Map a parsed VAST response into our `AdData` shape. Shared by both acquisition
  * paths — the GAM/VMAP tag flow and the Prebid auction flow — so the two always
- * produce identical downstream data. Returns `undefined` when the response has no
- * ad carrying creatives.
+ * produce identical downstream data.
+ *
+ * Returns `undefined` for a no-ad, which is two distinct shapes: a response with no ad carrying
+ * creatives, and an ad whose creatives carry no RENDERABLE asset — no linear `<MediaFile>`, no
+ * `<NonLinear>` still and no `<Companion>` image. Both callers `filter(Boolean)` the result, so a
+ * no-ad leaves `ads: []` and the card keeps whatever the server configured for it.
+ *
+ * Exported for `vast-mapping.spec.ts`, which drives it over the same fixture corpus the iOS suite
+ * uses. `src/index.ts` re-exports names explicitly, so this stays out of the package's public API.
  */
 const buildAdData = (parsedVAST, order) => {
   var _validAd$extensions$f;
+  // Defensive, and unreachable through either production path: `@dailymotion/vast-client` discards
+  // an ad whose creatives all fail to parse (empty `<Linear>`, empty/missing `<Creatives>`, unknown
+  // creative element) before `parseVAST` resolves, so it never yields an Ad with zero creatives.
+  // Kept because it costs nothing and `buildAdData` is also reachable from tests with a hand-built
+  // response — see the `invalid_ad` case in `vast-mapping.spec.ts`, which pins the parser contract
+  // this relies on rather than pretending to exercise the guard.
   const validAd = parsedVAST.ads.find(ads => ads.creatives.length > 0);
   if (!validAd) {
     log.warn({
@@ -175,13 +148,52 @@ const buildAdData = (parsedVAST, order) => {
   const parsedExtension = parseVastExtension(extension);
   const creative = getCreative(validAd);
   const mediaFileUrl = getMediaFileUrl(creative);
-  const companions = getCompanions(validAd);
+  const images = collectAssets(validAd);
+  const companions = images.filter(asset => asset.origin === 'companion');
+  const nonLinear = images.find(asset => asset.origin === 'nonlinear');
+  // An ad the parser KEPT whose creatives carry nothing any shell can draw is a no-ad, exactly
+  // like a response with no ad at all. vast-client only discards a creative it cannot parse; a
+  // `<NonLinear>` or `<Companion>` whose `<StaticResource>` body is empty parses fine and just
+  // yields no url, so the guard above cannot catch it. Without this the fabricated promotion still
+  // took the slot and drew the ad's TEXT — title and description over an empty media box — which
+  // is a billable impression for a creative that does not exist.
+  //
+  // "Renderable" is the union of the three slots the shells can fill: a linear `<MediaFile>`, a
+  // `<NonLinear>` still, or a `<Companion>` image. `collectAssets` already drops the imageless
+  // ones, so a non-empty `companions` means at least one drawable image. A tag carrying only a
+  // `<Mezzanine>` never reaches here — the parser drops that Linear itself — but it lands in the
+  // same place either way.
+  if (!mediaFileUrl && !nonLinear && companions.length === 0) {
+    log.warn({
+      order,
+      adId: validAd.id,
+      creatives: validAd.creatives.length
+    }, 'vast ad carries no renderable asset (no media file, no nonlinear, no companion) — treated as no-ad');
+    return undefined;
+  }
   const {
     logo,
     media: mediaCompanion
   } = selectCompanions(companions);
-  const nonLinear = getNonLinear(validAd);
   const clickThrough = getClickThrough(creative) || (nonLinear === null || nonLinear === void 0 ? void 0 : nonLinear.clickUrl) || (mediaCompanion === null || mediaCompanion === void 0 ? void 0 : mediaCompanion.clickUrl);
+  // Mirror iOS's greedy `pool.select([hero, .cardLogo])`: the hero claims first and a claimed
+  // asset is gone for later roles. Web's hero precedence (`createActiveAdFromVast`) is linear
+  // video → pair media companion (unreachable here: a `logo` short-circuits the whole selection)
+  // → NonLinear still → lone companion, so a companion is only unavailable to the logo slot when
+  // it IS the hero, i.e. when the tag ships neither. `selectCardLogo` already filters to companion
+  // origins, so the NonLinear never needs excluding.
+  //
+  // Excluding `companions[0]` (which is what `mediaCompanion` is when there is no `logo`) rather
+  // than the largest-area asset is a deliberate difference from iOS's `areaDominant` hero: web's
+  // content slot draws the FIRST companion in document order, so document order is the correct
+  // criterion for "what the hero already claimed" on this platform.
+  const companionIsHero = !mediaFileUrl && !nonLinear;
+  const cardLogoAsset = logo ? undefined : selectCardLogo(validAd, companionIsHero ? [mediaCompanion] : []);
+  // Share the selected resource wrapper so drawn-companion identity remains stable.
+  const cardLogo = cardLogoAsset ? companions.find(item => item.variation === cardLogoAsset.variation && item.imageUrl === cardLogoAsset.imageUrl) : undefined;
+  // Same collected instance as `companion` (identity matters to `drawnCompanions`). A lone
+  // companion never satisfies the pair rule, so this can only fill a slot `logo` left empty.
+  const loneLogo = companions.length === 1 && !companionIsHero && isLogoSized(companions[0]) ? companions[0] : undefined;
   log.info({
     order,
     adId: validAd.id,
@@ -201,6 +213,14 @@ const buildAdData = (parsedVAST, order) => {
         size: `${mediaCompanion.width}x${mediaCompanion.height}`,
         url: mediaCompanion.imageUrl
       } : undefined,
+      cardLogo: cardLogo ? {
+        size: `${cardLogo.width}x${cardLogo.height}`,
+        url: cardLogo.imageUrl
+      } : undefined,
+      loneLogo: loneLogo ? {
+        size: `${loneLogo.width}x${loneLogo.height}`,
+        url: loneLogo.imageUrl
+      } : undefined,
       clickThrough: !!clickThrough
     }
   }, 'vast ad parsed');
@@ -210,6 +230,8 @@ const buildAdData = (parsedVAST, order) => {
     mediaFileUrl,
     companion: companions[0],
     logo,
+    cardLogo,
+    loneLogo,
     mediaCompanion,
     nonLinear,
     clickThrough,
@@ -238,8 +260,12 @@ const createRequestId = () => `sl-web-${Date.now().toString(36)}-${Math.random()
  * - `storedauctionresponse` → `imp.ext.prebid.storedauctionresponse.id` (staging mock).
  * - `test=1` → top-level `test` flag.
  * - `w` / `h` → video dimensions (default 1920×1080).
+ *
+ * The host's GDPR consent (`AdTagParams`) rides the OpenRTB 2.5 extension fields Prebid Server
+ * reads — `regs.ext.gdpr` and `user.ext.consent` — the same signal the `${GDPR}` /
+ * `${GDPR_CONSENT}` macros carry for a VAST tag. Each is sent only when the host passed it.
  */
-const buildAuctionRequest = url => {
+const buildAuctionRequest = (url, adTagParams) => {
   var _ref, _params$get, _params$get2;
   const params = url.searchParams;
   const width = Number(params.get('w')) || 1920;
@@ -286,6 +312,20 @@ const buildAuctionRequest = url => {
   if (params.get('test') === '1') {
     request.test = 1;
   }
+  if ((adTagParams === null || adTagParams === void 0 ? void 0 : adTagParams.gdprApplies) !== undefined) {
+    request.regs = {
+      ext: {
+        gdpr: adTagParams.gdprApplies ? 1 : 0
+      }
+    };
+  }
+  if (adTagParams !== null && adTagParams !== void 0 && adTagParams.tcString) {
+    request.user = {
+      ext: {
+        consent: adTagParams.tcString
+      }
+    };
+  }
   return request;
 };
 /**
@@ -294,14 +334,14 @@ const buildAuctionRequest = url => {
  * so the winner plays first (RFC §2). A single bad bid must not drop the batch.
  */
 const fetchPrebidAds = /*#__PURE__*/function () {
-  var _ref2 = _asyncToGenerator(function* (prebidUrl) {
+  var _ref2 = _asyncToGenerator(function* (prebidUrl, adTagParams) {
     var _auction$seatbid, _params$get3, _params$get4;
     const response = yield fetch(prebidUrl.toString(), {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json'
       },
-      body: JSON.stringify(buildAuctionRequest(prebidUrl))
+      body: JSON.stringify(buildAuctionRequest(prebidUrl, adTagParams))
     });
     if (!response.ok) {
       throw new Error(`prebid auction failed with status ${response.status}`);
@@ -344,7 +384,7 @@ const fetchPrebidAds = /*#__PURE__*/function () {
       muted
     };
   });
-  return function fetchPrebidAds(_x) {
+  return function fetchPrebidAds(_x, _x2) {
     return _ref2.apply(this, arguments);
   };
 }();
@@ -365,13 +405,17 @@ const externalAd = instance => {
             return undefined;
           }
         })();
+        // The host's CURRENT macro values, read per request rather than baked into the store: the
+        // store is cached by url for the session, and consent routinely arrives after the SDK
+        // starts (a CMP answers asynchronously) or changes mid-session.
+        const adTagParams = instance.sdk.options.get().adTagParams;
         // Prebid links hit our Prebid Server auction endpoint instead of a VAST tag.
         // Run the OpenRTB auction and parse the winning bid's inline VAST (`adm`) into
         // the same `AdStore` shape the GAM/VMAP path returns. See rfcs/prebid.
         if (parsedAdUrl && isPrebidUrl(parsedAdUrl)) {
-          return fetchPrebidAds(parsedAdUrl);
+          return fetchPrebidAds(parsedAdUrl, adTagParams);
         }
-        const generateUrl = gam(adUrl);
+        const generateUrl = gam(adUrl, undefined, adTagParams);
         const generatedUrl = yield generateUrl();
         const noncedLink = generatedUrl === null || generatedUrl === void 0 ? void 0 : generatedUrl.url;
         if (!noncedLink) {
@@ -437,11 +481,11 @@ const externalAd = instance => {
           nonceManager
         };
       });
-      return function fetcher(_x2) {
+      return function fetcher(_x3) {
         return _ref3.apply(this, arguments);
       };
     }()
   });
 };
 
-export { externalAd };
+export { buildAdData, buildAuctionRequest, externalAd, selectCompanions };

package/lib/classic/units/external-pause-ad.js

@@ -12,6 +12,7 @@ import { eventBus } from '@streamlayer/sdk-web-interfaces/classic';
 import { createLogger } from '@streamlayer/sdk-web-logger/classic';
 import '@streamlayer/sdk-web-api/classic';
 import { VASTClient } from '@dailymotion/vast-client';
+import { substituteAdTagMacros } from './ad-macros.js';
 
 const FULLBLEED_VIDEO_TEMPLATES = ['fullbleed-video', 'fullbleed-video-center', 'fullbleed-video-left'];
 /**
@@ -126,7 +127,10 @@ const externalPauseAd = instance => {
               var _options$template2, _parsedVAST$ads$find;
               // `resolveAll: true` follows every `VASTAdTagURI` wrapper chain and resolves all
               // Ads (the default only resolves the first standalone Ad and stops at the wrapper).
-              const parsedVAST = yield vastClient.get(adUrl, {
+              // Pause-ad tags do not go through `gam()`, so fill the macros here — with the host's values
+              // as they are NOW, since this fetcher re-runs on every pause. The store key stays the
+              // configured url: `ExposedPauseAd` compares against it.
+              const parsedVAST = yield vastClient.get(substituteAdTagMacros(adUrl, instance.sdk.options.get().adTagParams), {
                 resolveAll: true
               });
               const template = (_options$template2 = options.template) !== null && _options$template2 !== void 0 ? _options$template2 : 'default';

package/lib/classic/units/gam.js

@@ -1,5 +1,7 @@
 import { asyncToGenerator as _asyncToGenerator } 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/web.dom-collections.iterator.js';
 import 'core-js/modules/web.url.js';
 import 'core-js/modules/web.url.to-json.js';
@@ -9,11 +11,73 @@ import 'core-js/modules/web.url-search-params.has.js';
 import 'core-js/modules/web.url-search-params.size.js';
 import { safeLocalStorage, safeSessionStorage } from '@streamlayer/sdk-web-storage/classic';
 import { v4, validate, v5 } from 'uuid';
+import { substituteAdTagMacros } from './ad-macros.js';
 
 const urlIsNotGam = url => {
   return url.origin !== 'https://pubads.g.doubleclick.net';
 };
-const gam = (url, adContainer) => {
+const palScriptUrl = 'https://imasdk.googleapis.com/pal/sdkloader/pal.js';
+const getPal = () => {
+  // @ts-expect-error Google PAL is supplied by the host or the script loader below.
+  return typeof goog === 'undefined' ? undefined : goog.pal;
+};
+let palReady;
+const ensurePal = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(function* () {
+    if (getPal()) {
+      return;
+    }
+    if (!palReady) {
+      palReady = new Promise((resolve, reject) => {
+        if (typeof document === 'undefined') {
+          reject(new Error('Google PAL requires a browser document'));
+          return;
+        }
+        const existing = document.querySelector(`script[src="${palScriptUrl}"]`);
+        const script = existing || document.createElement('script');
+        const finish = error => {
+          clearTimeout(timeout);
+          script.removeEventListener('load', onLoad);
+          script.removeEventListener('error', onError);
+          if (error) {
+            if (!existing) {
+              script.remove();
+            }
+            reject(error);
+          } else {
+            resolve();
+          }
+        };
+        const onLoad = () => finish(getPal() ? undefined : new Error('Google PAL did not initialize'));
+        const onError = () => finish(new Error('Google PAL failed to load'));
+        const timeout = setTimeout(() => finish(new Error('Google PAL loading timed out')), 10000);
+        script.addEventListener('load', onLoad);
+        script.addEventListener('error', onError);
+        if (!existing) {
+          script.async = true;
+          script.src = palScriptUrl;
+          document.head.appendChild(script);
+        }
+      }).catch(error => {
+        palReady = undefined;
+        throw error;
+      });
+    }
+    yield palReady;
+    palReady = undefined;
+  });
+  return function ensurePal() {
+    return _ref.apply(this, arguments);
+  };
+}();
+const gam = (rawUrl, adContainer, adTagParams) => {
+  // Every VAST/VMAP tag funnels through here, so this is where the macros get filled — for GAM and
+  // for any other vendor alike. Studio stores a programmatic tag verbatim, so an unexpanded
+  // `[timestamp]` / `[clickmacro]` / `${GDPR}` would otherwise reach the ad server literal, and a
+  // literal macro comes back copied into the vendor's click-through. `adTagParams` are the host's
+  // consent and click values, read by the caller at request time. The GAM `[placeholder]` tokens
+  // are left alone here and filled per parameter below.
+  const url = substituteAdTagMacros(rawUrl, adTagParams);
   const parsedUrl = (() => {
     try {
       const parsedUrl = new URL(url);
@@ -34,22 +98,21 @@ const gam = (url, adContainer) => {
       };
     });
   }
-  // @ts-expect-error goog is injected by the externally-loaded Google PAL SDK
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const pal = typeof goog === 'undefined' ? undefined : goog.pal;
-  if (!pal || !parsedUrl) {
+  if (!parsedUrl) {
     // eslint-disable-next-line require-await
     return /*#__PURE__*/_asyncToGenerator(function* () {
       return undefined;
     });
   }
-  const consentSettings = new pal.ConsentSettings();
-  consentSettings.allowStorage = false;
-  const nonceLoader = new pal.NonceLoader(consentSettings);
   const generateUrl = /*#__PURE__*/function () {
-    var _ref3 = _asyncToGenerator(function* () {
+    var _ref4 = _asyncToGenerator(function* () {
       try {
         var _adContainer$clientHe, _adContainer$clientWi;
+        yield ensurePal();
+        const pal = getPal();
+        const consentSettings = new pal.ConsentSettings();
+        consentSettings.allowStorage = false;
+        const nonceLoader = new pal.NonceLoader(consentSettings);
         const parsedUrl = new URL(url);
         const request = new pal.NonceRequest();
         let deviceId = safeLocalStorage().getItem('sl-device-id') || v4();
@@ -99,7 +162,7 @@ const gam = (url, adContainer) => {
       }
     });
     return function generateUrl() {
-      return _ref3.apply(this, arguments);
+      return _ref4.apply(this, arguments);
     };
   }();
   return generateUrl;

package/lib/classic/units/parse-vast-extensions.js

@@ -4,6 +4,10 @@ import 'core-js/modules/esnext.iterator.find.js';
 import 'core-js/modules/esnext.iterator.map.js';
 import { AdType } from '@streamlayer/sl-eslib/interactive/interactive.common_pb';
 
+/**
+ * Extension root element name → the placement it names. Only `DoubleBox` is defined by the
+ * StreamLayer extension schema today; anything else is a vendor extension we do not interpret.
+ */
 const MAP_EXTENSION_NAME_AD_TYPE = {
   DoubleBox: AdType.SIDE_BY_SIDE
 };
@@ -43,7 +47,7 @@ function parseVastExtension(root) {
   };
   return {
     adName,
-    adType: MAP_EXTENSION_NAME_AD_TYPE[root.name] || AdType.SIDE_BY_SIDE,
+    adType: MAP_EXTENSION_NAME_AD_TYPE[root.name],
     landscapeBackground: (_backgrounds$find = backgrounds.find(b => b.orientation === 'landscape')) === null || _backgrounds$find === void 0 ? void 0 : _backgrounds$find.url,
     portraitBackground: (_backgrounds$find2 = backgrounds.find(b => b.orientation === 'portrait')) === null || _backgrounds$find2 === void 0 ? void 0 : _backgrounds$find2.url,
     sponsorLogo: (_logos$find = logos.find(l => l.role === 'header')) === null || _logos$find === void 0 ? void 0 : _logos$find.url,

package/lib/classic/units/sponsor-logo.js

@@ -0,0 +1,197 @@
+import 'core-js/modules/es.array.push.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.iterator.map.js';
+
+/**
+ * Sponsor-logo slot selection for a **feature** ad unit (Insight, Prediction and Trivia today;
+ * Poll is the same shape and is a separate ticket).
+ *
+ * Deliberately NOT `selectCompanions` (`./external-ad.ts`). That rule is the *display*-unit rule:
+ * it promotes a companion to the logo slot only when the tag ships an exact 300x75 `<Companion>`
+ * next to at least one other. A feature ad-unit tag is typically a **single** creative — often a
+ * lone NonLinear `<StaticResource>` — where the ad IS the logo, which is exactly the shape that
+ * rule returns nothing for. `selectCompanions` stays untouched: SC-335's three shipped units
+ * depend on its exact behaviour and impression counts are billing-visible.
+ *
+ * Mirrors iOS `SLRVASTSlotRole.logo` + `SLRVASTAssetPool`
+ * (`StreamLayerSDK/Frameworks/SLRGAMFramework/Sources/VASTSlotFiller/`):
+ *
+ * - **Images only.** A video-only tag yields no logo. `<Icon>` is never projected — icons hang off
+ *   the `<Linear>` creative, which this selector does not look at. A `<StaticResource>` the tag
+ *   declares as a non-image `creativeType` is skipped too, so a companion that lists a script
+ *   before its image still resolves to the image (see `isImageResource`).
+ * - **Origin-agnostic.** A lone NonLinear `<StaticResource>` is as valid as a `<Companion>`.
+ * - **Aspect-dominant** toward 1:1: the smallest `|log(assetAspect) - log(1)|` wins, ties broken by
+ *   larger area, then by higher pixel density. Aspect is a *preference, never a filter* — the only
+ *   hard constraint is the asset kind, so a badly shaped asset still wins if it is the only one.
+ * - Assets whose intrinsic size the tag never declared rank last, but still beat nothing.
+ *
+ * The module also hosts iOS's second logo role, `SLRVASTSlotRole.cardLogo` (`selectCardLogo`) —
+ * the same ranking narrowed to `<Companion>` origins, for the hero-card display units.
+ */
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="../module.d.ts" />
+/** `width`/`height` are XML attributes (strings at runtime); 0 and NaN both mean "not declared". */
+const toSize = value => {
+  const size = Number(value);
+  return size > 0 ? size : undefined;
+};
+/**
+ * VAST 4 `<CompanionAds pxratio>`; `@dailymotion/vast-client` defaults it to `'1'` and the
+ * `@types/vast-client` shim does not declare it, hence the loose read.
+ */
+const toPxRatio = variation => {
+  return Number(variation.pxratio) || 1;
+};
+/**
+ * `<StaticResource creativeType>`. The slot draws an `<img>`, so a resource the tag declares as
+ * anything else — the `application/x-shockwave-flash` or `application/javascript` creative a
+ * companion may list beside its image — must never fill it: it would swap the proto logo for a
+ * broken image AND still fire an impression for something nobody ever saw.
+ *
+ * An ABSENT type is not a rejection. VAST requires the attribute but real GAM image companions
+ * routinely omit it, and this module's only hard constraint is the asset kind, so an undeclared
+ * type stays a candidate. `@dailymotion/vast-client` writes `0` for a missing NonLinear
+ * `creativeType` and `null` for a missing companion one; both are falsy, hence the single guard.
+ */
+const isImageResource = creativeType => {
+  if (!creativeType) {
+    return true;
+  }
+  return String(creativeType).toLowerCase().indexOf('image/') === 0;
+};
+/**
+ * The first resource a `<Companion>` declares as an image (or leaves undeclared). NOT
+ * `staticResources[0]`: the order in the tag is the advertiser's, and a non-image resource listed
+ * first must not hide a usable image behind it.
+ */
+const pickCompanionImage = variation => {
+  const resources = variation.staticResources || [];
+  for (let i = 0; i < resources.length; i++) {
+    const resource = resources[i];
+    if (resource && resource.url && isImageResource(resource.creativeType)) {
+      return resource.url;
+    }
+  }
+  return undefined;
+};
+/** Distance from square on a log scale, so 2:1 and 1:2 are equally far from 1:1. */
+const aspectDistance = asset => {
+  if (!asset.width || !asset.height) {
+    // Unknown intrinsic size — rank last, but still a candidate.
+    return Infinity;
+  }
+  return Math.abs(Math.log(asset.width / asset.height));
+};
+const collectAssetsFrom = ad => {
+  const assets = [];
+  for (let i = 0; i < ad.creatives.length; i++) {
+    const creative = ad.creatives[i];
+    if (creative.type === 'companion') {
+      const companionCreative = creative;
+      const variations = companionCreative.variations || [];
+      for (let j = 0; j < variations.length; j++) {
+        const variation = variations[j];
+        const imageUrl = variation && pickCompanionImage(variation);
+        if (imageUrl) {
+          var _variation$companionC;
+          assets.push({
+            imageUrl,
+            clickUrl: (_variation$companionC = variation.companionClickThroughURLTemplate) !== null && _variation$companionC !== void 0 ? _variation$companionC : undefined,
+            width: toSize(variation.width),
+            height: toSize(variation.height),
+            origin: 'companion',
+            creative: companionCreative,
+            variation
+          });
+        }
+      }
+      continue;
+    }
+    if (creative.type === 'nonlinear') {
+      const nonLinearCreative = creative;
+      const variations = nonLinearCreative.variations || [];
+      for (let j = 0; j < variations.length; j++) {
+        const variation = variations[j];
+        // `type` is where the parser puts a `<NonLinear>`'s `creativeType`, and it is written last
+        // from the `<StaticResource>` element, so it describes `staticResource` whenever that is
+        // set. An HTML- or iframe-typed variation carries no `staticResource` and drops out here.
+        const imageUrl = variation && isImageResource(variation.type) ? variation.staticResource : undefined;
+        if (imageUrl) {
+          var _variation$nonlinearC;
+          assets.push({
+            imageUrl,
+            // 6.4.2 emits `nonlinearClickThroughURLTemplate` (lower-case `l`); the shim declares
+            // the upper-case spelling. The runtime one is authoritative — see `getNonLinear`.
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            clickUrl: (_variation$nonlinearC = variation.nonlinearClickThroughURLTemplate) !== null && _variation$nonlinearC !== void 0 ? _variation$nonlinearC : undefined,
+            width: toSize(variation.width),
+            height: toSize(variation.height),
+            origin: 'nonlinear',
+            creative: nonLinearCreative,
+            variation
+          });
+        }
+      }
+    }
+  }
+  return assets;
+};
+/**
+ * The shared ranking both roles use: aspect distance from 1:1, ties broken by larger area, then by
+ * higher pixel density. Aspect is a preference, never a filter — the best of a bad set still wins.
+ */
+const rankBest = assets => {
+  if (!assets.length) {
+    return undefined;
+  }
+  let best = assets[0];
+  let bestDistance = aspectDistance(best);
+  let bestArea = (best.width || 0) * (best.height || 0);
+  let bestPxRatio = toPxRatio(best.variation);
+  for (let i = 1; i < assets.length; i++) {
+    const asset = assets[i];
+    const distance = aspectDistance(asset);
+    const area = (asset.width || 0) * (asset.height || 0);
+    const pxRatio = toPxRatio(asset.variation);
+    const wins = distance !== bestDistance ? distance < bestDistance : area !== bestArea ? area > bestArea : pxRatio > bestPxRatio;
+    if (wins) {
+      best = asset;
+      bestDistance = distance;
+      bestArea = area;
+      bestPxRatio = pxRatio;
+    }
+  }
+  return best;
+};
+/**
+ * Pick the image a parsed VAST ad offers for a sponsor-logo slot, or `undefined` when it offers
+ * none (a video-only tag, or an empty response). A caller that gets `undefined` must fall back to
+ * its own proto/Studio logo rather than suppressing the card.
+ */
+const collectAssets = ad => collectAssetsFrom(ad);
+const selectSponsorLogo = ad => rankBest(collectAssetsFrom(ad));
+/**
+ * iOS `SLRVASTSlotRole.cardLogo` — the sponsor logo of a **hero card** (1:1 / 2:1 / Picture in
+ * Picture / Side-by-Side / Sponsor Frame). Same 1:1 aspect-dominant ranking as `.logo`, plus the
+ * one constraint that distinguishes the two roles:
+ *
+ * - **`requiredOrigin: .companion`.** A NonLinear image is a hero creative, never a logo. iOS's
+ *   reason: a leftover hero-type asset — a second `<NonLinear>` overlay, or a stray image still in
+ *   the pool after the hero role claimed its own — must never leak into the card's logo slot,
+ *   where it would render at logo size as an unreadable smudge of the advertiser's key art.
+ *   `nonlinear_full` is the fixture that pins it: `.logo` takes the 500x500 NonLinear, `.cardLogo`
+ *   must take the 200x200 `<Companion>`.
+ * - **`exclude`** mirrors iOS's **greedy** `pool.select([hero, .cardLogo])`: roles resolve in array
+ *   order and an asset a role claims is removed from the pool for every later role. We have no
+ *   pool object, so the caller passes the assets the hero already claimed and they are filtered
+ *   out here by `imageUrl`.
+ */
+const selectCardLogo = (ad, exclude) => {
+  const claimed = (exclude || []).map(item => item === null || item === void 0 ? void 0 : item.imageUrl).filter(url => !!url);
+  return rankBest(collectAssetsFrom(ad).filter(asset => asset.origin === 'companion' && claimed.indexOf(asset.imageUrl) === -1));
+};
+
+export { collectAssets, selectCardLogo, selectSponsorLogo };