@sonordev/site-kit 6.5.0 → 7.0.1

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 };

package/dist/chunk-NJCTQH2P.js

@@ -0,0 +1,62 @@
+// src/contracts/forms.ts
+var FORMS_HONEYPOT_CONTRACT_VERSION = 1;
+var DEFAULT_HONEYPOT_FIELD = "_sk_hp_url";
+var GENERIC_HONEYPOT_FIELDS = Object.freeze([
+  DEFAULT_HONEYPOT_FIELD,
+  "website",
+  "_hp_field",
+  "bot-field",
+  "bot_field"
+]);
+function resolveHoneypotFieldNames(opts) {
+  const names = /* @__PURE__ */ new Set();
+  if (!opts.enabled) return names;
+  const real = new Set(opts.realFieldSlugs ?? []);
+  for (const generic of GENERIC_HONEYPOT_FIELDS) {
+    if (!real.has(generic)) names.add(generic);
+  }
+  if (opts.formHoneypotField) names.add(opts.formHoneypotField);
+  return names;
+}
+function isTrapFilled(value) {
+  if (value == null) return false;
+  if (typeof value === "string") return value.trim() !== "";
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) && value !== 0;
+  if (Array.isArray(value)) return value.length > 0;
+  return true;
+}
+function findTrippedTrap(data, fieldNames) {
+  for (const field of fieldNames) {
+    const value = data?.[field];
+    if (!isTrapFilled(value)) continue;
+    if (Array.isArray(value)) return { field, valueType: "array", length: value.length };
+    const valueType = typeof value;
+    return {
+      field,
+      valueType: valueType === "string" ? "string" : valueType,
+      length: typeof value === "string" ? value.length : null
+    };
+  }
+  return null;
+}
+function isHoneypotTriggered(data, fieldNames) {
+  return findTrippedTrap(data, fieldNames) !== null;
+}
+var HONEYPOT_CONFIG_JSON_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://sonor.io/schemas/honeypot-config.v1.json",
+  title: "HoneypotConfig",
+  description: "The honeypot slice of a public managed-form config.",
+  type: "object",
+  properties: {
+    honeypot_enabled: { type: "boolean" },
+    honeypot_field: {
+      description: `Trap field name; defaults to "${DEFAULT_HONEYPOT_FIELD}" when unset.`,
+      type: "string"
+    }
+  },
+  additionalProperties: true
+};
+
+export { DEFAULT_HONEYPOT_FIELD, FORMS_HONEYPOT_CONTRACT_VERSION, GENERIC_HONEYPOT_FIELDS, HONEYPOT_CONFIG_JSON_SCHEMA, findTrippedTrap, isHoneypotTriggered, resolveHoneypotFieldNames };

package/dist/chunk-NZOJHERI.js

@@ -0,0 +1,32 @@
+import { normalizeSiteHost } from './chunk-A4CC4ZG3.js';
+
+// src/contracts/sites.ts
+var SITE_HOST_CONTRACT_VERSION = 1;
+function stripWww(host) {
+  return host.startsWith("www.") ? host.slice(4) : host;
+}
+function sameSite(a, b) {
+  if (!a || !b) return false;
+  return stripWww(a) === stripWww(b);
+}
+function hostFromUrl(value) {
+  if (!value || !value.startsWith("http://") && !value.startsWith("https://")) return null;
+  try {
+    return normalizeSiteHost(new URL(value).host);
+  } catch {
+    return null;
+  }
+}
+function isNormalizedSiteHost(value) {
+  return typeof value === "string" && value.length > 0 && normalizeSiteHost(value) === value;
+}
+var SITE_HOST_JSON_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://sonor.io/schemas/site-host.v1.json",
+  title: "NormalizedSiteHost",
+  description: "A normalized sub-site host (the multi-site `site` dimension): lowercase, no protocol, no path, no port. null denotes a project-wide (unattributed) row.",
+  type: ["string", "null"],
+  pattern: "^[a-z0-9.-]+$"
+};
+
+export { SITE_HOST_CONTRACT_VERSION, SITE_HOST_JSON_SCHEMA, hostFromUrl, isNormalizedSiteHost, sameSite, stripWww };

package/dist/chunk-OFOAHPUV.js

