@canonry/canonry 5.18.0 → 5.19.1

package/dist/{chunk-Y5IDGH5B.js → chunk-3IAIW5KH.js}

@@ -32,6 +32,7 @@ import {
   AppError,
   BacklinkSources,
   COMPETITOR_LANDSCAPE_MODEL_GROUP_LIMIT,
+  COMPETITOR_LANDSCAPE_OBSERVED_NAME_LIMIT,
   CcReleaseSyncStatuses,
   CheckCategories,
   CheckScopes,
@@ -79,6 +80,10 @@ import {
   MEASUREMENT_PAGE_DEFAULT_LIMIT,
   MEASUREMENT_PAGE_MAX_LIMIT,
   MEASUREMENT_PLAN_V2_SCHEMA_VERSION,
+  MEASUREMENT_PORTFOLIO_ANSWER_SOURCES_LIMIT,
+  MEASUREMENT_PORTFOLIO_DEFAULT_LIMIT,
+  MEASUREMENT_PORTFOLIO_ROW_EVIDENCE_LIMIT,
+  MEASUREMENT_PORTFOLIO_TIE_NOTE,
   MIN_DOMAIN_BRAND_KEY_LENGTH,
   MIN_TREND_POINTS,
   MODEL_ATTRIBUTION_EVENT_LIMIT,
@@ -733,6 +738,7 @@ import {
   snapshotRequestInputSchema,
   snapshotRequestSchema,
   sourceBreakdownDtoSchema,
+  sourceBreakdownQuerySchema,
   splitList,
   sumInfraHits,
   summarizeCheckResults,
@@ -785,7 +791,7 @@ import {
   wordpressSchemaDeployResultDtoSchema,
   wordpressSchemaStatusResultDtoSchema,
   wordpressStatusDtoSchema
-} from "./chunk-77VHT3JD.js";
+} from "./chunk-SOCYTKTF.js";
 
 // src/intelligence-service.ts
 import { eq as eq71, desc as desc32, asc as asc12, and as and60, ne as ne11, or as or18, inArray as inArray27, gte as gte18, lte as lte15, isNull as isNull13, sql as sql28, exists } from "drizzle-orm";
@@ -9155,7 +9161,7 @@ function compileCompetitiveSignalResolver(competitorDomains) {
         ...evidence.citedDomains ?? [],
         ...(evidence.groundingSources ?? []).map((source) => source.uri)
       ];
-      const answerDomains = evidence.answerDomains ?? extractDomainsFromText(evidence.answerText);
+      const answerDomains2 = evidence.answerDomains ?? extractDomainsFromText(evidence.answerText);
       const mentionedBrandKeys = matchedAliasKeys(domainBrandMatcher, evidence.answerText);
       const citedCompetitorDomains = [];
       const mentionedCompetitorDomains = [];
@@ -9163,7 +9169,7 @@ function compileCompetitiveSignalResolver(competitorDomains) {
         if (citationCandidates.some((candidate) => hostMatchesDomain(candidate, identity.domain))) {
           citedCompetitorDomains.push(identity.domain);
         }
-        if (answerDomains.some((candidate) => hostMatchesDomain(candidate, identity.domain)) || identity.domainBrandKey !== null && mentionedBrandKeys.has(identity.domainBrandKey)) {
+        if (answerDomains2.some((candidate) => hostMatchesDomain(candidate, identity.domain)) || identity.domainBrandKey !== null && mentionedBrandKeys.has(identity.domainBrandKey)) {
           mentionedCompetitorDomains.push(identity.domain);
         }
       }
@@ -16052,7 +16058,8 @@ function readCompetitorLandscape(app, projectName, query, selection) {
     throw validationError("Invalid competitor landscape query", { issues: parsed.error.issues });
   }
   const filters = parsed.data;
-  if (selection?.autoAdvanced && activeMeasurementPlan(app.db, project.id)?.plan.schemaVersion === 2) filters.scope = "all-markets";
+  const classSplitByDefault = filters.scope === void 0 && filters.groupKey === void 0 && filters.queryClass !== void 0 && filters.queryClass !== "all";
+  if ((selection?.autoAdvanced || classSplitByDefault) && activeMeasurementPlan(app.db, project.id)?.plan.schemaVersion === 2) filters.scope = "all-markets";
   const window = parseWindow(filters.window);
   const cutoff = windowCutoff(window);
   const candidateRuns = app.db.select().from(runs).where(and10(
@@ -16125,8 +16132,10 @@ function readCompetitorLandscape(app, projectName, query, selection) {
   const pinned = mergePins(advanced?.pendingPins ?? [], advanced?.activePinned ?? [], projectPins);
   const buildHistory = (selectedSnapshots) => {
     const inputs = buildMentionShareInputs({ project, competitorDomains: [], snapshots: selectedSnapshots, queryTextById });
+    const allObservedNames = observedCompetitorNames(selectedSnapshots);
     return {
-      observedNames: observedCompetitorNames(selectedSnapshots),
+      observedNames: allObservedNames.slice(0, COMPETITOR_LANDSCAPE_OBSERVED_NAME_LIMIT),
+      observedNamesTotal: allObservedNames.length,
       ...buildCompetitorLandscapeHistory({
         project: {
           domain: project.canonicalDomain,
@@ -16242,21 +16251,7 @@ function resolveAdvancedScope(app, projectId, kind, groupKey, candidateRuns) {
   if (kind === "group" && (!groupKey || !active.plan.groups.some((group) => group.stableKey === groupKey))) {
     throw validationError(`Unknown Advanced Measurement group "${groupKey ?? ""}".`);
   }
-  const planVersionIds = [...new Set(candidateRuns.map((run) => run.measurementPlanVersionId).filter((id) => typeof id === "string" && id.length > 0))];
-  const historicalVersions = planVersionIds.length === 0 ? [] : app.db.select().from(measurementPlanVersions).where(and10(
-    eq15(measurementPlanVersions.projectId, projectId),
-    inArray4(measurementPlanVersions.id, planVersionIds)
-  )).all();
-  const frozenByVersionId = new Map(historicalVersions.map((version) => [
-    version.id,
-    scopeForFrozenPlan(parseStoredMeasurementPlanAnyVersion(version.canonicalJson), kind, groupKey)
-  ]));
-  const runScopes = /* @__PURE__ */ new Map();
-  for (const run of candidateRuns) {
-    if (!run.measurementPlanVersionId) continue;
-    const frozen = frozenByVersionId.get(run.measurementPlanVersionId);
-    if (frozen) runScopes.set(run.id, frozen);
-  }
+  const runScopes = frozenRunScopes(app.db, projectId, kind, groupKey, candidateRuns);
   const activeScope = scopeForFrozenPlan(active.plan, kind, groupKey);
   if (!activeScope) throw validationError("The active Advanced Measurement plan cannot resolve this market scope.");
   const draft = draftRow(app.db, projectId);
@@ -16274,25 +16269,58 @@ function resolveAdvancedScope(app, projectId, kind, groupKey, candidateRuns) {
     runScopes
   };
 }
+function frozenRunScopes(db, projectId, kind, groupKey, candidateRuns) {
+  const planVersionIds = [...new Set(candidateRuns.map((run) => run.measurementPlanVersionId).filter((id) => typeof id === "string" && id.length > 0))];
+  const historicalVersions = planVersionIds.length === 0 ? [] : db.select().from(measurementPlanVersions).where(and10(
+    eq15(measurementPlanVersions.projectId, projectId),
+    inArray4(measurementPlanVersions.id, planVersionIds)
+  )).all();
+  const frozenByVersionId = new Map(historicalVersions.map((version) => [
+    version.id,
+    scopeForFrozenPlan(parseStoredMeasurementPlanAnyVersion(version.canonicalJson), kind, groupKey)
+  ]));
+  const runScopes = /* @__PURE__ */ new Map();
+  for (const run of candidateRuns) {
+    if (!run.measurementPlanVersionId) continue;
+    const frozen = frozenByVersionId.get(run.measurementPlanVersionId);
+    if (frozen) runScopes.set(run.id, frozen);
+  }
+  return runScopes;
+}
+function planQueryClassesByRun(db, projectId, candidateRuns) {
+  const byRun = /* @__PURE__ */ new Map();
+  for (const [runId, scope] of frozenRunScopes(db, projectId, "all-markets", void 0, candidateRuns)) {
+    byRun.set(runId, scope.queryClassesByExecution);
+  }
+  return byRun;
+}
 function scopeForFrozenPlan(plan, kind, groupKey) {
   if (plan.schemaVersion !== 2) return null;
-  const groups = kind === "group" ? plan.groups.filter((group) => group.stableKey === groupKey) : plan.groups;
-  if (groups.length === 0) return null;
-  const targetKeys = new Set(groups.flatMap((group) => group.targetKeys));
-  const scopedUsageEdges = plan.usageEdges.filter((edge) => targetKeys.has(edge.targetKey));
-  const executionNodeKeys = new Set(scopedUsageEdges.map((edge) => edge.executionNodeKey));
-  const scopedUsages = new Set(scopedUsageEdges.map((edge) => JSON.stringify([
-    edge.executionNodeKey,
-    edge.targetKey,
-    edge.queryId
-  ])));
-  const queryClassesByExecution = /* @__PURE__ */ new Map();
-  for (const assignment of plan.assignments) {
-    if (!scopedUsages.has(JSON.stringify([
+  let groups = plan.groups;
+  let scopedUsageEdges = plan.usageEdges;
+  let scopedAssignments = plan.assignments;
+  if (kind === "group") {
+    groups = plan.groups.filter((group) => group.stableKey === groupKey);
+    if (groups.length === 0) return null;
+    const targetKeys = new Set(groups.flatMap((group) => group.targetKeys));
+    scopedUsageEdges = plan.usageEdges.filter((edge) => targetKeys.has(edge.targetKey));
+    const scopedUsages = new Set(scopedUsageEdges.map((edge) => JSON.stringify([
+      edge.executionNodeKey,
+      edge.targetKey,
+      edge.queryId
+    ])));
+    scopedAssignments = plan.assignments.filter((assignment) => scopedUsages.has(JSON.stringify([
       assignment.executionNodeKey,
       assignment.targetKey,
       assignment.queryId
-    ]))) continue;
+    ])));
+  }
+  const executionNodeKeys = /* @__PURE__ */ new Set([
+    ...scopedUsageEdges.map((edge) => edge.executionNodeKey),
+    ...scopedAssignments.map((assignment) => assignment.executionNodeKey)
+  ]);
+  const queryClassesByExecution = /* @__PURE__ */ new Map();
+  for (const assignment of scopedAssignments) {
     const classes = queryClassesByExecution.get(assignment.executionNodeKey) ?? /* @__PURE__ */ new Set();
     classes.add(assignment.queryClass);
     queryClassesByExecution.set(assignment.executionNodeKey, classes);
@@ -22807,34 +22835,155 @@ function filteredOverviewWithDb(db, active, plan, run, filters, targetKeys) {
     overview: evaluator.evaluate(targetKeys)
   };
 }
-function targetAnswers(plan, target, materialized, filters) {
-  const assignmentsByExecution = new Map(plan.assignments.filter((assignment) => assignment.targetKey === target.stableKey).filter((assignment) => filters.queryClass === "all" || assignment.queryClass === filters.queryClass).map((assignment) => [assignment.executionNodeKey, assignment]));
-  const edgesByExecution = new Map(materialized.input.usageEdges.filter((edge) => edge.type === "target" && edge.targetId === target.stableKey).filter((edge) => assignmentsByExecution.has(edge.executionId)).map((edge) => [edge.executionId, edge]));
-  const ownEdgeIds = new Set([...edgesByExecution.values()].map((edge) => edge.id));
-  const answerBySlot = new Map(materialized.evidence.answers.filter((answer) => ownEdgeIds.has(answer.usageEdgeId)).map((answer) => [answer.expectedSlotId, answer]));
-  const citedSlotIds = new Set(materialized.evidence.evidence.filter((row) => ownEdgeIds.has(row.usageEdgeId) && row.classification === "assigned").map((row) => row.expectedSlotId));
+function pushTo(map, key, value) {
+  const existing = map.get(key);
+  if (existing) existing.push(value);
+  else map.set(key, [value]);
+}
+function innerMap(outer, key) {
+  let inner = outer.get(key);
+  if (!inner) {
+    inner = /* @__PURE__ */ new Map();
+    outer.set(key, inner);
+  }
+  return inner;
+}
+function createTargetAnswerReader(plan, materialized, filters) {
+  const assignmentsByTarget = /* @__PURE__ */ new Map();
+  for (const assignment of plan.assignments) {
+    if (filters.queryClass !== "all" && assignment.queryClass !== filters.queryClass) continue;
+    innerMap(assignmentsByTarget, assignment.targetKey).set(assignment.executionNodeKey, assignment);
+  }
+  const edgesByTarget = /* @__PURE__ */ new Map();
+  for (const edge of materialized.input.usageEdges) {
+    if (edge.type !== "target") continue;
+    innerMap(edgesByTarget, edge.targetId).set(edge.executionId, edge);
+  }
+  const answersByEdge = /* @__PURE__ */ new Map();
+  for (const answer of materialized.evidence.answers) {
+    innerMap(answersByEdge, answer.usageEdgeId).set(answer.expectedSlotId, answer);
+  }
+  const citedSlotsByEdge = /* @__PURE__ */ new Map();
+  for (const row of materialized.evidence.evidence) {
+    if (row.classification !== "assigned") continue;
+    const slots = citedSlotsByEdge.get(row.usageEdgeId);
+    if (slots) slots.add(row.expectedSlotId);
+    else citedSlotsByEdge.set(row.usageEdgeId, /* @__PURE__ */ new Set([row.expectedSlotId]));
+  }
   const incompleteObservationIds = new Set(materialized.evidence.diagnostics.evidenceIncompleteObservationIds);
   const questionsById = new Map(plan.querySnapshots.map((question) => [question.queryId, question.queryText]));
   const provider = filters.provider === void 0 ? void 0 : normalizeText2(filters.provider);
   const location = filters.location === void 0 ? void 0 : normalizeMeasurementLocation(filters.location);
-  const slots = materialized.input.expectedSlots.filter((slot) => assignmentsByExecution.has(slot.executionId) && edgesByExecution.has(slot.executionId) && (provider === void 0 || normalizeText2(slot.provider) === provider) && (location === void 0 || normalizeMeasurementLocation(slot.location) === location));
-  const answers = [];
-  for (const slot of slots) {
-    const observation = materialized.observationsBySlot.get(slot.id);
-    const snapshot = observation === void 0 ? void 0 : materialized.snapshotsById.get(observation.id);
-    if (!snapshot || snapshot.answerText === null) continue;
-    const assignment = assignmentsByExecution.get(slot.executionId);
-    if (!assignment) throw new Error(`measurement assignment provenance is corrupt for execution ${slot.executionId}`);
-    answers.push({
-      slotId: slot.id,
-      provider: slot.provider,
-      question: questionsById.get(assignment.queryId) ?? slot.queryText,
-      snapshot,
-      mentioned: target.mentionNotApplicable ? null : answerBySlot.get(slot.id)?.mentioned ?? null,
-      cited: citedSlotIds.has(slot.id) ? true : incompleteObservationIds.has(snapshot.id) ? null : false
-    });
+  const slotsByExecution = /* @__PURE__ */ new Map();
+  const slotOrder = /* @__PURE__ */ new Map();
+  materialized.input.expectedSlots.forEach((slot, index2) => {
+    if (provider !== void 0 && normalizeText2(slot.provider) !== provider) return;
+    if (location !== void 0 && normalizeMeasurementLocation(slot.location) !== location) return;
+    pushTo(slotsByExecution, slot.executionId, slot);
+    slotOrder.set(slot.id, index2);
+  });
+  return (target) => {
+    const assignments = assignmentsByTarget.get(target.stableKey);
+    const edges = edgesByTarget.get(target.stableKey);
+    const answers = [];
+    const sourceAnswers = [];
+    const queries2 = /* @__PURE__ */ new Set();
+    const providers = /* @__PURE__ */ new Set();
+    let expected = 0;
+    if (!assignments || !edges) return { expected, queries: 0, providers, answers, sourceAnswers };
+    for (const [executionId, assignment] of assignments) {
+      const edge = edges.get(executionId);
+      const slots = slotsByExecution.get(executionId);
+      if (!edge || !slots) continue;
+      queries2.add(assignment.queryId);
+      const answerBySlot = answersByEdge.get(edge.id);
+      const citedSlotIds = citedSlotsByEdge.get(edge.id);
+      for (const slot of slots) {
+        expected++;
+        providers.add(slot.provider);
+        const observation = materialized.observationsBySlot.get(slot.id);
+        const snapshot = observation === void 0 ? void 0 : materialized.snapshotsById.get(observation.id);
+        if (!observation || !snapshot) continue;
+        const sourced = {
+          slotId: slot.id,
+          snapshot,
+          citedUrls: observation.citedUrls ?? observation.historicalCitedUrls ?? []
+        };
+        sourceAnswers.push(sourced);
+        if (snapshot.answerText === null) continue;
+        answers.push({
+          ...sourced,
+          provider: slot.provider,
+          question: questionsById.get(assignment.queryId) ?? slot.queryText,
+          mentioned: target.mentionNotApplicable ? null : answerBySlot?.get(slot.id)?.mentioned ?? null,
+          cited: citedSlotIds?.has(slot.id) ? true : incompleteObservationIds.has(snapshot.id) ? null : false
+        });
+      }
+    }
+    const inRunOrder = (left, right) => slotOrder.get(left.slotId) - slotOrder.get(right.slotId);
+    answers.sort(inRunOrder);
+    sourceAnswers.sort(inRunOrder);
+    return { expected, queries: queries2.size, providers, answers, sourceAnswers };
+  };
+}
+function targetAnswers(plan, target, materialized, filters) {
+  return createTargetAnswerReader(plan, materialized, filters)(target);
+}
+function plannedQueryCount(plan, targetKey, queryClass) {
+  return new Set(plan.assignments.filter((assignment) => assignment.targetKey === targetKey).filter((assignment) => queryClass === "all" || assignment.queryClass === queryClass).map((assignment) => assignment.queryId)).size;
+}
+function propertyLocations(plan) {
+  const groupsByKey = new Map(plan.groups.map((group) => [group.stableKey, group]));
+  const depth = (group) => {
+    let levels = 0;
+    const seen2 = /* @__PURE__ */ new Set([group.stableKey]);
+    let parentKey = group.parentGroupKey;
+    while (parentKey !== void 0 && !seen2.has(parentKey)) {
+      const parent = groupsByKey.get(parentKey);
+      if (!parent) break;
+      seen2.add(parentKey);
+      levels++;
+      parentKey = parent.parentGroupKey;
+    }
+    return levels;
+  };
+  const byLabel = (left, right) => compareText13(left.label, right.label) || compareText13(left.stableKey, right.stableKey);
+  const metros = /* @__PURE__ */ new Map();
+  const submarkets = /* @__PURE__ */ new Map();
+  for (const group of plan.groups) {
+    const level = depth(group);
+    for (const targetKey of new Set(group.targetKeys)) {
+      if (level === 0) pushTo(metros, targetKey, group);
+      else pushTo(submarkets, targetKey, { group, depth: level });
+    }
+  }
+  const metroDto = (group) => ({ groupKey: group.stableKey, label: group.label });
+  return (targetKey) => {
+    const own = [...metros.get(targetKey) ?? []].sort(byLabel);
+    const nested = [...submarkets.get(targetKey) ?? []].sort((left, right) => left.depth - right.depth || byLabel(left.group, right.group));
+    return {
+      metro: own.length === 0 ? null : metroDto(own[0]),
+      ...own.length > 1 ? { otherMetros: own.slice(1).map(metroDto) } : {},
+      submarkets: nested.map((row) => row.group.label)
+    };
+  };
+}
+function answerDomains(answer) {
+  const domains = /* @__PURE__ */ new Set();
+  for (const raw of [...answer.snapshot.citedDomains, ...answer.citedUrls]) {
+    const host = hostOf(raw);
+    if (!host || hostMatchesAnyDomain(host, AI_PROVIDER_INFRA_DOMAINS)) continue;
+    domains.add(host);
+  }
+  return domains;
+}
+function domainRows(answers, limit) {
+  const counts2 = /* @__PURE__ */ new Map();
+  for (const answer of answers) {
+    for (const domain of answerDomains(answer)) counts2.set(domain, (counts2.get(domain) ?? 0) + 1);
   }
-  return { expected: slots.length, answers };
+  const rows = [...counts2].map(([domain, count4]) => ({ domain, answers: count4 })).sort((left, right) => right.answers - left.answers || compareText13(left.domain, right.domain));
+  return { rows: rows.slice(0, limit), total: rows.length };
 }
 function targetAliasKeys(target) {
   return new Set([target.label, ...target.aliases].map(brandKeyFromText).filter(Boolean));
@@ -22844,16 +22993,18 @@ function recommendationRows(target, population) {
   const grouped = /* @__PURE__ */ new Map();
   for (const answer of population.answers) {
     if (answer.mentioned !== false || answer.cited !== false) continue;
+    const seenInAnswer = /* @__PURE__ */ new Set();
     for (const rawName of answer.snapshot.recommendedCompetitors) {
       const name = rawName.normalize("NFKC").trim().replace(/\s+/g, " ");
       const key = brandKeyFromText(name);
       if (!key || aliases.has(key)) continue;
       const existing = grouped.get(key);
       if (existing) {
+        if (compareText13(name, existing.name) < 0) existing.name = name;
+        if (seenInAnswer.has(key)) continue;
         existing.occurrences++;
         existing.providers.add(answer.provider);
         existing.questions.add(answer.question);
-        if (compareText13(name, existing.name) < 0) existing.name = name;
       } else {
         grouped.set(key, {
           name,
@@ -22862,6 +23013,7 @@ function recommendationRows(target, population) {
           questions: /* @__PURE__ */ new Set([answer.question])
         });
       }
+      seenInAnswer.add(key);
     }
   }
   return [...grouped.values()].map((row) => {
@@ -22879,6 +23031,16 @@ function recommendationRows(target, population) {
     };
   }).sort((left, right) => right.occurrences - left.occurrences || compareText13(left.name, right.name));
 }
+function namedInsteadFields(names) {
+  const returned = names.slice(0, MEASUREMENT_PORTFOLIO_ROW_EVIDENCE_LIMIT);
+  return {
+    namedInsteadInAnswerText: returned.map(({ name, occurrences }) => ({ name, answers: occurrences })),
+    namedInsteadInAnswerTextTotal: names.length,
+    recommendedInstead: returned.map(({ name, occurrences }) => ({ name, occurrences })),
+    recommendedInsteadTotal: names.length,
+    recommendedInsteadTruncated: names.length > returned.length
+  };
+}
 function propertyDto2(target) {
   return { targetKey: target.stableKey, label: target.label };
 }
@@ -22925,20 +23087,60 @@ function targetKeysForRun(plan, run, requested, requireEntireScope) {
   }
   return selected;
 }
-function marketRollup(plan, run, evaluator, scopedToOneGroup) {
-  if (scopedToOneGroup) return [];
-  return plan.groups.map((group) => {
-    const targetKeys = targetKeysForRun(plan, run, group.targetKeys, false);
-    const overview = evaluator.evaluate(targetKeys);
-    return {
+function marketRollup(plan, measured, scope, includeNested, limit) {
+  const childCounts = /* @__PURE__ */ new Map();
+  for (const group of plan.groups) {
+    if (group.parentGroupKey !== void 0) childCounts.set(group.parentGroupKey, (childCounts.get(group.parentGroupKey) ?? 0) + 1);
+  }
+  const groupKeys = new Set(plan.groups.map((group) => group.stableKey));
+  const isTopLevel = (group) => group.parentGroupKey === void 0 || !groupKeys.has(group.parentGroupKey);
+  let candidates;
+  if (scope === void 0) {
+    candidates = includeNested ? plan.groups : plan.groups.filter(isTopLevel);
+  } else if (!includeNested) {
+    candidates = plan.groups.filter((group) => group.parentGroupKey === scope.stableKey);
+  } else {
+    const descendants = /* @__PURE__ */ new Set([scope.stableKey]);
+    let grew = true;
+    while (grew) {
+      grew = false;
+      for (const group of plan.groups) {
+        if (group.parentGroupKey !== void 0 && descendants.has(group.parentGroupKey) && !descendants.has(group.stableKey)) {
+          descendants.add(group.stableKey);
+          grew = true;
+        }
+      }
+    }
+    candidates = plan.groups.filter((group) => group.stableKey !== scope.stableKey && descendants.has(group.stableKey));
+  }
+  const markets = candidates.map((group) => {
+    const identity = {
       groupKey: group.stableKey,
       label: group.label,
+      parentGroupKey: isTopLevel(group) ? null : group.parentGroupKey,
+      childMarketCount: childCounts.get(group.stableKey) ?? 0
+    };
+    if (measured === void 0) {
+      return {
+        ...identity,
+        propertyCount: group.targetKeys.length,
+        propertiesMentioned: unavailable3("no_completed_run"),
+        mentionCoverage: unavailable3("no_completed_run"),
+        citationCoverage: unavailable3("no_completed_run")
+      };
+    }
+    const targetKeys = targetKeysForRun(plan, measured.run, group.targetKeys, false);
+    const overview = measured.evaluator.evaluate(targetKeys);
+    return {
+      ...identity,
       propertyCount: targetKeys.length,
       propertiesMentioned: countMetric2(overview.propertiesMentioned),
       mentionCoverage: coverageMetric2(overview.mentionCoverage),
       citationCoverage: coverageMetric2(overview.citationCoverage)
     };
   }).sort(compareWeakestMarket);
+  const returned = includeNested ? markets : markets.slice(0, limit);
+  return { markets: returned, totalMarkets: markets.length, marketsTruncated: returned.length < markets.length };
 }
 function compareWeakestMarket(a, b) {
   const aUnavailable = a.mentionCoverage.state === "unavailable" || a.citationCoverage.state === "unavailable";
@@ -22956,11 +23158,20 @@ function compareWeakestMarket(a, b) {
 function mentionRanking(rows, limit) {
   const eligible = [];
   const excluded = [];
-  for (const { targetKey, label, mentionCoverage, citationCoverage } of rows) {
+  for (const { targetKey, label, mentionCoverage, citationCoverage, metro, otherMetros, submarkets, queries: queries2 } of rows) {
     if (mentionCoverage.state === "unavailable") {
       excluded.push({ targetKey, label, reason: mentionCoverage.reason });
     } else {
-      eligible.push({ targetKey, label, mentionCoverage, citationCoverage });
+      eligible.push({
+        targetKey,
+        label,
+        metro,
+        ...otherMetros === void 0 ? {} : { otherMetros },
+        submarkets,
+        queries: queries2,
+        mentionCoverage,
+        citationCoverage
+      });
     }
   }
   const byLabel = (a, b) => compareText13(a.label, b.label) || compareText13(a.targetKey, b.targetKey);
@@ -22985,65 +23196,74 @@ function portfolioResponse(db, active, plan, query) {
     provider: query.provider,
     location: query.location
   };
+  const limit = query.limit ?? MEASUREMENT_PORTFOLIO_DEFAULT_LIMIT;
+  const includeNestedMarkets = query.includeNestedMarkets ?? false;
+  const locate = propertyLocations(plan);
   if (!run) {
     const rows2 = targets.map((target) => ({
       ...propertyDto2(target),
+      ...locate(target.stableKey),
+      queries: plannedQueryCount(plan, target.stableKey, query.queryClass),
       mentionCoverage: unavailable3("no_completed_run"),
       citationCoverage: unavailable3("no_completed_run"),
       flags: 0,
-      recommendedInstead: [],
-      recommendedInsteadTotal: 0,
-      recommendedInsteadTruncated: false
+      ...namedInsteadFields([]),
+      citedDomains: [],
+      citedDomainsTotal: 0
     })).sort(compareWeakest);
-    const limit2 = query.limit ?? DEFAULT_LIMIT3;
     return measurementPortfolioSummaryResponseSchema.parse({
       portfolio: { groupKey: group?.stableKey ?? null, label: group?.label ?? null, measurementScope: null },
       measurement,
       queryClass: query.queryClass,
+      engines: [],
       metrics: {
         propertiesMentioned: unavailable3("no_completed_run"),
         mentionCoverage: unavailable3("no_completed_run"),
         citationCoverage: unavailable3("no_completed_run")
       },
-      weakestProperties: rows2.slice(0, limit2),
-      mentionRanking: mentionRanking(rows2, limit2),
+      weakestProperties: rows2.slice(0, limit),
+      tiedAtWeakest: null,
+      weakestAnswerSources: null,
+      mentionRanking: mentionRanking(rows2, limit),
       // Sorted through the same comparator as the measured branch. Plan order
       // is `stableKey`, so emitting it raw put markets in an order the schema
       // documents as worst-first and that changes the moment a run lands.
-      markets: group !== void 0 ? [] : plan.groups.map((g) => ({
-        groupKey: g.stableKey,
-        label: g.label,
-        propertyCount: g.targetKeys.length,
-        propertiesMentioned: unavailable3("no_completed_run"),
-        mentionCoverage: unavailable3("no_completed_run"),
-        citationCoverage: unavailable3("no_completed_run")
-      })).sort(compareWeakestMarket),
+      ...marketRollup(plan, void 0, group, includeNestedMarkets, limit),
       totalProperties: rows2.length,
-      truncated: rows2.length > limit2
+      truncated: rows2.length > limit
     });
   }
   const { materialized, overview, evaluator } = filteredOverviewWithDb(db, active, plan, run, filters, targetKeys);
+  const readTarget2 = createTargetAnswerReader(plan, materialized, filters);
+  const populations = new Map(targets.map((target) => [target.stableKey, readTarget2(target)]));
   const measured = new Map(overview.properties.map((row) => [row.targetId, row]));
   const ranked = targets.map((target) => {
     const row = measured.get(target.stableKey);
+    const population = populations.get(target.stableKey);
     return {
       target,
+      population,
       ...propertyDto2(target),
+      ...locate(target.stableKey),
+      queries: population.queries,
       mentionCoverage: row ? coverageMetric2(row.mentionCoverage) : unavailable3("no_population"),
       citationCoverage: row ? coverageMetric2(row.citationCoverage) : unavailable3("no_population"),
       flags: row?.flags ?? 0
     };
   }).sort(compareWeakest);
-  const limit = query.limit ?? DEFAULT_LIMIT3;
-  const rows = ranked.slice(0, limit).map(({ target, ...row }) => {
-    const recommendations = recommendationRows(target, targetAnswers(plan, target, materialized, filters));
+  const displayed = ranked.slice(0, limit);
+  const rows = displayed.map(({ target, population, ...row }) => {
+    const domains = domainRows(population.sourceAnswers, MEASUREMENT_PORTFOLIO_ROW_EVIDENCE_LIMIT);
     return {
       ...row,
-      recommendedInstead: recommendations.slice(0, 5).map(({ name, occurrences }) => ({ name, occurrences })),
-      recommendedInsteadTotal: recommendations.length,
-      recommendedInsteadTruncated: recommendations.length > 5
+      ...namedInsteadFields(recommendationRows(target, population)),
+      citedDomains: domains.rows,
+      citedDomainsTotal: domains.total
     };
   });
+  const tie = weakestTie(ranked);
+  const engines = /* @__PURE__ */ new Set();
+  for (const population of populations.values()) for (const provider of population.providers) engines.add(provider);
   return measurementPortfolioSummaryResponseSchema.parse({
     portfolio: {
       groupKey: group?.stableKey ?? null,
@@ -23052,18 +23272,46 @@ function portfolioResponse(db, active, plan, query) {
     },
     measurement,
     queryClass: query.queryClass,
+    engines: [...engines].sort(compareText13),
     metrics: {
       propertiesMentioned: countMetric2(overview.propertiesMentioned),
       mentionCoverage: coverageMetric2(overview.mentionCoverage),
       citationCoverage: coverageMetric2(overview.citationCoverage)
     },
-    weakestProperties: rows.slice(0, limit),
+    weakestProperties: rows,
+    tiedAtWeakest: tie.summary,
+    weakestAnswerSources: weakestAnswerSources([...displayed, ...tie.rows]),
     mentionRanking: mentionRanking(ranked, limit),
-    markets: marketRollup(plan, run, evaluator, group !== void 0),
+    ...marketRollup(plan, { run, evaluator }, group, includeNestedMarkets, limit),
     totalProperties: ranked.length,
     truncated: ranked.length > limit
   });
 }
+function weakestTie(ranked) {
+  if (ranked.length === 0) return { summary: null, rows: [] };
+  const first = ranked[0];
+  if (first.mentionCoverage.state !== "available" || first.citationCoverage.state !== "available") {
+    return { summary: null, rows: [] };
+  }
+  const mentionRate3 = first.mentionCoverage.value;
+  const citationRate = first.citationCoverage.value;
+  const rows = ranked.filter((row) => row.mentionCoverage.state === "available" && row.mentionCoverage.value === mentionRate3 && row.citationCoverage.state === "available" && row.citationCoverage.value === citationRate);
+  if (rows.length < 2) return { summary: null, rows: [] };
+  return {
+    summary: { count: rows.length, mentionRate: mentionRate3, citationRate, note: MEASUREMENT_PORTFOLIO_TIE_NOTE },
+    rows
+  };
+}
+function weakestAnswerSources(rows) {
+  const properties = /* @__PURE__ */ new Set();
+  const answers = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    properties.add(row.targetKey);
+    for (const answer of row.population.sourceAnswers) answers.set(answer.snapshot.id, answer);
+  }
+  const domains = domainRows([...answers.values()], MEASUREMENT_PORTFOLIO_ANSWER_SOURCES_LIMIT);
+  return { properties: properties.size, answers: answers.size, domains: domains.rows, domainTotal: domains.total };
+}
 function propertyCompetitorsResponse(db, active, plan, query) {
   const target = requireTarget3(plan, query.targetKey);
   const run = selectMeasurementQuestionRun(db, active.version.projectId, active, query.runId);
@@ -23398,7 +23646,9 @@ async function measurementPortfolioReadRoutes(app) {
     "/projects/:name/measurement-portfolio-summary",
     async (request) => {
       const project = resolveProject(app.db, request.params.name);
-      const query = parseLimitQuery(request.query, measurementPortfolioSummaryQuerySchema, "Invalid measurement portfolio summary query");
+      const nested = request.query.includeNestedMarkets;
+      const raw = nested === "true" || nested === "false" ? { ...request.query, includeNestedMarkets: nested === "true" } : request.query;
+      const query = parseLimitQuery(raw, measurementPortfolioSummaryQuerySchema, "Invalid measurement portfolio summary query");
       const { active, plan } = activeV2Plan2(app.db, project.id, "Portfolio summary");
       return portfolioResponse(app.db, active, plan, query);
     }
@@ -27866,6 +28116,31 @@ async function analyticsRoutes(app) {
       if (!Number.isInteger(n) || n <= 0) throw validationError('"limit" must be a positive integer');
       limit = n;
     }
+    const parsedFilters = sourceBreakdownQuerySchema.safeParse({
+      runId: request.query.runId,
+      queryClass: request.query.queryClass,
+      includeByQuery: request.query.includeByQuery
+    });
+    if (!parsedFilters.success) {
+      throw validationError("Invalid source breakdown query", { issues: parsedFilters.error.issues });
+    }
+    const requestedRunId = parsedFilters.data.runId ?? null;
+    const queryClass = parsedFilters.data.queryClass ?? "all";
+    const includeByQuery = parsedFilters.data.includeByQuery !== "false" && parsedFilters.data.includeByQuery !== "0";
+    const splitByClass = queryClass !== "all";
+    const planClassified = splitByClass && activeMeasurementPlan(app.db, project.id)?.plan.schemaVersion === 2;
+    const classifyQueryText = splitByClass && !planClassified ? projectQueryClassifier(project) : null;
+    if (splitByClass && !planClassified && !classifyQueryText) {
+      throw validationError(
+        `Query class "${queryClass}" needs a brand name or alias on this project. Add one, or omit queryClass for a pooled source list.`
+      );
+    }
+    const filters = {
+      runId: requestedRunId,
+      queryClass,
+      queryClassBasis: !splitByClass ? null : planClassified ? "measurement-plan" : "query-text",
+      includeByQuery
+    };
     const classifyCtx = {
       projectDomains: effectiveDomains(project),
       competitorDomains: app.db.select({ domain: competitors.domain }).from(competitors).where(eq30(competitors.projectId, project.id)).all().map((r) => r.domain)
@@ -27875,48 +28150,114 @@ async function analyticsRoutes(app) {
       const mapped = surfaceClassFromCompetitorType(row.competitorType);
       if (mapped) storedSurfaceClasses.set(normalizeProjectDomain(row.domain), mapped);
     }
-    const windowRuns = app.db.select().from(runs).where(and25(eq30(runs.projectId, project.id), eq30(runs.kind, RunKinds["answer-visibility"]), notProbeRun())).orderBy(desc12(runs.createdAt), desc12(runs.id)).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => measuredWhole(app.db, r)).filter((r) => !cutoff || r.createdAt >= cutoff);
+    if (requestedRunId) {
+      const requested = app.db.select().from(runs).where(and25(
+        eq30(runs.id, requestedRunId),
+        eq30(runs.projectId, project.id),
+        eq30(runs.kind, RunKinds["answer-visibility"])
+      )).get();
+      if (!requested) throw notFound("Answer-visibility run", requestedRunId);
+      if (requested.trigger === RunTriggers.probe) {
+        throw validationError(`Run "${requestedRunId}" is a probe run; probes never enter source analytics.`);
+      }
+      if (requested.status !== RunStatuses.completed && requested.status !== RunStatuses.partial) {
+        throw validationError(`Run "${requestedRunId}" is ${requested.status}; only completed or partial runs have source analytics.`);
+      }
+      if (!measuredWhole(app.db, requested)) {
+        throw validationError(`Run "${requestedRunId}" did not fill every slot its measurement plan promised, so it is excluded from source analytics.`);
+      }
+      if (cutoff && requested.createdAt < cutoff) {
+        throw validationError(`Run "${requestedRunId}" is older than the ${window} window. Omit window, or widen it, to read this run.`);
+      }
+    }
+    const windowRuns = app.db.select().from(runs).where(and25(
+      eq30(runs.projectId, project.id),
+      eq30(runs.kind, RunKinds["answer-visibility"]),
+      notProbeRun(),
+      requestedRunId ? eq30(runs.id, requestedRunId) : void 0
+    )).orderBy(desc12(runs.createdAt), desc12(runs.id)).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => measuredWhole(app.db, r)).filter((r) => !cutoff || r.createdAt >= cutoff);
     if (windowRuns.length === 0) {
       return reply.send({
-        overall: [],
-        byQuery: {},
-        ranked: buildRankedList(/* @__PURE__ */ new Map(), limit),
+        ranked: buildRankedList(/* @__PURE__ */ new Map(), limit, 0, 0),
         byProvider: {},
+        providersWithoutSources: [],
+        answerTotal: 0,
+        runCount: 0,
+        unclassifiedAnswers: 0,
+        filters,
         runId: "",
         window,
-        limit
+        limit,
+        overall: [],
+        ...includeByQuery ? { byQuery: {} } : {}
       });
     }
     const latestGroup = groupRunsByCreatedAt(windowRuns)[0] ?? [];
     const latestRunId = pickGroupRepresentative(latestGroup)?.id ?? windowRuns[0].id;
     const windowRunIds = windowRuns.map((r) => r.id);
-    const snapshots = app.db.select({
+    const loadedSnapshots = app.db.select({
+      runId: querySnapshots.runId,
       queryId: querySnapshots.queryId,
+      queryText: querySnapshots.queryText,
       query: queries.query,
       provider: querySnapshots.provider,
-      rawResponse: querySnapshots.rawResponse
+      citedDomains: querySnapshots.citedDomains,
+      citedUrls: querySnapshots.citedUrls,
+      measurementExecutionId: querySnapshots.measurementExecutionId
     }).from(querySnapshots).leftJoin(queries, eq30(querySnapshots.queryId, queries.id)).where(inArray13(querySnapshots.runId, windowRunIds)).all();
+    let unclassifiedAnswers = 0;
+    let snapshots = loadedSnapshots;
+    if (splitByClass) {
+      const planClasses = planClassified ? planQueryClassesByRun(app.db, project.id, windowRuns) : null;
+      snapshots = loadedSnapshots.filter((snap) => {
+        let classes;
+        if (planClasses) {
+          classes = snap.measurementExecutionId ? planClasses.get(snap.runId)?.get(snap.measurementExecutionId) : void 0;
+        } else {
+          const text2 = snap.query ?? snap.queryText;
+          classes = text2?.trim() ? /* @__PURE__ */ new Set([classifyQueryText(text2)]) : void 0;
+        }
+        if (!classes || classes.size === 0) {
+          unclassifiedAnswers += 1;
+          return false;
+        }
+        return classes.has(queryClass);
+      });
+    }
     const overallCounts = /* @__PURE__ */ new Map();
-    const byQuery = {};
+    const queryCounts = /* @__PURE__ */ new Map();
     const overallDomains = /* @__PURE__ */ new Map();
     const providerDomains = /* @__PURE__ */ new Map();
+    const answersByProvider = /* @__PURE__ */ new Map();
+    let answersWithSources = 0;
     for (const snap of snapshots) {
-      const sources = parseGroundingSources(snap.rawResponse);
-      const qCounts = /* @__PURE__ */ new Map();
-      for (const source of sources) {
-        const { category, label, domain } = categorizeSource(source.uri);
+      const domains = sourceDomainsOf(snap);
+      const providerAnswers = answersByProvider.get(snap.provider) ?? { total: 0, withSources: 0 };
+      providerAnswers.total += 1;
+      if (domains.length > 0) {
+        providerAnswers.withSources += 1;
+        answersWithSources += 1;
+      }
+      answersByProvider.set(snap.provider, providerAnswers);
+      const queryKey = includeByQuery && domains.length > 0 ? snap.query : null;
+      let qCounts;
+      if (queryKey) {
+        qCounts = queryCounts.get(queryKey);
+        if (!qCounts) {
+          qCounts = /* @__PURE__ */ new Map();
+          queryCounts.set(queryKey, qCounts);
+        }
+      }
+      for (const host of domains) {
+        const { category, label, domain } = categorizeSource(host);
         const surfaceClass = classifySurfaceFromCategory(
           domain,
           category,
           classifyCtx,
           storedSurfaceClasses.get(normalizeProjectDomain(domain))
         );
-        if (!overallCounts.has(category)) overallCounts.set(category, /* @__PURE__ */ new Map());
-        const oDomains = overallCounts.get(category);
-        oDomains.set(domain, (oDomains.get(domain) ?? 0) + 1);
-        if (!qCounts.has(category)) qCounts.set(category, /* @__PURE__ */ new Map());
-        const qDomains = qCounts.get(category);
-        qDomains.set(domain, (qDomains.get(domain) ?? 0) + 1);
+        bumpCategory(overallCounts, category, domain);
+        if (qCounts) bumpCategory(qCounts, category, domain);
         bumpDomain(overallDomains, domain, category, label, surfaceClass);
         let pm = providerDomains.get(snap.provider);
         if (!pm) {
@@ -27925,30 +28266,56 @@ async function analyticsRoutes(app) {
         }
         bumpDomain(pm, domain, category, label, surfaceClass);
       }
-      if (sources.length > 0 && snap.query) {
-        byQuery[snap.query] = buildCategoryCounts(qCounts);
-      }
     }
-    const overall = buildCategoryCounts(overallCounts);
-    const ranked = buildRankedList(overallDomains, limit);
+    const ranked = buildRankedList(overallDomains, limit, snapshots.length, answersWithSources);
     const byProvider = {};
     for (const [provider, domains] of providerDomains) {
-      byProvider[provider] = buildRankedList(domains, limit);
+      const answers = answersByProvider.get(provider);
+      byProvider[provider] = buildRankedList(domains, limit, answers.total, answers.withSources);
+    }
+    const providersWithoutSources = [...answersByProvider].filter(([, answers]) => answers.withSources === 0).map(([provider]) => provider).sort();
+    let byQuery;
+    if (includeByQuery) {
+      byQuery = {};
+      for (const [query, counts2] of queryCounts) byQuery[query] = buildCategoryCounts(counts2);
     }
-    return reply.send({ overall, byQuery, ranked, byProvider, runId: latestRunId, window, limit });
+    return reply.send({
+      ranked,
+      byProvider,
+      providersWithoutSources,
+      answerTotal: snapshots.length,
+      runCount: windowRuns.length,
+      unclassifiedAnswers,
+      filters,
+      runId: requestedRunId ?? latestRunId,
+      window,
+      limit,
+      overall: buildCategoryCounts(overallCounts),
+      ...byQuery ? { byQuery } : {}
+    });
   });
 }
 var ANCHOR_SWEEP_SCAN_LIMIT = 60;
 function isProviderInfraDomain(uri) {
   return hostMatchesAnyDomain(uri, AI_PROVIDER_INFRA_DOMAINS);
 }
-function parseGroundingSources(rawResponse) {
-  const parsed = parseJsonColumn(rawResponse, {});
-  const sources = parsed.groundingSources;
-  if (!Array.isArray(sources)) return [];
-  return sources.filter(
-    (s) => typeof s.uri === "string" && !isProviderInfraDomain(s.uri)
-  );
+function sourceDomainsOf(snapshot) {
+  const hosts = /* @__PURE__ */ new Set();
+  for (const value of [...snapshot.citedDomains ?? [], ...snapshot.citedUrls ?? []]) {
+    if (typeof value !== "string") continue;
+    const host = hostOf(value);
+    if (!host || isProviderInfraDomain(host)) continue;
+    hosts.add(host);
+  }
+  return [...hosts];
+}
+function bumpCategory(counts2, category, domain) {
+  let domains = counts2.get(category);
+  if (!domains) {
+    domains = /* @__PURE__ */ new Map();
+    counts2.set(category, domains);
+  }
+  domains.set(domain, (domains.get(domain) ?? 0) + 1);
 }
 function bucketSizeForSpan(spanDays) {
   if (spanDays <= 14) return 1;
@@ -28103,7 +28470,7 @@ function bumpDomain(map, domain, category, label, surfaceClass) {
   if (existing) existing.count += 1;
   else map.set(domain, { domain, count: 1, category, label, surfaceClass });
 }
-function buildRankedList(domains, limit) {
+function buildRankedList(domains, limit, answerTotal, answersWithSources) {
   const all = [...domains.values()];
   const totalCitedSlots = all.reduce((sum, d) => sum + d.count, 0);
   const domainTotal = all.length;
@@ -28113,6 +28480,7 @@ function buildRankedList(domains, limit) {
     domain: d.domain,
     count: d.count,
     percentage: totalCitedSlots > 0 ? round4(d.count / totalCitedSlots) : 0,
+    answerShare: answerTotal > 0 ? round4(d.count / answerTotal) : 0,
     category: d.category,
     label: d.label,
     surfaceClass: d.surfaceClass
@@ -28134,6 +28502,8 @@ function buildRankedList(domains, limit) {
   })).sort((a, b) => b.count - a.count || a.surfaceClass.localeCompare(b.surfaceClass));
   return {
     totalCitedSlots,
+    answerTotal,
+    answersWithSources,
     domainTotal,
     entries,
     truncatedDomainCount: domainTotal - shownEntries.length,
@@ -36589,7 +36959,7 @@ var competitorLandscapeGroupKeyParameter = {
 var competitorLandscapeScopeParameter = {
   name: "scope",
   in: "query",
-  description: 'Set to "all-markets" to aggregate raw stored evidence across every Advanced Measurement market. It cannot be combined with groupKey.',
+  description: 'Set to "all-markets" to aggregate raw stored evidence across every Property in the Advanced Measurement plan, including Properties in no market. It cannot be combined with groupKey.',
   schema: { type: "string", enum: ["project", "all-markets"] }
 };
 var competitorLandscapeProviderParameter = {
@@ -36613,7 +36983,7 @@ var competitorLandscapeGroupByParameter = {
 var competitorLandscapeQueryClassParameter = {
   name: "queryClass",
   in: "query",
-  description: "Restrict evidence to a question class. Advanced groups use their frozen assignment classes; simple projects classify stored query text.",
+  description: "Restrict evidence to a query class. Advanced groups use their frozen assignment classes; simple projects classify stored query text. On a project with an active v2 measurement plan, branded or non-brand without scope or groupKey defaults to scope=all-markets, so the class comes from the plan rather than the text classifier.",
   schema: { type: "string", enum: ["all", "branded", "non-brand"] }
 };
 var competitorLandscapeLocationParameter = {
@@ -36628,6 +36998,24 @@ var competitorLandscapeRunIdParameter = {
   description: "Restrict evidence to one stored answer-visibility run.",
   schema: stringSchema
 };
+var sourcesRunIdParameter = {
+  name: "runId",
+  in: "query",
+  description: "Read one stored answer-visibility run instead of pooling every run in the window. An unknown id is 404; a probe, unfinished, partially measured, or out-of-window run is 400.",
+  schema: stringSchema
+};
+var sourcesQueryClassParameter = {
+  name: "queryClass",
+  in: "query",
+  description: "Restrict to branded or non-brand answers. With an active v2 measurement plan the class comes from each run's frozen plan assignments (the same answers as the competitor landscape at scope=all-markets); otherwise from the project's brand-name classifier over the query text. Answers neither basis can place are excluded and counted in unclassifiedAnswers. Defaults to all, which pools both classes.",
+  schema: { type: "string", enum: ["all", "branded", "non-brand"] }
+};
+var sourcesIncludeByQueryParameter = {
+  name: "includeByQuery",
+  in: "query",
+  description: "Set to false to omit the per-query breakdown (byQuery), which grows with every tracked query. Defaults to true.",
+  schema: { type: "string", enum: ["true", "false", "1", "0"] }
+};
 var analyticsStartDateParameter = {
   name: "startDate",
   in: "query",
@@ -37435,7 +37823,7 @@ var routeCatalog = [
     method: "get",
     path: "/api/v1/projects/{name}/measurement-portfolio-summary",
     summary: "Get the weakest measured Properties",
-    description: "Returns a compact, revision-pinned portfolio ranking from stored results, plus a worst-first roll-up of every named market. It defaults to Non-brand questions, ranks measured mention coverage before citation coverage, and keeps unavailable rows separate from measured weakness. Every market is scoped to the displayed run, so a market row matches that market read with groupKey; markets may share Properties and never sum to the portfolio totals. The markets array is empty when the request already narrowed to one group. Replacement names come only from stored answer extraction. It never starts provider work.",
+    description: "Returns a compact, revision-pinned portfolio ranking from stored results, plus a worst-first market roll-up. It defaults to non-brand queries, ranks measured mention coverage before citation coverage, and keeps unavailable rows separate from measured weakness. Every Property row carries its metro, submarkets and query count; weakest rows also carry namedInsteadInAnswerText (names written in the answer text of answers that neither named nor cited the Property, counted by answer) and citedDomains (domains cited by the Property's answers, counted by answer, every engine included). tiedAtWeakest reports Properties sharing the weakest rates, and weakestAnswerSources ranks the domains cited across the weakest and tied Properties, each answer once. markets holds one level by default (top-level markets, or the selected group's direct children), worst-first and capped at limit; includeNestedMarkets returns every level. Every market is scoped to the displayed run, so a market row matches that market read with groupKey; markets may share Properties and never sum to the portfolio totals. It never starts provider work.",
     tags: ["measurement-plans"],
     parameters: [
       nameParameter,
@@ -37444,7 +37832,8 @@ var routeCatalog = [
       { name: "provider", in: "query", description: "Restrict to one answer provider.", schema: stringSchema },
       { name: "location", in: "query", description: "Restrict to one execution location label.", schema: stringSchema },
       { name: "runId", in: "query", description: "Read this completed or partial active-revision run, including a named spot check.", schema: stringSchema },
-      { name: "limit", in: "query", description: "Maximum Property rows. Defaults to 10, maximum 50.", schema: { type: "integer", minimum: 1, maximum: 50 } }
+      { name: "limit", in: "query", description: "Rows per list (weakest Properties, both mention rankings, markets). Defaults to 4, maximum 50.", schema: { type: "integer", minimum: 1, maximum: 50 } },
+      { name: "includeNestedMarkets", in: "query", description: "Return every market in scope at every level, uncapped. Defaults to false: one level (top-level markets, or the selected group's direct children), capped at limit.", schema: { type: "boolean" } }
     ],
     responses: {
       200: jsonResponse("Compact portfolio summary returned.", "MeasurementPortfolioSummaryResponse"),
@@ -38591,11 +38980,20 @@ var routeCatalog = [
     method: "get",
     path: "/api/v1/projects/{name}/analytics/sources",
     summary: "Get source origin analytics",
+    description: "Cited domains ranked by how many answers cite them, read from each answer's stored source list (citedDomains plus citedUrls), so every provider is counted, Gemini included. A domain counts at most once per answer. Without runId the response pools every run in the window (runCount says how many); without queryClass it pools branded and non-brand answers.",
     tags: ["analytics"],
-    parameters: [nameParameter, analyticsWindowParameter, limitQueryParameter],
+    parameters: [
+      nameParameter,
+      analyticsWindowParameter,
+      limitQueryParameter,
+      sourcesRunIdParameter,
+      sourcesQueryClassParameter,
+      sourcesIncludeByQueryParameter
+    ],
     responses: {
       200: jsonResponse("Source breakdown returned.", "SourceBreakdownDto"),
-      404: errorResponse("Project not found.")
+      400: errorResponse("Invalid query parameters."),
+      404: errorResponse("Project or run not found.")
     }
   },
   {
@@ -55513,7 +55911,7 @@ async function cdpRoutes(app, opts) {
           browserOnlyCited++;
           disagreed++;
         }
-        const parseGroundingSources2 = (snap) => {
+        const parseGroundingSources = (snap) => {
           if (!snap?.rawResponse) return [];
           try {
             const raw = JSON.parse(snap.rawResponse);
@@ -55528,13 +55926,13 @@ async function cdpRoutes(app, opts) {
             provider: api.provider,
             citationState: api.citationState,
             citedDomains: api.citedDomains,
-            groundingSources: parseGroundingSources2(api)
+            groundingSources: parseGroundingSources(api)
           } : null,
           browser: browser ? {
             provider: browser.provider,
             citationState: browser.citationState,
             citedDomains: browser.citedDomains,
-            groundingSources: parseGroundingSources2(browser),
+            groundingSources: parseGroundingSources(browser),
             screenshotUrl: browser.screenshotPath ? `${opts.routePrefix ?? "/api/v1"}/screenshots/${browser.id}` : void 0
           } : null,
           agreement
@@ -87546,6 +87944,10 @@ export {
   migrate,
   OperationalLogStore,
   groupRunsByCreatedAt,
+  determineCitationState,
+  computeCompetitorOverlap,
+  computeCitedCompetitorDomains,
+  extractRecommendedCompetitors,
   resolveTrustProxy,
   USER_SESSION_COOKIE_NAME,
   anyUsersExist,
@@ -87634,10 +88036,6 @@ export {
   addLogListener,
   createLogger,
   createFastifyLogger,
-  determineCitationState,
-  computeCompetitorOverlap,
-  computeCitedCompetitorDomains,
-  extractRecommendedCompetitors,
   HISTORY_WINDOW_RUNS,
   IntelligenceService
 };