@ainyc/canonry 4.116.0 → 4.117.0

package/assets/assets/{trash-2-ap_Fa4zA.js → trash-2-3J2u0woR.js}

@@ -1 +1 @@
-import{c}from"./index-DxjY63VC.js";const a=[["circle",{cx:"12",cy:"12",r:"10",key:"1mglay"}],["path",{d:"m9 12 2 2 4-4",key:"dzmm74"}]],h=c("circle-check",a);const e=[["circle",{cx:"12",cy:"12",r:"10",key:"1mglay"}],["path",{d:"M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3",key:"1u773s"}],["path",{d:"M12 17h.01",key:"p32p05"}]],n=c("circle-question-mark",e);const o=[["path",{d:"M12 15V3",key:"m9g1x1"}],["path",{d:"M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4",key:"ih7n3h"}],["path",{d:"m7 10 5 5 5-5",key:"brsn70"}]],s=c("download",o);const t=[["path",{d:"M10 11v6",key:"nco0om"}],["path",{d:"M14 11v6",key:"outv1u"}],["path",{d:"M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6",key:"miytrc"}],["path",{d:"M3 6h18",key:"d0wm0j"}],["path",{d:"M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2",key:"e791ji"}]],r=c("trash-2",t);export{h as C,s as D,r as T,n as a};
+import{c}from"./index-LjcWHaNZ.js";const a=[["circle",{cx:"12",cy:"12",r:"10",key:"1mglay"}],["path",{d:"m9 12 2 2 4-4",key:"dzmm74"}]],h=c("circle-check",a);const e=[["circle",{cx:"12",cy:"12",r:"10",key:"1mglay"}],["path",{d:"M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3",key:"1u773s"}],["path",{d:"M12 17h.01",key:"p32p05"}]],n=c("circle-question-mark",e);const o=[["path",{d:"M12 15V3",key:"m9g1x1"}],["path",{d:"M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4",key:"ih7n3h"}],["path",{d:"m7 10 5 5 5-5",key:"brsn70"}]],s=c("download",o);const t=[["path",{d:"M10 11v6",key:"nco0om"}],["path",{d:"M14 11v6",key:"outv1u"}],["path",{d:"M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6",key:"miytrc"}],["path",{d:"M3 6h18",key:"d0wm0j"}],["path",{d:"M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2",key:"e791ji"}]],r=c("trash-2",t);export{h as C,s as D,r as T,n as a};

package/assets/index.html

@@ -12,7 +12,7 @@
     <link rel="icon" type="image/png" sizes="32x32" href="./favicon-32.png" />
     <link rel="apple-touch-icon" href="./apple-touch-icon.png" />
     <title>Canonry</title>
-    <script type="module" crossorigin src="./assets/index-DxjY63VC.js"></script>
+    <script type="module" crossorigin src="./assets/index-LjcWHaNZ.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/vendor-tanstack-Be8JdV5M.js">
     <link rel="modulepreload" crossorigin href="./assets/vendor-radix-CQ77EO2y.js">
     <link rel="modulepreload" crossorigin href="./assets/vendor-recharts-C9EZkgbP.js">

package/dist/{chunk-WEAXJ25Y.js → chunk-FVVKNMZW.js}

