@sonordev/site-kit 6.5.0 → 7.0.0

package/dist/chunk-MZFF5F7R.js

@@ -0,0 +1,407 @@
+import { toHexColor, normalizeDesignTokens, designTokensHash } from './chunk-IHG36STL.js';
+import { contrastRatio, parseColor, relativeLuminance } from './chunk-S22FSH7C.js';
+import { resolveAnalyticsTarget } from './chunk-43OCZ3JA.js';
+import { sonorFetch } from './chunk-4WI3FU5L.js';
+import { SITE_KIT_VERSION } from './chunk-7ZHJIRM3.js';
+
+// src/website/design.ts
+var SITE_DESIGN_PATH = "/api/public/site/design";
+var chroma = (hex) => {
+  const rgb = parseColor(hex);
+  if (!rgb) return 0;
+  return (Math.max(rgb.r, rgb.g, rgb.b) - Math.min(rgb.r, rgb.g, rgb.b)) / 255;
+};
+var lum = (hex) => {
+  const rgb = parseColor(hex);
+  return rgb ? relativeLuminance(rgb) : 1;
+};
+var hexContrast = (a, b) => contrastRatio(lum(a), lum(b));
+function pickAccent(samples, pageBackground) {
+  const tally = /* @__PURE__ */ new Map();
+  for (const s of samples) {
+    const floor = chroma(s.background) > 0.15 ? 1.25 : 1.5;
+    if (hexContrast(s.background, pageBackground) < floor) continue;
+    const entry = tally.get(s.background) ?? { score: 0, first: s };
+    entry.score += chroma(s.background) > 0.15 ? 2 : 1;
+    tally.set(s.background, entry);
+  }
+  let best = null;
+  for (const entry of tally.values()) {
+    if (!best || entry.score > best.score || entry.score === best.score && chroma(entry.first.background) > chroma(best.first.background)) {
+      best = entry;
+    }
+  }
+  return best?.first ?? null;
+}
+function pickLinkAccent(colors, bodyText) {
+  return mode(colors.filter((c) => c !== bodyText && chroma(c) > 0.15));
+}
+var mode = (values) => {
+  const counts = /* @__PURE__ */ new Map();
+  let best = null;
+  for (const v of values) {
+    const n = (counts.get(v) ?? 0) + 1;
+    counts.set(v, n);
+    if (!best || n > (counts.get(best) ?? 0)) best = v;
+  }
+  return best;
+};
+function pickSurface(samples, pageBackground, accent) {
+  const surfaces = samples.map((s) => s.background).filter((bg) => !!bg && bg !== accent && hexContrast(bg, pageBackground) >= 1.02 && hexContrast(bg, pageBackground) < 3);
+  const borders = samples.map((s) => s.border).filter((b) => !!b);
+  const radii = samples.map((s) => s.radius).filter((r) => r && r !== "0px");
+  return { surface: mode(surfaces), border: mode(borders), radius: mode(radii) };
+}
+function cleanFontStack(stack) {
+  const out = [];
+  for (const part of stack.split(",")) {
+    let name = part.trim().replace(/^["']|["']$/g, "");
+    if (!name) continue;
+    if (/^__.+_Fallback_[0-9a-f]{5,}$/i.test(name) || / Fallback$/i.test(name)) continue;
+    const nextFont = name.match(/^__(.+)_[0-9a-f]{5,}$/i);
+    if (nextFont) name = nextFont[1].replace(/_/g, " ");
+    const key = name.toLowerCase();
+    if (out.some((n) => n.replace(/"/g, "").toLowerCase() === key)) continue;
+    out.push(/\s/.test(name) ? `"${name}"` : name);
+  }
+  return out.join(", ");
+}
+var pickDefined = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v != null && v !== ""));
+function mergeDesignReports(declared, measured) {
+  const sections = ["colors", "fonts", "radius", "button"];
+  const merged = {};
+  let usedDeclared = false;
+  let usedMeasured = false;
+  for (const key of sections) {
+    const d = pickDefined(declared[key] ?? {});
+    const m = pickDefined(measured[key] ?? {});
+    if (Object.keys(d).length) usedDeclared = true;
+    if (Object.keys(m).some((k) => !(k in d))) usedMeasured = true;
+    merged[key] = { ...m, ...d };
+  }
+  merged.source = usedDeclared && usedMeasured ? "mixed" : usedDeclared ? "declared" : "measured";
+  return merged;
+}
+var DESIGN_REPORT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+function shouldReportDesign(stamp, hash, now) {
+  if (!stamp) return true;
+  const [lastHash, at] = stamp.split(":");
+  return lastHash !== hash || !(now - Number(at) < DESIGN_REPORT_TTL_MS);
+}
+function tokensForReport(tokens) {
+  return {
+    ...tokens,
+    fonts: { body: cleanFontStack(tokens.fonts.body), heading: cleanFontStack(tokens.fonts.heading) }
+  };
+}
+var colorCtx;
+function colorToHex(value) {
+  if (!value) return null;
+  const direct = toHexColor(value);
+  if (direct) return direct;
+  if (/^(transparent|none)$/i.test(value.trim()) || typeof document === "undefined") return null;
+  if (colorCtx === void 0) {
+    try {
+      const canvas = document.createElement("canvas");
+      canvas.width = canvas.height = 1;
+      colorCtx = canvas.getContext("2d", { willReadFrequently: true });
+    } catch {
+      colorCtx = null;
+    }
+  }
+  const ctx = colorCtx;
+  if (!ctx) return null;
+  try {
+    const sentinel = "#010203";
+    ctx.fillStyle = sentinel;
+    ctx.fillStyle = value;
+    if (ctx.fillStyle === sentinel && value.trim().toLowerCase() !== sentinel) return null;
+    ctx.clearRect(0, 0, 1, 1);
+    ctx.fillRect(0, 0, 1, 1);
+    const [r, g, b, a] = ctx.getImageData(0, 0, 1, 1).data;
+    if (a < 128) return null;
+    return `#${[r, g, b].map((c) => c.toString(16).padStart(2, "0")).join("")}`;
+  } catch {
+    return null;
+  }
+}
+function labelOf(el) {
+  const hasText = (node) => Array.from(node.childNodes).some((c) => c.nodeType === 3 && (c.textContent ?? "").trim());
+  if (hasText(el)) return el;
+  let level = Array.from(el.children);
+  for (let depth = 0; depth < 3 && level.length; depth++) {
+    const found = level.find(hasText);
+    if (found) return found;
+    level = level.flatMap((c) => Array.from(c.children));
+  }
+  return el;
+}
+var OVERLAY = '[role="dialog"],[aria-modal="true"],[data-engage-element],[data-sk-popup]';
+var isVisible = (rect) => rect.width > 0 && rect.height > 0;
+function measureSiteDesign(doc = document, win = window) {
+  const style = (el) => win.getComputedStyle(el);
+  const vw = win.innerWidth;
+  const vh = win.innerHeight;
+  let background = colorToHex(style(doc.body).backgroundColor) ?? colorToHex(style(doc.documentElement).backgroundColor);
+  let node = doc.body;
+  for (let depth = 0; depth < 4; depth++) {
+    const next = Array.from(node.children).find((child) => {
+      if (child.matches(OVERLAY)) return false;
+      const rect = child.getBoundingClientRect();
+      return rect.width >= vw * 0.9 && rect.height >= vh * 1.2;
+    });
+    if (!next) break;
+    background = colorToHex(style(next).backgroundColor) ?? background;
+    node = next;
+  }
+  const pageBackground = background ?? "#ffffff";
+  const root = doc.querySelector("main") ?? doc.body;
+  const chrome = 'header, nav, footer, [role="banner"], [role="contentinfo"]';
+  const sitsOn = (el) => {
+    let cur = el;
+    for (let i = 0; cur && cur !== doc.body && i < 14; i++, cur = cur.parentElement) {
+      const s = style(cur);
+      if (s.backgroundImage && s.backgroundImage !== "none") return null;
+      const fill = colorToHex(s.backgroundColor);
+      if (fill) return fill;
+    }
+    return pageBackground;
+  };
+  const inks = /* @__PURE__ */ new Map();
+  const paragraphs = root.querySelectorAll("p");
+  for (let i = 0, seen = 0; i < paragraphs.length && seen < 80; i++) {
+    const p = paragraphs[i];
+    if (p.closest(chrome) || p.closest(OVERLAY)) continue;
+    const chars = (p.textContent ?? "").trim().length;
+    if (chars < 40 || !isVisible(p.getBoundingClientRect())) continue;
+    const under = sitsOn(p);
+    if (!under || hexContrast(under, pageBackground) >= 1.1) continue;
+    const ink = colorToHex(style(p).color);
+    if (!ink || hexContrast(ink, pageBackground) < 3) continue;
+    seen++;
+    const entry = inks.get(ink) ?? { chars: 0, el: p };
+    entry.chars += chars;
+    inks.set(ink, entry);
+  }
+  let paragraph;
+  let most = 0;
+  for (const entry of inks.values()) if (entry.chars > most) most = entry.chars, paragraph = entry.el;
+  const bodyStyle = style(paragraph ?? doc.body);
+  const heading = Array.from(doc.querySelectorAll("h1, h2")).find(
+    (h) => !h.closest(OVERLAY) && isVisible(h.getBoundingClientRect())
+  );
+  const buttons = [];
+  const linkColors = [];
+  const candidates = doc.querySelectorAll('a, button, [role="button"], input[type="submit"]');
+  for (let i = 0; i < candidates.length && i < 400 && buttons.length < 40; i++) {
+    const el = candidates[i];
+    if (el.closest(OVERLAY)) continue;
+    const rect = el.getBoundingClientRect();
+    if (!isVisible(rect) || rect.width < 60 || rect.height < 28 || rect.height > 64) continue;
+    const s = style(el);
+    if (s.visibility === "hidden" || parseFloat(s.opacity) < 0.5) continue;
+    const fill = s.backgroundImage && s.backgroundImage !== "none" ? null : colorToHex(s.backgroundColor);
+    if (!fill) {
+      const outlined = parseFloat(s.borderTopWidth) >= 1 && s.borderTopStyle !== "none";
+      const emphatic = s.textTransform === "uppercase" || Number(s.fontWeight) >= 600;
+      const ink = outlined ? colorToHex(s.borderTopColor) : emphatic ? colorToHex(s.color) : null;
+      if (ink) linkColors.push(ink);
+      continue;
+    }
+    const label = labelOf(el);
+    const ls = label === el ? s : style(label);
+    buttons.push({
+      background: fill,
+      color: colorToHex(ls.color),
+      radius: s.borderTopLeftRadius,
+      textTransform: ls.textTransform,
+      fontWeight: ls.fontWeight
+    });
+  }
+  const accent = pickAccent(buttons, pageBackground);
+  const bodyText = colorToHex(bodyStyle.color);
+  let primary = accent?.background ?? pickLinkAccent(linkColors, bodyText);
+  if (!primary && paragraph) {
+    const link = paragraph.querySelector("a") ?? root.querySelector("p a");
+    const linkColor = link ? colorToHex(style(link).color) : null;
+    if (linkColor && linkColor !== bodyText) primary = linkColor;
+  }
+  const cards = [];
+  const boxes = root.querySelectorAll("article, li, div, section, aside");
+  for (let i = 0; i < boxes.length && i < 1500 && cards.length < 40; i++) {
+    const el = boxes[i];
+    if (el.closest(OVERLAY) || el.closest(chrome)) continue;
+    const rect = el.getBoundingClientRect();
+    if (rect.width < 160 || rect.width > vw * 0.8 || rect.height < 80) continue;
+    const s = style(el);
+    const fill = colorToHex(s.backgroundColor);
+    const bordered = parseFloat(s.borderTopWidth) >= 1 && s.borderTopStyle !== "none";
+    const border = bordered ? colorToHex(s.borderTopColor) : null;
+    if (!fill && !border) continue;
+    if (fill && hexContrast(fill, pageBackground) < 1.02 && !border) continue;
+    cards.push({ background: fill, border, radius: s.borderTopLeftRadius });
+  }
+  const surface = pickSurface(cards, pageBackground, primary);
+  return {
+    colors: {
+      background: pageBackground,
+      text: bodyText ?? void 0,
+      primary: primary ?? void 0,
+      // The button's own color only when it reads on the fill (a label in a
+      // child span leaves the anchor's inherited color behind).
+      onPrimary: accent?.color && hexContrast(accent.color, accent.background) >= 4.5 ? accent.color : void 0,
+      surface: surface.surface ?? void 0,
+      border: surface.border ?? void 0
+    },
+    fonts: {
+      body: bodyStyle.fontFamily || void 0,
+      heading: heading ? style(heading).fontFamily : void 0
+    },
+    radius: {
+      control: accent?.radius || void 0,
+      card: surface.radius ?? void 0
+    },
+    button: accent ? { textTransform: accent.textTransform === "uppercase" ? "uppercase" : "none", fontWeight: accent.fontWeight } : void 0,
+    source: "measured"
+  };
+}
+function readDeclaredDesign(overrides = {}, doc = document, win = window) {
+  const rootStyle = win.getComputedStyle(doc.documentElement);
+  const cssVar = (name) => rootStyle.getPropertyValue(name).trim() ? `var(${name})` : void 0;
+  const pick = (override, ...vars) => override != null && override !== "" ? String(override) : vars.map(cssVar).find(Boolean);
+  const wanted = {
+    background: pick(overrides.background, "--sk-bg"),
+    surface: pick(overrides.surface, "--sk-surface", "--sk-bg-elevated"),
+    text: pick(overrides.text, "--sk-text-primary", "--sk-text"),
+    muted: pick(overrides.muted, "--sk-text-secondary"),
+    primary: pick(overrides.primary, "--sk-primary"),
+    onPrimary: pick(overrides.onPrimary, "--sk-on-primary"),
+    border: pick(overrides.border, "--sk-border"),
+    fontBody: pick(overrides.fontBody, "--sk-font"),
+    fontHeading: pick(overrides.fontHeading, "--sk-font-heading"),
+    radiusControl: pick(overrides.radiusControl, "--sk-radius-sm", "--sk-radius"),
+    radiusCard: pick(overrides.radiusCard, "--sk-radius-lg", "--sk-radius")
+  };
+  if (!Object.values(wanted).some(Boolean) && !overrides.buttonTextTransform && !overrides.buttonFontWeight) return {};
+  const wrap = doc.createElement("div");
+  wrap.setAttribute("aria-hidden", "true");
+  wrap.style.cssText = "position:absolute;visibility:hidden;pointer-events:none;width:0;height:0;overflow:hidden;color:rgb(1, 2, 3);font-family:sk-unset";
+  const probe = doc.createElement("div");
+  wrap.appendChild(probe);
+  doc.body.appendChild(wrap);
+  const color = (value) => {
+    if (!value) return void 0;
+    probe.style.color = "";
+    probe.style.color = value;
+    const computed = win.getComputedStyle(probe).color;
+    return computed === "rgb(1, 2, 3)" ? void 0 : colorToHex(computed) ?? void 0;
+  };
+  const font = (value) => {
+    if (!value) return void 0;
+    probe.style.fontFamily = value;
+    const computed = win.getComputedStyle(probe).fontFamily;
+    return computed && computed !== "sk-unset" ? computed : void 0;
+  };
+  const radius = (value) => {
+    if (!value) return void 0;
+    probe.style.borderTopLeftRadius = value;
+    return win.getComputedStyle(probe).borderTopLeftRadius || void 0;
+  };
+  try {
+    return {
+      colors: {
+        background: color(wanted.background),
+        surface: color(wanted.surface),
+        text: color(wanted.text),
+        muted: color(wanted.muted),
+        primary: color(wanted.primary),
+        onPrimary: color(wanted.onPrimary),
+        border: color(wanted.border)
+      },
+      fonts: { body: font(wanted.fontBody), heading: font(wanted.fontHeading) },
+      radius: { control: radius(wanted.radiusControl), card: radius(wanted.radiusCard) },
+      button: {
+        textTransform: overrides.buttonTextTransform,
+        fontWeight: overrides.buttonFontWeight != null ? String(overrides.buttonFontWeight) : void 0
+      },
+      source: "declared"
+    };
+  } finally {
+    wrap.remove();
+  }
+}
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var cacheKey = (site) => `_sk_design:${site}`;
+function readCache(site) {
+  try {
+    const raw = localStorage.getItem(cacheKey(site));
+    if (!raw) return null;
+    const cached = JSON.parse(raw);
+    if (cached.v !== SITE_KIT_VERSION || !(Date.now() - cached.at < CACHE_TTL_MS)) return null;
+    const tokens = normalizeDesignTokens(cached.tokens);
+    return tokens ? { ...cached, tokens } : null;
+  } catch {
+    return null;
+  }
+}
+function writeCache(site, entry) {
+  try {
+    localStorage.setItem(cacheKey(site), JSON.stringify(entry));
+  } catch {
+  }
+}
+function declaredSiteDesign() {
+  return typeof window === "undefined" ? void 0 : window.__SITE_KIT_DESIGN__;
+}
+function getSiteDesignTokens(options = {}) {
+  if (typeof window === "undefined" || typeof document === "undefined") return null;
+  const published = declaredSiteDesign();
+  if (published === false) return null;
+  const overrides = options.overrides ?? published ?? {};
+  const { report: _report, ...declaredOnly } = overrides;
+  const declared = JSON.stringify(declaredOnly);
+  const site = options.site || window.location.host;
+  const path = window.location.pathname || "/";
+  const cached = readCache(site);
+  if (cached && cached.declared === declared && (!options.requirePath || cached.path === options.requirePath)) {
+    return cached.tokens;
+  }
+  if (options.requirePath && path !== options.requirePath) return null;
+  let tokens = null;
+  try {
+    tokens = normalizeDesignTokens(mergeDesignReports(readDeclaredDesign(declaredOnly), measureSiteDesign()));
+  } catch {
+    tokens = null;
+  }
+  if (tokens) writeCache(site, { v: SITE_KIT_VERSION, at: Date.now(), path, declared, tokens });
+  return tokens;
+}
+async function sendSiteDesign(opts) {
+  const target = resolveAnalyticsTarget(opts);
+  if (!target) return false;
+  const tokens = tokensForReport(opts.tokens);
+  try {
+    const res = await sonorFetch(
+      `${target.apiUrl.replace(/\/$/, "")}${SITE_DESIGN_PATH}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          site: opts.site,
+          path: opts.path ?? "/",
+          tokens,
+          hash: designTokensHash(tokens),
+          kit_version: SITE_KIT_VERSION
+        })
+      },
+      { apiKey: target.apiKey, retries: 0 }
+    );
+    if (opts.debug) console.info(`[Sonor design] report ${res.status} (${tokens.source})`);
+    return res.ok;
+  } catch (err) {
+    if (opts.debug) console.info("[Sonor design] report skipped (network)", err);
+    return false;
+  }
+}
+
+export { SITE_DESIGN_PATH, cleanFontStack, colorToHex, getSiteDesignTokens, measureSiteDesign, readDeclaredDesign, sendSiteDesign, shouldReportDesign, tokensForReport };

package/dist/chunk-N2UVOR3X.js

@@ -0,0 +1,238 @@
+import { withSiteBody } from './chunk-MJP63SSS.js';
+import { serverApiFetch, requireServerApiConfig } from './chunk-X6F6SO4S.js';
+import { postRegisterSitemap, resolveSyncSite } from './chunk-DIKNRN34.js';
+import { cache } from 'react';
+import 'server-only';
+
+// src/seo/schema-filter.ts
+function typesOf(node) {
+  const t = node["@type"];
+  return Array.isArray(t) ? t.filter((x) => typeof x === "string") : typeof t === "string" ? [t] : [];
+}
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isEmptyNode(node) {
+  const keys = Object.keys(node).filter((k) => k !== "@context");
+  if (!keys.length) return true;
+  return keys.length === 1 && keys[0] === "@graph" && Array.isArray(node["@graph"]) && node["@graph"].length === 0;
+}
+function pruneSchemaTypes(value, deny) {
+  if (!deny.size) return value;
+  if (Array.isArray(value)) {
+    const kept = value.map((v) => pruneSchemaTypes(v, deny)).filter((v) => v !== null);
+    return kept;
+  }
+  if (!isPlainObject(value)) return value;
+  if (typesOf(value).some((t) => deny.has(t))) return null;
+  const out = {};
+  for (const [key, child] of Object.entries(value)) {
+    const next = pruneSchemaTypes(child, deny);
+    if (next === null) continue;
+    if (Array.isArray(next) && next.length === 0 && Array.isArray(child) && child.length > 0 && key !== "@graph") {
+      continue;
+    }
+    out[key] = next;
+  }
+  return isEmptyNode(out) && !isEmptyNode(value) ? null : out;
+}
+function filterSchemaRows(rows, { includeTypes, excludeTypes } = {}) {
+  let out = rows;
+  if (includeTypes?.length) {
+    const allow = new Set(includeTypes);
+    out = out.filter((r) => r?.schema_type && allow.has(r.schema_type));
+  }
+  if (excludeTypes?.length) {
+    const deny = new Set(excludeTypes);
+    out = out.flatMap((r) => {
+      if (r?.schema_type && deny.has(r.schema_type)) return [];
+      if (r?.schema_json === void 0) return [r];
+      const json = pruneSchemaTypes(r.schema_json, deny);
+      return json === null ? [] : [{ ...r, schema_json: json }];
+    });
+  }
+  return out;
+}
+
+// src/seo/server-api.ts
+var SEO_LOG_PREFIX = "@sonordev/seo";
+function getSecureApiConfig() {
+  return requireServerApiConfig(
+    {},
+    "@sonordev/seo: SONOR_API_KEY environment variable is required for server-side SEO functions"
+  );
+}
+function getProjectIdFromKey(apiKey) {
+  const match = apiKey.match(/^sonor_([0-9a-f-]{36})_/);
+  return match ? match[1] : null;
+}
+function secureApiPost(endpoint, body = {}, revalidate = 86400) {
+  return serverApiFetch(endpoint, {
+    method: "POST",
+    body,
+    revalidate,
+    requireKey: true,
+    retry: true,
+    logPrefix: SEO_LOG_PREFIX
+  });
+}
+var loadPageSeoContext = cache(async (path) => {
+  const result = await secureApiPost("/api/public/seo/page-context", { path });
+  if (!result) return null;
+  return {
+    page: result.page ?? null,
+    schemas: Array.isArray(result.schemas) ? result.schemas : [],
+    project: result.project ?? null
+  };
+});
+var getSEOPageData = cache(async (path) => {
+  const ctx = await loadPageSeoContext(path);
+  return {
+    page: ctx?.page ?? null,
+    project: ctx?.project ?? null
+  };
+});
+var getSchemaMarkups = cache(async (path, options) => {
+  const ctx = await loadPageSeoContext(path);
+  return filterSchemaRows(ctx?.schemas ?? [], options);
+});
+var getFAQData = cache(async (path, site) => {
+  const result = await secureApiPost("/api/public/seo/faq", withSiteBody({ path }, site));
+  return result?.faq || null;
+});
+var getInternalLinks = cache(async (sourcePath, options) => {
+  const result = await secureApiPost(
+    "/api/public/seo/internal-links",
+    withSiteBody(
+      {
+        sourcePath,
+        position: options?.position,
+        limit: options?.limit
+      },
+      options?.site
+    )
+  );
+  return result?.links || [];
+});
+var getContentBlock = cache(async (path, section, site) => {
+  const result = await secureApiPost("/api/public/seo/content", withSiteBody({ path, section }, site));
+  return result?.content || null;
+});
+var getABTest = cache(async (path, field) => {
+  const result = await secureApiPost("/api/public/seo/ab-test", { path, field });
+  return result?.test || null;
+});
+async function recordABImpression(testId, variant, sessionId) {
+  await secureApiPost("/api/public/seo/ab-impression", { testId, variant, sessionId });
+}
+var getRedirectData = cache(async (path) => {
+  const result = await secureApiPost("/api/public/seo/redirect", { path });
+  return result?.redirect || null;
+});
+var getManagedScripts = cache(async (position, currentPath) => {
+  const result = await secureApiPost("/api/public/seo/scripts", {
+    position,
+    currentPath
+  });
+  return result?.scripts || [];
+});
+var getRobotsData = cache(async (path) => {
+  const { page } = await getSEOPageData(path);
+  return page?.managed_robots || null;
+});
+var getSitemapEntries = cache(async (options) => {
+  const result = await secureApiPost("/api/public/seo/sitemap", {
+    publishedOnly: options?.publishedOnly
+  });
+  return result?.entries || [];
+});
+async function registerSitemap(entries, options) {
+  const { apiUrl, apiKey } = getSecureApiConfig();
+  const mode = options?.mode ?? "full-replace";
+  try {
+    const response = await postRegisterSitemap({ apiUrl, apiKey, entries, mode, site: resolveSyncSite(options?.site) });
+    if (!response.ok) {
+      console.error(`@sonordev/seo: Sitemap registration failed: ${response.statusText}`);
+      return { success: false, created: 0, updated: 0 };
+    }
+    return await response.json();
+  } catch (error) {
+    console.error("@sonordev/seo: Sitemap registration error:", error);
+    return { success: false, created: 0, updated: 0 };
+  }
+}
+var ensureMetadata = cache(async (path) => {
+  return secureApiPost("/api/public/seo/ensure-metadata", { path });
+});
+function getSignalApiConfig() {
+  const apiUrl = process.env.SONOR_SIGNAL_URL || process.env.SIGNAL_API_URL || process.env.NEXT_PUBLIC_SIGNAL_API_URL || "https://signal.sonor.io";
+  const apiKey = process.env.SONOR_API_KEY || "";
+  return { apiUrl, apiKey };
+}
+async function signalApiGet(endpoint) {
+  const { apiUrl, apiKey } = getSignalApiConfig();
+  if (!apiKey) {
+    return null;
+  }
+  try {
+    const response = await fetch(`${apiUrl}${endpoint}`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      next: { revalidate: 300 }
+      // Cache for 5 minutes
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const result = await response.json();
+    return result?.data || result;
+  } catch (error) {
+    console.error("@sonordev/seo: Signal API error:", error);
+    return null;
+  }
+}
+var getEntities = cache(async (options) => {
+  const { apiKey } = getSecureApiConfig();
+  const projectId = getProjectIdFromKey(apiKey);
+  if (!projectId) return [];
+  let endpoint = `/skills/seo/entities/${projectId}`;
+  if (options?.type) {
+    endpoint += `?type=${options.type}`;
+  }
+  const result = await signalApiGet(endpoint);
+  return result || [];
+});
+var getPrimaryEntity = cache(async () => {
+  const { apiKey } = getSecureApiConfig();
+  const projectId = getProjectIdFromKey(apiKey);
+  if (!projectId) return null;
+  return signalApiGet(`/skills/seo/entities/${projectId}/primary`);
+});
+var getEntityEnhancedSchema = cache(async (pagePath) => {
+  const { apiKey } = getSecureApiConfig();
+  const projectId = getProjectIdFromKey(apiKey);
+  if (!projectId) return [];
+  const result = await signalApiGet(
+    `/skills/seo/schema/${projectId}/entity-enhanced?pagePath=${encodeURIComponent(pagePath)}`
+  );
+  return result?.schemas || [];
+});
+var getVisibilityScore = cache(async (pagePath) => {
+  const { apiKey } = getSecureApiConfig();
+  const projectId = getProjectIdFromKey(apiKey);
+  if (!projectId) return null;
+  const result = await signalApiGet(`/skills/seo/visibility/${projectId}`);
+  if (!result) return null;
+  return result.find((s) => s.page_path === pagePath) || null;
+});
+var getVisibilitySummary = cache(async () => {
+  const { apiKey } = getSecureApiConfig();
+  const projectId = getProjectIdFromKey(apiKey);
+  if (!projectId) return null;
+  return signalApiGet(`/skills/seo/visibility/${projectId}/summary`);
+});
+
+export { ensureMetadata, getABTest, getContentBlock, getEntities, getEntityEnhancedSchema, getFAQData, getInternalLinks, getManagedScripts, getPrimaryEntity, getRedirectData, getRobotsData, getSEOPageData, getSchemaMarkups, getSitemapEntries, getVisibilityScore, getVisibilitySummary, pruneSchemaTypes, recordABImpression, registerSitemap };

package/dist/chunk-NDF4A5JM.js

@@ -0,0 +1,37 @@
+import { VISUAL_VIEWPORT_GAP_PROPERTY } from './chunk-6T6CQVNL.js';
+
+// src/engage/launcher-placement.ts
+var DEFAULT_LAUNCHER_OFFSET_BOTTOM = "20px";
+var DEFAULT_ENGAGE_Z_INDEX = 9999;
+var LAUNCHER_OFFSET_PROPERTY = "--sk-echo-offset-bottom";
+var SIDE_GUTTER = "20px";
+var POPUP_ABOVE_LAUNCHER = "70px";
+var POPUP_VERTICAL_RESERVE = "100px";
+function toCssLength(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? `${value}px` : void 0;
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function chatLauncherStyles({ position, offsetBottom, zIndex } = {}) {
+  const side = position === "bottom-left" ? { left: SIDE_GUTTER } : { right: SIDE_GUTTER };
+  const offset = toCssLength(offsetBottom) ?? DEFAULT_LAUNCHER_OFFSET_BOTTOM;
+  const layer = typeof zIndex === "number" && Number.isFinite(zIndex) ? zIndex : DEFAULT_ENGAGE_Z_INDEX;
+  const clearance = `var(${LAUNCHER_OFFSET_PROPERTY}, ${offset}) + env(safe-area-inset-bottom, 0px) + var(${VISUAL_VIEWPORT_GAP_PROPERTY}, 0px)`;
+  return {
+    launcher: {
+      ...side,
+      bottom: `calc(${clearance})`
+    },
+    popup: {
+      ...side,
+      bottom: `calc(${clearance} + ${POPUP_ABOVE_LAUNCHER})`,
+      maxHeight: `calc(100dvh - (${clearance}) - ${POPUP_VERTICAL_RESERVE})`
+    },
+    // One beneath the launcher. At 0 or below, the same layer instead: -1
+    // would paint the popup behind the page's own content, and at a shared
+    // layer the launcher, which renders after the popup, still paints on top.
+    zIndex: { launcher: layer, popup: layer > 0 ? layer - 1 : layer }
+  };
+}
+
+export { DEFAULT_ENGAGE_Z_INDEX, DEFAULT_LAUNCHER_OFFSET_BOTTOM, chatLauncherStyles };