@canonry/canonry 7.23.0 → 7.24.0

package/dist/{chunk-MRKV43TV.js → chunk-IM2BFAAT.js}

@@ -31,6 +31,7 @@ var providerQuotaPolicySchema = z2.object({
   maxRequestsPerMinute: z2.number().int().positive(),
   maxRequestsPerDay: z2.number().int().positive()
 });
+var PROVIDER_NAMES = ["gemini", "openai", "claude", "perplexity", "muse", "local", "cdp:chatgpt"];
 var ProviderNames = {
   gemini: "gemini",
   openai: "openai",
@@ -13581,14 +13582,20 @@ function breakdownShares(parts) {
   const total = parts.reduce((sum, part) => sum + Math.max(0, part), 0);
   return parts.map((part) => shareOf(part, total) ?? 0);
 }
-function wilsonInterval(successes, n, z75 = 1.96) {
+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, z76 = 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 = z75 * z75;
+  const z210 = z76 * z76;
   const denom = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denom;
-  const margin = z75 / denom * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z76 / 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))
@@ -21755,8 +21762,342 @@ function detectAgentRuntime(env) {
   return AGENT_NONE;
 }
 
-// ../contracts/src/ui-telemetry.ts
+// ../contracts/src/outcome-telemetry.ts
 import { z as z68 } from "zod";
