@sonordev/site-kit 8.8.0 → 8.9.0

package/dist/chunk-KMNHNCVG.js

@@ -0,0 +1,20 @@
+import { measurementStore } from './chunk-FRY6PBT6.js';
+
+// src/shared/measurement-proof.ts
+function currentSubjectProof(now = Date.now()) {
+  const { proof, config, cmpValid } = measurementStore.current;
+  if (!proof || !config || !config.enabled || !cmpValid || Date.parse(config.expiresAt) <= now || Date.parse(proof.expiresAt) <= now) return null;
+  const first = proof.receipts[0];
+  return first.projectId === config.projectId && first.site === config.site && first.configRevision === config.configRevision && first.policyRevision === config.policyRevision ? proof : null;
+}
+function advertisingPurposesPermitted(now = Date.now()) {
+  const proof = currentSubjectProof(now);
+  if (!proof || !measurementStore.current.config) return false;
+  const needed = /* @__PURE__ */ new Set(["ad_storage", "ad_user_data", "ad_personalization", ...measurementStore.current.config.consentPolicy.requiredPurposes]);
+  return [...needed].every((p) => measurementStore.current.choices[p] === "granted" && proof.receipts.some((r) => r.purpose === p && r.state === "granted" && r.consentRevision === proof.currentConsentRevision));
+}
+function experimentMeasurementPermitted(now = Date.now()) {
+  return !!currentSubjectProof(now) && measurementStore.current.choices.analytics_storage === "granted";
+}
+
+export { advertisingPurposesPermitted, currentSubjectProof, experimentMeasurementPermitted };

package/dist/chunk-KQKUXIUD.js

@@ -0,0 +1,25 @@
+import { measurementStore, analyticsPurposePermitted } from './chunk-FRY6PBT6.js';
+
+// src/shared/measurement-writer.ts
+var listeners = measurementStore.listeners;
+function updateMeasurementPolicy(patch) {
+  const before = analyticsPurposePermitted(), oldScope = measurementStore.current.identityScope;
+  measurementStore.current = { ...measurementStore.current, ...patch, version: measurementStore.current.version + 1 };
+  if (patch.choices && patch.cmpValid !== false && patch.choices.analytics_storage !== measurementStore.lastObservedAnalyticsChoice) {
+    measurementStore.lastObservedAnalyticsChoice = patch.choices.analytics_storage;
+    measurementStore.current = { ...measurementStore.current, analyticsChoiceEpoch: measurementStore.current.analyticsChoiceEpoch + 1 };
+  }
+  if (before !== analyticsPurposePermitted() || oldScope !== measurementStore.current.identityScope) measurementStore.current = { ...measurementStore.current, collectionEpoch: measurementStore.current.collectionEpoch + 1 };
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+}
+function setFirstPartyIdentityScope(projectId, site) {
+  const next = measurementStore.current.config ? `${measurementStore.current.config.projectId}:${measurementStore.current.config.site}:${measurementStore.current.config.configRevision}` : projectId && site ? `${projectId}:${site}:legacy` : null;
+  if (next !== measurementStore.current.identityScope) updateMeasurementPolicy({ identityScope: next });
+}
+
+export { setFirstPartyIdentityScope, updateMeasurementPolicy };

package/dist/{chunk-M5JIHQ42.js → chunk-L3S5WH4C.js}

@@ -1,7 +1,7 @@
 import { trackedFreshFetch } from './chunk-UAYAJPEP.js';
-import { isNextControlFlow } from './chunk-C7TLGL3R.js';
+import { isNextControlFlow } from './chunk-7VMA3KCN.js';
 import { monotonicMs } from './chunk-MH2DSGC6.js';
-import { SITE_KIT_VERSION } from './chunk-F6WLHVMQ.js';
+import { SITE_KIT_VERSION } from './chunk-DXE6SXWW.js';
 import 'server-only';
 
 var MINT_PATH = "/api/public/site-token";

package/dist/chunk-MDBXGN6W.js

