@sonordev/site-kit 8.10.0 → 8.12.0

package/dist/{runtime-core-EU2RZMOL.js → runtime-core-4WL4V4QE.js}

@@ -9,13 +9,16 @@ import { isNormalizedSiteHost } from './chunk-NZOJHERI.js';
 import { advertisingPurposesPermitted, experimentMeasurementPermitted } from './chunk-KMNHNCVG.js';
 import { resolveAnalyticsTarget, isFramed, isPrivatePreview, isLocalHostname } from './chunk-7643MCD2.js';
 import './chunk-64XODP7M.js';
-import { sonorFetch } from './chunk-Z4XJOVQX.js';
+import { sonorFetch } from './chunk-M2ZGSI6K.js';
 import './chunk-W7OPEMGJ.js';
 import './chunk-A4CC4ZG3.js';
 import './chunk-MOACHHOJ.js';
 import { measurementPolicySnapshot, subscribeMeasurementPolicy, unknownChoices, MEASUREMENT_PURPOSES } from './chunk-FRY6PBT6.js';
 import './chunk-PKBMQBKP.js';
 
+// src/contracts/wire-uuid.ts
+var UUID_V1_TO_V8_PATTERN = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89aAbB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
+
 // src/contracts/wire-schema.ts
 function createWireSchema(fail3, isValidationError) {
   const own = (v, k) => Object.prototype.hasOwnProperty.call(v, k);
@@ -95,7 +98,7 @@ var parseSignalExperimentCreate = (v) => create.read(v, "experimentCreate");
 var parseSignalExperimentUpdate = (v) => update.read(v, "experimentUpdate");
 var SIGNAL_EXPERIMENT_CREATE_JSON_SCHEMA = create.schema;
 var SIGNAL_EXPERIMENT_UPDATE_JSON_SCHEMA = update.schema;
-var measurementUuid = text(36, /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+var measurementUuid = text(36, UUID_V1_TO_V8_PATTERN);
 var measurementRevision = text(128, /^[a-zA-Z0-9._:-]+$/);
 var measurementInstant = refine(text(30, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/), (v, p) => {
   if (!Number.isFinite(Date.parse(v)) || new Date(v).toISOString().replace(".000Z", "Z") !== v.replace(".000Z", "Z")) fail(p, "invalid UTC instant");
@@ -235,7 +238,7 @@ var fail2 = (path2, reason) => {
   throw new ResonanceValidationError(path2, reason);
 };
 var { field: field2, text: text2, choice: choice2, literal: literal2, integer: integer2, bool, optional: optional2, nullable: nullable2, list: list2, object: object2, union: union2, refine: refine2 } = createWireSchema(fail2, (error) => error instanceof ResonanceValidationError);
-var uuid2 = text2(36, /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+var uuid2 = text2(36, UUID_V1_TO_V8_PATTERN);
 var digest = text2(64, /^[a-f0-9]{64}$/);
 var revision = text2(128, /^[a-zA-Z0-9._:-]+$/);
 var instant = refine2(text2(30, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/), (v, p) => {
@@ -450,9 +453,16 @@ var websiteVisitFeed = object2({ profile: literal2(RESONANCE_WEBSITE_VISIT_PROFI
 }), 100, 1) });
 websiteVisitFeed.schema;
 var providerReportingChannelIds = refine2(uniqueList(uuid2, 100, 1), (ids, p) => unique(ids.map((id) => id.toLowerCase()), p));
-var providerReportingSelection = object2({ agentContactId: uuid2, channelIds: providerReportingChannelIds });
-var providerReportingGrant = refine2(object2({ purpose: literal2("provider_reporting_refresh"), orgId: uuid2, projectId: uuid2, agentContactId: uuid2, principalContactId: uuid2, channelIds: providerReportingChannelIds }), (v, p) => {
+var RESONANCE_META_QUERY_ATTRIBUTION_WINDOWS = ["1d_click", "7d_click", "1d_view"];
+var metaReportingQuery = object2({ channelId: uuid2, attributionWindow: choice2(...RESONANCE_META_QUERY_ATTRIBUTION_WINDOWS), actionReportTime: literal2("conversion"), basis: literal2("explicit_query") });
+var providerReportingMetaQueries = refine2(list2(metaReportingQuery, 100, 1), (queries, p) => unique(queries.map((query) => query.channelId.toLowerCase()), p));
+function checkReportingQuerySubset(v, p) {
+  if (v.metaQueries?.some((query) => !v.channelIds.some((id) => id.toLowerCase() === query.channelId.toLowerCase()))) fail2(p + ".metaQueries", "query channel must be selected");
+}
+var providerReportingSelection = refine2(object2({ agentContactId: uuid2, channelIds: providerReportingChannelIds, metaQueries: optional2(providerReportingMetaQueries) }), checkReportingQuerySubset);
+var providerReportingGrant = refine2(object2({ purpose: literal2("provider_reporting_refresh"), orgId: uuid2, projectId: uuid2, agentContactId: uuid2, principalContactId: uuid2, channelIds: providerReportingChannelIds, metaQueries: optional2(providerReportingMetaQueries) }), (v, p) => {
   if (v.agentContactId.toLowerCase() === v.principalContactId.toLowerCase()) fail2(p + ".principalContactId", "agent and human principal must remain distinct");
+  checkReportingQuerySubset(v, p);
 });
 providerReportingSelection.schema;
 providerReportingGrant.schema;
@@ -617,6 +627,188 @@ function canonical(value) {
   if (Array.isArray(value)) return "[" + value.map(canonical).join(",") + "]";
   return "{" + Object.keys(value).sort().map((k) => JSON.stringify(k) + ":" + canonical(value[k])).join(",") + "}";
 }
+var positioningTarget = union2(
+  object2({ kind: literal2("broadcast"), channelId: uuid2 }),
+  object2({ kind: literal2("meta"), channelId: uuid2, creativeId: uuid2 }),
+  object2({ kind: literal2("google_search"), channelId: uuid2, adGroupKey: text2(80), adKey: text2(80) })
+);
+var positioningRequest = object2({
+  schemaVersion: literal2(1),
+  expectedRevision: integer2(1),
+  site,
+  destination: optional2(object2({ kind: choice2("existing_page", "funnel"), id: uuid2 })),
+  offerId: optional2(uuid2),
+  target: positioningTarget
+});
+var positioningWitnessFields = {
+  id: operationKey,
+  kind: choice2("page", "funnel", "offer", "brain", "buyer", "proof"),
+  sourceId: text2(160),
+  revision,
+  observedAt: instant,
+  expiresAt: instant,
+  permission: choice2("private", "public"),
+  certainty: choice2("verified", "reported", "conflicting")
+};
+var positioningWitness = refine2(object2(positioningWitnessFields), checkPositioningWitness);
+var positioningText = (max) => refine2(text2(max), (value, at) => {
+  if (!value.trim() || /[\x00-\x08\x0b-\x1f\x7f]/.test(value)) fail2(at, "requires nonblank text without control characters");
+});
+var positioningEvidence = refine2(object2({ ...positioningWitnessFields, text: positioningText(1600) }), checkPositioningWitness);
+function checkPositioningWitness(value, at) {
+  if (Date.parse(value.observedAt) >= Date.parse(value.expiresAt)) fail2(at, "requires a positive witness lifetime");
+}
+var positioningScopeFields = { schemaVersion: literal2(1), projectId: uuid2, campaignId: uuid2, request: positioningRequest, observedAt: instant, expiresAt: instant };
+function checkPositioningWindow(value, at) {
+  if (Date.parse(value.observedAt) >= Date.parse(value.expiresAt)) fail2(at, "requires a positive review lifetime");
+  unique(value.evidence.map((item) => item.id), at + ".evidence");
+  if (value.evidence.some((item) => Date.parse(item.observedAt) > Date.parse(value.observedAt))) fail2(at + ".evidence", "witness observation postdates the preview");
+}
+var positioningContext = refine2(object2({
+  ...positioningScopeFields,
+  orgId: uuid2,
+  evidence: list2(positioningEvidence, 32)
+}), (value, at) => {
+  checkPositioningWindow(value, at);
+  if (value.evidence.reduce((total, witness) => total + witness.text.length, 0) > 16e3) {
+    fail2(at + ".evidence", "exceeds the combined source text budget");
+  }
+});
+var positioningEvidenceIds = uniqueList(operationKey, 8);
+var positioningSupportedText = object2({ text: positioningText(320), evidenceIds: positioningEvidenceIds });
+var positioningAlternative = refine2(object2({
+  text: positioningText(320),
+  kind: choice2("status_quo", "alternative"),
+  basis: choice2("evidence", "hypothesis"),
+  evidenceIds: positioningEvidenceIds
+}), (value, at) => {
+  if (value.basis === "evidence" !== value.evidenceIds.length > 0) fail2(at, "requires evidence references exactly for evidenced alternatives");
+});
+var positioningClaim = object2({
+  attribute: positioningText(320),
+  value: positioningText(320),
+  evidenceIds: uniqueList(operationKey, 8, 1),
+  publicProofIds: positioningEvidenceIds
+});
+var positioningClaimIndexes = list2(integer2(0, 7), 8, 1);
+var positioningCopy = union2(
+  object2({ kind: literal2("broadcast"), caption: positioningText(2200), claimIndexes: positioningClaimIndexes }),
+  object2({
+    kind: literal2("meta"),
+    primaryText: positioningText(2200),
+    headline: positioningText(160),
+    body: positioningText(1e4),
+    claimIndexes: positioningClaimIndexes
+  }),
+  object2({
+    kind: literal2("google_search"),
+    headlines: uniqueList(positioningText(30), 15, 3),
+    descriptions: uniqueList(positioningText(90), 4, 2),
+    claimIndexes: positioningClaimIndexes
+  })
+);
+var positioningReasonCodes = choice2(
+  "destination_missing",
+  "destination_unverified",
+  "offer_unverified",
+  "offer_conflicting",
+  "brain_unavailable",
+  "buyer_evidence_sparse",
+  "public_proof_unavailable",
+  "fit_not_established",
+  "status_quo_sufficient",
+  "channel_mismatch",
+  "source_stale",
+  "evidence_conflicting",
+  "generation_unavailable"
+);
+var RESONANCE_POSITIONING_METHOD_VERSION = "positioning_v1";
+var positioningResult = refine2(object2({
+  methodVersion: literal2(RESONANCE_POSITIONING_METHOD_VERSION),
+  state: choice2("ready", "provisional", "no_fit"),
+  reasonCodes: uniqueList(positioningReasonCodes, 12),
+  alternatives: list2(positioningAlternative, 8),
+  claims: list2(positioningClaim, 8),
+  bestFit: list2(positioningSupportedText, 8),
+  category: nullable2(object2({ text: positioningText(160), style: choice2("existing_category", "focused_subcategory", "new_category"), evidenceIds: positioningEvidenceIds })),
+  timelyContext: nullable2(positioningSupportedText),
+  unknowns: list2(positioningText(320), 8),
+  questions: list2(positioningText(320), 8),
+  copy: nullable2(positioningCopy)
+}), (value, at) => {
+  if (value.state !== "ready") {
+    if (value.copy || !value.reasonCodes.length) fail2(at, "requires a reason and no draft copy when held");
+    return;
+  }
+  const { copy, claims, category, bestFit, alternatives } = value;
+  if (!copy || value.reasonCodes.length || !claims.length || !category || !bestFit.length || !alternatives.length) {
+    return fail2(at, "requires a supported ready brief and channel draft");
+  }
+  unique(copy.claimIndexes.map(String), at + ".copy.claimIndexes");
+  if (copy.claimIndexes.some((index) => index >= claims.length)) fail2(at + ".copy.claimIndexes", "requires an existing claim index");
+});
+function checkPositioningEvidence(result, context, at) {
+  const evidence = new Map(context.evidence.map((witness) => [witness.id, witness]));
+  const current = (witness) => witness.certainty === "verified" && Date.parse(witness.expiresAt) >= Date.parse(context.expiresAt);
+  const cited = [
+    ...result.alternatives,
+    ...result.claims,
+    ...result.bestFit,
+    ...result.category ? [result.category] : [],
+    ...result.timelyContext ? [result.timelyContext] : []
+  ];
+  if (cited.some((item) => item.evidenceIds.some((id) => !evidence.has(id)))) fail2(at, "references unknown evidence");
+  for (const claim of result.claims) {
+    for (const id of claim.publicProofIds) {
+      const witness = evidence.get(id);
+      if (!witness || witness.permission !== "public" || !current(witness)) fail2(at, "public proof requires a current permitted witness");
+    }
+  }
+  if (result.timelyContext && (!result.timelyContext.evidenceIds.length || result.timelyContext.evidenceIds.some((id) => {
+    const witness = evidence.get(id);
+    return !witness || !current(witness);
+  }))) fail2(at, "timely context requires current verified evidence");
+  if (!result.copy) return;
+  if (result.copy.kind !== context.request.target.kind) fail2(at, "copy target differs from the request");
+  const { destination: selected, offerId } = context.request;
+  const owns = (kind, id) => {
+    const witnesses = context.evidence.filter((w) => w.kind === kind && (!id || w.sourceId.toLowerCase() === id.toLowerCase()));
+    return witnesses.some(current) && !witnesses.some((w) => w.certainty === "conflicting");
+  };
+  if (!selected || !owns(selected.kind === "existing_page" ? "page" : "funnel", selected.id) || !owns("brain") || offerId && !owns("offer", offerId)) {
+    fail2(at, "ready copy requires current destination, Brain and selected offer witnesses");
+  }
+  for (const index of result.copy.claimIndexes) {
+    const claim = result.claims[index];
+    if (![...claim.evidenceIds, ...claim.publicProofIds].every((id) => {
+      const witness = evidence.get(id);
+      return witness && witness.permission === "public" && current(witness);
+    })) fail2(at, "selected copy requires current verified public claim evidence");
+  }
+}
+var positioningApplicationToken = text2(32e3, /^[a-zA-Z0-9._-]+$/);
+var positioningPreview = refine2(object2({
+  ...positioningScopeFields,
+  evidence: list2(positioningWitness, 32),
+  result: positioningResult,
+  applicationToken: nullable2(positioningApplicationToken)
+}), (value, at) => {
+  checkPositioningWindow(value, at);
+  checkPositioningEvidence(value.result, value, at + ".result");
+  if (value.result.state === "ready" !== (value.applicationToken !== null)) fail2(at, "requires an application token exactly for ready copy");
+});
+var positioningApplyRequest = object2({ applicationToken: positioningApplicationToken });
+positioningRequest.schema;
+positioningContext.schema;
+positioningResult.schema;
+positioningPreview.schema;
+positioningApplyRequest.schema;
+var positioningConsistencyAssessment = object2({
+  state: choice2("compatible", "conflicting", "unknown"),
+  evidenceDigest: digest,
+  coveredSourceIds: uniqueList(operationKey, 32)
+});
+positioningConsistencyAssessment.schema;
 var prepareCommand = object2({ expectedRevision: integer2(1), idempotencyKey: operationKey });
 var commandPreparation = object2({ command: nullable2(command), covered: bool, approvalRequirement: nullable2(choice2("existing_mandate", "current_owner")), reasonCodes: list2(text2(200), 100) });
 prepareCommand.schema;
@@ -981,7 +1173,256 @@ measurementSave.schema;
 measurementCurrent.schema;
 measurementSnapshot.schema;
 measurementSaveResponse.schema;
-var nativeAudienceRef = object2({ externalId: text2(160, /^[0-9]+(?![\s\S])/), revision: digest });
+var nativeAudienceId = text2(160, /^[0-9]+(?![\s\S])/);
+var RESONANCE_META_DATASET_NAME_MAX_LENGTH = 160;
+var metaDatasetName = refine2(text2(RESONANCE_META_DATASET_NAME_MAX_LENGTH), (value, at) => {
+  if (!value.trim() || value !== value.trim() || /[\x00-\x1f\x7f]/.test(value)) fail2(at, "requires a trimmed dataset name without control characters");
+});
+var metaDatasetExistingSelection = object2({ kind: literal2("existing"), externalId: nativeAudienceId });
+var metaDatasetSetupSelection = union2(
+  metaDatasetExistingSelection,
+  object2({ kind: literal2("create_if_none"), name: metaDatasetName })
+);
+var metaDatasetSetupPrepareFields = {
+  schemaVersion: literal2(1),
+  site,
+  accountBindingId: uuid2,
+  expectedDraftRevision: integer2(1),
+  idempotencyKey: operationKey,
+  selection: metaDatasetSetupSelection
+};
+var metaDatasetSetupPrepare = object2(metaDatasetSetupPrepareFields);
+metaDatasetSetupPrepare.schema;
+var metaDatasetSelectionRequest = object2({ ...metaDatasetSetupPrepareFields, selection: metaDatasetExistingSelection });
+var metaDatasetSelectionWitness = object2({ externalId: nativeAudienceId, resourceRevision: revision, observedAt: instant });
+metaDatasetSelectionRequest.schema;
+metaDatasetSelectionWitness.schema;
+var metaSetupOwnerFields = {
+  orgId: uuid2,
+  projectId: uuid2,
+  campaignId: uuid2,
+  connectionId: uuid2,
+  accountBindingRevision: integer2(1),
+  connectionRevision: revision,
+  capabilityRevision: revision,
+  expectedKillRevision: integer2(0),
+  externalAccountId: nativeAudienceId,
+  businessId: nativeAudienceId
+};
+var metaDatasetSetupIntent = object2({ ...metaDatasetSetupPrepareFields, ...metaSetupOwnerFields });
+var metaDatasetSetupReview = object2({ intent: metaDatasetSetupIntent, requestDigest: digest });
+metaDatasetSetupReview.schema;
+var metaDatasetSetupFirstOutcome = object2({
+  admission: choice2("accepted", "rejected", "unknown"),
+  externalId: nullable2(nativeAudienceId),
+  providerRequestId: nullable2(text2(200)),
+  providerRequestDigest: digest
+});
+var metaSetupVerificationFields = {
+  externalId: nativeAudienceId,
+  externalAccountId: nativeAudienceId,
+  businessId: nativeAudienceId,
+  resourceRevision: revision,
+  observedAt: instant
+};
+var metaDatasetSetupVerification = object2(metaSetupVerificationFields);
+var metaSetupReceiptFields = {
+  schemaVersion: literal2(1),
+  operationId: uuid2,
+  projectId: uuid2,
+  campaignId: uuid2,
+  site,
+  accountBindingId: uuid2,
+  requestDigest: digest,
+  status: choice2("pending", "selected", "created_unverified", "verified", "rejected", "uncertain", "cancelled"),
+  firstOutcome: nullable2(metaDatasetSetupFirstOutcome),
+  reasonCodes: uniqueList(text2(80, /^[a-z][a-z0-9_]*$/), 30)
+};
+function checkMetaSetupReceipt(value, at, resource2) {
+  const { status, firstOutcome, currentVerification } = value;
+  if (firstOutcome && firstOutcome.admission === "accepted" !== (firstOutcome.externalId !== null)) {
+    fail2(at + ".firstOutcome", "requires the original provider ID exactly when creation was accepted");
+  }
+  switch (status) {
+    case "pending":
+    case "cancelled":
+      if (firstOutcome || currentVerification) fail2(at, "cannot carry a creation outcome or verification");
+      break;
+    case "selected":
+      if (firstOutcome || !currentVerification) fail2(at, "requires verified existing selection without a creation outcome");
+      break;
+    case "created_unverified":
+      if (firstOutcome?.admission !== "accepted" || currentVerification) fail2(at, "requires accepted creation and no verified readback");
+      break;
+    case "verified":
+      if (firstOutcome?.admission !== "accepted" || !currentVerification || firstOutcome.externalId !== currentVerification.externalId) {
+        fail2(at, `requires verified readback of the exact created ${resource2}`);
+      }
+      break;
+    case "rejected":
+      if (firstOutcome?.admission !== "rejected") fail2(at, "requires the original rejection");
+      break;
+    case "uncertain":
+      if (firstOutcome?.admission !== "unknown" || currentVerification) fail2(at, `requires an unknown outcome without an attributable ${resource2}`);
+      break;
+  }
+}
+var metaSetupReceiptState = object2({ ...metaSetupReceiptFields, currentVerification: nullable2(metaDatasetSetupVerification) });
+var metaDatasetSetupReceipt = refine2(metaSetupReceiptState, (value, at) => checkMetaSetupReceipt(value, at, "dataset"));
+metaDatasetSetupReceipt.schema;
+var metaAudienceSetupResource = object2({ externalId: nativeAudienceId, resourceRevision: revision });
+var metaAudienceSetupSelection = union2(
+  object2({ kind: literal2("existing"), externalId: nativeAudienceId, resourceRevision: revision }),
+  object2({ kind: literal2("create_if_none") })
+);
+var websiteVisitSetupChoice = union2(
+  object2({ kind: literal2("off") }),
+  object2({ kind: literal2("enable"), expiresAt: instant })
+);
+var metaAudienceSetupPrepareFields = {
+  schemaVersion: literal2(1),
+  site,
+  accountBindingId: uuid2,
+  expectedDraftRevision: integer2(1),
+  idempotencyKey: operationKey,
+  dataset: metaAudienceSetupResource,
+  audienceRule: measurementRuleRef,
+  selection: metaAudienceSetupSelection,
+  feed: websiteVisitSetupChoice
+};
+var metaAudienceSetupPrepare = object2(metaAudienceSetupPrepareFields);
+metaAudienceSetupPrepare.schema;
+var metaAudienceSetupIntent = refine2(object2({
+  ...metaAudienceSetupPrepareFields,
+  ...metaSetupOwnerFields,
+  audienceRuleRef: audience,
+  resourceRuleRef: measurementRuleRef,
+  excludedResourceRuleRefs: list2(measurementRuleRef, 50),
+  measurementConfigRef,
+  matchingProfileRef,
+  audienceSpecDigest: digest,
+  name: friendlyName,
+  expiresAt: instant
+}), (value, at) => {
+  const { audienceRule, audienceRuleRef, resourceRuleRef, excludedResourceRuleRefs, measurementConfigRef: measurementConfigRef2 } = value;
+  if (audienceRuleRef.projectId !== value.projectId || audienceRuleRef.site !== value.site || audienceRuleRef.id !== audienceRule.id || audienceRuleRef.revision !== audienceRule.revision || audienceRuleRef.policyRevision !== measurementConfigRef2.policyRevision) fail2(at + ".audienceRuleRef", "requires the exact scoped audience and policy revision");
+  const excludedIds = excludedResourceRuleRefs.map((ref) => ref.id);
+  unique(excludedIds, at + ".excludedResourceRuleRefs");
+  if (excludedIds.includes(resourceRuleRef.id) || canonical([...audienceRuleRef.exclusionRuleIds].sort()) !== canonical(excludedIds.sort())) {
+    fail2(at + ".excludedResourceRuleRefs", "requires the exact exclusions disjoint from the positive rule");
+  }
+  checkAudienceBand(audienceRuleRef, "meta_ads", at + ".audienceRuleRef");
+});
+var metaAudienceSetupReview = object2({ intent: metaAudienceSetupIntent, requestDigest: digest });
+metaAudienceSetupReview.schema;
+var META_WEBSITE_AUDIENCE_MAX_RETENTION_DAYS = 180;
+var metaAudienceSetupVerification = object2({
+  ...metaSetupVerificationFields,
+  datasetExternalId: nativeAudienceId,
+  datasetResourceRevision: revision,
+  audienceSpecDigest: digest,
+  retentionDays: integer2(1, META_WEBSITE_AUDIENCE_MAX_RETENTION_DAYS)
+});
+var metaAudienceSetupReceipt = refine2(object2({
+  ...metaSetupReceiptFields,
+  currentVerification: nullable2(metaAudienceSetupVerification)
+}), (value, at) => checkMetaSetupReceipt(value, at, "audience"));
+metaAudienceSetupReceipt.schema;
+var websiteVisitSetupGrantProof = refine2(object2({
+  schemaVersion: literal2(1),
+  grantOperationId: uuid2,
+  audienceOperationId: uuid2,
+  approvalActionId: uuid2,
+  requestDigest: digest,
+  audienceReceiptDigest: digest,
+  generation: integer2(1),
+  activatedAt: instant,
+  expiresAt: instant,
+  projectId: uuid2,
+  campaignId: uuid2,
+  site,
+  accountBindingId: uuid2,
+  audience: metaAudienceSetupVerification
+}), (value, at) => {
+  if (value.grantOperationId.toLowerCase() === value.audienceOperationId.toLowerCase()) fail2(at + ".grantOperationId", "requires a distinct native grant operation");
+  if (Date.parse(value.audience.observedAt) > Date.parse(value.activatedAt) || Date.parse(value.activatedAt) >= Date.parse(value.expiresAt)) fail2(at, "requires verification by activation and a nonempty grant window");
+});
+var websiteVisitSetupGrantStatus = refine2(object2({
+  proof: websiteVisitSetupGrantProof,
+  status: choice2("active", "revoked", "expired", "invalidated"),
+  checkedAt: instant,
+  revokedAt: nullable2(instant),
+  reasonCodes: metaSetupReceiptFields.reasonCodes
+}), (value, at) => {
+  const checked = Date.parse(value.checkedAt), activated = Date.parse(value.proof.activatedAt), expires = Date.parse(value.proof.expiresAt);
+  if (checked < activated) fail2(at + ".checkedAt", "cannot predate activation");
+  if (value.status === "revoked") {
+    if (!value.revokedAt || Date.parse(value.revokedAt) < activated || Date.parse(value.revokedAt) > checked) {
+      fail2(at + ".revokedAt", "requires the recorded revocation between activation and observation");
+    }
+  } else if (value.revokedAt) fail2(at + ".revokedAt", "requires revoked status");
+  if (value.status === "active" && checked >= expires || value.status === "expired" && checked < expires) {
+    fail2(at + ".status", "must agree with the original expiry");
+  }
+});
+websiteVisitSetupGrantProof.schema;
+websiteVisitSetupGrantStatus.schema;
+var metaAudienceSetupStatusFields = { receipt: metaAudienceSetupReceipt, grant: nullable2(websiteVisitSetupGrantStatus) };
+function checkMetaAudienceSetupStatus({ receipt: receipt2, grant }, at) {
+  if (!grant) return;
+  const { proof } = grant;
+  if (receipt2.status !== "selected" && receipt2.status !== "verified" || !receipt2.currentVerification || canonical(receipt2.currentVerification) !== canonical(proof.audience)) {
+    fail2(at + ".grant", "requires the same verified audience witness as the setup receipt");
+  }
+  if (proof.audienceOperationId !== receipt2.operationId || proof.requestDigest !== receipt2.requestDigest || proof.projectId !== receipt2.projectId || proof.campaignId !== receipt2.campaignId || proof.site !== receipt2.site || proof.accountBindingId !== receipt2.accountBindingId) {
+    fail2(at + ".grant", "requires the grant linked to this exact setup operation");
+  }
+}
+var metaAudienceSetupStatusShape = object2(metaAudienceSetupStatusFields);
+var metaAudienceSetupStatus = refine2(metaAudienceSetupStatusShape, checkMetaAudienceSetupStatus);
+metaAudienceSetupStatus.schema;
+var metaAudienceSetupListItem = refine2(object2({ ledgerActionId: uuid2, ...metaAudienceSetupStatusFields }), (item, at) => {
+  checkMetaAudienceSetupStatus(item, at);
+  if (item.grant && item.grant.proof.approvalActionId.toLowerCase() !== item.ledgerActionId.toLowerCase()) {
+    fail2(at + ".ledgerActionId", "requires the original approval linked to this grant");
+  }
+});
+var metaAudienceSetupList = refine2(object2({
+  items: list2(metaAudienceSetupListItem, 25),
+  nextCursor: nullable2(uuid2)
+}), ({ items }, at) => {
+  unique(items.map((item) => item.receipt.operationId.toLowerCase()), at + ".items");
+});
+metaAudienceSetupList.schema;
+refine2(object2({
+  proof: websiteVisitSetupGrantProof,
+  intent: metaAudienceSetupIntent
+}), (value, at) => {
+  const { proof, intent } = value;
+  const { audience: witness } = proof;
+  if (intent.feed.kind !== "enable" || Date.parse(intent.feed.expiresAt) !== Date.parse(proof.expiresAt) || Date.parse(proof.activatedAt) >= Date.parse(intent.expiresAt)) fail2(at, "requires the explicit original opt-in and an unexpired setup approval");
+  if (proof.projectId !== intent.projectId || proof.campaignId !== intent.campaignId || proof.site !== intent.site || proof.accountBindingId !== intent.accountBindingId || witness.externalAccountId !== intent.externalAccountId || witness.businessId !== intent.businessId || witness.datasetExternalId !== intent.dataset.externalId || witness.datasetResourceRevision !== intent.dataset.resourceRevision || witness.audienceSpecDigest !== intent.audienceSpecDigest || witness.retentionDays !== intent.audienceRuleRef.retentionDays) {
+    fail2(at, "requires the exact original scope and verified destination");
+  }
+  if (intent.selection.kind === "existing" && (witness.externalId !== intent.selection.externalId || witness.resourceRevision !== intent.selection.resourceRevision)) {
+    fail2(at, "requires verification of the exact existing audience");
+  }
+});
+var websiteVisitSetupOrigin = object2({ kind: literal2("setup"), grantOperationId: uuid2, generation: integer2(1) });
+var websiteVisitSetupAcceptedVisitFields = { acceptedVisits: integer2(0), checkedAt: instant };
+var websiteVisitSetupGrantAcceptedVisits = object2({ grantOperationId: uuid2, ...websiteVisitSetupAcceptedVisitFields });
+websiteVisitSetupGrantAcceptedVisits.schema;
+var websiteVisitSetupDeliveryCommand = object2({
+  schemaVersion: literal2(1),
+  operation: literal2("deliver_website_visit"),
+  campaignId: uuid2,
+  occurrenceId: uuid2,
+  idempotencyKey: operationKey,
+  setupOrigin: websiteVisitSetupOrigin
+});
+websiteVisitSetupDeliveryCommand.schema;
+object2({ activatedAt: instant, expiresAt: instant, now: instant });
+var nativeAudienceRef = object2({ externalId: nativeAudienceId, revision: digest });
 var metaSave = refine2(object2({
   schemaVersion: literal2(1),
   expectedCampaignRevision: integer2(1),
@@ -1063,6 +1504,80 @@ var metaView = refine2(union2(
   if (v.projectId !== s.projectId || v.campaignId !== s.campaignId || v.channelId !== s.channelId || v.configurationRevision !== s.configurationRevision) fail2(p, "snapshot identity or configuration CAS mismatch");
   if (v.readyForReview !== metaReviewable(s, v)) fail2(p + ".readyForReview", "must reflect current review prerequisites only");
 });
+var RESONANCE_META_AUDIENCE_VERDICTS = ["ready", "too_small", "blocked", "unknown"];
+var RESONANCE_META_AUDIENCE_REASONS = [
+  "meta_audience_status_unreadable",
+  "meta_audience_status_unrecognized",
+  "meta_audience_integrity_flagged",
+  "meta_audience_account_inactive",
+  "meta_audience_pixel_problem",
+  "meta_audience_error",
+  "meta_audience_out_of_date",
+  "meta_audience_too_small",
+  "meta_audience_not_usable",
+  "meta_audience_prefill_failed",
+  "meta_audience_filling",
+  "meta_audience_category_unknown",
+  "meta_url_audience_unverified",
+  "meta_core_setup_suspected",
+  "meta_audience_fill_mismatch",
+  "meta_core_setup_attestation_missing",
+  "meta_flight_too_short_after_wait",
+  "meta_terms_nondiscrimination_pending",
+  "meta_terms_custom_audience_unconfirmed",
+  "meta_terms_business_tools_pending",
+  "meta_special_category_age_must_be_provider_managed",
+  "meta_special_category_genders_not_allowed",
+  "meta_audience_name_sensitive"
+];
+var metaReadinessPage = object2({ resourceRuleRef: measurementRuleRef, path: observedPagePath, label: nullable2(friendlyName) });
+var metaAudienceSize = refine2(object2({ lower: integer2(0), upper: integer2(0) }), (v, p) => {
+  if (v.upper < v.lower) fail2(p, "size bounds must be ordered");
+});
+var metaAudienceReadinessFields = {
+  verdict: choice2(...RESONANCE_META_AUDIENCE_VERDICTS),
+  reasonCodes: uniqueList(choice2(...RESONANCE_META_AUDIENCE_REASONS), 50),
+  size: nullable2(metaAudienceSize)
+};
+var metaAudienceSetupReadiness = refine2(object2({
+  status: metaAudienceSetupStatus,
+  delivery: nullable2(object2(websiteVisitSetupAcceptedVisitFields)),
+  providerAudience: nullable2(object2({ externalId: nativeAudienceId, observedAt: instant, readiness: object2(metaAudienceReadinessFields) }))
+}), ({ status, delivery, providerAudience }, at) => {
+  if (delivery && (!status.grant || Date.parse(delivery.checkedAt) < Date.parse(status.grant.proof.activatedAt))) {
+    fail2(at + ".delivery", "requires the grant and an observation at or after activation");
+  }
+  if (providerAudience && (status.receipt.status !== "selected" && status.receipt.status !== "verified" || status.receipt.currentVerification?.externalId !== providerAudience.externalId)) {
+    fail2(at + ".providerAudience", "requires observation of the exact verified audience");
+  }
+});
+metaAudienceSetupReadiness.schema;
+var metaReadinessCheck = union2(
+  object2({ state: literal2("not_checked"), reasonCode: choice2("configuration_unavailable", "native_mapping_unavailable") }),
+  object2({ state: literal2("observed"), mappingSource: choice2("selected_external_audience", "current_materialized_audience"), ...metaAudienceReadinessFields, observedAt: instant, expiresAt: nullable2(instant), sizeObservedAt: literal2(null), sizeExpiresAt: literal2(null) })
+);
+var metaReadinessAudience = object2({ audienceRuleRef: audience, name: friendlyName, includedPage: metaReadinessPage, excludedPages: list2(metaReadinessPage, 50), nativeAudienceId: nullable2(nativeAudienceId), check: metaReadinessCheck });
+var metaRetargetingReadiness = refine2(object2({ schemaVersion: literal2(1), projectId: uuid2, campaignId: uuid2, channelId: uuid2, site, campaignRevision: integer2(1), accountBindingId: uuid2, configuration: metaView, audiences: list2(metaReadinessAudience, 50) }), (v, p) => {
+  const sameId = (a, b) => a.toLowerCase() === b.toLowerCase();
+  const config = v.configuration;
+  if (!sameId(config.projectId, v.projectId) || !sameId(config.campaignId, v.campaignId) || !sameId(config.channelId, v.channelId)) fail2(p + ".configuration", "configuration scope mismatch");
+  if (config.kind === "configured" && (config.currentCampaignRevision !== v.campaignRevision || config.snapshot.site !== v.site || !sameId(config.snapshot.account.id, v.accountBindingId))) fail2(p + ".configuration", "current configuration revision, site or account mismatch");
+  unique(v.audiences.map((row) => row.audienceRuleRef.id.toLowerCase()), p + ".audiences");
+  for (const row of v.audiences) {
+    if (!sameId(row.audienceRuleRef.projectId, v.projectId) || row.audienceRuleRef.site !== v.site) fail2(p + ".audiences", "audience scope mismatch");
+    const excluded = row.excludedPages.map((page2) => page2.resourceRuleRef.id.toLowerCase());
+    unique(excluded, p + ".audiences.excludedPages");
+    const expected = row.audienceRuleRef.exclusionRuleIds.map((id) => id.toLowerCase());
+    unique(expected, p + ".audiences.audienceRuleRef.exclusionRuleIds");
+    if (excluded.includes(row.includedPage.resourceRuleRef.id.toLowerCase()) || excluded.length !== expected.length || expected.some((id) => !excluded.includes(id))) fail2(p + ".audiences.excludedPages", "exclusion rule scope mismatch");
+    if (row.check.state === "observed" && (row.nativeAudienceId === null || config.kind !== "configured")) fail2(p + ".audiences.check", "observed check requires configured scope and actual native audience identity");
+    if (config.kind === "configured" && config.currentDefinitionDigest === config.snapshot.reviewedDefinitionDigest) {
+      const original = config.snapshot.audiences.find((a) => sameId(a.audienceRuleRef.id, row.audienceRuleRef.id));
+      if (!original || canonical(original.audienceRuleRef) !== canonical(row.audienceRuleRef) || canonical(original.resourceRuleRef) !== canonical(row.includedPage.resourceRuleRef) || original.excludedResourceRuleRefs.length !== row.excludedPages.length || original.excludedResourceRuleRefs.some((ref) => !row.excludedPages.some((page2) => canonical(page2.resourceRuleRef) === canonical(ref)))) fail2(p + ".audiences", "original audience and page rule versions must match");
+    }
+  }
+});
+metaRetargetingReadiness.schema;
 var metaSaveResponse = object2({ schemaVersion: literal2(1), snapshot: metaSnapshot, replayed: bool });
 metaSave.schema;
 metaSnapshot.schema;
@@ -1100,7 +1615,6 @@ var observationsPage = object2({ items: list2(publicObservationMetric, 500), nex
 publicObservationMetric.schema;
 observationSupport.schema;
 observationsPage.schema;
-var META_WEBSITE_AUDIENCE_MAX_RETENTION_DAYS = 180;
 var META_AUDIENCE_RULE_LIMIT = 10;
 var usesPropertyModel = (c) => c.channelGroup !== void 0 || c.audienceRuleRefs.some((ref) => ref.minDaysSinceVisit !== void 0);
 function checkAudienceBand(ref, provider = "meta_ads", at = "audienceRuleRef") {
@@ -1336,6 +1850,8 @@ var ResonanceController = class {
       site: this.options.site,
       configRevision: this.config?.configRevision ?? null,
       policyRevision: this.config?.policyRevision ?? null,
+      configEnabled: this.config?.enabled ?? false,
+      configExpiresAt: this.config?.expiresAt ?? null,
       requiredPurposes: this.config?.consentPolicy.requiredPurposes ?? this.adapter?.requiredPurposes ?? []
     };
   }

package/dist/seo/client.js

@@ -1,8 +1,8 @@
 'use client';
-export { SitemapSync } from '../chunk-XAPSYDVT.js';
+export { SitemapSync } from '../chunk-WX4XX3BZ.js';
 import '../chunk-YVKRYQRG.js';
 import '../chunk-7643MCD2.js';
 import '../chunk-64XODP7M.js';
-import '../chunk-Z4XJOVQX.js';
+import '../chunk-M2ZGSI6K.js';
 import '../chunk-W7OPEMGJ.js';
 import '../chunk-PKBMQBKP.js';

package/dist/seo/index.js

@@ -2,7 +2,7 @@ export { ManagedNoScripts, ManagedScripts } from '../chunk-MVLMXC44.js';
 import { pickManagedLlmSchemaForJsonLd } from '../chunk-XAZC2TUD.js';
 import { withoutSchemaPlaceholders } from '../chunk-VWWITFWM.js';
 import { safeJsonLd } from '../chunk-4KZ6W3ZH.js';
-export { SitemapSync } from '../chunk-XAPSYDVT.js';
+export { SitemapSync } from '../chunk-WX4XX3BZ.js';
 import { getManagedMetadata, mergeAlternates } from '../chunk-3W3MN6Z7.js';
 export { generateSitemap, getABVariant, getManagedMetadata, getManagedMetadataWithAB, getRedirect, getRobotsDirective, isIndexable } from '../chunk-3W3MN6Z7.js';
 import { getSchemaMarkups, getSEOPageData, getEntityEnhancedSchema, getFAQData, getInternalLinks, pruneSchemaTypes } from '../chunk-STIVFCWM.js';
@@ -18,7 +18,7 @@ import '../chunk-DIKNRN34.js';
 import '../chunk-FESKKJAS.js';
 import '../chunk-7643MCD2.js';
 import '../chunk-64XODP7M.js';
-import '../chunk-Z4XJOVQX.js';
+import '../chunk-M2ZGSI6K.js';
 import '../chunk-W7OPEMGJ.js';
 import '../chunk-A4CC4ZG3.js';
 import '../chunk-PKBMQBKP.js';

package/dist/seo/llms.js

@@ -1,10 +1,10 @@
-export { createLLMsFullTxtHandler, createLLMsTxtHandler, formatSourcedFactsSection, llmsResponseHeaders } from '../chunk-HLN7A4GL.js';
+export { createLLMsFullTxtHandler, createLLMsTxtHandler, formatSourcedFactsSection, llmsResponseHeaders } from '../chunk-DUIGCLQM.js';
 export { buildAiDiscoveryHeaders, wantsLlmsDiscoveryLink } from '../chunk-MTDVV5P3.js';
 export { AI_RETRIEVAL_CRAWLERS, AI_TRAINING_CRAWLERS, buildAiCrawlerRules, createRobotsTxtHandler } from '../chunk-QLTDFUJ7.js';
-export { LEGACY_PUBLICATION_PATH, SEO_REVALIDATION_MAX_BODY_BYTES, SEO_REVALIDATION_MAX_ITEMS, createLlmsRevalidateHandler, createSeoRevalidationHandler, parseSeoRevalidationPayload } from '../chunk-RUV6DCKL.js';
+export { LEGACY_PUBLICATION_PATH, SEO_REVALIDATION_MAX_BODY_BYTES, SEO_REVALIDATION_MAX_ITEMS, createLlmsRevalidateHandler, createSeoRevalidationHandler, parseSeoRevalidationPayload } from '../chunk-T2Z7KEIH.js';
 export { AEOBlock, AEOCitedContent, AEOClaim, AEOComparison, AEODefinition, AEOEntity, AEOProvenanceList, AEOStep, AEOSteps, AEOSummary, DEFAULT_SPEAKABLE_SELECTORS, SpeakableSchema, createSpeakableSchema, getSpeakableSelectorsForPage } from '../chunk-PSAG45YF.js';
 import '../chunk-XTRZGXB2.js';
-export { AGENT_ACCESS_HEADING, appendAgentAccessSection, describesMcp, detectMcpServer, formatAgentAccessSection, generateLLMsFullTxt, generateLLMsTxt, writeLLMsTxtToPublic } from '../chunk-ORSQKTMN.js';
+export { AGENT_ACCESS_HEADING, appendAgentAccessSection, describesMcp, detectMcpServer, formatAgentAccessSection, generateLLMsFullTxt, generateLLMsTxt, writeLLMsTxtToPublic } from '../chunk-2YSX4ZUC.js';
 export { getBusinessInfo, getFAQItems, getLLMsData, getOptimizedLLMsTxt, getPageSummaries, getServices } from '../chunk-EK7P62DT.js';
 import '../chunk-7DYMM6SS.js';
 import '../chunk-IBHBEUZV.js';
@@ -16,7 +16,7 @@ import '../chunk-ISRBSTB7.js';
 import '../chunk-MJP63SSS.js';
 import '../chunk-YVKRYQRG.js';
 import '../chunk-FESKKJAS.js';
-import '../chunk-D4R3FQED.js';
+import '../chunk-2MJYGVKB.js';
 import '../chunk-W7OPEMGJ.js';
 import '../chunk-A4CC4ZG3.js';
 import '../chunk-PKBMQBKP.js';