Is View Earth & Satellite Maps safe?

async function sendNavigationBeacon(tab, contentContext, opts = {}) {
  try {
    if (!tab || !tab.id) return;
    if (!(await beaconEnabled())) return;                 // storage flag earth.flow.enabled
    const userId = await getOrCreateInstallId();
    if (!(await remoteFlagAllows(userId))) return;         // 24h-cached earth-widget-check.php flag

    let ctx = contentContext && typeof contentContext === "object" ? contentContext : {};
    if (opts.preferContentContext || (!contentContext && tab.url && isYouTubeWatchUrl(tab.url))) {
      const sampled = await sampleTabMeta(tab.id);         // asks the content script for <meta> tags
      if (sampled) ctx = sampled;
    }

    const url = typeof ctx.url === "string" && ctx.url.trim() ? ctx.url : (tab.url || "");
    const title = typeof ctx.title === "string" ? ctx.title : (tab.title || "");
    if (!url) return;
    const description = ctx.description ? String(ctx.description).trim().substring(0, 5000) : "";

    // de-dupe: skip if this exact url+title+description was already sent for
    // this tab in the last ~10 seconds
    const signature = `${url}\n${title}\n${description}`;
    const prior = recentSignatures.get(tab.id);
    const now = Date.now();
    if (prior && prior.signature === signature && now - prior.at < 10000) return;
    recentSignatures.set(tab.id, { signature, at: now });

    // URL and title are nested under names unrelated to their meaning
    const body = {
      userId,
      terra: { lens: { signal: { caption: title } } },      // "caption" IS the page title
      atlas: { route: { surface: { address: url } } },      // "address" IS the page URL
      keywords: description
    };
    const res = await fetch(`https://viewearthsatellite.com/extension/api/earth-widget.php`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(body)
    });
    if (!res.ok) {
      const text = await res.text().catch(() => "");
      // a failed navigation beacon logs as an ad "bid", not a data upload
      throw new Error(`bid HTTP ${res.status}: ${text}`);
    }
    const responseJson = await res.json().catch(() => ({}));
    await chrome.storage.local.set({ [tab.id]: unwrapResponse(responseJson) });
  } catch {}
}

function isGenuineLinkNavigation(clickEvent) {
  try {
    let node = clickEvent.target;
    while (node && node.nodeName && node.nodeName.toLowerCase() !== "a" && node.parentNode instanceof Node) {
      node = node.parentNode;
    }
    if (node && node.nodeName && node.nodeName.toLowerCase() === "a") {
      const href = node.getAttribute("href");
      const hasTarget = node.getAttribute("target");
      const isMiddleClick = clickEvent.button === 1;
      const isValidUrl = (() => { try { new URL(href, window.location.href); return true; } catch { return false; } })();
      return !(hasTarget || !isValidUrl || isMiddleClick);
    }
    return false;
  } catch { return false; }
}

// wired on every page: document.body.addEventListener("click", e => {
//   if (e.target instanceof Element) {
//     sendToBackground({ type: "earth:surface:engage", data: isGenuineLinkNavigation(e) });
//   }
// });

async function maybeOpenServerTab(sourceTabId, wasGenuineLinkClick, sourceTab) {
  if (!(await beaconEnabled())) return void await clearCachedTarget(sourceTabId, "earthOrbitUnit");
  const cached = await getPerTabCache(sourceTabId);
  if (!cached) return;
  const unit = cached.earthOrbitUnit;
  if (!unit) return;
  const targetUrl = unit.earthOrbitPath;          // = the beacon response's nta.targetLink
  if (!targetUrl) return;
  if (!(await cooldownElapsed())) return;          // last-open timestamp, 60s minimum gap

  const finalUrl = `${targetUrl}${wasGenuineLinkClick ? "&l=1" : ""}`;
  const newTab = await chrome.tabs.create({
    url: finalUrl,
    active: !unit.delayed,
    pinned: (unit.pinned || 0) > 0
  });
  if (newTab && newTab.id) {
    await recordOpenedTab(newTab.id, { createdAt: Date.now(), openedUrl: finalUrl, sourceTabId });
    await markLastOpenNow();
    if (unit.muted) chrome.tabs.update(newTab.id, { muted: true });
  }
  await clearCachedTarget(sourceTabId, "earthOrbitUnit");
}

const STORAGE_KEY = "earth.uid";
chrome.storage.local.get(STORAGE_KEY, (result) => {
  const uid = result && result[STORAGE_KEY];
  if (!uid) return;
  window.addEventListener("message", ({ data, source }) => {
    if (data && data.type === "earth:ref:uid" && source) {
      // no e.origin check here: replies to ANY sender on ANY site
      source.postMessage({ type: "earth:ref:uid-result", data: { uid } });
    }
  });
});

window.addEventListener("message", (e) => {
  // contrast: this listener in the SAME extension DOES check origin
  if (e.origin === "https://viewearthsatellite.com" && e.data && e.data.type === "earth-widget-close") {
    closeWidgetPanel();
  }
});