@@ -0,0 +1,127 @@
+import { resolveFetch } from './chunk-VX5CMNMM.js';
+import { monotonicMs } from './chunk-MH2DSGC6.js';
+import { SITE_KIT_VERSION } from './chunk-QGHSMJKW.js';
+import 'server-only';
+
+var MINT_PATH = "/api/public/site-token";
+var MINT_TIMEOUT_MS = 4e3;
+var SITE_TOKEN_PREFIX = "st1.";
+var MINT_MAX_ATTEMPTS = 4;
+var MINT_BACKOFF_BASE_MS = 500;
+var MINT_BACKOFF_CAP_MS = 8e3;
+var cache = /* @__PURE__ */ new Map();
+var inflight = /* @__PURE__ */ new Map();
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function retryDelayMs(res, attempt) {
+  const header = res?.headers?.get?.("retry-after");
+  if (header) {
+    const seconds = Number(header);
+    const ms = Number.isFinite(seconds) ? seconds * 1e3 : NaN;
+    if (Number.isFinite(ms) && ms > 0) return Math.min(ms, MINT_BACKOFF_CAP_MS);
+  }
+  return Math.min(MINT_BACKOFF_BASE_MS * 2 ** attempt, MINT_BACKOFF_CAP_MS);
+}
+var isRetryableStatus = (status) => status === 429 || status >= 500;
+function rawFallbackAllowed() {
+  return typeof process !== "undefined" && process.env?.SONOR_SITE_TOKEN_FALLBACK === "raw";
+}
+function failClosed(reason, rawKey, now) {
+  if (rawFallbackAllowed()) {
+    console.warn(
+      `[SiteKitLayout] Token mint failed (${reason}) and SONOR_SITE_TOKEN_FALLBACK=raw is set; injecting the RAW API KEY into page HTML. The key is publicly readable wherever this page is served \u2014 unset the escape hatch once the mint is healthy.`
+    );
+    cache.set(rawKey, { credential: rawKey, expiresAt: now + 6e4 });
+    return rawKey;
+  }
+  throw new Error(
+    `site-kit: could not mint a site token (${reason}). Refusing to publish the raw SONOR_API_KEY in page HTML, so this build fails instead. Check that the mint endpoint is reachable and the key is valid, then rebuild. To ship anyway \u2014 which publishes the project secret in public HTML \u2014 set SONOR_SITE_TOKEN_FALLBACK=raw.`
+  );
+}
+function isFrameworkSignal(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e.digest === "DYNAMIC_SERVER_USAGE") return true;
+  if (e.code === "NEXT_STATIC_GEN_BAILOUT") return true;
+  if (typeof e.digest === "string" && e.digest.startsWith("NEXT_")) return true;
+  if (e.$$typeof === /* @__PURE__ */ Symbol.for("react.postpone")) return true;
+  return false;
+}
+async function resolveClientCredential(rawKey, apiUrl) {
+  if (!rawKey) return "";
+  if (rawKey.startsWith(SITE_TOKEN_PREFIX)) return rawKey;
+  const cached = cache.get(rawKey);
+  if (cached && cached.expiresAt > monotonicMs()) return cached.credential;
+  const pending = inflight.get(rawKey);
+  if (pending) return pending;
+  const request = mintWithRetry(rawKey, apiUrl);
+  inflight.set(rawKey, request);
+  try {
+    return await request;
+  } finally {
+    inflight.delete(rawKey);
+  }
+}
+async function mintWithRetry(rawKey, apiUrl) {
+  const base = (apiUrl || "https://api.sonor.io").replace(/\/+$/, "");
+  let lastReason = "unknown error";
+  for (let attempt = 0; attempt < MINT_MAX_ATTEMPTS; attempt++) {
+    let res = null;
+    try {
+      const { fn: fetchFn, unpatched } = resolveFetch();
+      res = await fetchFn(`${base}${MINT_PATH}`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-api-key": rawKey,
+          "x-sitekit-version": SITE_KIT_VERSION
+        },
+        // Only meaningful on the fallback path, where a future Next stopped
+        // exposing `_nextOriginalFetch` and we're back on the patched fetch.
+        // `revalidate: false` is the one setting that neither bails out of static
+        // generation nor downgrades the route to ISR; a Data Cache entry is the
+        // lesser evil versus shipping the raw key again.
+        ...unpatched ? {} : { next: { revalidate: false } },
+        signal: typeof AbortSignal !== "undefined" && AbortSignal.timeout ? AbortSignal.timeout(MINT_TIMEOUT_MS) : void 0
+      });
+    } catch (err) {
+      if (isFrameworkSignal(err)) throw err;
+      lastReason = err instanceof Error ? err.message : "network error";
+      if (attempt < MINT_MAX_ATTEMPTS - 1) {
+        await sleep(retryDelayMs(null, attempt));
+        continue;
+      }
+      break;
+    }
+    if (res.ok) {
+      const data = await res.json().catch(() => null);
+      const token = data?.token;
+      const expiresIn = typeof data?.expiresIn === "number" ? data.expiresIn : 3600;
+      if (typeof token === "string" && token.startsWith(SITE_TOKEN_PREFIX)) {
+        cache.set(rawKey, {
+          credential: token,
+          expiresAt: monotonicMs() + Math.min(expiresIn * 1e3 / 2, 30 * 6e4)
+        });
+        return token;
+      }
+      lastReason = "mint returned no usable token";
+      break;
+    }
+    if (res.status === 404) {
+      cache.set(rawKey, { credential: rawKey, expiresAt: monotonicMs() + 6e4 });
+      return rawKey;
+    }
+    lastReason = `HTTP ${res.status}`;
+    if (isRetryableStatus(res.status) && attempt < MINT_MAX_ATTEMPTS - 1) {
+      const delay = retryDelayMs(res, attempt);
+      console.warn(
+        `[SiteKitLayout] Token mint returned ${res.status}; retrying in ${Math.round(delay)}ms (attempt ${attempt + 2}/${MINT_MAX_ATTEMPTS}).`
+      );
+      await sleep(delay);
+      continue;
+    }
+    break;
+  }
+  return failClosed(lastReason, rawKey, monotonicMs());
+}
+
+export { resolveClientCredential };

