@canonry/canonry 7.92.1 → 7.94.0

package/dist/{chunk-FYYOX7UY.js → chunk-NSUB2S4V.js}

@@ -17165,7 +17165,7 @@ var resultsClearResponseSchema = z47.object({
 });
 
 // ../contracts/src/ga.ts
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 
 // ../contracts/src/traffic-class.ts
 import { z as z48 } from "zod";
@@ -17370,29 +17370,131 @@ function buildStackedDailySeries(points, options) {
   return { series, otherCount: folded.length, days };
 }
 
+// ../contracts/src/statistics.ts
+import { z as z51 } from "zod";
+function round(value, dp = 4) {
+  const f = 10 ** dp;
+  return (Math.round(value * f) + 0) / f;
+}
+function roundSignificant(value, sig = 6) {
+  if (!Number.isFinite(value) || value === 0) return 0;
+  const magnitude = Math.ceil(Math.log10(Math.abs(value)));
+  const factor = 10 ** (sig - magnitude);
+  return (Math.round(value * factor) + 0) / factor;
+}
+function shareOf(part, total) {
+  if (!Number.isFinite(part) || !Number.isFinite(total)) return null;
+  if (part <= 0) return 0;
+  return total > 0 ? part / total : null;
+}
+function breakdownShares(parts) {
+  const total = parts.reduce((sum, part) => sum + Math.max(0, part), 0);
+  return parts.map((part) => shareOf(part, total) ?? 0);
+}
+function median(values) {
+  const sorted = values.filter((value) => Number.isFinite(value)).sort((left, right) => left - right);
+  if (sorted.length === 0) return null;
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+}
+function wilsonInterval(successes, n, z97 = 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 = z97 * z97;
+  const denom = 1 + z210 / n;
+  const center = (p + z210 / (2 * n)) / denom;
+  const margin = z97 / 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))
+  };
+}
+var linearTrendSchema = z51.object({
+  /** Change in the fitted value per one-index step. */
+  slope: z51.number(),
+  /** Fitted value at index 0. */
+  intercept: z51.number(),
+  /** Coefficient of determination in [0, 1]. `1` for a series with no variance. */
+  r2: z51.number(),
+  /** Fitted value at the first index. */
+  start: z51.number(),
+  /** Fitted value at the last index. */
+  end: z51.number(),
+  /** Count of finite observations the fit used (not the series length). */
+  n: z51.number(),
+  /**
+   * Index of the first observation the fit used, and of the last.
+   *
+   * `start` / `end` are evaluated AT these indices, not at the series' own ends.
+   * A caller drawing the line must span exactly this range: extending it across
+   * leading or trailing indices the metric has no data for draws a fitted claim
+   * over dates that were never measured.
+   */
+  startIndex: z51.number(),
+  endIndex: z51.number()
+});
+function linearTrend(values) {
+  const points = [];
+  for (const [index, value] of values.entries()) {
+    if (typeof value === "number" && Number.isFinite(value)) points.push({ x: index, y: value });
+  }
+  const n = points.length;
+  if (n < 2) return null;
+  const meanX = points.reduce((sum, p) => sum + p.x, 0) / n;
+  const meanY = points.reduce((sum, p) => sum + p.y, 0) / n;
+  let sxx = 0;
+  let sxy = 0;
+  for (const p of points) {
+    sxx += (p.x - meanX) ** 2;
+    sxy += (p.x - meanX) * (p.y - meanY);
+  }
+  const slope = sxy / sxx;
+  const intercept = meanY - slope * meanX;
+  let ssRes = 0;
+  let ssTot = 0;
+  for (const p of points) {
+    ssRes += (p.y - (slope * p.x + intercept)) ** 2;
+    ssTot += (p.y - meanY) ** 2;
+  }
+  const r2 = ssTot === 0 ? 1 : Math.min(1, Math.max(0, 1 - ssRes / ssTot));
+  const firstX = points[0].x;
+  const lastX = points[n - 1].x;
+  return {
+    slope: roundSignificant(slope),
+    intercept: roundSignificant(intercept),
+    r2: round(r2),
+    start: roundSignificant(slope * firstX + intercept),
+    end: roundSignificant(slope * lastX + intercept),
+    n,
+    startIndex: firstX,
+    endIndex: lastX
+  };
+}
+
 // ../contracts/src/ga.ts
