@ainyc/canonry 5.5.0 → 5.6.0

package/dist/{chunk-REQEWYNF.js → chunk-D3DKDTXP.js}

@@ -3276,6 +3276,55 @@ function absolutizeProjectUrl(url, canonicalDomain) {
   if (trimmed.startsWith("/")) return `https://${host}${trimmed}`;
   return `https://${host}/${trimmed}`;
 }
+function safeLinkHref(value) {
+  const trimmed = (value ?? "").trim();
+  if (!trimmed) return "#";
+  if (trimmed.startsWith("/")) return trimmed;
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  if (/^mailto:/i.test(trimmed)) return trimmed;
+  return "#";
+}
+function describeLandingPage(raw) {
+  const value = raw ?? "";
+  const queryIndex = value.indexOf("?");
+  const path = queryIndex === -1 ? value : value.slice(0, queryIndex);
+  const query = queryIndex === -1 ? "" : value.slice(queryIndex + 1);
+  const displayPath = path || "/";
+  if (!query) return { path: displayPath, querySummary: null, raw: value };
+  let summary = "";
+  try {
+    summary = summarizeQueryParams(new URLSearchParams(query));
+  } catch {
+    summary = "tracking params";
+  }
+  return { path: displayPath, querySummary: summary || null, raw: value };
+}
+function summarizeQueryParams(params) {
+  const keys = Array.from(params.keys());
+  const total = keys.length;
+  if (total === 0) return "";
+  const noun = total === 1 ? "param" : "params";
+  const tag = inferAdSource(params);
+  return tag ? `${tag} \xB7 ${total} ${noun}` : `${total} tracking ${noun}`;
+}
+function inferAdSource(params) {
+  if (params.has("fbclid")) return "Facebook Ad";
+  if (params.has("gclid") || params.has("gbraid") || params.has("wbraid")) return "Google Ad";
+  if (params.has("msclkid")) return "Microsoft Ad";
+  if (params.has("ttclid")) return "TikTok Ad";
+  if (params.has("li_fat_id")) return "LinkedIn Ad";
+  if (params.has("twclid")) return "X / Twitter Ad";
+  if (params.has("epik")) return "Pinterest Ad";
+  for (const k of params.keys()) {
+    if (k.startsWith("hsa_")) return "Search Ad";
+  }
+  const src = params.get("utm_source");
+  const med = params.get("utm_medium");
+  if (src && med) return `${src} / ${med}`;
+  if (src) return `Source: ${src}`;
+  if (med) return `Medium: ${med}`;
+  return null;
+}
 function hostOf(value) {
   if (value == null) return null;
   const trimmed = value.trim();
@@ -6360,10 +6409,58 @@ function visibilityReportPageSchema(itemSchema) {
     total: z15.number().int().nonnegative()
   }).strict();
 }
+var visibilityReportRateChangeUnavailableReasonSchema = z15.enum([
+  "current-unavailable",
+  "previous-unavailable",
+  "not-applicable"
+]);
+var VisibilityReportRateChangeUnavailableReasons = visibilityReportRateChangeUnavailableReasonSchema.enum;
+var visibilityReportRateChangeSchema = z15.discriminatedUnion("state", [
+  z15.object({
+    state: z15.literal("available"),
+    previous: visibilityReportRateSchema,
+    delta: z15.number().min(-1).max(1)
+  }).strict(),
+  z15.object({
+    state: z15.literal("unavailable"),
+    reason: visibilityReportRateChangeUnavailableReasonSchema
+  }).strict()
+]);
+var visibilityReportComparedRunSchema = z15.object({
+  id: nonBlankIdSchema,
+  createdAt: dateTimeSchema,
+  completedAt: dateTimeSchema.nullable()
+}).strict();
+var visibilityReportComparisonUnavailableReasonSchema = z15.enum([
+  "no-selected-run",
+  "no-previous-run",
+  "scoped-run",
+  "partial-run",
+  "definition-changed",
+  "model-changed",
+  "legacy-unknown"
+]);
+var VisibilityReportComparisonUnavailableReasons = visibilityReportComparisonUnavailableReasonSchema.enum;
+var visibilityReportComparisonSchema = z15.discriminatedUnion("state", [
+  z15.object({
+    state: z15.literal("available"),
+    previousRun: visibilityReportComparedRunSchema,
+    mentionCoverage: visibilityReportRateChangeSchema,
+    citationCoverage: visibilityReportRateChangeSchema,
+    propertyReach: visibilityReportRateChangeSchema
+  }).strict(),
+  z15.object({
+    state: z15.literal("unavailable"),
+    reason: visibilityReportComparisonUnavailableReasonSchema,
+    previousRun: visibilityReportComparedRunSchema.nullable()
+  }).strict()
+]);
 var visibilityReportPopulationSchema = z15.object({
   queryClass: visibilityReportPopulationClassSchema,
   summary: visibilityReportSummarySchema,
   trend: z15.array(visibilityReportTrendPointSchema),
+  /** Optional: report builds and servers that predate the field omit it. */
+  comparison: visibilityReportComparisonSchema.optional(),
   queries: visibilityReportPageSchema(visibilityReportQueryRowSchema),
   evidence: visibilityReportPageSchema(visibilityReportEvidenceRowSchema),
   /** `items: []` alone means no measured competitors only when this is available. */
@@ -6423,6 +6520,44 @@ var visibilityReportResponseSchema = z15.object({
       message: "Populations must exactly match the selected query class order"
     });
   }
+  for (const [populationIndex, population] of value.populations.entries()) {
+    const comparison = population.comparison;
+    if (comparison?.state !== "available") continue;
+    for (const key of ["mentionCoverage", "citationCoverage", "propertyReach"]) {
+      const change = comparison[key];
+      if (change.state !== "available") continue;
+      const path = ["populations", populationIndex, "comparison", key];
+      const current = population.summary[key].rate;
+      const previous = change.previous.rate;
+      if (current === null) {
+        ctx.addIssue({ code: z15.ZodIssueCode.custom, path, message: "Available changes require a current rate" });
+      }
+      if (previous === null) {
+        ctx.addIssue({
+          code: z15.ZodIssueCode.custom,
+          path: [...path, "previous", "rate"],
+          message: "Available changes require a previous rate"
+        });
+      }
+      if (current !== null && previous !== null && Math.abs(change.delta - (current - previous)) > Number.EPSILON) {
+        ctx.addIssue({ code: z15.ZodIssueCode.custom, path: [...path, "delta"], message: "Delta must equal current minus previous" });
+      }
+      if (value.selection.run.id === null) {
+        ctx.addIssue({ code: z15.ZodIssueCode.custom, path, message: "Available changes require a selected run" });
+      }
+    }
+  }
+});
+var visibilityReportScopeErrorReasonSchema = z15.enum(["retired-scope", "retired-market"]);
+var VisibilityReportScopeErrorReasons = visibilityReportScopeErrorReasonSchema.enum;
+var visibilityReportScopeErrorDetailsSchema = z15.object({
+  reason: visibilityReportScopeErrorReasonSchema,
+  kind: visibilityReportScopeKindSchema.exclude(["project"]),
+  key: nonBlankIdSchema
+}).strict().superRefine((details, ctx) => {
+  if (details.reason === VisibilityReportScopeErrorReasons["retired-market"] && details.kind !== "market") {
+    ctx.addIssue({ code: z15.ZodIssueCode.custom, path: ["kind"], message: "retired-market details must name a market" });
+  }
 });
 
 // ../contracts/src/query-tracking.ts