@@ -0,0 +1,13 @@
+import { currentSubjectProof, advertisingPurposesPermitted, experimentMeasurementPermitted } from './chunk-KMNHNCVG.js';
+import { resonanceControllerState } from './chunk-MOACHHOJ.js';
+import { measurementPolicySnapshot } from './chunk-FRY6PBT6.js';
+
+// src/resonance/form-context.ts
+function currentResonanceFormContext(projectId, site) {
+  const config = measurementPolicySnapshot().config;
+  const proof = currentSubjectProof();
+  if (!config || config.projectId !== projectId || config.site !== site || !proof || !advertisingPurposesPermitted() && !experimentMeasurementPermitted()) return null;
+  return { subjectProof: proof.subjectProof, exposureId: resonanceControllerState.controller?.formExposureId() ?? null };
+}
+
+export { currentResonanceFormContext };

package/dist/chunk-MOACHHOJ.js

@@ -0,0 +1,20 @@
+// src/resonance/controller-registry.ts
+var makeStore = () => ({ controller: null, blockers: [], registrationConflict: false });
+var resonanceControllerState = typeof window === "undefined" ? makeStore() : window.__SONOR_RESONANCE_RUNTIME_V1__ ?? (window.__SONOR_RESONANCE_RUNTIME_V1__ = makeStore());
+function recordRenderedResonanceExposure(exposure, context) {
+  try {
+    const controller = resonanceControllerState.controller;
+    const pending = context ? controller?.renderedExposure(exposure, context) : controller?.renderedExposure(exposure);
+    if (!pending) return false;
+    void pending.catch(() => {
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseRenderedResonanceExposure(exposure) {
+  resonanceControllerState.controller?.releaseRenderedExposure(exposure);
+}
+
+export { recordRenderedResonanceExposure, releaseRenderedResonanceExposure, resonanceControllerState };

package/dist/{chunk-6DXQHNZK.js → chunk-MP35JETP.js}

@@ -1,5 +1,5 @@
 'use client';
-import { detectTimezone, releaseSlotHold, fetchBookingTypeDetails, fetchBookingTypes, fetchAvailability, createSlotHold, createBooking, formatDuration, formatDate, formatTime, prepareMeeting } from './chunk-PSS6M4CG.js';
+import { detectTimezone, releaseSlotHold, fetchBookingTypeDetails, fetchBookingTypes, fetchAvailability, createSlotHold, createBooking, formatDuration, formatDate, formatTime, prepareMeeting } from './chunk-ZRSXCT4O.js';
 import { readPublishedApiConfig, DEFAULT_SONOR_API_URL } from './chunk-W7OPEMGJ.js';
 import { useState, useRef, useMemo, useCallback, useEffect, useId } from 'react';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';

package/dist/chunk-NHDRA4Y5.js

@@ -0,0 +1,6 @@
+// src/contracts/resonance-constants.ts
+var RESONANCE_ATTRIBUTION_MODEL = "first_party_last_touch_marker_v1";
+var RESONANCE_SOURCE_MARKER_PARAMETER = "sonor_source";
+var RESONANCE_SUBJECT_HEADER = "X-Sonor-Resonance-Subject";
+
+export { RESONANCE_ATTRIBUTION_MODEL, RESONANCE_SOURCE_MARKER_PARAMETER, RESONANCE_SUBJECT_HEADER };

package/dist/{chunk-AYQEIMGS.js → chunk-NZHECYLF.js}

@@ -1,10 +1,11 @@
 import { isBlockedPublicUrlHost } from './chunk-XS2ORMUG.js';
-import { LandingPage } from './chunk-PAYCK7FC.js';
-import { normalizeCampaignSlug } from './chunk-3MJNBOUO.js';
+import { LandingPage } from './chunk-XJZLXUTG.js';
+import { normalizeCampaignSlug } from './chunk-2QPVU63T.js';
 import { landingPageMetadata } from './chunk-JESLPEST.js';
-import { ServerForm } from './chunk-YRQS7VAH.js';
-import { serverApiFetch } from './chunk-C7TLGL3R.js';
+import { ServerForm } from './chunk-S63QY5XW.js';
+import { serverApiFetch, ServerApiFetchError } from './chunk-7VMA3KCN.js';
 import { normalizeSiteHost } from './chunk-A4CC4ZG3.js';
+import { SignalExperiment } from './chunk-F3RKFGRW.js';
 import 'server-only';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 
@@ -37,6 +38,7 @@ var integer = (minimum, maximum = Number.MAX_SAFE_INTEGER) => ({ type: "integer"
 var nullable = (shape) => ({ oneOf: [shape, { type: "null" }] });
 var isoDate = { type: "string", pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?Z$" };
 var uuid = { type: "string", pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$" };
+var fingerprint = { type: "string", pattern: "^[a-f0-9]{64}$" };
 var slug = { ...string(80), pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$" };
 var fieldSlug = { ...string(80), pattern: "^[a-zA-Z0-9_-]+$" };
 var path = { ...string(512), pattern: "^/(?!/)[a-zA-Z0-9/_-]*$" };
@@ -54,6 +56,22 @@ var override = object({
 }, []);
 var bodyBlock = { oneOf: [object({ type: literal("paragraph"), text: string(2e3) }), object({ type: literal("bullets"), items: array(string(500), 8, 1) })] };
 var body = array(bodyBlock, 12);
+var publishedContentFields = { headline: string(160), body };
+var authoredExperimentShape = object({
+  experimentId: uuid,
+  experimentRevision: integer(1),
+  controlVariantKey: string(80),
+  variants: array(object({ variantKey: string(80), content: object(publishedContentFields) }), 50, 2)
+});
+var experimentContentShape = object({
+  schemaVersion: literal(1),
+  kind: literal("funnel_experiment_content_v1"),
+  experimentId: uuid,
+  experimentRevision: integer(1),
+  goalRevision: { ...string(128), pattern: "^[a-zA-Z0-9._:-]+$" },
+  controlVariantKey: string(80),
+  variants: array(object({ variantKey: string(80), content: object(publishedContentFields), contentDigest: fingerprint }), 50, 2)
+});
 var publicBrand = object({ displayName: string(120), tagline: string(300, 0), fullLogoUrl: nullable(string(2048)), squareLogoUrl: nullable(string(2048)), colors, typography, scheme: enumeration("light", "dark") });
 var step = { oneOf: [
   object({ id: uuid, type: literal("wait"), durationSeconds: integer(60, 2592e3) }),
@@ -68,7 +86,7 @@ var definitionShape = object({
   site,
   entry: object({ formId: uuid, mode: literal("future_accepted_form_only") }),
   goal: object({ type: enumeration("newsletter_confirmed", "guide_requested", "inquiry_received", "booking_confirmed"), bookingTypeId: nullable(uuid) }, ["type"]),
-  page: object({ mode: enumeration("existing", "managed"), path, slug: nullable(slug), headline: string(160, 0), body, formId: uuid, offerAssetId: nullable(uuid) }, ["mode", "path", "headline", "body", "formId"]),
+  page: object({ mode: enumeration("existing", "managed"), path, slug: nullable(slug), headline: string(160, 0), body, formId: uuid, offerAssetId: nullable(uuid), experiment: authoredExperimentShape }, ["mode", "path", "headline", "body", "formId"]),
   permission: object({ mode: enumeration("requested_only", "marketing_opt_in"), optInFieldSlug: nullable(fieldSlug) }, ["mode"]),
   brandOverride: override,
   steps: array(step, 8),
@@ -91,7 +109,11 @@ draftProps.steps.items.oneOf = draftProps.steps.items.oneOf.map((item) => {
   if (fields.tag) fields.tag = string(80, 0);
   return item;
 });
-draftProps.page.properties.body = array({ oneOf: [object({ type: literal("paragraph"), text: string(2e3, 0) }), object({ type: literal("bullets"), items: array(string(500, 0), 8, 1) })] }, 12);
+var draftBody = array({ oneOf: [object({ type: literal("paragraph"), text: string(2e3, 0) }), object({ type: literal("bullets"), items: array(string(500, 0), 8, 1) })] }, 12);
+draftProps.page.properties.body = draftBody;
+var draftExperimentContent = draftProps.page.properties.experiment.properties.variants.items.properties.content.properties;
+draftExperimentContent.headline = string(160, 0);
+draftExperimentContent.body = draftBody;
 var FUNNEL_DRAFT_DEFINITION_JSON_SCHEMA = { $schema: "http://json-schema.org/draft-07/schema#", ...draftDefinitionShape };
 var FUNNEL_DEFINITION_JSON_SCHEMA = { $schema: "http://json-schema.org/draft-07/schema#", ...definitionShape };
 var publishedShape = object({
@@ -101,11 +123,14 @@ var publishedShape = object({
   revision: integer(1),
   site,
   path,
-  content: object({ headline: string(160), body, offer: object({ label: string(120), href: string(2048) }) }, ["headline", "body"]),
+  content: object({ ...publishedContentFields, offer: object({ label: string(120), href: string(2048) }) }, ["headline", "body"]),
   brand: publicBrand,
   conversion: object({ formSlug: fieldSlug }),
-  tracking: object({ campaignSlug: slug })
-});
+  tracking: object({ campaignSlug: slug }),
+  experimentContent: experimentContentShape
+}, ["schemaVersion", "id", "versionId", "revision", "site", "path", "content", "brand", "conversion", "tracking"]);
+({ ...authoredExperimentShape });
+({ ...experimentContentShape });
 var PUBLISHED_FUNNEL_PAGE_JSON_SCHEMA = { $schema: "http://json-schema.org/draft-07/schema#", ...publishedShape };
 var FUNNEL_LAUNCH_JSON_SCHEMA = object({ expectedRevision: integer(1), previewId: uuid, idempotencyKey: string(200), confirm: literal(true) });
 var FUNNEL_LIFECYCLE_JSON_SCHEMA = object({ expectedActiveVersionId: uuid, idempotencyKey: string(200), confirm: literal(true) });
@@ -190,14 +215,32 @@ function parsePublishedFunnelPage(value) {
   checkFonts(result.brand, "page.brand");
   checkBody(result.content.body, "page.content.body");
   if (result.content.offer && !isSafeFunnelPublicUrl(result.content.offer.href)) fail("page.content.offer.href", "unsafe public URL");
+  if (result.experimentContent) result.experimentContent = parseFunnelExperimentContent(result.experimentContent);
   return result;
 }
+function checkExperimentVariants(value, at) {
+  const keys = value.variants.map((variant) => variant.variantKey);
+  if (new Set(keys).size !== keys.length) fail(`${at}.variants`, "variant keys must be unique");
+  if (!keys.includes(value.controlVariantKey)) fail(`${at}.controlVariantKey`, "must identify an existing variant");
+  value.variants.forEach((variant, i) => checkBody(variant.content.body, `${at}.variants[${i}].content.body`));
+}
+function parseFunnelExperimentContent(value) {
+  check(value, experimentContentShape, "experimentContent");
+  const result = JSON.parse(JSON.stringify(value));
+  checkExperimentVariants(result, "experimentContent");
+  return result;
+}
+function resolveFunnelExperimentContent(value, variantKey) {
+  const page = parsePublishedFunnelPage(value);
+  const variant = page.experimentContent?.variants.find((v) => v.variantKey === variantKey);
+  if (!variant) fail("page.experimentContent.variants", "an existing reviewed variant is required");
+  return { ...page.content, headline: variant.content.headline, body: variant.content.body };
+}
 var FUNNEL_CREATE_JSON_SCHEMA = object({ idempotencyKey: string(200), definition: draftDefinitionShape });
 var FUNNEL_UPDATE_JSON_SCHEMA = object({ expectedRevision: integer(1), idempotencyKey: string(200), definition: draftDefinitionShape });
 var FUNNEL_REVISION_JSON_SCHEMA = object({ expectedRevision: integer(1) });
 var FUNNEL_RETRY_JSON_SCHEMA = object({ expectedAttempt: integer(0, 100), idempotencyKey: string(200), confirm: literal(true) });
 var FUNNEL_DRAFT_JSON_SCHEMAS = { create: FUNNEL_CREATE_JSON_SCHEMA, update: FUNNEL_UPDATE_JSON_SCHEMA };
-var fingerprint = { type: "string", pattern: "^[a-f0-9]{64}$" };
 var issue = object({ code: { ...string(80), pattern: "^[A-Z][A-Z0-9_]*$" }, path: string(300), message: string(500), fixRef: object({ section: string(80), field: string(80), resourceId: uuid }, ["section"]) }, ["code", "path", "message"]);
 var FUNNEL_READINESS_JSON_SCHEMA = object({ definitionRevision: integer(1), brandFingerprint: fingerprint, resourceFingerprint: fingerprint, ready: { type: "boolean" }, blockers: array(issue, 50), warnings: array(issue, 50), capabilities: object({ managedPage: { type: "boolean" } }) });
 var funnelDetailShape = object({ id: uuid, revision: integer(1), definition: draftDefinitionShape, activeVersionId: nullable(uuid), lifecycle: enumeration("draft", "active", "paused"), health: enumeration("healthy", "waiting", "needs_attention", "unknown"), hasDraftChanges: { type: "boolean" }, readiness: FUNNEL_READINESS_JSON_SCHEMA });
@@ -311,7 +354,13 @@ for (const schema of [FUNNEL_DEFINITION_JSON_SCHEMA, FUNNEL_DRAFT_DEFINITION_JSO
 var FUNNEL_VERSION_JSON_SCHEMA = object({ versionId: uuid, definitionRevision: integer(1), publishedAt: isoDate, brandFingerprint: fingerprint, resourceFingerprint: fingerprint, active: { type: "boolean" } });
 var FUNNEL_VERSION_DETAIL_JSON_SCHEMA = object({ ...FUNNEL_VERSION_JSON_SCHEMA.properties, rollbackEvidence: FUNNEL_ROLLBACK_EVIDENCE_JSON_SCHEMA });
 for (const schema of [FUNNEL_LAUNCH_EVIDENCE_JSON_SCHEMA, FUNNEL_ROLLBACK_EVIDENCE_JSON_SCHEMA, FUNNEL_VERSION_JSON_SCHEMA, FUNNEL_VERSION_DETAIL_JSON_SCHEMA]) freezeSchema(schema);
-function FunnelPageContent({ page: input, conversion, preview = false }) {
+function FunnelPageCopy({ content, headingFamily, headingId }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("h1", { id: headingId, style: { fontFamily: headingFamily }, children: content.headline }),
+    content.body.map((block, index) => block.type === "paragraph" ? /* @__PURE__ */ jsx("p", { children: block.text }, index) : /* @__PURE__ */ jsx("ul", { children: block.items.map((item, i) => /* @__PURE__ */ jsx("li", { children: item }, i)) }, index))
+  ] });
+}
+function FunnelPageContent({ page: input, conversion, preview = false, copy }) {
   const page = parsePublishedFunnelPage(input);
   const { brand, content } = page;
   const tokens = {
@@ -341,9 +390,8 @@ function FunnelPageContent({ page: input, conversion, preview = false }) {
         ] })
       ] }),
       /* @__PURE__ */ jsxs("div", { className: "sk-funnel-grid", children: [
-        /* @__PURE__ */ jsxs("section", { "aria-label": content.headline, children: [
-          /* @__PURE__ */ jsx("h1", { style: { fontFamily: brand.typography.headingFamily }, children: content.headline }),
-          content.body.map((block, index) => block.type === "paragraph" ? /* @__PURE__ */ jsx("p", { children: block.text }, index) : /* @__PURE__ */ jsx("ul", { children: block.items.map((item, i) => /* @__PURE__ */ jsx("li", { children: item }, i)) }, index)),
+        /* @__PURE__ */ jsxs("section", { "aria-label": copy === void 0 ? content.headline : void 0, "aria-labelledby": copy === void 0 ? void 0 : `sk-funnel-${page.id}`, children: [
+          copy ?? /* @__PURE__ */ jsx(FunnelPageCopy, { content, headingFamily: brand.typography.headingFamily }),
           content.offer && (preview ? /* @__PURE__ */ jsx("p", { children: content.offer.label }) : /* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx("a", { href: content.offer.href, rel: "noopener noreferrer", children: content.offer.label }) }))
         ] }),
         /* @__PURE__ */ jsx("section", { className: "sk-funnel-conversion", "aria-label": "Response form", children: preview ? /* @__PURE__ */ jsx("p", { className: "sk-funnel-preview", role: "status", children: "Form preview. Submissions are disabled." }) : conversion })
@@ -361,14 +409,20 @@ async function getPublishedFunnelPage(slug2, options) {
   }
   const site2 = normalizeSiteHost(options.site);
   if (!site2 || !/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/.test(site2)) throw new Error("An explicit canonical registered site is required");
-  const data = await serverApiFetch(`/api/public/funnels/${encodeURIComponent(slug2)}?site=${encodeURIComponent(site2)}`, {
-    apiKey: options.apiKey,
-    apiUrl: options.apiUrl,
-    revalidate: 0,
-    init: { cache: "no-store" },
-    logPrefix: "@sonordev/site-kit/landing"
-  });
-  if (data === null) return null;
+  let data;
+  try {
+    data = await serverApiFetch(`/api/public/funnels/${encodeURIComponent(slug2)}?site=${encodeURIComponent(site2)}`, {
+      apiKey: options.apiKey,
+      apiUrl: options.apiUrl,
+      revalidate: 0,
+      init: { cache: "no-store" },
+      throwOnError: true,
+      logPrefix: "@sonordev/site-kit/landing"
+    });
+  } catch (error) {
+    if (error instanceof ServerApiFetchError && error.category === "http" && error.status === 404) return null;
+    throw error;
+  }
   const page = parsePublishedFunnelPage(data);
   if (page.site !== site2 || page.path !== path2) throw new Error("Published funnel page scope mismatch");
   return page;
@@ -381,6 +435,33 @@ async function ManagedFunnelPage({ page: input, preview = false, configOptions }
   const page = parsePublishedFunnelPage(input);
   if (preview) return /* @__PURE__ */ jsx(FunnelPageContent, { page, preview: true });
   const form = await ServerForm({ formId: page.conversion.formSlug, defer: false, enter: "none", configOptions });
+  if (page.experimentContent) {
+    const manifest = page.experimentContent;
+    const variants = Object.fromEntries(manifest.variants.map(({ variantKey }) => [
+      variantKey,
+      /* @__PURE__ */ jsx(FunnelPageCopy, { content: resolveFunnelExperimentContent(page, variantKey), headingFamily: page.brand.typography.headingFamily, headingId: `sk-funnel-${page.id}` })
+    ]));
+    const copy = /* @__PURE__ */ jsx(
+      SignalExperiment,
+      {
+        experimentId: manifest.experimentId,
+        variants,
+        fallback: variants[manifest.controlVariantKey],
+        reviewedContext: {
+          site: page.site,
+          pagePath: page.path,
+          pageVersionId: page.versionId,
+          experimentRevision: manifest.experimentRevision,
+          controlVariantKey: manifest.controlVariantKey
+        }
+      },
+      page.versionId
+    );
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(LandingPage, { campaign: page.tracking.campaignSlug, robotsMeta: false }),
+      /* @__PURE__ */ jsx(FunnelPageContent, { page, copy, conversion: form })
+    ] });
+  }
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsx(LandingPage, { campaign: page.tracking.campaignSlug, robotsMeta: false }),
     /* @__PURE__ */ jsx(FunnelPageContent, { page, conversion: form })

package/dist/{chunk-EATJPSTS.js → chunk-O5LQUBBN.js}

@@ -1,4 +1,4 @@
-import { serverApiFetch } from './chunk-C7TLGL3R.js';
+import { serverApiFetch } from './chunk-7VMA3KCN.js';
 
 // src/robots/indexnow.ts
 var INDEXNOW_KEY_PATH = "/indexnow.txt";

package/dist/{chunk-Y6SHFILE.js → chunk-OEOSR5EG.js}

@@ -1,4 +1,4 @@
-import { publishSiteCredential } from './chunk-OPUY4RS6.js';
+import { publishSiteCredential } from './chunk-2LBKIE2K.js';
 
 // src/client/SiteKitCredential.tsx
 function SiteKitCredential({

package/dist/{chunk-GQN4BGK6.js → chunk-OUD4RTBD.js}

@@ -22,7 +22,7 @@ function useFieldControls(fields) {
       });
     }
     if (needsFile) {
-      import('./FileField-MJ3RCNFJ.js').then((m) => {
+      import('./FileField-YWMSK7RF.js').then((m) => {
         if (!cancelled) setControls((prev) => ({ ...prev, File: m.FileField }));
       }).catch(() => {
       });

package/dist/chunk-PMXQPO5Q.js

@@ -0,0 +1,78 @@
+import { RESONANCE_SUBJECT_HEADER } from './chunk-NHDRA4Y5.js';
+import { currentCredential } from './chunk-D4M5K6JN.js';
+import { sameSite } from './chunk-NZOJHERI.js';
+import { currentSubjectProof } from './chunk-KMNHNCVG.js';
+import { SITE_KIT_VERSION } from './chunk-DXE6SXWW.js';
+import { resolveAnalyticsTarget } from './chunk-7643MCD2.js';
+import { sonorFetch } from './chunk-VXCUXHZO.js';
+import { readPublishedApiConfig } from './chunk-W7OPEMGJ.js';
+import { normalizeSiteHost } from './chunk-A4CC4ZG3.js';
+import { analyticsPurposePermitted, measurementPolicySnapshot } from './chunk-FRY6PBT6.js';
+
+// src/shared/sonor-beacon.ts
+function sonorBeaconWithContext(url, payload, apiKey, contextHeaders) {
+  const credential = currentCredential(apiKey);
+  const body = typeof payload === "string" ? payload : JSON.stringify(payload);
+  try {
+    void fetch(url, {
+      method: "POST",
+      keepalive: true,
+      headers: {
+        ...contextHeaders,
+        "Content-Type": "application/json",
+        "x-sitekit-version": SITE_KIT_VERSION,
+        ...credential ? { "x-api-key": credential } : {}
+      },
+      body
+    }).catch(() => {
+    });
+  } catch {
+    if (Object.keys(contextHeaders).length) return;
+    try {
+      if (typeof navigator !== "undefined" && navigator.sendBeacon) {
+        navigator.sendBeacon(url, new Blob([body], { type: "application/json" }));
+      }
+    } catch {
+    }
+  }
+}
+
+// src/analytics/send-gate.ts
+function currentAnalyticsHeaders(path, apiUrl) {
+  if (!/^\/(?:api\/public\/analytics\/(?:page-view|session|scroll-depth|heatmap-click|web-vitals|event|conversion)|api\/public\/forms\/analytics\/(?:start|step|complete|abandon)|engage\/widget\/(?:event|impression|click))$/.test(path)) return {};
+  const proof = currentSubjectProof(), config = measurementPolicySnapshot().config;
+  if (!proof || !config || typeof window === "undefined" || readPublishedApiConfig().apiUrl !== apiUrl || !sameSite(normalizeSiteHost(window.location.hostname), config.site)) return {};
+  return { [RESONANCE_SUBJECT_HEADER]: proof.subjectProof };
+}
+var resolveAnalyticsTarget2 = (options = {}) => analyticsPurposePermitted() && (options.measurementEpoch === void 0 || options.measurementEpoch === measurementPolicySnapshot().collectionEpoch) ? resolveAnalyticsTarget(options) : null;
+async function analyticsSend(path, body, options = {}) {
+  const dispatchOptions = { ...options, measurementEpoch: options.measurementEpoch ?? measurementPolicySnapshot().collectionEpoch };
+  const target = resolveAnalyticsTarget2(dispatchOptions);
+  if (!target) return null;
+  try {
+    return await sonorFetch(
+      `${target.apiUrl}${path}`,
+      {
+        method: options.method || "POST",
+        headers: { "Content-Type": "application/json" },
+        ...options.keepalive ? { keepalive: true } : {},
+        ...body === void 0 ? {} : { body: JSON.stringify(body) }
+      },
+      {
+        apiKey: target.apiKey,
+        retries: options.retries ?? 0,
+        shouldSend: () => !!resolveAnalyticsTarget2(dispatchOptions),
+        prepareAttempt: (init) => ({ ...init, headers: { ...Object.fromEntries(new Headers(init.headers)), ...currentAnalyticsHeaders(path, target.apiUrl) } })
+      }
+    );
+  } catch {
+    return null;
+  }
+}
+function analyticsBeacon(path, body, options = {}) {
+  const target = resolveAnalyticsTarget2(options);
+  if (!target) return;
+  sonorBeaconWithContext(`${target.apiUrl}${path}`, body, target.apiKey, currentAnalyticsHeaders(path, target.apiUrl));
+}
+
+export { analyticsBeacon, analyticsSend, resolveAnalyticsTarget2 as resolveAnalyticsTarget };

package/dist/chunk-PVY7X5UR.js

@@ -0,0 +1,21 @@
+import { identityStorageKeys, memoryIdentity } from './chunk-5IVD6G77.js';
+import { analyticsPurposePermitted } from './chunk-FRY6PBT6.js';
+
+// src/shared/identity-reader.ts
+function readKey(kind, key) {
+  try {
+    return window[kind].getItem(key) || null;
+  } catch {
+    return null;
+  }
+}
+function readAnalyticsIdentity() {
+  if (typeof window === "undefined" || !analyticsPurposePermitted()) return { sessionId: null, visitorId: null };
+  const keys = identityStorageKeys();
+  return {
+    sessionId: readKey("sessionStorage", keys.session) || memoryIdentity.sessionId || null,
+    visitorId: readKey("localStorage", keys.visitor) || memoryIdentity.visitorId || null
+  };
+}
+
+export { readAnalyticsIdentity };

package/dist/{chunk-KG5IEV7I.js → chunk-QLJ2SC3T.js}

@@ -330,7 +330,7 @@ async function generateLLMsTxt(options) {
     if (includeEntities) {
       attemptedSections.push("knowledge-graph");
       optionalFetches.push(
-        import('./server-api-XIKDWSNO.js').then(async ({ getEntities, getPrimaryEntity }) => {
+        import('./server-api-A34TABT2.js').then(async ({ getEntities, getPrimaryEntity }) => {
           const [entities, primaryEntity] = await Promise.all([
             getEntities().then((e) => e.slice(0, maxEntities)),
             getPrimaryEntity()

package/dist/{chunk-2WM4TNDF.js → chunk-QXAJPB6O.js}

@@ -1,4 +1,4 @@
-import { generateLLMsTxt, generateLLMsFullTxt, appendAgentAccessSection } from './chunk-KG5IEV7I.js';
+import { generateLLMsTxt, generateLLMsFullTxt, appendAgentAccessSection } from './chunk-QLJ2SC3T.js';
 import { createHash } from 'crypto';
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';

package/dist/{chunk-2WDWQI7K.js → chunk-RYR6N4X4.js}

@@ -1,7 +1,7 @@
 import { SLOTS_CONTRACT_VERSION, verifySlotContent, canonicalJson } from './chunk-VCJYLYJV.js';
 import { isValidSlotId, SLOT_CONTENT_MAX_LENGTH, parseSlotRichText, normalizeSlotValue } from './chunk-LPH5FANE.js';
 import { SITE_CACHE_TAGS } from './chunk-HY7ZEU2C.js';
-import { resolveServerApiConfig } from './chunk-C7TLGL3R.js';
+import { resolveServerApiConfig } from './chunk-7VMA3KCN.js';
 import 'server-only';
 import * as React from 'react';
 import { cache } from 'react';

package/dist/{chunk-G7BRCSV6.js → chunk-S33CUULL.js}

@@ -1,6 +1,6 @@
 'use client';
-import { countStageViews, countStageQuestions, useFieldControls } from './chunk-GQN4BGK6.js';
-import { useFormLoadedAt, useFormTracking, submitForm, useRecaptchaWarmup, useForm } from './chunk-IWNJCRXW.js';
+import { countStageViews, countStageQuestions, useFieldControls } from './chunk-OUD4RTBD.js';
+import { useFormLoadedAt, useFormTracking, submitForm, useRecaptchaWarmup, useForm } from './chunk-UG53ZW7S.js';
 import { readAgentSubmit, formToolAttributes } from './chunk-Q6E4OPGG.js';
 import { isFieldVisible, validateField, isFieldComplete, isDisplayOnly, unseenControlValues } from './chunk-C2FZBUSS.js';
 import { HoneypotField } from './chunk-DXO6SBMD.js';
@@ -63,7 +63,7 @@ function FormClient({
       return;
     }
     let cancelled = false;
-    const load = resolvedExperience === "stage" ? import('./FormStage-4T5PJR5K.js').then((m) => m.FormStage) : import('./FormSpotlight-NQPQFZS7.js').then((m) => m.FormSpotlight);
+    const load = resolvedExperience === "stage" ? import('./FormStage-VAHRVOIZ.js').then((m) => m.FormStage) : import('./FormSpotlight-MAXDW3TK.js').then((m) => m.FormSpotlight);
     load.then((Component) => {
       if (!cancelled) setExperience(() => Component);
     }).catch((err) => {

package/dist/{chunk-YRQS7VAH.js → chunk-S63QY5XW.js}

@@ -1,6 +1,6 @@
-import { FormEnhancer } from './chunk-SLFYTELD.js';
+import { FormEnhancer } from './chunk-J4LJE4NB.js';
 import { StaticForm } from './chunk-VPZJ7ZTL.js';
-import { serverApiFetch } from './chunk-C7TLGL3R.js';
+import { serverApiFetch } from './chunk-7VMA3KCN.js';
 import { jsx } from 'react/jsx-runtime';
 
 async function ServerForm({