-var ga4ConnectionDtoSchema = z51.object({
-  id: z51.string(),
-  projectId: z51.string(),
-  propertyId: z51.string(),
-  clientEmail: z51.string(),
-  connected: z51.boolean(),
-  createdAt: z51.string(),
-  updatedAt: z51.string()
-});
-var ga4TrafficSnapshotDtoSchema = z51.object({
-  date: z51.string(),
-  landingPage: z51.string(),
-  sessions: z51.number(),
-  organicSessions: z51.number(),
-  users: z51.number()
-});
-var ga4SourceDimensionSchema = z51.enum(["session", "first_user", "manual_utm"]);
-var ga4AiReferralDtoSchema = z51.object({
-  source: z51.string(),
-  medium: z51.string(),
+var ga4ConnectionDtoSchema = z52.object({
+  id: z52.string(),
+  projectId: z52.string(),
+  propertyId: z52.string(),
+  clientEmail: z52.string(),
+  connected: z52.boolean(),
+  createdAt: z52.string(),
+  updatedAt: z52.string()
+});
+var ga4TrafficSnapshotDtoSchema = z52.object({
+  date: z52.string(),
+  landingPage: z52.string(),
+  sessions: z52.number(),
+  organicSessions: z52.number(),
+  users: z52.number()
+});
+var ga4SourceDimensionSchema = z52.enum(["session", "first_user", "manual_utm"]);
+var ga4AiReferralDtoSchema = z52.object({
+  source: z52.string(),
+  medium: z52.string(),
   trafficClass: aiReferralTrafficClassSchema,
-  sessions: z51.number(),
+  sessions: z52.number(),
   /**
    * @deprecated Never emitted since 4.135.0. Removed in the next major.
    *
@@ -17407,7 +17509,7 @@ var ga4AiReferralDtoSchema = z51.object({
    * number. Sessions are unaffected: GA4 attributes exactly one landing page
    * per session, so the landing-page rows partition the day and do sum.
    */
-  users: z51.number().optional(),
+  users: z52.number().optional(),
   /**
    * The winning attribution dimension for this (source, medium) tuple — the
    * one with the highest session count. GA4 emits one row per dimension
@@ -17425,33 +17527,33 @@ var ga4AiReferralDtoSchema = z51.object({
    */
   share: fraction()
 });
-var ga4AiReferralLandingPageDtoSchema = z51.object({
-  source: z51.string(),
-  medium: z51.string(),
+var ga4AiReferralLandingPageDtoSchema = z52.object({
+  source: z52.string(),
+  medium: z52.string(),
   trafficClass: aiReferralTrafficClassSchema,
   /**
    * The winning attribution dimension for this (source, medium, landingPage)
    * tuple — the one with the highest session count.
    */
   sourceDimension: ga4SourceDimensionSchema,
-  landingPage: z51.string(),
-  sessions: z51.number(),
+  landingPage: z52.string(),
+  sessions: z52.number(),
   /** @deprecated See `GA4AiReferralDto.users`. Never emitted since 4.135.0. */
-  users: z51.number().optional()
+  users: z52.number().optional()
 });
-var ga4SocialReferralDtoSchema = z51.object({
-  source: z51.string(),
-  medium: z51.string(),
-  sessions: z51.number(),
+var ga4SocialReferralDtoSchema = z52.object({
+  source: z52.string(),
+  medium: z52.string(),
+  sessions: z52.number(),
   /**
    * @deprecated Never emitted by `/ga/traffic`. ga_social_referrals stores
    * users as GA's COUNT DISTINCT at (date, source, medium, channel group), so
    * summing it across the window counts a returning visitor once per day.
    * Optional so existing consumers keep parsing.
    */
-  users: z51.number().optional(),
+  users: z52.number().optional(),
   /** GA4 default channel group (e.g. 'Organic Social', 'Paid Social') */
-  channelGroup: z51.string(),
+  channelGroup: z52.string(),
   /**
    * This row's sessions as a 0..1 share of the window's social sessions
    * (`socialSessions`, which is the sum of these rows), so the rows' shares add
@@ -17459,51 +17561,51 @@ var ga4SocialReferralDtoSchema = z51.object({
    */
   share: fraction()
 });
-var ga4SocialPlatformDtoSchema = z51.object({
+var ga4SocialPlatformDtoSchema = z52.object({
   /** Platform id from `socialPlatformForReferralSource`; null for a source no platform matches. */
   platform: socialPlatformSchema.nullable(),
   /** The platform's name, or the raw source when `platform` is null. */
-  label: z51.string(),
-  sessions: z51.number(),
+  label: z52.string(),
+  sessions: z52.number(),
   /** Sessions outside GA4's Paid Social channel group. */
-  organicSessions: z51.number(),
+  organicSessions: z52.number(),
   /** Sessions in GA4's Paid Social channel group. */
-  paidSessions: z51.number(),
+  paidSessions: z52.number(),
   /** 0..1 share of `socialSessions`; the groups' shares add up to 1. */
   share: fraction(),
   /** The grouped `socialReferrals` rows, sessions descending. */
-  sources: z51.array(ga4SocialReferralDtoSchema)
+  sources: z52.array(ga4SocialReferralDtoSchema)
 });
-var ga4AiEngineReferralDtoSchema = z51.object({
+var ga4AiEngineReferralDtoSchema = z52.object({
   /** Engine id from `aiEngineForReferralSource`; null for the unattributed group. */
   engine: aiReferralEngineSchema.nullable(),
   /** The engine's name, or `Unattributed AI`. */
-  label: z51.string(),
-  sessions: z51.number(),
-  organicSessions: z51.number(),
-  paidSessions: z51.number(),
+  label: z52.string(),
+  sessions: z52.number(),
+  organicSessions: z52.number(),
+  paidSessions: z52.number(),
   /** 0..1 share of the `aiReferrals` rows' sessions, the same base as each row's `share`. */
   share: fraction(),
   /** The grouped `aiReferrals` rows, sessions descending. */
-  sources: z51.array(ga4AiReferralDtoSchema)
+  sources: z52.array(ga4AiReferralDtoSchema)
 });
-var ga4ChannelBucketDtoSchema = z51.object({
-  sessions: z51.number(),
+var ga4ChannelBucketDtoSchema = z52.object({
+  sessions: z52.number(),
   sharePct: percent(),
-  sharePctDisplay: z51.string()
+  sharePctDisplay: z52.string()
 });
-var ga4ChannelBreakdownDtoSchema = z51.object({
+var ga4ChannelBreakdownDtoSchema = z52.object({
   organic: ga4ChannelBucketDtoSchema,
   social: ga4ChannelBucketDtoSchema,
   direct: ga4ChannelBucketDtoSchema,
   ai: ga4ChannelBucketDtoSchema,
   other: ga4ChannelBucketDtoSchema
 });
-var ga4TrafficSummaryDtoSchema = z51.object({
-  totalSessions: z51.number(),
-  totalOrganicSessions: z51.number(),
+var ga4TrafficSummaryDtoSchema = z52.object({
+  totalSessions: z52.number(),
+  totalOrganicSessions: z52.number(),
   /** Direct-channel sessions (sessions with no source — bookmarks, typed URLs, AI-driven traffic with stripped referrer). 0 for legacy rows from before the column was added. */
-  totalDirectSessions: z51.number(),
+  totalDirectSessions: z52.number(),
   /**
    * Null when the range has no un-dimensioned aggregate behind it.
    *
@@ -17512,14 +17614,14 @@ var ga4TrafficSummaryDtoSchema = z51.object({
    * windows have a precomputed deduplicated row; an explicit calendar range does
    * not, and reports the figure as unavailable rather than as an inflated sum.
    */
-  totalUsers: z51.number().nullable(),
-  topPages: z51.array(z51.object({
-    landingPage: z51.string(),
-    sessions: z51.number(),
-    organicSessions: z51.number(),
+  totalUsers: z52.number().nullable(),
+  topPages: z52.array(z52.object({
+    landingPage: z52.string(),
+    sessions: z52.number(),
+    organicSessions: z52.number(),
     /** Per-page Direct-channel sessions. 0 for legacy rows. */
-    directSessions: z51.number(),
-    users: z51.number(),
+    directSessions: z52.number(),
+    users: z52.number(),
     /**
      * Organic search sessions as a 0..1 share of this page's sessions. 0 when
      * the page has no organic sessions; null when organic sessions exist with
@@ -17527,49 +17629,49 @@ var ga4TrafficSummaryDtoSchema = z51.object({
      */
     organicShare: fraction().nullable()
   })),
-  aiReferrals: z51.array(ga4AiReferralDtoSchema),
-  aiReferralLandingPages: z51.array(ga4AiReferralLandingPageDtoSchema),
+  aiReferrals: z52.array(ga4AiReferralDtoSchema),
+  aiReferralLandingPages: z52.array(ga4AiReferralLandingPageDtoSchema),
   /** Deduped AI session total: MAX(sessions) per date+source across attribution dimensions, then summed. Cross-cutting: can overlap with Direct/Organic/Social via firstUserSource. */
-  aiSessionsDeduped: z51.number(),
+  aiSessionsDeduped: z52.number(),
   /** @deprecated See `GA4AiReferralDto.users`. Never emitted since 4.135.0. */
-  aiUsersDeduped: z51.number().optional(),
+  aiUsersDeduped: z52.number().optional(),
   /** Deduped AI sessions whose attribution carries paid intent. */
-  paidAiSessionsDeduped: z51.number(),
+  paidAiSessionsDeduped: z52.number(),
   /** @deprecated See `GA4AiReferralDto.users`. Never emitted since 4.135.0. */
-  paidAiUsersDeduped: z51.number().optional(),
+  paidAiUsersDeduped: z52.number().optional(),
   /** Deduped AI sessions without paid intent evidence. */
-  organicAiSessionsDeduped: z51.number(),
+  organicAiSessionsDeduped: z52.number(),
   /** @deprecated See `GA4AiReferralDto.users`. Never emitted since 4.135.0. */
-  organicAiUsersDeduped: z51.number().optional(),
+  organicAiUsersDeduped: z52.number().optional(),
   /** AI sessions whose CURRENT sessionSource matched an AI engine. Can overlap with raw Organic/Social/Direct totals; `channelBreakdown` removes those overlaps for display. */
-  aiSessionsBySession: z51.number(),
+  aiSessionsBySession: z52.number(),
   /** @deprecated See `GA4AiReferralDto.users`. Never emitted since 4.135.0. */
-  aiUsersBySession: z51.number().optional(),
+  aiUsersBySession: z52.number().optional(),
   /** Session-source-only paid AI sessions. */
-  paidAiSessionsBySession: z51.number(),
+  paidAiSessionsBySession: z52.number(),
   /** @deprecated See `GA4AiReferralDto.users`. Never emitted since 4.135.0. */
-  paidAiUsersBySession: z51.number().optional(),
+  paidAiUsersBySession: z52.number().optional(),
   /** Session-source-only organic/non-paid AI sessions. */
-  organicAiSessionsBySession: z51.number(),
+  organicAiSessionsBySession: z52.number(),
   /** @deprecated See `GA4AiReferralDto.users`. Never emitted since 4.135.0. */
-  organicAiUsersBySession: z51.number().optional(),
+  organicAiUsersBySession: z52.number().optional(),
   /**
    * `aiReferrals` grouped by engine, sessions descending, with the unattributed
    * group last. The groups' sessions add up to the rows' sessions.
    */
-  aiEngines: z51.array(ga4AiEngineReferralDtoSchema),
-  socialReferrals: z51.array(ga4SocialReferralDtoSchema),
+  aiEngines: z52.array(ga4AiEngineReferralDtoSchema),
+  socialReferrals: z52.array(ga4SocialReferralDtoSchema),
   /** `socialReferrals` grouped by platform, sessions descending; the groups' sessions add up to `socialSessions`. */
-  socialPlatforms: z51.array(ga4SocialPlatformDtoSchema),
+  socialPlatforms: z52.array(ga4SocialPlatformDtoSchema),
   /**
    * Daily social sessions by platform over the same window as every other
    * figure here: the five largest platforms, then the rest as `other`.
    */
   socialPlatformDaily: stackedDailySeriesSchema,
   /** Total social sessions (session-scoped, no cross-dimension dedup needed). */
-  socialSessions: z51.number(),
+  socialSessions: z52.number(),
   /** Social sessions in GA4's Paid Social channel group. */
-  paidSocialSessions: z51.number(),
+  paidSocialSessions: z52.number(),
   /** `paidSocialSessions` as a 0..1 share of `socialSessions`; 0 with no social sessions. */
   paidSocialShare: fraction(),
   /** Total social users (session-scoped, no cross-dimension dedup needed). */
@@ -17578,7 +17680,7 @@ var ga4TrafficSummaryDtoSchema = z51.object({
    * COUNT DISTINCT at (date, source, medium, channel group), so summing it
    * across the window counts a returning visitor once per day.
    */
-  socialUsers: z51.number().optional(),
+  socialUsers: z52.number().optional(),
   /** Five disjoint buckets used for the channel breakdown. Known AI session-source matches are removed from their native GA4 bucket before shares are computed. */
   channelBreakdown: ga4ChannelBreakdownDtoSchema,
   /** Organic sessions as a percentage of total sessions (0–100, at wire precision). */
@@ -17600,50 +17702,50 @@ var ga4TrafficSummaryDtoSchema = z51.object({
   /** Social sessions as a percentage of total sessions (0–100, at wire precision). */
   socialSharePct: percent(),
   /** Display string for organicSharePct: the unrounded share through formatPercent ('12.5%', '<0.1%' for a non-zero share below one decimal), '0%' with no sessions, or '—' when sessions exist but total is unknown (partial sync). */
-  organicSharePctDisplay: z51.string(),
+  organicSharePctDisplay: z52.string(),
   /** Display string for aiSharePct: the unrounded share through formatPercent ('12.5%', '<0.1%' for a non-zero share below one decimal), '0%' with no sessions, or '—' when sessions exist but total is unknown (partial sync). */
-  aiSharePctDisplay: z51.string(),
+  aiSharePctDisplay: z52.string(),
   /** Display string for aiSharePctBySession: the unrounded share through formatPercent ('12.5%', '<0.1%' for a non-zero share below one decimal), '0%' with no sessions, or '—' when sessions exist but total is unknown (partial sync). */
-  aiSharePctBySessionDisplay: z51.string(),
+  aiSharePctBySessionDisplay: z52.string(),
   /** Display string for paidAiSharePct. */
-  paidAiSharePctDisplay: z51.string(),
+  paidAiSharePctDisplay: z52.string(),
   /** Display string for paidAiSharePctBySession. */
-  paidAiSharePctBySessionDisplay: z51.string(),
+  paidAiSharePctBySessionDisplay: z52.string(),
   /** Display string for organicAiSharePct. */
-  organicAiSharePctDisplay: z51.string(),
+  organicAiSharePctDisplay: z52.string(),
   /** Display string for organicAiSharePctBySession. */
-  organicAiSharePctBySessionDisplay: z51.string(),
+  organicAiSharePctBySessionDisplay: z52.string(),
   /** Display string for directSharePct: the unrounded share through formatPercent ('12.5%', '<0.1%' for a non-zero share below one decimal), '0%' with no sessions, or '—' when sessions exist but total is unknown (partial sync). */
-  directSharePctDisplay: z51.string(),
+  directSharePctDisplay: z52.string(),
   /** Display string for socialSharePct: the unrounded share through formatPercent ('12.5%', '<0.1%' for a non-zero share below one decimal), '0%' with no sessions, or '—' when sessions exist but total is unknown (partial sync). */
-  socialSharePctDisplay: z51.string(),
+  socialSharePctDisplay: z52.string(),
   /** Sessions not covered by Organic, Social, Direct, or AI (session) channels — e.g. Referral, Email, Paid Search, Display. Always non-negative; clamped to 0 when the four disjoint channels sum above total (rounding edge). */
-  otherSessions: z51.number(),
+  otherSessions: z52.number(),
   /** Other sessions as a percentage of total sessions (0–100, at wire precision). */
   otherSharePct: percent(),
   /** Display string for otherSharePct: the unrounded share through formatPercent ('12.5%', '<0.1%' for a non-zero share below one decimal), '0%' with no sessions, or '—' when sessions exist but total is unknown (partial sync). */
-  otherSharePctDisplay: z51.string(),
-  lastSyncedAt: z51.string().nullable()
-});
-var ga4StatusDtoSchema = z51.object({
-  connected: z51.boolean(),
-  propertyId: z51.string().nullable(),
-  clientEmail: z51.string().nullable(),
-  authMethod: z51.enum(["service-account", "oauth"]).nullable(),
-  lastSyncedAt: z51.string().nullable(),
-  createdAt: z51.string().nullable().optional(),
-  updatedAt: z51.string().nullable().optional()
-});
-var ga4PropertySummaryDtoSchema = z51.object({
-  propertyId: z51.string(),
-  displayName: z51.string(),
+  otherSharePctDisplay: z52.string(),
+  lastSyncedAt: z52.string().nullable()
+});
+var ga4StatusDtoSchema = z52.object({
+  connected: z52.boolean(),
+  propertyId: z52.string().nullable(),
+  clientEmail: z52.string().nullable(),
+  authMethod: z52.enum(["service-account", "oauth"]).nullable(),
+  lastSyncedAt: z52.string().nullable(),
+  createdAt: z52.string().nullable().optional(),
+  updatedAt: z52.string().nullable().optional()
+});
+var ga4PropertySummaryDtoSchema = z52.object({
+  propertyId: z52.string(),
+  displayName: z52.string(),
   /** GA4 account that owns the property. Two accounts can hold like-named properties. */
-  accountName: z51.string()
+  accountName: z52.string()
 });
-var ga4PropertiesDtoSchema = z51.object({
-  properties: z51.array(ga4PropertySummaryDtoSchema)
+var ga4PropertiesDtoSchema = z52.object({
+  properties: z52.array(ga4PropertySummaryDtoSchema)
 });
-var gaSearchLandingWindowSchema = z51.enum(WINDOW_SETS.gaSearchLanding);
+var gaSearchLandingWindowSchema = z52.enum(WINDOW_SETS.gaSearchLanding);
 var GA_SEARCH_LANDING_WINDOWS = gaSearchLandingWindowSchema.options;
 var GA_SEARCH_LANDING_WINDOW_DAYS = {
   "7d": 7,
@@ -17657,124 +17759,124 @@ function gaSearchLandingPageLabel(landingPage) {
   return landingPage === "" ? GA_SEARCH_LANDING_EMPTY_PAGE_LABEL : landingPage;
 }
 var GA_SEARCH_LANDING_MAX_LIMIT = 1e3;
-var gaSearchLandingStatusSchema = z51.enum(["never-synced", "ready", "unavailable", "error"]);
-var gaSearchLandingMetricsSchema = z51.object({
-  organicGoogleSearchClicks: z51.number().int().nonnegative(),
-  organicGoogleSearchImpressions: z51.number().int().nonnegative(),
+var gaSearchLandingStatusSchema = z52.enum(["never-synced", "ready", "unavailable", "error"]);
+var gaSearchLandingMetricsSchema = z52.object({
+  organicGoogleSearchClicks: z52.number().int().nonnegative(),
+  organicGoogleSearchImpressions: z52.number().int().nonnegative(),
   /** GA4's own click-through rate (0..1). Null when there were no impressions. */
-  organicGoogleSearchClickThroughRate: fraction(z51.number().min(0).max(1)).nullable(),
+  organicGoogleSearchClickThroughRate: fraction(z52.number().min(0).max(1)).nullable(),
   /** GA4's own average position. Null when there were no impressions. */
-  organicGoogleSearchAveragePosition: z51.number().nonnegative().nullable(),
+  organicGoogleSearchAveragePosition: z52.number().nonnegative().nullable(),
   /**
    * GA4's plain `activeUsers` from the same request, which is what GA4's own
    * report shows in this column (verified against the GA4 UI). Not limited to
    * Google organic sessions.
    */
-  activeUsers: z51.number().int().nonnegative()
+  activeUsers: z52.number().int().nonnegative()
 });
 var gaSearchLandingPageRowSchema = gaSearchLandingMetricsSchema.extend({
   /** GA4's `landingPagePlusQueryString`, exactly as reported (never normalized). */
-  landingPage: z51.string()
+  landingPage: z52.string()
 });
-var gaSearchConsoleLinkStateSchema = z51.enum(["has-data", "not-linked", "no-search-data", "unknown"]);
-var gaSearchLandingPagesResponseSchema = z51.object({
-  source: z51.literal("ga4-search-console-link"),
+var gaSearchConsoleLinkStateSchema = z52.enum(["has-data", "not-linked", "no-search-data", "unknown"]);
+var gaSearchLandingPagesResponseSchema = z52.object({
+  source: z52.literal("ga4-search-console-link"),
   status: gaSearchLandingStatusSchema,
   /** The last failed attempt's message (Google's own text for `unavailable`). */
-  error: z51.string().nullable(),
+  error: z52.string().nullable(),
   /** When the stored snapshot was written. Null when none exists. */
-  syncedAt: z51.string().datetime().nullable(),
+  syncedAt: z52.string().datetime().nullable(),
   /** When a sync last tried to refresh the snapshot, successful or not. */
-  attemptedAt: z51.string().datetime().nullable(),
+  attemptedAt: z52.string().datetime().nullable(),
   window: gaSearchLandingWindowSchema,
   /** Inclusive first day of the stored window, in the property's time zone. */
-  windowStart: z51.iso.date().nullable(),
+  windowStart: z52.iso.date().nullable(),
   /** Inclusive last day of the stored window (yesterday at sync time). */
-  windowEnd: z51.iso.date().nullable(),
-  windowDays: z51.number().int().positive().nullable(),
+  windowEnd: z52.iso.date().nullable(),
+  windowDays: z52.number().int().positive().nullable(),
   /** GA4 property reporting time zone the window dates are in. */
-  timeZone: z51.string().nullable(),
-  subjectToThresholding: z51.boolean(),
-  dataLossFromOtherRow: z51.boolean(),
+  timeZone: z52.string().nullable(),
+  subjectToThresholding: z52.boolean(),
+  dataLossFromOtherRow: z52.boolean(),
   /** GA4's own TOTAL row for the window. Never a sum of `rows`. Null when no snapshot exists. */
   total: gaSearchLandingMetricsSchema.nullable(),
   /** Rows GA4 reported for the window. Can exceed `totalRows` when `rowsCapped`. */
-  reportRowCount: z51.number().int().nonnegative().nullable(),
+  reportRowCount: z52.number().int().nonnegative().nullable(),
   /** True when GA4 reported more rows than were stored (the per-window row cap). */
-  rowsCapped: z51.boolean(),
+  rowsCapped: z52.boolean(),
   /** Stored rows for the window, the population `limit` / `offset` page over. */
-  totalRows: z51.number().int().nonnegative(),
-  limit: z51.number().int().positive(),
-  offset: z51.number().int().nonnegative(),
+  totalRows: z52.number().int().nonnegative(),
+  limit: z52.number().int().positive(),
+  offset: z52.number().int().nonnegative(),
   /** Ordered by clicks, then impressions (both descending), then landing page. */
-  rows: z51.array(gaSearchLandingPageRowSchema),
+  rows: z52.array(gaSearchLandingPageRowSchema),
   /**
    * Whether the window's GA4 report has Search Console data, compared with
    * Canonry's own Search Console data for the same days. Null when no window
    * is stored.
    */
-  searchConsoleLink: z51.object({
+  searchConsoleLink: z52.object({
     state: gaSearchConsoleLinkStateSchema,
     /** Search Console impressions Canonry stores for the window's days; null when it has none for them. */
-    searchConsoleImpressions: z51.number().int().nonnegative().nullable()
+    searchConsoleImpressions: z52.number().int().nonnegative().nullable()
   }).nullable()
 });
 function gaSearchLandingHasSearchData(total) {
   return total.organicGoogleSearchClicks > 0 || total.organicGoogleSearchImpressions > 0;
 }
-var gaSearchLandingSyncResultSchema = z51.object({
-  status: z51.enum(["ready", "unavailable", "error"]),
+var gaSearchLandingSyncResultSchema = z52.object({
+  status: z52.enum(["ready", "unavailable", "error"]),
   /** Windows written by this sync, empty unless `ready`. */
-  windows: z51.array(z51.object({
+  windows: z52.array(z52.object({
     window: gaSearchLandingWindowSchema,
-    rowCount: z51.number().int().nonnegative(),
-    reportRowCount: z51.number().int().nonnegative(),
-    rowsCapped: z51.boolean()
+    rowCount: z52.number().int().nonnegative(),
+    reportRowCount: z52.number().int().nonnegative(),
+    rowsCapped: z52.boolean()
   })),
   /** Landing-page rows written across every window. */
-  rowCount: z51.number().int().nonnegative(),
-  error: z51.string().optional()
+  rowCount: z52.number().int().nonnegative(),
+  error: z52.string().optional()
 });
-var gaSyncOnlySchema = z51.enum(["traffic", "ai", "social", "search-landing"]);
-var ga4SyncResponseDtoSchema = z51.object({
-  synced: z51.boolean(),
-  rowCount: z51.number().int().nonnegative(),
-  aiReferralCount: z51.number().int().nonnegative(),
-  socialReferralCount: z51.number().int().nonnegative(),
+var gaSyncOnlySchema = z52.enum(["traffic", "ai", "social", "search-landing"]);
+var ga4SyncResponseDtoSchema = z52.object({
+  synced: z52.boolean(),
+  rowCount: z52.number().int().nonnegative(),
+  aiReferralCount: z52.number().int().nonnegative(),
+  socialReferralCount: z52.number().int().nonnegative(),
   /**
    * The window that was ACTUALLY fetched and written, in days — the request's
    * `days` bounded to GA4's supported sync range (1–90). Read this, not
    * `requestedDays`, when reporting or reasoning about coverage: a
    * `--days 500` sync writes 90 days, and this field says 90.
    */
-  days: z51.number().int().nonnegative(),
+  days: z52.number().int().nonnegative(),
   /** The window the caller asked for, before bounding. Equals `days` unless `clamped`. */
-  requestedDays: z51.number().int().nonnegative(),
+  requestedDays: z52.number().int().nonnegative(),
   /**
    * True when `requestedDays` fell outside GA4's supported range and `days`
    * differs from it — i.e. the synced history is not the range requested.
    */
-  clamped: z51.boolean(),
-  syncedAt: z51.string(),
-  measurement: z51.object({
-    acquisition: z51.object({ days: z51.number().int().nonnegative(), status: z51.enum(["ready", "error"]), rowCount: z51.number().int().nonnegative(), error: z51.string().optional() }),
-    leads: z51.object({
-      days: z51.number().int().nonnegative(),
-      status: z51.enum(["ready", "error", "not-configured"]),
-      rowCount: z51.number().int().nonnegative(),
-      attributionScope: z51.enum(["landing-page", "channel"]).optional(),
-      error: z51.string().optional(),
+  clamped: z52.boolean(),
+  syncedAt: z52.string(),
+  measurement: z52.object({
+    acquisition: z52.object({ days: z52.number().int().nonnegative(), status: z52.enum(["ready", "error"]), rowCount: z52.number().int().nonnegative(), error: z52.string().optional() }),
+    leads: z52.object({
+      days: z52.number().int().nonnegative(),
+      status: z52.enum(["ready", "error", "not-configured"]),
+      rowCount: z52.number().int().nonnegative(),
+      attributionScope: z52.enum(["landing-page", "channel"]).optional(),
+      error: z52.string().optional(),
       /** The GA4 events this sync counted: the configured lead events plus the property's key events. */
-      eventNames: z51.array(z51.string()).optional(),
+      eventNames: z52.array(z52.string()).optional(),
       /**
        * The property's key-event read. `read` lists them; `error` keeps the
        * previous successful list and names the failure; `disabled` means the
        * project counts only its configured lead events.
        */
-      keyEvents: z51.object({
-        status: z51.enum(["read", "error", "disabled"]),
-        names: z51.array(z51.string()),
-        error: z51.string().optional()
+      keyEvents: z52.object({
+        status: z52.enum(["read", "error", "disabled"]),
+        names: z52.array(z52.string()),
+        error: z52.string().optional()
       }).optional()
     }),
     /**
@@ -17792,18 +17894,18 @@ var ga4SyncResponseDtoSchema = z51.object({
    * or `unavailable` attempt is left out and reported in
    * `measurement.searchLandingPages`.
    */
-  syncedComponents: z51.array(z51.string()).optional()
+  syncedComponents: z52.array(z52.string()).optional()
 });
-var gaMoverChangeBasisSchema = z51.enum(["new", "small-base", "percent"]);
+var gaMoverChangeBasisSchema = z52.enum(["new", "small-base", "percent"]);
 var GaMoverChangeBases = gaMoverChangeBasisSchema.enum;
-var gaSourceMoverSchema = z51.object({
-  source: z51.string(),
+var gaSourceMoverSchema = z52.object({
+  source: z52.string(),
   /** Sessions from this source in the last 7 days. */
-  sessions7d: z51.number(),
+  sessions7d: z52.number(),
   /** Sessions from this source in the 7 days before that. */
-  sessionsPrev7d: z51.number(),
+  sessionsPrev7d: z52.number(),
   /** Signed session change, `sessions7d - sessionsPrev7d`. The mover is the source whose change is largest in size. */
-  changeSessions: z51.number(),
+  changeSessions: z52.number(),
   /**
    * Signed whole-percent change against the prior 7 days (`150` = +150%, `-100`
    * = the source stopped sending sessions). Null when the prior 7 days had no
@@ -17812,29 +17914,29 @@ var gaSourceMoverSchema = z51.object({
   changePct: percent().nullable(),
   changeBasis: gaMoverChangeBasisSchema
 });
-var gaSocialReferralTrendResponseSchema = z51.object({
-  socialSessions7d: z51.number(),
-  socialSessionsPrev7d: z51.number(),
+var gaSocialReferralTrendResponseSchema = z52.object({
+  socialSessions7d: z52.number(),
+  socialSessionsPrev7d: z52.number(),
   /** Signed whole-percent change of the last 7 days against the 7 before. Null when the prior 7 days had no sessions. */
   trend7dPct: percent().nullable(),
-  socialSessions30d: z51.number(),
-  socialSessionsPrev30d: z51.number(),
+  socialSessions30d: z52.number(),
+  socialSessionsPrev30d: z52.number(),
   /** Signed whole-percent change of the last 30 days against the 30 before. Null when the prior 30 days had no sessions. */
   trend30dPct: percent().nullable(),
   /** Social source with the largest session change in the last 7 days against the 7 before. Null when no source moved. */
   biggestMover: gaSourceMoverSchema.nullable()
 });
-var gaChannelTrendSchema = z51.object({
-  sessions7d: z51.number(),
-  sessionsPrev7d: z51.number(),
+var gaChannelTrendSchema = z52.object({
+  sessions7d: z52.number(),
+  sessionsPrev7d: z52.number(),
   /** Signed whole-percent change of the last 7 days against the 7 before. Null when the prior 7 days had no sessions. */
   trend7dPct: percent().nullable(),
-  sessions30d: z51.number(),
-  sessionsPrev30d: z51.number(),
+  sessions30d: z52.number(),
+  sessionsPrev30d: z52.number(),
   /** Signed whole-percent change of the last 30 days against the 30 before. Null when the prior 30 days had no sessions. */
   trend30dPct: percent().nullable()
 });
-var gaAttributionTrendResponseSchema = z51.object({
+var gaAttributionTrendResponseSchema = z52.object({
   organic: gaChannelTrendSchema,
   /** AI session trend, scoped to sessionSource-only matches so it lines up with the disjoint AI cell in the channel breakdown. */
   ai: gaChannelTrendSchema,
@@ -17846,23 +17948,23 @@ var gaAttributionTrendResponseSchema = z51.object({
   /** Social source with the largest session change in the last 7 days against the 7 before. Null when no source moved. */
   socialBiggestMover: gaSourceMoverSchema.nullable()
 });
-var gaOverviewValuesSchema = z51.object({
-  activeUsers: z51.number().int().nonnegative().nullable(),
-  newUsers: z51.number().int().nonnegative().nullable(),
-  totalUsers: z51.number().int().nonnegative().nullable(),
-  sessions: z51.number().int().nonnegative().nullable(),
-  organicSessions: z51.number().int().nonnegative().nullable(),
-  views: z51.number().int().nonnegative().nullable(),
-  eventCount: z51.number().int().nonnegative().nullable(),
+var gaOverviewValuesSchema = z52.object({
+  activeUsers: z52.number().int().nonnegative().nullable(),
+  newUsers: z52.number().int().nonnegative().nullable(),
+  totalUsers: z52.number().int().nonnegative().nullable(),
+  sessions: z52.number().int().nonnegative().nullable(),
+  organicSessions: z52.number().int().nonnegative().nullable(),
+  views: z52.number().int().nonnegative().nullable(),
+  eventCount: z52.number().int().nonnegative().nullable(),
   /** GA4 counts a key event once per session when the property says so, so this can be a decimal. */
-  keyEvents: z51.number().nonnegative().nullable(),
+  keyEvents: z52.number().nonnegative().nullable(),
   engagementRate: fraction().nullable(),
   bounceRate: fraction().nullable(),
-  averageEngagementTimeSeconds: z51.number().nonnegative().nullable()
+  averageEngagementTimeSeconds: z52.number().nonnegative().nullable()
 });
 var gaOverviewMetricKeySchema = gaOverviewValuesSchema.keyof();
 var GaOverviewMetricKeys = gaOverviewMetricKeySchema.enum;
-var gaOverviewChangeSchema = z51.object({
+var gaOverviewChangeSchema = z52.object({
   activeUsers: percent().nullable(),
   newUsers: percent().nullable(),
   totalUsers: percent().nullable(),
@@ -17897,19 +17999,19 @@ function gaOverviewComparisonRanges(window, now = /* @__PURE__ */ new Date(), ti
   };
 }
 var GaOverviewPeriods = { current: "current", previous: "previous" };
-var gaOverviewPeriodSchema = z51.object({
+var gaOverviewPeriodSchema = z52.object({
   /** Inclusive. Null when the window has never been synced with the overview metrics. */
-  startDate: z51.string().nullable(),
-  endDate: z51.string().nullable()
+  startDate: z52.string().nullable(),
+  endDate: z52.string().nullable()
 });
-var gaOverviewDaySchema = z51.object({
-  date: z51.string(),
+var gaOverviewDaySchema = z52.object({
+  date: z52.string(),
   /** The day of the previous period in the same position: the window's first day lines up with its first. */
-  previousDate: z51.string(),
+  previousDate: z52.string(),
   values: gaOverviewValuesSchema,
   previousValues: gaOverviewValuesSchema
 });
-var gaOverviewResponseSchema = z51.object({
+var gaOverviewResponseSchema = z52.object({
   window: metricsWindowSchema,
   current: gaOverviewPeriodSchema,
   /** The period just before `current`, of the same length. */
@@ -17923,9 +18025,9 @@ var gaOverviewResponseSchema = z51.object({
    */
   changePct: gaOverviewChangeSchema,
   /** One entry per day of `current`, oldest first. */
-  days: z51.array(gaOverviewDaySchema),
+  days: z52.array(gaOverviewDaySchema),
   /** When GA4 last reported this window's totals. Null when it never has. */
-  syncedAt: z51.string().nullable()
+  syncedAt: z52.string().nullable()
 });
 var GaOverviewUnits = { count: "count", fraction: "fraction", seconds: "seconds" };
 var GaOverviewBetter = { higher: "higher", lower: "lower" };
@@ -17964,128 +18066,141 @@ var gaTrafficResponseSchema = ga4TrafficSummaryDtoSchema.extend({
    * Read every share against this window. The share fields divide a channel
    * count by `totalSessions`; both come from these dates and only these dates.
    */
-  windowStart: z51.string().nullable(),
+  windowStart: z52.string().nullable(),
   /** Inclusive end (YYYY-MM-DD) of the measured window. `null` when open-ended. */
-  windowEnd: z51.string().nullable(),
+  windowEnd: z52.string().nullable(),
   /**
    * Calendar days the measured window covers, counting both ends. `null` when
    * either bound is open — an unknown span is reported as unknown rather than
    * guessed.
    */
-  windowDays: z51.number().nullable(),
+  windowDays: z52.number().nullable(),
   /** Alias of `windowStart`, retained for callers that predate it. */
-  periodStart: z51.string().nullable(),
+  periodStart: z52.string().nullable(),
   /** Alias of `windowEnd`, retained for callers that predate it. */
-  periodEnd: z51.string().nullable()
+  periodEnd: z52.string().nullable()
 });
-var ga4AiReferralHistoryEntrySchema = z51.object({
-  date: z51.string(),
-  source: z51.string(),
-  medium: z51.string(),
+var ga4AiReferralHistoryEntrySchema = z52.object({
+  date: z52.string(),
+  source: z52.string(),
+  medium: z52.string(),
   trafficClass: aiReferralTrafficClassSchema,
-  landingPage: z51.string(),
-  sessions: z51.number(),
+  landingPage: z52.string(),
+  sessions: z52.number(),
   /** @deprecated See `GA4AiReferralDto.users`. Never emitted since 4.180.6. */
-  users: z51.number().optional(),
+  users: z52.number().optional(),
   /** Which GA4 dimension this row came from: session (sessionSource), first_user (firstUserSource), or manual_utm (utm_source parameter) */
   sourceDimension: ga4SourceDimensionSchema
 });
-var ga4AiReferralDailySourceSchema = z51.object({
-  source: z51.string(),
-  sessions: z51.number(),
-  paidSessions: z51.number(),
-  organicSessions: z51.number()
-});
-var ga4AiReferralDailyEntrySchema = z51.object({
-  date: z51.string(),
-  sessions: z51.number(),
-  paidSessions: z51.number(),
-  organicSessions: z51.number(),
+var ga4AiReferralDailySourceSchema = z52.object({
+  source: z52.string(),
+  sessions: z52.number(),
+  paidSessions: z52.number(),
+  organicSessions: z52.number()
+});
+var ga4AiReferralDailyEntrySchema = z52.object({
+  date: z52.string(),
+  sessions: z52.number(),
+  paidSessions: z52.number(),
+  organicSessions: z52.number(),
   /** Per-source split of the day. `sessions` is the sum of these. */
-  bySource: z51.array(ga4AiReferralDailySourceSchema)
+  bySource: z52.array(ga4AiReferralDailySourceSchema)
+});
+var ga4AiReferralDailyTrendSchema = linearTrendSchema.extend({
+  startDate: z52.string(),
+  endDate: z52.string()
 });
-var ga4AiReferralDailyDtoSchema = z51.object({
+var ga4AiReferralDailyDtoSchema = z52.object({
   /** Ascending by date. Dates with no AI referrals are absent, not zero-filled. */
-  days: z51.array(ga4AiReferralDailyEntrySchema),
+  days: z52.array(ga4AiReferralDailyEntrySchema),
   /** Sources present in the window, ordered by total sessions descending. */
-  sources: z51.array(z51.string()),
-  totalSessions: z51.number(),
-  totalPaidSessions: z51.number(),
-  totalOrganicSessions: z51.number(),
+  sources: z52.array(z52.string()),
+  totalSessions: z52.number(),
+  totalPaidSessions: z52.number(),
+  totalOrganicSessions: z52.number(),
   /**
    * The same days by AI engine: the five largest engines (the unattributed
    * group counts as one), then the rest as `other`. Folded from the same
    * winner set as `days`, so each day's values add up to that day's sessions.
    */
-  byEngine: stackedDailySeriesSchema
-});
-var ga4SocialReferralHistoryEntrySchema = z51.object({
-  date: z51.string(),
-  source: z51.string(),
-  medium: z51.string(),
-  sessions: z51.number(),
-  users: z51.number(),
+  byEngine: stackedDailySeriesSchema,
+  /**
+   * Fitted over the window's complete GA4 days, server side so every consumer
+   * draws the same line. A day counts once GA4 reported the site's daily total
+   * for it, so a date with no AI row is a measured zero; days before the
+   * project's first stored AI row, and the last two UTC days (still filling),
+   * are left out. Null with fewer than two such days. Optional so a newer
+   * client reads an older API.
+   */
+  trend: ga4AiReferralDailyTrendSchema.nullable().optional()
+});
+var ga4SocialReferralHistoryEntrySchema = z52.object({
+  date: z52.string(),
+  source: z52.string(),
+  medium: z52.string(),
+  sessions: z52.number(),
+  users: z52.number(),
   /** GA4 default channel group (e.g. 'Organic Social', 'Paid Social') */
-  channelGroup: z51.string()
+  channelGroup: z52.string()
 });
-var ga4SessionHistoryEntrySchema = z51.object({
-  date: z51.string(),
-  sessions: z51.number(),
-  organicSessions: z51.number(),
+var ga4SessionHistoryEntrySchema = z52.object({
+  date: z52.string(),
+  sessions: z52.number(),
+  organicSessions: z52.number(),
   /**
    * Unique visitors for the day. Deduplicated by GA when `usersSource` is
    * `deduplicated`; a landing-page sum (which overcounts multi-page visitors)
    * for days synced before per-day totals were captured.
    */
-  users: z51.number(),
+  users: z52.number(),
   /**
    * How `users` was derived. `deduplicated` matches the GA UI's active users;
    * `landing-page-sum` is the legacy overcount kept so historical days still
    * render. Never compare the two across a series without saying which is which.
    */
-  usersSource: z51.enum(["deduplicated", "landing-page-sum"])
+  usersSource: z52.enum(["deduplicated", "landing-page-sum"])
 });
-var gaAcquisitionDimensionSchema = z51.enum(["date", "channelGroup", "source", "medium", "hostName", "landingPage"]);
+var gaAcquisitionDimensionSchema = z52.enum(["date", "channelGroup", "source", "medium", "hostName", "landingPage"]);
 var GaAcquisitionDimensions = gaAcquisitionDimensionSchema.enum;
-var gaAcquisitionQuerySchema = z51.object({
+var gaAcquisitionQuerySchema = z52.object({
   window: metricsWindowSchema.optional(),
-  startDate: z51.iso.date().optional(),
-  endDate: z51.iso.date().optional(),
-  channel: z51.string().optional(),
-  source: z51.string().optional(),
-  medium: z51.string().optional(),
-  hostName: z51.string().optional(),
-  landingPage: z51.string().optional(),
-  pathPrefix: z51.string().optional(),
-  groupBy: z51.string().refine((value) => value.split(",").every((key) => gaAcquisitionDimensionSchema.safeParse(key.trim()).success), `groupBy must contain: ${gaAcquisitionDimensionSchema.options.join(", ")}`).optional(),
-  limit: z51.number().int().min(1).max(1e3).optional(),
-  offset: z51.number().int().nonnegative().optional()
-}).strict();
-var gaAcquisitionRowSchema = z51.object({
-  date: z51.string().optional(),
-  channelGroup: z51.string().optional(),
-  source: z51.string().optional(),
-  medium: z51.string().optional(),
-  hostName: z51.string().optional(),
-  landingPage: z51.string().optional(),
-  sessions: z51.number().int().nonnegative()
-});
-var gaAcquisitionResponseSchema = z51.object({
-  source: z51.literal("ga4-acquisition"),
+  startDate: z52.iso.date().optional(),
+  endDate: z52.iso.date().optional(),
+  channel: z52.string().optional(),
+  source: z52.string().optional(),
+  medium: z52.string().optional(),
+  hostName: z52.string().optional(),
+  landingPage: z52.string().optional(),
+  pathPrefix: z52.string().optional(),
+  groupBy: z52.string().refine((value) => value.split(",").every((key) => gaAcquisitionDimensionSchema.safeParse(key.trim()).success), `groupBy must contain: ${gaAcquisitionDimensionSchema.options.join(", ")}`).optional(),
+  limit: z52.number().int().min(1).max(1e3).optional(),
+  offset: z52.number().int().nonnegative().optional()
+}).strict();
+var gaAcquisitionRowSchema = z52.object({
+  date: z52.string().optional(),
+  channelGroup: z52.string().optional(),
+  source: z52.string().optional(),
+  medium: z52.string().optional(),
+  hostName: z52.string().optional(),
+  landingPage: z52.string().optional(),
+  sessions: z52.number().int().nonnegative()
+});
+var gaAcquisitionResponseSchema = z52.object({
+  source: z52.literal("ga4-acquisition"),
   status: gaMeasurementComponentStatusSchema,
-  error: z51.string().nullable(),
-  syncedAt: z51.string().nullable(),
-  scope: z51.object({ project: z51.string(), attribution: z51.literal("project-only"), unavailableDimensions: z51.array(z51.enum(["property", "target", "market"])) }),
-  window: z51.object({ startDate: z51.string().nullable(), endDate: z51.string().nullable(), window: metricsWindowSchema }),
-  coverage: z51.object({ earliestDate: z51.string().nullable(), latestDate: z51.string().nullable() }),
-  filters: z51.object({ channel: z51.string().nullable(), source: z51.string().nullable(), medium: z51.string().nullable(), hostName: z51.string().nullable(), landingPage: z51.string().nullable(), pathPrefix: z51.string().nullable() }),
-  groupBy: z51.array(gaAcquisitionDimensionSchema),
-  channelGroups: z51.array(z51.string()),
-  totalSessions: z51.number().int().nonnegative(),
-  totalRows: z51.number().int().nonnegative(),
-  limit: z51.number().int(),
-  offset: z51.number().int(),
-  rows: z51.array(gaAcquisitionRowSchema)
+  error: z52.string().nullable(),
+  syncedAt: z52.string().nullable(),
+  scope: z52.object({ project: z52.string(), attribution: z52.literal("project-only"), unavailableDimensions: z52.array(z52.enum(["property", "target", "market"])) }),
+  window: z52.object({ startDate: z52.string().nullable(), endDate: z52.string().nullable(), window: metricsWindowSchema }),
+  coverage: z52.object({ earliestDate: z52.string().nullable(), latestDate: z52.string().nullable() }),
+  filters: z52.object({ channel: z52.string().nullable(), source: z52.string().nullable(), medium: z52.string().nullable(), hostName: z52.string().nullable(), landingPage: z52.string().nullable(), pathPrefix: z52.string().nullable() }),
+  groupBy: z52.array(gaAcquisitionDimensionSchema),
+  channelGroups: z52.array(z52.string()),
+  totalSessions: z52.number().int().nonnegative(),
+  totalRows: z52.number().int().nonnegative(),
+  limit: z52.number().int(),
+  offset: z52.number().int(),
+  rows: z52.array(gaAcquisitionRowSchema)
 });
 function formatGaOverviewValue(key, value, options = {}) {
   if (value === null) return "\u2014";
@@ -18168,8 +18283,8 @@ function collectBrandAliasesFromDomain(domain) {
 }
 
 // ../contracts/src/backlinks.ts
-import { z as z52 } from "zod";
-var backlinkSourceSchema = z52.enum(["commoncrawl", "bing-webmaster"]);
+import { z as z53 } from "zod";
+var backlinkSourceSchema = z53.enum(["commoncrawl", "bing-webmaster"]);
 var BacklinkSources = backlinkSourceSchema.enum;
 function computeBacklinkSummaryMetrics(rows) {
   if (rows.length === 0) {
@@ -18185,108 +18300,108 @@ function computeBacklinkSummaryMetrics(rows) {
     top10HostsShare: share.toFixed(6)
   };
 }
-var ccReleaseSyncStatusSchema = z52.enum(["queued", "downloading", "querying", "ready", "failed"]);
+var ccReleaseSyncStatusSchema = z53.enum(["queued", "downloading", "querying", "ready", "failed"]);
 var CcReleaseSyncStatuses = ccReleaseSyncStatusSchema.enum;
-var ccReleaseSyncDtoSchema = z52.object({
-  id: z52.string(),
-  release: z52.string(),
+var ccReleaseSyncDtoSchema = z53.object({
+  id: z53.string(),
+  release: z53.string(),
   status: ccReleaseSyncStatusSchema,
-  phaseDetail: z52.string().nullable().optional(),
-  vertexPath: z52.string().nullable().optional(),
-  edgesPath: z52.string().nullable().optional(),
-  vertexSha256: z52.string().nullable().optional(),
-  edgesSha256: z52.string().nullable().optional(),
-  vertexBytes: z52.number().int().nullable().optional(),
-  edgesBytes: z52.number().int().nullable().optional(),
-  projectsProcessed: z52.number().int().nullable().optional(),
-  domainsDiscovered: z52.number().int().nullable().optional(),
-  downloadStartedAt: z52.string().nullable().optional(),
-  downloadFinishedAt: z52.string().nullable().optional(),
-  queryStartedAt: z52.string().nullable().optional(),
-  queryFinishedAt: z52.string().nullable().optional(),
-  error: z52.string().nullable().optional(),
-  createdAt: z52.string(),
-  updatedAt: z52.string()
+  phaseDetail: z53.string().nullable().optional(),
+  vertexPath: z53.string().nullable().optional(),
+  edgesPath: z53.string().nullable().optional(),
+  vertexSha256: z53.string().nullable().optional(),
+  edgesSha256: z53.string().nullable().optional(),
+  vertexBytes: z53.number().int().nullable().optional(),
+  edgesBytes: z53.number().int().nullable().optional(),
+  projectsProcessed: z53.number().int().nullable().optional(),
+  domainsDiscovered: z53.number().int().nullable().optional(),
+  downloadStartedAt: z53.string().nullable().optional(),
+  downloadFinishedAt: z53.string().nullable().optional(),
+  queryStartedAt: z53.string().nullable().optional(),
+  queryFinishedAt: z53.string().nullable().optional(),
+  error: z53.string().nullable().optional(),
+  createdAt: z53.string(),
+  updatedAt: z53.string()
 });
-var backlinkDomainDtoSchema = z52.object({
-  linkingDomain: z52.string(),
-  numHosts: z52.number().int(),
+var backlinkDomainDtoSchema = z53.object({
+  linkingDomain: z53.string(),
+  numHosts: z53.number().int(),
   source: backlinkSourceSchema
 });
-var backlinkSummaryDtoSchema = z52.object({
-  projectId: z52.string(),
-  release: z52.string(),
-  targetDomain: z52.string(),
-  totalLinkingDomains: z52.number().int(),
-  totalHosts: z52.number().int(),
-  top10HostsShare: z52.string(),
-  queriedAt: z52.string(),
+var backlinkSummaryDtoSchema = z53.object({
+  projectId: z53.string(),
+  release: z53.string(),
+  targetDomain: z53.string(),
+  totalLinkingDomains: z53.number().int(),
+  totalHosts: z53.number().int(),
+  top10HostsShare: z53.string(),
+  queriedAt: z53.string(),
   source: backlinkSourceSchema,
   // Populated when the response is filtered (e.g. ?excludeCrawlers=1).
   // Counts the rows omitted from totalLinkingDomains/totalHosts so callers
   // can show "N hidden" hints without re-deriving them.
-  excludedLinkingDomains: z52.number().int().optional(),
-  excludedHosts: z52.number().int().optional()
+  excludedLinkingDomains: z53.number().int().optional(),
+  excludedHosts: z53.number().int().optional()
 });
-var backlinkListResponseSchema = z52.object({
+var backlinkListResponseSchema = z53.object({
   source: backlinkSourceSchema,
   summary: backlinkSummaryDtoSchema.nullable(),
-  total: z52.number().int(),
-  rows: z52.array(backlinkDomainDtoSchema)
-});
-var backlinkHistoryEntrySchema = z52.object({
-  release: z52.string(),
-  totalLinkingDomains: z52.number().int(),
-  totalHosts: z52.number().int(),
-  top10HostsShare: z52.string(),
-  queriedAt: z52.string(),
+  total: z53.number().int(),
+  rows: z53.array(backlinkDomainDtoSchema)
+});
+var backlinkHistoryEntrySchema = z53.object({
+  release: z53.string(),
+  totalLinkingDomains: z53.number().int(),
+  totalHosts: z53.number().int(),
+  top10HostsShare: z53.string(),
+  queriedAt: z53.string(),
   source: backlinkSourceSchema
 });
-var backlinkSourceAvailabilityDtoSchema = z52.object({
+var backlinkSourceAvailabilityDtoSchema = z53.object({
   source: backlinkSourceSchema,
-  connected: z52.boolean(),
-  hasData: z52.boolean(),
-  latestRelease: z52.string().nullable(),
-  totalLinkingDomains: z52.number().int(),
-  lastSyncedAt: z52.string().nullable()
-});
-var backlinkSourcesResponseSchema = z52.object({
-  projectId: z52.string(),
-  targetDomain: z52.string(),
-  sources: z52.array(backlinkSourceAvailabilityDtoSchema),
-  anyConnected: z52.boolean(),
-  anyData: z52.boolean()
-});
-var backlinksInstallStatusDtoSchema = z52.object({
-  duckdbInstalled: z52.boolean(),
-  duckdbVersion: z52.string().nullable().optional(),
-  duckdbSpec: z52.string(),
-  pluginDir: z52.string()
-});
-var backlinksInstallResultDtoSchema = z52.object({
-  installed: z52.boolean(),
-  version: z52.string(),
-  path: z52.string(),
-  alreadyPresent: z52.boolean()
-});
-var ccAvailableReleaseSchema = z52.object({
-  release: z52.string(),
-  vertexUrl: z52.string(),
-  edgesUrl: z52.string(),
-  vertexBytes: z52.number().int().nullable(),
-  edgesBytes: z52.number().int().nullable(),
-  lastModified: z52.string().nullable()
-});
-var ccCachedReleaseSchema = z52.object({
-  release: z52.string(),
+  connected: z53.boolean(),
+  hasData: z53.boolean(),
+  latestRelease: z53.string().nullable(),
+  totalLinkingDomains: z53.number().int(),
+  lastSyncedAt: z53.string().nullable()
+});
+var backlinkSourcesResponseSchema = z53.object({
+  projectId: z53.string(),
+  targetDomain: z53.string(),
+  sources: z53.array(backlinkSourceAvailabilityDtoSchema),
+  anyConnected: z53.boolean(),
+  anyData: z53.boolean()
+});
+var backlinksInstallStatusDtoSchema = z53.object({
+  duckdbInstalled: z53.boolean(),
+  duckdbVersion: z53.string().nullable().optional(),
+  duckdbSpec: z53.string(),
+  pluginDir: z53.string()
+});
+var backlinksInstallResultDtoSchema = z53.object({
+  installed: z53.boolean(),
+  version: z53.string(),
+  path: z53.string(),
+  alreadyPresent: z53.boolean()
+});
+var ccAvailableReleaseSchema = z53.object({
+  release: z53.string(),
+  vertexUrl: z53.string(),
+  edgesUrl: z53.string(),
+  vertexBytes: z53.number().int().nullable(),
+  edgesBytes: z53.number().int().nullable(),
+  lastModified: z53.string().nullable()
+});
+var ccCachedReleaseSchema = z53.object({
+  release: z53.string(),
   syncStatus: ccReleaseSyncStatusSchema.nullable(),
-  bytes: z52.number().int(),
-  lastUsedAt: z52.string().nullable()
+  bytes: z53.number().int(),
+  lastUsedAt: z53.string().nullable()
 });
 
 // ../contracts/src/content.ts
-import { z as z53 } from "zod";
-var contentActionSchema = z53.enum(["create", "expand", "refresh", "add-schema"]);
+import { z as z54 } from "zod";
+var contentActionSchema = z54.enum(["create", "expand", "refresh", "add-schema"]);
 var ContentActions = contentActionSchema.enum;
 function contentActionLabel(action) {
   switch (action) {
@@ -18300,9 +18415,9 @@ function contentActionLabel(action) {
       return "Add schema";
   }
 }
-var demandSourceSchema = z53.enum(["gsc", "competitor-evidence", "both"]);
+var demandSourceSchema = z54.enum(["gsc", "competitor-evidence", "both"]);
 var DemandSources = demandSourceSchema.enum;
-var actionConfidenceSchema = z53.enum(["high", "medium", "low"]);
+var actionConfidenceSchema = z54.enum(["high", "medium", "low"]);
 var ActionConfidences = actionConfidenceSchema.enum;
 function actionConfidenceLabel(confidence) {
   switch (confidence) {
@@ -18314,7 +18429,7 @@ function actionConfidenceLabel(confidence) {
       return "Low";
   }
 }
-var pageTypeSchema = z53.enum([
+var pageTypeSchema = z54.enum([
   "blog-post",
   "comparison",
   "listicle",
@@ -18323,7 +18438,7 @@ var pageTypeSchema = z53.enum([
   "glossary"
 ]);
 var PageTypes = pageTypeSchema.enum;
-var contentActionStateSchema = z53.enum([
+var contentActionStateSchema = z54.enum([
   "proposed",
   "briefed",
   "payload-generated",
@@ -18333,7 +18448,7 @@ var contentActionStateSchema = z53.enum([
   "dismissed"
 ]);
 var ContentActionStates = contentActionStateSchema.enum;
-var winnabilityClassSchema = z53.enum(["ownable", "ceded"]);
+var winnabilityClassSchema = z54.enum(["ownable", "ceded"]);
 var WinnabilityClasses = winnabilityClassSchema.enum;
 function winnabilityClassLabel(winnabilityClass) {
   switch (winnabilityClass) {
@@ -18368,40 +18483,40 @@ function deriveWinnabilityClass(citedSurfaceDomains, surfaceClasses, threshold =
     winnability
   };
 }
-var ourBestPageSchema = z53.object({
-  url: z53.string(),
-  gscImpressions: z53.number().nonnegative(),
-  gscClicks: z53.number().nonnegative(),
+var ourBestPageSchema = z54.object({
+  url: z54.string(),
+  gscImpressions: z54.number().nonnegative(),
+  gscClicks: z54.number().nonnegative(),
   // Null when the page came from the inventory fallback (no GSC ranking data).
-  gscAvgPosition: z53.number().nonnegative().nullable(),
-  organicSessions: z53.number().nonnegative()
-});
-var winningCompetitorSchema = z53.object({
-  domain: z53.string(),
-  url: z53.string(),
-  title: z53.string(),
-  citationCount: z53.number().int().nonnegative()
-});
-var scoreBreakdownSchema = z53.object({
-  demand: z53.number(),
-  competitor: z53.number(),
-  absence: z53.number(),
-  gapSeverity: z53.number()
-});
-var existingActionRefSchema = z53.object({
-  actionId: z53.string(),
+  gscAvgPosition: z54.number().nonnegative().nullable(),
+  organicSessions: z54.number().nonnegative()
+});
+var winningCompetitorSchema = z54.object({
+  domain: z54.string(),
+  url: z54.string(),
+  title: z54.string(),
+  citationCount: z54.number().int().nonnegative()
+});
+var scoreBreakdownSchema = z54.object({
+  demand: z54.number(),
+  competitor: z54.number(),
+  absence: z54.number(),
+  gapSeverity: z54.number()
+});
+var existingActionRefSchema = z54.object({
+  actionId: z54.string(),
   state: contentActionStateSchema,
-  lastUpdated: z53.string()
+  lastUpdated: z54.string()
 });
-var contentTargetRowDtoSchema = z53.object({
-  targetRef: z53.string(),
-  query: z53.string(),
+var contentTargetRowDtoSchema = z54.object({
+  targetRef: z54.string(),
+  query: z54.string(),
   action: contentActionSchema,
   ourBestPage: ourBestPageSchema.nullable(),
   winningCompetitor: winningCompetitorSchema.nullable(),
-  score: z53.number(),
+  score: z54.number(),
   scoreBreakdown: scoreBreakdownSchema,
-  drivers: z53.array(z53.string()),
+  drivers: z54.array(z54.string()),
   demandSource: demandSourceSchema,
   actionConfidence: actionConfidenceSchema,
   existingAction: existingActionRefSchema.nullable(),
@@ -18416,134 +18531,134 @@ var contentTargetRowDtoSchema = z53.object({
    * `[0, 1]`. `null` when the gate failed open (no classification coverage for
    * the cited surface) — distinct from a computed `1.0`.
    */
-  winnability: fraction(z53.number().min(0).max(1)).nullable()
-});
-var contentTargetsResponseDtoSchema = z53.object({
-  targets: z53.array(contentTargetRowDtoSchema),
-  contextMetrics: z53.object({
-    totalAiReferralSessions: z53.number().int().nonnegative(),
-    latestRunId: z53.string(),
-    runTimestamp: z53.string()
+  winnability: fraction(z54.number().min(0).max(1)).nullable()
+});
+var contentTargetsResponseDtoSchema = z54.object({
+  targets: z54.array(contentTargetRowDtoSchema),
+  contextMetrics: z54.object({
+    totalAiReferralSessions: z54.number().int().nonnegative(),
+    latestRunId: z54.string(),
+    runTimestamp: z54.string()
   })
 });
-var contentTargetDismissalDtoSchema = z53.object({
-  targetRef: z53.string(),
-  addressedUrl: z53.string().nullable(),
-  note: z53.string().nullable(),
-  dismissedAt: z53.string()
+var contentTargetDismissalDtoSchema = z54.object({
+  targetRef: z54.string(),
+  addressedUrl: z54.string().nullable(),
+  note: z54.string().nullable(),
+  dismissedAt: z54.string()
 });
-var contentTargetDismissalsResponseDtoSchema = z53.object({
-  dismissals: z53.array(contentTargetDismissalDtoSchema)
+var contentTargetDismissalsResponseDtoSchema = z54.object({
+  dismissals: z54.array(contentTargetDismissalDtoSchema)
 });
-var contentTargetDismissRequestSchema = z53.object({
-  targetRef: z53.string().min(1),
+var contentTargetDismissRequestSchema = z54.object({
+  targetRef: z54.string().min(1),
   /** URL of the page the user wrote that addresses this recommendation. Stored verbatim for the audit trail; not currently used to suppress the slug-token matcher. */
-  addressedUrl: z53.string().url().optional(),
+  addressedUrl: z54.string().url().optional(),
   /** Free-form note (e.g. "covered in our Q1 content sprint"). 500 char cap is the API surface limit; the DB column is unbounded. */
-  note: z53.string().max(500).optional()
+  note: z54.string().max(500).optional()
 });
-var recommendationExplanationDtoSchema = z53.object({
-  targetRef: z53.string(),
+var recommendationExplanationDtoSchema = z54.object({
+  targetRef: z54.string(),
   /** Version of the prompt template used. Bumping the version invalidates the cache forward without touching the table. */
-  promptVersion: z53.string(),
+  promptVersion: z54.string(),
   /** Provider that produced the explanation (e.g. "claude", "gemini"). */
-  provider: z53.string(),
+  provider: z54.string(),
   /** Model id within that provider (e.g. "claude-sonnet-4-6"). */
-  model: z53.string(),
+  model: z54.string(),
   /** Markdown-formatted rationale + recommended next steps. */
-  responseText: z53.string(),
+  responseText: z54.string(),
   /** Estimated cost in millicents (1/100 of a cent). 0 when unknown. */
-  costMillicents: z53.number().int().nonnegative(),
-  generatedAt: z53.string()
+  costMillicents: z54.number().int().nonnegative(),
+  generatedAt: z54.string()
 });
-var recommendationExplainRequestSchema = z53.object({
+var recommendationExplainRequestSchema = z54.object({
   /**
    * Optional provider override (e.g. "claude" to force Claude even if
    * the project's default is Gemini). Falls through to project default
    * → auto-detect when omitted.
    */
-  provider: z53.string().optional(),
+  provider: z54.string().optional(),
   /**
    * Optional model override within the chosen provider. Falls through to
    * the `analyze`-tier default model when omitted.
    */
-  model: z53.string().optional(),
+  model: z54.string().optional(),
   /**
    * Force a fresh LLM call even if a cached explanation exists for the
    * current prompt version. Use sparingly — defeats the cache.
    */
-  forceRefresh: z53.boolean().optional()
+  forceRefresh: z54.boolean().optional()
 });
-var contentBriefDtoSchema = z53.object({
+var contentBriefDtoSchema = z54.object({
   /** The query the brief is for (echoed from the recommendation). */
-  targetQuery: z53.string().trim().min(1),
+  targetQuery: z54.string().trim().min(1),
   /** Always `ownable` in practice — the gate rejects `ceded` before synthesis. */
   winnabilityClass: winnabilityClassSchema,
   /** The differentiated content angle to take. */
-  angle: z53.string().trim().min(1),
+  angle: z54.string().trim().min(1),
   /** Why this query is winnable, citing the cited-surface signal. */
-  whyWinnable: z53.string().trim().min(1),
+  whyWinnable: z54.string().trim().min(1),
   /** The schema.org type or markup to add or extend. */
-  schemaHookup: z53.string().trim().min(1),
+  schemaHookup: z54.string().trim().min(1),
   /** Why the cited surface is controllable (the ownable-vs-ceded reasoning). */
-  controllableSurfaceRationale: z53.string().trim().min(1)
+  controllableSurfaceRationale: z54.string().trim().min(1)
 });
-var recommendationBriefDtoSchema = z53.object({
-  targetRef: z53.string(),
+var recommendationBriefDtoSchema = z54.object({
+  targetRef: z54.string(),
   /** Version of the brief prompt template; bumping invalidates the cache forward. */
-  promptVersion: z53.string(),
-  provider: z53.string(),
-  model: z53.string(),
+  promptVersion: z54.string(),
+  provider: z54.string(),
+  model: z54.string(),
   brief: contentBriefDtoSchema,
   /** Estimated cost in millicents (1/100 of a cent). 0 when unknown. */
-  costMillicents: z53.number().int().nonnegative(),
-  generatedAt: z53.string()
+  costMillicents: z54.number().int().nonnegative(),
+  generatedAt: z54.string()
 });
-var domainClassificationDtoSchema = z53.object({
-  domain: z53.string(),
+var domainClassificationDtoSchema = z54.object({
+  domain: z54.string(),
   competitorType: discoveryCompetitorTypeSchema,
-  hits: z53.number().int().nonnegative(),
-  updatedAt: z53.string()
+  hits: z54.number().int().nonnegative(),
+  updatedAt: z54.string()
+});
+var domainClassificationsResponseDtoSchema = z54.object({
+  classifications: z54.array(domainClassificationDtoSchema)
 });
-var domainClassificationsResponseDtoSchema = z53.object({
-  classifications: z53.array(domainClassificationDtoSchema)
-});
-var contentGroundingSourceSchema = z53.object({
-  uri: z53.string(),
-  title: z53.string(),
-  domain: z53.string(),
-  isOurDomain: z53.boolean(),
-  isCompetitor: z53.boolean(),
-  citationCount: z53.number().int().nonnegative(),
-  providers: z53.array(providerNameSchema)
-});
-var contentSourceRowDtoSchema = z53.object({
-  query: z53.string(),
-  groundingSources: z53.array(contentGroundingSourceSchema)
-});
-var contentSourcesResponseDtoSchema = z53.object({
-  sources: z53.array(contentSourceRowDtoSchema),
-  latestRunId: z53.string()
-});
-var contentGapRowDtoSchema = z53.object({
-  query: z53.string(),
-  competitorDomains: z53.array(z53.string()),
-  competitorCount: z53.number().int().nonnegative(),
-  missRate: fraction(z53.number().min(0).max(1)),
-  lastSeenInRunId: z53.string()
-});
-var contentGapsResponseDtoSchema = z53.object({
-  gaps: z53.array(contentGapRowDtoSchema),
-  latestRunId: z53.string()
+var contentGroundingSourceSchema = z54.object({
+  uri: z54.string(),
+  title: z54.string(),
+  domain: z54.string(),
+  isOurDomain: z54.boolean(),
+  isCompetitor: z54.boolean(),
+  citationCount: z54.number().int().nonnegative(),
+  providers: z54.array(providerNameSchema)
+});
+var contentSourceRowDtoSchema = z54.object({
+  query: z54.string(),
+  groundingSources: z54.array(contentGroundingSourceSchema)
+});
+var contentSourcesResponseDtoSchema = z54.object({
+  sources: z54.array(contentSourceRowDtoSchema),
+  latestRunId: z54.string()
+});
+var contentGapRowDtoSchema = z54.object({
+  query: z54.string(),
+  competitorDomains: z54.array(z54.string()),
+  competitorCount: z54.number().int().nonnegative(),
+  missRate: fraction(z54.number().min(0).max(1)),
+  lastSeenInRunId: z54.string()
+});
+var contentGapsResponseDtoSchema = z54.object({
+  gaps: z54.array(contentGapRowDtoSchema),
+  latestRunId: z54.string()
 });
 
 // ../contracts/src/doctor.ts
-import { z as z54 } from "zod";
-var checkStatusSchema = z54.enum(["ok", "warn", "fail", "skipped"]);
+import { z as z55 } from "zod";
+var checkStatusSchema = z55.enum(["ok", "warn", "fail", "skipped"]);
 var CheckStatuses = checkStatusSchema.enum;
-var checkScopeSchema = z54.enum(["global", "project"]);
+var checkScopeSchema = z55.enum(["global", "project"]);
 var CheckScopes = checkScopeSchema.enum;
-var checkCategorySchema = z54.enum([
+var checkCategorySchema = z55.enum([
   "auth",
   "config",
   "providers",
@@ -18555,9 +18670,9 @@ var checkCategorySchema = z54.enum([
 ]);
 var CheckCategories = checkCategorySchema.enum;
 var CHECK_RUNTIME_ERROR_SUFFIX = ".runtime-error";
-var checkNotificationPolicySchema = z54.enum(["health", "silent"]);
+var checkNotificationPolicySchema = z55.enum(["health", "silent"]);
 var CheckNotificationPolicies = checkNotificationPolicySchema.enum;
-var reportMonthSchema = z54.string().regex(/^[1-9]\d{3}-(0[1-9]|1[0-2])$/, "Expected YYYY-MM");
+var reportMonthSchema = z55.string().regex(/^[1-9]\d{3}-(0[1-9]|1[0-2])$/, "Expected YYYY-MM");
 function reportMonthsForDoctor(reportMonth, now = /* @__PURE__ */ new Date()) {
   if (reportMonth !== void 0) return [reportMonthSchema.parse(reportMonth)];
   const current = now.toISOString().slice(0, 7);
@@ -18569,40 +18684,40 @@ function gradedReportMonths(months, now = /* @__PURE__ */ new Date()) {
   const current = now.toISOString().slice(0, 7);
   return new Set(months.length > 1 ? months.filter((month) => month !== current) : months);
 }
-var healthAlertCopySchema = z54.object({
-  label: z54.string().describe(`The problem in a few words, e.g. "Can't reach Google".`),
-  line: z54.string().describe("What happened, in one plain sentence."),
-  next: z54.string().nullable().describe("What to do, in one plain sentence; null when nothing needs doing yet.")
+var healthAlertCopySchema = z55.object({
+  label: z55.string().describe(`The problem in a few words, e.g. "Can't reach Google".`),
+  line: z55.string().describe("What happened, in one plain sentence."),
+  next: z55.string().nullable().describe("What to do, in one plain sentence; null when nothing needs doing yet.")
 });
-var checkResultSchema = z54.object({
-  id: z54.string(),
+var checkResultSchema = z55.object({
+  id: z55.string(),
   category: checkCategorySchema,
   scope: checkScopeSchema,
-  title: z54.string(),
+  title: z55.string(),
   status: checkStatusSchema,
   notificationPolicy: checkNotificationPolicySchema.optional().describe("Health checks page by default. Silent checks (report advisories and standing advisories) remain visible but never affect health alert state."),
-  code: z54.string().describe('Stable machine-readable code (e.g. "google.token.refresh-failed"). Use this for filtering and remediation logic.'),
-  urgent: z54.boolean().optional().describe('True when this result is a problem a person has to act on now (the website is down, daily data stopped arriving, a sync keeps failing). Urgent results are what the health.urgent notification event reports. A result set aside under its failing cause (status "skipped", code "<id>.superseded") keeps the flag: the problem is still open.'),
-  summary: z54.string(),
-  remediation: z54.string().nullable().optional().describe('Operator-facing next step. Null when status is "ok" or no specific remediation applies.'),
-  details: z54.record(z54.string(), z54.unknown()).optional().describe("Structured context \u2014 principal email, redirect URI, missing scopes, etc. Stable per check id."),
+  code: z55.string().describe('Stable machine-readable code (e.g. "google.token.refresh-failed"). Use this for filtering and remediation logic.'),
+  urgent: z55.boolean().optional().describe('True when this result is a problem a person has to act on now (the website is down, daily data stopped arriving, a sync keeps failing). Urgent results are what the health.urgent notification event reports. A result set aside under its failing cause (status "skipped", code "<id>.superseded") keeps the flag: the problem is still open.'),
+  summary: z55.string(),
+  remediation: z55.string().nullable().optional().describe('Operator-facing next step. Null when status is "ok" or no specific remediation applies.'),
+  details: z55.record(z55.string(), z55.unknown()).optional().describe("Structured context \u2014 principal email, redirect URI, missing scopes, etc. Stable per check id."),
   alert: healthAlertCopySchema.optional().describe("Plain words a health alert shows for this result. Absent when the check has none; alerts then fall back to the summary."),
-  durationMs: z54.number().int().nonnegative().describe("How long the check took to execute.")
+  durationMs: z55.number().int().nonnegative().describe("How long the check took to execute.")
 });
-var doctorReportSchema = z54.object({
+var doctorReportSchema = z55.object({
   scope: checkScopeSchema,
-  project: z54.string().nullable().describe('Project name when scope is "project", null otherwise.'),
-  reportMonths: z54.array(reportMonthSchema).optional().describe("Calendar months evaluated by project report readiness checks."),
-  generatedAt: z54.string().describe("ISO-8601 timestamp when this doctor run started."),
-  durationMs: z54.number().int().nonnegative(),
-  summary: z54.object({
-    total: z54.number().int().nonnegative(),
-    ok: z54.number().int().nonnegative(),
-    warn: z54.number().int().nonnegative(),
-    fail: z54.number().int().nonnegative(),
-    skipped: z54.number().int().nonnegative()
+  project: z55.string().nullable().describe('Project name when scope is "project", null otherwise.'),
+  reportMonths: z55.array(reportMonthSchema).optional().describe("Calendar months evaluated by project report readiness checks."),
+  generatedAt: z55.string().describe("ISO-8601 timestamp when this doctor run started."),
+  durationMs: z55.number().int().nonnegative(),
+  summary: z55.object({
+    total: z55.number().int().nonnegative(),
+    ok: z55.number().int().nonnegative(),
+    warn: z55.number().int().nonnegative(),
+    fail: z55.number().int().nonnegative(),
+    skipped: z55.number().int().nonnegative()
   }),
-  checks: z54.array(checkResultSchema)
+  checks: z55.array(checkResultSchema)
 });
 function summarizeCheckResults(results) {
   const summary = { total: results.length, ok: 0, warn: 0, fail: 0, skipped: 0 };
@@ -18635,8 +18750,8 @@ function groupIsoDateRanges(dates) {
 }
 
 // ../contracts/src/skills.ts
-import { z as z55 } from "zod";
-var codingAgentSchema = z55.enum(["claude", "codex"]);
+import { z as z56 } from "zod";
+var codingAgentSchema = z56.enum(["claude", "codex"]);
 var CodingAgents = codingAgentSchema.enum;
 function agentPluginClientLabel(client) {
   return client === "claude-code" ? "Claude Code" : "Codex";
@@ -18660,7 +18775,7 @@ function formatCanonryPluginUpdateHint(clients) {
   if (names.length === 1) return `Update or reinstall \`canonry@canonry\` in ${names[0]}.`;
   return `Update or reinstall \`canonry@canonry\` in ${joinPluginSubjects(names)}.`;
 }
-var skillsClientSchema = z55.enum(["claude", "codex", "all"]);
+var skillsClientSchema = z56.enum(["claude", "codex", "all"]);
 var SkillsClients = skillsClientSchema.enum;
 var SKILL_MANIFEST_FILENAME = ".canonry-skill-manifest.json";
 function classifySkillFile(params) {
@@ -18677,108 +18792,6 @@ function coerceSkillManifest(parsed) {
   return null;
 }
 
-// ../contracts/src/statistics.ts
-import { z as z56 } from "zod";
-function round(value, dp = 4) {
-  const f = 10 ** dp;
-  return (Math.round(value * f) + 0) / f;
-}
-function roundSignificant(value, sig = 6) {
-  if (!Number.isFinite(value) || value === 0) return 0;
-  const magnitude = Math.ceil(Math.log10(Math.abs(value)));
-  const factor = 10 ** (sig - magnitude);
-  return (Math.round(value * factor) + 0) / factor;
-}
-function shareOf(part, total) {
-  if (!Number.isFinite(part) || !Number.isFinite(total)) return null;
-  if (part <= 0) return 0;
-  return total > 0 ? part / total : null;
-}
-function breakdownShares(parts) {
-  const total = parts.reduce((sum, part) => sum + Math.max(0, part), 0);
-  return parts.map((part) => shareOf(part, total) ?? 0);
-}
-function median(values) {
-  const sorted = values.filter((value) => Number.isFinite(value)).sort((left, right) => left - right);
-  if (sorted.length === 0) return null;
-  const middle = Math.floor(sorted.length / 2);
-  return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
-}
-function wilsonInterval(successes, n, z97 = 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 = z97 * z97;
-  const denom = 1 + z210 / n;
-  const center = (p + z210 / (2 * n)) / denom;
-  const margin = z97 / 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))
-  };
-}
-var linearTrendSchema = z56.object({
-  /** Change in the fitted value per one-index step. */
-  slope: z56.number(),
-  /** Fitted value at index 0. */
-  intercept: z56.number(),
-  /** Coefficient of determination in [0, 1]. `1` for a series with no variance. */
-  r2: z56.number(),
-  /** Fitted value at the first index. */
-  start: z56.number(),
-  /** Fitted value at the last index. */
-  end: z56.number(),
-  /** Count of finite observations the fit used (not the series length). */
-  n: z56.number(),
-  /**
-   * Index of the first observation the fit used, and of the last.
-   *
-   * `start` / `end` are evaluated AT these indices, not at the series' own ends.
-   * A caller drawing the line must span exactly this range: extending it across
-   * leading or trailing indices the metric has no data for draws a fitted claim
-   * over dates that were never measured.
-   */
-  startIndex: z56.number(),
-  endIndex: z56.number()
-});
-function linearTrend(values) {
-  const points = [];
-  for (const [index, value] of values.entries()) {
-    if (typeof value === "number" && Number.isFinite(value)) points.push({ x: index, y: value });
-  }
-  const n = points.length;
-  if (n < 2) return null;
-  const meanX = points.reduce((sum, p) => sum + p.x, 0) / n;
-  const meanY = points.reduce((sum, p) => sum + p.y, 0) / n;
-  let sxx = 0;
-  let sxy = 0;
-  for (const p of points) {
-    sxx += (p.x - meanX) ** 2;
-    sxy += (p.x - meanX) * (p.y - meanY);
-  }
-  const slope = sxy / sxx;
-  const intercept = meanY - slope * meanX;
-  let ssRes = 0;
-  let ssTot = 0;
-  for (const p of points) {
-    ssRes += (p.y - (slope * p.x + intercept)) ** 2;
-    ssTot += (p.y - meanY) ** 2;
-  }
-  const r2 = ssTot === 0 ? 1 : Math.min(1, Math.max(0, 1 - ssRes / ssTot));
-  const firstX = points[0].x;
-  const lastX = points[n - 1].x;
-  return {
-    slope: roundSignificant(slope),
-    intercept: roundSignificant(intercept),
-    r2: round(r2),
-    start: roundSignificant(slope * firstX + intercept),
-    end: roundSignificant(slope * lastX + intercept),
-    n,
-    startIndex: firstX,
-    endIndex: lastX
-  };
-}
-
 // ../contracts/src/traffic.ts
 import { z as z57 } from "zod";
 var trafficCrawlerSegmentsSchema = z57.object({
@@ -19214,6 +19227,17 @@ var trafficStatusResponseSchema = z57.object({
 });
 var trafficEventKindSchema = z57.enum(["crawler", "ai-user-fetch", "ai-referral"]);
 var TrafficEventKinds = trafficEventKindSchema.enum;
+var TRAFFIC_EVENT_KIND_FILTER_HINT = `all, or one or more (comma-separated) of: ${trafficEventKindSchema.options.join(", ")}`;
+function parseTrafficEventKindFilter(value) {
+  if (value === "all") return [...trafficEventKindSchema.options];
+  const kinds = [];
+  for (const member of value.split(",").map((part) => part.trim()).filter(Boolean)) {
+    const parsed = trafficEventKindSchema.safeParse(member);
+    if (!parsed.success) return null;
+    if (!kinds.includes(parsed.data)) kinds.push(parsed.data);
+  }
+  return kinds.length > 0 ? kinds : null;
+}
 var trafficSeriesGranularitySchema = z57.enum(["hour", "day"]);
 var TrafficSeriesGranularities = trafficSeriesGranularitySchema.enum;
 var trafficSeriesPointSchema = z57.object({
@@ -19321,6 +19345,16 @@ var trafficEventsResponseSchema = z57.object({
      * early gap, which is the better error than marking real data unmeasured.
      */
     coverageStart: z57.string().nullable(),
+    /**
+     * When the selected sources began counting AI-referral arrivals once per
+     * visit, or null when none holds hours counted by the older rule. Hours
+     * before it also counted a visitor's later pages, assets and API calls as
+     * arrivals and read high; stored hourly rows keep no visitor, so they
+     * cannot be recounted. Like `coverageStart`, not bound to the window.
+     * `trends.aiReferralLandedHits` is fitted only over buckets that begin at
+     * or after it. Optional so a newer client reads an older API.
+     */
+    aiReferralCountingChangedAt: z57.string().nullable().optional(),
     /**
      * Least-squares fit per charted metric, over the densified points.
      *
@@ -21435,6 +21469,14 @@ var trafficActivitySummarySchema = z66.object({
   coverageStart: z66.string().nullable(),
   /** Recording began on or before the prior window start. This does not establish uninterrupted ingestion. */
   priorWindowComplete: z66.boolean(),
+  /**
+   * When the project's sources began counting AI-referral arrivals once per
+   * visit, or null when none holds hours counted by the older rule. Earlier hours
+   * also counted a visitor's later requests and read high, and cannot be
+   * recounted, so referral deltas are null while the prior window starts
+   * before it. Not window-bound. Optional so a newer client reads an older API.
+   */
+  aiReferralCountingChangedAt: z66.string().nullable().optional(),
   hasData: z66.boolean().describe("True when the selected or prior window has stored crawler, user-fetch, countable referral or operator evidence, or the selected window has referral redirects. False means no qualifying stored evidence; it can occur with no, paused, errored or never-synced ingestion and out-of-window observations. It does not establish measured zero traffic or source health."),
   /** Verified crawler hits during the selected period and the equal preceding period. */
   verifiedCrawlerHits: trafficActivityCountSchema,
@@ -28478,8 +28520,9 @@ export {
   trafficSourceListResponseSchema,
   trafficSourceDetailDtoSchema,
   trafficStatusResponseSchema,
-  trafficEventKindSchema,
   TrafficEventKinds,
+  TRAFFIC_EVENT_KIND_FILTER_HINT,
+  parseTrafficEventKindFilter,
   trafficSeriesGranularitySchema,
   TrafficSeriesGranularities,
   trafficEventsResponseSchema,