package/dist/chunk-OPRBF7VE.js

@@ -0,0 +1,41 @@
+import { HoneypotField } from './chunk-DXO6SBMD.js';
+import { FormField } from './chunk-QPEEKFCA.js';
+import { normalizeFormConfig } from './chunk-5SQK3D53.js';
+import { DEFAULT_HONEYPOT_FIELD } from './chunk-NJCTQH2P.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+function visibleStaticFields(config) {
+  const all = config.fields || [];
+  if (!config.is_multi_step) return all;
+  const firstStepId = config.steps?.[0]?.id;
+  return all.filter((f) => !f.step_id || f.step_id === firstStepId);
+}
+function StaticForm({ config: raw, className }) {
+  if (!raw) return null;
+  const config = normalizeFormConfig(raw);
+  const fields = visibleStaticFields(config);
+  const honeypotFieldName = config.honeypot_field || DEFAULT_HONEYPOT_FIELD;
+  return /* @__PURE__ */ jsxs(
+    "form",
+    {
+      "data-sk-state": "idle",
+      "data-sk-mount": "shell",
+      className: `sk-form ${className || ""}`,
+      method: "post",
+      children: [
+        /* @__PURE__ */ jsx("div", { className: "sk-form__step", children: /* @__PURE__ */ jsx("div", { className: "sk-form__fields", children: fields.map((field) => /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: `sk-form__field-wrapper sk-form__field-wrapper--${field.width || "full"}`,
+            children: /* @__PURE__ */ jsx(FormField, { field, value: field.default_value ?? "" })
+          },
+          field.id || field.slug
+        )) }) }),
+        /* @__PURE__ */ jsx("div", { className: "sk-form__actions", style: { justifyContent: "flex-end" }, children: /* @__PURE__ */ jsx("button", { type: "submit", className: "sk-form__btn sk-form__btn--submit", children: config.submit_button_text || "Submit" }) }),
+        config.honeypot_enabled && /* @__PURE__ */ jsx(HoneypotField, { name: honeypotFieldName })
+      ]
+    }
+  );
+}
+
+export { StaticForm };

package/dist/chunk-OSYCOC3K.js

@@ -0,0 +1,21 @@
+// src/landing/contract.ts
+function normalizeCampaignSlug(input) {
+  if (!input || typeof input !== "string") return null;
+  const slug = input.trim().toLowerCase().replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+  return slug || null;
+}
+
+// src/landing/metadata.ts
+function landingPageMetadata(meta = {}) {
+  const callerRobots = meta.robots && typeof meta.robots === "object" ? meta.robots : void 0;
+  return {
+    ...meta,
+    robots: {
+      index: false,
+      follow: false,
+      ...callerRobots
+    }
+  };
+}
+
+export { landingPageMetadata, normalizeCampaignSlug };

package/dist/chunk-P4GRY6QP.js