@@ -6590,6 +6725,11 @@ var queryTrackingWorkspaceResponseSchema = z16.object({
   targets: z16.array(queryTrackingTargetSchema),
   groups: z16.array(queryTrackingGroupSchema),
   markets: z16.array(queryTrackingMarketSchema),
+  /**
+   * Server-built scope choices for this workspace's Groups, markets, and
+   * Properties. Optional so a client tolerates a server that predates it.
+   */
+  scopeOptions: z16.array(visibilityReportScopeOptionSchema).optional(),
   tracked: z16.array(queryTrackingTrackedRowSchema),
   savedSources: z16.object({
     research: z16.array(queryTrackingResearchCandidateSchema),
@@ -8040,6 +8180,10 @@ function formatRatio(value) {
   if (!Number.isFinite(value) || value === 0) return "0%";
   return `${(value * 100).toFixed(1)}%`;
 }
+function formatWholePercent(ratio) {
+  if (!Number.isFinite(ratio)) return "0%";
+  return `${Math.round(Number((ratio * 100).toFixed(6)))}%`;
+}
 function formatNumber(value) {
   if (!Number.isFinite(value)) return "\u2014";
   if (Math.abs(value) >= 1e6) return `${(value / 1e6).toFixed(1)}M`;
@@ -8525,14 +8669,14 @@ function roundSignificant(value, sig = 6) {
   const factor = 10 ** (sig - magnitude);
   return (Math.round(value * factor) + 0) / factor;
 }
-function wilsonInterval(successes, n, z62 = 1.96) {
+function wilsonInterval(successes, n, z63 = 1.96) {
   if (!Number.isFinite(n) || n <= 0) return null;
   const s = Math.max(0, Math.min(successes, n));
   const p = s / n;
-  const z210 = z62 * z62;
+  const z210 = z63 * z63;
   const denom = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denom;
-  const margin = z62 / denom * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z63 / denom * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
   return {
     low: round(Math.max(0, center - margin)),
     high: round(Math.min(1, center + margin))
@@ -15177,9 +15321,11 @@ var citationsTrendPointSchema = z52.object({
     mentionRate: z52.number()
   }))
 });
+var reportInsightTypeSchema = z52.enum(["regression", "gain", "opportunity"]);
+var ReportInsightTypes = reportInsightTypeSchema.enum;
 var reportInsightSchema = z52.object({
   id: z52.string(),
-  type: z52.enum(["regression", "gain", "opportunity"]),
+  type: reportInsightTypeSchema,
   severity: z52.enum(["critical", "high", "medium", "low"]),
   title: z52.string(),
   query: z52.string(),
@@ -15362,6 +15508,38 @@ function reportActionTone(action) {
   if (action.confidence === "low") return "neutral";
   return "caution";
 }
+function reportPressureTone(label) {
+  if (label === "High") return "negative";
+  if (label === "Moderate") return "caution";
+  if (label === "Low") return "positive";
+  return "neutral";
+}
+function reportSeverityTone(severity) {
+  switch (severity) {
+    case "critical":
+      return "negative";
+    case "high":
+      return "negative";
+    case "medium":
+      return "caution";
+    case "low":
+      return "neutral";
+  }
+}
+function reportInsightTone(insight) {
+  return insight.type === ReportInsightTypes.gain ? "positive" : reportSeverityTone(insight.severity);
+}
+function reportSourceCategoryTone(category) {
+  switch (category) {
+    case SourceCategories.competitor:
+      return "negative";
+    case SourceCategories.directory:
+    case SourceCategories.forum:
+      return "caution";
+    default:
+      return "neutral";
+  }
+}
 function reportSeverityLabel(severity) {
   switch (severity) {
     case "critical":
@@ -17871,80 +18049,799 @@ function isTrendBaseline(points) {
   return points.length < MIN_TREND_POINTS;
 }
 
-// ../contracts/src/operational-logs.ts
+// ../contracts/src/report-sections.ts
 import { z as z61 } from "zod";
-var operationalLogLevelSchema = z61.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
-var diagnosticContextSchema = z61.object({
-  runId: z61.string().min(1).max(256).optional(),
-  projectId: z61.string().min(1).max(256).optional(),
-  requestId: z61.string().min(1).max(256).optional(),
-  actor: z61.string().min(1).max(512).optional(),
-  credentialId: z61.string().min(1).max(512).optional(),
-  userAgent: z61.string().min(1).max(512).optional(),
-  actorSession: z61.string().min(1).max(512).optional(),
-  method: z61.string().min(1).max(16).optional(),
-  route: z61.string().min(1).max(256).optional(),
-  operationId: z61.string().min(1).max(256).optional(),
-  jobId: z61.string().min(1).max(256).optional(),
-  taskId: z61.string().min(1).max(256).optional(),
-  traceId: z61.string().min(1).max(256).optional(),
-  errorCode: z61.string().min(1).max(128).optional(),
-  attempt: z61.number().finite().optional(),
-  count: z61.number().finite().optional(),
-  total: z61.number().finite().optional(),
-  progress: z61.number().finite().optional(),
-  httpStatus: z61.number().finite().optional(),
-  statusCode: z61.number().finite().optional(),
-  durationMs: z61.number().finite().optional(),
-  bytes: z61.number().finite().optional(),
-  retryAfterMs: z61.number().finite().optional(),
-  retriable: z61.boolean().optional(),
-  retrying: z61.boolean().optional(),
-  cancelled: z61.boolean().optional(),
-  success: z61.boolean().optional()
-}).strict();
-var operationalLogEntryDtoSchema = z61.object({
-  cursor: z61.string().min(1).max(512),
-  ts: z61.string().datetime(),
+var CLIENT_AUDIENCE = reportAudienceSchema.enum.client;
+var BOTH_AUDIENCES = reportActionAudienceSchema.enum.both;
+var ADVANCED_MODE = visibilityReportResolvedModeSchema.enum.advanced;
+function pluralize(count, singular, plural = `${singular}s`) {
+  return count === 1 ? singular : plural;
+}
+var reportSectionIdSchema = z61.enum([
+  "client-summary",
+  "executive-summary",
+  "share-of-voice",
+  "whats-changed",
+  "client-action-plan",
+  "agency-action-plan",
+  "agency-diagnostics",
+  "citation-scorecard",
+  "competitor-landscape",
+  "ai-source-origin",
+  "gsc",
+  "ga",
+  "social-referrals",
+  "ai-referrals",
+  "server-activity",
+  "indexing-health",
+  "citations-trend",
+  "insights",
+  "content-opportunities",
+  "content-gaps",
+  "recommended-next-steps",
+  "client-evidence-summary"
+]);
+var ReportSectionIds = reportSectionIdSchema.enum;
+var PROVIDER_DISPLAY_NAMES = {
+  gemini: "Gemini",
+  openai: "ChatGPT",
+  claude: "Claude",
+  perplexity: "Perplexity",
+  local: "Local model",
+  "cdp:chatgpt": "ChatGPT (browser)"
+};
+function reportProviderDisplayName(provider) {
+  return PROVIDER_DISPLAY_NAMES[provider] ?? provider.charAt(0).toUpperCase() + provider.slice(1);
+}
+function reportClientHorizonLabel(horizon) {
+  switch (horizon) {
+    case "immediate":
+      return "Do now";
+    case "short-term":
+      return "This month";
+    case "medium-term":
+      return "Next quarter";
+  }
+}
+function reportClientConfidenceLabel(confidence) {
+  switch (confidence) {
+    case "high":
+      return "Strong evidence";
+    case "medium":
+      return "Some evidence";
+    case "low":
+      return "Worth trying";
+  }
+}
+function reportLocationDisplay(location) {
+  if (!location) return "";
+  const place = [location.city, location.region, location.country].filter(Boolean).join(", ");
+  return place ? `${location.label} (${place})` : location.label;
+}
+var REPORT_HEADER_COPY = {
+  eyebrow: "AI Visibility Report",
+  market: "Market",
+  noMarket: "No market set",
+  generated: "Generated"
+};
+function reportHeaderMarketLabel(location) {
+  return location ? `${REPORT_HEADER_COPY.market}: ${reportLocationDisplay(location)}` : REPORT_HEADER_COPY.noMarket;
+}
+function reportHeaderPeriodLabel(periodDays) {
+  return `Last ${periodDays} days`;
+}
+function reportCompactList(items, limit = 3) {
+  const visible = items.slice(0, limit);
+  const more = items.length - visible.length;
+  return `${visible.join(", ")}${more > 0 ? `, +${more} more` : ""}`;
+}
+function reportTruncatedList(items, limit) {
+  return `${items.slice(0, limit).join(", ")}${items.length > limit ? "\u2026" : ""}`;
+}
+function reportMoreChipLabel(count) {
+  return `+${count} more`;
+}
+function reportInstanceCountLabel(count) {
+  return `\xD7 ${count}`;
+}
+function reportBarChartLabel(title) {
+  return `${title} bar chart`;
+}
+function reportLineChartLabel(title) {
+  return `${title} line chart`;
+}
+function reportDeltaArrow(direction) {
+  if (direction === "up") return "\u2191";
+  if (direction === "down") return "\u2193";
+  return "\u2192";
+}
+function reportDirectionTone(direction) {
+  if (direction === "up") return "positive";
+  if (direction === "down") return "negative";
+  return "neutral";
+}
+function reportRateDeltaCopy(delta, unit) {
+  return unit === "%" ? `${delta.deltaAbs > 0 ? "+" : ""}${delta.deltaAbs.toFixed(1)}% vs ${delta.prior}%` : formatAverageDelta(delta);
+}
+function reportMovementChangeCopy(movement) {
+  return `${movement.deltaAbs > 0 ? "+" : ""}${movement.deltaAbs.toFixed(1)}% ${reportDeltaArrow(movement.direction)}`;
+}
+function reportPriorWindowLabel(days) {
+  return `vs prior ${days} days`;
+}
+function reportClientTrendCopy(delta) {
+  if (!delta) return null;
+  const checks = delta.window ?? 1;
+  const compare = checks >= 2 ? `vs prior ${checks} checks (avg ${delta.prior}%)` : `since last check (was ${delta.prior}%)`;
+  const arrow = reportDeltaArrow(delta.direction);
+  if (delta.direction === "up") return { text: `Up ${delta.deltaAbs.toFixed(1)} points ${compare}`, tone: "positive", arrow };
+  if (delta.direction === "down") return { text: `Down ${Math.abs(delta.deltaAbs).toFixed(1)} points ${compare}`, tone: "negative", arrow };
+  return { text: `Holding steady ${compare}`, tone: "neutral", arrow };
+}
+var SHARED_SECTION_COPY = {
+  "client-summary": {
+    heroEyebrow: "Overview",
+    heroEmpty: "No AI check has been run yet. Run a check to see how AI tools answer customer queries about your business.",
+    tiles: {
+      mentioned: "AI mentions your name",
+      cited: "AI links to your website",
+      providers: "AI tools tested"
+    },
+    noData: "No data yet",
+    explainer: {
+      lead: "Mentions and links are different.",
+      mention: { article: "A", term: "mention", definition: "is when AI says your name out loud in its answer." },
+      link: { article: "A", term: "link", definition: "is when AI lists your website as a source it used." },
+      closing: "AI can do either, both, or neither \u2014 that's why we track both."
+    },
+    queriesHeading: "Customer queries we tested",
+    providerBarsHeading: "How often each AI tool mentions you",
+    providerBarsSubtitle: "Higher is better. Each bar shows the share of customer queries where the AI named you in the answer."
+  },
+  "whats-changed": {
+    client: {
+      eyebrow: "Since last check",
+      title: "What's different since last check",
+      empty: "No comparison yet \u2014 trends will appear after a few more checks.",
+      tiles: {
+        mentionRate: "AI mentions your name",
+        citationRate: "AI links to your website",
+        mentionedQueryCount: "Queries AI mentioned you in",
+        gscClicks: "Visitors from Google",
+        aiReferrals: "Visitors from AI tools"
+      },
+      gscCountLabel: "visits",
+      aiReferralsCountLabel: "visits",
+      movementsHeading: "How each AI tool changed",
+      movementHeaders: ["AI tool", "Was", "Now", "Change"],
+      winsHeading: "What got better",
+      winsEmpty: "No new wins this period.",
+      regressionsHeading: "What got worse",
+      regressionsEmpty: "Nothing got worse this period.",
+      insightHeaders: ["What changed", "Customer query", "AI tool"]
+    },
+    agency: {
+      eyebrow: "Section 2",
+      title: "What's Changed",
+      empty: "Trends will appear after a few more checks.",
+      tiles: {
+        citationRate: "Citation rate",
+        mentionRate: "Mention rate",
+        citedQueryCount: "Cited queries",
+        gscClicks: "GSC clicks",
+        aiReferrals: "AI referral sessions"
+      },
+      gscCountLabel: "clicks",
+      aiReferralsCountLabel: "sessions",
+      movementsHeading: "AI engine movements",
+      movementHeaders: ["Engine", "Prior", "Current", "Change"],
+      winsHeading: "Wins",
+      winsEmpty: "No new gains in the latest check.",
+      regressionsHeading: "Regressions",
+      regressionsEmpty: "No new regressions in the latest check.",
+      insightHeaders: ["Severity", "Title", "Query", "Provider"]
+    },
+    rateTileEmpty: "No prior data",
+    trafficTileEmpty: "Not enough trend data"
+  },
+  "client-action-plan": {
+    eyebrow: "Action plan",
+    title: "What to do next",
+    intro: "Approve these in order. They are sorted by what will move the needle fastest.",
+    empty: "No recommendations yet \u2014 run an AI check to populate this.",
+    rankTitle: "Priority \u2014 1 will move the needle fastest",
+    detailsSummary: "See the data behind this",
+    whyLabel: "Why this matters",
+    evidenceLabel: "What we saw",
+    successLabel: "What success looks like:"
+  },
+  "agency-action-plan": {
+    eyebrow: "Agency actions",
+    title: "Agency Action Plan",
+    intro: "The highest-leverage work, sorted by urgency and evidence strength.",
+    empty: "No prioritized actions yet.",
+    rankTitle: "Impact rank \u2014 1 is the highest-leverage action",
+    detailsSummary: "Evidence details",
+    whyLabel: "Why",
+    evidenceLabel: "Evidence",
+    successLabel: "Win condition:"
+  },
+  "client-evidence-summary": {
+    eyebrow: "What we based this on",
+    title: "The signals behind this plan",
+    intro: "The data behind the recommendations above. Switch to Agency for the full breakdowns.",
+    empty: "No supporting evidence yet \u2014 this fills in after the first AI check.",
+    sources: {
+      heading: "Where AI gets its answers",
+      subtitle: "The websites AI tools cited most often when answering customer queries about your industry.",
+      competitorTag: "(competitor)"
+    },
+    indexing: {
+      heading: "Pages Google can find on your site",
+      subtitle: "Google indexing your site increases the chances of it appearing in AI search (especially Gemini)."
+    },
+    search: {
+      heading: "What people search Google for",
+      subtitleLead: "You appeared in",
+      subtitleMiddle: "Google searches and got",
+      subtitleTail: "this period."
+    },
+    opportunities: {
+      heading: "Topics where you could improve",
+      subtitle: "Customer queries where better content on your site would help AI cite you.",
+      cededTag: "Ceded surface"
+    }
+  }
+};
+function reportClientHeroSentence(totalQueries, mentionedQueries) {
+  if (!(totalQueries > 0)) return SHARED_SECTION_COPY["client-summary"].heroEmpty;
+  return `When customers asked AI ${totalQueries} ${pluralize(totalQueries, "query", "queries")} about your industry, AI mentioned you in ${mentionedQueries} of ${totalQueries === 1 ? "them" : "those queries"}.`;
+}
+function reportClientMentionedSubtitle(mentionedQueries, totalQueries) {
+  return totalQueries > 0 ? `Says your name in ${mentionedQueries} of ${totalQueries} ${pluralize(totalQueries, "query", "queries")}` : SHARED_SECTION_COPY["client-summary"].noData;
+}
+function reportClientCitedSubtitle(citedQueries, totalQueries) {
+  return totalQueries > 0 ? `Cites your site as a source in ${citedQueries} of ${totalQueries} ${pluralize(totalQueries, "query", "queries")}` : SHARED_SECTION_COPY["client-summary"].noData;
+}
+function reportClientProvidersSubtitle(providers, queryCount) {
+  return providers.length > 0 ? providers.map((provider) => reportProviderDisplayName(provider)).join(", ") : `${formatNumber(queryCount)} ${pluralize(queryCount, "query", "queries")} tested`;
+}
+function reportClientQueriesSubtitle(queryCount) {
+  return `These are the ${queryCount} ${pluralize(queryCount, "query we asked", "queries we asked")} every AI tool. The numbers above measure how often you came up.`;
+}
+function reportAudienceActions(report, audience) {
+  const actions = audience === CLIENT_AUDIENCE ? report.clientSummary.actionItems : report.agencyDiagnostics.priorities.length > 0 ? report.agencyDiagnostics.priorities : report.actionPlan.filter((action) => action.audience === BOTH_AUDIENCES || action.audience === audience);
+  return dedupeReportActions(report, actions);
+}
+function reportActionHorizonBadge(audience, horizon) {
+  return audience === CLIENT_AUDIENCE ? reportClientHorizonLabel(horizon) : reportHorizonLabel(horizon);
+}
+function reportActionConfidenceBadge(audience, confidence) {
+  return audience === CLIENT_AUDIENCE ? reportClientConfidenceLabel(confidence) : `${reportConfidenceLabel(confidence)} confidence`;
+}
+function reportClientSourceCount(count) {
+  return `${formatNumber(count)}\xD7`;
+}
+function reportClientIndexedPages(indexed, total) {
+  return `${formatNumber(indexed)} of ${formatNumber(total)} pages indexed`;
+}
+function reportClientNotIndexedTail(notIndexed) {
+  return `${pluralize(notIndexed, "page is", "pages are")} not indexed yet.`;
+}
+function reportClientClicksNoun(clicks) {
+  return pluralize(clicks, "click");
+}
+function reportClientSearchCount(impressions) {
+  return `${formatNumber(impressions)} ${pluralize(impressions, "search", "searches")}`;
+}
+function reportClientIndexingTone(indexedPct) {
+  if (indexedPct >= 90) return "positive";
+  if (indexedPct >= 70) return "caution";
+  return "negative";
+}
+var AGENCY_OVERVIEW_COPY = {
+  "executive-summary": {
+    eyebrow: "Section 1",
+    title: "Executive Summary",
+    intro: "Citation = source list. Mention = answer text. They are independent signals.",
+    heroKicker: "Latest AI visibility check",
+    emptyTitle: "No AI citation data yet",
+    emptySubtitle: "Run a check to populate the first citation and mention baseline.",
+    noQueries: "no queries",
+    proofTiles: {
+      citationTrend: "Citation trend",
+      mentionCoverage: "Mention coverage",
+      prioritizedActions: "Prioritized actions"
+    },
+    prioritizedActionsCopy: "Sorted for agency follow-up.",
+    tiles: {
+      citationRate: "Citation rate",
+      mentionRate: "Mention rate",
+      queriesTracked: "Queries tracked",
+      gscClicks: "GSC clicks",
+      gaSessions: "GA sessions"
+    },
+    trendLabels: { up: "\u2191 Up", down: "\u2193 Down", flat: "\u2192 Flat", unknown: "\u2014" },
+    marketScope: {
+      heading: "Market Scope",
+      currentLabel: "Current check",
+      currentCopy: "All findings below are scoped to this run.",
+      notIncludedLabel: "Not included",
+      providerLabel: "Provider context",
+      noOtherMarkets: "None",
+      noProviders: "\u2014",
+      singleMarketCopy: "Single-market report; findings can be read as the current market view.",
+      noMarketCopy: "No geographic hint was attached to this check; read findings as default-market or national results.",
+      noProviderMetadataCopy: "No provider-level location metadata is available for this report.",
+      warningTitle: "Location handling needs review",
+      warningDetail: "used weak or indirect market handling. Treat provider-level differences cautiously."
+    }
+  },
+  "agency-diagnostics": {
+    eyebrow: "Agency diagnostics",
+    title: "Technical Diagnostics",
+    intro: "Fast-read operator flags behind the action plan.",
+    empty: "No agency diagnostics available yet.",
+    /** Legacy diagnostics with this title are hidden: the market scope card covers them. */
+    hiddenTitle: "Location caveat"
+  },
+  "recommended-next-steps": {
+    eyebrow: "Section 16",
+    title: "Recommended Next Steps",
+    intro: "Action items bucketed by timing.",
+    empty: "No outstanding actions."
+  }
+};
+function reportExecutiveHeadline(report) {
+  const copy = AGENCY_OVERVIEW_COPY["executive-summary"];
+  const summary = report.executiveSummary;
+  const trend = summary.trend;
+  const trendLabel = trend === "up" ? copy.trendLabels.up : trend === "down" ? copy.trendLabels.down : trend === "flat" ? copy.trendLabels.flat : copy.trendLabels.unknown;
+  const trendTone = trend === "up" ? "positive" : trend === "down" ? "negative" : "neutral";
+  const hasQueries = (summary.totalQueryCount ?? 0) > 0;
+  const queryNoun = summary.totalQueryCount === 1 ? "query" : "queries";
+  const priorities = report.agencyDiagnostics.priorities.length > 0 ? report.agencyDiagnostics.priorities : report.actionPlan;
+  const gscDateRange = summary.gsc ? reportGscDateRange(report) : "";
+  return {
+    trendLabel,
+    trendTone,
+    title: hasQueries ? `${summary.citedQueryCount} of ${summary.totalQueryCount} tracked ${queryNoun} cite ${report.meta.project.displayName}` : copy.emptyTitle,
+    subtitle: hasQueries ? `${summary.citationRate}% citation coverage and ${summary.mentionRate}% mention coverage across ${summary.providerCount} ${pluralize(summary.providerCount, "provider")}.` : copy.emptySubtitle,
+    citedFragment: hasQueries ? `${summary.citedQueryCount}/${summary.totalQueryCount} ${queryNoun} cited` : copy.noQueries,
+    mentionedFragment: hasQueries ? `${summary.mentionedQueryCount}/${summary.totalQueryCount} ${queryNoun} mentioned` : copy.noQueries,
+    prioritizedActionCount: dedupeReportActions(report, priorities).length,
+    providerCountLabel: `${summary.providerCount} provider${summary.providerCount === 1 ? "" : "s"}`,
+    competitorCountLabel: `${summary.competitorCount} competitor${summary.competitorCount === 1 ? "" : "s"} tracked`,
+    gscDelta: summary.gsc ? `${formatNumber(summary.gsc.impressions)} imp \xB7 ${formatRatio(summary.gsc.ctr)} CTR${gscDateRange ? ` \xB7 ${gscDateRange}` : ""}` : null,
+    gaDelta: summary.ga ? `${formatNumber(summary.ga.users)} users \xB7 ${formatDate(summary.ga.periodStart)} \u2192 ${formatDate(summary.ga.periodEnd)}` : null
+  };
+}
+function reportMarketScope(report) {
+  const copy = AGENCY_OVERVIEW_COPY["executive-summary"].marketScope;
+  const location = report.meta.location;
+  const handling = report.meta.providerLocationHandling;
+  if (!location && handling.length === 0) return null;
+  const otherLocations = location?.otherConfiguredLabels ?? [];
+  const weak = handling.filter((entry) => entry.treatment === "ignored" || entry.treatment === "browser-geo").map((entry) => entry.provider);
+  return {
+    currentValue: location ? reportLocationDisplay(location) : REPORT_HEADER_COPY.noMarket,
+    notIncludedValue: otherLocations.length > 0 ? reportCompactList(otherLocations, 4) : copy.noOtherMarkets,
+    notIncludedCopy: location ? otherLocations.length > 0 ? `${otherLocations.length} configured ${pluralize(otherLocations.length, "market")} still ${otherLocations.length === 1 ? "needs" : "need"} a matching check before cross-market recommendations.` : copy.singleMarketCopy : copy.noMarketCopy,
+    providerValue: handling.length > 0 ? formatNumber(handling.length) : copy.noProviders,
+    providerCopy: handling.length > 0 ? weak.length > 0 ? `${weak.length} ${pluralize(weak.length, "provider")} need a closer location check.` : `${handling.length} ${pluralize(handling.length, "provider")} received the market context.` : copy.noProviderMetadataCopy,
+    weakProviders: weak.length > 0 ? reportCompactList(weak, 4) : null
+  };
+}
+var COMPETITIVE_EVIDENCE_COPY = {
+  "citation-scorecard": {
+    eyebrow: "Section 3",
+    title: "Citation Scorecard",
+    intro: "Per-engine citation and mention coverage from the latest check.",
+    providerChartTitle: "Provider citation rate",
+    empty: "Run a check to populate the citation matrix.",
+    queryHeader: "Query",
+    /** Two-glyph matrix cells: citation first, then mention. */
+    glyphs: { cited: "C", notCited: "c", mentioned: "M", notMentioned: "m", pending: "\u2013", missingCell: "\u2014 \u2014" },
+    legend: {
+      lead: "Legend:",
+      citedMeaning: "= cited/not,",
+      mentionedMeaning: "= mentioned/not,",
+      pendingMeaning: "= no data."
+    }
+  },
+  "competitor-landscape": {
+    eyebrow: "Section 4",
+    title: "Competitor Landscape",
+    intro: "Who AI engines cite and mention instead of the client.",
+    empty: "No competitor data yet. Add competitors and run a check.",
+    noCompetitors: "No competitors configured.",
+    citationsChartTitle: "Citations per domain",
+    brandedChartTitle: "Mentions per domain \xB7 branded queries",
+    headers: {
+      domain: "Domain",
+      pressure: "Pressure",
+      citations: "Citations",
+      citationShare: "Citation share",
+      citedQueries: "Cited queries"
+    },
+    citationShareTooltip: "Citation share \u2014 % of cited-source slots that went to this competitor across tracked queries. Distinct from Mention Share."
+  },
+  "ai-source-origin": {
+    eyebrow: "Section 5",
+    title: "AI Citation Sources",
+    intro: "External domains AI engines cited most in the latest check.",
+    empty: "No source data yet. Run a check first.",
+    topSourcesHeading: "Top sources",
+    topSourceHeaders: ["Domain", "Citations", "Tag"],
+    trackedCompetitorTag: "Tracked competitor",
+    externalTag: "External",
+    categoriesHeading: "By source type"
+  }
+};
+function reportProviderRateLabel(rate) {
+  return `${rate.citationRate}% (${rate.citedCount}/${rate.totalCount})`;
+}
+var MENTION_SCOPE_LABELS = {
+  "non-brand": "non-brand queries",
+  pooled: "pooled queries \xB7 classification unavailable"
+};
+function reportMentionScopeLabel(scope) {
+  return MENTION_SCOPE_LABELS[scope] ?? "pooled queries \xB7 classification unavailable";
+}
+function reportCompetitorMentionCopy(mentionLandscape) {
+  const scopeLabel = reportMentionScopeLabel(mentionLandscape.scope);
+  const branded = mentionLandscape.branded;
+  return {
+    scopeLabel,
+    mentionsHeader: `Mentions (${scopeLabel})`,
+    mentionsTooltip: mentionLandscape.scope === "non-brand" ? `Mentions on ${scopeLabel}. Branded queries are counted separately \u2014 the client is named on nearly all of them and a competitor cannot be, so pooling the two would rank the client on its own brand recall.` : `Mentions on ${scopeLabel}. The project has no usable brand identity for a branded/non-brand split, so all tracked queries remain pooled and this is not a competitive category read.`,
+    mentionsChartTitle: `Mentions per domain \xB7 ${scopeLabel}`,
+    mentionShareUnavailable: `Mention share unavailable for ${scopeLabel}: no tracked brand was named, so the denominator is 0.`,
+    brandedNote: `Branded queries contain the client's own name. The client is named on nearly all of them and a competitor structurally cannot be, so these are kept out of the competitive figure above. Read them as brand recall: ${branded?.projectMentionCount ?? 0} of ${branded?.totalAnswerSnapshots ?? 0} branded answers named the client.`
+  };
+}
+function reportCitedUrlCount(count) {
+  return `${count} cited URL${count > 1 ? "s" : ""}`;
+}
+function reportSourceOriginHeadline(categories) {
+  const competitor = categories.find((category) => category.category === SourceCategories.competitor);
+  if (!competitor) return null;
+  const total = categories.reduce((sum, category) => sum + category.count, 0);
+  return { share: `${competitor.sharePct}%`, detail: `of citations went to tracked competitors (${competitor.count} of ${total}).` };
+}
+function reportSourceCategoryShareLabel(sharePct) {
+  return `(${sharePct}%)`;
+}
+var SEARCH_TRAFFIC_COPY = {
+  gsc: {
+    eyebrow: "Section 6",
+    title: "GSC Performance",
+    empty: "Connect Google Search Console to populate this section.",
+    tiles: {
+      clicks: "Total clicks",
+      impressions: "Total impressions",
+      ctr: "Avg CTR",
+      position: "Avg position"
+    },
+    trendTitle: "Clicks over time",
+    topQueriesHeading: "Top queries",
+    topQueryHeaders: ["Query", "Clicks", "Imp.", "CTR", "Pos.", "Category"],
+    intentHeading: "Search demand by intent",
+    intentCountLabel: "clicks",
+    untrackedDemand: {
+      heading: "AEO queries without search demand",
+      subtitle: "Review whether these still belong in the tracking set."
+    },
+    suggestedQueries: {
+      heading: "Search queries you should track",
+      subtitle: "High-impression candidates to add to AEO tracking."
+    }
+  },
+  ga: {
+    eyebrow: "Section 7",
+    title: "GA4 Traffic",
+    empty: "Connect Google Analytics 4 to populate this section.",
+    tiles: {
+      sessions: "Total sessions",
+      users: "Total users",
+      organicSessions: "Organic sessions"
+    },
+    topPagesHeading: "Top landing pages",
+    topPageHeaders: ["Page", "Sessions", "Organic"],
+    channelsHeading: "Channel mix",
+    channelsCountLabel: "sessions"
+  },
+  "social-referrals": {
+    eyebrow: "Section 8",
+    title: "Social Referrals",
+    intro: "Social traffic split by channel and campaign.",
+    empty: "No social referral data yet.",
+    tiles: {
+      sessions: "Total sessions",
+      organic: "Organic social",
+      paid: "Paid social"
+    },
+    channelsHeading: "Social channel mix",
+    channelsCountLabel: "sessions",
+    campaignsHeading: "Top campaigns",
+    campaignHeaders: ["Source", "Medium", "Sessions"]
+  },
+  "ai-referrals": {
+    eyebrow: "Section 9",
+    title: "AI Referral Traffic",
+    intro: "Traffic arriving from AI answer engines.",
+    empty: "No AI referral traffic detected yet.",
+    tiles: {
+      sessions: "Total sessions"
+    },
+    trendTitle: "AI referral sessions over time",
+    sourcesHeading: "AI sessions by source",
+    sourcesCountLabel: "sessions",
+    topPagesHeading: "Top AI landing pages",
+    topPageHeaders: ["Page", "Sessions"]
+  }
+};
+function reportGscDateRange(report) {
+  const summary = report.executiveSummary.gsc;
+  const gsc = report.gsc;
+  const start = summary?.periodStart || gsc?.periodStart || gsc?.trend.at(0)?.date || "";
+  const end = summary?.periodEnd || gsc?.periodEnd || gsc?.trend.at(-1)?.date || "";
+  return formatDateRange(start, end);
+}
+function reportGscIntro(report) {
+  const dateRange = reportGscDateRange(report);
+  return `Search demand signals to compare against AI visibility${dateRange ? ` for ${dateRange}` : ""}.`;
+}
+function reportGaIntro(ga) {
+  return `Site traffic from ${formatDate(ga.periodStart)} to ${formatDate(ga.periodEnd)}.`;
+}
+function reportShareBarShareLabel(countLabel, sharePct) {
+  return `${countLabel} \xB7 ${sharePct}%`;
+}
+var SERVER_TRENDS_COPY = {
+  "server-activity": {
+    title: "AI Visibility \u2014 Server-Side",
+    client: {
+      eyebrow: "AI engine attention",
+      introNoData: "Live telemetry from your server logs.",
+      empty: "Your server-side traffic source is connected. Numbers will appear after the next sync.",
+      tiles: {
+        botRequests: "AI bot requests observed",
+        userFetches: "AI user-fetch requests",
+        referralSessions: "AI referral sessions"
+      },
+      userFetchFallback: "ChatGPT-User, Perplexity-User, MistralAI-User",
+      operatorsHeading: "By AI tool",
+      operatorsFootnote: "Bot requests are bulk crawl (GPTBot, PerplexityBot, \u2026). User fetches are on-demand reads triggered by real users inside an AI surface (ChatGPT-User, Perplexity-User, \u2026). Verified means the request came from an IP the operator publishes as its own; unverified means the user-agent matched but the IP is not in a published range. User-fetch totals count both, since many genuine user fetches come from outside any published range."
+    },
+    agency: {
+      eyebrow: "Section 10",
+      intro: "What AI engines actually do in your server logs \u2014 direct evidence, complementary to citations (which measure what they say).",
+      emptyNotConnected: "Connect a server-side traffic source to surface what AI engines do directly in your server logs \u2014 distinct from GA4 click-throughs.",
+      empty: "Source connected \u2014 collecting your first data. Numbers will appear after the next sync.",
+      operatorsHeading: "Per AI operator",
+      operatorsNote: "Verified means the request's source IP falls inside the operator's published range. Unverified bots claim the user-agent but the IP is not in a published range, so it could be the real bot or an imitator. User fetches are on-demand reads from an AI surface on behalf of a real user (ChatGPT-User, Perplexity-User, \u2026), disjoint from bulk crawl and counted whether or not the IP can be verified.",
+      noDelta: "\u2014",
+      crawledPathsHeading: "Top crawled paths",
+      crawledPathHeaders: ["Path", "Hits", "Verified", "Distinct operators"],
+      referralProductsHeading: "AI-referral sessions by product",
+      referralProductsNote: "Where humans landed coming from each AI product (chatgpt.com, claude.ai, \u2026).",
+      referralProductHeaders: ["Product", "Sessions", "Distinct landing paths"],
+      referralLandingHeading: "Top AI-referral landing paths",
+      referralLandingHeaders: ["Path", "Sessions", "Distinct products"]
+    },
+    /** The noun `formatDeltaCopy` puts after the prior-window count. */
+    countNouns: {
+      requests: "requests",
+      hits: "hits",
+      sessions: "sessions"
+    }
+  },
+  "indexing-health": {
+    eyebrow: "Section 11",
+    title: "Indexing Health",
+    empty: "Connect Google Search Console or Bing Webmaster Tools and run a sitemap inspection.",
+    tiles: {
+      indexed: "Indexed",
+      total: "Total inspected",
+      share: "Indexed share"
+    },
+    coverageHeading: "Coverage breakdown",
+    coverageLabel: "Coverage stacked bar",
+    segments: {
+      indexed: "Indexed",
+      notIndexed: "Not indexed",
+      deindexed: "Deindexed",
+      unknown: "Unknown"
+    }
+  },
+  "citations-trend": {
+    eyebrow: "Section 12",
+    title: "Citations Over Time",
+    intro: "Citation coverage across recent checks.",
+    empty: "Run multiple checks to see a trend.",
+    chartTitle: "Overall citation rate",
+    breakdownHeading: "Check-by-check breakdown",
+    breakdownHeaders: ["Check", "Cited queries", "Per-engine rates"]
+  }
+};
+function reportServerActivityHeading(audience, hasData, windowDays) {
+  const copy = SERVER_TRENDS_COPY["server-activity"];
+  const isClient = audience === CLIENT_AUDIENCE;
+  return {
+    id: ReportSectionIds["server-activity"],
+    eyebrow: isClient ? copy.client.eyebrow : copy.agency.eyebrow,
+    title: copy.title,
+    intro: isClient ? hasData ? `What AI engines actually do in your server logs over the last ${windowDays} days \u2014 the other half of citations.` : copy.client.introNoData : copy.agency.intro
+  };
+}
+function reportServerActivityWindowLabel(windowDays) {
+  return `${windowDays}d`;
+}
+function reportServerActivityClientOperatorHeaders(windowDays) {
+  const window = reportServerActivityWindowLabel(windowDays);
+  return ["AI tool", `Bot requests (${window})`, `User fetches (${window})`, "Referral sessions"];
+}
+function reportServerActivityAgencyTiles(windowDays) {
+  const window = reportServerActivityWindowLabel(windowDays);
+  return {
+    verified: `Verified crawler hits (${window})`,
+    unverified: `Unverified crawler hits (${window})`,
+    userFetches: `AI user-fetch hits (${window})`,
+    referralSessions: `AI-referral sessions (${window})`
+  };
+}
+function reportServerActivityAgencyOperatorHeaders(windowDays) {
+  return ["Operator", "Verified hits", "Unverified", "User fetches", "Referral sessions", `${reportServerActivityWindowLabel(windowDays)} delta`];
+}
+function reportServerActivityTrendTitle(windowDays) {
+  return `Verified crawler hits over time (last ${windowDays} days)`;
+}
+function reportServerActivityCrawledPathsNote(windowDays) {
+  return `Pages AI bots fetched most often (verified only, last ${reportServerActivityWindowLabel(windowDays)}).`;
+}
+function reportServerActivityOperatorDelta(deltaPct) {
+  if (deltaPct === null) return SERVER_TRENDS_COPY["server-activity"].agency.noDelta;
+  return `${deltaPct > 0 ? "+" : ""}${deltaPct}%`;
+}
+function reportServerActivityPathHits(path) {
+  return path.verifiedHits + path.unverifiedHits;
+}
+function reportCrawlerTrustSummary(verified, unverified) {
+  return `${formatNumber(verified)} verified \xB7 ${formatNumber(unverified)} unverified`;
+}
+function reportReferralRedirectNote(redirects) {
+  return redirects > 0 ? `${formatNumber(redirects)} blocked by redirects` : "";
+}
+function reportIndexingIntro(provider) {
+  return `Pages absent from ${provider === "google" ? "Google" : "Bing"} are harder for AI engines to retrieve.`;
+}
+function reportIndexingLegendLabel(label, count) {
+  return `${label}: ${count}`;
+}
+function reportCitationsTrendBaseline(pointCount) {
+  return `Building baseline (${pointCount} of ${MIN_TREND_POINTS} checks completed). Trend will appear once more checks are recorded.`;
+}
+function reportTrendProviderRates(rates) {
+  return rates.map((rate) => `${rate.provider}: ${rate.citationRate}%`).join(" \xB7 ");
+}
+var INSIGHTS_CONTENT_COPY = {
+  insights: {
+    eyebrow: "Section 13",
+    title: "Insights & Alerts",
+    intro: "Regressions, gains, and recurring alerts ordered by severity.",
+    empty: "No insights yet \u2014 run a check to generate alerts.",
+    headers: ["Severity", "Title", "Query", "Provider", "Recommendation"],
+    noRecommendation: "\u2014"
+  },
+  "content-opportunities": {
+    eyebrow: "Section 14",
+    title: "Content Opportunities",
+    intro: "Queries where content work has the clearest path to more AI citations. Opportunity score is 0\u2013100, higher = stronger. Winnability flags whether the cited surface is ownable or ceded to aggregators/editorial.",
+    headers: ["Query", "Action", "Winnability", "Score", "Why", "Our page", "Winning competitor", "Confidence"],
+    scoreSuffix: "/100",
+    scoreCardTooltip: "Opportunity score (0\u2013100, higher = stronger)",
+    scoreHeaderTooltip: "Opportunity score (0\u2013100)",
+    noDriverSignal: "No driver signal yet",
+    noPage: "No page yet",
+    noWinningCompetitor: "\u2014"
+  },
+  "content-gaps": {
+    eyebrow: "Section 15",
+    title: "Content Gaps",
+    intro: "Tracked queries where competitors are cited and the client is missing.",
+    headers: ["Query", "Competitors cited", "Domains", "Miss rate"]
+  }
+};
+function reportOpportunityActionLine(opportunity) {
+  return `${contentActionLabel(opportunity.action)} \xB7 ${actionConfidenceLabel(opportunity.actionConfidence)} confidence`;
+}
+function reportMissRateLabel(missRate) {
+  return formatWholePercent(missRate);
+}
+var REPORT_SECTION_COPY = {
+  ...SHARED_SECTION_COPY,
+  ...AGENCY_OVERVIEW_COPY,
+  ...COMPETITIVE_EVIDENCE_COPY,
+  ...SEARCH_TRAFFIC_COPY,
+  ...SERVER_TRENDS_COPY,
+  ...INSIGHTS_CONTENT_COPY
+};
+
+// ../contracts/src/operational-logs.ts
+import { z as z62 } from "zod";
+var operationalLogLevelSchema = z62.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
+var diagnosticContextSchema = z62.object({
+  runId: z62.string().min(1).max(256).optional(),
+  projectId: z62.string().min(1).max(256).optional(),
+  requestId: z62.string().min(1).max(256).optional(),
+  actor: z62.string().min(1).max(512).optional(),
+  credentialId: z62.string().min(1).max(512).optional(),
+  userAgent: z62.string().min(1).max(512).optional(),
+  actorSession: z62.string().min(1).max(512).optional(),
+  method: z62.string().min(1).max(16).optional(),
+  route: z62.string().min(1).max(256).optional(),
+  operationId: z62.string().min(1).max(256).optional(),
+  jobId: z62.string().min(1).max(256).optional(),
+  taskId: z62.string().min(1).max(256).optional(),
+  traceId: z62.string().min(1).max(256).optional(),
+  errorCode: z62.string().min(1).max(128).optional(),
+  attempt: z62.number().finite().optional(),
+  count: z62.number().finite().optional(),
+  total: z62.number().finite().optional(),
+  progress: z62.number().finite().optional(),
+  httpStatus: z62.number().finite().optional(),
+  statusCode: z62.number().finite().optional(),
+  durationMs: z62.number().finite().optional(),
+  bytes: z62.number().finite().optional(),
+  retryAfterMs: z62.number().finite().optional(),
+  retriable: z62.boolean().optional(),
+  retrying: z62.boolean().optional(),
+  cancelled: z62.boolean().optional(),
+  success: z62.boolean().optional()
+}).strict();
+var operationalLogEntryDtoSchema = z62.object({
+  cursor: z62.string().min(1).max(512),
+  ts: z62.string().datetime(),
   level: operationalLogLevelSchema,
-  module: z61.string().min(1).max(256),
-  action: z61.string().min(1).max(256),
-  message: z61.string().max(4096).optional(),
-  runId: z61.string().min(1).max(256).optional(),
-  projectId: z61.string().min(1).max(256).optional(),
+  module: z62.string().min(1).max(256),
+  action: z62.string().min(1).max(256),
+  message: z62.string().max(4096).optional(),
+  runId: z62.string().min(1).max(256).optional(),
+  projectId: z62.string().min(1).max(256).optional(),
   context: diagnosticContextSchema
 }).strict();
-var logQuerySchema = z61.object({
+var logQuerySchema = z62.object({
   level: operationalLogLevelSchema.optional(),
-  module: z61.string().trim().min(1).max(256).optional(),
-  runId: z61.string().trim().min(1).max(256).optional(),
-  projectId: z61.string().trim().min(1).max(256).optional(),
-  actor: z61.string().trim().min(1).max(512).optional(),
-  requestId: z61.string().trim().min(1).max(256).optional(),
-  since: z61.string().datetime().optional(),
-  until: z61.string().datetime().optional(),
-  limit: z61.coerce.number().int().min(1).max(200).default(100),
-  cursor: z61.string().trim().min(1).max(512).optional()
+  module: z62.string().trim().min(1).max(256).optional(),
+  runId: z62.string().trim().min(1).max(256).optional(),
+  projectId: z62.string().trim().min(1).max(256).optional(),
+  actor: z62.string().trim().min(1).max(512).optional(),
+  requestId: z62.string().trim().min(1).max(256).optional(),
+  since: z62.string().datetime().optional(),
+  until: z62.string().datetime().optional(),
+  limit: z62.coerce.number().int().min(1).max(200).default(100),
+  cursor: z62.string().trim().min(1).max(512).optional()
 }).strict().superRefine((query, ctx) => {
   if (query.since && query.until && Date.parse(query.since) > Date.parse(query.until)) {
-    ctx.addIssue({ code: z61.ZodIssueCode.custom, path: ["until"], message: '"until" must be on or after "since".' });
+    ctx.addIssue({ code: z62.ZodIssueCode.custom, path: ["until"], message: '"until" must be on or after "since".' });
   }
 });
-var operationalLogListDtoSchema = z61.object({
-  entries: z61.array(operationalLogEntryDtoSchema),
-  nextCursor: z61.string().min(1).max(512).nullable(),
+var operationalLogListDtoSchema = z62.object({
+  entries: z62.array(operationalLogEntryDtoSchema),
+  nextCursor: z62.string().min(1).max(512).nullable(),
   /** Matching entries left after this page. */
-  truncated: z61.number().int().nonnegative(),
+  truncated: z62.number().int().nonnegative(),
   /** Entries evicted by the active retention policy. */
-  dropped: z61.number().int().nonnegative(),
-  retention: z61.enum(["process", "durable"]),
-  retentionPolicy: z61.object({
-    maxEntries: z61.number().int().positive(),
-    maxAgeSeconds: z61.number().int().positive()
+  dropped: z62.number().int().nonnegative(),
+  retention: z62.enum(["process", "durable"]),
+  retentionPolicy: z62.object({
+    maxEntries: z62.number().int().positive(),
+    maxAgeSeconds: z62.number().int().positive()
   }).strict().optional(),
   /** Best-effort persistence failures observed by this store. */
-  captureErrors: z61.number().int().nonnegative().optional(),
-  observedAt: z61.string().datetime()
+  captureErrors: z62.number().int().nonnegative().optional(),
+  observedAt: z62.string().datetime()
 }).strict();
 
 // ../contracts/src/log-redaction.ts
@@ -18212,6 +19109,8 @@ export {
   gaMeasurementHostScopeSchema,
   gaMeasurementAnalysisDtoSchema,
   absolutizeProjectUrl,
+  safeLinkHref,
+  describeLandingPage,
   hostOf,
   registrableDomain,
   brandLabelFromDomain,
@@ -18303,6 +19202,7 @@ export {
   visibilityReportRequestSchema,
   visibilityReportQuerySchema,
   visibilityReportResponseSchema,
+  VisibilityReportScopeErrorReasons,
   expandQueryTemplate,
   queryTrackingProvenanceSchema,
   queryTrackingPreviewRequestSchema,
@@ -18399,6 +19299,7 @@ export {
   measurementDraftApplyGroupMembershipRequestSchema,
   measurementDraftApplyGroupMembershipResponseSchema,
   formatRatio,
+  formatWholePercent,
   formatNumber,
   formatDate,
   formatIsoDate,
@@ -18408,13 +19309,11 @@ export {
   shiftIsoCalendarDate,
   isoDateDaysBeforeInTimeZone,
   startOfDayHourInTimeZone,
-  formatDateRange,
   parseInclusiveEndMs,
   relativeChangeRatio,
   deltaPercent,
   deltaTone,
   formatDeltaCopy,
-  formatAverageDelta,
   formatWindowCountDelta,
   compactDateToIso,
   parseBoundedRate,
@@ -18767,14 +19666,14 @@ export {
   parseReportPeriodDays,
   reportComparisonWindowDays,
   reportActionTone,
+  reportPressureTone,
+  reportInsightTone,
+  reportSourceCategoryTone,
   reportSeverityLabel,
-  reportHorizonLabel,
   reportActionCategoryLabel,
-  reportConfidenceLabel,
   projectReportDtoSchema,
   organicEvidencePeriodSchema,
   organicEvidenceDtoSchema,
-  dedupeReportActions,
   dedupeReportOpportunities,
   CodingAgents,
   agentPluginClientLabel,
@@ -18946,6 +19845,64 @@ export {
   detectAgentRuntime,
   MIN_TREND_POINTS,
   isTrendBaseline,
+  ReportSectionIds,
+  reportProviderDisplayName,
+  REPORT_HEADER_COPY,
+  reportHeaderMarketLabel,
+  reportHeaderPeriodLabel,
+  reportCompactList,
+  reportTruncatedList,
+  reportMoreChipLabel,
+  reportInstanceCountLabel,
+  reportBarChartLabel,
+  reportLineChartLabel,
+  reportDeltaArrow,
+  reportDirectionTone,
+  reportRateDeltaCopy,
+  reportMovementChangeCopy,
+  reportPriorWindowLabel,
+  reportClientTrendCopy,
+  reportClientHeroSentence,
+  reportClientMentionedSubtitle,
+  reportClientCitedSubtitle,
+  reportClientProvidersSubtitle,
+  reportClientQueriesSubtitle,
+  reportAudienceActions,
+  reportActionHorizonBadge,
+  reportActionConfidenceBadge,
+  reportClientSourceCount,
+  reportClientIndexedPages,
+  reportClientNotIndexedTail,
+  reportClientClicksNoun,
+  reportClientSearchCount,
+  reportClientIndexingTone,
+  reportExecutiveHeadline,
+  reportMarketScope,
+  reportProviderRateLabel,
+  reportCompetitorMentionCopy,
+  reportCitedUrlCount,
+  reportSourceOriginHeadline,
+  reportSourceCategoryShareLabel,
+  reportGscIntro,
+  reportGaIntro,
+  reportShareBarShareLabel,
+  reportServerActivityHeading,
+  reportServerActivityClientOperatorHeaders,
+  reportServerActivityAgencyTiles,
+  reportServerActivityAgencyOperatorHeaders,
+  reportServerActivityTrendTitle,
+  reportServerActivityCrawledPathsNote,
+  reportServerActivityOperatorDelta,
+  reportServerActivityPathHits,
+  reportCrawlerTrustSummary,
+  reportReferralRedirectNote,
+  reportIndexingIntro,
+  reportIndexingLegendLabel,
+  reportCitationsTrendBaseline,
+  reportTrendProviderRates,
+  reportOpportunityActionLine,
+  reportMissRateLabel,
+  REPORT_SECTION_COPY,
   operationalLogEntryDtoSchema,
   logQuerySchema,
   operationalLogListDtoSchema,