@sonordev/site-kit 8.8.0 → 8.9.0

package/dist/runtime-core-WT7KKLWQ.js

@@ -0,0 +1,2213 @@
+import { updateMeasurementPolicy } from './chunk-KQKUXIUD.js';
+import { registerResonanceController, subscribeConsentAdapter, setProviderBlockers, getConsentAdapter } from './chunk-WYNDBJG7.js';
+import { isBlockedPublicUrlHost } from './chunk-XS2ORMUG.js';
+import { normalizeCampaignSlug } from './chunk-2QPVU63T.js';
+import './chunk-MDBXGN6W.js';
+import { RESONANCE_ATTRIBUTION_MODEL, RESONANCE_SOURCE_MARKER_PARAMETER, RESONANCE_SUBJECT_HEADER } from './chunk-NHDRA4Y5.js';
+import { uuid } from './chunk-GJWI74ZZ.js';
+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-VXCUXHZO.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-schema.ts
+function createWireSchema(fail3, isValidationError) {
+  const own = (v, k) => Object.prototype.hasOwnProperty.call(v, k);
+  const field3 = (schema, read) => ({ schema, read });
+  const text3 = (max = 200, pattern, min = 1) => field3({ type: "string", minLength: min, maxLength: max, ...pattern ? { pattern: pattern.source } : {} }, (v, p) => typeof v === "string" && v.length >= min && v.length <= max && (!pattern || pattern.test(v)) ? v : fail3(p, "invalid string"));
+  const choice3 = (...values) => field3({ type: "string", enum: values }, (v, p) => typeof v === "string" && values.includes(v) ? v : fail3(p, "unsupported value"));
+  const literal3 = (value) => field3({ const: value }, (v, p) => v === value ? value : fail3(p, "unexpected value"));
+  const integer3 = (min = 0, max = Number.MAX_SAFE_INTEGER) => field3({ type: "integer", minimum: min, maximum: max }, (v, p) => typeof v === "number" && Number.isSafeInteger(v) && v >= min && v <= max ? v : fail3(p, "invalid integer"));
+  const bool2 = field3({ type: "boolean" }, (v, p) => typeof v === "boolean" ? v : fail3(p, "must be boolean"));
+  const optional3 = (f) => ({ ...f, optional: true });
+  const nullable3 = (f) => field3({ anyOf: [f.schema, { type: "null" }] }, (v, p) => v === null ? null : f.read(v, p));
+  const list3 = (f, max = 100, min = 0) => field3({ type: "array", items: f.schema, minItems: min, maxItems: max }, (v, p) => {
+    if (!Array.isArray(v) || v.length < min || v.length > max) fail3(p, "invalid array");
+    return v.map((x, i) => f.read(x, `${p}[${i}]`));
+  });
+  const object3 = (fields2) => field3({ type: "object", additionalProperties: false, properties: Object.fromEntries(Object.entries(fields2).map(([k, f]) => [k, f.schema])), required: Object.keys(fields2).filter((k) => !("optional" in fields2[k])) }, (v, p) => {
+    if (!v || typeof v !== "object" || Array.isArray(v) || ![Object.prototype, null].includes(Object.getPrototypeOf(v))) fail3(p, "must be a plain object");
+    const source2 = v, result = {};
+    for (const key of Reflect.ownKeys(source2)) if (typeof key !== "string" || !own(fields2, key)) fail3(p, "unknown field");
+    for (const [key, f] of Object.entries(fields2)) {
+      if (!own(source2, key)) {
+        if ("optional" in f) continue;
+        fail3(`${p}.${key}`, "required");
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(source2, key);
+      if (!own(descriptor, "value")) fail3(`${p}.${key}`, "accessors are not wire data");
+      result[key] = f.read(descriptor.value, `${p}.${key}`);
+    }
+    return result;
+  });
+  const union3 = (...fields2) => field3({ oneOf: fields2.map((f) => f.schema) }, (v, p) => {
+    const found = [];
+    for (const f of fields2) {
+      try {
+        found.push(f.read(v, p));
+      } catch (e) {
+        if (!isValidationError(e)) throw e;
+      }
+    }
+    return found.length === 1 ? found[0] : fail3(p, "must match exactly one supported shape");
+  });
+  const refine3 = (f, check) => field3(f.schema, (v, p) => {
+    const result = f.read(v, p);
+    check(result, p);
+    return result;
+  });
+  return { field: field3, text: text3, choice: choice3, literal: literal3, integer: integer3, bool: bool2, optional: optional3, nullable: nullable3, list: list3, object: object3, union: union3, refine: refine3 };
+}
+
+// src/contracts/signal-experiments.ts
+var SignalExperimentValidationError = class extends Error {
+  constructor(path2, reason) {
+    super(`${path2}: ${reason}`);
+    this.path = path2;
+    this.name = "SignalExperimentValidationError";
+  }
+};
+var fail = (path2, reason) => {
+  throw new SignalExperimentValidationError(path2, reason);
+};
+var { field, text, choice, literal, integer, optional, nullable, list, object, union, refine } = createWireSchema(fail, (error) => error instanceof SignalExperimentValidationError);
+var percent = field({ type: "number", minimum: 0, maximum: 100 }, (v, p) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 100 ? v : fail(p, "must be a finite percentage from 0 to 100"));
+var page = refine(text(2048, /^\/(?!\/)[^?#\s\\]*$/), (v, p) => {
+  const parsed = new URL(v, "https://example.com");
+  if (parsed.pathname !== v) fail(p, "must be a canonical page path");
+});
+var variant = object({ key: text(80), name: text(160), weight: percent, description: optional(text(1e3, void 0, 0)) });
+var variants = refine(list(variant, 50, 2), (v, p) => {
+  if (new Set(v.map((x) => x.key)).size !== v.length) fail(p, "variant keys must be unique");
+  if (Math.abs(v.reduce((sum, x) => sum + x.weight, 0) - 100) > 0.01) fail(p, "variant weights must sum to 100");
+});
+var targeting = object({ pages: optional(list(page, 100)), segments: optional(list(text(160), 100)), devices: optional(list(choice("desktop", "mobile", "tablet"), 3)), geo: optional(list(text(160), 100)) });
+var fields = { name: text(160), description: text(1e4, void 0, 0), variants, traffic_allocation: percent, targeting_rules: targeting };
+var create = object({ ...fields, description: optional(fields.description), traffic_allocation: optional(fields.traffic_allocation), targeting_rules: optional(fields.targeting_rules) });
+var update = object({ name: optional(fields.name), description: optional(fields.description), variants: optional(fields.variants), traffic_allocation: optional(fields.traffic_allocation), targeting_rules: optional(fields.targeting_rules) });
+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 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");
+});
+var measurementSite = refine(text(253), (v, p) => {
+  if (!isNormalizedSiteHost(v) || isBlockedPublicUrlHost(v)) fail(p, "must be a normalized public site host");
+});
+var measurementCount = text(30, /^(?:0|[1-9][0-9]*)$/);
+var measurementScope = object({
+  projectId: measurementUuid,
+  experimentId: measurementUuid,
+  site: measurementSite,
+  experimentRevision: integer(1),
+  goalRevision: measurementRevision,
+  campaignId: measurementUuid,
+  campaignVersionId: measurementUuid,
+  assignedFrom: measurementInstant,
+  assignedTo: measurementInstant
+});
+var assignmentCounts = {
+  variantKey: text(80),
+  assignedUnits: measurementCount,
+  exposureEvents: measurementCount,
+  exposedUnits: measurementCount,
+  matureAssignedUnits: measurementCount,
+  immatureAssignedUnits: measurementCount,
+  assignmentsWithoutExposure: measurementCount
+};
+var availableVariant = object({ ...assignmentCounts, acceptedFormEvents: measurementCount, acceptedFormUnits: measurementCount, matureAcceptedFormUnits: measurementCount });
+var unsupportedVariant = object({ ...assignmentCounts, acceptedFormEvents: literal(null), acceptedFormUnits: literal(null), matureAcceptedFormUnits: literal(null) });
+var businessMetrics = object({
+  uniqueQualifiedContacts: object({ state: literal("unavailable"), reasonCode: literal("original_qualified_lineage_not_bound") }),
+  wonValue: object({ state: literal("unavailable"), reasonCode: literal("original_deal_lineage_not_bound") }),
+  paidRevenue: object({ state: literal("unavailable"), reasonCode: literal("original_paid_source_lineage_not_bound") })
+});
+var goalCountingUnit = choice("unique_source", "unique_qualified_contact", "net_order");
+var originalGoalFields = { sourceId: measurementUuid, sourceRevision: measurementRevision, countingUnit: goalCountingUnit };
+var formSourceKind = choice("accepted_form", "qualified_lead");
+var unsupportedSourceKind = choice("completed_booking", "net_paid_order", "approved_application");
+var observedFields = {
+  schemaVersion: literal(1),
+  mode: literal("trusted_source"),
+  state: literal("observed"),
+  observedAt: measurementInstant,
+  scope: measurementScope,
+  countingUnit: literal("consent_subject"),
+  coverage: literal("assigned_population_only"),
+  semanticRole: literal("accepted_form_diagnostic"),
+  businessMetrics
+};
+var observedMeasurement = refine(union(
+  object({
+    ...observedFields,
+    originalGoal: object({ ...originalGoalFields, sourceKind: formSourceKind }),
+    diagnosticType: literal("accepted_form"),
+    diagnosticState: literal("available"),
+    variants: list(availableVariant, 50)
+  }),
+  object({
+    ...observedFields,
+    originalGoal: object({ ...originalGoalFields, sourceKind: unsupportedSourceKind }),
+    diagnosticType: literal(null),
+    diagnosticState: literal("unsupported_original_source"),
+    variants: list(unsupportedVariant, 50)
+  })
+), (value, p) => {
+  if (Date.parse(value.scope.assignedFrom) >= Date.parse(value.scope.assignedTo) || Date.parse(value.scope.assignedTo) > Date.parse(value.observedAt))
+    fail(p + ".scope", "requires an increasing assignment cohort ending by the native observation");
+  if (new Set(value.variants.map((v) => v.variantKey)).size !== value.variants.length) fail(p + ".variants", "variant keys must be unique");
+  for (const [index, v] of value.variants.entries()) {
+    const assigned = BigInt(v.assignedUnits), exposed = BigInt(v.exposedUnits), mature = BigInt(v.matureAssignedUnits);
+    const at = `${p}.variants[${index}]`;
+    if (exposed > assigned || BigInt(v.exposureEvents) < exposed || BigInt(v.assignmentsWithoutExposure) !== assigned - exposed || mature + BigInt(v.immatureAssignedUnits) !== assigned)
+      fail(at, "assignment, exposure and maturity counts are inconsistent");
+    if (v.acceptedFormUnits !== null && v.acceptedFormEvents !== null && v.matureAcceptedFormUnits !== null) {
+      const accepted = BigInt(v.acceptedFormUnits), matureAccepted = BigInt(v.matureAcceptedFormUnits);
+      if (accepted > exposed || accepted > BigInt(v.acceptedFormEvents) || matureAccepted > mature || matureAccepted > accepted)
+        fail(at, "accepted form units must remain within their exposed, event and mature cohorts");
+    }
+  }
+});
+var measurement = union(
+  object({ schemaVersion: literal(1), mode: literal("legacy"), state: literal("unavailable"), reasonCode: literal("legacy_assignment_outcome_events_only") }),
+  object({ schemaVersion: literal(1), mode: literal("trusted_source"), state: literal("unavailable"), reasonCode: literal("measurement_scope_required") }),
+  observedMeasurement
+);
+measurement.schema;
+var scopeOption = object({
+  campaignId: measurementUuid,
+  campaignVersionId: measurementUuid,
+  campaignDefinitionRevision: integer(1),
+  acceptedAt: measurementInstant,
+  site: measurementSite,
+  experimentId: measurementUuid,
+  experimentRevision: integer(1),
+  goalRevision: measurementRevision,
+  goalLabel: nullable(text(200)),
+  assignmentExtent: nullable(object({ firstAssignedAt: measurementInstant, lastAssignedAt: measurementInstant })),
+  suggestedCohort: nullable(object({ assignedFrom: measurementInstant, assignedTo: measurementInstant }))
+});
+var scopeOptions = refine(object({ observedAt: measurementInstant, items: list(scopeOption, 100), nextCursor: nullable(text(4096)) }), (value, p) => {
+  const observed = Date.parse(value.observedAt), tuples = /* @__PURE__ */ new Set();
+  for (const [index, item] of value.items.entries()) {
+    const at = `${p}.items[${index}]`, accepted = Date.parse(item.acceptedAt);
+    const tuple = JSON.stringify([
+      item.campaignId.toLowerCase(),
+      item.campaignVersionId.toLowerCase(),
+      item.site,
+      item.experimentId.toLowerCase(),
+      item.experimentRevision,
+      item.goalRevision
+    ]);
+    if (tuples.has(tuple)) fail(at, "original scope tuples must be unique");
+    tuples.add(tuple);
+    if (accepted > observed) fail(at + ".acceptedAt", "must not follow the native observation");
+    if (item.assignmentExtent) {
+      const first = Date.parse(item.assignmentExtent.firstAssignedAt), last = Date.parse(item.assignmentExtent.lastAssignedAt);
+      if (first > last || last > observed) fail(at + ".assignmentExtent", "requires first <= last <= native observation");
+    }
+    if (item.suggestedCohort) {
+      const from = Date.parse(item.suggestedCohort.assignedFrom), to = Date.parse(item.suggestedCohort.assignedTo);
+      if (from !== accepted || from >= to || to > observed) fail(at + ".suggestedCohort", "requires original acceptance start and increasing cohort ending by native observation");
+    }
+  }
+});
+scopeOptions.schema;
+
+// src/contracts/resonance.ts
+var ResonanceValidationError = class extends Error {
+  constructor(path2, reason) {
+    super(`${path2}: ${reason}`);
+    this.path = path2;
+    this.name = "ResonanceValidationError";
+  }
+};
+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 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) => {
+  if (!Number.isFinite(Date.parse(v)) || new Date(v).toISOString().replace(".000Z", "Z") !== v.replace(".000Z", "Z")) fail2(p, "invalid UTC instant");
+});
+var timeZone = refine2(text2(80), (v, p) => {
+  try {
+    new Intl.DateTimeFormat("en", { timeZone: v });
+  } catch {
+    fail2(p, "invalid IANA timezone");
+  }
+});
+var site = refine2(text2(253), (v, p) => {
+  if (!isNormalizedSiteHost(v) || isBlockedPublicUrlHost(v)) fail2(p, "must be a normalized public site host");
+});
+var path = text2(2048, /^\/(?!\/)[^?#\s\\]*$/);
+var decimal = text2(30, /^(?:0|[1-9][0-9]{0,29})$/);
+var operationKey = text2(200, /^[a-zA-Z0-9._:-]+$/);
+var objectiveCountingUnit = choice2("unique_source", "unique_qualified_contact", "net_order");
+var RESONANCE_CURRENCIES = ["AED", "AFN", "ALL", "AMD", "ANG", "AOA", "ARS", "AUD", "AWG", "AZN", "BAM", "BBD", "BDT", "BGN", "BHD", "BIF", "BMD", "BND", "BOB", "BRL", "BSD", "BTN", "BWP", "BYN", "BZD", "CAD", "CDF", "CHF", "CLP", "CNY", "COP", "CRC", "CUC", "CUP", "CVE", "CZK", "DJF", "DKK", "DOP", "DZD", "EGP", "ERN", "ETB", "EUR", "FJD", "FKP", "GBP", "GEL", "GHS", "GIP", "GMD", "GNF", "GTQ", "GYD", "HKD", "HNL", "HRK", "HTG", "HUF", "IDR", "ILS", "INR", "IQD", "IRR", "ISK", "JMD", "JOD", "JPY", "KES", "KGS", "KHR", "KMF", "KPW", "KRW", "KWD", "KYD", "KZT", "LAK", "LBP", "LKR", "LRD", "LSL", "LYD", "MAD", "MDL", "MGA", "MKD", "MMK", "MNT", "MOP", "MRU", "MUR", "MVR", "MWK", "MXN", "MYR", "MZN", "NAD", "NGN", "NIO", "NOK", "NPR", "NZD", "OMR", "PAB", "PEN", "PGK", "PHP", "PKR", "PLN", "PYG", "QAR", "RON", "RSD", "RUB", "RWF", "SAR", "SBD", "SCR", "SDG", "SEK", "SGD", "SHP", "SLE", "SLL", "SOS", "SRD", "SSP", "STN", "SVC", "SYP", "SZL", "THB", "TJS", "TMT", "TND", "TOP", "TRY", "TTD", "TWD", "TZS", "UAH", "UGX", "USD", "UYU", "UZS", "VES", "VND", "VUV", "WST", "XAF", "XCD", "XCG", "XDR", "XOF", "XPF", "XSU", "YER", "ZAR", "ZMW", "ZWG", "ZWL"];
+var currency = choice2(...RESONANCE_CURRENCIES);
+var money = object2({ currency, amountMicros: decimal });
+money.schema;
+var sourceMarker = text2(1536, /^rsm1\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]{43}$/);
+var parseResonanceSourceMarker = (v) => sourceMarker.read(v, "sourceMarker");
+sourceMarker.schema;
+var scope = { projectId: uuid2, site };
+var resource = object2({ ...scope, module: choice2("funnel", "broadcast", "outreach", "experiment", "files", "business_brain", "publication", "crm", "commerce", "forms", "booking", "prepared_plan"), id: uuid2, revision, digest });
+var source = object2({ ...scope, kind: choice2("accepted_form", "qualified_lead", "completed_booking", "net_paid_order", "approved_application"), id: uuid2, revision });
+var qualificationFields = { schemaVersion: literal2(1), semantics: literal2("current_at_observation"), positiveStageKeys: list2(revision, 500), finalNegativeStageKeys: list2(revision, 500), pendingStageKeys: list2(revision, 500), existingContactPolicy: literal2("include_source_cohort") };
+var checkQualificationPartitions = (v, p) => {
+  unique([...v.positiveStageKeys, ...v.finalNegativeStageKeys, ...v.pendingStageKeys], p + ".stagePartitions");
+};
+var qualificationRule = refine2(object2({ ...qualificationFields, attributionModel: literal2(RESONANCE_ATTRIBUTION_MODEL) }), checkQualificationPartitions);
+qualificationRule.schema;
+var resolvedQualificationRule = refine2(object2({
+  ...qualificationFields,
+  ref: resource,
+  crmVariant: text2(128),
+  ladderSnapshot: list2(object2({ id: nullable2(uuid2), stage_key: revision, semantic_key: nullable2(revision), is_won: bool, is_lost: bool }), 500, 1),
+  eligibleFormIds: list2(uuid2, 500, 1),
+  attribution: object2({ model: literal2(RESONANCE_ATTRIBUTION_MODEL), resolverRevision: literal2(1) }),
+  cohort: object2({ startAt: instant, endAt: instant, maturityDelaySeconds: integer2(0, 31536e3) })
+}), (v, p) => {
+  checkQualificationPartitions(v, p);
+  if (v.ref.module !== "crm" || v.ref.id !== v.ref.projectId) fail2(p + ".ref", "must reference the actual CRM project configuration");
+  unique(v.eligibleFormIds, p + ".eligibleFormIds");
+  unique(v.ladderSnapshot.flatMap((x) => x.id ? [x.id] : []), p + ".ladderSnapshot.id");
+  unique(v.ladderSnapshot.map((x) => x.stage_key), p + ".ladderSnapshot.stage_key");
+  const partitions = [...v.positiveStageKeys, ...v.finalNegativeStageKeys, ...v.pendingStageKeys], keys = new Set(v.ladderSnapshot.map((x) => x.stage_key));
+  if (partitions.length !== keys.size || partitions.some((k) => !keys.has(k))) fail2(p + ".stagePartitions", "must exhaust the actual native ladder");
+  if (Date.parse(v.cohort.endAt) <= Date.parse(v.cohort.startAt)) fail2(p + ".cohort", "invalid cohort interval");
+});
+resolvedQualificationRule.schema;
+var objective = refine2(object2({ source, measurementRevision: revision, countingUnit: objectiveCountingUnit, attributionWindowDays: integer2(1, 365), maturityDelaySeconds: integer2(0, 31536e3), qualificationRuleRef: nullable2(resource), qualificationRule: optional2(qualificationRule) }), (v, p) => {
+  if (v.qualificationRule && v.source.kind !== "qualified_lead") fail2(p + ".qualificationRule", "requires the native qualified-lead source");
+  if (v.qualificationRule && v.qualificationRuleRef && (v.qualificationRuleRef.module !== "crm" || v.qualificationRuleRef.id !== v.source.projectId)) fail2(p + ".qualificationRuleRef", "must reference actual CRM project configuration");
+});
+var creative = object2({ id: uuid2, assetRef: resource, preparedArtifactRef: nullable2(resource), headline: text2(160), body: text2(1e4), callToAction: text2(80), cropDigest: digest });
+var destination = union2(
+  object2({ kind: literal2("funnel"), id: uuid2, ...scope, path, funnelRef: resource, formSlug: text2(80, /^[a-z0-9]+(?:-[a-z0-9]+)*$/), installationRevision: revision }),
+  object2({ kind: literal2("existing_page"), id: uuid2, ...scope, path, pageRevision: revision, evidenceDigest: digest })
+);
+var audience = object2({ ...scope, id: uuid2, revision, policyRevision: revision, retentionDays: integer2(1, 540), exclusionRuleIds: list2(uuid2, 50), minDaysSinceVisit: optional2(integer2(1, 179)), consentPurpose: literal2("ad_personalization") });
+var experiment = object2({ ...scope, id: uuid2, revision: integer2(1), digest });
+var budget = refine2(object2({ total: money, dailyAllocationCeiling: nullable2(money), reserveMargin: money, startAt: instant, endAt: instant, timeZone, maxChange: money, maxChangeBasisPoints: integer2(0, 1e4), cooldownSeconds: integer2(0, 31536e3) }), (v, p) => {
+  if (Date.parse(v.endAt) <= Date.parse(v.startAt)) fail2(p, "end must follow start");
+  for (const m of [v.reserveMargin, v.maxChange, ...v.dailyAllocationCeiling ? [v.dailyAllocationCeiling] : []]) if (m.currency !== v.total.currency) fail2(p, "currency mismatch");
+  if (BigInt(v.reserveMargin.amountMicros) > BigInt(v.total.amountMicros)) fail2(p, "reserve exceeds total");
+});
+var allocationPolicyFields = {
+  schemaVersion: literal2(1),
+  sourceRef: nullable2(resource),
+  decisionKind: literal2("observational_allocation"),
+  eligibleGoal: literal2("qualified_lead"),
+  algorithm: literal2("mature_cpql_conserved_transfer_v1"),
+  minimumMatureExposures: integer2(1),
+  minimumMatureOutcomes: integer2(1),
+  minimumCoverageBasisPoints: integer2(0, 1e4),
+  maxEvidenceAgeSeconds: integer2(1),
+  maturityDelaySeconds: integer2(0),
+  cooldownSeconds: integer2(0),
+  donorTransferBasisPoints: integer2(1, 1e4),
+  maxUncertaintyBasisPoints: integer2(0, 1e4),
+  uncertaintyMethod: literal2("observational_cpql_missing_outcome_bound_v1"),
+  attributionModel: choice2("first_party_source", "first_touch", "last_touch", "provider_reported", RESONANCE_ATTRIBUTION_MODEL),
+  requiredChecks: list2(choice2("tracking", "dedupe", "qualification", "uncertainty", "assignment", "power"), 6, 1)
+};
+var matureOptimizationPolicy = object2(allocationPolicyFields);
+var reportedPolicyFields = { ...allocationPolicyFields, algorithm: literal2("reported_cpql_conserved_transfer_v1"), costBasis: literal2("provider_reported_snapshot_v1"), costRevisionRisk: literal2("accepted_provisional") };
+var reportedOptimizationPolicy = object2({ ...reportedPolicyFields, readClockKind: literal2("sql_before_provider_read_lower_bound_v1") });
+function uniqueList(item, max, min = 0) {
+  const base = list2(item, max, min);
+  return field2({ ...base.schema, uniqueItems: true }, (v, p) => {
+    const r = base.read(v, p);
+    unique(r, p);
+    return r;
+  });
+}
+var optimizationCheck = choice2("tracking", "dedupe", "qualification", "uncertainty", "assignment", "power");
+var finiteCandidateAction = choice2("materialize_and_activate", "activate_held", "pause_candidate");
+var finiteStopRule = choice2("exploration_cap", "flight_end", "policy_or_mandate_expiry", "kill", "candidate_identity_or_settings_drift", "source_or_consent_invalid", "required_tracking_unavailable_or_stale", "unknown_effect");
+var positiveMicrosPattern = /^[1-9][0-9]*(?![\s\S])/;
+var positiveMoneyShape = field2({ allOf: [money.schema, { properties: { amountMicros: { pattern: positiveMicrosPattern.source } } }] }, (v, p) => {
+  const m = money.read(v, p);
+  if (!positiveMicrosPattern.test(m.amountMicros)) fail2(p, "requires positive canonical money");
+  return m;
+});
+var finiteMetaCandidatePolicy = object2({
+  schemaVersion: literal2(1),
+  algorithm: literal2("finite_meta_candidates_v1"),
+  decisionKind: literal2("preapproved_candidate_operation"),
+  eligibleGoal: literal2("qualified_lead"),
+  sourceRef: nullable2(resource),
+  candidateChannelIds: uniqueList(uuid2, 100, 1),
+  selection: object2({ kind: literal2("fixed_reviewed_order"), candidateOrder: uniqueList(uuid2, 100, 1), eligibilitySchedule: list2(object2({ channelId: uuid2, notBefore: instant, notAfter: instant }), 100, 1) }),
+  allowedActions: uniqueList(finiteCandidateAction, 3, 1),
+  maxConcurrentCandidates: integer2(1, 100),
+  maxActivationsPerCandidate: literal2(1),
+  totalExplorationCap: positiveMoneyShape,
+  measurementGuard: object2({ sourceRef: source, qualificationRuleRef: resource, attributionModel: literal2(RESONANCE_ATTRIBUTION_MODEL), maturityDelaySeconds: integer2(0, 31536e3), minimumCoverageBasisPoints: integer2(0, 1e4), maxEvidenceAgeSeconds: integer2(1), requiredChecks: uniqueList(optimizationCheck, 6, 1) }),
+  performanceDecisionPolicy: literal2(null),
+  stopRules: uniqueList(finiteStopRule, 8, 8),
+  expiresAt: instant
+});
+var optimizationPolicy = union2(matureOptimizationPolicy, finiteMetaCandidatePolicy, reportedOptimizationPolicy);
+optimizationPolicy.schema;
+var optimization = object2({ enabled: bool, policy: optimizationPolicy, stopLoss: object2({ confirmedSpend: money, unreconciledExposure: money }) });
+var channelBase = { id: uuid2, ...scope, destinationId: uuid2, creativeIds: list2(uuid2, 50, 1) };
+var search = object2({ ...channelBase, localCampaignKey: text2(80), kind: literal2("google_search"), provider: literal2("google_ads"), accountBindingId: uuid2, capabilityRevision: revision, allocation: money, budgetMode: choice2("campaign_total", "average_daily"), keywords: list2(object2({ text: text2(80), match: choice2("exact", "phrase", "broad") }), 200, 1), negativeKeywords: list2(text2(80), 200), bidding: union2(object2({ strategy: literal2("maximize_conversions") }), object2({ strategy: literal2("target_cpa"), target: money })), locationIds: list2(text2(80), 100, 1), network: object2({ googleSearch: literal2(true), searchPartners: bool, displayExpansion: literal2(false) }), geoPresence: choice2("presence", "presence_or_interest"), excludedLocationIds: list2(text2(80), 100), adGroups: list2(object2({ localKey: text2(80), ads: list2(object2({ localKey: text2(80), creativeId: uuid2, headlines: list2(text2(30), 15, 3), descriptions: list2(text2(90), 4, 2) }), 20, 1) }), 100, 1), assetAutomation: literal2("disabled") });
+var metaAgeConstraint = union2(refine2(object2({ mode: literal2("bounded"), min: integer2(1, 120), max: integer2(1, 120) }), (v, p) => {
+  if (v.min > v.max) fail2(p, "minimum age exceeds maximum");
+}), object2({ mode: literal2("omitted") }), object2({ mode: literal2("provider_managed") }));
+var propertyKey = object2({ key: text2(40, /^[a-z0-9]+(?:-[a-z0-9]+)*$/), label: text2(80) });
+var meta = object2({
+  ...channelBase,
+  localCampaignKey: text2(80),
+  kind: literal2("meta_retargeting"),
+  provider: literal2("meta_ads"),
+  accountBindingId: uuid2,
+  capabilityRevision: revision,
+  allocation: money,
+  budgetMode: choice2("lifetime", "daily"),
+  audienceRuleRefs: list2(audience, 50, 1),
+  objective: choice2("OUTCOME_LEADS", "OUTCOME_SALES", "OUTCOME_TRAFFIC"),
+  pageRef: object2({ connectionId: uuid2, externalId: text2(160), revision }),
+  instagramRef: nullable2(object2({ connectionId: uuid2, externalId: text2(160), revision })),
+  datasetRef: object2({ id: text2(160), revision }),
+  conversionGoalRef: resource,
+  optimization: choice2("landing_page_views", "lead", "purchase"),
+  billing: literal2("impressions"),
+  bid: union2(object2({ strategy: literal2("lowest_cost") }), object2({ strategy: literal2("cost_cap"), cap: money })),
+  localAdSetKey: text2(80),
+  localAdKey: text2(80),
+  budgetOwner: choice2("campaign", "adset"),
+  specialCategories: list2(choice2("housing", "employment", "financial_products_services"), 3),
+  countryCodes: list2(text2(2, /^[A-Z]{2}$/), 30, 1),
+  placement: literal2("automatic"),
+  ageConstraint: optional2(metaAgeConstraint),
+  // Property retargeting (one channel per property under one group). Every field is optional and omitted from the canonical form when absent, so no existing reviewed digest changes.
+  channelGroup: optional2(propertyKey),
+  property: optional2(propertyKey),
+  tier: optional2(object2({ label: text2(40) })),
+  primaryText: optional2(text2(2200)),
+  convertersAcknowledged: optional2(literal2(true))
+});
+var owned = object2({ ...channelBase, kind: choice2("funnel", "broadcast", "outreach"), resourceRef: resource });
+var channel = union2(search, meta, owned);
+var definitionFields = { schemaVersion: literal2(1), projectId: uuid2, name: text2(160), slug: refine2(text2(80), (v, p) => {
+  if (normalizeCampaignSlug(v) !== v) fail2(p, "must be canonical campaign slug");
+}), sites: list2(site, 50, 1), objective, brandRef: resource, creativeRefs: list2(creative, 100, 1), destinations: list2(destination, 100, 1), channels: list2(channel, 100, 1), experimentRefs: list2(experiment, 50), budget, optimization };
+var definition = object2(definitionFields);
+var draft = object2({ schemaVersion: literal2(1), projectId: uuid2, name: text2(160, void 0, 0), slug: definitionFields.slug, sites: list2(site, 50), objective: optional2(objective), brandRef: optional2(resource), creativeRefs: optional2(list2(creative, 100)), destinations: optional2(list2(destination, 100)), channels: optional2(list2(channel, 100)), experimentRefs: optional2(list2(experiment, 50)), budget: optional2(budget), optimization: optional2(optimization) });
+function scoped(value, projectId, sites, at) {
+  if (!value || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    value.forEach((x, i) => scoped(x, projectId, sites, `${at}[${i}]`));
+    return;
+  }
+  const v = value;
+  if ("projectId" in v && v.projectId !== projectId) fail2(at, "cross-project reference");
+  if ("site" in v && !sites.includes(v.site)) fail2(at, "site outside campaign scope");
+  for (const [k, x] of Object.entries(v)) scoped(x, projectId, sites, `${at}.${k}`);
+}
+function unique(values, at) {
+  if (new Set(values).size !== values.length) fail2(at, "duplicate identity");
+}
+definition.schema;
+draft.schema;
+var capability = object2({ id: uuid2, projectId: uuid2, connectionId: uuid2, provider: choice2("google_ads", "meta_ads"), externalAccountId: text2(160), currency, timeZone, connectionRevision: revision, capabilityRevision: revision, observedAt: instant, expiresAt: instant, advertiserState: choice2("eligible", "blocked", "unknown"), operations: list2(object2({ operation: choice2("discover", "prepare", "launch", "update", "pause", "resume", "finish", "reconcile", "measure", "audience", "conversion", "experiment"), state: choice2("supported", "blocked", "unknown"), reasonCodes: list2(text2(80), 30), prerequisites: list2(text2(100), 30) }), 20), profiles: list2(object2({ profile: choice2("google_search", "meta_retargeting"), state: choice2("supported", "blocked", "unknown"), reasonCodes: list2(text2(80), 30), budgetModes: list2(choice2("campaign_total", "average_daily", "lifetime", "daily"), 4), providerApiVersion: text2(30) }), 2) });
+var mandateRef = object2({ ledgerActionId: uuid2, campaignId: uuid2, preparedPlanId: uuid2, reviewDigest: digest, mandateDigest: digest, expectedKillRevision: integer2(0) });
+var websiteVisitMaxAgeMs = 3e5;
+var RESONANCE_WEBSITE_VISIT_PROFILE = Object.freeze({
+  profile: "sonor_sdk_page_view_fresh_v1",
+  source: "sdk_reported_first_party_cookie",
+  assurance: "sdk_reported",
+  matchingFields: Object.freeze(["fbp", "fbc"]),
+  maxCaptureAgeMs: websiteVisitMaxAgeMs,
+  maxDispatchAgeMs: websiteVisitMaxAgeMs,
+  maxFutureSkewMs: 0,
+  browserServerPairing: "unsupported"
+});
+var measurementRuleRef = object2({ id: uuid2, revision });
+var measurementConfigRef = object2({ configRevision: revision, policyRevision: revision, digest });
+var matchingProfileRef = object2({ id: uuid2, revision: integer2(1), digest });
+var mandateAllowedOperations = list2(choice2("launch", "update", "resume", "optimize", "deliver_conversion"), 5, 1);
+var websiteVisitFeed = object2({ profile: literal2(RESONANCE_WEBSITE_VISIT_PROFILE.profile), channels: list2(object2({
+  channelId: uuid2,
+  measurementConfigRef,
+  resourceRuleRefs: list2(measurementRuleRef, 500, 1),
+  matchingProfileRef
+}), 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) => {
+  if (v.agentContactId.toLowerCase() === v.principalContactId.toLowerCase()) fail2(p + ".principalContactId", "agent and human principal must remain distinct");
+});
+providerReportingSelection.schema;
+providerReportingGrant.schema;
+var mandateScope = object2({ projectId: uuid2, campaignId: uuid2, preparedPlanId: uuid2, reviewDigest: digest, accountBindingIds: list2(uuid2, 100), sites: list2(site, 50, 1), budget, creativeRefs: list2(creative, 100, 1), audienceRuleRefs: list2(audience, 100), goal: objective, allowedOperations: mandateAllowedOperations, allowedTransformationRef: nullable2(resource), expiresAt: instant, websiteVisitFeed: optional2(websiteVisitFeed), providerReporting: optional2(providerReportingGrant) });
+object2({ occurredAt: instant, receivedAt: instant });
+var RESONANCE_GOOGLE_SIGNAL_SEMANTICS = "qualified_at_observation_v1";
+var googleSignalSemantics = literal2(RESONANCE_GOOGLE_SIGNAL_SEMANTICS);
+var RESONANCE_GOOGLE_SOURCE_CATEGORIES = Object.freeze({ accepted_form: "SUBMIT_LEAD_FORM", qualified_lead: "QUALIFIED_LEAD", completed_booking: "BOOK_APPOINTMENT", net_paid_order: "PURCHASE", approved_application: "CONVERTED_LEAD" });
+var googleSemanticsInput = object2({ sourceKind: choice2(...Object.keys(RESONANCE_GOOGLE_SOURCE_CATEGORIES)), counting: choice2("one", "every"), clickWindowDays: integer2(1, 90) });
+function googleConversionActionSemantics(input) {
+  const v = googleSemanticsInput.read(input, "googleConversionActionSemantics");
+  return { type: "UPLOAD_CLICKS", category: RESONANCE_GOOGLE_SOURCE_CATEGORIES[v.sourceKind], countingType: v.counting === "one" ? "ONE_PER_CLICK" : "MANY_PER_CLICK", clickThroughLookbackWindowDays: v.clickWindowDays, primaryForGoal: false };
+}
+var googleSetupPolicyInput = object2({ source, countingUnit: objectiveCountingUnit, attributionWindowDays: integer2(1, 365) });
+function googleUploadClicksSetupSemantics(input) {
+  const v = googleSetupPolicyInput.read(input, "googleSetupPolicy");
+  if (v.source.kind !== "qualified_lead" || v.countingUnit !== "unique_qualified_contact") fail2("googleSetupPolicy", "unsupported_counting_policy");
+  if (v.attributionWindowDays > 90) fail2("googleSetupPolicy.attributionWindowDays", "unsupported_attribution_window");
+  return { ...googleConversionActionSemantics({ sourceKind: v.source.kind, counting: "one", clickWindowDays: v.attributionWindowDays }), category: RESONANCE_GOOGLE_SOURCE_CATEGORIES.qualified_lead, countingType: "ONE_PER_CLICK" };
+}
+var googleGoalChoiceFields = {
+  externalId: text2(160, /^customers\/[0-9]+\/customConversionGoals\/[0-9]+$/),
+  actionIds: list2(text2(160, /^customers\/[0-9]+\/conversionActions\/[0-9]+$/), 100, 1)
+};
+var googleDeclarationChoiceFields = {
+  statement: literal2("DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING"),
+  category: choice2("general", "housing", "employment", "financial_products_services")
+};
+function normalizeGoogleGoal(value, at) {
+  unique(value.actionIds, at + ".actionIds");
+  value.actionIds.sort();
+  return value;
+}
+var googleSetupSpec = object2({
+  schemaVersion: literal2(1),
+  kind: literal2("google_upload_clicks_custom_goal_v1"),
+  signalSemantics: googleSignalSemantics,
+  goalLocalKey: literal2("setup:custom-goal"),
+  requestedGoalName: text2(160),
+  action: object2({
+    localKey: literal2("setup:conversion-action"),
+    requestedActionName: text2(160),
+    type: literal2("UPLOAD_CLICKS"),
+    category: literal2(RESONANCE_GOOGLE_SOURCE_CATEGORIES.qualified_lead),
+    countingType: literal2("ONE_PER_CLICK"),
+    clickThroughLookbackWindowDays: integer2(1, 90),
+    primaryForGoal: literal2(false)
+  }),
+  goalActionKey: literal2("setup:conversion-action"),
+  goalStrategy: literal2("exclusive_custom_goal_v1")
+});
+var googleSaveCommonFields = { schemaVersion: literal2(1), expectedCampaignRevision: integer2(1), expectedRevision: integer2(0), idempotencyKey: operationKey, signalSemantics: googleSignalSemantics, declaration: object2(googleDeclarationChoiceFields) };
+var googleSave = union2(
+  object2({ ...googleSaveCommonFields, mode: literal2("existing"), nativeGoal: object2(googleGoalChoiceFields) }),
+  object2({ ...googleSaveCommonFields, mode: literal2("admitted_setup"), setupIntent: object2({ requestedGoalName: text2(160), requestedActionName: text2(160) }) })
+);
+var googleGoalDraft = object2({ ...googleGoalChoiceFields, name: nullable2(text2(200, void 0, 0)), revision: nullable2(digest) });
+var googleGoalReviewed = object2({ ...googleGoalChoiceFields, name: text2(200, void 0, 0), revision: digest });
+var googleDeclared = object2({
+  ...googleDeclarationChoiceFields,
+  creativeDigest: digest,
+  locationIds: list2(text2(80), 100, 1),
+  excludedLocationIds: list2(text2(80), 100),
+  declaredByActorId: uuid2,
+  declaredAt: instant,
+  declaredForCampaignRevision: integer2(1)
+});
+var googleConfigurationFields = {
+  projectId: uuid2,
+  campaignId: uuid2,
+  channelId: uuid2,
+  site,
+  accountBindingId: uuid2,
+  configurationRevision: integer2(1),
+  configurationDigest: digest,
+  signalSemantics: googleSignalSemantics,
+  source,
+  measurementRevision: revision,
+  countingUnit: objectiveCountingUnit,
+  attributionWindowDays: integer2(1, 365),
+  declaration: googleDeclared
+};
+var googleExistingChoiceFields = { mode: literal2("existing"), nativeGoal: googleGoalDraft };
+var googleSetupChoiceFields = { mode: literal2("admitted_setup"), setupSpec: googleSetupSpec, setupDigest: digest };
+function checkGoogleConfiguration(value, at) {
+  if (value.source.projectId !== value.projectId || value.source.site !== value.site) fail2(at + ".source", "source scope mismatch");
+  unique(value.declaration.locationIds, at + ".declaration.locationIds");
+  unique(value.declaration.excludedLocationIds, at + ".declaration.excludedLocationIds");
+  value.declaration.locationIds.sort();
+  value.declaration.excludedLocationIds.sort();
+  const expected = googleUploadClicksSetupSemantics({ source: value.source, countingUnit: value.countingUnit, attributionWindowDays: value.attributionWindowDays });
+  if (value.mode === "existing") {
+    normalizeGoogleGoal(value.nativeGoal, at + ".nativeGoal");
+    return;
+  }
+  if (canonical({ type: value.setupSpec.action.type, category: value.setupSpec.action.category, countingType: value.setupSpec.action.countingType, clickThroughLookbackWindowDays: value.setupSpec.action.clickThroughLookbackWindowDays, primaryForGoal: value.setupSpec.action.primaryForGoal }) !== canonical(expected)) fail2(at + ".setupSpec.action", "canonical setup semantics mismatch");
+}
+var googleSnapshotBase = union2(object2({ ...googleConfigurationFields, ...googleExistingChoiceFields }), object2({ ...googleConfigurationFields, ...googleSetupChoiceFields }));
+var googleConfigurationSnapshot = refine2(googleSnapshotBase, checkGoogleConfiguration);
+var googleConfigurationReview = refine2(union2(object2({ ...googleConfigurationFields, mode: literal2("existing"), nativeGoal: googleGoalReviewed }), object2({ ...googleConfigurationFields, ...googleSetupChoiceFields })), checkGoogleConfiguration);
+var { configurationRevision: _configurationRevisionField, ...googleViewContentFields } = googleConfigurationFields;
+var googleReadinessFields = { ready: bool, activationReadiness: choice2("blocked", "pending_setup", "requires_final_verification", "verified"), reasonCodes: list2(text2(200), 100) };
+var googleViewFields = { ...googleViewContentFields, revision: integer2(1), ...googleReadinessFields };
+var googleViewBase = union2(object2({ ...googleViewFields, ...googleExistingChoiceFields }), object2({ ...googleViewFields, ...googleSetupChoiceFields }));
+function checkGoogleView(value, at) {
+  checkGoogleConfiguration(value, at);
+  if (!value.ready && value.activationReadiness !== "blocked") fail2(at + ".activationReadiness", "unready configuration must be blocked");
+  if (value.mode === "existing") {
+    if (value.ready && (value.nativeGoal.name === null || value.nativeGoal.revision === null)) fail2(at + ".ready", "unavailable native evidence cannot be ready");
+    if (value.ready && value.activationReadiness !== "requires_final_verification" && value.activationReadiness !== "verified") fail2(at + ".activationReadiness", "existing native setup needs current verification");
+  } else if (value.ready && value.activationReadiness !== "pending_setup") fail2(at + ".activationReadiness", "reviewed setup intent is not native activation");
+}
+var googleConfigurationView = refine2(googleViewBase, checkGoogleView);
+var googleSaveResultFields = { operationId: uuid2, replayed: bool, campaignRevision: integer2(1) };
+var googleConfigurationSaveResponse = refine2(union2(object2({ ...googleViewFields, ...googleExistingChoiceFields, ...googleSaveResultFields }), object2({ ...googleViewFields, ...googleSetupChoiceFields, ...googleSaveResultFields })), checkGoogleView);
+refine2(union2(object2({ ...googleConfigurationFields, ...googleExistingChoiceFields, configurationDigest: optional2(digest) }), object2({ ...googleConfigurationFields, ...googleSetupChoiceFields, configurationDigest: optional2(digest) })), checkGoogleConfiguration);
+googleSetupSpec.schema;
+googleSave.schema;
+googleConfigurationSnapshot.schema;
+googleConfigurationReview.schema;
+googleConfigurationView.schema;
+googleConfigurationSaveResponse.schema;
+var preparedManifestRef = object2({ id: uuid2, digest, providerVersion: text2(30), revision });
+var preview = object2({ channelId: uuid2, site, accountBindingId: nullable2(uuid2), accountName: text2(200), accountTimeZone: timeZone, destinationUrl: text2(4096), attributionMarker: optional2(object2({ parameter: literal2(RESONANCE_SOURCE_MARKER_PARAMETER), value: sourceMarker })), orderedCreatives: list2(creative, 50, 1), audienceRuleRefs: list2(audience, 100), allocation: nullable2(money), capabilityRevision: revision, snapshotDigest: digest, manifestRef: preparedManifestRef, conversionRevision: revision, policyRevision: revision, googleConfiguration: nullable2(googleConfigurationReview) });
+var prepared = object2({ schemaVersion: literal2(1), id: uuid2, campaignId: uuid2, projectId: uuid2, expectedRevision: integer2(1), definitionDigest: digest, reviewDigest: digest, definition, resolvedEvidencePolicy: optimizationPolicy, resolvedQualificationRule: nullable2(resolvedQualificationRule), accounts: list2(capability, 100), channelPreviews: list2(preview, 100, 1), preparedAt: instant, expiresAt: instant, blockingReasons: list2(text2(200), 100) });
+var commandBase = { schemaVersion: literal2(1), campaignId: uuid2, expectedRevision: integer2(1), idempotencyKey: operationKey, channelIds: list2(uuid2, 100) };
+var effect = object2({ ...commandBase, operation: choice2("launch", "update", "resume"), preparedPlanId: uuid2, reviewDigest: digest, mandateRef, expectedRemoteSnapshots: list2(object2({ channelId: uuid2, digest }), 100) });
+var optimize = object2({ ...commandBase, operation: literal2("optimize"), preparedPlanId: uuid2, reviewDigest: digest, mandateRef, decisionRef: object2({ id: uuid2, revision, evidenceDigest: digest }), expectedRemoteSnapshots: list2(object2({ channelId: uuid2, digest }), 100) });
+var safety = object2({ ...commandBase, operation: choice2("pause", "finish", "reconcile") });
+var deliverConversion = object2({ ...commandBase, operation: literal2("deliver_conversion"), channelIds: list2(uuid2, 1, 1), preparedPlanId: uuid2, reviewDigest: digest, mandateRef, conversionId: uuid2 });
+var deliverWebsiteVisit = object2({ ...commandBase, operation: literal2("deliver_website_visit"), channelIds: list2(uuid2, 1, 1), preparedPlanId: uuid2, reviewDigest: digest, mandateRef, occurrenceId: uuid2 });
+var command = union2(effect, optimize, safety, deliverConversion, deliverWebsiteVisit);
+command.schema;
+var step = object2({ id: uuid2, channelId: uuid2, state: choice2("planned", "admitted", "confirmed", "failed", "uncertain"), providerRequestId: nullable2(text2(200)), admission: choice2("not_dispatched", "accepted", "rejected", "unknown"), configuredStatus: nullable2(text2(80)), effectiveStatus: nullable2(text2(80)), reviewStatus: nullable2(text2(80)), retryAfter: nullable2(instant), errorSubcode: nullable2(text2(80)), errorFieldPath: nullable2(text2(200)), resourceRefs: list2(object2({ type: text2(80), externalId: text2(200) }), 100), evidenceDigest: nullable2(digest), errorCode: nullable2(text2(80)), observedAt: nullable2(instant) });
+var receipt = object2({ schemaVersion: literal2(1), id: uuid2, projectId: uuid2, campaignId: uuid2, preparedPlanId: nullable2(uuid2), effectKey: text2(200), requestDigest: digest, ledgerActionId: uuid2, actorId: text2(160), state: choice2("pending", "applying", "accepted", "failed", "needs_reconciliation"), steps: list2(step, 1e3), reservedExposure: money, unreconciledExposure: money, providerSemanticsNotice: list2(text2(500), 30), nextActions: list2(choice2("read", "reconcile", "retry_same_operation", "pause", "escalate"), 5) });
+var lifecycle = choice2("not_materialized", "pending", "partially_live", "live", "pausing", "paused", "finished", "needs_attention", "unknown");
+var view = object2({ id: uuid2, projectId: uuid2, managementMode: choice2("tracking_only", "managed"), revision: integer2(0), definition: nullable2(draft), acceptedPlanId: nullable2(uuid2), desiredLifecycle: choice2("draft", "running", "paused", "finished"), effectiveLifecycle: lifecycle, blockingReasons: list2(text2(200), 100), activeOperation: nullable2(receipt), unresolvedExposure: nullable2(money) });
+var metricValue = union2(object2({ kind: literal2("count"), count: decimal }), object2({ kind: literal2("money"), money }), object2({ kind: literal2("ratio"), numerator: decimal, denominator: refine2(decimal, (v, p) => {
+  if (v === "0") fail2(p, "zero denominator");
+}) }));
+var metricBase = { ...scope, campaignId: uuid2, name: choice2("impressions", "clicks", "spend", "accepted_goals", "qualified_goals", "revenue", "conversion_rate", "reach", "results"), source: choice2("first_party", "provider", "experiment"), sourceRef: revision, goalRevision: nullable2(revision), countingUnit: choice2("unique_source", "unique_qualified_contact", "net_order", "provider_aggregate", "provider_unique_reach"), windowStart: instant, windowEnd: instant, timeZone, attributionModel: nullable2(text2(100)), asOf: instant, dataThrough: nullable2(instant), maturityDelaySeconds: integer2(0), coverageBasisPoints: nullable2(integer2(0, 1e4)), eligibleExposures: nullable2(decimal), matureOutcomes: nullable2(decimal), native: nullable2(object2({ unit: text2(80), amount: decimal, currency: nullable2(currency), unitExponent: integer2(0, 9), providerVersion: text2(30) })) };
+var metric = union2(object2({ ...metricBase, state: literal2("observed"), value: metricValue }), object2({ ...metricBase, state: choice2("unknown", "insufficient", "delayed", "unavailable"), value: literal2(null), reasonCode: text2(80) }));
+var purpose = choice2("analytics_storage", "ad_storage", "ad_user_data", "ad_personalization");
+var consent = object2({ ...scope, receiptId: uuid2, visitorNamespace: text2(160), configRevision: revision, policyRevision: revision, consentRevision: integer2(1), state: choice2("unknown", "granted", "denied", "withdrawn"), purpose, observedAt: instant, evidenceRef: revision });
+var exposure = object2({ ...scope, experimentId: uuid2, experimentRevision: integer2(1), assignmentId: uuid2, variantKey: text2(80), exposureId: uuid2, occurredAt: instant });
+var conversion = object2({ schemaVersion: literal2(1), ...scope, eventId: uuid2, sourceRef: source, campaignId: nullable2(uuid2), goalRevision: revision, occurredAt: instant, receivedAt: instant, value: union2(object2({ state: literal2("observed"), money }), object2({ state: choice2("unknown", "unavailable"), money: literal2(null), reasonCode: text2(80) })), consent: list2(consent, 4), experiment: nullable2(exposure) });
+conversion.schema;
+prepared.schema;
+capability.schema;
+mandateScope.schema;
+mandateRef.schema;
+receipt.schema;
+view.schema;
+metric.schema;
+consent.schema;
+var mandateTarget = object2({ project_id: uuid2, campaign_id: uuid2 });
+var mandateApproval = object2({ schemaVersion: literal2(1), expectedRevision: integer2(1), preparedPlanId: uuid2, reviewDigest: digest, mandateDigest: digest, mandate: mandateScope });
+mandateApproval.schema;
+mandateTarget.schema;
+function canonical(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(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 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;
+commandPreparation.schema;
+var saveCommand = object2({ definition: draft, expectedRevision: optional2(integer2(0)), idempotencyKey: operationKey });
+var acceptCommand = object2({ expectedRevision: integer2(1), ledgerActionId: uuid2 });
+var bindingCommand = object2({ connectionId: uuid2, provider: choice2("google_ads", "meta_ads"), externalAccountId: text2(160), expectedConnectionRevision: revision, idempotencyKey: operationKey });
+saveCommand.schema;
+acceptCommand.schema;
+bindingCommand.schema;
+var RESONANCE_CPQL_UNCERTAINTY_METHOD = "observational_cpql_missing_outcome_bound_v1";
+var allocationHorizon = union2(
+  refine2(object2({ kind: literal2("finite_period"), startAt: instant, endAt: instant, timeZone, sourceRef: revision }), (r, p) => {
+    if (Date.parse(r.endAt) <= Date.parse(r.startAt)) fail2(p, "invalid finite horizon");
+  }),
+  object2({ kind: literal2("daily_average"), timeZone, sourceRef: revision })
+);
+var uncertaintySource = object2({ method: literal2(RESONANCE_CPQL_UNCERTAINTY_METHOD), eligibleContacts: decimal, fullyResolvedContacts: decimal, qualifiedContacts: decimal, verifiedSpend: money, sourceRevision: revision, qualificationRuleRef: resource, universeComplete: literal2(true), spendPeriodComplete: literal2(true) });
+var allocationEvidenceFields = {
+  id: uuid2,
+  revision,
+  evidenceDigest: digest,
+  projectId: uuid2,
+  campaignId: uuid2,
+  preparedPlanId: uuid2,
+  reviewDigest: digest,
+  observedAt: instant,
+  windowStart: instant,
+  windowEnd: instant,
+  dataThrough: nullable2(instant),
+  lastAdjustmentAt: nullable2(instant),
+  currentKillRevision: integer2(0),
+  goalRevision: revision,
+  objective,
+  policyDigest: digest,
+  resolvedPolicy: matureOptimizationPolicy,
+  trackingState: choice2("healthy", "blocked", "unknown"),
+  coverageBasisPoints: nullable2(integer2(0, 1e4)),
+  assignmentCheck: choice2("pass", "failed", "unknown", "not_applicable"),
+  powerCheck: choice2("pass", "failed", "unknown", "not_applicable")
+};
+var allocationChannelFields = { channelId: uuid2, site, accountBindingId: uuid2, trackingState: choice2("healthy", "blocked", "unknown"), coverageBasisPoints: nullable2(integer2(0, 1e4)), coverageFamily: choice2("crm_attribution", "provider_import", "experiment_exposure"), coverageDefinitionRef: resource, coveredNumerator: nullable2(decimal), eligibleDenominator: nullable2(decimal), uncertaintyBasisPoints: nullable2(integer2(0, 1e4)), uncertaintySource: nullable2(uncertaintySource), dedupeCheck: choice2("pass", "failed", "unknown", "not_applicable"), qualificationCheck: choice2("pass", "failed", "unknown", "not_applicable"), reasonCodes: list2(text2(80), 50), capabilityRevision: revision, budgetMode: choice2("campaign_total", "average_daily", "lifetime", "daily"), allocationHorizon: nullable2(allocationHorizon), matureThrough: nullable2(instant), dataThrough: nullable2(instant), goalRevision: revision, countingUnit: choice2("unique_source", "unique_qualified_contact", "net_order"), attributionModel: text2(100), attributionWindowDays: integer2(1, 365), policyRevision: revision, currentAllocation: money, remoteSnapshotDigest: digest, observations: list2(metric, 100), providerUnitExponent: refine2(integer2(0, 6), (v, p) => {
+  if (![0, 2, 3, 6].includes(v)) fail2(p, "unsupported provider exponent");
+}), providerMaxUnits: decimal };
+var { uncertaintySource: _legacyUncertaintyField, ...reportedChannelFields } = allocationChannelFields;
+var matureOptimizationEvidence = object2({ ...allocationEvidenceFields, resolvedPolicy: matureOptimizationPolicy, channels: list2(object2({ ...allocationChannelFields, uncertaintySource: nullable2(uncertaintySource) }), 100, 1) });
+var reportedCostFields = { basis: literal2("provider_reported_snapshot_v1"), observationId: uuid2, sourceEvidenceDigest: digest, reportedSpend: money, queriedFrom: instant, queriedThrough: instant, firstReceivedAt: instant, receivedAt: instant, recordedAt: instant, providerFinality: literal2("unknown"), correctionsPossible: literal2(true) };
+var reportedOutcomeSource = object2({ method: literal2(RESONANCE_CPQL_UNCERTAINTY_METHOD), eligibleContacts: decimal, fullyResolvedContacts: decimal, qualifiedContacts: decimal, sourceRevision: revision, qualificationRuleRef: resource, universeComplete: literal2(true) });
+var nativeSqlReadInstant = refine2(text2(32, /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,6}))?(?:Z|\+00:00)$/), (v, p) => {
+  const match = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,6}))?(?:Z|\+00:00)$/.exec(v);
+  const projected = match[1] + "." + (match[2] ?? "").padEnd(3, "0").slice(0, 3) + "Z";
+  if (!Number.isFinite(Date.parse(projected)) || new Date(projected).toISOString() !== projected) fail2(p, "invalid native SQL UTC instant");
+});
+var providerReadClock = object2({ kind: literal2("sql_before_provider_read_lower_bound_v1"), notBeforeAt: nativeSqlReadInstant });
+var channelReportedCost = object2({ ...reportedCostFields, readClock: providerReadClock });
+var reportedOptimizationEvidence = object2({
+  ...allocationEvidenceFields,
+  evidenceKind: literal2("reported_cpql_sql_clock_v1"),
+  resolvedPolicy: reportedOptimizationPolicy,
+  channels: list2(object2({ ...reportedChannelFields, channelReportedCost, outcomeSource: reportedOutcomeSource }), 100, 1)
+});
+var optimizationEvidenceRefFields = { id: uuid2, revision, evidenceDigest: digest };
+var optimizationEvidenceRef = object2(optimizationEvidenceRefFields);
+var finiteOwnMeasurement = union2(
+  object2({ state: literal2("unobserved"), observations: literal2(null), reasonCodes: list2(text2(80), 50) }),
+  object2({ state: choice2("pending", "blocked"), observations: nullable2(list2(metric, 100)), reasonCodes: list2(text2(80), 50) }),
+  object2({ state: literal2("mature"), observations: list2(metric, 100, 1), reasonCodes: list2(text2(80), 50) })
+);
+var finiteCandidateObservation = object2({
+  channelId: uuid2,
+  site,
+  accountBindingId: uuid2,
+  graphDigest: digest,
+  manifestRef: preparedManifestRef,
+  cap: positiveMoneyShape,
+  flight: object2({ startAt: instant, endAt: instant, timeZone }),
+  lifecycle: choice2("not_materialized", "paused", "active", "stopped", "unknown"),
+  nativeStateEvidenceRef: nullable2(optimizationEvidenceRef),
+  commitmentEvidenceRef: nullable2(object2({ ...optimizationEvidenceRefFields, commitmentOperationId: uuid2 })),
+  activationsObserved: integer2(0, 1),
+  trackingState: choice2("healthy", "blocked", "unknown"),
+  coverageBasisPoints: nullable2(integer2(0, 1e4)),
+  dedupeCheck: choice2("pass", "failed", "unknown", "not_applicable"),
+  qualificationCheck: choice2("pass", "failed", "unknown", "not_applicable"),
+  reasonCodes: list2(text2(80), 50),
+  ownMeasurement: finiteOwnMeasurement
+});
+var finiteOptimizationEvidence = object2({
+  id: uuid2,
+  revision,
+  evidenceDigest: digest,
+  projectId: uuid2,
+  campaignId: uuid2,
+  preparedPlanId: uuid2,
+  reviewDigest: digest,
+  observedAt: instant,
+  windowStart: instant,
+  windowEnd: instant,
+  dataThrough: nullable2(instant),
+  lastAdjustmentAt: nullable2(instant),
+  currentKillRevision: integer2(0),
+  goalRevision: revision,
+  objective,
+  policyDigest: digest,
+  resolvedPolicy: finiteMetaCandidatePolicy,
+  trackingState: choice2("healthy", "blocked", "unknown"),
+  coverageBasisPoints: nullable2(integer2(0, 1e4)),
+  assignmentCheck: choice2("pass", "failed", "unknown", "not_applicable"),
+  powerCheck: choice2("pass", "failed", "unknown", "not_applicable"),
+  evidenceKind: literal2("finite_candidate_lifecycle_v1"),
+  inventoryState: choice2("complete", "incomplete", "unknown"),
+  candidates: list2(finiteCandidateObservation, 100, 1)
+});
+var optimizationEvidence = union2(matureOptimizationEvidence, finiteOptimizationEvidence, reportedOptimizationEvidence);
+var matureOptimizationDecision = object2({
+  id: uuid2,
+  revision,
+  projectId: uuid2,
+  campaignId: uuid2,
+  preparedPlanId: uuid2,
+  reviewDigest: digest,
+  evidenceRef: optimizationEvidenceRef,
+  policyDigest: digest,
+  requestDigest: digest,
+  expiresAt: instant,
+  algorithmRevision: revision,
+  sourceRefs: list2(revision, 200),
+  state: choice2("actionable", "noop", "blocked"),
+  decisionKind: choice2("observational_allocation", "experimental_promotion"),
+  executionOrder: literal2("reduce_then_increase"),
+  reasonCodes: list2(text2(80), 50),
+  adjustments: list2(object2({ channelId: uuid2, site, budgetMode: choice2("campaign_total", "average_daily", "lifetime", "daily"), providerUnitExponent: refine2(integer2(0, 6), (v, p) => {
+    if (![0, 2, 3, 6].includes(v)) fail2(p, "unsupported provider exponent");
+  }), providerMaxUnits: decimal, before: money, after: money, remoteSnapshotDigest: digest }), 100),
+  createdAt: instant
+});
+var finiteCandidateActionFields = { channelId: uuid2, graphDigest: digest, nativeStateEvidenceRef: optimizationEvidenceRef };
+var finiteCandidateActionBody = union2(
+  object2({ action: literal2("materialize_and_activate"), ...finiteCandidateActionFields }),
+  object2({ action: literal2("activate_held"), ...finiteCandidateActionFields, commitmentOperationId: uuid2 }),
+  object2({ action: literal2("pause_candidate"), ...finiteCandidateActionFields })
+);
+var finiteDecisionFields = {
+  id: uuid2,
+  revision,
+  projectId: uuid2,
+  campaignId: uuid2,
+  preparedPlanId: uuid2,
+  reviewDigest: digest,
+  evidenceRef: optimizationEvidenceRef,
+  policyDigest: digest,
+  requestDigest: digest,
+  expiresAt: instant,
+  createdAt: instant,
+  algorithmRevision: literal2("finite_meta_candidates_v1"),
+  sourceRefs: list2(revision, 200),
+  decisionKind: literal2("preapproved_candidate_operation"),
+  reasonCodes: list2(text2(80), 50, 1)
+};
+var finiteOptimizationDecision = union2(
+  object2({ ...finiteDecisionFields, state: literal2("actionable"), candidateActions: list2(finiteCandidateActionBody, 1, 1) }),
+  object2({ ...finiteDecisionFields, state: choice2("noop", "blocked"), candidateActions: list2(finiteCandidateActionBody, 0) })
+);
+var optimizationDecision = union2(matureOptimizationDecision, finiteOptimizationDecision);
+optimizationEvidence.schema;
+optimizationDecision.schema;
+var metaBrowserWitness = object2({ controlsRevision: text2(60, /^[A-Z][A-Z0-9_]*$/), policyRevision: revision, witnessId: uuid2, assertedAt: instant });
+var publicDestination = union2(
+  object2({ provider: literal2("google_ads"), id: uuid2, tagId: text2(40, /^AW-[0-9]+$/) }),
+  // browserWitness and tagManagerAttested are optional so configurations from before the Meta loader keep parsing; absent means no Meta browser loading.
+  object2({ provider: literal2("meta_ads"), id: uuid2, pixelId: text2(40, /^[0-9]+$/), browserWitness: optional2(metaBrowserWitness), tagManagerAttested: optional2(bool) })
+);
+var interestResource = object2({ ...scope, type: choice2("page", "article", "product", "listing"), id: text2(160, /^[a-zA-Z0-9._:-]+$/), revision });
+var measurementConfig = object2({
+  schemaVersion: literal2(1),
+  ...scope,
+  configRevision: revision,
+  policyRevision: revision,
+  expiresAt: instant,
+  enabled: bool,
+  consentPolicy: object2({ mode: literal2("basic"), requiredPurposes: list2(purpose, 4, 1) }),
+  destinations: list2(publicDestination, 10),
+  // metaEligible is set by a person with owner or admin standing; absent means false. The browser never decides it.
+  resourceRules: list2(object2({ id: uuid2, revision, site, resource: interestResource, path, interestKey: text2(100, /^[a-zA-Z0-9._:-]+$/), metaEligible: optional2(bool) }), 500)
+});
+function parseResonanceMeasurementConfig(v) {
+  const r = measurementConfig.read(v, "measurementConfig");
+  scoped(r, r.projectId, [r.site], "measurementConfig");
+  unique(r.destinations.map((d) => d.id), "measurementConfig.destinations");
+  unique(r.consentPolicy.requiredPurposes, "measurementConfig.consentPolicy.requiredPurposes");
+  unique(r.resourceRules.map((rule) => rule.id), "measurementConfig.resourceRules");
+  if (r.destinations.length && ["ad_storage", "ad_user_data", "ad_personalization"].some((p) => !r.consentPolicy.requiredPurposes.includes(p))) fail2("measurementConfig.consentPolicy", "provider minimum purposes are mandatory");
+  return r;
+}
+var clickIdentifierPattern = /^[^\s\u0000-\u001f\u007f-\u009f]+(?![\s\S])/;
+var clickIdentifier = field2({ type: "string", minLength: 1, maxLength: 1024, pattern: clickIdentifierPattern.source }, (v, p) => typeof v === "string" && v.length <= 2048 && [...v].length <= 1024 && clickIdentifierPattern.test(v) ? v : fail2(p, "invalid click identifier"));
+var clickIdentifiersShape = union2(object2({ gclid: clickIdentifier }), object2({ gbraid: clickIdentifier }), object2({ wbraid: clickIdentifier }));
+var clickIdentifiers = field2(clickIdentifiersShape.schema, clickIdentifiersShape.read);
+var parseResonanceClickIdentifiers = (v) => clickIdentifiers.read(v, "clickIdentifiers");
+clickIdentifiers.schema;
+var observedPathControl = /[\s\u0000-\u001f\u007f-\u009f]/;
+var observedPagePath = field2({ ...path.schema, allOf: [{ not: { pattern: observedPathControl.source } }] }, (v, p) => {
+  const result = path.read(v, p);
+  if (observedPathControl.test(result)) fail2(p, "invalid observed path");
+  return result;
+});
+var metaCookieShape = object2({ source: literal2(RESONANCE_WEBSITE_VISIT_PROFILE.source), fbp: optional2(clickIdentifier), fbc: optional2(clickIdentifier) });
+var metaCookieObservation = field2({ ...metaCookieShape.schema, anyOf: [{ required: ["fbp"] }, { required: ["fbc"] }] }, (v, p) => {
+  const result = metaCookieShape.read(v, p);
+  if (!result.fbp && !result.fbc) fail2(p, "requires an actual reported cookie value");
+  return result;
+});
+var occurrenceShape = object2({
+  schemaVersion: literal2(1),
+  ...scope,
+  configRevision: revision,
+  eventId: uuid2,
+  navigationId: uuid2,
+  occurredAt: instant,
+  kind: choice2("page_view", "content_interest", "experiment_exposure"),
+  sourceMarker: optional2(sourceMarker),
+  resourceRef: nullable2(interestResource),
+  campaignPlanId: nullable2(uuid2),
+  experiment: nullable2(exposure),
+  clickIdentifiers: optional2(clickIdentifiers),
+  pagePath: optional2(observedPagePath),
+  metaCookieObservation: optional2(metaCookieObservation),
+  consentReceiptRefs: list2(object2({ purpose, receiptId: uuid2, consentRevision: integer2(1) }), 4)
+});
+var occurrence = field2({ ...occurrenceShape.schema, allOf: [
+  { if: { required: ["clickIdentifiers"] }, then: { properties: { kind: { const: "page_view" } } } },
+  { if: { required: ["pagePath"] }, then: { properties: { kind: { enum: ["page_view", "experiment_exposure"] } } } },
+  { if: { required: ["metaCookieObservation"] }, then: { required: ["pagePath"], properties: { kind: { const: "page_view" }, resourceRef: interestResource.schema } } }
+] }, (v, p) => {
+  const r = occurrenceShape.read(v, p);
+  if (r.clickIdentifiers && r.kind !== "page_view") fail2(p + ".clickIdentifiers", "requires page_view");
+  if (r.pagePath !== void 0 && r.kind !== "page_view" && r.kind !== "experiment_exposure") fail2(p + ".pagePath", "requires page_view or experiment_exposure");
+  if (r.metaCookieObservation && (r.kind !== "page_view" || r.pagePath === void 0 || !r.resourceRef)) fail2(p + ".metaCookieObservation", "requires the same page_view path and resource");
+  return r;
+});
+function parseResonanceMeasurementOccurrence(v) {
+  const r = occurrence.read(v, "occurrence");
+  scoped(r, r.projectId, [r.site], "occurrence");
+  unique(r.consentReceiptRefs.map((c) => c.purpose), "occurrence.consentReceiptRefs");
+  if (r.kind === "content_interest" && !r.resourceRef) fail2("occurrence.resourceRef", "content interest requires resource");
+  if (r.kind === "experiment_exposure" && !r.experiment) fail2("occurrence.experiment", "exposure requires assignment context");
+  return r;
+}
+var consentUpdate = object2({ schemaVersion: literal2(1), ...scope, configRevision: revision, policyRevision: revision, expectedConsentRevision: integer2(0), occurredAt: instant, idempotencyKey: operationKey, source: choice2("cmp", "user_preference"), purposes: list2(object2({ purpose, state: choice2("unknown", "granted", "denied", "withdrawn") }), 4, 1) });
+function parseResonanceConsentUpdate(v) {
+  const r = consentUpdate.read(v, "consentUpdate");
+  unique(r.purposes.map((p) => p.purpose), "consentUpdate.purposes");
+  return r;
+}
+measurementConfig.schema;
+occurrence.schema;
+consentUpdate.schema;
+var consentResult = object2({ subjectProof: text2(200, /^[a-zA-Z0-9_-]{32,}$/), expiresAt: instant, currentConsentRevision: integer2(1), receipts: list2(consent, 4, 4) });
+function parseResonanceConsentResponse(v) {
+  const r = consentResult.read(v, "consentResponse"), first = r.receipts[0];
+  if (r.receipts.some((c) => c.consentRevision !== r.currentConsentRevision)) fail2("consentResponse.receipts", "global consent revision mismatch");
+  unique(r.receipts.map((c) => c.purpose), "consentResult.receipts");
+  for (const c of r.receipts) if (c.projectId !== first.projectId || c.site !== first.site || c.configRevision !== first.configRevision || c.policyRevision !== first.policyRevision || c.visitorNamespace !== first.visitorNamespace) fail2("consentResult.receipts", "mixed consent subjects or scope");
+  return r;
+}
+var occurrenceResult = object2({ eventId: uuid2, accepted: literal2(true), replayed: bool, exposureId: nullable2(uuid2) });
+var parseResonanceOccurrenceResponse = (v) => occurrenceResult.read(v, "occurrenceResult");
+consentResult.schema;
+occurrenceResult.schema;
+var subjectRenew = object2({ schemaVersion: literal2(1), ...scope, expectedConsentRevision: integer2(1), configRevision: revision, policyRevision: revision });
+var parseResonanceSubjectRenewCommand = (v) => subjectRenew.read(v, "subjectRenew");
+subjectRenew.schema;
+resource.schema;
+audience.schema;
+experiment.schema;
+var audienceDraft = object2({
+  schemaVersion: literal2(1),
+  expectedRevision: optional2(integer2(1)),
+  idempotencyKey: operationKey,
+  definition: object2({ name: text2(160), site, accountBindingId: uuid2, resourceRuleId: uuid2, excludedResourceRuleIds: list2(uuid2, 50), retentionDays: integer2(1, 540), minDaysSinceVisit: optional2(integer2(1, 179)), policyRevision: revision, currentConsentPolicyRevision: revision })
+});
+audienceDraft.schema;
+var managedExperimentBase = { expectedRevision: integer2(1), idempotencyKey: operationKey };
+var experimentCreateField = field2(SIGNAL_EXPERIMENT_CREATE_JSON_SCHEMA, (v, p) => {
+  try {
+    return parseSignalExperimentCreate(v);
+  } catch (error) {
+    return fail2(p, error instanceof Error ? error.message : "invalid experiment");
+  }
+});
+var experimentUpdateField = field2(SIGNAL_EXPERIMENT_UPDATE_JSON_SCHEMA, (v, p) => {
+  try {
+    return parseSignalExperimentUpdate(v);
+  } catch (error) {
+    return fail2(p, error instanceof Error ? error.message : "invalid experiment");
+  }
+});
+var managedExperimentCreate = object2({ ...managedExperimentBase, experiment: experimentCreateField });
+var managedExperimentUpdate = object2({ ...managedExperimentBase, experiment: experimentUpdateField });
+var managedExperimentLifecycle = object2(managedExperimentBase);
+var managedExperimentComplete = object2({ ...managedExperimentBase, winnerVariant: text2(80) });
+var managedExperimentLink = object2({ ...managedExperimentBase, experimentId: uuid2 });
+managedExperimentCreate.schema;
+managedExperimentUpdate.schema;
+managedExperimentLifecycle.schema;
+managedExperimentComplete.schema;
+managedExperimentLink.schema;
+var nativePageRevision = field2({ ...instant.schema, pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z(?![\\s\\S])" }, (v, p) => {
+  const result = instant.read(v, p);
+  if (new Date(result).toISOString() !== result) fail2(p, "requires canonical UTC milliseconds");
+  return result;
+});
+var positiveRevision = text2(128, /^[1-9][0-9]*(?![\s\S])/);
+var friendlyName = field2({ type: "string", minLength: 0, maxLength: 200 }, (v, p) => typeof v === "string" && [...v].length <= 200 ? v : fail2(p, "invalid friendly name"));
+var setupConsentPolicyShape = object2({ mode: literal2("basic"), requiredPurposes: uniqueList(purpose, 4, 3) });
+var setupConsentPolicy = field2({ ...setupConsentPolicyShape.schema, allOf: [{ properties: { requiredPurposes: { allOf: ["ad_storage", "ad_user_data", "ad_personalization"].map((value) => ({ contains: { const: value } })) } } }] }, (input, p) => {
+  const v = setupConsentPolicyShape.read(input, p);
+  for (const required of ["ad_storage", "ad_user_data", "ad_personalization"]) if (!v.requiredPurposes.includes(required)) fail2(p, "all advertising purpose requirements are mandatory");
+  return v;
+});
+var measurementSave = refine2(object2({
+  schemaVersion: literal2(1),
+  site,
+  expectedCampaignRevision: integer2(1),
+  expectedConfigurationRevision: integer2(0),
+  idempotencyKey: operationKey,
+  enabled: bool,
+  consentPolicy: setupConsentPolicy,
+  pages: list2(object2({ pageId: uuid2, observedRevision: nativePageRevision, observedDigest: digest }), 500, 1)
+}), (v, p) => unique(v.pages.map((page2) => page2.pageId), p + ".pages"));
+var measurementPage = object2({ pageId: uuid2, label: friendlyName, path: observedPagePath, pageRevision: nativePageRevision, evidenceDigest: digest, resourceRuleId: uuid2, resourceRuleRevision: digest });
+var measurementSavedFields = { configurationRevision: integer2(1), configurationDigest: digest, configuration: measurementConfig, saveOperationId: uuid2, pages: list2(measurementPage, 500, 1) };
+object2(measurementSavedFields);
+function checkMeasurementSaved(v, p) {
+  const config = parseResonanceMeasurementConfig(v.configuration);
+  if (config.projectId !== v.projectId || config.site !== v.site) fail2(p + ".configuration", "configuration scope mismatch");
+  positiveRevision.read(config.configRevision, p + ".configuration.configRevision");
+  positiveRevision.read(config.policyRevision, p + ".configuration.policyRevision");
+  setupConsentPolicy.read(config.consentPolicy, p + ".configuration.consentPolicy");
+  unique(v.pages.map((page2) => page2.pageId), p + ".pages");
+  if (v.pages.length !== config.resourceRules.length) fail2(p + ".pages", "must cover the exact native page rules");
+  for (const page2 of v.pages) {
+    const rule = config.resourceRules.find((rule2) => rule2.id === page2.resourceRuleId);
+    if (page2.resourceRuleId !== page2.pageId || page2.resourceRuleRevision !== page2.evidenceDigest || !rule || rule.revision !== page2.evidenceDigest || rule.path !== page2.path || rule.interestKey !== page2.pageId || rule.resource.type !== "page" || rule.resource.id !== page2.pageId || rule.resource.revision !== page2.pageRevision) fail2(p + ".pages", "native page/resource/rule version mismatch");
+  }
+}
+var measurementCurrent = refine2(union2(
+  object2({ schemaVersion: literal2(1), kind: literal2("unconfigured"), ...scope, configurationRevision: literal2(0) }),
+  object2({ schemaVersion: literal2(1), kind: literal2("configured"), ...scope, ...measurementSavedFields, reasonCodes: uniqueList(text2(200), 100) })
+), (v, p) => {
+  if (v.kind === "configured") checkMeasurementSaved(v, p);
+});
+var measurementSnapshotFields = { schemaVersion: literal2(1), ...scope, campaignId: uuid2, operationId: uuid2, configurationRevision: integer2(1), configurationDigest: digest, configuration: measurementConfig, pages: list2(measurementPage, 500, 1) };
+var measurementSnapshotShape = object2(measurementSnapshotFields);
+function checkMeasurementSnapshot(v, p) {
+  checkMeasurementSaved({ ...v, saveOperationId: v.operationId }, p);
+}
+var measurementSnapshot = refine2(measurementSnapshotShape, checkMeasurementSnapshot);
+var measurementSaveResponse = refine2(object2({ ...measurementSnapshotFields, replayed: bool }), checkMeasurementSnapshot);
+object2({ projectId: uuid2, current: measurementCurrent, pages: list2(object2({ pageId: uuid2, label: friendlyName, path: observedPagePath, pageRevision: nativePageRevision, evidenceDigest: digest }), 500, 1), expiresAt: instant });
+measurementSave.schema;
+measurementCurrent.schema;
+measurementSnapshot.schema;
+measurementSaveResponse.schema;
+var nativeAudienceRef = object2({ externalId: text2(160, /^[0-9]+(?![\s\S])/), revision: digest });
+var metaSave = refine2(object2({
+  schemaVersion: literal2(1),
+  expectedCampaignRevision: integer2(1),
+  expectedConfigurationRevision: integer2(0),
+  idempotencyKey: operationKey,
+  audiences: list2(union2(object2({ audienceRuleId: uuid2, mode: literal2("existing"), nativeAudienceRef }), object2({ audienceRuleId: uuid2, mode: literal2("admitted_setup") })), 50, 1)
+}), (v, p) => unique(v.audiences.map((a) => a.audienceRuleId), p + ".audiences"));
+var metaResolvedAudience = object2({ audienceRuleRef: audience, name: friendlyName, resourceRuleRef: measurementRuleRef, excludedResourceRuleRefs: list2(measurementRuleRef, 50), selection: union2(
+  object2({ mode: literal2("existing"), nativeAudienceRef, nativeAudienceName: nullable2(friendlyName) }),
+  object2({ mode: literal2("admitted_setup"), setup: object2({ kind: literal2("meta_website_audience_v1"), localOutputKey: operationKey, specDigest: digest }) })
+) });
+var metaMaterialFields = {
+  schemaVersion: literal2(1),
+  projectId: uuid2,
+  campaignId: uuid2,
+  channelId: uuid2,
+  site,
+  campaignRevision: integer2(1),
+  reviewedDefinitionDigest: digest,
+  configurationRevision: integer2(1),
+  saveOperationId: uuid2,
+  channel: meta,
+  account: object2({ id: uuid2, externalId: text2(160), name: nullable2(friendlyName) }),
+  datasetName: nullable2(friendlyName),
+  pageName: nullable2(friendlyName),
+  instagramName: nullable2(friendlyName),
+  measurementConfigRef,
+  matchingProfileRef,
+  rules: list2(object2({ id: uuid2, revision, resource: interestResource, path: observedPagePath, label: friendlyName }), 500, 1),
+  audiences: list2(metaResolvedAudience, 50, 1)
+};
+object2(metaMaterialFields);
+function checkMetaMaterial(v, p) {
+  scoped(v, v.projectId, [v.site], p);
+  if (v.channel.id !== v.channelId || v.channel.accountBindingId !== v.account.id || v.matchingProfileRef.id !== v.saveOperationId || v.matchingProfileRef.revision !== v.configurationRevision) fail2(p, "original channel/account/profile receipt mismatch");
+  if (!v.channel.instagramRef && v.instagramName !== null) fail2(p + ".instagramName", "absent original Instagram identity requires null");
+  unique(v.rules.map((rule) => rule.id), p + ".rules");
+  unique(v.audiences.map((a) => a.audienceRuleRef.id), p + ".audiences");
+  unique(v.channel.audienceRuleRefs.map((a) => a.id), p + ".channel.audienceRuleRefs");
+  if (v.audiences.length !== v.channel.audienceRuleRefs.length) fail2(p + ".audiences", "must cover exactly the original logical audiences");
+  checkMetaAudienceBands(v.channel, p + ".channel.audienceRuleRefs");
+  for (const a of v.audiences) {
+    if (!v.channel.audienceRuleRefs.some((ref) => canonical(ref) === canonical(a.audienceRuleRef))) fail2(p + ".audiences", "original logical audience version mismatch");
+    unique(a.excludedResourceRuleRefs.map((ref) => ref.id), p + ".audiences.excludedResourceRuleRefs");
+    unique(a.audienceRuleRef.exclusionRuleIds, p + ".audiences.audienceRuleRef.exclusionRuleIds");
+    if (canonical([...a.audienceRuleRef.exclusionRuleIds].sort()) !== canonical(a.excludedResourceRuleRefs.map((ref) => ref.id).sort()) || a.excludedResourceRuleRefs.some((ref) => ref.id === a.resourceRuleRef.id)) fail2(p + ".audiences", "positive/excluded resource scope mismatch");
+    for (const selected of [a.resourceRuleRef, ...a.excludedResourceRuleRefs]) if (!v.rules.some((rule) => rule.id === selected.id && rule.revision === selected.revision)) fail2(p + ".audiences", "resource rule version mismatch");
+    if (a.selection.mode === "admitted_setup" && a.selection.setup.localOutputKey !== `audience:${a.audienceRuleRef.id}:${a.audienceRuleRef.revision}`) fail2(p + ".audiences.selection.setup.localOutputKey", "must retain the actual original SDK creator key");
+  }
+}
+var metaSnapshot = refine2(object2({ ...metaMaterialFields, configurationDigest: digest }), checkMetaMaterial);
+var parseResonanceMetaConfigurationSnapshot = (v) => metaSnapshot.read(v, "metaConfigurationSnapshot");
+refine2(object2({ ...metaMaterialFields, configurationDigest: optional2(digest) }), checkMetaMaterial);
+object2({ currentCampaignRevision: integer2(1), currentDefinitionDigest: digest, observedAt: instant, expiresAt: nullable2(instant), reasonCodes: uniqueList(text2(200), 100), pendingRequirements: uniqueList(text2(200), 100) });
+function metaReviewable(snapshot, metadata) {
+  return metadata.currentCampaignRevision >= snapshot.campaignRevision && metadata.currentDefinitionDigest === snapshot.reviewedDefinitionDigest && metadata.reasonCodes.length === 0 && metadata.expiresAt !== null && Date.parse(metadata.expiresAt) > Date.parse(metadata.observedAt);
+}
+var metaView = refine2(union2(
+  object2({ schemaVersion: literal2(1), kind: literal2("unconfigured"), projectId: uuid2, campaignId: uuid2, channelId: uuid2, configurationRevision: literal2(0) }),
+  object2({
+    schemaVersion: literal2(1),
+    kind: literal2("configured"),
+    projectId: uuid2,
+    campaignId: uuid2,
+    channelId: uuid2,
+    configurationRevision: integer2(1),
+    snapshot: metaSnapshot,
+    currentCampaignRevision: integer2(1),
+    currentDefinitionDigest: digest,
+    observedAt: instant,
+    expiresAt: nullable2(instant),
+    readyForReview: bool,
+    reasonCodes: uniqueList(text2(200), 100),
+    pendingRequirements: uniqueList(text2(200), 100)
+  })
+), (v, p) => {
+  if (v.kind !== "configured") return;
+  const s = parseResonanceMetaConfigurationSnapshot(v.snapshot);
+  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 metaSaveResponse = object2({ schemaVersion: literal2(1), snapshot: metaSnapshot, replayed: bool });
+metaSave.schema;
+metaSnapshot.schema;
+metaView.schema;
+metaSaveResponse.schema;
+var feedSelection = refine2(object2({ channels: list2(object2({ channelId: uuid2, expectedConfigurationRevision: integer2(1), resourceRuleRefs: list2(measurementRuleRef, 500, 1) }), 100, 1) }), (v, p) => {
+  unique(v.channels.map((c) => c.channelId), p + ".channels");
+  for (const c of v.channels) unique(c.resourceRuleRefs.map((ref) => ref.id), p + ".resourceRuleRefs");
+});
+var mandateDraftRequest = object2({ expectedRevision: integer2(1), allowedOperations: mandateAllowedOperations, expiresAt: instant, websiteVisitFeedSelection: optional2(feedSelection), providerReporting: optional2(providerReportingSelection) });
+mandateDraftRequest.schema;
+var feedReview = object2({ schemaVersion: literal2(1), approval: mandateApproval, mandateRef, configurations: list2(metaSnapshot, 100), current: object2({ state: choice2("not_enabled", "eligible", "invalidated", "unavailable"), checkedAt: instant, expiresAt: nullable2(instant), reasonCodes: uniqueList(text2(200), 100) }) });
+feedReview.schema;
+var observationIdentity = { observationId: uuid2, channelId: uuid2, versionId: uuid2, accountBindingId: uuid2 };
+var publicObservationMetric = union2(
+  object2({ ...metricBase, ...observationIdentity, source: choice2("provider", "first_party"), state: literal2("observed"), value: metricValue }),
+  object2({ ...metricBase, ...observationIdentity, source: choice2("provider", "first_party"), state: choice2("unknown", "insufficient", "delayed", "unavailable"), value: literal2(null), reasonCode: text2(80) })
+);
+var observationDenominators = object2({ eligibleContacts: nullable2(decimal), fullyResolvedContacts: nullable2(decimal), qualifiedContacts: nullable2(decimal) });
+var observationSupportFields = { ...observationIdentity, currency, fetchedAt: instant, dataThrough: nullable2(instant), coverage: choice2("unknown", "partial", "complete"), reasonCode: nullable2(text2(80)), denominators: observationDenominators };
+var firstPartyObservationSupport = object2({ ...observationSupportFields, source: literal2("first_party") });
+var providerObservationSupport = object2({
+  ...observationSupportFields,
+  source: literal2("provider"),
+  firstReceivedAt: nullable2(instant),
+  receivedAt: nullable2(instant),
+  recordedAt: nullable2(instant),
+  readClock: nullable2(providerReadClock),
+  providerFinality: literal2("unknown"),
+  correctionsPossible: literal2(true),
+  coverageBasis: choice2("closed_query_snapshot", "not_established")
+});
+var observationSupport = union2(firstPartyObservationSupport, providerObservationSupport);
+var observationsPage = object2({ items: list2(publicObservationMetric, 500), nextCursor: nullable2(uuid2), observedAt: instant, support: list2(observationSupport, 500) });
+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") {
+  const min = ref.minDaysSinceVisit;
+  if (min !== void 0 && min >= ref.retentionDays) fail2(at + ".minDaysSinceVisit", "must be shorter than the retention window");
+  if (provider === "google_ads") {
+    if (min !== void 0) fail2(at + ".minDaysSinceVisit", "Google audiences have no recency band");
+    return;
+  }
+  if (ref.retentionDays > META_WEBSITE_AUDIENCE_MAX_RETENTION_DAYS) fail2(at + ".retentionDays", `exceeds the ${META_WEBSITE_AUDIENCE_MAX_RETENTION_DAYS}-day Meta website audience maximum`);
+  if (1 + ref.exclusionRuleIds.length + (min === void 0 ? 0 : 1) > META_AUDIENCE_RULE_LIMIT) fail2(at + ".exclusionRuleIds", `a Meta audience holds at most ${META_AUDIENCE_RULE_LIMIT} rules including the page and any recency band`);
+}
+function checkMetaAudienceBands(channel2, at) {
+  if (!usesPropertyModel(channel2)) return;
+  channel2.audienceRuleRefs.forEach((ref, index) => checkAudienceBand(ref, "meta_ads", `${at}[${index}]`));
+}
+
+// src/resonance/controller.ts
+var payload = (body) => {
+  if (!body || typeof body !== "object" || body.success !== true || !("data" in body)) throw new Error("measurement_response_unavailable");
+  return body.data;
+};
+var ResonanceController = class {
+  constructor(options) {
+    this.options = options;
+    this.config = null;
+    this.proof = null;
+    this.adapter = null;
+    this.unsubscribe = null;
+    this.configEpoch = 0;
+    this.readEpoch = 0;
+    this.deliveryEpoch = 0;
+    this.stopped = false;
+    this.busy = false;
+    this.latest = null;
+    this.latestEpoch = 0;
+    this.completedEpoch = 0;
+    this.path = "";
+    this.sourceMarker = null;
+    this.navigationSequence = 0;
+    this.recordedNavigationKey = "";
+    this.navigation = null;
+    this.renderedFrame = null;
+    this.acceptedExposure = null;
+    this.retry = /* @__PURE__ */ new Map();
+    this.expiryTimer = null;
+    this.configExpiryTimer = null;
+    this.refreshTimer = null;
+    this.refreshing = false;
+    this.renewing = false;
+    this.renewalTimer = null;
+    this.status = { state: "unknown", reason: null };
+  }
+  now() {
+    return this.options.now?.() ?? Date.now();
+  }
+  changed() {
+    this.options.onState?.();
+  }
+  /** One current-navigation slot, not a history cache. A true identity change
+   * retires its receipt and retry work; late deliveries cannot rejoin it. */
+  discardRenderedFrame() {
+    const frame = this.renderedFrame;
+    if (!frame) return;
+    frame.active = false;
+    this.renderedFrame = null;
+    if (this.acceptedExposure?.frame === frame) this.acceptedExposure = null;
+    for (const [id, pending] of this.retry) if (pending.frame === frame) this.retry.delete(id);
+  }
+  invalidate() {
+    this.deliveryEpoch++;
+    this.navigation = null;
+    this.renderedFrame = null;
+    this.acceptedExposure = null;
+    this.retry.clear();
+    updateMeasurementPolicy({ proof: null, preferencePending: !!this.config?.enabled });
+    this.changed();
+  }
+  timerDelay(milliseconds) {
+    return Math.max(0, Math.min(2147483647, milliseconds));
+  }
+  timers() {
+    if (this.expiryTimer) clearTimeout(this.expiryTimer);
+    if (this.renewalTimer) clearTimeout(this.renewalTimer);
+    if (!this.proof) return;
+    const proofRemaining = Date.parse(this.proof.expiresAt) - this.now();
+    this.expiryTimer = setTimeout(() => {
+      if (this.proof && Date.parse(this.proof.expiresAt) > this.now()) {
+        this.timers();
+        return;
+      }
+      this.invalidate();
+      this.status.state = "blocked";
+      this.status.reason = "proof_expired";
+      this.changed();
+    }, this.timerDelay(proofRemaining));
+    this.renewalTimer = setTimeout(() => {
+      void this.renew();
+    }, this.timerDelay(Math.max(1e3, proofRemaining - Math.min(6e4, proofRemaining / 2))));
+    this.scheduleConfigRefresh();
+  }
+  scheduleConfigRefresh(delay) {
+    if (this.refreshTimer) clearTimeout(this.refreshTimer);
+    if (!this.config || this.stopped) return;
+    const remaining = Date.parse(this.config.expiresAt) - this.now();
+    if (this.configExpiryTimer) clearTimeout(this.configExpiryTimer);
+    this.configExpiryTimer = setTimeout(() => {
+      if (this.config && Date.parse(this.config.expiresAt) > this.now()) {
+        this.scheduleConfigRefresh();
+        return;
+      }
+      this.invalidate();
+      updateMeasurementPolicy({ collectionEpoch: measurementPolicySnapshot().collectionEpoch + 1 });
+      this.status.state = "blocked";
+      this.status.reason = "config_expired";
+      this.changed();
+    }, this.timerDelay(remaining));
+    this.refreshTimer = setTimeout(() => {
+      void this.refreshConfig();
+    }, this.timerDelay(delay ?? Math.max(1e3, remaining - Math.min(6e4, remaining / 2))));
+  }
+  /** A safe public read refreshes policy freshness without re-prompting or changing consent. */
+  async refreshConfig() {
+    if (!this.config || this.stopped || this.refreshing) return;
+    if (this.busy) {
+      this.scheduleConfigRefresh(1e3);
+      return;
+    }
+    const previous = this.config;
+    this.refreshing = true;
+    try {
+      const response = await this.options.transport.request(`/config?site=${encodeURIComponent(this.options.site)}`, { method: "GET", cache: "no-store" }, () => !this.stopped);
+      if (this.stopped || previous !== this.config) return;
+      if (response.status !== 200) throw new Error("config_refresh_unavailable");
+      const next = parseResonanceMeasurementConfig(payload(response.body));
+      if (next.projectId !== previous.projectId || next.site !== this.options.site || Date.parse(next.expiresAt) <= this.now()) throw new Error("config_scope_or_expiry");
+      if (this.busy) {
+        this.scheduleConfigRefresh(1e3);
+        return;
+      }
+      const sameRevision = next.configRevision === previous.configRevision && next.policyRevision === previous.policyRevision;
+      if (sameRevision && JSON.stringify({ ...next, expiresAt: "" }) !== JSON.stringify({ ...previous, expiresAt: "" })) throw new Error("config_revision_inconsistent");
+      this.config = next;
+      if (sameRevision) {
+        const resumable = this.latest?.valid && this.proof && Date.parse(this.proof.expiresAt) > this.now() && this.proof.receipts.every((r) => r.state === this.latest?.choices[r.purpose]);
+        updateMeasurementPolicy({ policy: this.configPolicy(next), config: next, proof: resumable ? this.proof : null });
+        if (this.proof) this.timers();
+        else this.scheduleConfigRefresh();
+        this.recordCurrentNavigation();
+      } else {
+        this.invalidate();
+        this.acceptedExposure = null;
+        this.proof = null;
+        this.latest = null;
+        this.latestEpoch++;
+        this.completedEpoch = this.latestEpoch;
+        updateMeasurementPolicy({
+          policy: this.configPolicy(next),
+          config: next,
+          identityScope: `${next.projectId}:${next.site}:${next.configRevision}`,
+          proof: null,
+          choices: unknownChoices(),
+          cmpValid: false,
+          preferencePending: !!this.adapter,
+          analyticsRequired: next.consentPolicy.requiredPurposes.includes("analytics_storage") || !!this.adapter?.requiredPurposes.includes("analytics_storage")
+        });
+        this.status.state = "waiting_for_consent";
+        this.status.reason = null;
+        this.scheduleConfigRefresh();
+        await this.readConsent();
+      }
+      this.changed();
+    } catch {
+      if (this.stopped || previous !== this.config) return;
+      if (this.configPolicy(previous) !== "legacy_unconfigured") {
+        this.invalidate();
+        updateMeasurementPolicy({ policy: "resolving" });
+        this.status.state = "blocked";
+      }
+      this.status.reason = "config_refresh_unavailable";
+      this.changed();
+      this.scheduleConfigRefresh(1e4);
+    } finally {
+      this.refreshing = false;
+    }
+  }
+  async start() {
+    const epoch = ++this.configEpoch;
+    this.proof = null;
+    this.invalidate();
+    updateMeasurementPolicy({ policy: "resolving", config: null, proof: null, choices: unknownChoices(), cmpValid: false, preferencePending: !!this.adapter });
+    try {
+      const result = await this.options.transport.request(`/config?site=${encodeURIComponent(this.options.site)}`, { method: "GET", cache: "no-store" });
+      if (this.stopped || epoch !== this.configEpoch) return;
+      if (result.status === 404) {
+        this.status.state = "legacy_unconfigured";
+        updateMeasurementPolicy({ policy: "legacy_unconfigured", config: null, analyticsRequired: this.adapter?.requiredPurposes.includes("analytics_storage") ?? false });
+        await this.readConsent();
+        return;
+      }
+      if (result.status !== 200) throw new Error("config_unavailable");
+      const config = parseResonanceMeasurementConfig(payload(result.body));
+      if (config.site !== this.options.site || Date.parse(config.expiresAt) <= this.now()) throw new Error("config_scope_or_expiry");
+      this.config = config;
+      updateMeasurementPolicy({ policy: this.configPolicy(config), config, identityScope: `${config.projectId}:${config.site}:${config.configRevision}`, preferencePending: config.enabled && !!this.adapter, analyticsRequired: config.consentPolicy.requiredPurposes.includes("analytics_storage") || !!this.adapter?.requiredPurposes.includes("analytics_storage") });
+      this.status.state = config.enabled ? "waiting_for_consent" : "blocked";
+      this.status.reason = config.enabled ? null : "measurement_disabled";
+      this.scheduleConfigRefresh();
+      await this.readConsent();
+    } catch {
+      if (this.stopped || epoch !== this.configEpoch) return;
+      this.status.state = "blocked";
+      this.status.reason = "config_unavailable";
+      updateMeasurementPolicy({ policy: "resolving", proof: null });
+    }
+    this.changed();
+  }
+  setAdapter(adapter) {
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+    this.adapter = adapter;
+    this.invalidate();
+    updateMeasurementPolicy({ analyticsRequired: !!adapter?.requiredPurposes.includes("analytics_storage") || !!this.config?.consentPolicy.requiredPurposes.includes("analytics_storage"), choices: unknownChoices(), cmpValid: false, preferencePending: !!adapter });
+    if (adapter) this.unsubscribe = adapter.subscribe(() => {
+      this.observe({ valid: false, choices: unknownChoices(), source: "cmp", observedAt: new Date(this.now()).toISOString() });
+      void this.readConsent();
+    });
+    void this.readConsent();
+  }
+  consentContext() {
+    return {
+      projectId: this.config?.projectId ?? null,
+      site: this.options.site,
+      configRevision: this.config?.configRevision ?? null,
+      policyRevision: this.config?.policyRevision ?? null,
+      requiredPurposes: this.config?.consentPolicy.requiredPurposes ?? this.adapter?.requiredPurposes ?? []
+    };
+  }
+  configPolicy(config) {
+    return !config.enabled && config.configRevision === "not_configured" && config.policyRevision === "not_configured" && !config.destinations.length && !config.resourceRules.length ? "legacy_unconfigured" : "configured";
+  }
+  async readConsent() {
+    if (!this.adapter || this.stopped) return;
+    const adapter = this.adapter;
+    const readEpoch = ++this.readEpoch;
+    try {
+      const observation = await adapter.read(this.consentContext());
+      if (this.stopped || this.adapter !== adapter || readEpoch !== this.readEpoch) return;
+      this.observe(observation);
+    } catch {
+      if (readEpoch !== this.readEpoch) return;
+      this.observe({ valid: false, choices: unknownChoices(), source: "cmp", observedAt: new Date(this.now()).toISOString() });
+    }
+  }
+  /** Maintained CMP observations may resume valid consent; this never prompts or infers a grant. */
+  observe(observation) {
+    if (this.stopped) return;
+    if (this.latest?.valid === observation.valid && MEASUREMENT_PURPOSES.every((p) => this.latest?.choices[p] === observation.choices[p]) && (this.busy || this.proof)) return;
+    if (observation.valid && !this.busy && this.proof && this.config && this.proof.receipts.every((r) => r.state === observation.choices[r.purpose])) {
+      this.latest = observation;
+      this.latestEpoch++;
+      this.completedEpoch = this.latestEpoch;
+      const expired = Date.parse(this.proof.expiresAt) <= this.now();
+      updateMeasurementPolicy({ choices: { ...observation.choices }, cmpValid: true, preferencePending: expired, proof: expired ? null : this.proof });
+      if (expired) {
+        void this.renew();
+        return;
+      }
+      this.status.state = "ready";
+      this.status.reason = null;
+      this.timers();
+      this.changed();
+      this.recordCurrentNavigation();
+      return;
+    }
+    if (observation.valid) this.acceptedExposure = null;
+    this.latest = observation;
+    this.latestEpoch++;
+    this.invalidate();
+    updateMeasurementPolicy({ choices: observation.valid ? { ...observation.choices } : unknownChoices(), cmpValid: observation.valid, preferencePending: !observation.valid || !!this.config?.enabled });
+    this.status.state = this.config ? this.config.enabled ? "waiting_for_consent" : "blocked" : "unknown";
+    this.status.reason = this.config && !this.config.enabled ? "measurement_disabled" : null;
+    if (observation.valid && this.config?.enabled) void this.captureLatest();
+    this.changed();
+  }
+  async captureLatest() {
+    if (this.busy || this.stopped || !this.config || !this.latest?.valid) return;
+    this.busy = true;
+    let processingEpoch = this.latestEpoch;
+    try {
+      while (!this.stopped && this.latest?.valid && this.completedEpoch < this.latestEpoch) {
+        const observation = this.latest, epoch = this.latestEpoch, config = this.config;
+        processingEpoch = epoch;
+        const prior = this.proof;
+        this.status.state = "pending";
+        this.changed();
+        const body = parseResonanceConsentUpdate({
+          schemaVersion: 1,
+          projectId: config.projectId,
+          site: config.site,
+          configRevision: config.configRevision,
+          policyRevision: config.policyRevision,
+          expectedConsentRevision: prior?.currentConsentRevision ?? 0,
+          occurredAt: observation.observedAt,
+          idempotencyKey: uuid(),
+          source: observation.source,
+          purposes: MEASUREMENT_PURPOSES.map((purpose2) => ({ purpose: purpose2, state: observation.choices[purpose2] }))
+        });
+        const result = await this.options.transport.request("/consent", { method: "POST", cache: "no-store", headers: { "Content-Type": "application/json", ...prior ? { [RESONANCE_SUBJECT_HEADER]: prior.subjectProof } : {} }, body: JSON.stringify(body) }, () => !this.stopped && epoch === this.latestEpoch && config === this.config);
+        if (this.stopped) return;
+        if (result.status !== 200) throw new Error("consent_not_accepted");
+        const accepted = parseResonanceConsentResponse(payload(result.body));
+        this.verifyProofScope(accepted, config);
+        if (prior && (accepted.receipts[0].visitorNamespace !== prior.receipts[0].visitorNamespace || accepted.currentConsentRevision < prior.currentConsentRevision)) throw new Error("consent_subject_or_revision_changed");
+        this.proof = accepted;
+        this.completedEpoch = epoch;
+        if (epoch !== this.latestEpoch) continue;
+        for (const receipt2 of accepted.receipts) if (receipt2.state !== observation.choices[receipt2.purpose]) throw new Error("consent_state_mismatch");
+        updateMeasurementPolicy({ proof: accepted, preferencePending: false });
+        this.status.state = "ready";
+        this.status.reason = null;
+        this.timers();
+        this.changed();
+        this.recordCurrentNavigation();
+      }
+    } catch {
+      if (this.stopped) return;
+      this.completedEpoch = processingEpoch;
+      this.status.state = "blocked";
+      this.status.reason = "consent_unavailable";
+      updateMeasurementPolicy({ proof: null });
+      this.changed();
+    } finally {
+      this.busy = false;
+      if (!this.stopped && this.latest?.valid && this.completedEpoch < this.latestEpoch) void this.captureLatest();
+    }
+  }
+  verifyProofScope(proof, config) {
+    const first = proof.receipts[0];
+    if (first.projectId !== config.projectId || first.site !== config.site || first.configRevision !== config.configRevision || first.policyRevision !== config.policyRevision || Date.parse(proof.expiresAt) <= this.now()) throw new Error("proof_scope_or_expiry");
+  }
+  async renew() {
+    if (!this.proof || !this.config || !this.latest?.valid || this.stopped || this.busy || this.renewing) return;
+    this.renewing = true;
+    const previous = this.proof, config = this.config, epoch = this.latestEpoch;
+    try {
+      const current = await this.adapter?.read(this.consentContext());
+      if (this.stopped || epoch !== this.latestEpoch || this.proof !== previous) return;
+      if (!current?.valid || !MEASUREMENT_PURPOSES.every((p) => current.choices[p] === this.latest?.choices[p])) {
+        if (current) this.observe(current);
+        else this.invalidate();
+        return;
+      }
+      const body = parseResonanceSubjectRenewCommand({ schemaVersion: 1, projectId: config.projectId, site: config.site, configRevision: config.configRevision, policyRevision: config.policyRevision, expectedConsentRevision: previous.currentConsentRevision });
+      const result = await this.options.transport.request("/consent/renew", { method: "POST", cache: "no-store", headers: { "Content-Type": "application/json", [RESONANCE_SUBJECT_HEADER]: previous.subjectProof }, body: JSON.stringify(body) }, () => !this.stopped && epoch === this.latestEpoch && previous === this.proof);
+      if (this.stopped || epoch !== this.latestEpoch || this.proof !== previous) return;
+      if (result.status !== 200) throw new Error("renewal_failed");
+      const renewed = parseResonanceConsentResponse(payload(result.body));
+      this.verifyProofScope(renewed, config);
+      if (renewed.currentConsentRevision !== previous.currentConsentRevision || renewed.receipts.some((r) => {
+        const old = previous.receipts.find((p) => p.purpose === r.purpose);
+        return !old || r.visitorNamespace !== old.visitorNamespace || r.state !== old.state || r.receiptId !== old.receiptId;
+      })) throw new Error("renewal_changed_consent_or_subject");
+      this.proof = renewed;
+      updateMeasurementPolicy({ proof: renewed, preferencePending: false });
+      this.status.state = "ready";
+      this.status.reason = null;
+      this.timers();
+      this.changed();
+      this.recordCurrentNavigation();
+    } catch {
+      if (this.stopped || epoch !== this.latestEpoch || this.proof !== previous) return;
+      this.invalidate();
+      this.status.state = "blocked";
+      this.status.reason = "renewal_unavailable";
+      this.changed();
+    } finally {
+      this.renewing = false;
+    }
+  }
+  /** Connectivity recovery renews existing proof; it never replays a failed grant. */
+  async recover() {
+    if (this.stopped) return;
+    if (this.config) await this.refreshConfig();
+    else await this.start();
+    await this.renew();
+    this.retryPending();
+  }
+  navigate(path2, sourceMarker2 = null) {
+    let marker = null;
+    if (sourceMarker2) {
+      try {
+        marker = parseResonanceSourceMarker(sourceMarker2);
+      } catch {
+      }
+    }
+    if (path2 === this.path && marker === this.sourceMarker) return;
+    this.sourceMarker = marker;
+    this.navigationSequence++;
+    this.path = path2;
+    this.navigation = null;
+    this.discardRenderedFrame();
+    this.acceptedExposure = null;
+    this.recordCurrentNavigation();
+  }
+  recordCurrentNavigation() {
+    if (!this.config || !this.path || !advertisingPurposesPermitted(this.now())) return;
+    const navigationKey = `${this.navigationSequence}:${this.proof?.currentConsentRevision}`;
+    if (navigationKey === this.recordedNavigationKey) return;
+    this.recordedNavigationKey = navigationKey;
+    this.navigation = { path: this.path, id: uuid(), epoch: this.deliveryEpoch };
+    const navigation = this.navigation;
+    const rule = this.config.resourceRules.find((r) => r.path === this.path);
+    const pages = this.config.resourceRules.filter((r) => r.path === this.path && r.resource.type === "page");
+    void this.emit("page_view", pages.length === 1 ? pages[0].resource : null);
+    if (rule && navigation === this.navigation) void this.emit("content_interest", rule.resource);
+  }
+  async exposure(experiment2) {
+    await this.submitExposure(experiment2);
+  }
+  /** Internal rendered occurrence seam; retry queues retain the resulting immutable event and ID. */
+  renderedExposure(experiment2, context) {
+    if (!this.exposurePermitted(experiment2) || context && (!context.pagePath || context.pagePath !== this.path)) return null;
+    if (!this.navigation) this.navigation = { path: this.path, id: uuid(), epoch: this.deliveryEpoch };
+    const previous = this.renderedFrame;
+    if (previous && previous.navigation === this.navigation && previous.context?.pagePath === context?.pagePath && previous.context?.pageVersionId === context?.pageVersionId && previous.input.projectId === experiment2.projectId && previous.input.site === experiment2.site && previous.input.experimentId === experiment2.experimentId && previous.input.experimentRevision === experiment2.experimentRevision && previous.input.assignmentId === experiment2.assignmentId && previous.input.variantKey === experiment2.variantKey) {
+      previous.input = experiment2;
+      previous.active = true;
+      return previous.pending ?? Promise.resolve();
+    }
+    const frame = { input: experiment2, context: context ? { ...context } : void 0, navigation: this.navigation, active: true, pending: null };
+    this.discardRenderedFrame();
+    this.renderedFrame = frame;
+    this.acceptedExposure = null;
+    const pending = this.submitExposure(experiment2, frame);
+    frame.pending = pending;
+    if (pending) void pending.then(() => {
+      frame.pending = null;
+    }, () => {
+      frame.pending = null;
+    });
+    return pending;
+  }
+  /** Close form attachment immediately, but retain this single bounded frame
+   * while the current assignment is revalidated. An exact native-identity rejoin
+   * keeps its original occurrence/receipt even after an asynchronous fallback.
+   * Navigation, replacement, consent/scope invalidation and stop retire it. */
+  releaseRenderedExposure(experiment2) {
+    const frame = this.renderedFrame;
+    if (!frame || frame.input !== experiment2) return;
+    frame.active = false;
+  }
+  exposurePermitted(experiment2) {
+    return !this.stopped && !!this.proof && !!this.config && experimentMeasurementPermitted(this.now()) && experiment2.projectId === this.config.projectId && experiment2.site === this.config.site;
+  }
+  submitExposure(experiment2, frame) {
+    if (!this.exposurePermitted(experiment2)) return null;
+    if (!this.navigation) this.navigation = { path: this.path, id: uuid(), epoch: this.deliveryEpoch };
+    const resolved = "exposureId" in experiment2 ? experiment2 : { ...experiment2, exposureId: uuid() };
+    return this.emit("experiment_exposure", null, resolved, frame);
+  }
+  async emit(kind, resourceRef, experiment2 = null, frame) {
+    if (!this.config || !this.proof || !this.navigation) return;
+    const navigation = this.navigation, proof = this.proof, config = this.config, epoch = this.deliveryEpoch;
+    let clickIdentifiers2;
+    if (kind === "page_view" && advertisingPurposesPermitted(this.now())) {
+      try {
+        const observed = this.options.readClickIdentifiers?.(this.navigation.path);
+        if (observed != null) clickIdentifiers2 = parseResonanceClickIdentifiers(observed);
+      } catch {
+      }
+    }
+    if (navigation !== this.navigation || proof !== this.proof || epoch !== this.deliveryEpoch) return;
+    let event = parseResonanceMeasurementOccurrence({
+      schemaVersion: 1,
+      projectId: config.projectId,
+      site: config.site,
+      configRevision: config.configRevision,
+      eventId: uuid(),
+      navigationId: navigation.id,
+      occurredAt: new Date(this.now()).toISOString(),
+      kind,
+      resourceRef,
+      ...clickIdentifiers2 ? { clickIdentifiers: clickIdentifiers2 } : {},
+      ...frame?.context ? { pagePath: frame.context.pagePath } : {},
+      ...this.sourceMarker && advertisingPurposesPermitted(this.now()) ? { sourceMarker: this.sourceMarker } : {},
+      campaignPlanId: null,
+      experiment: experiment2,
+      consentReceiptRefs: this.proof.receipts.map((r) => ({ purpose: r.purpose, receiptId: r.receiptId, consentRevision: r.consentRevision }))
+    });
+    if (kind === "page_view" && resourceRef?.type === "page" && advertisingPurposesPermitted(this.now())) {
+      try {
+        event = parseResonanceMeasurementOccurrence({ ...event, pagePath: navigation.path });
+      } catch {
+      }
+      if (event.pagePath !== void 0) {
+        try {
+          const observed = this.options.readMetaCookieObservation?.(navigation.path);
+          if (observed != null) event = parseResonanceMeasurementOccurrence({ ...event, metaCookieObservation: observed });
+        } catch {
+        }
+      }
+    }
+    if (navigation !== this.navigation || proof !== this.proof || config !== this.config || epoch !== this.deliveryEpoch) return;
+    await this.deliver(event, epoch, frame);
+  }
+  async deliver(event, epoch, frame) {
+    const allowed = () => !this.stopped && epoch === this.deliveryEpoch && (!frame || this.renderedFrame === frame && frame.navigation === this.navigation) && (event.kind === "experiment_exposure" ? experimentMeasurementPermitted(this.now()) : advertisingPurposesPermitted(this.now()));
+    if (!allowed() || !this.proof) return;
+    try {
+      const result = await this.options.transport.request("/occurrences", { method: "POST", cache: "no-store", headers: { "Content-Type": "application/json", [RESONANCE_SUBJECT_HEADER]: this.proof.subjectProof }, body: JSON.stringify(event) }, allowed);
+      if (!allowed()) return;
+      if (result.status !== 200) throw new Error("occurrence_not_accepted");
+      const receipt2 = parseResonanceOccurrenceResponse(payload(result.body));
+      if (receipt2.eventId !== event.eventId) throw new Error("occurrence_identity_mismatch");
+      this.retry.delete(event.eventId);
+      if (event.kind === "experiment_exposure" && receipt2.exposureId && this.proof && this.navigation?.id === event.navigationId && (!frame || this.renderedFrame === frame && frame.navigation === this.navigation)) {
+        this.acceptedExposure = {
+          id: receipt2.exposureId,
+          namespace: this.proof.receipts[0].visitorNamespace,
+          consentRevision: this.proof.currentConsentRevision,
+          configRevision: this.config.configRevision,
+          policyRevision: this.config.policyRevision,
+          navigation: this.navigation,
+          frame: frame ?? null
+        };
+      }
+      if (!receipt2.replayed) this.options.onOccurrence?.(event);
+    } catch {
+      if (allowed() && this.retry.size < 50) this.retry.set(event.eventId, { event, epoch, frame });
+    }
+  }
+  /** Explicit network recovery only; identical occurrence ID, never old preference/scope epochs. */
+  retryPending() {
+    for (const { event, epoch, frame } of this.retry.values()) void this.deliver(event, epoch, frame);
+  }
+  /** Optional server receipt reference, never a claim that a form converted. */
+  formExposureId() {
+    const exposure2 = this.acceptedExposure, proof = this.proof, config = this.config;
+    return exposure2 && proof && config && exposure2.navigation === this.navigation && (!exposure2.frame || exposure2.frame === this.renderedFrame && exposure2.frame.active) && exposure2.namespace === proof.receipts[0].visitorNamespace && exposure2.consentRevision === proof.currentConsentRevision && exposure2.configRevision === config.configRevision && exposure2.policyRevision === config.policyRevision ? exposure2.id : null;
+  }
+  stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.configEpoch++;
+    this.readEpoch++;
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+    if (this.expiryTimer) clearTimeout(this.expiryTimer);
+    if (this.renewalTimer) clearTimeout(this.renewalTimer);
+    if (this.refreshTimer) clearTimeout(this.refreshTimer);
+    if (this.configExpiryTimer) clearTimeout(this.configExpiryTimer);
+    this.invalidate();
+    this.acceptedExposure = null;
+    this.proof = null;
+    updateMeasurementPolicy({ config: null, cmpValid: false, proof: null, choices: unknownChoices(), preferencePending: true });
+  }
+};
+
+// src/resonance/meta-pixel.ts
+var META_BROWSER_CONTROLS_IMPLEMENTED = [];
+var META_SDK_URL = "https://connect.facebook.net/en_US/fbevents.js";
+var ALLOWED_QUERY_KEYS = /* @__PURE__ */ new Set(["fbclid", "sonor_source", "utm_source", "utm_medium", "utm_campaign", "utm_content", "utm_term"]);
+var QUERY_VALUE = /^[^\s\u0000-\u001f\u007f-\u009f]{1,256}$/;
+var SONOR_APPLICATION_HOSTS = /* @__PURE__ */ new Set(["app.sonor.io", "api.sonor.io", "signal.sonor.io"]);
+var DENIED_PATH_ROOTS = ["/admin", "/account", "/dashboard", "/login", "/signin", "/signup", "/checkout", "/cart", "/portal", "/api", "/preview"];
+var COOKIES = ["_fbp", "_fbc"];
+var WITNESS_MAX_AGE_MS = 48 * 36e5;
+function queryClean(search2) {
+  if (!search2) return true;
+  const entries = [...new URLSearchParams(search2).entries()];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [key, value] of entries) {
+    if (!ALLOWED_QUERY_KEYS.has(key) || seen.has(key) || !QUERY_VALUE.test(value)) return false;
+    seen.add(key);
+  }
+  return true;
+}
+function referrerClean(referrer) {
+  if (!referrer) return true;
+  let url;
+  try {
+    url = new URL(referrer);
+  } catch {
+    return false;
+  }
+  if (url.hash || referrer.includes("#") || url.username || url.password) return false;
+  if (url.hostname === window.location.hostname) return !pathDenied(url.pathname) && queryClean(url.search);
+  return !url.search && !referrer.includes("?") && (url.pathname === "/" || url.pathname === "");
+}
+function pathDenied(path2) {
+  const lower = path2.toLowerCase();
+  return DENIED_PATH_ROOTS.some((root) => lower === root || lower.startsWith(root + "/"));
+}
+function decideMetaPage(config) {
+  if (typeof window === "undefined" || typeof document === "undefined") return { ok: false, blocker: "meta_page_not_eligible" };
+  const location = window.location;
+  let framed = true;
+  try {
+    framed = isFramed();
+  } catch {
+  }
+  if (framed || isPrivatePreview() || isLocalHostname(location.hostname) || SONOR_APPLICATION_HOSTS.has(location.hostname.toLowerCase()) || document.querySelector("[data-sk-authenticated]") || pathDenied(location.pathname)) return { ok: false, blocker: "meta_page_not_eligible" };
+  const pages = config.resourceRules.filter((rule) => rule.path === location.pathname && rule.resource.type === "page");
+  if (pages.length !== 1 || pages[0].metaEligible !== true) return { ok: false, blocker: "meta_page_not_eligible" };
+  if (location.hash || location.href.includes("#") || !queryClean(location.search) || !referrerClean(document.referrer)) return { ok: false, blocker: "meta_url_not_clean" };
+  return { ok: true };
+}
+function expireMetaCookies() {
+  const host = window.location.hostname;
+  if (!host || host.includes(":") || /^\d+(\.\d+){3}$/.test(host)) {
+    for (const name of COOKIES) document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+    return;
+  }
+  const labels = host.split(".");
+  const domains = ["", ...labels.map((_, index) => "." + labels.slice(index).join("."))];
+  for (const name of COOKIES) for (const domain of domains) document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/${domain ? `; domain=${domain}` : ""}`;
+}
+var MetaPixelLoader = class {
+  constructor(config, hooks) {
+    this.config = config;
+    this.hooks = hooks;
+    this.generation = 0;
+    this.owned = null;
+    this.granted = false;
+    this.cookiesExpired = false;
+  }
+  destinations() {
+    return this.config.destinations.filter((d) => d.provider === "meta_ads");
+  }
+  /** Configuration-level facts, independent of consent and of the page. */
+  inspect() {
+    const destinations = this.destinations();
+    const witness = destinations.length === 1 ? destinations[0].browserWitness : void 0;
+    const implemented = this.hooks.implementedRevisions ?? META_BROWSER_CONTROLS_IMPLEMENTED;
+    const age = witness ? Date.now() - Date.parse(witness.assertedAt) : Number.NaN;
+    return {
+      destinations: destinations.length,
+      multiple: destinations.length > 1,
+      witnessed: !!witness && implemented.includes(witness.controlsRevision) && witness.policyRevision === this.config.policyRevision && age >= -6e5 && age <= WITNESS_MAX_AGE_MS
+    };
+  }
+  /** Every SDK command re-checks the fence; a withdrawn runtime pushes nothing. */
+  command(...args) {
+    const fbq = this.owned?.fbq;
+    if (!fbq || !this.hooks.allowed()) return false;
+    try {
+      fbq(...args);
+    } catch {
+    }
+    return true;
+  }
+  blockers(decision) {
+    this.hooks.setBlocker("meta_page_not_eligible", !decision.ok && decision.blocker === "meta_page_not_eligible");
+    this.hooks.setBlocker("meta_url_not_clean", !decision.ok && decision.blocker === "meta_url_not_clean");
+  }
+  foreign(w, destination2) {
+    if (w.fbq || w._fbq || document.querySelector('script[src*="connect.facebook.net"][src*="fbevents"]') || document.querySelector('img[src*="facebook.com/tr"]')) return true;
+    for (const noscript of document.querySelectorAll("noscript")) if ((noscript.textContent ?? "").includes("facebook.com/tr") || noscript.innerHTML.includes("facebook.com/tr")) return true;
+    const tagManager = !!w.google_tag_manager || !!document.querySelector('script[src*="googletagmanager.com/gtm.js"]') || w.dataLayer !== void 0 && w.dataLayer !== w.__SONOR_RESONANCE_GOOGLE_V1__?.data;
+    return tagManager && destination2.tagManagerAttested !== true;
+  }
+  update() {
+    const { destinations, multiple, witnessed } = this.inspect();
+    if (typeof window === "undefined" || !destinations) return;
+    if (multiple) {
+      this.hooks.setBlocker("meta_multiple_destinations", true);
+      return;
+    }
+    if (!witnessed) {
+      this.withdraw();
+      return;
+    }
+    if (!this.hooks.allowed()) {
+      this.withdraw();
+      return;
+    }
+    const decision = decideMetaPage(this.config);
+    this.blockers(decision);
+    if (!decision.ok) {
+      this.pause();
+      return;
+    }
+    const w = window, destination2 = this.destinations()[0];
+    const record = w.__SONOR_RESONANCE_META_V1__;
+    if (this.owned || record) return this.resume(w, destination2, record);
+    if (this.foreign(w, destination2)) {
+      this.hooks.setBlocker("meta_duplicate_installation", true);
+      return;
+    }
+    this.install(w, destination2);
+  }
+  /** Single-page navigation: re-evaluate; never re-initialize. */
+  navigate() {
+    this.update();
+  }
+  resume(w, destination2, record) {
+    if (!record) return;
+    if (this.owned && this.owned !== record) return;
+    if (record.scope !== `${this.config.projectId}:${this.config.site}` || record.pixelId !== destination2.pixelId) {
+      this.hooks.setBlocker("meta_scope_change_requires_reload", true);
+      return;
+    }
+    if (w.fbq !== record.fbq) {
+      this.hooks.setBlocker("meta_duplicate_installation", true);
+      return;
+    }
+    if (!this.owned && !record.loaded && !record.failed) {
+      this.hooks.setBlocker("meta_duplicate_installation", true);
+      return;
+    }
+    this.owned = record;
+    if (record.failed) {
+      this.hooks.setBlocker("meta_load_failed", true);
+      return;
+    }
+    if (record.loaded && record.consent === "revoked") this.grant();
+  }
+  install(w, destination2) {
+    const generation = this.generation;
+    const queue = [];
+    const fbq = function(..._args) {
+      if (fbq.callMethod) fbq.callMethod.apply(fbq, arguments);
+      else fbq.queue.push(arguments);
+    };
+    fbq.push = fbq;
+    fbq.loaded = true;
+    fbq.version = "2.0";
+    fbq.queue = queue;
+    const script = document.createElement("script");
+    this.owned = { scope: `${this.config.projectId}:${this.config.site}`, pixelId: destination2.pixelId, fbq, script, loaded: false, failed: false, consent: "revoked" };
+    w.fbq = fbq;
+    w._fbq = fbq;
+    w.__SONOR_RESONANCE_META_V1__ = this.owned;
+    if (!this.command("consent", "revoke") || !this.command("set", "autoConfig", false, destination2.pixelId) || !this.command("init", destination2.pixelId)) {
+      this.discard(w);
+      return;
+    }
+    const owned2 = this.owned;
+    script.async = true;
+    script.src = META_SDK_URL;
+    script.referrerPolicy = "no-referrer";
+    script.onload = () => {
+      owned2.loaded = true;
+      this.afterLoad(generation);
+    };
+    script.onerror = () => {
+      owned2.failed = true;
+      this.hooks.setBlocker("meta_load_failed", true);
+    };
+    if (generation !== this.generation || !this.hooks.allowed()) {
+      this.discard(w);
+      return;
+    }
+    document.head.appendChild(script);
+  }
+  /** The grant is issued live, after the SDK has executed: a grant queued ahead of the script never releases its lock. */
+  afterLoad(generation) {
+    if (generation !== this.generation || !this.hooks.allowed()) return;
+    const decision = decideMetaPage(this.config);
+    this.blockers(decision);
+    if (decision.ok) this.grant();
+  }
+  grant() {
+    if (!this.owned?.loaded || this.owned.consent === "granted") return;
+    if (this.command("consent", "grant")) {
+      this.owned.consent = "granted";
+      this.granted = true;
+      this.cookiesExpired = false;
+    }
+  }
+  /** The page stopped being eligible or clean: pause the SDK without forgetting the installation. */
+  pause() {
+    const owned2 = this.owned;
+    if (!owned2) return;
+    if (!owned2.loaded) {
+      this.discard(window);
+      return;
+    }
+    if (owned2.consent === "granted") {
+      try {
+        owned2.fbq("consent", "revoke");
+      } catch {
+      }
+      owned2.consent = "revoked";
+    }
+  }
+  /** Before the SDK has executed nothing needs retracting: remove everything so a late script finds no queue and does nothing. */
+  discard(w) {
+    const owned2 = this.owned;
+    if (!owned2) return;
+    owned2.script.onload = null;
+    owned2.script.onerror = null;
+    if (owned2.script.isConnected) owned2.script.remove();
+    if (w.fbq === owned2.fbq) delete w.fbq;
+    if (w._fbq === owned2.fbq) delete w._fbq;
+    if (w.__SONOR_RESONANCE_META_V1__ === owned2) delete w.__SONOR_RESONANCE_META_V1__;
+    this.owned = null;
+  }
+  withdraw() {
+    this.generation++;
+    const owned2 = this.owned;
+    if (owned2) {
+      if (!owned2.loaded) this.discard(window);
+      else if (owned2.consent === "granted") {
+        try {
+          owned2.fbq("consent", "revoke");
+        } catch {
+        }
+        owned2.consent = "revoked";
+      }
+    }
+    if ((this.granted || owned2?.loaded) && !this.cookiesExpired) {
+      expireMetaCookies();
+      this.cookiesExpired = true;
+    }
+    this.granted = false;
+  }
+  stop() {
+    this.withdraw();
+  }
+};
+
+// src/resonance/providers.ts
+var denied = { analytics_storage: "denied", ad_storage: "denied", ad_user_data: "denied", ad_personalization: "denied" };
+var ResonanceProviderRuntime = class {
+  constructor(config, onBlockers, options = {}) {
+    this.config = config;
+    this.onBlockers = onBlockers;
+    this.google = null;
+    this.script = null;
+    this.configured = /* @__PURE__ */ new Set();
+    this.pending = null;
+    this.generation = 0;
+    this.active = false;
+    this.loaded = false;
+    this.finishLoad = null;
+    this.blockers = /* @__PURE__ */ new Set();
+    this.meta = new MetaPixelLoader(config, { allowed: () => this.allowed(), setBlocker: (code, present) => this.setBlocker(code, present), implementedRevisions: options.metaControlsRevisions });
+    const meta2 = this.meta.inspect();
+    if (meta2.destinations && !meta2.witnessed) this.block("meta_browser_collection_unverified");
+    if (meta2.multiple) this.block("meta_multiple_destinations");
+  }
+  block(code) {
+    this.setBlocker(code, true);
+  }
+  setBlocker(code, present) {
+    if (this.blockers.has(code) === present) return;
+    if (present) this.blockers.add(code);
+    else this.blockers.delete(code);
+    this.onBlockers?.([...this.blockers]);
+  }
+  allowed() {
+    const state = measurementPolicySnapshot();
+    return this.active && advertisingPurposesPermitted() && state.config?.projectId === this.config.projectId && state.config.site === this.config.site && state.config.configRevision === this.config.configRevision;
+  }
+  update() {
+    if (!advertisingPurposesPermitted()) {
+      this.withdraw();
+      return;
+    }
+    this.active = true;
+    const meta2 = this.meta.inspect();
+    this.setBlocker("meta_browser_collection_unverified", meta2.destinations > 0 && !meta2.witnessed);
+    this.meta.update();
+    if (!this.pending && !this.google && !this.blockers.has("google_duplicate_installation") && !this.blockers.has("google_scope_change_requires_reload") && !this.blockers.has("google_load_failed")) {
+      this.pending = this.loadGoogle().finally(() => {
+        this.pending = null;
+      });
+    } else if (this.google) {
+      this.applyConsent();
+      if (!this.loaded && this.script && !this.script.isConnected && this.allowed()) document.head.appendChild(this.script);
+    }
+  }
+  applyConsent() {
+    if (!this.allowed() || !this.google) return;
+    this.google("consent", "update", { ...measurementPolicySnapshot().choices });
+  }
+  async loadGoogle() {
+    const destinations = this.config.destinations.filter((d) => d.provider === "google_ads");
+    if (!destinations.length || !this.allowed() || typeof window === "undefined") return;
+    const w = window;
+    const owned2 = w.__SONOR_RESONANCE_GOOGLE_V1__;
+    if (owned2) {
+      const tags = [...new Set(destinations.map((d) => d.tagId))].sort();
+      if (owned2.scope !== `${this.config.projectId}:${this.config.site}` || JSON.stringify(tags) !== JSON.stringify(owned2.tags)) {
+        this.block("google_scope_change_requires_reload");
+        return;
+      }
+      if (w.gtag !== owned2.command || w.dataLayer !== owned2.data) {
+        this.block("google_duplicate_installation");
+        return;
+      }
+      if (owned2.failed) {
+        this.block("google_load_failed");
+        return;
+      }
+      this.google = owned2.command;
+      this.script = owned2.script;
+      this.loaded = owned2.loaded;
+      for (const tag of tags) this.configured.add(tag);
+      this.applyConsent();
+      if (!this.loaded) {
+        const script2 = this.script;
+        let done;
+        const loaded = () => {
+          this.loaded = true;
+          done();
+        };
+        const failed = () => {
+          this.block("google_load_failed");
+          done();
+        };
+        await new Promise((resolve) => {
+          done = resolve;
+          this.finishLoad = resolve;
+          script2.addEventListener("load", loaded, { once: true });
+          script2.addEventListener("error", failed, { once: true });
+          if (!script2.isConnected && this.allowed()) document.head.appendChild(script2);
+        });
+        script2.removeEventListener("load", loaded);
+        script2.removeEventListener("error", failed);
+      }
+      return;
+    }
+    if (w.gtag || w.dataLayer || document.querySelector('script[src*="googletagmanager.com/gtag/js"],script[src*="googletagmanager.com/gtm.js"]')) {
+      this.block("google_duplicate_installation");
+      return;
+    }
+    const generation = this.generation;
+    const data = [];
+    const command2 = function(..._args) {
+      data.push(arguments);
+    };
+    w.dataLayer = data;
+    w.gtag = command2;
+    this.google = command2;
+    command2("consent", "default", denied);
+    command2("set", "ads_data_redaction", true);
+    command2("set", "url_passthrough", false);
+    this.applyConsent();
+    command2("js", /* @__PURE__ */ new Date());
+    for (const d of destinations) {
+      if (this.configured.has(d.tagId)) continue;
+      command2("config", d.tagId, { send_page_view: false, allow_enhanced_conversions: false, page_location: `https://${this.config.site}/`, page_referrer: "", page_title: "" });
+      this.configured.add(d.tagId);
+    }
+    const script = document.createElement("script");
+    this.script = script;
+    script.async = true;
+    script.src = `https://www.googletagmanager.com/gtag/js?id=${encodeURIComponent(destinations[0].tagId)}`;
+    script.referrerPolicy = "no-referrer";
+    const ownership = { scope: `${this.config.projectId}:${this.config.site}`, tags: [...this.configured].sort(), command: command2, data, script, loaded: false, failed: false };
+    w.__SONOR_RESONANCE_GOOGLE_V1__ = ownership;
+    await new Promise((resolve) => {
+      this.finishLoad = resolve;
+      script.onload = () => {
+        this.loaded = true;
+        ownership.loaded = true;
+        resolve();
+      };
+      script.onerror = () => {
+        ownership.failed = true;
+        this.block("google_load_failed");
+        resolve();
+      };
+      if (generation !== this.generation || !this.allowed()) {
+        resolve();
+        return;
+      }
+      document.head.appendChild(script);
+    });
+  }
+  async occurrence(event) {
+    const generation = this.generation;
+    if (!this.allowed() || event.kind === "experiment_exposure") return;
+    if (this.pending) await this.pending;
+    if (generation !== this.generation || !this.allowed() || !this.google || this.blockers.has("google_load_failed")) return;
+    const rule = event.resourceRef ? this.config.resourceRules.find((r) => r.resource.id === event.resourceRef?.id && r.resource.revision === event.resourceRef.revision && r.resource.type === event.resourceRef.type) : null;
+    for (const tag of this.configured) this.google("event", event.kind === "page_view" ? "page_view" : "sonor_content_interest", {
+      send_to: tag,
+      event_id: event.eventId,
+      page_location: `https://${this.config.site}${rule?.path ?? "/"}`,
+      page_referrer: "",
+      page_title: "",
+      ...rule ? { sonor_resource_id: rule.resource.id, sonor_interest_key: rule.interestKey } : {}
+    });
+  }
+  /** Single-page navigation: Meta re-evaluates the new page's eligibility and URL hygiene. */
+  navigate() {
+    if (this.active) this.meta.navigate();
+  }
+  withdraw() {
+    this.meta.withdraw();
+    if (!this.active) return;
+    this.active = false;
+    this.generation++;
+    this.google?.("consent", "update", denied);
+    if (!this.loaded) this.script?.remove();
+    this.finishLoad?.();
+    this.finishLoad = null;
+  }
+  stop() {
+    this.withdraw();
+  }
+};
+
+// src/resonance/runtime-core.ts
+function currentSourceMarker() {
+  const values = new URLSearchParams(window.location.search).getAll(RESONANCE_SOURCE_MARKER_PARAMETER);
+  if (values.length !== 1) return null;
+  try {
+    return parseResonanceSourceMarker(values[0]);
+  } catch {
+    return null;
+  }
+}
+function mountResonanceRuntime({ site: site2, apiUrl, apiKey }) {
+  if (!site2 || !resolveAnalyticsTarget({ apiUrl, apiKey })) return;
+  let providers = null;
+  let providerRevision = "";
+  const runtime = new ResonanceController({
+    site: site2,
+    readClickIdentifiers(pathname) {
+      if (typeof window === "undefined" || window.location.pathname !== pathname) return null;
+      const parameters = new URLSearchParams(window.location.search);
+      const entries = ["gclid", "gbraid", "wbraid"].flatMap((key) => parameters.getAll(key).map((value) => [key, value]));
+      if (entries.length !== 1) return null;
+      try {
+        return parseResonanceClickIdentifiers(Object.fromEntries(entries));
+      } catch {
+        return null;
+      }
+    },
+    readMetaCookieObservation(pathname) {
+      if (typeof window === "undefined" || typeof document === "undefined" || window.location.pathname !== pathname) return null;
+      const pages = measurementPolicySnapshot().config?.resourceRules.filter((rule) => rule.path === pathname && rule.resource.type === "page") ?? [];
+      if (pages.length !== 1 || pages[0].metaEligible !== true) return null;
+      try {
+        const cookies = document.cookie.split(";").map((part) => {
+          const separator = part.indexOf("=");
+          return separator < 0 ? null : [part.slice(0, separator).trim(), part.slice(separator + 1)];
+        });
+        if (window.location.pathname !== pathname) return null;
+        const observed = {};
+        for (const field3 of RESONANCE_WEBSITE_VISIT_PROFILE.matchingFields) {
+          const matches = cookies.filter((cookie) => cookie?.[0] === `_${field3}`);
+          if (matches.length === 1 && matches[0][1]) observed[field3] = matches[0][1];
+        }
+        return Object.keys(observed).length ? { source: RESONANCE_WEBSITE_VISIT_PROFILE.source, ...observed } : null;
+      } catch {
+        return null;
+      }
+    },
+    transport: { async request(path2, init, stillAllowed) {
+      const response = await sonorFetch(`${apiUrl.replace(/\/+$/, "")}/api/public/resonance/measurement${path2}`, init, {
+        apiKey,
+        retries: 0,
+        shouldSend: () => !!resolveAnalyticsTarget({ apiUrl, apiKey }) && (stillAllowed?.() ?? true)
+      });
+      return { status: response.status, body: await response.json().catch(() => null) };
+    } },
+    onOccurrence(event) {
+      void providers?.occurrence(event);
+    }
+  });
+  const unregister = registerResonanceController(runtime);
+  if (!unregister) return;
+  const updateProviders = () => {
+    const config = measurementPolicySnapshot().config;
+    const revision2 = config ? `${config.projectId}:${config.site}:${config.configRevision}:${config.policyRevision}` : "";
+    if (revision2 !== providerRevision) {
+      providers?.stop();
+      providers = null;
+      providerRevision = revision2;
+    }
+    if (config && !providers) providers = new ResonanceProviderRuntime(config, setProviderBlockers);
+    providers?.update();
+    setProviderBlockers(providers ? [...providers.blockers] : []);
+  };
+  const unpolicy = subscribeMeasurementPolicy(updateProviders);
+  const adapter = () => runtime.setAdapter(getConsentAdapter());
+  const unadapter = subscribeConsentAdapter(adapter);
+  adapter();
+  void runtime.start();
+  runtime.navigate(window.location.pathname, currentSourceMarker());
+  const online = () => {
+    void runtime.recover();
+  };
+  window.addEventListener("online", online);
+  const navigation = () => {
+    runtime.navigate(window.location.pathname, currentSourceMarker());
+    providers?.navigate();
+  };
+  window.addEventListener("popstate", navigation);
+  return { navigate(pathname) {
+    runtime.navigate(pathname, currentSourceMarker());
+    providers?.navigate();
+  }, stop() {
+    window.removeEventListener("online", online);
+    window.removeEventListener("popstate", navigation);
+    unadapter();
+    unpolicy();
+    unregister();
+    runtime.stop();
+    providers?.stop();
+  } };
+}
+
+export { mountResonanceRuntime };