@@ -173,6 +173,7 @@ import {
   gscSitemapListResponseDtoSchema,
   gscUrlInspectionDtoSchema,
   hasLocationLabel,
+  hostOf,
   indexingRequestResponseDtoSchema,
   internalError,
   isReadOnlyKey,
@@ -259,8 +260,10 @@ import {
   trafficSyncResponseSchema,
   unsupportedKind,
   validationError,
+  visibilityCompareDtoSchema,
   visibilityStateFromAnswerMentioned,
   visibilityStatsDtoSchema,
+  wilsonInterval,
   windowCutoff,
   winnabilityClassLabel,
   winnabilityClassSchema,
@@ -277,7 +280,7 @@ import {
   wordpressSchemaDeployResultDtoSchema,
   wordpressSchemaStatusResultDtoSchema,
   wordpressStatusDtoSchema
-} from "./chunk-IQPMK36Y.js";
+} from "./chunk-IAJ5TQ4S.js";
 
 // src/intelligence-service.ts
 import { eq as eq38, desc as desc18, asc as asc6, and as and30, ne as ne5, or as or6, inArray as inArray14, gte as gte7, lte as lte4 } from "drizzle-orm";
@@ -5647,8 +5650,8 @@ var METRIC_LABELS = {
   WEBSITE_CLICKS: "Website clicks",
   CALL_CLICKS: "Call clicks"
 };
-function metricLabel(metric) {
-  return METRIC_LABELS[metric] ?? metric;
+function metricLabel(metric2) {
+  return METRIC_LABELS[metric2] ?? metric2;
 }
 function formatAmenityList(amenities) {
   if (amenities.length === 1) return amenities[0];
@@ -5742,12 +5745,12 @@ function analyzeGbp(signals) {
 }
 function pickWorstMetricDrop(loc) {
   let worst = null;
-  for (const metric of GBP_HEADLINE_METRICS) {
-    const delta = loc.metricDeltaPct[metric];
-    const prior = loc.metricPrior7d[metric] ?? 0;
+  for (const metric2 of GBP_HEADLINE_METRICS) {
+    const delta = loc.metricDeltaPct[metric2];
+    const prior = loc.metricPrior7d[metric2] ?? 0;
     if (delta == null || delta > -GBP_METRIC_DROP_PCT || prior < GBP_METRIC_MIN_BASELINE) continue;
     if (!worst || delta < worst.deltaPct) {
-      worst = { metric, deltaPct: delta, recent: loc.metricRecent7d[metric] ?? 0, prior };
+      worst = { metric: metric2, deltaPct: delta, recent: loc.metricRecent7d[metric2] ?? 0, prior };
     }
   }
   return worst;
@@ -8541,7 +8544,7 @@ function computeBuckets(snapshots, projectRuns, bucketDays, queryCreatedAt, ment
         });
         if (eligible.length > 0) usable = eligible;
       }
-      const metric = computeProviderMetric(usable);
+      const metric2 = computeProviderMetric(usable);
       const queryCount = new Set(usable.map((s) => s.queryId)).size;
       const byProvider = {};
       for (const provider of new Set(usable.map((s) => s.provider))) {
@@ -8550,12 +8553,12 @@ function computeBuckets(snapshots, projectRuns, bucketDays, queryCreatedAt, ment
       buckets.push({
         startDate: startISO,
         endDate: endISO,
-        citationRate: metric.citationRate,
-        cited: metric.cited,
-        total: metric.total,
+        citationRate: metric2.citationRate,
+        cited: metric2.cited,
+        total: metric2.total,
         queryCount,
-        mentionRate: metric.mentionRate,
-        mentionedCount: metric.mentionedCount,
+        mentionRate: metric2.mentionRate,
+        mentionedCount: metric2.mentionedCount,
         mentionShare: computeMentionShareBucketMetric(usable, mentionShareCompetitors),
         byProvider
       });
@@ -13631,6 +13634,253 @@ function normalizeDomain2(domain) {
 
 // ../api-routes/src/visibility-stats.ts
 import { and as and14, desc as desc8, eq as eq17, inArray as inArray8 } from "drizzle-orm";
+
+// ../api-routes/src/visibility-compare.ts
+var VISIBILITY_COMPARE_MIN_RUNS = 5;
+function basketPairKey(queryId, provider) {
+  return JSON.stringify([queryId, provider]);
+}
+function citedHostMatches(citedHost, competitorHost) {
+  return citedHost === competitorHost || citedHost.endsWith(`.${competitorHost}`);
+}
+function restrict(snapshots, attribution, pairs) {
+  const out = [];
+  for (const snap of snapshots) {
+    const resolved = resolveCurrentQuery(attribution, snap);
+    if (!resolved) continue;
+    if (!pairs.has(basketPairKey(resolved.id, snap.provider))) continue;
+    out.push({ ...snap, queryId: resolved.id });
+  }
+  return out;
+}
+function observed(snapshots, attribution) {
+  const queryIds = /* @__PURE__ */ new Set();
+  const providers = /* @__PURE__ */ new Set();
+  for (const snap of snapshots) {
+    const resolved = resolveCurrentQuery(attribution, snap);
+    if (!resolved) continue;
+    queryIds.add(resolved.id);
+    providers.add(snap.provider);
+  }
+  return { queryIds, providers };
+}
+function observedPairs(snapshots, attribution, queryIds) {
+  const pairs = /* @__PURE__ */ new Map();
+  for (const snap of snapshots) {
+    const resolved = resolveCurrentQuery(attribution, snap);
+    if (!resolved || !queryIds.has(resolved.id)) continue;
+    const pair = { queryId: resolved.id, provider: snap.provider };
+    pairs.set(basketPairKey(pair.queryId, pair.provider), pair);
+  }
+  return pairs;
+}
+function period(numerator, denominator) {
+  const ci = wilsonInterval(numerator, denominator);
+  return {
+    point: denominator > 0 ? Math.round(numerator / denominator * 1e4) / 1e4 : null,
+    ciLow: ci ? ci.low : null,
+    ciHigh: ci ? ci.high : null,
+    numerator,
+    denominator
+  };
+}
+function ciOverlap(a, b) {
+  if (a.ciLow === null || a.ciHigh === null || b.ciLow === null || b.ciHigh === null) return true;
+  return a.ciLow <= b.ciHigh && b.ciLow <= a.ciHigh;
+}
+function metric(key, label, driftRobust, from, to, continuityBlock) {
+  const verdict = continuityBlock ?? (from.denominator === 0 || to.denominator === 0 ? "insufficient-data" : ciOverlap(from, to) ? "within-noise" : "moved");
+  const direction = from.point === null || to.point === null ? null : to.point > from.point ? "up" : to.point < from.point ? "down" : "flat";
+  const rateRatio = from.point === null || from.point === 0 || to.point === null ? null : Math.round(to.point / from.point * 100) / 100;
+  return { key, label, driftRobust, from, to, rateRatio, direction, verdict };
+}
+function countPeriod(snaps, competitors2) {
+  let checked = 0;
+  let mentioned = 0;
+  let cited = 0;
+  let competitorCited = 0;
+  const perProvider = /* @__PURE__ */ new Map();
+  const models = /* @__PURE__ */ new Map();
+  const modelUnknownProviders = /* @__PURE__ */ new Set();
+  const mentionedQueries = /* @__PURE__ */ new Set();
+  const competitorHosts = competitors2.map((c) => hostOf(c.domain)).filter((h) => h !== null && h.length > 0);
+  for (const snap of snaps) {
+    const isMentioned = snap.answerMentioned === true;
+    if (snap.answerMentioned === true || snap.answerMentioned === false) checked += 1;
+    if (isMentioned) {
+      mentioned += 1;
+      mentionedQueries.add(snap.queryId);
+    }
+    const isCited = snap.citationState === CitationStates.cited;
+    if (isCited) cited += 1;
+    const pp = perProvider.get(snap.provider) ?? { checked: 0, mentioned: 0, cited: 0 };
+    if (snap.answerMentioned === true || snap.answerMentioned === false) pp.checked += 1;
+    if (isMentioned) pp.mentioned += 1;
+    if (isCited) pp.cited += 1;
+    perProvider.set(snap.provider, pp);
+    if (snap.model) {
+      const set = models.get(snap.provider) ?? /* @__PURE__ */ new Set();
+      set.add(snap.model);
+      models.set(snap.provider, set);
+    } else {
+      modelUnknownProviders.add(snap.provider);
+    }
+    if (competitorHosts.length > 0 && snap.citedDomains.length > 0) {
+      const citedHosts = snap.citedDomains.map((d) => hostOf(d)).filter((h) => h !== null && h.length > 0);
+      for (const compHost of competitorHosts) {
+        if (citedHosts.some((ch) => citedHostMatches(ch, compHost))) competitorCited += 1;
+      }
+    }
+  }
+  const mentionShare = buildMentionShare(
+    snaps.map((s) => ({ projectMentioned: s.answerMentioned === true, answerText: s.answerText })),
+    { competitors: competitors2 }
+  );
+  return {
+    checked,
+    mentioned,
+    total: snaps.length,
+    cited,
+    projectCited: cited,
+    competitorCited,
+    queriesMentioned: mentionedQueries.size,
+    perProvider,
+    models,
+    modelUnknownProviders,
+    mentionShare,
+    competitors: mentionShare.breakdown.perCompetitor.map((c) => ({ domain: c.domain, mentions: c.mentionSnapshots }))
+  };
+}
+function computeVisibilityCompare(input) {
+  const attribution = buildQueryAttribution(input.queries);
+  const fromObs = observed(input.from.snapshots, attribution);
+  const toObs = observed(input.to.snapshots, attribution);
+  const queriesObservedBoth = new Set([...fromObs.queryIds].filter((q) => toObs.queryIds.has(q)));
+  const fromPairs = observedPairs(input.from.snapshots, attribution, queriesObservedBoth);
+  const toPairs = observedPairs(input.to.snapshots, attribution, queriesObservedBoth);
+  const pairsBoth = new Map([...fromPairs].filter(([key]) => toPairs.has(key)));
+  const candidateProviders = new Set([...pairsBoth.values()].map((pair) => pair.provider));
+  const fromCandidateSnaps = restrict(input.from.snapshots, attribution, pairsBoth);
+  const toCandidateSnaps = restrict(input.to.snapshots, attribution, pairsBoth);
+  const fromCandidateCounts = countPeriod(fromCandidateSnaps, input.competitors);
+  const toCandidateCounts = countPeriod(toCandidateSnaps, input.competitors);
+  const continuityProviders = [...candidateProviders].sort((a, b) => a.localeCompare(b)).map((provider) => {
+    const fromModels = [...fromCandidateCounts.models.get(provider) ?? /* @__PURE__ */ new Set()].sort((a, b) => a.localeCompare(b));
+    const toModels = [...toCandidateCounts.models.get(provider) ?? /* @__PURE__ */ new Set()].sort((a, b) => a.localeCompare(b));
+    const fromModelUnknown = fromCandidateCounts.modelUnknownProviders.has(provider) || fromModels.length === 0;
+    const toModelUnknown = toCandidateCounts.modelUnknownProviders.has(provider) || toModels.length === 0;
+    const status = fromModelUnknown || toModelUnknown ? "model-unknown" : fromModels.length === 1 && toModels.length === 1 && fromModels[0] === toModels[0] ? "included" : "model-discontinuous";
+    return { provider, status, fromModels, toModels };
+  });
+  const providersBoth = new Set(
+    continuityProviders.filter((provider) => provider.status === "included").map((provider) => provider.provider)
+  );
+  const continuityStatus = candidateProviders.size === 0 ? "insufficient-data" : providersBoth.size > 0 ? "comparable" : continuityProviders.every((provider) => provider.status === "model-unknown") ? "model-unknown" : "model-discontinuous";
+  const continuityBlock = continuityStatus === "model-discontinuous" || continuityStatus === "model-unknown" ? continuityStatus : null;
+  const comparedPairs = new Map([...pairsBoth].filter(([, pair]) => providersBoth.has(pair.provider)));
+  const queriesBoth = new Set([...comparedPairs.values()].map((pair) => pair.queryId));
+  const excludedProviders = [.../* @__PURE__ */ new Set([...fromObs.providers, ...toObs.providers])].filter((p) => !providersBoth.has(p)).sort((a, b) => a.localeCompare(b));
+  const fromSnaps = restrict(input.from.snapshots, attribution, comparedPairs);
+  const toSnaps = restrict(input.to.snapshots, attribution, comparedPairs);
+  const fromCounts = countPeriod(fromSnaps, input.competitors);
+  const toCounts = countPeriod(toSnaps, input.competitors);
+  const shareCounts = (c) => ({
+    proj: c.mentionShare.breakdown.projectMentionSnapshots,
+    comp: c.mentionShare.breakdown.competitorMentionSnapshots
+  });
+  const fromShare = shareCounts(fromCounts);
+  const toShare = shareCounts(toCounts);
+  const metrics = [
+    metric(
+      "mention-share-of-voice",
+      "Named share of voice",
+      true,
+      period(fromShare.proj, fromShare.proj + fromShare.comp),
+      period(toShare.proj, toShare.proj + toShare.comp),
+      continuityBlock
+    ),
+    // Share of voice is undefined without a competitive frame: with zero
+    // configured competitors the denominator degenerates to the project's own
+    // count and the metric would fabricate a 100%. buildMentionShare already
+    // refuses that on the mention side ("reporting 100% would mislead");
+    // degrade the cited side identically to a 0/0 period -> insufficient-data.
+    metric(
+      "cited-share-of-voice",
+      "Cited share of voice",
+      true,
+      input.competitors.length > 0 ? period(fromCounts.projectCited, fromCounts.projectCited + fromCounts.competitorCited) : period(0, 0),
+      input.competitors.length > 0 ? period(toCounts.projectCited, toCounts.projectCited + toCounts.competitorCited) : period(0, 0),
+      continuityBlock
+    ),
+    metric(
+      "mention-rate",
+      "Named rate",
+      false,
+      period(fromCounts.mentioned, fromCounts.checked),
+      period(toCounts.mentioned, toCounts.checked),
+      continuityBlock
+    ),
+    metric(
+      "cited-rate",
+      "Cited rate",
+      false,
+      period(fromCounts.cited, fromCounts.total),
+      period(toCounts.cited, toCounts.total),
+      continuityBlock
+    )
+  ];
+  const modelChanges = [...candidateProviders].sort((a, b) => a.localeCompare(b)).map((provider) => {
+    const fromModels = [...fromCandidateCounts.models.get(provider) ?? /* @__PURE__ */ new Set()].sort((a, b) => a.localeCompare(b));
+    const toModels = [...toCandidateCounts.models.get(provider) ?? /* @__PURE__ */ new Set()].sort((a, b) => a.localeCompare(b));
+    return { provider, fromModels, toModels };
+  }).filter(
+    (c) => c.fromModels.length > 0 && c.toModels.length > 0 && JSON.stringify(c.fromModels) !== JSON.stringify(c.toModels)
+  );
+  const byProvider = [...providersBoth].sort((a, b) => a.localeCompare(b)).map((provider) => ({
+    provider,
+    from: fromCounts.perProvider.get(provider) ?? { checked: 0, mentioned: 0, cited: 0 },
+    to: toCounts.perProvider.get(provider) ?? { checked: 0, mentioned: 0, cited: 0 }
+  }));
+  return {
+    project: input.project,
+    from: {
+      month: input.from.month,
+      since: input.from.since,
+      until: input.from.until,
+      runCount: input.from.runCount,
+      lowRunCount: input.from.runCount < VISIBILITY_COMPARE_MIN_RUNS
+    },
+    to: {
+      month: input.to.month,
+      since: input.to.since,
+      until: input.to.until,
+      runCount: input.to.runCount,
+      lowRunCount: input.to.runCount < VISIBILITY_COMPARE_MIN_RUNS
+    },
+    basket: {
+      queryCount: queriesBoth.size,
+      excludedFromOnly: [...fromObs.queryIds].filter((q) => !queriesBoth.has(q)).length,
+      excludedToOnly: [...toObs.queryIds].filter((q) => !queriesBoth.has(q)).length,
+      providers: [...providersBoth].sort((a, b) => a.localeCompare(b)),
+      excludedProviders
+    },
+    metrics,
+    queriesMentioned: {
+      from: { count: fromCounts.queriesMentioned, of: queriesBoth.size },
+      to: { count: toCounts.queriesMentioned, of: queriesBoth.size }
+    },
+    byProvider,
+    modelChanges,
+    continuity: {
+      status: continuityStatus,
+      comparedProviders: [...providersBoth].sort((a, b) => a.localeCompare(b)),
+      providers: continuityProviders
+    },
+    competitors: { from: fromCounts.competitors, to: toCounts.competitors }
+  };
+}
+
+// ../api-routes/src/visibility-stats.ts
 function round42(value) {
   return Math.round(value * 1e4) / 1e4;
 }
@@ -13849,6 +14099,62 @@ async function visibilityStatsRoutes(app) {
     };
     return reply.send(response);
   });
+  app.get("/projects/:name/visibility-compare", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const { from: fromRaw, to: toRaw } = request.query;
+    if (fromRaw === void 0 || fromRaw === "") throw validationError('"from" (YYYY-MM) is required');
+    if (toRaw === void 0 || toRaw === "") throw validationError('"to" (YYYY-MM) is required');
+    let fromBounds;
+    let toBounds;
+    try {
+      fromBounds = calendarMonthBounds(fromRaw);
+    } catch (err) {
+      throw validationError(err instanceof RangeError ? `"from": ${err.message}` : '"from" must be in YYYY-MM format');
+    }
+    try {
+      toBounds = calendarMonthBounds(toRaw);
+    } catch (err) {
+      throw validationError(err instanceof RangeError ? `"to": ${err.message}` : '"to" must be in YYYY-MM format');
+    }
+    if (Date.parse(fromBounds.since) >= Date.parse(toBounds.since)) {
+      throw validationError('"from" must be a month strictly before "to"');
+    }
+    const projectQueries = app.db.select({ id: queries.id, query: queries.query }).from(queries).where(eq17(queries.projectId, project.id)).all();
+    const competitorRows = app.db.select({ domain: competitors.domain }).from(competitors).where(eq17(competitors.projectId, project.id)).all();
+    const competitorInputs = competitorRows.map((c) => ({
+      domain: c.domain,
+      brandTokens: [brandLabelFromDomain(c.domain)].filter((t) => t.length >= 3)
+    }));
+    const loadMonth = (bounds) => {
+      const sinceMs = Date.parse(bounds.since);
+      const untilMs = Date.parse(bounds.until);
+      const monthRuns = app.db.select({ id: runs.id, createdAt: runs.createdAt, status: runs.status }).from(runs).where(and14(eq17(runs.projectId, project.id), eq17(runs.kind, RunKinds["answer-visibility"]), notProbeRun())).all().filter(
+        (r) => (r.status === RunStatuses.completed || r.status === RunStatuses.partial) && Date.parse(r.createdAt) >= sinceMs && Date.parse(r.createdAt) <= untilMs
+      );
+      const runIds = monthRuns.map((r) => r.id);
+      const snapshots = runIds.length > 0 && projectQueries.length > 0 ? app.db.select({
+        queryId: querySnapshots.queryId,
+        queryText: querySnapshots.queryText,
+        provider: querySnapshots.provider,
+        model: querySnapshots.model,
+        citationState: querySnapshots.citationState,
+        answerMentioned: querySnapshots.answerMentioned,
+        answerText: querySnapshots.answerText,
+        citedDomains: querySnapshots.citedDomains
+      }).from(querySnapshots).where(inArray8(querySnapshots.runId, runIds)).all() : [];
+      return { runCount: monthRuns.length, snapshots };
+    };
+    const fromMonth = loadMonth(fromBounds);
+    const toMonth = loadMonth(toBounds);
+    const dto = computeVisibilityCompare({
+      project: project.name,
+      queries: projectQueries,
+      competitors: competitorInputs,
+      from: { month: fromRaw, since: fromBounds.since, until: fromBounds.until, runCount: fromMonth.runCount, snapshots: fromMonth.snapshots },
+      to: { month: toRaw, since: toBounds.since, until: toBounds.until, runCount: toMonth.runCount, snapshots: toMonth.snapshots }
+    });
+    return reply.send(dto);
+  });
 }
 
 // ../api-routes/src/composites.ts
@@ -14654,6 +14960,7 @@ var SCHEMA_TABLE = {
   TrafficSourceListResponse: trafficSourceListResponseSchema,
   TrafficStatusResponse: trafficStatusResponseSchema,
   TrafficSyncResponse: trafficSyncResponseSchema,
+  VisibilityCompareDto: visibilityCompareDtoSchema,
   VisibilityStatsDto: visibilityStatsDtoSchema,
   WordpressAuditPageDto: wordpressAuditPageDtoSchema,
   WordpressBulkMetaResultDto: wordpressBulkMetaResultDtoSchema,
@@ -14930,6 +15237,20 @@ var monthQueryParameter = {
   description: `Aggregate a single calendar month (YYYY-MM), expanded to that month's inclusive UTC bounds. Mutually exclusive with "since"/"until"/"lastRuns".`,
   schema: stringSchema
 };
+var compareFromQueryParameter = {
+  name: "from",
+  in: "query",
+  required: true,
+  description: 'Earlier calendar month (YYYY-MM) \u2014 the baseline period. Must be strictly before "to".',
+  schema: stringSchema
+};
+var compareToQueryParameter = {
+  name: "to",
+  in: "query",
+  required: true,
+  description: 'Later calendar month (YYYY-MM) \u2014 the reporting period compared against "from".',
+  schema: stringSchema
+};
 var shareOfVoiceQueryParameter = {
   name: "shareOfVoice",
   in: "query",
@@ -15705,6 +16026,19 @@ var routeCatalog = [
       404: errorResponse("Project not found.")
     }
   },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/visibility-compare",
+    summary: "Compare AEO visibility month over month",
+    description: "Statistically honest month-over-month AEO comparison in one call. PRIMARY metric is share of voice (brand vs competitor mentions in the same answers), which is less exposed to broad model-wide naming propensity than an absolute rate but never bypasses model continuity. Rates are pooled per-snapshot over each month (invariant to sweep count), restricted to query/provider pairs present in BOTH months, and then restricted again to providers with exactly one known, identical configured model id in both months. `continuity` reports every provider and its model evidence; changed, mixed mid-month, or legacy-unknown models are excluded. When no provider remains, metrics return a continuity-blocked verdict rather than a directional call. `from` must be a month strictly before `to`. A silent upstream version bump under an unchanged configured id remains undetectable.",
+    tags: ["analytics"],
+    parameters: [nameParameter, compareFromQueryParameter, compareToQueryParameter],
+    responses: {
+      200: jsonResponse("Month-over-month visibility comparison returned.", "VisibilityCompareDto"),
+      400: errorResponse("Invalid or missing from/to months."),
+      404: errorResponse("Project not found.")
+    }
+  },
   {
     method: "get",
     path: "/api/v1/projects/{name}/snapshots/diff",
@@ -19516,12 +19850,12 @@ function computeWindowDelta(rows, referenceDate) {
   }
   const deltaPct = {};
   const metrics = /* @__PURE__ */ new Set([...Object.keys(recent7d), ...Object.keys(prior7d)]);
-  for (const metric of metrics) {
-    const recent = recent7d[metric] ?? 0;
-    const prior = prior7d[metric] ?? 0;
-    recent7d[metric] = recent;
-    prior7d[metric] = prior;
-    deltaPct[metric] = prior === 0 ? null : Math.round((recent - prior) / prior * 100);
+  for (const metric2 of metrics) {
+    const recent = recent7d[metric2] ?? 0;
+    const prior = prior7d[metric2] ?? 0;
+    recent7d[metric2] = recent;
+    prior7d[metric2] = prior;
+    deltaPct[metric2] = prior === 0 ? null : Math.round((recent - prior) / prior * 100);
   }
   return { recent7d, prior7d, deltaPct };
 }