@sonordev/contracts 2.17.0 → 2.20.0

package/dist/resonance.mjs

@@ -0,0 +1,1650 @@
+// src/contracts/resonance-constants.ts
+var RESONANCE_ATTRIBUTION_MODEL = "first_party_last_touch_marker_v1";
+var RESONANCE_SOURCE_MARKER_PARAMETER = "sonor_source";
+var RESONANCE_SUBJECT_HEADER = "X-Sonor-Resonance-Subject";
+
+// 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/sites-normalize.ts
+function normalizeSiteHost(site2) {
+  if (!site2 || typeof site2 !== "string") return null;
+  let s = site2.trim().toLowerCase();
+  if (!s) return null;
+  s = s.replace(/^https?:\/\//, "");
+  const slash = s.indexOf("/");
+  if (slash >= 0) s = s.slice(0, slash);
+  const colon = s.indexOf(":");
+  if (colon >= 0) s = s.slice(0, colon);
+  s = s.replace(/\.+$/, "");
+  return s || null;
+}
+
+// src/contracts/sites.ts
+function stripWww(host) {
+  return host.startsWith("www.") ? host.slice(4) : host;
+}
+function sameSite(a, b) {
+  if (!a || !b) return false;
+  return stripWww(a) === stripWww(b);
+}
+function hostFromUrl(value) {
+  if (!value || !value.startsWith("http://") && !value.startsWith("https://")) return null;
+  try {
+    return normalizeSiteHost(new URL(value).host);
+  } catch {
+    return null;
+  }
+}
+function isNormalizedSiteHost(value) {
+  return typeof value === "string" && value.length > 0 && normalizeSiteHost(value) === value;
+}
+
+// src/contracts/public-url-host.ts
+function isPrivateIpv4(a, b) {
+  return a === 127 || a === 10 || a === 0 || a === 192 && b === 168 || a === 172 && b >= 16 && b <= 31 || a === 169 && b === 254 || a === 100 && b >= 64 && b <= 127 || a >= 224;
+}
+function ipv6Words(host) {
+  if (!host.includes(":") || !/^[a-f\d:.]+$/.test(host)) return null;
+  let canonical2;
+  try {
+    canonical2 = new URL(`http://[${host}]/`).hostname.slice(1, -1);
+  } catch {
+    return null;
+  }
+  const sides = canonical2.split("::");
+  const left = sides[0] ? sides[0].split(":") : [];
+  const right = sides.length > 1 && sides[1] ? sides[1].split(":") : [];
+  return [...left, ...Array(sides.length > 1 ? 8 - left.length - right.length : 0).fill("0"), ...right].map((word) => parseInt(word, 16));
+}
+function isBlockedPublicUrlHost(rawHost) {
+  const host = rawHost.toLowerCase().replace(/^\[|\]$/g, "");
+  const blockedName = host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal");
+  if (host.includes(":") && host.includes("%")) return true;
+  const ipv4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  const blockedIp = !!ipv4 && isPrivateIpv4(Number(ipv4[1]), Number(ipv4[2]));
+  const words = ipv6Words(host);
+  const blockedIpv6 = !!words && // Unspecified/loopback, unique-local, link-local, deprecated site-local
+  // and multicast destinations aren't public logo/webhook endpoints.
+  (words.every((word) => word === 0) || words.slice(0, 7).every((word) => word === 0) && words[7] === 1 || (words[0] & 65024) === 64512 || (words[0] & 65472) === 65152 || (words[0] & 65472) === 65216 || (words[0] & 65280) === 65280 || // IPv4-mapped and older IPv4-compatible forms carry an IPv4 destination.
+  words.slice(0, 5).every((word) => word === 0) && [0, 65535].includes(words[5]) && isPrivateIpv4(words[6] >> 8, words[6] & 255));
+  return blockedName || blockedIp || blockedIpv6;
+}
+
+// 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/campaign-normalize.ts
+function normalizeCampaignSlug(input) {
+  if (!input || typeof input !== "string") return null;
+  const slug = input.trim().toLowerCase().replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+  return slug || null;
+}
+
+// src/contracts/resonance.ts
+var RESONANCE_SCHEMA_VERSION = 1;
+var MONEY_EXPONENT = 6;
+var MAX_MONEY_MICROS = "999999999999999999999999999999";
+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 uuid = 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 });
+var parseMoney = (value) => money.read(value, "money");
+function addMoney(a, b) {
+  a = parseMoney(a);
+  b = parseMoney(b);
+  if (a.currency !== b.currency) fail2("money.currency", "currency mismatch; no implicit FX");
+  return parseMoney({ currency: a.currency, amountMicros: (BigInt(a.amountMicros) + BigInt(b.amountMicros)).toString() });
+}
+function moneyToProviderUnits(input, account) {
+  const m = parseMoney(input);
+  currency.read(account.currency, "account.currency");
+  decimal.read(account.maxUnits, "account.maxUnits");
+  if (m.currency !== account.currency) fail2("money.currency", "currency mismatch");
+  if (![0, 2, 3, 6].includes(account.unitExponent)) fail2("account.unitExponent", "unsupported provider exponent");
+  const factor = 10n ** BigInt(6 - account.unitExponent), amount = BigInt(m.amountMicros);
+  if (amount % factor !== 0n) fail2("money.amountMicros", "not exactly representable in provider units");
+  const units = amount / factor;
+  if (units > BigInt(account.maxUnits)) fail2("money.amountMicros", "provider overflow");
+  return units.toString();
+}
+function moneyFromProviderUnits(units, account) {
+  decimal.read(units, "provider.units");
+  if (![0, 2, 3, 6].includes(account.unitExponent)) fail2("account.unitExponent", "unsupported provider exponent");
+  return parseMoney({ currency: account.currency, amountMicros: (BigInt(units) * 10n ** BigInt(6 - account.unitExponent)).toString() });
+}
+var MONEY_JSON_SCHEMA = money.schema;
+var sourceMarker = text2(1536, /^rsm1\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]{43}$/);
+var parseResonanceSourceMarker = (v) => sourceMarker.read(v, "sourceMarker");
+var RESONANCE_SOURCE_MARKER_JSON_SCHEMA = sourceMarker.schema;
+var scope = { projectId: uuid, site };
+var resource = object2({ ...scope, module: choice2("funnel", "broadcast", "outreach", "experiment", "files", "business_brain", "publication", "crm", "commerce", "forms", "booking", "prepared_plan"), id: uuid, revision, digest });
+var source = object2({ ...scope, kind: choice2("accepted_form", "qualified_lead", "completed_booking", "net_paid_order", "approved_application"), id: uuid, 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);
+var parseResonanceQualificationRule = (v) => qualificationRule.read(v, "qualificationRule");
+var RESONANCE_QUALIFICATION_RULE_JSON_SCHEMA = qualificationRule.schema;
+var resolvedQualificationRule = refine2(object2({
+  ...qualificationFields,
+  ref: resource,
+  crmVariant: text2(128),
+  ladderSnapshot: list2(object2({ id: nullable2(uuid), stage_key: revision, semantic_key: nullable2(revision), is_won: bool, is_lost: bool }), 500, 1),
+  eligibleFormIds: list2(uuid, 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");
+});
+var parseResonanceResolvedQualificationRule = (v) => resolvedQualificationRule.read(v, "resolvedQualificationRule");
+var RESONANCE_RESOLVED_QUALIFICATION_RULE_JSON_SCHEMA = 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: uuid, assetRef: resource, preparedArtifactRef: nullable2(resource), headline: text2(160), body: text2(1e4), callToAction: text2(80), cropDigest: digest });
+var destination = union2(
+  object2({ kind: literal2("funnel"), id: uuid, ...scope, path, funnelRef: resource, formSlug: text2(80, /^[a-z0-9]+(?:-[a-z0-9]+)*$/), installationRevision: revision }),
+  object2({ kind: literal2("existing_page"), id: uuid, ...scope, path, pageRevision: revision, evidenceDigest: digest })
+);
+var audience = object2({ ...scope, id: uuid, revision, policyRevision: revision, retentionDays: integer2(1, 540), exclusionRuleIds: list2(uuid, 50), consentPurpose: literal2("ad_personalization") });
+var experiment = object2({ ...scope, id: uuid, 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 matureOptimizationPolicy = object2({
+  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)
+});
+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(uuid, 100, 1),
+  selection: object2({ kind: literal2("fixed_reviewed_order"), candidateOrder: uniqueList(uuid, 100, 1), eligibilitySchedule: list2(object2({ channelId: uuid, 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);
+function parseResonanceOptimizationPolicy(v) {
+  const r = optimizationPolicy.read(v, "optimizationPolicy");
+  if (r.algorithm === "mature_cpql_conserved_transfer_v1") {
+    unique(r.requiredChecks, "optimizationPolicy.requiredChecks");
+    return r;
+  }
+  const p = "optimizationPolicy", ids = r.candidateChannelIds, guard = r.measurementGuard;
+  if (r.selection.candidateOrder.length !== ids.length || r.selection.candidateOrder.some((id) => !ids.includes(id))) fail2(p + ".selection.candidateOrder", "must be the exact candidate permutation");
+  unique(r.selection.eligibilitySchedule.map((s) => s.channelId), p + ".selection.eligibilitySchedule");
+  if (r.selection.eligibilitySchedule.length !== ids.length || r.selection.eligibilitySchedule.some((s) => !ids.includes(s.channelId))) fail2(p + ".selection.eligibilitySchedule", "must cover exactly the original candidates");
+  if (r.selection.eligibilitySchedule.some((s) => Date.parse(s.notAfter) <= Date.parse(s.notBefore) || Date.parse(s.notAfter) > Date.parse(r.expiresAt))) fail2(p + ".selection.eligibilitySchedule", "invalid policy selection window");
+  if (r.maxConcurrentCandidates > ids.length) fail2(p + ".maxConcurrentCandidates", "exceeds finite candidate count");
+  if (BigInt(r.totalExplorationCap.amountMicros) === 0n) fail2(p + ".totalExplorationCap", "requires a positive reviewed ceiling");
+  if (guard.sourceRef.kind !== r.eligibleGoal || guard.qualificationRuleRef.module !== "crm" || guard.qualificationRuleRef.id !== guard.sourceRef.projectId || guard.qualificationRuleRef.projectId !== guard.sourceRef.projectId || guard.qualificationRuleRef.site !== guard.sourceRef.site) fail2(p + ".measurementGuard", "requires the original qualified source and CRM witness scope");
+  scoped(r, guard.sourceRef.projectId, [guard.sourceRef.site], p);
+  return r;
+}
+var RESONANCE_OPTIMIZATION_POLICY_JSON_SCHEMA = optimizationPolicy.schema;
+var optimization = object2({ enabled: bool, policy: optimizationPolicy, stopLoss: object2({ confirmedSpend: money, unreconciledExposure: money }) });
+var channelBase = { id: uuid, ...scope, destinationId: uuid, creativeIds: list2(uuid, 50, 1) };
+var search = object2({ ...channelBase, localCampaignKey: text2(80), kind: literal2("google_search"), provider: literal2("google_ads"), accountBindingId: uuid, 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: uuid, 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 meta = object2({ ...channelBase, localCampaignKey: text2(80), kind: literal2("meta_retargeting"), provider: literal2("meta_ads"), accountBindingId: uuid, capabilityRevision: revision, allocation: money, budgetMode: choice2("lifetime", "daily"), audienceRuleRefs: list2(audience, 50, 1), objective: choice2("OUTCOME_LEADS", "OUTCOME_SALES", "OUTCOME_TRAFFIC"), pageRef: object2({ connectionId: uuid, externalId: text2(160), revision }), instagramRef: nullable2(object2({ connectionId: uuid, 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) });
+var owned = object2({ ...channelBase, kind: choice2("funnel", "broadcast", "outreach"), resourceRef: resource });
+var channel = union2(search, meta, owned);
+var definitionFields = { schemaVersion: literal2(1), projectId: uuid, 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: uuid, 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");
+}
+function checkDefinition(v) {
+  unique(v.sites, "campaign.sites");
+  scoped(v, v.projectId, v.sites, "campaign");
+  parseResonanceOptimizationPolicy(v.optimization.policy);
+  if (v.optimization.enabled && v.objective.source.kind !== v.optimization.policy.eligibleGoal) fail2("campaign.optimization.policy", "policy is not eligible for this goal");
+  if ([v.optimization.stopLoss.confirmedSpend, v.optimization.stopLoss.unreconciledExposure].some((m) => m.currency !== v.budget.total.currency)) fail2("campaign.optimization.stopLoss", "currency mismatch");
+  unique(v.channels.map((c) => c.id), "campaign.channels");
+  unique(v.creativeRefs.map((c) => c.id), "campaign.creativeRefs");
+  unique(v.destinations.map((d) => d.id), "campaign.destinations");
+  if (!["business_brain", "publication"].includes(v.brandRef.module)) fail2("campaign.brandRef", "must reference existing brand owner");
+  for (const c of v.creativeRefs) if (c.assetRef.module !== "files" || c.preparedArtifactRef && !["files", "broadcast"].includes(c.preparedArtifactRef.module)) fail2("campaign.creativeRefs", "unsupported asset owner");
+  for (const d of v.destinations) if (d.kind === "funnel" && d.funnelRef.module !== "funnel") fail2("campaign.destinations", "must reference funnel owner");
+  for (const c of v.channels) {
+    const dest = v.destinations.find((d) => d.id === c.destinationId) ?? fail2("campaign.channels.destinationId", "must reference a destination ID");
+    if (dest.site !== c.site) fail2("campaign.channels.destinationId", "destination site mismatch");
+    if (c.creativeIds.some((id) => !v.creativeRefs.some((x) => x.id === id))) fail2("campaign.channels.creativeIds", "unknown creative");
+    if ("bid" in c && "cap" in c.bid && c.bid.cap.currency !== v.budget.total.currency) fail2("campaign.channels.bid", "currency mismatch");
+    if ("adGroups" in c) {
+      for (const g of c.adGroups) for (const a of g.ads) if (!c.creativeIds.includes(a.creativeId)) fail2("campaign.channels.adGroups", "ad creative outside channel");
+    }
+    if ("resourceRef" in c && c.resourceRef.module !== c.kind) fail2("campaign.channels.resourceRef", "module owner mismatch");
+    if ("bidding" in c && "target" in c.bidding && c.bidding.target.currency !== v.budget.total.currency) fail2("campaign.channels.bidding", "currency mismatch");
+    if ("allocation" in c && c.allocation.currency !== v.budget.total.currency) fail2("campaign.channels.allocation", "currency mismatch");
+  }
+  const policy = v.optimization.policy;
+  if (policy.algorithm === "finite_meta_candidates_v1") {
+    const guard = policy.measurementGuard, goal = v.objective;
+    if (canonical(guard.sourceRef) !== canonical(goal.source) || !goal.qualificationRuleRef || canonical(guard.qualificationRuleRef) !== canonical(goal.qualificationRuleRef) || guard.maturityDelaySeconds !== goal.maturityDelaySeconds || goal.countingUnit !== "unique_qualified_contact") fail2("campaign.optimization.policy.measurementGuard", "must match the original qualified objective");
+    if (policy.totalExplorationCap.currency !== v.budget.total.currency || compareMoney(policy.totalExplorationCap, v.budget.total) > 0) fail2("campaign.optimization.policy.totalExplorationCap", "outside original budget ceiling");
+    if (Date.parse(policy.expiresAt) > Date.parse(v.budget.endAt) || policy.selection.eligibilitySchedule.some((s) => Date.parse(s.notBefore) < Date.parse(v.budget.startAt) || Date.parse(s.notAfter) > Date.parse(v.budget.endAt))) fail2("campaign.optimization.policy.selection", "selection windows must stay inside the original flight");
+    for (const id of policy.candidateChannelIds) {
+      const c = v.channels.find((c2) => c2.id === id);
+      if (!c || c.kind !== "meta_retargeting" || c.budgetMode !== "lifetime" || c.budgetOwner !== "adset" || BigInt(c.allocation.amountMicros) === 0n) fail2("campaign.optimization.policy.candidateChannelIds", "requires an original independently capped Meta adset channel");
+    }
+  }
+}
+function parseResonanceCampaignDefinition(v) {
+  const result = definition.read(v, "campaign");
+  checkDefinition(result);
+  return result;
+}
+function parseResonanceCampaignDraft(v) {
+  const result = draft.read(v, "draft");
+  unique(result.sites, "draft.sites");
+  scoped(result, result.projectId, result.sites, "draft");
+  return result;
+}
+var RESONANCE_CAMPAIGN_DEFINITION_JSON_SCHEMA = definition.schema;
+var RESONANCE_CAMPAIGN_DRAFT_JSON_SCHEMA = draft.schema;
+var capability = object2({ id: uuid, projectId: uuid, connectionId: uuid, 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 parseResonanceAccountCapability = (v) => {
+  const r = capability.read(v, "account");
+  if (Date.parse(r.expiresAt) <= Date.parse(r.observedAt)) fail2("account.expiresAt", "must follow observation");
+  return r;
+};
+var mandateRef = object2({ ledgerActionId: uuid, campaignId: uuid, preparedPlanId: uuid, reviewDigest: digest, mandateDigest: digest, expectedKillRevision: integer2(0) });
+var parseResonanceMandateRef = (v) => mandateRef.read(v, "mandateRef");
+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 resonanceWebsiteVisitProfileDigestInput = () => canonical(RESONANCE_WEBSITE_VISIT_PROFILE);
+var measurementRuleRef = object2({ id: uuid, revision });
+var measurementConfigRef = object2({ configRevision: revision, policyRevision: revision, digest });
+var matchingProfileRef = object2({ id: uuid, 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: uuid,
+  measurementConfigRef,
+  resourceRuleRefs: list2(measurementRuleRef, 500, 1),
+  matchingProfileRef
+}), 100, 1) });
+var RESONANCE_WEBSITE_VISIT_FEED_JSON_SCHEMA = websiteVisitFeed.schema;
+var mandateScope = object2({ projectId: uuid, campaignId: uuid, preparedPlanId: uuid, reviewDigest: digest, accountBindingIds: list2(uuid, 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) });
+function parseResonanceMandateScope(v) {
+  const r = mandateScope.read(v, "mandateScope");
+  scoped(r, r.projectId, r.sites, "mandateScope");
+  if (r.websiteVisitFeed) {
+    unique(r.websiteVisitFeed.channels.map((c) => c.channelId), "mandateScope.websiteVisitFeed.channels");
+    for (const c of r.websiteVisitFeed.channels) unique(c.resourceRuleRefs.map((rule) => rule.id), "mandateScope.websiteVisitFeed.resourceRuleRefs");
+  }
+  return r;
+}
+var websiteVisitTimes = object2({ occurredAt: instant, receivedAt: instant });
+function resonanceWebsiteVisitEventTime(value, context) {
+  const input = websiteVisitTimes.read(value, "websiteVisitTime");
+  const actual = object2({ mandate: mandateScope, approvedAt: instant, now: instant }).read(context, "websiteVisitTime.context");
+  const grant = parseResonanceMandateScope(actual.mandate);
+  if (!grant.websiteVisitFeed) fail2("websiteVisitTime.context.mandate.websiteVisitFeed", "requires an explicit original feed selection");
+  const occurred = Date.parse(input.occurredAt), received = Date.parse(input.receivedAt), now = Date.parse(actual.now);
+  const policy = RESONANCE_WEBSITE_VISIT_PROFILE;
+  if (received < occurred - policy.maxFutureSkewMs || received - occurred > policy.maxCaptureAgeMs || now < received || now < occurred - policy.maxFutureSkewMs || now - occurred > policy.maxDispatchAgeMs) fail2("websiteVisitTime", "outside the local original observation freshness profile");
+  const start = Math.max(Date.parse(grant.budget.startAt), Date.parse(actual.approvedAt)), end = Math.min(Date.parse(grant.budget.endAt), Date.parse(grant.expiresAt));
+  if (occurred < start || received < start || occurred >= end || received >= end || now >= end) fail2("websiteVisitTime", "outside the original approval and dispatch window");
+  return Math.floor(occurred / 1e3);
+}
+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 parseResonanceGoogleUploadClicksCustomGoalSpec = (value) => googleSetupSpec.read(value, "googleSetupSpec");
+var resonanceGoogleSetupDigestInput = (value) => canonical(parseResonanceGoogleUploadClicksCustomGoalSpec(value));
+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) }) })
+);
+function parseResonanceGoogleConfigurationSaveCommand(value) {
+  const result = googleSave.read(value, "googleConfigurationSave");
+  if (result.mode === "existing") normalizeGoogleGoal(result.nativeGoal, "googleConfigurationSave.nativeGoal");
+  return result;
+}
+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: uuid,
+  declaredAt: instant,
+  declaredForCampaignRevision: integer2(1)
+});
+var googleConfigurationFields = {
+  projectId: uuid,
+  campaignId: uuid,
+  channelId: uuid,
+  site,
+  accountBindingId: uuid,
+  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 parseResonanceGoogleConfigurationSnapshot = (value) => googleConfigurationSnapshot.read(value, "googleConfiguration");
+var parseResonanceGoogleConfigurationReview = (value) => googleConfigurationReview.read(value, "googleConfigurationReview");
+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: uuid, replayed: bool, campaignRevision: integer2(1) };
+var googleConfigurationSaveResponse = refine2(union2(object2({ ...googleViewFields, ...googleExistingChoiceFields, ...googleSaveResultFields }), object2({ ...googleViewFields, ...googleSetupChoiceFields, ...googleSaveResultFields })), checkGoogleView);
+var parseResonanceGoogleConfigurationView = (value) => googleConfigurationView.read(value, "googleConfigurationView");
+var parseResonanceGoogleConfigurationSaveResponse = (value) => googleConfigurationSaveResponse.read(value, "googleConfigurationSaveResponse");
+function projectResonanceGoogleConfiguration(value, readiness) {
+  const snapshot = parseResonanceGoogleConfigurationSnapshot(value);
+  const metadata = googleReadiness().read(readiness, "googleConfigurationReadiness");
+  const { configurationRevision, ...fields2 } = snapshot;
+  const view2 = parseResonanceGoogleConfigurationView({ ...fields2, revision: configurationRevision, ...metadata });
+  return { view: view2, review: view2.ready ? parseResonanceGoogleConfigurationReview(snapshot) : null };
+}
+function googleReadiness() {
+  return object2(googleReadinessFields);
+}
+var googleConfigurationDigestValue = refine2(union2(object2({ ...googleConfigurationFields, ...googleExistingChoiceFields, configurationDigest: optional2(digest) }), object2({ ...googleConfigurationFields, ...googleSetupChoiceFields, configurationDigest: optional2(digest) })), checkGoogleConfiguration);
+function resonanceGoogleConfigurationDigestInput(value) {
+  const { configurationDigest: _self, ...content } = googleConfigurationDigestValue.read(value, "googleConfigurationDigestInput");
+  return canonical(content);
+}
+var RESONANCE_GOOGLE_SETUP_SPEC_JSON_SCHEMA = googleSetupSpec.schema;
+var RESONANCE_GOOGLE_CONFIGURATION_SAVE_COMMAND_JSON_SCHEMA = googleSave.schema;
+var RESONANCE_GOOGLE_CONFIGURATION_SNAPSHOT_JSON_SCHEMA = googleConfigurationSnapshot.schema;
+var RESONANCE_GOOGLE_CONFIGURATION_REVIEW_JSON_SCHEMA = googleConfigurationReview.schema;
+var RESONANCE_GOOGLE_CONFIGURATION_VIEW_JSON_SCHEMA = googleConfigurationView.schema;
+var RESONANCE_GOOGLE_CONFIGURATION_SAVE_RESPONSE_JSON_SCHEMA = googleConfigurationSaveResponse.schema;
+var preparedManifestRef = object2({ id: uuid, digest, providerVersion: text2(30), revision });
+var preview = object2({ channelId: uuid, site, accountBindingId: nullable2(uuid), 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: uuid, campaignId: uuid, projectId: uuid, 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) });
+function parseResonancePreparedPlan(v) {
+  const r = prepared.read(v, "preparedPlan");
+  checkDefinition(r.definition);
+  scoped(r, r.projectId, r.definition.sites, "preparedPlan");
+  if (Date.parse(r.expiresAt) <= Date.parse(r.preparedAt)) fail2("preparedPlan.expiresAt", "must follow preparation");
+  const goal = r.definition.objective, witness = r.resolvedQualificationRule;
+  if (goal.source.kind === "qualified_lead") {
+    if (!goal.qualificationRule || !goal.qualificationRuleRef || !witness) fail2("preparedPlan.resolvedQualificationRule", "qualified-lead preparation requires actual configured native witness");
+    const w = witness, selected = goal.qualificationRule;
+    if (goal.countingUnit !== "unique_qualified_contact" || canonical(w.ref) !== canonical(goal.qualificationRuleRef) || w.eligibleFormIds.length !== 1 || w.eligibleFormIds[0] !== goal.source.id || w.cohort.maturityDelaySeconds !== goal.maturityDelaySeconds) fail2("preparedPlan.resolvedQualificationRule", "source, counting unit, reference or maturity mismatch");
+    for (const key of ["schemaVersion", "semantics", "positiveStageKeys", "finalNegativeStageKeys", "pendingStageKeys", "existingContactPolicy"]) if (canonical(w[key]) !== canonical(selected[key])) fail2("preparedPlan.resolvedQualificationRule", "selected qualification snapshot mismatch");
+  } else if (witness !== null) fail2("preparedPlan.resolvedQualificationRule", "nonqualified objectives require explicit null");
+  if (canonical(r.resolvedEvidencePolicy) !== canonical(r.definition.optimization.policy)) fail2("preparedPlan.resolvedEvidencePolicy", "policy snapshot mismatch");
+  parseResonanceOptimizationPolicy(r.resolvedEvidencePolicy);
+  if (r.resolvedEvidencePolicy.algorithm === "finite_meta_candidates_v1" && Date.parse(r.resolvedEvidencePolicy.expiresAt) <= Date.parse(r.preparedAt)) fail2("preparedPlan.resolvedEvidencePolicy.expiresAt", "finite policy expired before preparation");
+  unique(r.accounts.map((a) => a.id), "preparedPlan.accounts");
+  unique(r.channelPreviews.map((p) => p.channelId), "preparedPlan.channelPreviews");
+  if (r.channelPreviews.length !== r.definition.channels.length) fail2("preparedPlan.channelPreviews", "must cover every channel");
+  for (const a of r.accounts) parseResonanceAccountCapability(a);
+  for (const p of r.channelPreviews) {
+    const c = r.definition.channels.find((c2) => c2.id === p.channelId) ?? fail2("preparedPlan.channelPreviews", "unknown channel");
+    if (c.site !== p.site) fail2("preparedPlan.channelPreviews", "channel scope mismatch");
+    const google = p.googleConfiguration;
+    if (c.kind === "google_search") {
+      if (!google) fail2("preparedPlan.channelPreviews.googleConfiguration", "Google requires the actual reviewed configuration");
+      const g = google;
+      if (g.projectId !== r.projectId || g.campaignId !== r.campaignId || g.channelId !== c.id || g.site !== c.site || g.accountBindingId !== c.accountBindingId) fail2("preparedPlan.channelPreviews.googleConfiguration", "configuration scope mismatch");
+      if (canonical(g.source) !== canonical(goal.source) || g.measurementRevision !== goal.measurementRevision || g.countingUnit !== goal.countingUnit || g.attributionWindowDays !== goal.attributionWindowDays) fail2("preparedPlan.channelPreviews.googleConfiguration.source", "objective measurement mismatch");
+      unique(c.locationIds, "preparedPlan.channelPreviews.googleConfiguration.locationIds");
+      unique(c.excludedLocationIds, "preparedPlan.channelPreviews.googleConfiguration.excludedLocationIds");
+      if (canonical(g.declaration.locationIds) !== canonical([...c.locationIds].sort()) || canonical(g.declaration.excludedLocationIds) !== canonical([...c.excludedLocationIds].sort())) fail2("preparedPlan.channelPreviews.googleConfiguration.declaration", "region scope mismatch");
+      if (g.declaration.declaredForCampaignRevision > r.expectedRevision || Date.parse(g.declaration.declaredAt) > Date.parse(r.preparedAt)) fail2("preparedPlan.channelPreviews.googleConfiguration.declaration", "declaration follows preparation scope");
+    } else if (google !== null) fail2("preparedPlan.channelPreviews.googleConfiguration", "non-Google channels require explicit null");
+    const d = r.definition.destinations.find((d2) => d2.id === c.destinationId);
+    const expectedUrl = p.attributionMarker ? new URL(`https://${p.site}${d.path}`) : null;
+    if (expectedUrl && p.attributionMarker) expectedUrl.searchParams.set(RESONANCE_SOURCE_MARKER_PARAMETER, p.attributionMarker.value);
+    if (!sameSite(hostFromUrl(p.destinationUrl), p.site) || p.destinationUrl !== (expectedUrl?.toString() ?? `https://${p.site}${d.path}`)) fail2("preparedPlan.channelPreviews.destinationUrl", "must be exact HTTPS destination and reviewed source marker on the owned site");
+    if (canonical(p.orderedCreatives) !== canonical(c.creativeIds.map((id) => r.definition.creativeRefs.find((x) => x.id === id)))) fail2("preparedPlan.channelPreviews.orderedCreatives", "creative order/content mismatch");
+    if ("provider" in c) {
+      if (p.accountBindingId !== c.accountBindingId || !r.accounts.some((a) => a.id === c.accountBindingId)) fail2("preparedPlan.channelPreviews.accountBindingId", "account binding mismatch");
+      if (canonical(p.allocation) !== canonical(c.allocation)) fail2("preparedPlan.channelPreviews.allocation", "allocation mismatch");
+    } else if (p.accountBindingId !== null || p.allocation !== null) fail2("preparedPlan.channelPreviews", "nonpaid child cannot select paid account/allocation");
+  }
+  return r;
+}
+var commandBase = { schemaVersion: literal2(1), campaignId: uuid, expectedRevision: integer2(1), idempotencyKey: operationKey, channelIds: list2(uuid, 100) };
+var effect = object2({ ...commandBase, operation: choice2("launch", "update", "resume"), preparedPlanId: uuid, reviewDigest: digest, mandateRef, expectedRemoteSnapshots: list2(object2({ channelId: uuid, digest }), 100) });
+var optimize = object2({ ...commandBase, operation: literal2("optimize"), preparedPlanId: uuid, reviewDigest: digest, mandateRef, decisionRef: object2({ id: uuid, revision, evidenceDigest: digest }), expectedRemoteSnapshots: list2(object2({ channelId: uuid, digest }), 100) });
+var safety = object2({ ...commandBase, operation: choice2("pause", "finish", "reconcile") });
+var deliverConversion = object2({ ...commandBase, operation: literal2("deliver_conversion"), channelIds: list2(uuid, 1, 1), preparedPlanId: uuid, reviewDigest: digest, mandateRef, conversionId: uuid });
+var deliverWebsiteVisit = object2({ ...commandBase, operation: literal2("deliver_website_visit"), channelIds: list2(uuid, 1, 1), preparedPlanId: uuid, reviewDigest: digest, mandateRef, occurrenceId: uuid });
+var command = union2(effect, optimize, safety, deliverConversion, deliverWebsiteVisit);
+function parseResonanceCommand(v, context) {
+  const r = command.read(v, "command");
+  unique(r.channelIds, "command.channelIds");
+  if ("mandateRef" in r && (r.mandateRef.campaignId !== r.campaignId || r.mandateRef.preparedPlanId !== r.preparedPlanId || r.mandateRef.reviewDigest !== r.reviewDigest)) fail2("command.mandateRef", "snapshot mismatch");
+  if ((r.operation === "deliver_conversion" || r.operation === "deliver_website_visit") && context) {
+    const plan = parseResonancePreparedPlan(context.preparedPlan), grant = parseResonanceMandateScope(context.mandate);
+    const now = Date.parse(instant.read(context.now, "command.context.now"));
+    if (r.expectedRevision !== plan.expectedRevision) fail2("command.expectedRevision", "requires the original prepared definition revision");
+    if (r.campaignId !== plan.campaignId || r.preparedPlanId !== plan.id || r.reviewDigest !== plan.reviewDigest || grant.projectId !== plan.projectId || grant.campaignId !== plan.campaignId || grant.preparedPlanId !== plan.id || grant.reviewDigest !== plan.reviewDigest) fail2("command.context", "requires the exact original plan and mandate scope");
+    if (canonical(grant.goal) !== canonical(plan.definition.objective) || canonical(grant.budget) !== canonical(plan.definition.budget)) fail2("command.context.mandate", "original goal or budget mismatch");
+    const channel2 = plan.definition.channels.find((c) => c.id === r.channelIds[0]);
+    if (r.operation === "deliver_conversion") {
+      if (!grant.allowedOperations.includes("deliver_conversion")) fail2("command.context.mandate.allowedOperations", "requires the explicit original delivery grant");
+      if (!channel2 || channel2.kind !== "google_search") fail2("command.channelIds", "requires one original Google channel");
+      const c = channel2;
+      const goal = plan.definition.objective, witness = plan.resolvedQualificationRule;
+      if (goal.source.kind !== "qualified_lead" || goal.countingUnit !== "unique_qualified_contact" || !witness || witness.eligibleFormIds.length !== 1 || witness.eligibleFormIds[0] !== goal.source.id || goal.source.site !== c.site) fail2("command.context.goal", "requires the original single managed-form qualified source");
+      const account = plan.accounts.find((a) => a.id === c.accountBindingId);
+      if (!account || account.provider !== "google_ads" || !grant.accountBindingIds.includes(c.accountBindingId) || !grant.sites.includes(c.site)) fail2("command.context.account", "requires the original granted Google account and site");
+      const configuration = plan.channelPreviews.find((p) => p.channelId === c.id)?.googleConfiguration;
+      if (!configuration || configuration.signalSemantics !== RESONANCE_GOOGLE_SIGNAL_SEMANTICS) fail2("command.context.googleConfiguration", "requires the reviewed qualified-at-observation profile");
+      const g = configuration;
+      if (g.mode === "existing" && (g.nativeGoal.actionIds.length !== 1 || g.nativeGoal.actionIds[0].split("/")[1] !== account.externalAccountId || g.nativeGoal.externalId.split("/")[1] !== account.externalAccountId)) fail2("command.context.googleConfiguration.nativeGoal", "requires one action owned by the original account; cross-account delivery is unsupported");
+      if (g.mode === "admitted_setup" && (g.setupSpec.goalStrategy !== "exclusive_custom_goal_v1" || g.setupSpec.goalActionKey !== g.setupSpec.action.localKey)) fail2("command.context.googleConfiguration.setupSpec", "requires the original single-action setup intent");
+    } else {
+      const selected = grant.websiteVisitFeed?.channels.find((c2) => c2.channelId === r.channelIds[0]);
+      if (!selected) fail2("command.context.mandate.websiteVisitFeed", "requires the explicit original feed channel");
+      if (!channel2 || channel2.kind !== "meta_retargeting") fail2("command.channelIds", "requires one original Meta channel");
+      const c = channel2;
+      const account = plan.accounts.find((a) => a.id === c.accountBindingId);
+      if (!account || account.provider !== "meta_ads" || !grant.accountBindingIds.includes(c.accountBindingId) || !grant.sites.includes(c.site)) fail2("command.context.account", "requires the original granted Meta account and site");
+      if (c.audienceRuleRefs.some((rule) => !grant.audienceRuleRefs.some((original) => canonical(original) === canonical(rule)))) fail2("command.context.audienceRuleRefs", "requires the original granted audience rules");
+    }
+    if (now < Date.parse(grant.budget.startAt) || now >= Date.parse(grant.budget.endAt) || now >= Date.parse(grant.expiresAt)) fail2("command.context.now", "outside the original mandate and budget dispatch window");
+  }
+  return r;
+}
+var RESONANCE_COMMAND_JSON_SCHEMA = command.schema;
+var step = object2({ id: uuid, channelId: uuid, 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: uuid, projectId: uuid, campaignId: uuid, preparedPlanId: nullable2(uuid), effectKey: text2(200), requestDigest: digest, ledgerActionId: uuid, 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) });
+function parseResonanceReceipt(v) {
+  const r = receipt.read(v, "receipt");
+  if (r.reservedExposure.currency !== r.unreconciledExposure.currency) fail2("receipt", "currency mismatch");
+  const uncertain = r.steps.some((s) => s.state === "uncertain" || s.admission === "unknown");
+  if (uncertain && r.state !== "needs_reconciliation") fail2("receipt.state", "uncertain child requires reconciliation state");
+  if ((uncertain || r.state === "needs_reconciliation") && r.nextActions.includes("retry_same_operation")) fail2("receipt.nextActions", "unknown admission must reconcile before retry");
+  return r;
+}
+var lifecycle = choice2("not_materialized", "pending", "partially_live", "live", "pausing", "paused", "finished", "needs_attention", "unknown");
+var view = object2({ id: uuid, projectId: uuid, managementMode: choice2("tracking_only", "managed"), revision: integer2(0), definition: nullable2(draft), acceptedPlanId: nullable2(uuid), desiredLifecycle: choice2("draft", "running", "paused", "finished"), effectiveLifecycle: lifecycle, blockingReasons: list2(text2(200), 100), activeOperation: nullable2(receipt), unresolvedExposure: nullable2(money) });
+function parseResonanceCampaignView(v) {
+  const r = view.read(v, "campaignView");
+  if (r.managementMode === "managed" && r.revision < 1) fail2("campaignView.revision", "managed campaigns require revision >=1");
+  if (r.definition) parseResonanceCampaignDraft(r.definition);
+  if (r.activeOperation) parseResonanceReceipt(r.activeOperation);
+  if (r.definition && r.definition.projectId !== r.projectId) fail2("campaignView.definition", "cross-project reference");
+  if (r.activeOperation && (r.activeOperation.projectId !== r.projectId || r.activeOperation.campaignId !== r.id)) fail2("campaignView.activeOperation", "scope mismatch");
+  return r;
+}
+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: uuid, name: choice2("impressions", "clicks", "spend", "accepted_goals", "qualified_goals", "revenue", "conversion_rate"), source: choice2("first_party", "provider", "experiment"), sourceRef: revision, goalRevision: nullable2(revision), countingUnit: choice2("unique_source", "unique_qualified_contact", "net_order", "provider_aggregate"), 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) }));
+function parseResonanceMetricObservation(v) {
+  const r = metric.read(v, "metric");
+  if (["accepted_goals", "qualified_goals", "revenue", "conversion_rate"].includes(r.name) && r.goalRevision === null) fail2("metric.goalRevision", "goal measurement requires explicit revision");
+  if (Date.parse(r.windowEnd) <= Date.parse(r.windowStart)) fail2("metric.window", "invalid window");
+  if (r.state === "observed") {
+    const expected = r.name === "spend" || r.name === "revenue" ? "money" : r.name === "conversion_rate" ? "ratio" : "count";
+    if (r.value.kind !== expected) fail2("metric.value", "metric unit mismatch");
+  }
+  return r;
+}
+var purpose = choice2("analytics_storage", "ad_storage", "ad_user_data", "ad_personalization");
+var consent = object2({ ...scope, receiptId: uuid, visitorNamespace: text2(160), configRevision: revision, policyRevision: revision, consentRevision: integer2(1), state: choice2("unknown", "granted", "denied", "withdrawn"), purpose, observedAt: instant, evidenceRef: revision });
+var parseResonanceConsentSnapshot = (v) => consent.read(v, "consent");
+var exposure = object2({ ...scope, experimentId: uuid, experimentRevision: integer2(1), assignmentId: uuid, variantKey: text2(80), exposureId: uuid, occurredAt: instant });
+var conversion = object2({ schemaVersion: literal2(1), ...scope, eventId: uuid, sourceRef: source, campaignId: nullable2(uuid), 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) });
+function parseResonanceConversionEnvelope(v) {
+  const r = conversion.read(v, "conversion");
+  unique(r.consent.map((c) => c.purpose), "conversion.consent");
+  scoped(r, r.projectId, [r.site], "conversion");
+  if (Date.parse(r.receivedAt) < Date.parse(r.occurredAt)) fail2("conversion.receivedAt", "precedes occurrence");
+  return r;
+}
+var RESONANCE_CONVERSION_JSON_SCHEMA = conversion.schema;
+var RESONANCE_PREPARED_PLAN_JSON_SCHEMA = prepared.schema;
+var RESONANCE_ACCOUNT_CAPABILITY_JSON_SCHEMA = capability.schema;
+var RESONANCE_MANDATE_SCOPE_JSON_SCHEMA = mandateScope.schema;
+var RESONANCE_MANDATE_REF_JSON_SCHEMA = mandateRef.schema;
+var RESONANCE_RECEIPT_JSON_SCHEMA = receipt.schema;
+var RESONANCE_CAMPAIGN_VIEW_JSON_SCHEMA = view.schema;
+var RESONANCE_METRIC_JSON_SCHEMA = metric.schema;
+var RESONANCE_CONSENT_JSON_SCHEMA = consent.schema;
+var parseResonanceExperimentExposure = (v) => exposure.read(v, "exposure");
+var mandateTarget = object2({ project_id: uuid, campaign_id: uuid });
+var mandateApproval = object2({ schemaVersion: literal2(1), expectedRevision: integer2(1), preparedPlanId: uuid, reviewDigest: digest, mandateDigest: digest, mandate: mandateScope });
+var RESONANCE_MANDATE_APPROVAL_JSON_SCHEMA = mandateApproval.schema;
+var RESONANCE_MANDATE_TARGET_JSON_SCHEMA = mandateTarget.schema;
+var RESONANCE_MANDATE_ACTION_KIND = "resonance_mandate";
+function parseResonanceMandateApprovalPayload(v, target) {
+  const r = mandateApproval.read(v, "mandateApproval"), t = mandateTarget.read(target, "target_ref");
+  parseResonanceMandateScope(r.mandate);
+  if (r.mandate.projectId !== t.project_id || r.mandate.campaignId !== t.campaign_id || r.preparedPlanId !== r.mandate.preparedPlanId || r.reviewDigest !== r.mandate.reviewDigest) fail2("mandateApproval", "target or snapshot mismatch");
+  return r;
+}
+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 resonanceMandateDigestInput = (v) => canonical(parseResonanceMandateScope(v));
+var resonanceCommandDigestInput = (v) => canonical(parseResonanceCommand(v));
+var parseResonanceMandateTarget = (v) => mandateTarget.read(v, "target_ref");
+var prepareCommand = object2({ expectedRevision: integer2(1), idempotencyKey: operationKey });
+var parseResonancePrepareCommand = (v) => prepareCommand.read(v, "prepare");
+var parseResonanceCommandPrepareRequest = parseResonancePrepareCommand;
+var commandPreparation = object2({ command: nullable2(command), covered: bool, approvalRequirement: nullable2(choice2("existing_mandate", "current_owner")), reasonCodes: list2(text2(200), 100) });
+function parseResonanceCommandPrepareResponse(v) {
+  const r = commandPreparation.read(v, "commandPreparation");
+  if (r.command) parseResonanceCommand(r.command);
+  return r;
+}
+var RESONANCE_COMMAND_PREPARE_REQUEST_JSON_SCHEMA = prepareCommand.schema;
+var RESONANCE_COMMAND_PREPARE_RESPONSE_JSON_SCHEMA = commandPreparation.schema;
+function resonancePlanIssues(input, at) {
+  const plan = parseResonancePreparedPlan(input), issues = [];
+  instant.read(at, "asOf");
+  if (Date.parse(plan.expiresAt) <= Date.parse(at) || Date.parse(plan.preparedAt) > Date.parse(at)) issues.push({ path: "preparedPlan", code: "plan_stale" });
+  for (const reason of plan.blockingReasons) issues.push({ path: "preparedPlan", code: reason });
+  if (plan.definition.optimization.enabled) {
+    const goal = plan.definition.objective;
+    if (!goal.qualificationRule || !goal.qualificationRuleRef || !goal.qualificationRule.positiveStageKeys.length) issues.push({ path: "objective.qualificationRule", code: "native_qualification_rule_missing" });
+    const attributionModel = plan.resolvedEvidencePolicy.algorithm === "finite_meta_candidates_v1" ? plan.resolvedEvidencePolicy.measurementGuard.attributionModel : plan.resolvedEvidencePolicy.attributionModel;
+    if (plan.resolvedEvidencePolicy.algorithm === "finite_meta_candidates_v1" && Date.parse(plan.resolvedEvidencePolicy.expiresAt) <= Date.parse(at)) issues.push({ path: "resolvedEvidencePolicy.expiresAt", code: "finite_policy_expired" });
+    if (attributionModel !== RESONANCE_ATTRIBUTION_MODEL) issues.push({ path: "resolvedEvidencePolicy.attributionModel", code: "verified_last_touch_model_required" });
+    for (const preview2 of plan.channelPreviews) if (!preview2.attributionMarker) issues.push({ path: "channelPreviews." + preview2.channelId, code: "approved_source_marker_missing" });
+  }
+  for (const channel2 of plan.definition.channels) {
+    if (!("provider" in channel2)) continue;
+    const account = plan.accounts.find((a) => a.id === channel2.accountBindingId);
+    const path2 = "channels." + channel2.id;
+    if (!account) {
+      issues.push({ path: path2, code: "account_missing" });
+      continue;
+    }
+    if (account.provider !== channel2.provider || account.projectId !== plan.projectId) issues.push({ path: path2, code: "account_scope_mismatch" });
+    if (account.currency !== channel2.allocation.currency) issues.push({ path: path2, code: "currency_mismatch" });
+    if (account.capabilityRevision !== channel2.capabilityRevision || Date.parse(account.expiresAt) <= Date.parse(at) || Date.parse(account.observedAt) > Date.parse(at)) issues.push({ path: path2, code: "capability_stale" });
+    if (account.advertiserState !== "eligible" || account.profiles.find((p) => p.profile === channel2.kind)?.state !== "supported" || account.operations.find((o) => o.operation === "launch")?.state !== "supported") issues.push({ path: path2, code: "capability_not_supported" });
+    if (!account.profiles.find((p) => p.profile === channel2.kind)?.budgetModes.includes(channel2.budgetMode)) issues.push({ path: path2, code: "budget_mode_not_supported" });
+  }
+  return issues;
+}
+function compareMoney(a, b) {
+  a = parseMoney(a);
+  b = parseMoney(b);
+  if (a.currency !== b.currency) fail2("money.currency", "currency mismatch");
+  const left = BigInt(a.amountMicros), right = BigInt(b.amountMicros);
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function subtractMoney(a, b) {
+  if (compareMoney(a, b) < 0) fail2("money.amountMicros", "negative result");
+  return parseMoney({ currency: a.currency, amountMicros: (BigInt(a.amountMicros) - BigInt(b.amountMicros)).toString() });
+}
+function formatMoney(input) {
+  const m = parseMoney(input), n = m.amountMicros.padStart(7, "0");
+  const fraction = n.slice(-6).replace(/0+$/, "");
+  return m.currency + " " + n.slice(0, -6) + (fraction ? "." + fraction : "");
+}
+var saveCommand = object2({ definition: draft, expectedRevision: optional2(integer2(0)), idempotencyKey: operationKey });
+function parseResonanceCampaignSaveCommand(v, mode = "update") {
+  const r = saveCommand.read(v, "save");
+  parseResonanceCampaignDraft(r.definition);
+  if (mode !== "create" && mode !== "update") fail2("save.mode", "unsupported mode");
+  if (mode === "update" && (r.expectedRevision === void 0 || r.expectedRevision < 1)) fail2("save.expectedRevision", "required for update");
+  return r;
+}
+var acceptCommand = object2({ expectedRevision: integer2(1), ledgerActionId: uuid });
+var parseResonanceAcceptCommand = (v) => acceptCommand.read(v, "accept");
+var bindingCommand = object2({ connectionId: uuid, provider: choice2("google_ads", "meta_ads"), externalAccountId: text2(160), expectedConnectionRevision: revision, idempotencyKey: operationKey });
+var parseResonanceBindingCommand = (v) => bindingCommand.read(v, "binding");
+var RESONANCE_SAVE_COMMAND_JSON_SCHEMA = saveCommand.schema;
+var RESONANCE_ACCEPT_COMMAND_JSON_SCHEMA = acceptCommand.schema;
+var RESONANCE_BINDING_COMMAND_JSON_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) });
+function cpqlMissingOutcomeBound(input) {
+  const n = BigInt(decimal.read(input.eligibleContacts, "bound.eligibleContacts"));
+  const c = BigInt(decimal.read(input.fullyResolvedContacts, "bound.fullyResolvedContacts"));
+  const k = BigInt(decimal.read(input.qualifiedContacts, "bound.qualifiedContacts"));
+  if (c > n || k > c) fail2("bound", "inconsistent unique-contact source universe");
+  if (n === 0n || k === 0n || parseMoney(input.verifiedSpend).amountMicros === "0") return null;
+  const u = n - c, denominator = 2n * k + u;
+  return Number((10000n * u + denominator - 1n) / denominator);
+}
+var matureOptimizationEvidence = object2({
+  id: uuid,
+  revision,
+  evidenceDigest: digest,
+  projectId: uuid,
+  campaignId: uuid,
+  preparedPlanId: uuid,
+  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"),
+  channels: list2(object2({ channelId: uuid, site, accountBindingId: uuid, 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 }), 100, 1)
+});
+function parseMatureOptimizationEvidence(v) {
+  const r = matureOptimizationEvidence.read(v, "optimizationEvidence");
+  if (r.objective.measurementRevision !== r.goalRevision) fail2("optimizationEvidence.goalRevision", "goal snapshot mismatch");
+  if (Date.parse(r.windowEnd) <= Date.parse(r.windowStart) || r.dataThrough !== null && Date.parse(r.dataThrough) > Date.parse(r.observedAt)) fail2("optimizationEvidence.window", "invalid observed window");
+  const sites = r.channels.map((c) => c.site);
+  scoped(r, r.projectId, sites, "optimizationEvidence");
+  unique(r.channels.map((c) => c.channelId), "optimizationEvidence.channels");
+  const currency2 = r.channels[0].currentAllocation.currency;
+  for (const c of r.channels) {
+    if (c.uncertaintySource === null) {
+      if (c.uncertaintyBasisPoints !== null) fail2("optimizationEvidence.channels.uncertainty", "no bound without source witness");
+    } else if (c.uncertaintySource.verifiedSpend.currency !== c.currentAllocation.currency || c.uncertaintyBasisPoints !== cpqlMissingOutcomeBound(c.uncertaintySource)) fail2("optimizationEvidence.channels.uncertainty", "source bound mismatch");
+    if (c.allocationHorizon !== null && (["campaign_total", "lifetime"].includes(c.budgetMode) ? c.allocationHorizon.kind !== "finite_period" : c.allocationHorizon.kind !== "daily_average")) fail2("optimizationEvidence.channels.allocationHorizon", "unapproved budget period normalization");
+    if (c.coveredNumerator === null || c.eligibleDenominator === null || c.eligibleDenominator === "0") {
+      if (c.coverageBasisPoints !== null) fail2("optimizationEvidence.channels.coverage", "unknown denominator means unknown coverage");
+    } else {
+      const numerator = BigInt(c.coveredNumerator), denominator = BigInt(c.eligibleDenominator);
+      if (numerator > denominator || c.coverageBasisPoints !== Number(numerator * 10000n / denominator)) fail2("optimizationEvidence.channels.coverage", "coverage ratio mismatch");
+    }
+    if (r.resolvedPolicy.sourceRef === null && c.policyRevision !== r.policyDigest) fail2("optimizationEvidence.channels.policyRevision", "inline policy digest mismatch");
+    if (c.goalRevision !== r.goalRevision || c.countingUnit !== r.objective.countingUnit || c.attributionWindowDays !== r.objective.attributionWindowDays) fail2("optimizationEvidence.channels", "measurement semantics mismatch");
+    if (c.currentAllocation.currency !== currency2) fail2("optimizationEvidence.channels", "currency mismatch");
+    moneyToProviderUnits(c.currentAllocation, { currency: currency2, unitExponent: c.providerUnitExponent, maxUnits: c.providerMaxUnits });
+    for (const observation of c.observations) {
+      parseResonanceMetricObservation(observation);
+      if (observation.campaignId !== r.campaignId || observation.site !== c.site) fail2("optimizationEvidence.channels.observations", "scope mismatch");
+    }
+  }
+  return r;
+}
+var optimizationEvidenceRefFields = { id: uuid, 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: uuid,
+  site,
+  accountBindingId: uuid,
+  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: uuid })),
+  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: uuid,
+  revision,
+  evidenceDigest: digest,
+  projectId: uuid,
+  campaignId: uuid,
+  preparedPlanId: uuid,
+  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);
+function parseResonanceOptimizationEvidence(v, preparedPlan) {
+  const r = optimizationEvidence.read(v, "optimizationEvidence");
+  if (preparedPlan !== void 0) checkOptimizationEvidencePlan(r, parseResonancePreparedPlan(preparedPlan));
+  if (!("evidenceKind" in r)) return parseMatureOptimizationEvidence(r);
+  const p = "optimizationEvidence", policy = parseResonanceOptimizationPolicy(r.resolvedPolicy);
+  if (r.objective.measurementRevision !== r.goalRevision || r.objective.countingUnit !== "unique_qualified_contact" || canonical(policy.measurementGuard.sourceRef) !== canonical(r.objective.source) || canonical(policy.measurementGuard.qualificationRuleRef) !== canonical(r.objective.qualificationRuleRef) || policy.measurementGuard.maturityDelaySeconds !== r.objective.maturityDelaySeconds) fail2(p + ".objective", "finite policy must retain the original qualified objective");
+  if (Date.parse(r.windowEnd) <= Date.parse(r.windowStart) || r.dataThrough !== null && Date.parse(r.dataThrough) > Date.parse(r.observedAt)) fail2(p + ".window", "invalid observed window");
+  unique(r.candidates.map((c) => c.channelId), p + ".candidates");
+  if (r.candidates.length !== policy.candidateChannelIds.length || r.candidates.some((c) => !policy.candidateChannelIds.includes(c.channelId))) fail2(p + ".candidates", "must cover exactly the original finite policy");
+  scoped(r, r.projectId, r.candidates.map((c) => c.site), p);
+  for (const c of r.candidates) {
+    if (c.graphDigest !== c.manifestRef.digest) fail2(p + ".candidates.graphDigest", "must match the actual original manifest graph digest");
+    if (c.cap.currency !== policy.totalExplorationCap.currency || BigInt(c.cap.amountMicros) === 0n) fail2(p + ".candidates.cap", "requires the original positive cap currency");
+    if (Date.parse(c.flight.endAt) <= Date.parse(c.flight.startAt)) fail2(p + ".candidates.flight", "invalid original flight");
+    const schedule = policy.selection.eligibilitySchedule.find((s) => s.channelId === c.channelId);
+    if (Date.parse(schedule.notBefore) < Date.parse(c.flight.startAt) || Date.parse(schedule.notAfter) > Date.parse(c.flight.endAt)) fail2(p + ".candidates.flight", "selection must stay inside original flight");
+    if (c.lifecycle === "not_materialized" && (c.commitmentEvidenceRef !== null || c.activationsObserved !== 0)) fail2(p + ".candidates", "absence cannot borrow a commitment or prior activation");
+    if (["active", "stopped"].includes(c.lifecycle) && c.activationsObserved !== 1) fail2(p + ".candidates.activationsObserved", "active/stopped state requires its original activation");
+    if (c.lifecycle === "not_materialized" && c.ownMeasurement.observations !== null || c.activationsObserved === 0 && c.ownMeasurement.state === "mature") fail2(p + ".candidates.ownMeasurement", "cold/absent candidates cannot borrow mature observations");
+    if (c.ownMeasurement.state === "mature" && c.ownMeasurement.observations.some((o) => o.state !== "observed")) fail2(p + ".candidates.ownMeasurement", "mature observations must be observed");
+    for (const o of c.ownMeasurement.observations ?? []) {
+      parseResonanceMetricObservation(o);
+      if (o.projectId !== r.projectId || o.campaignId !== r.campaignId || o.site !== c.site) fail2(p + ".candidates.ownMeasurement", "foreign candidate measurement scope");
+      if (Date.parse(o.asOf) > Date.parse(r.observedAt) || Date.parse(o.windowStart) < Date.parse(r.windowStart) || Date.parse(o.windowEnd) > Date.parse(r.windowEnd) || o.dataThrough !== null && Date.parse(o.dataThrough) > Date.parse(r.observedAt)) fail2(p + ".candidates.ownMeasurement", "outside the actual candidate evidence window");
+      const aggregate = o.source === "provider" && ["spend", "clicks", "impressions"].includes(o.name);
+      if (aggregate ? o.countingUnit !== "provider_aggregate" || o.attributionModel !== "provider_reported" || o.goalRevision !== null && o.goalRevision !== r.goalRevision : o.source !== "first_party" || o.goalRevision !== r.goalRevision || o.countingUnit !== r.objective.countingUnit || o.attributionModel !== policy.measurementGuard.attributionModel) fail2(p + ".candidates.ownMeasurement", "preserve actual provider aggregate versus first-party cohort provenance");
+    }
+  }
+  return r;
+}
+function checkOptimizationEvidencePlan(e, plan) {
+  const p = "optimizationEvidence";
+  if (e.projectId !== plan.projectId || e.campaignId !== plan.campaignId || e.preparedPlanId !== plan.id || e.reviewDigest !== plan.reviewDigest || canonical(e.objective) !== canonical(plan.definition.objective) || canonical(e.resolvedPolicy) !== canonical(plan.resolvedEvidencePolicy)) fail2(p + ".preparedPlanId", "requires the exact original prepared scope and policy");
+  if (!("evidenceKind" in e)) return;
+  for (const observed of e.candidates) {
+    const original = plan.definition.channels.find((c) => c.id === observed.channelId), preview2 = plan.channelPreviews.find((c) => c.channelId === observed.channelId);
+    if (!original || original.kind !== "meta_retargeting" || !preview2 || observed.site !== original.site || observed.accountBindingId !== original.accountBindingId || canonical(observed.cap) !== canonical(original.allocation) || canonical(observed.manifestRef) !== canonical(preview2.manifestRef)) fail2(p + ".candidates", "candidate projection differs from original channel and manifest");
+    if (canonical(observed.flight) !== canonical({ startAt: plan.definition.budget.startAt, endAt: plan.definition.budget.endAt, timeZone: plan.definition.budget.timeZone })) fail2(p + ".candidates.flight", "must retain the original budget flight");
+  }
+}
+var matureOptimizationDecision = object2({
+  id: uuid,
+  revision,
+  projectId: uuid,
+  campaignId: uuid,
+  preparedPlanId: uuid,
+  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: uuid, 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: uuid, graphDigest: digest, nativeStateEvidenceRef: optimizationEvidenceRef };
+var finiteCandidateActionBody = union2(
+  object2({ action: literal2("materialize_and_activate"), ...finiteCandidateActionFields }),
+  object2({ action: literal2("activate_held"), ...finiteCandidateActionFields, commitmentOperationId: uuid }),
+  object2({ action: literal2("pause_candidate"), ...finiteCandidateActionFields })
+);
+var finiteDecisionFields = {
+  id: uuid,
+  revision,
+  projectId: uuid,
+  campaignId: uuid,
+  preparedPlanId: uuid,
+  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);
+function parseResonanceOptimizationDecision(v, evidence, preparedPlan) {
+  const r = optimizationDecision.read(v, "optimizationDecision");
+  if (Date.parse(r.expiresAt) <= Date.parse(r.createdAt)) fail2("optimizationDecision.expiresAt", "must follow decision");
+  if (preparedPlan !== void 0 && evidence === void 0) fail2("optimizationDecision.evidenceRef", "plan binding requires actual evidence");
+  if (evidence !== void 0) checkOptimizationDecisionEvidence(r, parseResonanceOptimizationEvidence(evidence, preparedPlan));
+  if (r.decisionKind === "preapproved_candidate_operation") return r;
+  unique(r.adjustments.map((c) => c.channelId), "optimizationDecision.adjustments");
+  scoped(r, r.projectId, r.adjustments.map((c) => c.site), "optimizationDecision");
+  if (r.state !== "actionable" && r.adjustments.length) fail2("optimizationDecision.adjustments", "no effects for blocked/noop decision");
+  if (r.state === "actionable" && !r.adjustments.length) fail2("optimizationDecision.adjustments", "action requires exact adjustments");
+  for (const a of r.adjustments) {
+    compareMoney(a.before, a.after);
+    moneyToProviderUnits(a.before, { currency: a.before.currency, unitExponent: a.providerUnitExponent, maxUnits: a.providerMaxUnits });
+    moneyToProviderUnits(a.after, { currency: a.after.currency, unitExponent: a.providerUnitExponent, maxUnits: a.providerMaxUnits });
+    if (r.adjustments[0].before.currency !== a.before.currency) fail2("optimizationDecision.adjustments", "currency mismatch");
+  }
+  return r;
+}
+function checkOptimizationDecisionEvidence(d, e) {
+  const p = "optimizationDecision";
+  if (d.projectId !== e.projectId || d.campaignId !== e.campaignId || d.preparedPlanId !== e.preparedPlanId || d.reviewDigest !== e.reviewDigest || d.policyDigest !== e.policyDigest || canonical(d.evidenceRef) !== canonical({ id: e.id, revision: e.revision, evidenceDigest: e.evidenceDigest })) fail2(p + ".evidenceRef", "must bind the exact original evidence and review");
+  if (Date.parse(d.createdAt) < Date.parse(e.observedAt)) fail2(p + ".createdAt", "precedes actual evidence");
+  if (d.decisionKind !== "preapproved_candidate_operation") {
+    if ("evidenceKind" in e) fail2(p + ".decisionKind", "mature decisions cannot borrow finite lifecycle evidence");
+    if (d.algorithmRevision === "finite_meta_candidates_v1") fail2(p + ".algorithmRevision", "mature decisions cannot use the finite algorithm");
+    return;
+  }
+  if (!("evidenceKind" in e)) fail2(p + ".decisionKind", "finite actions require finite lifecycle evidence");
+  const finite = e, policy = finite.resolvedPolicy;
+  if (Date.parse(d.createdAt) - Date.parse(finite.observedAt) > policy.measurementGuard.maxEvidenceAgeSeconds * 1e3 || Date.parse(d.expiresAt) > Date.parse(policy.expiresAt)) fail2(p + ".expiresAt", "outside current policy/evidence freshness");
+  for (const a of d.candidateActions) {
+    const c = finite.candidates.find((c2) => c2.channelId === a.channelId) ?? fail2(p + ".candidateActions", "unknown original candidate");
+    if (!policy.allowedActions.includes(a.action) || c.graphDigest !== a.graphDigest || c.nativeStateEvidenceRef === null || canonical(c.nativeStateEvidenceRef) !== canonical(a.nativeStateEvidenceRef)) fail2(p + ".candidateActions", "outside original candidate action/state evidence");
+    if (c.lifecycle === "unknown") fail2(p + ".candidateActions", "unknown state requires reconciliation");
+    if (a.action === "pause_candidate") {
+      if (c.lifecycle !== "active") fail2(p + ".candidateActions", "pause requires the actual active original candidate");
+      continue;
+    }
+    if (finite.inventoryState !== "complete" || finite.candidates.some((c2) => c2.lifecycle === "unknown") || c.activationsObserved !== 0 || finite.candidates.filter((c2) => c2.lifecycle === "active").length >= policy.maxConcurrentCandidates) fail2(p + ".candidateActions", "unknown inventory, prior activation or concurrency blocks activation");
+    const firstEligible = policy.selection.candidateOrder.find((id) => {
+      const candidate = finite.candidates.find((c2) => c2.channelId === id), window = policy.selection.eligibilitySchedule.find((s) => s.channelId === id);
+      const permittedLifecycle = candidate.lifecycle === "not_materialized" && policy.allowedActions.includes("materialize_and_activate") && candidate.nativeStateEvidenceRef !== null || candidate.lifecycle === "paused" && policy.allowedActions.includes("activate_held") && candidate.commitmentEvidenceRef !== null && candidate.nativeStateEvidenceRef !== null;
+      return permittedLifecycle && candidate.activationsObserved === 0 && Date.parse(d.createdAt) >= Date.parse(window.notBefore) && Date.parse(d.createdAt) < Date.parse(window.notAfter);
+    });
+    if (firstEligible !== c.channelId) fail2(p + ".candidateActions", "must retain the original fixed candidate order");
+    const schedule = policy.selection.eligibilitySchedule.find((s) => s.channelId === c.channelId);
+    if (Date.parse(d.createdAt) < Date.parse(schedule.notBefore) || Date.parse(d.createdAt) >= Date.parse(schedule.notAfter)) fail2(p + ".candidateActions", "outside original selection window");
+    if (a.action === "materialize_and_activate" && (c.lifecycle !== "not_materialized" || c.commitmentEvidenceRef !== null)) fail2(p + ".candidateActions", "new create requires original absence, not a borrowed hold");
+    if (a.action === "activate_held" && (c.lifecycle !== "paused" || !c.commitmentEvidenceRef || c.commitmentEvidenceRef.commitmentOperationId !== a.commitmentOperationId)) fail2(p + ".candidateActions", "held activation requires the exact original commitment reference");
+    if (compareMoney(c.cap, policy.totalExplorationCap) > 0) fail2(p + ".candidateActions", "original full cap exceeds reviewed exploration ceiling");
+    if (finite.trackingState !== "healthy" || c.trackingState !== "healthy" || c.coverageBasisPoints === null || c.coverageBasisPoints < policy.measurementGuard.minimumCoverageBasisPoints) fail2(p + ".candidateActions", "current required tracking coverage unavailable");
+    for (const check of policy.measurementGuard.requiredChecks) {
+      if (check === "dedupe" && c.dedupeCheck !== "pass" || check === "qualification" && c.qualificationCheck !== "pass") fail2(p + ".candidateActions", "required source check unavailable");
+      if (["uncertainty", "assignment", "power"].includes(check)) fail2(p + ".candidateActions", "fixed exploration has no adopted measured/assignment decision policy");
+    }
+  }
+}
+var RESONANCE_OPTIMIZATION_EVIDENCE_JSON_SCHEMA = optimizationEvidence.schema;
+var RESONANCE_OPTIMIZATION_DECISION_JSON_SCHEMA = optimizationDecision.schema;
+var publicDestination = union2(
+  object2({ provider: literal2("google_ads"), id: uuid, tagId: text2(40, /^AW-[0-9]+$/) }),
+  object2({ provider: literal2("meta_ads"), id: uuid, pixelId: text2(40, /^[0-9]+$/) })
+);
+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),
+  resourceRules: list2(object2({ id: uuid, revision, site, resource: interestResource, path, interestKey: text2(100, /^[a-zA-Z0-9._:-]+$/) }), 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;
+}
+function resonanceMeasurementConfigDigestInput(value) {
+  const { expiresAt: _expiresAt, ...semantic } = parseResonanceMeasurementConfig(value);
+  return canonical(semantic);
+}
+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");
+var RESONANCE_CLICK_IDENTIFIERS_JSON_SCHEMA = 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: uuid,
+  navigationId: uuid,
+  occurredAt: instant,
+  kind: choice2("page_view", "content_interest", "experiment_exposure"),
+  sourceMarker: optional2(sourceMarker),
+  resourceRef: nullable2(interestResource),
+  campaignPlanId: nullable2(uuid),
+  experiment: nullable2(exposure),
+  clickIdentifiers: optional2(clickIdentifiers),
+  pagePath: optional2(observedPagePath),
+  metaCookieObservation: optional2(metaCookieObservation),
+  consentReceiptRefs: list2(object2({ purpose, receiptId: uuid, 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;
+}
+var RESONANCE_MEASUREMENT_CONFIG_JSON_SCHEMA = measurementConfig.schema;
+var RESONANCE_MEASUREMENT_OCCURRENCE_JSON_SCHEMA = occurrence.schema;
+var RESONANCE_CONSENT_UPDATE_JSON_SCHEMA = consentUpdate.schema;
+function resonanceOptimizationEvidenceDigestInput(v) {
+  const { evidenceDigest: _digest, ...body } = parseResonanceOptimizationEvidence(v);
+  return canonical(body);
+}
+function resonanceOptimizationDecisionDigestInput(v) {
+  const { requestDigest: _digest, ...body } = parseResonanceOptimizationDecision(v);
+  return canonical(body);
+}
+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: uuid, accepted: literal2(true), replayed: bool, exposureId: nullable2(uuid) });
+var parseResonanceOccurrenceResponse = (v) => occurrenceResult.read(v, "occurrenceResult");
+var RESONANCE_CONSENT_RESPONSE_JSON_SCHEMA = consentResult.schema;
+var RESONANCE_OCCURRENCE_RESPONSE_JSON_SCHEMA = occurrenceResult.schema;
+var resonanceOptimizationPolicyDigestInput = (v) => canonical(parseResonanceOptimizationPolicy(v));
+var subjectRenew = object2({ schemaVersion: literal2(1), ...scope, expectedConsentRevision: integer2(1), configRevision: revision, policyRevision: revision });
+var parseResonanceSubjectRenewCommand = (v) => subjectRenew.read(v, "subjectRenew");
+var RESONANCE_SUBJECT_RENEW_COMMAND_JSON_SCHEMA = subjectRenew.schema;
+var parseResonanceResourceRef = (v) => resource.read(v, "resourceRef");
+var parseResonanceAudienceRuleRef = (v) => audience.read(v, "audienceRuleRef");
+var parseResonanceExperimentRef = (v) => experiment.read(v, "experimentRef");
+var RESONANCE_RESOURCE_REF_JSON_SCHEMA = resource.schema;
+var RESONANCE_AUDIENCE_RULE_REF_JSON_SCHEMA = audience.schema;
+var RESONANCE_EXPERIMENT_REF_JSON_SCHEMA = experiment.schema;
+var audienceDraft = object2({
+  schemaVersion: literal2(1),
+  expectedRevision: optional2(integer2(1)),
+  idempotencyKey: operationKey,
+  definition: object2({ name: text2(160), site, accountBindingId: uuid, resourceRuleId: uuid, excludedResourceRuleIds: list2(uuid, 50), retentionDays: integer2(1, 540), policyRevision: revision, currentConsentPolicyRevision: revision })
+});
+function parseResonanceAudienceDraftSaveCommand(v) {
+  const r = audienceDraft.read(v, "audienceDraftSave");
+  unique(r.definition.excludedResourceRuleIds, "audienceDraftSave.definition.excludedResourceRuleIds");
+  return r;
+}
+var RESONANCE_AUDIENCE_DRAFT_SAVE_COMMAND_JSON_SCHEMA = 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: uuid });
+var parseResonanceExperimentCreateCommand = (v) => managedExperimentCreate.read(v, "experimentCreateCommand");
+var parseResonanceExperimentUpdateCommand = (v) => managedExperimentUpdate.read(v, "experimentUpdateCommand");
+var parseResonanceExperimentLifecycleCommand = (v) => managedExperimentLifecycle.read(v, "experimentLifecycleCommand");
+var parseResonanceExperimentCompleteCommand = (v) => managedExperimentComplete.read(v, "experimentCompleteCommand");
+var parseResonanceExperimentLinkCommand = (v) => managedExperimentLink.read(v, "experimentLinkCommand");
+var RESONANCE_EXPERIMENT_CREATE_COMMAND_JSON_SCHEMA = managedExperimentCreate.schema;
+var RESONANCE_EXPERIMENT_UPDATE_COMMAND_JSON_SCHEMA = managedExperimentUpdate.schema;
+var RESONANCE_EXPERIMENT_LIFECYCLE_COMMAND_JSON_SCHEMA = managedExperimentLifecycle.schema;
+var RESONANCE_EXPERIMENT_COMPLETE_COMMAND_JSON_SCHEMA = managedExperimentComplete.schema;
+var RESONANCE_EXPERIMENT_LINK_COMMAND_JSON_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: uuid, observedRevision: nativePageRevision, observedDigest: digest }), 500, 1)
+}), (v, p) => unique(v.pages.map((page2) => page2.pageId), p + ".pages"));
+var parseResonanceMeasurementConfigurationSaveCommand = (v) => measurementSave.read(v, "measurementConfigurationSave");
+var resonanceMeasurementConfigurationSaveDigestInput = (v) => canonical(parseResonanceMeasurementConfigurationSaveCommand(v));
+var measurementPage = object2({ pageId: uuid, label: friendlyName, path: observedPagePath, pageRevision: nativePageRevision, evidenceDigest: digest, resourceRuleId: uuid, resourceRuleRevision: digest });
+var measurementSavedFields = { configurationRevision: integer2(1), configurationDigest: digest, configuration: measurementConfig, saveOperationId: uuid, 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: uuid, operationId: uuid, 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);
+var parseResonanceMeasurementConfigurationCurrent = (v) => measurementCurrent.read(v, "measurementConfigurationCurrent");
+var parseResonanceMeasurementConfigurationSnapshot = (v) => measurementSnapshot.read(v, "measurementConfigurationSnapshot");
+var parseResonanceMeasurementConfigurationSaveResponse = (v) => measurementSaveResponse.read(v, "measurementConfigurationSaveResponse");
+var measurementProjectionContext = object2({ projectId: uuid, current: measurementCurrent, pages: list2(object2({ pageId: uuid, label: friendlyName, path: observedPagePath, pageRevision: nativePageRevision, evidenceDigest: digest }), 500, 1), expiresAt: instant });
+function projectResonanceMeasurementConfiguration(value, context) {
+  const command2 = parseResonanceMeasurementConfigurationSaveCommand(value), actual = measurementProjectionContext.read(context, "measurementConfigurationProjection");
+  const current = parseResonanceMeasurementConfigurationCurrent(actual.current);
+  if (current.projectId !== actual.projectId || current.site !== command2.site || current.configurationRevision !== command2.expectedConfigurationRevision) fail2("measurementConfigurationProjection.current", "scope or configuration CAS mismatch");
+  unique(actual.pages.map((page2) => page2.pageId), "measurementConfigurationProjection.pages");
+  if (actual.pages.length !== command2.pages.length || actual.pages.some((page2) => !command2.pages.some((selected) => selected.pageId === page2.pageId && selected.observedRevision === page2.pageRevision && selected.observedDigest === page2.evidenceDigest))) fail2("measurementConfigurationProjection.pages", "requires the exact selected current native page evidence");
+  const pages = [...actual.pages].sort((a, b) => a.pageId < b.pageId ? -1 : a.pageId > b.pageId ? 1 : 0).map((page2) => ({ ...page2, resourceRuleId: page2.pageId, resourceRuleRevision: page2.evidenceDigest }));
+  const consentPolicy = { ...command2.consentPolicy, requiredPurposes: [...command2.consentPolicy.requiredPurposes].sort() };
+  const previous = current.kind === "configured" ? current.configuration : null;
+  const next = {
+    schemaVersion: 1,
+    projectId: actual.projectId,
+    site: command2.site,
+    configRevision: previous?.configRevision ?? "1",
+    policyRevision: previous?.policyRevision ?? "1",
+    expiresAt: actual.expiresAt,
+    enabled: command2.enabled,
+    consentPolicy,
+    destinations: previous?.destinations ?? [],
+    resourceRules: pages.map((page2) => ({ id: page2.pageId, revision: page2.evidenceDigest, site: command2.site, resource: { projectId: actual.projectId, site: command2.site, type: "page", id: page2.pageId, revision: page2.pageRevision }, path: page2.path, interestKey: page2.pageId }))
+  };
+  if (previous) {
+    if (canonical({ ...previous.consentPolicy, requiredPurposes: [...previous.consentPolicy.requiredPurposes].sort() }) !== canonical(consentPolicy)) next.policyRevision = (BigInt(previous.policyRevision) + 1n).toString();
+    if (resonanceMeasurementConfigDigestInput(previous) !== resonanceMeasurementConfigDigestInput(next)) next.configRevision = (BigInt(previous.configRevision) + 1n).toString();
+  }
+  const configuration = parseResonanceMeasurementConfig(next);
+  positiveRevision.read(configuration.configRevision, "measurementConfigurationProjection.configRevision");
+  positiveRevision.read(configuration.policyRevision, "measurementConfigurationProjection.policyRevision");
+  return { configuration, pages, configurationDigestInput: resonanceMeasurementConfigDigestInput(configuration) };
+}
+var RESONANCE_MEASUREMENT_CONFIGURATION_SAVE_COMMAND_JSON_SCHEMA = measurementSave.schema;
+var RESONANCE_MEASUREMENT_CONFIGURATION_CURRENT_JSON_SCHEMA = measurementCurrent.schema;
+var RESONANCE_MEASUREMENT_CONFIGURATION_SNAPSHOT_JSON_SCHEMA = measurementSnapshot.schema;
+var RESONANCE_MEASUREMENT_CONFIGURATION_SAVE_RESPONSE_JSON_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: uuid, mode: literal2("existing"), nativeAudienceRef }), object2({ audienceRuleId: uuid, mode: literal2("admitted_setup") })), 50, 1)
+}), (v, p) => unique(v.audiences.map((a) => a.audienceRuleId), p + ".audiences"));
+var parseResonanceMetaConfigurationSaveCommand = (v) => metaSave.read(v, "metaConfigurationSave");
+var resonanceMetaConfigurationSaveDigestInput = (v) => canonical(parseResonanceMetaConfigurationSaveCommand(v));
+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: uuid,
+  campaignId: uuid,
+  channelId: uuid,
+  site,
+  campaignRevision: integer2(1),
+  reviewedDefinitionDigest: digest,
+  configurationRevision: integer2(1),
+  saveOperationId: uuid,
+  channel: meta,
+  account: object2({ id: uuid, externalId: text2(160), name: nullable2(friendlyName) }),
+  datasetName: nullable2(friendlyName),
+  pageName: nullable2(friendlyName),
+  instagramName: nullable2(friendlyName),
+  measurementConfigRef,
+  matchingProfileRef,
+  rules: list2(object2({ id: uuid, 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");
+  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");
+var metaDigestValue = refine2(object2({ ...metaMaterialFields, configurationDigest: optional2(digest) }), checkMetaMaterial);
+function resonanceMetaConfigurationDigestInput(v) {
+  const { configurationDigest: _self, ...material } = metaDigestValue.read(v, "metaConfigurationDigestInput");
+  return canonical(material);
+}
+var metaCurrentMetadata = 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: uuid, campaignId: uuid, channelId: uuid, configurationRevision: literal2(0) }),
+  object2({
+    schemaVersion: literal2(1),
+    kind: literal2("configured"),
+    projectId: uuid,
+    campaignId: uuid,
+    channelId: uuid,
+    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 parseResonanceMetaConfigurationView = (v) => metaView.read(v, "metaConfigurationView");
+var metaSaveResponse = object2({ schemaVersion: literal2(1), snapshot: metaSnapshot, replayed: bool });
+var parseResonanceMetaConfigurationSaveResponse = (v) => metaSaveResponse.read(v, "metaConfigurationSaveResponse");
+function projectResonanceMetaConfiguration(v, currentMetadata) {
+  const snapshot = parseResonanceMetaConfigurationSnapshot(v), metadata = metaCurrentMetadata.read(currentMetadata, "metaConfigurationCurrentMetadata");
+  const readyForReview = metaReviewable(snapshot, metadata);
+  const view2 = parseResonanceMetaConfigurationView({ schemaVersion: 1, kind: "configured", projectId: snapshot.projectId, campaignId: snapshot.campaignId, channelId: snapshot.channelId, configurationRevision: snapshot.configurationRevision, snapshot, ...metadata, readyForReview });
+  return { view: view2, review: readyForReview ? snapshot : null };
+}
+var RESONANCE_META_CONFIGURATION_SAVE_COMMAND_JSON_SCHEMA = metaSave.schema;
+var RESONANCE_META_CONFIGURATION_SNAPSHOT_JSON_SCHEMA = metaSnapshot.schema;
+var RESONANCE_META_CONFIGURATION_VIEW_JSON_SCHEMA = metaView.schema;
+var RESONANCE_META_CONFIGURATION_SAVE_RESPONSE_JSON_SCHEMA = metaSaveResponse.schema;
+var feedSelection = refine2(object2({ channels: list2(object2({ channelId: uuid, 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) });
+var parseResonanceMandateDraftRequest = (v) => mandateDraftRequest.read(v, "mandateDraftRequest");
+var RESONANCE_MANDATE_DRAFT_REQUEST_JSON_SCHEMA = 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) }) });
+function parseResonanceWebsiteVisitFeedReview(v, context) {
+  const r = feedReview.read(v, "websiteVisitFeedReview"), original = r.approval, grant = parseResonanceMandateScope(original.mandate), ref = r.mandateRef, p = "websiteVisitFeedReview";
+  parseResonanceMandateApprovalPayload(original, { project_id: grant.projectId, campaign_id: grant.campaignId });
+  if (ref.campaignId !== grant.campaignId || ref.preparedPlanId !== original.preparedPlanId || ref.reviewDigest !== original.reviewDigest || ref.mandateDigest !== original.mandateDigest) fail2(p + ".mandateRef", "requires the same original accepted mandate");
+  unique(r.configurations.map((c) => c.channelId), p + ".configurations");
+  const feed = grant.websiteVisitFeed;
+  if (!feed) {
+    if (r.configurations.length || r.current.state !== "not_enabled") fail2(p, "absent original feed requires not_enabled and no configurations");
+  } else {
+    if (r.current.state === "not_enabled" || r.configurations.length !== feed.channels.length) fail2(p, "must cover the exact original feed channels");
+    for (const selected of feed.channels) {
+      const config = r.configurations.find((c) => c.channelId === selected.channelId);
+      if (!config || config.projectId !== grant.projectId || config.campaignId !== grant.campaignId || !grant.sites.includes(config.site) || !grant.accountBindingIds.includes(config.account.id) || config.campaignRevision > original.expectedRevision || canonical(config.measurementConfigRef) !== canonical(selected.measurementConfigRef) || canonical(config.matchingProfileRef) !== canonical(selected.matchingProfileRef)) fail2(p + ".configurations", "original configuration/profile/scope mismatch");
+      const saved = config;
+      for (const a of saved.channel.audienceRuleRefs) if (!grant.audienceRuleRefs.some((ref2) => canonical(ref2) === canonical(a))) fail2(p + ".configurations", "original logical audience grant mismatch");
+      const positive = saved.audiences.map((a) => a.resourceRuleRef);
+      for (const rule of selected.resourceRuleRefs) if (!positive.some((ref2) => ref2.id === rule.id && ref2.revision === rule.revision)) fail2(p + ".configurations", "feed requires an original positive resource rule, never excluded-only");
+    }
+    if (r.current.state === "eligible" && (r.current.reasonCodes.length || r.current.expiresAt === null || Date.parse(r.current.expiresAt) <= Date.parse(r.current.checkedAt))) fail2(p + ".current", "eligible review requires an observed nonexpired horizon and no blockers");
+  }
+  if (context) {
+    const actual = object2({ preparedPlan: prepared }).read(context, p + ".context"), plan = parseResonancePreparedPlan(actual.preparedPlan);
+    if (plan.id !== original.preparedPlanId || plan.campaignId !== grant.campaignId || plan.projectId !== grant.projectId || plan.reviewDigest !== original.reviewDigest || plan.expectedRevision !== original.expectedRevision || canonical(plan.definition.budget) !== canonical(grant.budget) || canonical(plan.definition.objective) !== canonical(grant.goal)) fail2(p + ".context", "requires the original prepared plan and mandate material");
+    for (const config of r.configurations) if (config.reviewedDefinitionDigest !== plan.definitionDigest || !plan.definition.channels.some((c) => canonical(c) === canonical(config.channel))) fail2(p + ".context", "original channel or reviewed definition mismatch");
+  }
+  return r;
+}
+var RESONANCE_WEBSITE_VISIT_FEED_REVIEW_JSON_SCHEMA = feedReview.schema;
+
+export { MAX_MONEY_MICROS, MONEY_EXPONENT, MONEY_JSON_SCHEMA, RESONANCE_ACCEPT_COMMAND_JSON_SCHEMA, RESONANCE_ACCOUNT_CAPABILITY_JSON_SCHEMA, RESONANCE_ATTRIBUTION_MODEL, RESONANCE_AUDIENCE_DRAFT_SAVE_COMMAND_JSON_SCHEMA, RESONANCE_AUDIENCE_RULE_REF_JSON_SCHEMA, RESONANCE_BINDING_COMMAND_JSON_SCHEMA, RESONANCE_CAMPAIGN_DEFINITION_JSON_SCHEMA, RESONANCE_CAMPAIGN_DRAFT_JSON_SCHEMA, RESONANCE_CAMPAIGN_VIEW_JSON_SCHEMA, RESONANCE_CLICK_IDENTIFIERS_JSON_SCHEMA, RESONANCE_COMMAND_JSON_SCHEMA, RESONANCE_COMMAND_PREPARE_REQUEST_JSON_SCHEMA, RESONANCE_COMMAND_PREPARE_RESPONSE_JSON_SCHEMA, RESONANCE_CONSENT_JSON_SCHEMA, RESONANCE_CONSENT_RESPONSE_JSON_SCHEMA, RESONANCE_CONSENT_UPDATE_JSON_SCHEMA, RESONANCE_CONVERSION_JSON_SCHEMA, RESONANCE_CPQL_UNCERTAINTY_METHOD, RESONANCE_CURRENCIES, RESONANCE_EXPERIMENT_COMPLETE_COMMAND_JSON_SCHEMA, RESONANCE_EXPERIMENT_CREATE_COMMAND_JSON_SCHEMA, RESONANCE_EXPERIMENT_LIFECYCLE_COMMAND_JSON_SCHEMA, RESONANCE_EXPERIMENT_LINK_COMMAND_JSON_SCHEMA, RESONANCE_EXPERIMENT_REF_JSON_SCHEMA, RESONANCE_EXPERIMENT_UPDATE_COMMAND_JSON_SCHEMA, RESONANCE_GOOGLE_CONFIGURATION_REVIEW_JSON_SCHEMA, RESONANCE_GOOGLE_CONFIGURATION_SAVE_COMMAND_JSON_SCHEMA, RESONANCE_GOOGLE_CONFIGURATION_SAVE_RESPONSE_JSON_SCHEMA, RESONANCE_GOOGLE_CONFIGURATION_SNAPSHOT_JSON_SCHEMA, RESONANCE_GOOGLE_CONFIGURATION_VIEW_JSON_SCHEMA, RESONANCE_GOOGLE_SETUP_SPEC_JSON_SCHEMA, RESONANCE_GOOGLE_SIGNAL_SEMANTICS, RESONANCE_GOOGLE_SOURCE_CATEGORIES, RESONANCE_MANDATE_ACTION_KIND, RESONANCE_MANDATE_APPROVAL_JSON_SCHEMA, RESONANCE_MANDATE_DRAFT_REQUEST_JSON_SCHEMA, RESONANCE_MANDATE_REF_JSON_SCHEMA, RESONANCE_MANDATE_SCOPE_JSON_SCHEMA, RESONANCE_MANDATE_TARGET_JSON_SCHEMA, RESONANCE_MEASUREMENT_CONFIGURATION_CURRENT_JSON_SCHEMA, RESONANCE_MEASUREMENT_CONFIGURATION_SAVE_COMMAND_JSON_SCHEMA, RESONANCE_MEASUREMENT_CONFIGURATION_SAVE_RESPONSE_JSON_SCHEMA, RESONANCE_MEASUREMENT_CONFIGURATION_SNAPSHOT_JSON_SCHEMA, RESONANCE_MEASUREMENT_CONFIG_JSON_SCHEMA, RESONANCE_MEASUREMENT_OCCURRENCE_JSON_SCHEMA, RESONANCE_META_CONFIGURATION_SAVE_COMMAND_JSON_SCHEMA, RESONANCE_META_CONFIGURATION_SAVE_RESPONSE_JSON_SCHEMA, RESONANCE_META_CONFIGURATION_SNAPSHOT_JSON_SCHEMA, RESONANCE_META_CONFIGURATION_VIEW_JSON_SCHEMA, RESONANCE_METRIC_JSON_SCHEMA, RESONANCE_OCCURRENCE_RESPONSE_JSON_SCHEMA, RESONANCE_OPTIMIZATION_DECISION_JSON_SCHEMA, RESONANCE_OPTIMIZATION_EVIDENCE_JSON_SCHEMA, RESONANCE_OPTIMIZATION_POLICY_JSON_SCHEMA, RESONANCE_PREPARED_PLAN_JSON_SCHEMA, RESONANCE_QUALIFICATION_RULE_JSON_SCHEMA, RESONANCE_RECEIPT_JSON_SCHEMA, RESONANCE_RESOLVED_QUALIFICATION_RULE_JSON_SCHEMA, RESONANCE_RESOURCE_REF_JSON_SCHEMA, RESONANCE_SAVE_COMMAND_JSON_SCHEMA, RESONANCE_SCHEMA_VERSION, RESONANCE_SOURCE_MARKER_JSON_SCHEMA, RESONANCE_SOURCE_MARKER_PARAMETER, RESONANCE_SUBJECT_HEADER, RESONANCE_SUBJECT_RENEW_COMMAND_JSON_SCHEMA, RESONANCE_WEBSITE_VISIT_FEED_JSON_SCHEMA, RESONANCE_WEBSITE_VISIT_FEED_REVIEW_JSON_SCHEMA, RESONANCE_WEBSITE_VISIT_PROFILE, ResonanceValidationError, addMoney, compareMoney, cpqlMissingOutcomeBound, formatMoney, googleConversionActionSemantics, googleUploadClicksSetupSemantics, moneyFromProviderUnits, moneyToProviderUnits, parseMoney, parseResonanceAcceptCommand, parseResonanceAccountCapability, parseResonanceAudienceDraftSaveCommand, parseResonanceAudienceRuleRef, parseResonanceBindingCommand, parseResonanceCampaignDefinition, parseResonanceCampaignDraft, parseResonanceCampaignSaveCommand, parseResonanceCampaignView, parseResonanceClickIdentifiers, parseResonanceCommand, parseResonanceCommandPrepareRequest, parseResonanceCommandPrepareResponse, parseResonanceConsentResponse, parseResonanceConsentSnapshot, parseResonanceConsentUpdate, parseResonanceConversionEnvelope, parseResonanceExperimentCompleteCommand, parseResonanceExperimentCreateCommand, parseResonanceExperimentExposure, parseResonanceExperimentLifecycleCommand, parseResonanceExperimentLinkCommand, parseResonanceExperimentRef, parseResonanceExperimentUpdateCommand, parseResonanceGoogleConfigurationReview, parseResonanceGoogleConfigurationSaveCommand, parseResonanceGoogleConfigurationSaveResponse, parseResonanceGoogleConfigurationSnapshot, parseResonanceGoogleConfigurationView, parseResonanceGoogleUploadClicksCustomGoalSpec, parseResonanceMandateApprovalPayload, parseResonanceMandateDraftRequest, parseResonanceMandateRef, parseResonanceMandateScope, parseResonanceMandateTarget, parseResonanceMeasurementConfig, parseResonanceMeasurementConfigurationCurrent, parseResonanceMeasurementConfigurationSaveCommand, parseResonanceMeasurementConfigurationSaveResponse, parseResonanceMeasurementConfigurationSnapshot, parseResonanceMeasurementOccurrence, parseResonanceMetaConfigurationSaveCommand, parseResonanceMetaConfigurationSaveResponse, parseResonanceMetaConfigurationSnapshot, parseResonanceMetaConfigurationView, parseResonanceMetricObservation, parseResonanceOccurrenceResponse, parseResonanceOptimizationDecision, parseResonanceOptimizationEvidence, parseResonanceOptimizationPolicy, parseResonancePrepareCommand, parseResonancePreparedPlan, parseResonanceQualificationRule, parseResonanceReceipt, parseResonanceResolvedQualificationRule, parseResonanceResourceRef, parseResonanceSourceMarker, parseResonanceSubjectRenewCommand, parseResonanceWebsiteVisitFeedReview, projectResonanceGoogleConfiguration, projectResonanceMeasurementConfiguration, projectResonanceMetaConfiguration, resonanceCommandDigestInput, resonanceGoogleConfigurationDigestInput, resonanceGoogleSetupDigestInput, resonanceMandateDigestInput, resonanceMeasurementConfigDigestInput, resonanceMeasurementConfigurationSaveDigestInput, resonanceMetaConfigurationDigestInput, resonanceMetaConfigurationSaveDigestInput, resonanceOptimizationDecisionDigestInput, resonanceOptimizationEvidenceDigestInput, resonanceOptimizationPolicyDigestInput, resonancePlanIssues, resonanceWebsiteVisitEventTime, resonanceWebsiteVisitProfileDigestInput, subtractMoney };