@hientran0208/ads-sdk 1.0.0

package/dist/chunk-GA4VEFSM.js

@@ -0,0 +1,900 @@
+import { OOP_FORMATS, plan, normalize, CONSERVATIVE_CONSENT_DEFAULTS, isDomainAllowed } from '@hientran0208/ads-manifest';
+
+// src/core/boot-spine.ts
+var BOOT_SPINE = [
+  "disableInitialLoad",
+  "enableSingleRequest",
+  "collapseEmptyDivs",
+  "enableServices"
+];
+
+// src/core/consent-gate-contract.ts
+function createAllowAllConsentGate(signals) {
+  const snap = {
+    signals: signals ?? {
+      ad_storage: "granted",
+      analytics_storage: "granted",
+      ad_user_data: "granted",
+      ad_personalization: "granted"
+    },
+    allows: () => true,
+    resolved: true
+  };
+  return {
+    snapshot: () => snap,
+    onChange: () => () => {
+    },
+    start: () => {
+    }
+  };
+}
+
+// src/core/event-bus.ts
+function createEventBus(onHandlerError) {
+  const handlers = /* @__PURE__ */ new Map();
+  return {
+    on(type, handler) {
+      let set = handlers.get(type);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        handlers.set(type, set);
+      }
+      set.add(handler);
+      return () => set.delete(handler);
+    },
+    emit(ev) {
+      const set = handlers.get(ev.type);
+      if (!set) return;
+      for (const handler of [...set]) {
+        try {
+          handler(ev);
+        } catch (err) {
+          onHandlerError?.(err);
+        }
+      }
+    }
+  };
+}
+function dispatchTraits(format) {
+  const isOop = OOP_FORMATS.includes(format);
+  if (format === "interstitial") {
+    return { usesDiv: false, ridesEagerBatch: false, onDemandOnly: true, refreshable: false };
+  }
+  if (isOop) {
+    return { usesDiv: false, ridesEagerBatch: true, onDemandOnly: false, refreshable: false };
+  }
+  return { usesDiv: true, ridesEagerBatch: true, onDemandOnly: false, refreshable: true };
+}
+
+// src/core/registries/adapter-slot-registry.ts
+function createAdapterSlotRegistry() {
+  const byType = /* @__PURE__ */ new Map();
+  return {
+    register(type, vendor) {
+      byType.set(type, vendor);
+    },
+    resolve(type) {
+      return byType.get(type) ?? null;
+    },
+    all() {
+      return [...byType.values()];
+    }
+  };
+}
+
+// src/core/registries/provider-registry.ts
+function createProviderRegistry() {
+  const providers = [];
+  return {
+    register(provider) {
+      providers.push(provider);
+    },
+    resolve(format) {
+      return providers.find((p) => p.capabilities().includes(format)) ?? null;
+    },
+    all() {
+      return [...providers];
+    }
+  };
+}
+
+// src/core/slot-lifecycle.ts
+var LEGAL = {
+  registered: ["gated", "destroyed"],
+  gated: ["requested", "destroyed"],
+  requested: ["rendered", "destroyed"],
+  rendered: ["requested", "destroyed"],
+  // refresh re-enters requested
+  destroyed: []
+};
+function createSlotLifecycle() {
+  const records = /* @__PURE__ */ new Map();
+  return {
+    register(slot, epoch) {
+      const rec = { slot, handle: null, state: "registered", epoch };
+      records.set(slot.__uid, rec);
+      return rec;
+    },
+    get(uid) {
+      return records.get(uid);
+    },
+    all() {
+      return [...records.values()];
+    },
+    transition(uid, to) {
+      const rec = records.get(uid);
+      if (!rec) return false;
+      if (!LEGAL[rec.state].includes(to)) return false;
+      rec.state = to;
+      return true;
+    },
+    attachHandle(uid, handle) {
+      const rec = records.get(uid);
+      if (rec) rec.handle = handle;
+    },
+    isCurrent(uid, epoch) {
+      const rec = records.get(uid);
+      return !!rec && rec.epoch === epoch && rec.state !== "destroyed";
+    },
+    destroyAll() {
+      for (const rec of records.values()) rec.state = "destroyed";
+      records.clear();
+    }
+  };
+}
+
+// src/inject/tag-injector.ts
+function hostOf(src) {
+  try {
+    return new URL(src, "https://invalid.local").hostname;
+  } catch {
+    return null;
+  }
+}
+function createTagInjector(bus, doc = document) {
+  const injected = /* @__PURE__ */ new Set();
+  return {
+    has(key) {
+      return injected.has(key);
+    },
+    inject(src, allowedHosts, opts = {}) {
+      const key = opts.key ?? src;
+      if (injected.has(key)) return true;
+      const host = hostOf(src);
+      if (!host || !allowedHosts.includes(host)) {
+        bus.emit({
+          type: "error",
+          scope: "tag-injector",
+          message: `blocked script from disallowed host: ${host ?? src}`
+        });
+        return false;
+      }
+      const el = doc.createElement("script");
+      el.src = src;
+      if (opts.defer) el.defer = true;
+      else el.async = true;
+      for (const [k, v] of Object.entries(opts.attrs ?? {})) {
+        el.setAttribute(k, v);
+      }
+      (doc.head ?? doc.documentElement).appendChild(el);
+      injected.add(key);
+      bus.emit({ type: "tag:injected", host, key });
+      return true;
+    }
+  };
+}
+
+// src/inject/lazy-observer.ts
+function createLazyObserver(win = window) {
+  const observers = [];
+  const Ctor = win.IntersectionObserver;
+  return {
+    observe(el, rootMargin, onEnter) {
+      if (!Ctor) {
+        onEnter();
+        return;
+      }
+      const io = new Ctor(
+        (entries, obs) => {
+          for (const entry of entries) {
+            if (entry.isIntersecting) {
+              obs.disconnect();
+              onEnter();
+            }
+          }
+        },
+        { rootMargin }
+      );
+      io.observe(el);
+      observers.push(io);
+    },
+    disconnect() {
+      for (const io of observers) io.disconnect();
+      observers.length = 0;
+    }
+  };
+}
+
+// src/core/dynamic-params.ts
+function createDynamicParamsStore() {
+  const store = {
+    page: {},
+    perSlot: /* @__PURE__ */ new Map(),
+    setPage(p) {
+      store.page = { ...store.page, ...p };
+    },
+    setSlot(id, p) {
+      store.perSlot.set(id, { ...store.perSlot.get(id) ?? {}, ...p });
+    },
+    resolved(slotId) {
+      const slot = slotId ? store.perSlot.get(slotId) : void 0;
+      return { ...store.page, ...slot ?? {} };
+    }
+  };
+  return store;
+}
+function runGateChain(deps) {
+  const { manifest, bus, hostname } = deps;
+  if (manifest.killed) {
+    bus.emit({ type: "warning", scope: "gate:kill", message: "kill switch active" });
+    return { ok: false, gate: "kill", reason: "killed" };
+  }
+  if (!isDomainAllowed(hostname, manifest.allowDomains)) {
+    bus.emit({
+      type: "error",
+      scope: "gate:domain",
+      message: `host not allowed: ${hostname}`
+    });
+    return { ok: false, gate: "domain", reason: "domain_not_allowed" };
+  }
+  return { ok: true };
+}
+
+// src/core/ads-engine.ts
+var GUARD_KEY = "__adsEngine";
+function createAdsEngine(deps = {}) {
+  const win = deps.win ?? (typeof window !== "undefined" ? window : void 0);
+  const doc = deps.doc ?? (typeof document !== "undefined" ? document : void 0);
+  const bus = deps.bus ?? createEventBus();
+  const providerRegistry = deps.providerRegistry ?? createProviderRegistry();
+  const adapterRegistry = deps.adapterRegistry ?? createAdapterSlotRegistry();
+  const consentGate = deps.consentGate ?? createAllowAllConsentGate();
+  const injector = deps.injector ?? (doc ? createTagInjector(bus, doc) : void 0);
+  const lazyObserver = deps.lazyObserver ?? (win ? createLazyObserver(win) : void 0);
+  const dynamicStore = createDynamicParamsStore();
+  const lifecycle = createSlotLifecycle();
+  let booted = false;
+  let epoch = 0;
+  let current = null;
+  let consentUnsub = null;
+  function planContext(overridePageView) {
+    const base = current.ctx;
+    const dyn = dynamicStore.resolved();
+    const merged = { ...dyn };
+    if (overridePageView !== void 0) merged.changeCorrelator = overridePageView;
+    return {
+      url: merged.pageUrl ?? base.url,
+      viewport: base.viewport,
+      ...Object.keys(merged).length ? { dynamic: merged } : {}
+    };
+  }
+  function defineSlots(rp) {
+    for (const slot of rp.slots) {
+      const provider = providerRegistry.resolve(slot.format);
+      if (!provider) {
+        bus.emit({ type: "warning", scope: "dispatch", message: `no provider for format ${slot.format}` });
+        continue;
+      }
+      lifecycle.register(slot, epoch);
+      bus.emit({ type: "slot:registered", slotId: slot.id, uid: slot.__uid });
+      const handle = provider.prepare(slot);
+      lifecycle.attachHandle(slot.__uid, handle);
+      lifecycle.transition(slot.__uid, "gated");
+    }
+  }
+  function eagerHandles() {
+    return lifecycle.all().filter((r) => r.handle && dispatchTraits(r.slot.format).ridesEagerBatch && r.slot.loading !== "lazy").map((r) => r.handle).filter(Boolean);
+  }
+  function requestHandles(handles, changeCorrelator) {
+    if (!handles.length) return;
+    for (const h of handles) {
+      const rec = lifecycle.get(h.uid);
+      if (rec && lifecycle.transition(h.uid, "requested")) {
+        bus.emit({ type: "slot:requested", slotId: rec.slot.id, uid: h.uid });
+      }
+    }
+    providerRegistry.all()[0]?.request(handles, { changeCorrelator });
+  }
+  function armLazy() {
+    for (const rec of lifecycle.all()) {
+      if (rec.slot.loading !== "lazy" || !rec.handle) continue;
+      const el = doc?.getElementById(rec.slot.id) ?? void 0;
+      const arm = () => {
+        if (!consentGate.snapshot().allows("gpt")) return;
+        requestHandles([rec.handle], false);
+      };
+      if (lazyObserver && el) lazyObserver.observe(el, rec.slot.rootMargin ?? "0px", arm);
+      else if (lazyObserver && !el) lazyObserver.observe(doc.body, rec.slot.rootMargin ?? "0px", arm);
+    }
+  }
+  function armTagVendors() {
+    if (!current || !injector) return;
+    for (const tag of current.plan.managedTags) {
+      const vendor = adapterRegistry.resolve(tag.type);
+      if (!vendor) continue;
+      if (!consentGate.snapshot().allows(tag.type)) continue;
+      vendor.init(tag, { injector, bus, allowedHosts: current.plan.allowedTagHosts });
+    }
+  }
+  function bootResolved(rp, autoShow) {
+    for (const provider of providerRegistry.all()) {
+      for (const step of BOOT_SPINE) provider.bootStep(step);
+    }
+    defineSlots(rp);
+    booted = true;
+    consentGate.start();
+    consentUnsub = consentGate.onChange(() => onConsentChange());
+    armTagVendors();
+    if (autoShow && consentGate.snapshot().allows("gpt")) {
+      requestHandles(eagerHandles(), false);
+      armLazy();
+    }
+  }
+  function claimPageGuard() {
+    if (win && win[GUARD_KEY]) {
+      bus.emit({ type: "warning", scope: "dual-load", message: "an AdsEngine already booted on this page; ignoring second init" });
+      return false;
+    }
+    if (win) win[GUARD_KEY] = true;
+    return true;
+  }
+  function onConsentChange() {
+    if (!booted || !current) return;
+    armTagVendors();
+    if (consentGate.snapshot().allows("gpt")) {
+      const handles = eagerHandles().filter((h) => {
+        const rec = lifecycle.get(h.uid);
+        return rec && rec.state !== "requested";
+      });
+      requestHandles(handles, false);
+    }
+  }
+  return {
+    providerRegistry,
+    adapterRegistry,
+    isBooted: () => booted,
+    getExecutedPlan: () => current?.plan ?? null,
+    on: (type, handler) => bus.on(type, handler),
+    init(manifest, ctx) {
+      if (!claimPageGuard()) return;
+      const normalized = normalize(manifest);
+      const hostname = win?.location?.hostname ?? new URL(ctx.url).hostname;
+      const gate = runGateChain({ manifest: normalized, bus, hostname });
+      if (!gate.ok) {
+        booted = false;
+        return;
+      }
+      current = { manifest, ctx, plan: { slots: [], managedTags: [], video: [], allowedTagHosts: [] } };
+      current.plan = plan(manifest, planContext());
+      bootResolved(current.plan, normalized.autoShow);
+    },
+    initFromPlan(rp, ctx, opts = {}) {
+      if (!claimPageGuard()) return;
+      current = { ctx, plan: rp };
+      bootResolved(rp, opts.autoShow ?? true);
+    },
+    setPageParams(p) {
+      dynamicStore.setPage(p);
+    },
+    setSlotParams(id, p) {
+      dynamicStore.setSlot(id, p);
+    },
+    refresh(ids, opts = {}) {
+      if (!booted || !current) return;
+      const newPageView = opts.newPageView ?? false;
+      if (newPageView) epoch += 1;
+      if (current.manifest) {
+        current = { ...current, plan: plan(current.manifest, planContext(newPageView)) };
+      }
+      const targets = ids && ids.length ? lifecycle.all().filter((r) => ids.includes(r.slot.id) && r.handle) : lifecycle.all().filter((r) => r.handle && dispatchTraits(r.slot.format).refreshable);
+      const handles = targets.map((r) => r.handle).filter(Boolean);
+      if (!handles.length) return;
+      for (const r of targets) lifecycle.transition(r.slot.__uid, "requested");
+      providerRegistry.all()[0]?.refresh(handles, { changeCorrelator: newPageView });
+    },
+    display(id) {
+      if (!booted) return;
+      const rec = lifecycle.all().find((r) => r.slot.id === id);
+      if (!rec?.handle) return;
+      if (!consentGate.snapshot().allows("gpt")) return;
+      providerRegistry.all()[0]?.display(rec.handle);
+    },
+    destroy() {
+      consentUnsub?.();
+      lazyObserver?.disconnect();
+      for (const provider of providerRegistry.all()) {
+        const handles = lifecycle.all().map((r) => r.handle).filter(Boolean);
+        if (handles.length) provider.destroy(handles);
+      }
+      lifecycle.destroyAll();
+      booted = false;
+      current = null;
+      if (win) delete win[GUARD_KEY];
+    }
+  };
+}
+
+// src/consent/consent-mode.ts
+function ensureGtag(host) {
+  if (typeof host.gtag === "function") return host.gtag;
+  host.dataLayer = host.dataLayer ?? [];
+  const gtag = (...args) => {
+    host.dataLayer.push(args);
+  };
+  host.gtag = gtag;
+  return gtag;
+}
+function createConsentMode(host = window) {
+  let defaultsApplied = false;
+  return {
+    defaultsSet: () => defaultsApplied,
+    setDefaults(signals) {
+      const gtag = ensureGtag(host);
+      gtag("consent", "default", { ...signals, wait_for_update: 500 });
+      defaultsApplied = true;
+    },
+    update(signals) {
+      const gtag = ensureGtag(host);
+      gtag("consent", "update", { ...signals });
+    }
+  };
+}
+
+// src/consent/tcf-bridge.ts
+var READY_STATUSES = /* @__PURE__ */ new Set(["tcloaded", "useractioncomplete"]);
+function createTcfBridge(host = window, opts = {}) {
+  const api = host.__tcfapi;
+  const setTimeoutFn = opts.setTimeoutFn ?? setTimeout;
+  return {
+    present: () => typeof api === "function",
+    onConsent(cb) {
+      if (typeof api !== "function") {
+        opts.onTimeout?.();
+        return;
+      }
+      let fired = false;
+      const timer = setTimeoutFn(() => {
+        if (!fired) opts.onTimeout?.();
+      }, opts.timeoutMs ?? 2e3);
+      api("addEventListener", 2, (tcData, success) => {
+        if (!success || !tcData) return;
+        if (!tcData.eventStatus || READY_STATUSES.has(tcData.eventStatus)) {
+          fired = true;
+          clearTimeout(timer);
+          cb(tcData.purpose?.consents ?? {}, tcData.gdprApplies ?? true);
+        }
+      });
+    }
+  };
+}
+
+// src/consent/tcf-purpose-signal-map.ts
+function state(granted) {
+  return granted ? "granted" : "denied";
+}
+var g = (p, n) => p[n] === true;
+function purposesToSignals(consents) {
+  return {
+    ad_storage: state(g(consents, 1)),
+    analytics_storage: state(g(consents, 1)),
+    ad_user_data: state(g(consents, 1) && g(consents, 7)),
+    ad_personalization: state(g(consents, 3) && g(consents, 4))
+  };
+}
+
+// src/consent/vendor-map.ts
+function vendorAllowed(vendor, signals) {
+  switch (vendor) {
+    case "gpt":
+      return signals.ad_storage === "granted";
+    case "ga4":
+      return signals.analytics_storage === "granted";
+    case "meta-pixel":
+      return signals.ad_storage === "granted";
+    default:
+      return signals.ad_storage === "granted";
+  }
+}
+function vendorDecisionMap(signals) {
+  return {
+    gpt: vendorAllowed("gpt", signals),
+    ga4: vendorAllowed("ga4", signals),
+    "meta-pixel": vendorAllowed("meta-pixel", signals)
+  };
+}
+function snapshotFor(signals, resolved) {
+  return {
+    signals,
+    resolved,
+    allows: (vendor) => vendorAllowed(vendor, signals)
+  };
+}
+function createConsentGate(deps = {}) {
+  const config = deps.config ?? {};
+  const consentMode = deps.consentMode ?? createConsentMode();
+  const tcfBridge = deps.tcfBridge ?? createTcfBridge(void 0, { timeoutMs: config.cmpTimeoutMs ?? 2e3 });
+  const defaults = config.defaults ?? CONSERVATIVE_CONSENT_DEFAULTS;
+  let current = snapshotFor(defaults, false);
+  const listeners = /* @__PURE__ */ new Set();
+  let started = false;
+  consentMode.setDefaults(defaults);
+  function applySignals(signals) {
+    current = snapshotFor(signals, true);
+    consentMode.update(signals);
+    deps.bus?.emit({ type: "consent:changed", signals });
+    for (const l of [...listeners]) l(current);
+  }
+  return {
+    snapshot: () => current,
+    onChange(cb) {
+      listeners.add(cb);
+      return () => listeners.delete(cb);
+    },
+    start() {
+      if (started) return;
+      started = true;
+      tcfBridge.onConsent((consents) => {
+        applySignals(purposesToSignals(consents));
+      });
+    }
+  };
+}
+
+// src/adapters/provider/gpt/define-slot.ts
+function baseSizes(slot) {
+  const base = slot.sizeMapping?.find((m) => m.viewport[0] === 0 && m.viewport[1] === 0);
+  const sizes = base?.sizes ?? slot.sizeMapping?.[0]?.sizes ?? [];
+  return sizes.map(toGptSize);
+}
+function toGptSize(size) {
+  return size === "fluid" ? "fluid" : size;
+}
+function buildSizeMapping(gt, mapping) {
+  const builder = gt.sizeMapping();
+  for (const entry of mapping) {
+    builder.addSize(entry.viewport, entry.sizes.map(toGptSize));
+  }
+  return builder.build();
+}
+function defineDisplaySlot(gt, slot) {
+  const gptSlot = gt.defineSlot(slot.adUnitPath, baseSizes(slot), slot.id);
+  if (!gptSlot) return null;
+  if (slot.sizeMapping && slot.sizeMapping.length > 0) {
+    gptSlot.defineSizeMapping(buildSizeMapping(gt, slot.sizeMapping));
+  }
+  gptSlot.addService(gt.pubads());
+  return gptSlot;
+}
+
+// src/adapters/provider/gpt/oop-formats.ts
+function oopFormatValue(gt, slot) {
+  const formats = gt.enums?.OutOfPageFormat ?? {};
+  switch (slot.format) {
+    case "anchor":
+      return slot.position === "bottom" ? formats["BOTTOM_ANCHOR"] : formats["TOP_ANCHOR"];
+    case "interstitial":
+      return formats["INTERSTITIAL"];
+    case "side-rail":
+      return slot.side === "right" ? formats["RIGHT_SIDE_RAIL"] : formats["LEFT_SIDE_RAIL"];
+    default:
+      return formats["INTERSTITIAL"];
+  }
+}
+function defineOopSlot(gt, slot) {
+  const fmt = oopFormatValue(gt, slot);
+  const gptSlot = gt.defineOutOfPageSlot(slot.adUnitPath, fmt);
+  if (!gptSlot) return null;
+  gptSlot.addService(gt.pubads());
+  return gptSlot;
+}
+
+// src/adapters/provider/gpt/config-api.ts
+function applyPageConfig(gt, dynamic) {
+  if (!dynamic) return;
+  const cfg = {};
+  if (dynamic.pageUrl) cfg["pageUrl"] = dynamic.pageUrl;
+  if (dynamic.privacy) cfg["privacyTreatments"] = dynamic.privacy;
+  if (Object.keys(cfg).length) gt.setConfig(cfg);
+}
+function applySlotConfig(slot, planSlot) {
+  const cfg = {};
+  const targeting = planSlot.dynamic?.targeting;
+  if (targeting && Object.keys(targeting).length) {
+    cfg["targeting"] = targeting;
+  }
+  if (planSlot.contentPause) {
+    cfg["adsenseAttributes"] = { content_pause: true };
+  }
+  if (Object.keys(cfg).length) slot.setConfig(cfg);
+}
+
+// src/adapters/provider/gpt/ppid.ts
+function applyPpid(gt, ppid) {
+  if (!ppid) return;
+  gt.pubads().setPublisherProvidedId(ppid);
+}
+
+// src/adapters/provider/gpt/index.ts
+var GPT_SRC = "https://securepubads.g.doubleclick.net/tag/js/gpt.js";
+var GPT_HOST = "securepubads.g.doubleclick.net";
+var V1_FORMATS = ["display", "native", "anchor", "interstitial", "side-rail", "oop"];
+function createGptProvider(deps) {
+  const win = deps.win ?? window;
+  const entries = /* @__PURE__ */ new Map();
+  const lifecycleCbs = [];
+  let gptLoaded = false;
+  function gtCmd(fn) {
+    const gt = win.googletag = win.googletag ?? { cmd: [] };
+    gt.cmd.push(() => {
+      try {
+        fn(win.googletag);
+      } catch (err) {
+        deps.bus.emit({ type: "error", scope: "gpt", message: String(err), cause: err });
+      }
+    });
+  }
+  function loadGpt() {
+    if (gptLoaded || !deps.injector) return;
+    const hosts = deps.allowedHosts ?? [GPT_HOST];
+    const ok = deps.injector.inject(GPT_SRC, hosts, { key: "gpt.js" });
+    if (!ok) {
+      return;
+    }
+    gptLoaded = true;
+  }
+  function pagePpid() {
+    for (const { planSlot } of entries.values()) {
+      if (planSlot.dynamic?.ppid) return planSlot.dynamic.ppid;
+    }
+    return void 0;
+  }
+  function pageDynamic() {
+    for (const { planSlot } of entries.values()) {
+      if (planSlot.dynamic) return planSlot.dynamic;
+    }
+    return void 0;
+  }
+  return {
+    id: "gpt",
+    capabilities: () => V1_FORMATS,
+    bootStep(step) {
+      if (step === "disableInitialLoad") loadGpt();
+      gtCmd((gt) => {
+        const pubads = gt.pubads();
+        switch (step) {
+          case "disableInitialLoad":
+            pubads.disableInitialLoad();
+            break;
+          case "enableSingleRequest":
+            pubads.enableSingleRequest();
+            break;
+          case "collapseEmptyDivs":
+            pubads.collapseEmptyDivs();
+            break;
+          case "enableServices":
+            gt.enableServices();
+            pubads.addEventListener("slotRenderEnded", (e) => {
+              const ev = e;
+              const uid = findUidByElementId(ev.slot?.getSlotElementId?.());
+              for (const cb of lifecycleCbs) {
+                cb({ type: "rendered", uid: uid ?? "", isEmpty: !!ev.isEmpty });
+              }
+            });
+            break;
+        }
+      });
+    },
+    prepare(slot) {
+      let gptSlot = null;
+      const isOop = OOP_FORMATS.includes(slot.format);
+      gtCmd((gt) => {
+        gptSlot = isOop ? defineOopSlot(gt, slot) : defineDisplaySlot(gt, slot);
+        if (gptSlot) {
+          entries.set(slot.__uid, { planSlot: slot, gptSlot });
+          applySlotConfig(gptSlot, slot);
+        } else {
+          deps.bus.emit({ type: "warning", scope: "gpt", message: `slot ${slot.id} returned null (${slot.format})` });
+        }
+      });
+      return { uid: slot.__uid, slotId: slot.id, format: slot.format, native: () => entries.get(slot.__uid)?.gptSlot };
+    },
+    request(handles, opts) {
+      gtCmd((gt) => {
+        applyPpid(gt, pagePpid());
+        applyPageConfig(gt, pageDynamic());
+        const gptSlots = handles.map((h) => entries.get(h.uid)?.gptSlot).filter((s) => !!s);
+        if (gptSlots.length) gt.pubads().refresh(gptSlots, { changeCorrelator: opts.changeCorrelator });
+      });
+    },
+    display(handle) {
+      gtCmd((gt) => {
+        const entry = entries.get(handle.uid);
+        if (entry) gt.display(entry.gptSlot);
+      });
+    },
+    refresh(handles, opts) {
+      gtCmd((gt) => {
+        const gptSlots = handles.map((h) => entries.get(h.uid)?.gptSlot).filter((s) => !!s);
+        if (gptSlots.length) gt.pubads().refresh(gptSlots, { changeCorrelator: opts.changeCorrelator });
+      });
+    },
+    destroy(handles) {
+      gtCmd((gt) => {
+        const gptSlots = handles.map((h) => entries.get(h.uid)?.gptSlot).filter((s) => !!s);
+        if (gptSlots.length && gt.destroySlots) gt.destroySlots(gptSlots);
+        for (const h of handles) entries.delete(h.uid);
+      });
+    },
+    onLifecycle(cb) {
+      lifecycleCbs.push(cb);
+    }
+  };
+  function findUidByElementId(elementId) {
+    if (!elementId) return void 0;
+    for (const [uid, entry] of entries) {
+      if (entry.planSlot.id === elementId) return uid;
+    }
+    return void 0;
+  }
+}
+
+// src/adapters/tag-path/ga4.ts
+var GTAG_HOST = "www.googletagmanager.com";
+function createGa4Vendor(win = window) {
+  let initialized = false;
+  function ensureGtag2() {
+    if (typeof win.gtag === "function") return win.gtag;
+    win.dataLayer = win.dataLayer ?? [];
+    const gtag = (...args) => {
+      win.dataLayer.push(args);
+    };
+    win.gtag = gtag;
+    return gtag;
+  }
+  return {
+    id: "ga4",
+    kind: () => "analytics",
+    init(tag, ctx) {
+      if (initialized) return;
+      const src = `https://${GTAG_HOST}/gtag/js?id=${encodeURIComponent(tag.id)}`;
+      const ok = ctx.injector.inject(src, ctx.allowedHosts, { key: `ga4:${tag.id}` });
+      if (!ok) return;
+      const gtag = ensureGtag2();
+      gtag("js", /* @__PURE__ */ new Date());
+      gtag("config", tag.id);
+      initialized = true;
+      ctx.bus.emit({ type: "vendor:event", vendor: "ga4", name: "config", payload: { id: tag.id } });
+    }
+  };
+}
+
+// src/adapters/tag-path/meta-pixel.ts
+var FB_SRC = "https://connect.facebook.net/en_US/fbevents.js";
+function createMetaPixelVendor(win = window) {
+  let initialized = false;
+  function ensureFbq() {
+    if (typeof win.fbq === "function") return win.fbq;
+    const fbq = function(...args) {
+      if (fbq.callMethod) fbq.callMethod(...args);
+      else fbq.queue.push(args);
+    };
+    fbq.queue = [];
+    fbq.loaded = true;
+    fbq.version = "2.0";
+    win.fbq = fbq;
+    win._fbq = win._fbq ?? fbq;
+    return fbq;
+  }
+  return {
+    id: "meta-pixel",
+    kind: () => "analytics",
+    init(tag, ctx) {
+      if (initialized) return;
+      const ok = ctx.injector.inject(FB_SRC, ctx.allowedHosts, { key: `meta-pixel:${tag.id}` });
+      if (!ok) return;
+      const fbq = ensureFbq();
+      fbq("init", tag.id);
+      track(ctx, fbq, "PageView");
+      initialized = true;
+    }
+  };
+  function track(ctx, fbq, event, payload) {
+    fbq("track", event, payload);
+    ctx.bus.emit({ type: "vendor:event", vendor: "meta-pixel", name: event, payload });
+  }
+}
+function buildEngine(args) {
+  const win = args.win ?? (typeof window !== "undefined" ? window : void 0);
+  const doc = args.doc ?? (typeof document !== "undefined" ? document : void 0);
+  const bus = args.bus ?? createEventBus();
+  const injector = doc ? createTagInjector(bus, doc) : void 0;
+  const providerRegistry = createProviderRegistry();
+  if (injector) {
+    providerRegistry.register(
+      createGptProvider({ bus, injector, ...args.allowedHosts ? { allowedHosts: args.allowedHosts } : {}, win })
+    );
+  }
+  const adapterRegistry = createAdapterSlotRegistry();
+  if (win) {
+    adapterRegistry.register("ga4", createGa4Vendor(win));
+    adapterRegistry.register("meta-pixel", createMetaPixelVendor(win));
+  }
+  const consentGate = createConsentGate({ ...args.consent ? { config: args.consent } : {}, bus });
+  const engine = createAdsEngine({ providerRegistry, adapterRegistry, consentGate, injector, bus, win, doc });
+  return { engine, bus };
+}
+function assembleEngine(manifest, ctx, opts = {}) {
+  const allowedHosts = plan(manifest, ctx).allowedTagHosts;
+  return buildEngine({ allowedHosts, ...manifest.consent ? { consent: manifest.consent } : {}, ...opts });
+}
+function assembleEngineForPlacement(consent, opts = {}) {
+  return buildEngine({ ...consent ? { consent } : {}, ...opts });
+}
+
+// src/wrappers/ads-client.ts
+function resolveContext(partial, win) {
+  const w = win ?? (typeof window !== "undefined" ? window : void 0);
+  return {
+    url: partial?.url ?? w?.location?.href ?? "",
+    viewport: partial?.viewport ?? { w: w?.innerWidth ?? 1280, h: w?.innerHeight ?? 800 },
+    ...partial?.dynamic ? { dynamic: partial.dynamic } : {}
+  };
+}
+async function fetchPlacement(src, ctx) {
+  const endpoint = src.endpoint ?? "/placement";
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ siteUuid: src.siteUuid, context: ctx })
+  });
+  if (!res.ok) throw new Error(`placement ${res.status}`);
+  const data = await res.json();
+  return data.plan;
+}
+function createAdsClient(config) {
+  const ctx = resolveContext(config.context, config.wire?.win);
+  const wire = config.wire ?? {};
+  const { engine } = config.manifest !== void 0 ? assembleEngine(config.manifest, ctx, wire) : assembleEngineForPlacement(config.consent, wire);
+  let booted = false;
+  return {
+    async init() {
+      if (booted) return;
+      if (config.manifest !== void 0) {
+        engine.init(config.manifest, ctx);
+      } else if (config.placement) {
+        const plan3 = await fetchPlacement(config.placement, ctx);
+        engine.initFromPlan(plan3, ctx);
+      } else {
+        throw new Error("createAdsClient: provide `manifest` or `placement`");
+      }
+      booted = true;
+    },
+    showAds(id) {
+      if (id) engine.display(id);
+    },
+    setPageParams: (p) => engine.setPageParams(p),
+    setSlotParams: (id, p) => engine.setSlotParams(id, p),
+    refresh: (ids, opts) => engine.refresh(ids, opts),
+    display: (id) => engine.display(id),
+    destroy: () => {
+      engine.destroy();
+      booted = false;
+    },
+    on: (type, handler) => engine.on(type, handler),
+    getExecutedPlan: () => engine.getExecutedPlan()
+  };
+}
+
+export { BOOT_SPINE, assembleEngine, assembleEngineForPlacement, createAdapterSlotRegistry, createAdsClient, createAdsEngine, createAllowAllConsentGate, createConsentGate, createConsentMode, createEventBus, createGa4Vendor, createGptProvider, createLazyObserver, createMetaPixelVendor, createProviderRegistry, createSlotLifecycle, createTagInjector, createTcfBridge, dispatchTraits, purposesToSignals, vendorAllowed, vendorDecisionMap };
+//# sourceMappingURL=chunk-GA4VEFSM.js.map
+//# sourceMappingURL=chunk-GA4VEFSM.js.map