@@ -0,0 +1,54 @@
+'use client';
+import { getSiteDesignTokens, tokensForReport, shouldReportDesign, sendSiteDesign } from './chunk-FL4EPUWA.js';
+import { designTokensHash } from './chunk-IHG36STL.js';
+import { useDeferredActivation } from './chunk-YC7ELZS3.js';
+import { resolveAnalyticsTarget } from './chunk-43OCZ3JA.js';
+import { useRef, useEffect } from 'react';
+
+var STAMP_KEY = (site) => `_sk_design_sent:${site}`;
+function SiteDesignReporter({
+  apiUrl,
+  apiKey,
+  site,
+  overrides,
+  defer = true,
+  allowInFrame = false,
+  allowLocalhost = false,
+  debug = false
+}) {
+  const ready = useDeferredActivation(defer);
+  const doneRef = useRef(false);
+  useEffect(() => {
+    if (!ready || doneRef.current || typeof window === "undefined") return;
+    doneRef.current = true;
+    if ((window.location.pathname || "/") !== "/") return;
+    const target = resolveAnalyticsTarget({ apiUrl, apiKey, allowInFrame, allowLocalhost, debug });
+    if (!target) return;
+    const w = window;
+    const host = site || w.__SITE_KIT_SITE__ || window.location.host;
+    const tokens = getSiteDesignTokens({ site: host, overrides, requirePath: "/" });
+    if (!tokens) {
+      if (debug) console.info("[Sonor design] nothing to report: no background, text or accent color found");
+      return;
+    }
+    const hash = designTokensHash(tokensForReport(tokens));
+    let stamp = null;
+    try {
+      stamp = localStorage.getItem(STAMP_KEY(host));
+    } catch {
+    }
+    if (!shouldReportDesign(stamp, hash, Date.now())) return;
+    void sendSiteDesign({ apiUrl: target.apiUrl, apiKey: target.apiKey, site: host, tokens, path: "/", allowInFrame, allowLocalhost, debug }).then(
+      (ok) => {
+        if (!ok) return;
+        try {
+          localStorage.setItem(STAMP_KEY(host), `${hash}:${Date.now()}`);
+        } catch {
+        }
+      }
+    );
+  }, [ready, apiUrl, apiKey, site, overrides, allowInFrame, allowLocalhost, debug]);
+  return null;
+}
+
+export { SiteDesignReporter };

package/dist/chunk-P5GB6NEO.js

@@ -0,0 +1,66 @@
+'use client';
+import { trackConversion } from './chunk-LCDVPAMR.js';
+import { useCallback, useEffect } from 'react';
+
+function useContactTracking(options = {}) {
+  const { autoTrack = true, debug = false } = options;
+  const trackPhoneClick = useCallback((phoneNumber, metadata) => {
+    if (debug) console.log("[Analytics] Phone click:", phoneNumber);
+    trackConversion({
+      type: "phone_call",
+      metadata: {
+        phoneNumber: phoneNumber.replace(/\D/g, ""),
+        // Normalize to digits
+        rawNumber: phoneNumber,
+        ...metadata
+      }
+    });
+  }, [debug]);
+  const trackEmailClick = useCallback((email, metadata) => {
+    if (debug) console.log("[Analytics] Email click:", email);
+    trackConversion({
+      type: "email_click",
+      metadata: {
+        email,
+        ...metadata
+      }
+    });
+  }, [debug]);
+  useEffect(() => {
+    if (!autoTrack || typeof document === "undefined") return;
+    const handleClick = (e) => {
+      const target = e.target;
+      const anchor = target.closest("a");
+      if (!anchor) return;
+      const href = anchor.getAttribute("href");
+      if (!href) return;
+      if (href.startsWith("tel:")) {
+        const phone = href.replace("tel:", "").trim();
+        trackPhoneClick(phone, {
+          linkText: anchor.textContent?.trim(),
+          source: "auto"
+        });
+      } else if (href.startsWith("mailto:")) {
+        const email = href.replace("mailto:", "").split("?")[0].trim();
+        trackEmailClick(email, {
+          linkText: anchor.textContent?.trim(),
+          source: "auto"
+        });
+      }
+    };
+    document.addEventListener("click", handleClick, { capture: true });
+    return () => {
+      document.removeEventListener("click", handleClick, { capture: true });
+    };
+  }, [autoTrack, trackPhoneClick, trackEmailClick]);
+  return {
+    trackPhoneClick,
+    trackEmailClick
+  };
+}
+function ContactTracking({ debug = false }) {
+  useContactTracking({ autoTrack: true, debug });
+  return null;
+}
+
+export { ContactTracking, useContactTracking };