+var OUTCOME_SURFACES = ["cli", "mcp-stdio", "mcp-http", "aero", "api", "dashboard", "system"];
+var outcomeSurfaceSchema = z68.enum(OUTCOME_SURFACES);
+var OutcomeSurfaces = outcomeSurfaceSchema.enum;
+var INTEGRATION_NAMES = [
+  "provider",
+  "gsc",
+  "ga4",
+  "bing",
+  "gbp",
+  "google_ads",
+  "gtm",
+  "openai_ads",
+  "traffic_cloudflare",
+  "traffic_vercel",
+  "traffic_cloud_run",
+  "wordpress",
+  "backlinks",
+  "webhook",
+  "agent_webhook",
+  "cdp",
+  /** The WordPress traffic-logger plugin source, apart from the WordPress publishing connection. */
+  "traffic_wordpress"
+];
+var integrationNameSchema = z68.enum(INTEGRATION_NAMES);
+var IntegrationNames = integrationNameSchema.enum;
+var CONNECTION_ACTIONS = ["connect", "disconnect", "test", "reauth", "select"];
+var connectionActionSchema = z68.enum(CONNECTION_ACTIONS);
+var ConnectionActions = connectionActionSchema.enum;
+var CONNECTION_STATUSES = ["started", "succeeded", "failed", "cancelled"];
+var connectionStatusSchema = z68.enum(CONNECTION_STATUSES);
+var ConnectionStatuses = connectionStatusSchema.enum;
+var OUTCOME_STATUSES = ["succeeded", "partial", "failed", "skipped", "cancelled"];
+var outcomeStatusSchema = z68.enum(OUTCOME_STATUSES);
+var OutcomeStatuses = outcomeStatusSchema.enum;
+var OUTCOME_TRIGGERS = ["manual", "scheduled", "agent", "startup", "retry", "push"];
+var outcomeTriggerSchema = z68.enum(OUTCOME_TRIGGERS);
+var OutcomeTriggers = outcomeTriggerSchema.enum;
+var OUTCOME_REASON_CODES = [
+  "AUTH_DENIED",
+  "OAUTH_CANCELLED",
+  "OAUTH_STATE_INVALID",
+  "INVALID_CREDENTIALS",
+  "PERMISSION_MISSING",
+  "NOT_CONNECTED",
+  "ALREADY_CONNECTED",
+  "NOT_FOUND",
+  "ACCOUNT_NOT_FOUND",
+  "PROPERTY_NOT_FOUND",
+  "QUOTA_EXCEEDED",
+  "RATE_LIMITED",
+  "BILLING",
+  "NETWORK",
+  "TIMEOUT",
+  "HTTP_4XX",
+  "HTTP_5XX",
+  "BLOCKED_UNSAFE_URL",
+  "VALIDATION",
+  "UNSUPPORTED",
+  "NO_DATA",
+  "NOT_DUE",
+  "GATE_REFUSED",
+  "OPERATION_IN_PROGRESS",
+  "QUARANTINED",
+  "CANCELLED_BY_USER",
+  "SERVER_RESTARTED",
+  "INTERNAL",
+  "UNKNOWN",
+  "PORT_IN_USE",
+  "MIGRATION_FAILED",
+  "UNCAUGHT_EXCEPTION",
+  "UNHANDLED_REJECTION"
+];
+var outcomeReasonCodeSchema = z68.enum(OUTCOME_REASON_CODES);
+var OutcomeReasonCodes = outcomeReasonCodeSchema.enum;
+var FEATURE_OPERATIONS = {
+  search_console: ["sync", "inspect", "sitemap_submit"],
+  ga4: ["sync"],
+  bing: ["sync", "inspect"],
+  gbp: ["sync", "reviews"],
+  google_ads: ["sync"],
+  gtm: ["sync"],
+  openai_ads: ["sync", "operation", "activation", "reconcile"],
+  server_traffic: ["sync", "ingest", "backfill", "reset"],
+  backlinks: ["install", "sync", "extract"],
+  content: ["analyze", "brief"],
+  research: ["run"],
+  discovery: ["run"],
+  sentiment: ["run"],
+  aero: ["turn"],
+  webhooks: ["deliver", "test"],
+  schedules: ["slot"],
+  exports: ["export"],
+  providers: ["reload"],
+  wordpress: ["schema_deploy", "llms_txt", "meta_write", "publish"],
+  measurement: ["publish"],
+  insights: ["generate"],
+  site_liveness: ["check"],
+  reports: ["download"],
+  data_refresh: ["refresh"],
+  server: ["start", "crash"]
+};
+var FEATURE_NAMES = Object.keys(FEATURE_OPERATIONS);
+var featureNameSchema = z68.enum(FEATURE_NAMES);
+var FeatureNames = featureNameSchema.enum;
+var OUTCOME_COUNT_KEYS = [
+  "rows",
+  "pages",
+  "urls",
+  "links",
+  "domains",
+  "reviews",
+  "events",
+  "crawlerHits",
+  "aiReferralHits",
+  "aiUserFetchHits",
+  "campaigns",
+  "operations",
+  "queries",
+  "snapshots",
+  "briefs",
+  "gaps",
+  "targets",
+  "insights",
+  "toolCalls",
+  "toolErrors",
+  "modelCalls",
+  "inputTokens",
+  "outputTokens",
+  "cachedTokens",
+  "costMicros",
+  "attempts",
+  "deliveries",
+  "failures",
+  "skipped",
+  "providers",
+  "items",
+  "bytes"
+];
+var COUNT_KEY_SET = new Set(OUTCOME_COUNT_KEYS);
+var MAX_COUNT = 1e12;
+var countValueSchema = z68.number().int().min(0).max(MAX_COUNT);
+var countsSchema = z68.record(z68.string(), countValueSchema).refine((obj) => Object.keys(obj).length > 0 && Object.keys(obj).length <= 12, "counts must have 1 to 12 keys").refine((obj) => Object.keys(obj).every((k) => COUNT_KEY_SET.has(k)), "unknown count key");
+var WEBHOOK_TARGETS = ["first_party", "slack", "discord"];
+var webhookTargetSchema = z68.enum(WEBHOOK_TARGETS);
+var WebhookTargets = webhookTargetSchema.enum;
+var STATUS_CLASSES = ["2xx", "3xx", "4xx", "5xx", "timeout", "network", "blocked"];
+var statusClassSchema = z68.enum(STATUS_CLASSES);
+var StatusClasses = statusClassSchema.enum;
+var DURATION_BUCKETS = ["under_1s", "1s_to_10s", "10s_to_1m", "1m_to_5m", "5m_to_30m", "30m_or_more"];
+var durationBucketSchema = z68.enum(DURATION_BUCKETS);
+var DurationBuckets = durationBucketSchema.enum;
+function bucketDuration(durationMs) {
+  const duration = Number.isFinite(durationMs) ? Math.max(0, durationMs) : 0;
+  if (duration < 1e3) return "under_1s";
+  if (duration < 1e4) return "1s_to_10s";
+  if (duration < 6e4) return "10s_to_1m";
+  if (duration < 3e5) return "1m_to_5m";
+  if (duration < 18e5) return "5m_to_30m";
+  return "30m_or_more";
+}
+var errorNameSchema = z68.string().regex(/^[A-Z_$][\w$]{0,39}$/i);
+var agentSlugSchema = z68.string().regex(/^[a-z0-9][a-z0-9._-]{0,39}$/);
+var providerNameSchema2 = z68.enum(PROVIDER_NAMES);
+var modelIdSchema2 = z68.string().regex(/^[A-Z0-9][\w.:/@-]{0,99}$/i).refine((v) => !v.includes("://"), "a model id is never a URL");
+var slugSchema = z68.string().regex(/^[a-z0-9][a-z0-9._-]{0,31}$/);
+var integrationConnectionPropertiesSchema = z68.object({
+  integration: integrationNameSchema,
+  provider: providerNameSchema2.optional(),
+  action: connectionActionSchema,
+  status: connectionStatusSchema,
+  reasonCode: outcomeReasonCodeSchema.optional(),
+  errorName: errorNameSchema.optional(),
+  target: webhookTargetSchema.optional(),
+  surface: outcomeSurfaceSchema.optional(),
+  agent: agentSlugSchema.optional(),
+  durationBucket: durationBucketSchema.optional(),
+  attempt: z68.number().int().min(1).max(1e6).optional(),
+  /** The install's first success of this kind; set by the helpers, never by callers. */
+  first: z68.literal(true).optional()
+}).strict().refine(
+  (p) => p.integration === IntegrationNames.provider === (p.provider !== void 0),
+  "provider is required for, and only for, integration provider"
+).refine(
+  (p) => p.status === ConnectionStatuses.succeeded || p.status === ConnectionStatuses.started || p.reasonCode !== void 0,
+  "a failed or cancelled attempt needs a reasonCode"
+);
+var featureCompletedPropertiesSchema = z68.object({
+  feature: featureNameSchema,
+  operation: z68.string().regex(/^[a-z][a-z_]{0,31}$/),
+  status: outcomeStatusSchema,
+  trigger: outcomeTriggerSchema.optional(),
+  surface: outcomeSurfaceSchema.optional(),
+  agent: agentSlugSchema.optional(),
+  reasonCode: outcomeReasonCodeSchema.optional(),
+  errorName: errorNameSchema.optional(),
+  durationBucket: durationBucketSchema.optional(),
+  counts: countsSchema.optional(),
+  target: webhookTargetSchema.optional(),
+  eventType: notificationEventSchema.optional(),
+  statusClass: statusClassSchema.optional(),
+  provider: providerNameSchema2.optional(),
+  model: modelIdSchema2.optional(),
+  modelProvider: slugSchema.optional(),
+  sampleRate: z68.number().int().min(1).max(1e6).optional(),
+  droppedBefore: z68.number().int().min(0).max(MAX_COUNT).optional(),
+  domainHash: z68.string().regex(/^[0-9a-f]{64}$/).optional(),
+  first: z68.literal(true).optional()
+}).strict().refine(
+  (p) => FEATURE_OPERATIONS[p.feature].includes(p.operation),
+  "operation is not one this feature reports"
+).refine((p) => p.status === OutcomeStatuses.succeeded || p.reasonCode !== void 0, "a non-succeeded outcome needs a reasonCode");
+var INSTALL_SOURCES = ["npm", "homebrew", "docker", "source"];
+var installSourceSchema = z68.enum(INSTALL_SOURCES);
+var installRefSchema = z68.string().regex(/^[a-z0-9][a-z0-9-]{0,31}$/);
+function normalizeInstallRef(value) {
+  const ref = value?.trim().toLowerCase();
+  return ref && installRefSchema.safeParse(ref).success ? ref : void 0;
+}
+var INSTALL_STATE_COUNT_KEYS = [
+  "projects",
+  "queries",
+  "competitors",
+  "locations",
+  "schedules",
+  "webhooks",
+  "agentWebhooks",
+  "trafficSources",
+  "googleConnections",
+  "bingConnections",
+  "backlinkSources",
+  "adsAccounts"
+];
+var INSTALL_STATE_USAGE_KEYS = [
+  "sweeps",
+  "audits",
+  "providerCalls",
+  "inputTokens",
+  "outputTokens",
+  "costMicros",
+  "aeroTurns",
+  "aeroModelCalls",
+  "aeroInputTokens",
+  "aeroOutputTokens",
+  "aeroCostMicros",
+  "webhookDeliveries"
+];
+var fixedKeyCounts = (keys) => {
+  const allowed = new Set(keys);
+  return z68.record(z68.string(), countValueSchema).refine((obj) => Object.keys(obj).every((k) => allowed.has(k)), "unknown key");
+};
+var installStatePropertiesSchema = z68.object({
+  providers: z68.array(providerNameSchema2).max(PROVIDER_NAMES.length),
+  integrations: z68.array(integrationNameSchema.exclude([IntegrationNames.provider])).max(INTEGRATION_NAMES.length),
+  counts: fixedKeyCounts(INSTALL_STATE_COUNT_KEYS),
+  usage24h: fixedKeyCounts(INSTALL_STATE_USAGE_KEYS),
+  providerCalls24h: fixedKeyCounts(PROVIDER_NAMES).optional(),
+  agentProvider: slugSchema.optional(),
+  agentModel: modelIdSchema2.optional(),
+  uptimeBucket: durationBucketSchema.optional(),
+  installSource: installSourceSchema.optional(),
+  installRef: installRefSchema.optional()
+}).strict();
+function statusClassOf(status) {
+  if (status === void 0 || status === null || status === 0) return "network";
+  if (status >= 500) return "5xx";
+  if (status >= 400) return "4xx";
+  if (status >= 300) return "3xx";
+  return "2xx";
+}
+var NETWORK_CODES = /* @__PURE__ */ new Set(["ECONNREFUSED", "ECONNRESET", "ENOTFOUND", "EAI_AGAIN", "EHOSTUNREACH", "ENETUNREACH", "EPIPE", "UND_ERR_SOCKET"]);
+var TIMEOUT_CODES = /* @__PURE__ */ new Set(["ETIMEDOUT", "ESOCKETTIMEDOUT", "UND_ERR_CONNECT_TIMEOUT", "UND_ERR_HEADERS_TIMEOUT", "UND_ERR_BODY_TIMEOUT"]);
+function httpStatusOf(err) {
+  for (const value of [err.status, err.statusCode, err.response?.status, err.details?.httpStatus]) {
+    if (typeof value === "number" && value >= 100 && value <= 599) return value;
+  }
+  return void 0;
+}
+function classifyOutcomeError(err) {
+  if (!err || typeof err !== "object") return { reasonCode: "UNKNOWN" };
+  const e = err;
+  const rawName = typeof e.name === "string" ? e.name : err.constructor?.name;
+  const errorName = typeof rawName === "string" && errorNameSchema.safeParse(rawName).success ? rawName : void 0;
+  const code = typeof e.code === "string" ? e.code : void 0;
+  const known = code && OUTCOME_REASON_CODES.includes(code) ? code : void 0;
+  if (known) return { reasonCode: known, errorName };
+  const cause = e.cause && typeof e.cause === "object" ? e.cause : void 0;
+  const causeCode = typeof cause?.code === "string" ? cause.code : void 0;
+  const causeName = typeof cause?.name === "string" ? cause.name : void 0;
+  if (errorName === "AbortError" || errorName === "TimeoutError" || causeName === "TimeoutError" || code && TIMEOUT_CODES.has(code) || causeCode && TIMEOUT_CODES.has(causeCode)) return { reasonCode: "TIMEOUT", errorName };
+  if (code && NETWORK_CODES.has(code) || causeCode && NETWORK_CODES.has(causeCode)) return { reasonCode: "NETWORK", errorName };
+  if (errorName === "TypeError" && e.message === "fetch failed") return { reasonCode: "NETWORK", errorName };
+  if (code === "PROVIDER_AUTH" || code === "AUTH_INVALID" || code === "AUTH_REQUIRED") return { reasonCode: "INVALID_CREDENTIALS", errorName };
+  if (code === "FORBIDDEN") return { reasonCode: "PERMISSION_MISSING", errorName };
+  if (code === "PROVIDER_BILLING") return { reasonCode: "BILLING", errorName };
+  if (code === "NOT_FOUND") return { reasonCode: "NOT_FOUND", errorName };
+  if (code === "VALIDATION_ERROR") return { reasonCode: "VALIDATION", errorName };
+  if (code === "RUN_CANCELLED") return { reasonCode: "CANCELLED_BY_USER", errorName };
+  const status = httpStatusOf(e);
+  if (status === 401) return { reasonCode: "INVALID_CREDENTIALS", errorName };
+  if (status === 403) return { reasonCode: "PERMISSION_MISSING", errorName };
+  if (status === 404) return { reasonCode: "NOT_FOUND", errorName };
+  if (status === 429) return { reasonCode: "RATE_LIMITED", errorName };
+  if (status !== void 0 && status >= 500) return { reasonCode: "HTTP_5XX", errorName };
+  if (status !== void 0 && status >= 400) return { reasonCode: "HTTP_4XX", errorName };
+  return { reasonCode: "UNKNOWN", errorName };
+}
+function providerErrorOutcomeReason(code) {
+  switch (code) {
+    case "PROVIDER_AUTH":
+      return "INVALID_CREDENTIALS";
+    case "PROVIDER_BILLING":
+      return "BILLING";
+    case "RATE_LIMITED":
+      return "RATE_LIMITED";
+    case "PROVIDER_UNAVAILABLE":
+      return "HTTP_5XX";
+    case "TIMEOUT":
+      return "TIMEOUT";
+    case "NETWORK":
+      return "NETWORK";
+    case "PARSE_ERROR":
+      return "UNKNOWN";
+    case "UNKNOWN":
+      return "UNKNOWN";
+  }
+}
+function classifyProviderOutcomeError(err) {
+  const classified = classifyOutcomeError(err);
+  if (classified.reasonCode !== "UNKNOWN") return classified;
+  return { ...classified, reasonCode: providerErrorOutcomeReason(classifyProviderErrorMessage(describeError(err))) };
+}
+
+// ../contracts/src/ui-telemetry.ts
+import { z as z69 } from "zod";
 var UI_PAGES = [
   "/",
   "/projects",
@@ -21784,7 +22125,7 @@ var UI_PAGES = [
   "not-found",
   "other"
 ];
-var uiPageSchema = z68.enum(UI_PAGES);
+var uiPageSchema = z69.enum(UI_PAGES);
 var UI_PROJECT_TABS = [
   "overview",
   "portfolio",
@@ -21802,7 +22143,7 @@ var UI_PROJECT_TABS = [
   "settings",
   "other"
 ];
-var uiProjectTabSchema = z68.enum(UI_PROJECT_TABS);
+var uiProjectTabSchema = z69.enum(UI_PROJECT_TABS);
 var UI_ACTIONS = [
   "sweep.launch",
   "sweep.cancel",
@@ -21842,7 +22183,7 @@ var UI_ACTIONS = [
   /** A table search settled on a non-empty query (debounced or Enter; the text is never sent). */
   "search.submit"
 ];
-var uiActionSchema = z68.enum(UI_ACTIONS);
+var uiActionSchema = z69.enum(UI_ACTIONS);
 var UI_INTEGRATIONS = [
   "google",
   "gsc",
@@ -21858,9 +22199,9 @@ var UI_INTEGRATIONS = [
   "traffic_cloud_run",
   "traffic_wordpress"
 ];
-var uiIntegrationSchema = z68.enum(UI_INTEGRATIONS);
+var uiIntegrationSchema = z69.enum(UI_INTEGRATIONS);
 var UI_FILTERS = ["provider", "model", "location", "window", "query_class", "other"];
-var uiFilterSchema = z68.enum(UI_FILTERS);
+var uiFilterSchema = z69.enum(UI_FILTERS);
 var UI_EXPORT_FORMATS = ["csv", "json", "html"];
 var UI_ERROR_KINDS = ["render", "unhandled", "api"];
 var UI_STATUS_CLASSES = ["4xx", "5xx", "network"];
@@ -21945,44 +22286,44 @@ function isUiApiRouteTemplate(route) {
     return PARAM_SEGMENT.test(segment) || UI_ROUTE_FIXED_CHILDREN.has(`${previous}/${segment}`);
   });
 }
-var uiEventBaseSchema = z68.object({
-  eventId: z68.string().uuid(),
-  uiSessionId: z68.string().uuid(),
+var uiEventBaseSchema = z69.object({
+  eventId: z69.string().uuid(),
+  uiSessionId: z69.string().uuid(),
   page: uiPageSchema
 });
-var uiTelemetryEventSchema = z68.discriminatedUnion("event", [
+var uiTelemetryEventSchema = z69.discriminatedUnion("event", [
   uiEventBaseSchema.extend({
-    event: z68.literal("ui.page_viewed"),
+    event: z69.literal("ui.page_viewed"),
     tab: uiProjectTabSchema.optional()
   }).strict(),
   uiEventBaseSchema.extend({
-    event: z68.literal("ui.action"),
+    event: z69.literal("ui.action"),
     action: uiActionSchema,
     tab: uiProjectTabSchema.optional(),
     integration: uiIntegrationSchema.optional(),
-    format: z68.enum(UI_EXPORT_FORMATS).optional(),
+    format: z69.enum(UI_EXPORT_FORMATS).optional(),
     filter: uiFilterSchema.optional()
   }).strict(),
   uiEventBaseSchema.extend({
-    event: z68.literal("ui.error"),
-    kind: z68.enum(UI_ERROR_KINDS),
+    event: z69.literal("ui.error"),
+    kind: z69.enum(UI_ERROR_KINDS),
     tab: uiProjectTabSchema.optional(),
-    component: z68.string().regex(UI_COMPONENT_PATTERN).optional(),
-    errorName: z68.string().regex(UI_ERROR_NAME_PATTERN).optional(),
-    route: z68.string().max(UI_API_ROUTE_MAX_LENGTH).refine(isUiApiRouteTemplate, "route must be a route template").optional(),
-    method: z68.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).optional(),
-    statusClass: z68.enum(UI_STATUS_CLASSES).optional(),
-    status: z68.number().int().min(400).max(599).optional()
+    component: z69.string().regex(UI_COMPONENT_PATTERN).optional(),
+    errorName: z69.string().regex(UI_ERROR_NAME_PATTERN).optional(),
+    route: z69.string().max(UI_API_ROUTE_MAX_LENGTH).refine(isUiApiRouteTemplate, "route must be a route template").optional(),
+    method: z69.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).optional(),
+    statusClass: z69.enum(UI_STATUS_CLASSES).optional(),
+    status: z69.number().int().min(400).max(599).optional()
   }).strict(),
   uiEventBaseSchema.extend({
-    event: z68.literal("ui.vitals"),
-    metric: z68.enum(UI_VITAL_METRICS),
-    rating: z68.enum(UI_VITAL_RATINGS)
+    event: z69.literal("ui.vitals"),
+    metric: z69.enum(UI_VITAL_METRICS),
+    rating: z69.enum(UI_VITAL_RATINGS)
   }).strict()
 ]);
 
 // ../contracts/src/feedback.ts
-import { z as z69 } from "zod";
+import { z as z70 } from "zod";
 
 // ../contracts/src/log-redaction.ts
 var REDACTED = "[REDACTED]";
@@ -22134,7 +22475,7 @@ function redactEmbeddedUrls(value) {
 
 // ../contracts/src/feedback.ts
 var FEEDBACK_KINDS = ["struggle", "bug", "improvement", "other"];
-var feedbackKindSchema = z69.enum(FEEDBACK_KINDS);
+var feedbackKindSchema = z70.enum(FEEDBACK_KINDS);
 var FEEDBACK_LIMITS = {
   summary: 500,
   details: 4e3,
@@ -22142,17 +22483,17 @@ var FEEDBACK_LIMITS = {
   command: 120,
   errorCode: 40
 };
-var feedbackSubmissionSchema = z69.object({
+var feedbackSubmissionSchema = z70.object({
   kind: feedbackKindSchema,
-  summary: z69.string().trim().min(1).max(FEEDBACK_LIMITS.summary),
-  details: z69.string().trim().min(1).max(FEEDBACK_LIMITS.details).optional(),
-  area: z69.string().trim().min(1).max(FEEDBACK_LIMITS.area).optional(),
-  command: z69.string().trim().min(1).max(FEEDBACK_LIMITS.command).optional(),
-  errorCode: z69.string().trim().min(1).max(FEEDBACK_LIMITS.errorCode).optional()
+  summary: z70.string().trim().min(1).max(FEEDBACK_LIMITS.summary),
+  details: z70.string().trim().min(1).max(FEEDBACK_LIMITS.details).optional(),
+  area: z70.string().trim().min(1).max(FEEDBACK_LIMITS.area).optional(),
+  command: z70.string().trim().min(1).max(FEEDBACK_LIMITS.command).optional(),
+  errorCode: z70.string().trim().min(1).max(FEEDBACK_LIMITS.errorCode).optional()
 }).strict();
-var feedbackAcceptedDtoSchema = z69.object({
-  accepted: z69.boolean(),
-  id: z69.string()
+var feedbackAcceptedDtoSchema = z70.object({
+  accepted: z70.boolean(),
+  id: z70.string()
 });
 function redactFeedbackText(value, limit) {
   return truncateUtf16(
@@ -22169,90 +22510,90 @@ var SECRET_FLAG_VALUE = /(?<=^|[ \t])(--?(?:[a-z\d]+-)*(?:key|token|secret|passw
 var BARE_CREDENTIAL = /\b(?:sk-[\w-]{16,}|AIza[\w-]{30,}|pplx-[A-Za-z0-9]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|github_pat_\w{20,}|cnry_[\w-]{16,})/g;
 
 // ../contracts/src/operational-logs.ts
-import { z as z70 } from "zod";
-var operationalLogLevelSchema = z70.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
-var diagnosticContextSchema = z70.object({
-  runId: z70.string().min(1).max(256).optional(),
-  projectId: z70.string().min(1).max(256).optional(),
-  requestId: z70.string().min(1).max(256).optional(),
-  actor: z70.string().min(1).max(512).optional(),
-  credentialId: z70.string().min(1).max(512).optional(),
-  userAgent: z70.string().min(1).max(512).optional(),
-  actorSession: z70.string().min(1).max(512).optional(),
-  method: z70.string().min(1).max(16).optional(),
-  route: z70.string().min(1).max(256).optional(),
-  operationId: z70.string().min(1).max(256).optional(),
-  jobId: z70.string().min(1).max(256).optional(),
-  taskId: z70.string().min(1).max(256).optional(),
-  traceId: z70.string().min(1).max(256).optional(),
-  provider: z70.string().min(1).max(256).optional(),
-  errorCode: z70.string().min(1).max(128).optional(),
-  attempt: z70.number().finite().optional(),
-  count: z70.number().finite().optional(),
-  total: z70.number().finite().optional(),
-  progress: z70.number().finite().optional(),
-  httpStatus: z70.number().finite().optional(),
-  statusCode: z70.number().finite().optional(),
-  durationMs: z70.number().finite().optional(),
-  bytes: z70.number().finite().optional(),
-  retryAfterMs: z70.number().finite().optional(),
-  retriable: z70.boolean().optional(),
-  retrying: z70.boolean().optional(),
-  cancelled: z70.boolean().optional(),
-  success: z70.boolean().optional()
-}).strict();
-var operationalLogEntryDtoSchema = z70.object({
-  cursor: z70.string().min(1).max(512),
-  ts: z70.string().datetime(),
+import { z as z71 } from "zod";
+var operationalLogLevelSchema = z71.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
+var diagnosticContextSchema = z71.object({
+  runId: z71.string().min(1).max(256).optional(),
+  projectId: z71.string().min(1).max(256).optional(),
+  requestId: z71.string().min(1).max(256).optional(),
+  actor: z71.string().min(1).max(512).optional(),
+  credentialId: z71.string().min(1).max(512).optional(),
+  userAgent: z71.string().min(1).max(512).optional(),
+  actorSession: z71.string().min(1).max(512).optional(),
+  method: z71.string().min(1).max(16).optional(),
+  route: z71.string().min(1).max(256).optional(),
+  operationId: z71.string().min(1).max(256).optional(),
+  jobId: z71.string().min(1).max(256).optional(),
+  taskId: z71.string().min(1).max(256).optional(),
+  traceId: z71.string().min(1).max(256).optional(),
+  provider: z71.string().min(1).max(256).optional(),
+  errorCode: z71.string().min(1).max(128).optional(),
+  attempt: z71.number().finite().optional(),
+  count: z71.number().finite().optional(),
+  total: z71.number().finite().optional(),
+  progress: z71.number().finite().optional(),
+  httpStatus: z71.number().finite().optional(),
+  statusCode: z71.number().finite().optional(),
+  durationMs: z71.number().finite().optional(),
+  bytes: z71.number().finite().optional(),
+  retryAfterMs: z71.number().finite().optional(),
+  retriable: z71.boolean().optional(),
+  retrying: z71.boolean().optional(),
+  cancelled: z71.boolean().optional(),
+  success: z71.boolean().optional()
+}).strict();
+var operationalLogEntryDtoSchema = z71.object({
+  cursor: z71.string().min(1).max(512),
+  ts: z71.string().datetime(),
   level: operationalLogLevelSchema,
-  module: z70.string().min(1).max(256),
-  action: z70.string().min(1).max(256),
-  message: z70.string().max(4096).optional(),
-  runId: z70.string().min(1).max(256).optional(),
-  projectId: z70.string().min(1).max(256).optional(),
+  module: z71.string().min(1).max(256),
+  action: z71.string().min(1).max(256),
+  message: z71.string().max(4096).optional(),
+  runId: z71.string().min(1).max(256).optional(),
+  projectId: z71.string().min(1).max(256).optional(),
   context: diagnosticContextSchema
 }).strict();
-var logQuerySchema = z70.object({
+var logQuerySchema = z71.object({
   level: operationalLogLevelSchema.optional(),
-  module: z70.string().trim().min(1).max(256).optional(),
-  runId: z70.string().trim().min(1).max(256).optional(),
-  projectId: z70.string().trim().min(1).max(256).optional(),
-  actor: z70.string().trim().min(1).max(512).optional(),
-  requestId: z70.string().trim().min(1).max(256).optional(),
-  since: z70.string().datetime().optional(),
-  until: z70.string().datetime().optional(),
-  limit: z70.coerce.number().int().min(1).max(200).default(100),
-  cursor: z70.string().trim().min(1).max(512).optional()
+  module: z71.string().trim().min(1).max(256).optional(),
+  runId: z71.string().trim().min(1).max(256).optional(),
+  projectId: z71.string().trim().min(1).max(256).optional(),
+  actor: z71.string().trim().min(1).max(512).optional(),
+  requestId: z71.string().trim().min(1).max(256).optional(),
+  since: z71.string().datetime().optional(),
+  until: z71.string().datetime().optional(),
+  limit: z71.coerce.number().int().min(1).max(200).default(100),
+  cursor: z71.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: z70.ZodIssueCode.custom, path: ["until"], message: '"until" must be on or after "since".' });
+    ctx.addIssue({ code: z71.ZodIssueCode.custom, path: ["until"], message: '"until" must be on or after "since".' });
   }
 });
-var retentionPolicySchema = z70.object({
-  maxEntries: z70.number().int().positive(),
-  maxAgeSeconds: z70.number().int().positive()
+var retentionPolicySchema = z71.object({
+  maxEntries: z71.number().int().positive(),
+  maxAgeSeconds: z71.number().int().positive()
 }).strict();
-var operationalLogListDtoSchema = z70.object({
-  entries: z70.array(operationalLogEntryDtoSchema),
-  nextCursor: z70.string().min(1).max(512).nullable(),
+var operationalLogListDtoSchema = z71.object({
+  entries: z71.array(operationalLogEntryDtoSchema),
+  nextCursor: z71.string().min(1).max(512).nullable(),
   /** Matching entries left after this page. */
-  truncated: z70.number().int().nonnegative(),
+  truncated: z71.number().int().nonnegative(),
   /** Entries evicted by the active retention policy. */
-  dropped: z70.number().int().nonnegative(),
-  retention: z70.enum(["process", "durable"]),
+  dropped: z71.number().int().nonnegative(),
+  retention: z71.enum(["process", "durable"]),
   retentionPolicy: retentionPolicySchema.optional(),
   /** Best-effort persistence failures observed by this store. */
-  captureErrors: z70.number().int().nonnegative().optional(),
-  observedAt: z70.string().datetime()
+  captureErrors: z71.number().int().nonnegative().optional(),
+  observedAt: z71.string().datetime()
 }).strict();
 var OPERATIONAL_LOG_FIELDS_HEADER = "x-canonry-log-fields";
 var OPERATIONAL_LOG_OPT_IN_CONTEXT_FIELDS = ["provider"];
-var diagnosticContextReadSchema = z70.object(diagnosticContextSchema.shape);
-var operationalLogEntryReadSchema = z70.object({ ...operationalLogEntryDtoSchema.shape, context: diagnosticContextReadSchema });
-var operationalLogListReadSchema = z70.object({
+var diagnosticContextReadSchema = z71.object(diagnosticContextSchema.shape);
+var operationalLogEntryReadSchema = z71.object({ ...operationalLogEntryDtoSchema.shape, context: diagnosticContextReadSchema });
+var operationalLogListReadSchema = z71.object({
   ...operationalLogListDtoSchema.shape,
-  entries: z70.array(operationalLogEntryReadSchema),
-  retentionPolicy: z70.object(retentionPolicySchema.shape).optional()
+  entries: z71.array(operationalLogEntryReadSchema),
+  retentionPolicy: z71.object(retentionPolicySchema.shape).optional()
 });
 
 // ../contracts/src/semver.ts
@@ -22318,81 +22659,81 @@ function asRecord(value) {
 }
 
 // ../contracts/src/referral-assessment.ts
-import { z as z71 } from "zod";
-var referralAssessmentQuerySchema = z71.object({
+import { z as z72 } from "zod";
+var referralAssessmentQuerySchema = z72.object({
   startDate: calendarDateSchema,
   endDate: calendarDateSchema,
-  sourceId: z71.string().trim().min(1).optional(),
-  burstThreshold: z71.number().int().min(1).max(1e6).optional(),
-  ratioThreshold: z71.number().min(1).max(1e3).optional(),
-  limit: z71.number().int().min(1).max(500).optional()
-}).strict();
-var countsSchema = z71.object({
-  total: z71.number().int().nonnegative(),
-  paid: z71.number().int().nonnegative(),
-  organic: z71.number().int().nonnegative(),
-  unknown: z71.number().int().nonnegative()
-});
-var referralAssessmentSchema = z71.object({
-  scope: z71.object({
-    project: z71.string(),
-    sourceId: z71.string().nullable(),
-    attribution: z71.literal("project-source-only"),
-    unavailableDimensions: z71.array(z71.enum(["property", "target", "market"]))
+  sourceId: z72.string().trim().min(1).optional(),
+  burstThreshold: z72.number().int().min(1).max(1e6).optional(),
+  ratioThreshold: z72.number().min(1).max(1e3).optional(),
+  limit: z72.number().int().min(1).max(500).optional()
+}).strict();
+var countsSchema2 = z72.object({
+  total: z72.number().int().nonnegative(),
+  paid: z72.number().int().nonnegative(),
+  organic: z72.number().int().nonnegative(),
+  unknown: z72.number().int().nonnegative()
+});
+var referralAssessmentSchema = z72.object({
+  scope: z72.object({
+    project: z72.string(),
+    sourceId: z72.string().nullable(),
+    attribution: z72.literal("project-source-only"),
+    unavailableDimensions: z72.array(z72.enum(["property", "target", "market"]))
   }),
-  window: z71.object({ startDate: calendarDateSchema, endDate: calendarDateSchema, timeZone: z71.literal("UTC") }),
-  rule: z71.object({
-    version: z71.literal("hourly-normalized-path-v1"),
-    burstThreshold: z71.number().int().positive(),
-    ratioThreshold: z71.number().positive(),
-    calibration: z71.enum(["uncalibrated-default", "request-override"]),
-    grouping: z71.array(z71.string()),
-    confirmsAutomation: z71.literal(false)
+  window: z72.object({ startDate: calendarDateSchema, endDate: calendarDateSchema, timeZone: z72.literal("UTC") }),
+  rule: z72.object({
+    version: z72.literal("hourly-normalized-path-v1"),
+    burstThreshold: z72.number().int().positive(),
+    ratioThreshold: z72.number().positive(),
+    calibration: z72.enum(["uncalibrated-default", "request-override"]),
+    grouping: z72.array(z72.string()),
+    confirmsAutomation: z72.literal(false)
   }),
-  totals: z71.object({
-    raw: countsSchema,
-    redirects: countsSchema,
-    subresources: countsSchema,
-    countable: countsSchema,
-    suspected: countsSchema,
-    adjustedEstimate: countsSchema
+  totals: z72.object({
+    raw: countsSchema2,
+    redirects: countsSchema2,
+    subresources: countsSchema2,
+    countable: countsSchema2,
+    suspected: countsSchema2,
+    adjustedEstimate: countsSchema2
   }),
-  bursts: z71.array(z71.object({
-    sourceId: z71.string(),
-    product: z71.string(),
-    landingPathNormalized: z71.string(),
-    tsHour: z71.string(),
-    counts: countsSchema
+  bursts: z72.array(z72.object({
+    sourceId: z72.string(),
+    product: z72.string(),
+    landingPathNormalized: z72.string(),
+    tsHour: z72.string(),
+    counts: countsSchema2
   })),
-  evidence: z71.object({ total: z71.number().int().nonnegative(), returned: z71.number().int().nonnegative(), truncated: z71.boolean() }),
-  comparison: z71.object({
-    status: z71.literal("unavailable"),
-    serverCountable: z71.number().int().nonnegative(),
-    serverObservation: z71.enum(["missing", "observed-zero", "observed-positive"]),
+  evidence: z72.object({ total: z72.number().int().nonnegative(), returned: z72.number().int().nonnegative(), truncated: z72.boolean() }),
+  comparison: z72.object({
+    status: z72.literal("unavailable"),
+    serverCountable: z72.number().int().nonnegative(),
+    serverObservation: z72.enum(["missing", "observed-zero", "observed-positive"]),
     /**
      * Dimension-deduplicated GA AI sessions. With no stored AI row in the
      * window: `0` (`observed-zero`) when the latest GA sync queried the whole
      * window (GA4 omits zero rows), else `null` (`missing`).
      */
-    gaSessions: z71.number().int().nonnegative().nullable(),
-    gaObservation: z71.enum(["missing", "observed-zero", "observed-positive"]),
+    gaSessions: z72.number().int().nonnegative().nullable(),
+    gaObservation: z72.enum(["missing", "observed-zero", "observed-positive"]),
     /**
      * Descriptive quotient only (`serverCountable / gaSessions`, a multiplier
      * where 3 is three times as many, never a percent), rounded to 2
      * decimals. Not a matched, coverage-complete comparison.
      */
-    observedRatio: z71.number().nonnegative().nullable(),
+    observedRatio: z72.number().nonnegative().nullable(),
     /** Compares the rounded `observedRatio` with `rule.ratioThreshold`. */
-    observedRatioAboveThreshold: z71.boolean().nullable(),
-    ratio: z71.null(),
-    reasons: z71.array(z71.string()),
-    gaScope: z71.literal("project")
+    observedRatioAboveThreshold: z72.boolean().nullable(),
+    ratio: z72.null(),
+    reasons: z72.array(z72.string()),
+    gaScope: z72.literal("project")
   }),
-  caveats: z71.array(z71.string())
+  caveats: z72.array(z72.string())
 });
 
 // ../contracts/src/tolerant-read.ts
-import { z as z72 } from "zod";
+import { z as z73 } from "zod";
 var WRAPPER_TYPES = /* @__PURE__ */ new Set(["optional", "nullable", "default", "prefault", "readonly", "catch", "nonoptional"]);
 var DEPTH_LIMIT = 64;
 function defOf(schema) {
@@ -22403,9 +22744,9 @@ function cloneWith(schema, changes) {
 }
 function openPrimitive(values) {
   if (values.length === 0) return void 0;
-  if (values.every((value) => typeof value === "string")) return z72.string();
-  if (values.every((value) => typeof value === "number")) return z72.number();
-  if (values.every((value) => typeof value === "boolean")) return z72.boolean();
+  if (values.every((value) => typeof value === "string")) return z73.string();
+  if (values.every((value) => typeof value === "number")) return z73.number();
+  if (values.every((value) => typeof value === "boolean")) return z73.boolean();
   return void 0;
 }
 function walk2(schema, open, memo, depth) {
@@ -22419,7 +22760,7 @@ function walk2(schema, open, memo, depth) {
     const shape = Object.fromEntries(Object.entries(schema.shape).map(([key, child]) => [key, next(child)]));
     const declared = def.catchall;
     const catchall = open.get(schema) ?? (declared && defOf(declared).type !== "never" ? next(declared) : void 0);
-    result = catchall ? z72.object(shape).catchall(catchall) : z72.object(shape);
+    result = catchall ? z73.object(shape).catchall(catchall) : z73.object(shape);
   } else if (WRAPPER_TYPES.has(def.type)) {
     const inner = def.innerType;
     const mapped = next(inner);
@@ -22436,10 +22777,10 @@ function walk2(schema, open, memo, depth) {
     const options = def.options;
     const mapped = options.map(next);
     const changed = mapped.some((option, index) => option !== options[index]);
-    result = !changed ? schema : def.discriminator ? z72.union(mapped) : cloneWith(schema, { options: mapped });
+    result = !changed ? schema : def.discriminator ? z73.union(mapped) : cloneWith(schema, { options: mapped });
   } else if (def.type === "record") {
     const keyType = def.keyType, valueType = def.valueType;
-    const mappedKey = defOf(keyType).type === "enum" ? z72.string() : keyType;
+    const mappedKey = defOf(keyType).type === "enum" ? z73.string() : keyType;
     const mappedValue = next(valueType);
     result = mappedKey === keyType && mappedValue === valueType ? schema : cloneWith(schema, { keyType: mappedKey, valueType: mappedValue });
   } else if (def.type === "intersection") {
@@ -22455,7 +22796,7 @@ function walk2(schema, open, memo, depth) {
     result = changed ? cloneWith(schema, { items: mappedItems, rest: mappedRest }) : schema;
   } else if (def.type === "lazy") {
     const getter = def.getter;
-    result = z72.lazy(() => next(getter()));
+    result = z73.lazy(() => next(getter()));
   } else if (def.type === "enum") {
     result = openPrimitive(Object.values(def.entries)) ?? schema;
   } else if (def.type === "literal") {
@@ -22470,8 +22811,8 @@ function tolerantReadSchema(schema, options = {}) {
 }
 
 // ../contracts/src/sentiment-read.ts
-import { z as z73 } from "zod";
-var OPEN_COUNTS = { openKeys: [[sentimentCountsSchema, z73.number().int().nonnegative()]] };
+import { z as z74 } from "zod";
+var OPEN_COUNTS = { openKeys: [[sentimentCountsSchema, z74.number().int().nonnegative()]] };
 var sentimentSettingsReadSchema = tolerantReadSchema(sentimentSettingsSchema, OPEN_COUNTS);
 var sentimentSummaryReadSchema = tolerantReadSchema(sentimentSummarySchema, OPEN_COUNTS);
 var sentimentEvidencePageReadSchema = tolerantReadSchema(sentimentEvidencePageSchema, OPEN_COUNTS);
@@ -22481,10 +22822,10 @@ var sentimentJobReadSchema = tolerantReadSchema(sentimentJobSchema, OPEN_COUNTS)
 var sentimentJobsReadSchema = tolerantReadSchema(sentimentJobsSchema, OPEN_COUNTS);
 
 // ../contracts/src/traffic-analytics.ts
-import { z as z74 } from "zod";
+import { z as z75 } from "zod";
 var TRAFFIC_ANALYTICS_PERIOD_OPTIONS = [7, 14, 30, 90];
 var TRAFFIC_ANALYTICS_DEFAULT_PERIOD_DAYS = 30;
-var trafficAnalyticsPeriodSchema = z74.union([z74.literal(7), z74.literal(14), z74.literal(30), z74.literal(90)]).describe("Traffic activity window in days (7, 14, 30, or 90). Defaults to 30 when omitted.");
+var trafficAnalyticsPeriodSchema = z75.union([z75.literal(7), z75.literal(14), z75.literal(30), z75.literal(90)]).describe("Traffic activity window in days (7, 14, 30, or 90). Defaults to 30 when omitted.");
 function parseTrafficAnalyticsPeriod(value) {
   if (value === void 0 || value === null || value === "") return TRAFFIC_ANALYTICS_DEFAULT_PERIOD_DAYS;
   const parsed = typeof value === "number" ? value : Number(value);
@@ -22494,17 +22835,17 @@ function parseTrafficAnalyticsPeriod(value) {
   }
   return result.data;
 }
-var trafficActivityCountSchema = z74.object({ current: z74.number(), prior: z74.number(), deltaPct: percent().nullable() });
-var trafficActivitySummarySchema = z74.object({
+var trafficActivityCountSchema = z75.object({ current: z75.number(), prior: z75.number(), deltaPct: percent().nullable() });
+var trafficActivitySummarySchema = z75.object({
   /** ISO8601 inclusive lower bound of the selected window (default: 30 days). */
-  windowStart: z74.string(),
+  windowStart: z75.string(),
   /** ISO8601 inclusive upper bound. */
-  windowEnd: z74.string(),
+  windowEnd: z75.string(),
   /** Earliest stored project observation across crawler, user-fetch and referral hourly rows; not window-bound. */
-  coverageStart: z74.string().nullable(),
+  coverageStart: z75.string().nullable(),
   /** Recording began on or before the prior window start. This does not establish uninterrupted ingestion. */
-  priorWindowComplete: z74.boolean(),
-  hasData: z74.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."),
+  priorWindowComplete: z75.boolean(),
+  hasData: z75.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,
   /** Unverified crawler hits during the selected period, separate from verified hits. */
@@ -22533,7 +22874,7 @@ var trafficActivitySummarySchema = z74.object({
    * is exactly the thing to fix, so the summary must show it rather
    * than render an empty section.
    */
-  referralRedirects: z74.number().int().nonnegative(),
+  referralRedirects: z75.number().int().nonnegative(),
   /**
    * `referralArrivals` split by traffic class. The three buckets sum to it.
    *
@@ -22542,31 +22883,31 @@ var trafficActivitySummarySchema = z74.object({
    * never be resolved. Reporting them as organic would overstate earned AI
    * traffic by exactly a client's ad volume.
    */
-  referralArrivalsByClass: z74.object({
+  referralArrivalsByClass: z75.object({
     paid: trafficActivityCountSchema,
     organic: trafficActivityCountSchema,
     unclassified: trafficActivityCountSchema
   }),
   /** Pre-rendered one-line breakdown, e.g. "Paid 1,200 · Organic 24". Empty when there is nothing to split. */
-  referralArrivalsClassSummary: z74.string(),
+  referralArrivalsClassSummary: z75.string(),
   /** Per-AI-operator breakdown (OpenAI, Anthropic, Google AI, Perplexity, …). */
-  byOperator: z74.array(z74.object({
-    operator: z74.string(),
-    verifiedHits: z74.number(),
+  byOperator: z75.array(z75.object({
+    operator: z75.string(),
+    verifiedHits: z75.number(),
     /** claimed-bot UA, source IP not in a published range. */
-    unverifiedHits: z74.number(),
+    unverifiedHits: z75.number(),
     /** Per-user fetches from this operator's AI surface (ChatGPT-User, …). */
-    userFetchHits: z74.number(),
-    referralArrivals: z74.number(),
+    userFetchHits: z75.number(),
+    referralArrivals: z75.number(),
     deltaPct: percent().nullable()
   })),
   /**
    * Top crawled paths during the selected period, with both verified and
    * unverified crawler hits. These are request counts, not citation evidence.
    */
-  topCrawledPaths: z74.array(z74.object({
-    path: z74.string(),
-    verifiedHits: z74.number(),
+  topCrawledPaths: z75.array(z75.object({
+    path: z75.string(),
+    verifiedHits: z75.number(),
     /**
      * Hits from a crawler that identified itself but whose source IP could not
      * be matched against the operator's published ranges. Additive, not an
@@ -22574,36 +22915,36 @@ var trafficActivitySummarySchema = z74.object({
      * logs, for one), so for those projects every hit lands here and a
      * verified-only view reports zero against real crawl activity.
      */
-    unverifiedHits: z74.number().default(0),
+    unverifiedHits: z75.number().default(0),
     /** How many distinct AI operators crawled this path in the window. */
-    distinctOperators: z74.number()
+    distinctOperators: z75.number()
   })),
   /** AI products that sent ≥1 session in the window (referral by destination). */
-  referralProducts: z74.array(z74.object({
-    product: z74.string(),
-    arrivals: z74.number(),
-    distinctLandingPaths: z74.number()
+  referralProducts: z75.array(z75.object({
+    product: z75.string(),
+    arrivals: z75.number(),
+    distinctLandingPaths: z75.number()
   })),
   /** Daily request counts during the selected period. */
-  dailyTrend: z74.array(z74.object({
-    date: z74.string(),
-    verifiedCrawlerHits: z74.number(),
+  dailyTrend: z75.array(z75.object({
+    date: z75.string(),
+    verifiedCrawlerHits: z75.number(),
     /** See topCrawledPaths.unverifiedHits. Plotted alongside, never instead. */
-    unverifiedCrawlerHits: z74.number().default(0),
-    userFetchHits: z74.number(),
-    referralArrivals: z74.number()
+    unverifiedCrawlerHits: z75.number().default(0),
+    userFetchHits: z75.number(),
+    referralArrivals: z75.number()
   })),
   /**
    * Top landing paths for AI-referral sessions during the selected period.
    * Complements crawler paths with server-observed referral arrivals.
    */
-  topReferralLandingPaths: z74.array(z74.object({
-    path: z74.string(),
-    arrivals: z74.number(),
-    distinctProducts: z74.number()
+  topReferralLandingPaths: z75.array(z75.object({
+    path: z75.string(),
+    arrivals: z75.number(),
+    distinctProducts: z75.number()
   }))
 });
-var trafficAnalyticsResponseSchema = z74.object({
+var trafficAnalyticsResponseSchema = z75.object({
   /** Null when no non-archived traffic source is connected. Connected sources without events return zero counts. */
   activity: trafficActivitySummarySchema.nullable()
 });
@@ -22651,6 +22992,7 @@ export {
   RetrievalStatuses,
   RetrievalContracts,
   providerQuotaPolicySchema,
+  PROVIDER_NAMES,
   ProviderNames,
   API_PROVIDER_NAMES,
   isBrowserProvider,
@@ -23147,6 +23489,7 @@ export {
   buildModelChangeNotice,
   shareOf,
   breakdownShares,
+  median,
   wilsonInterval,
   linearTrend,
   googleConnectionDtoSchema,
@@ -23621,6 +23964,22 @@ export {
   AGENT_NONE,
   normalizeAgentSlug,
   detectAgentRuntime,
+  outcomeSurfaceSchema,
+  OutcomeSurfaces,
+  INTEGRATION_NAMES,
+  IntegrationNames,
+  OutcomeStatuses,
+  OutcomeTriggers,
+  OutcomeReasonCodes,
+  FeatureNames,
+  bucketDuration,
+  integrationConnectionPropertiesSchema,
+  featureCompletedPropertiesSchema,
+  normalizeInstallRef,
+  installStatePropertiesSchema,
+  statusClassOf,
+  classifyOutcomeError,
+  classifyProviderOutcomeError,
   uiTelemetryEventSchema,
   isSensitiveDiagnosticQueryKey,
   redactLogValue,