@canonry/canonry 4.156.0 → 4.158.0

package/dist/{chunk-ZWESOFA5.js → chunk-4VZP64GZ.js}

@@ -10,7 +10,7 @@ import {
   loadConfig,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-CPASKGUE.js";
+} from "./chunk-LK6YFHG4.js";
 import {
   CC_CACHE_DIR,
   DUCKDB_SPEC,
@@ -136,7 +136,7 @@ import {
   siteCrawlSnapshots,
   toAlertView,
   usageCounters
-} from "./chunk-ABNN2ZVR.js";
+} from "./chunk-YP4K2KXH.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_PROVIDER_IDS,
@@ -236,7 +236,7 @@ import {
   validationError,
   winnabilityClassLabel,
   withRetry
-} from "./chunk-AMPT2EP7.js";
+} from "./chunk-DEVAEC2S.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -3167,8 +3167,67 @@ function removeVercelTrafficConnection(config, projectName) {
   return true;
 }
 
-// src/wordpress-config.ts
+// src/cloudflare-traffic-config.ts
+function unsupportedDeliveryMode(deliveryMode) {
+  const label = typeof deliveryMode === "string" ? ` "${deliveryMode}"` : "";
+  return new Error(`Unsupported Cloudflare traffic delivery mode${label}`);
+}
 function ensureConnections6(config) {
+  if (!config.cloudflareTraffic) config.cloudflareTraffic = {};
+  if (!config.cloudflareTraffic.connections) config.cloudflareTraffic.connections = [];
+  return config.cloudflareTraffic.connections;
+}
+function normalizeDirectPushConnection(connection) {
+  const deliveryMode = connection.deliveryMode;
+  if (deliveryMode !== void 0 && deliveryMode !== "direct-push") {
+    throw unsupportedDeliveryMode(deliveryMode);
+  }
+  if (deliveryMode === "direct-push") return connection;
+  return { ...connection, deliveryMode: "direct-push" };
+}
+function getCloudflareTrafficConnection(config, projectName) {
+  const connection = (config.cloudflareTraffic?.connections ?? []).find((c) => c.projectName === projectName);
+  return connection ? normalizeDirectPushConnection(connection) : void 0;
+}
+function getCloudflareTrafficConnectionBySourceId(config, sourceId) {
+  const connection = (config.cloudflareTraffic?.connections ?? []).find((c) => c.sourceId === sourceId);
+  return connection ? normalizeDirectPushConnection(connection) : void 0;
+}
+function upsertCloudflareTrafficConnection(config, connection) {
+  const deliveryMode = connection.deliveryMode;
+  if (deliveryMode !== "direct-push") {
+    throw unsupportedDeliveryMode(deliveryMode);
+  }
+  const connections = ensureConnections6(config);
+  const index = connections.findIndex((c) => c.projectName === connection.projectName);
+  if (index === -1) {
+    connections.push(connection);
+    return connection;
+  }
+  connections[index] = connection;
+  return connection;
+}
+function removeCloudflareTrafficConnection(config, projectName) {
+  const connections = config.cloudflareTraffic?.connections;
+  if (!connections?.length) return false;
+  const next = connections.filter((c) => c.projectName !== projectName);
+  if (next.length === connections.length) return false;
+  if (!config.cloudflareTraffic) return false;
+  config.cloudflareTraffic.connections = next;
+  if (next.length === 0) {
+    delete config.cloudflareTraffic;
+  }
+  return true;
+}
+
+// src/cloudflare-ingest-url.ts
+function buildCloudflareIngestUrlTemplate(config) {
+  const base = (config.publicUrl ?? config.apiUrl).replace(/\/+$/, "");
+  return `${base}/api/v1/projects/{name}/traffic/cloudflare/ingest`;
+}
+
+// src/wordpress-config.ts
+function ensureConnections7(config) {
   if (!config.wordpress) config.wordpress = {};
   if (!config.wordpress.connections) config.wordpress.connections = [];
   return config.wordpress.connections;
@@ -3185,7 +3244,7 @@ function getWordpressConnection(config, projectName) {
   return (config.wordpress?.connections ?? []).find((connection) => connection.projectName === projectName);
 }
 function upsertWordpressConnection(config, connection) {
-  const connections = ensureConnections6(config);
+  const connections = ensureConnections7(config);
   const normalized = normalizeConnection(connection);
   const index = connections.findIndex((entry) => entry.projectName === connection.projectName);
   if (index === -1) {
@@ -5290,7 +5349,7 @@ async function getAdGroupInsights(apiKey, adGroupId, opts) {
 }
 
 // src/ads-config.ts
-function ensureConnections7(config) {
+function ensureConnections8(config) {
   if (!config.openaiAds) config.openaiAds = {};
   if (!config.openaiAds.connections) config.openaiAds.connections = [];
   return config.openaiAds.connections;
@@ -5299,7 +5358,7 @@ function getOpenAiAdsConnection(config, projectName) {
   return (config.openaiAds?.connections ?? []).find((c) => c.projectName === projectName);
 }
 function upsertOpenAiAdsConnection(config, connection) {
-  const connections = ensureConnections7(config);
+  const connections = ensureConnections8(config);
   const index = connections.findIndex((c) => c.projectName === connection.projectName);
   if (index === -1) {
     connections.push(connection);
@@ -6945,7 +7004,6 @@ import { createRequire as createRequire3 } from "module";
 import { Worker } from "worker_threads";
 import { and as and10, asc, count, desc as desc6, eq as eq13, isNull, ne as ne2, or, sql as sql5 } from "drizzle-orm";
 import { alias } from "drizzle-orm/sqlite-core";
-var SITE_CRAWL_GRAPH_LAYOUT_VERSION = "site-health-fa2-v1";
 var SITE_CRAWL_GRAPH_LAYOUT_TIMEOUT_MS = 15e3;
 var SITE_CRAWL_GRAPH_SEED_SCALE = 100;
 var graphSourcePage = alias(siteCrawlPages, "layout_graph_source_page");
@@ -6955,20 +7013,81 @@ var FORCE_ATLAS_SETTINGS = Object.freeze({
   barnesHutOptimize: true,
   barnesHutTheta: 0.5,
   edgeWeightInfluence: 0.5,
-  gravity: 1,
-  linLogMode: false,
-  outboundAttractionDistribution: false,
-  scalingRatio: 10,
+  gravity: 0.2,
+  linLogMode: true,
+  outboundAttractionDistribution: true,
+  scalingRatio: 2,
   slowDown: 10,
   strongGravityMode: false
 });
+var RENDER_MAX_NODE_SIZE = 14;
+var RENDER_HALF_EXTENT_PX = 420;
+var NODE_SIZE_EXTENT_FRACTION = RENDER_MAX_NODE_SIZE / RENDER_HALF_EXTENT_PX;
+var NOVERLAP_SETTINGS = Object.freeze({
+  /** Half a node of clear space between two touching nodes. */
+  marginFactor: 0.5,
+  expansion: 1.1,
+  ratio: 1,
+  speed: 3,
+  /**
+   * Node discs may claim at most this share of the graph's bounding box. At
+   * the 20k cap the extent-derived size asks for spacing the graph physically
+   * does not have, and noverlap either runs for minutes or overflows its
+   * collision set. This bound keeps the pass solvable at every graph size,
+   * and it only binds on graphs far too dense to read node-by-node anyway.
+   */
+  maxPackingFraction: 0.15,
+  /** Cells hold a handful of nodes each, which is what keeps the pass linear. */
+  gridSizeMin: 10,
+  gridSizeMax: 200,
+  iterationLadder: [
+    { maxNodes: 1e3, iterations: 120 },
+    { maxNodes: 5e3, iterations: 60 }
+  ],
+  iterationsFloor: 20
+});
+function noverlapGridSize(nodeCount) {
+  return Math.max(
+    NOVERLAP_SETTINGS.gridSizeMin,
+    Math.min(NOVERLAP_SETTINGS.gridSizeMax, Math.ceil(Math.sqrt(Math.max(1, nodeCount))))
+  );
+}
+function noverlapMaxIterations(nodeCount) {
+  for (const step of NOVERLAP_SETTINGS.iterationLadder) {
+    if (nodeCount <= step.maxNodes) return step.iterations;
+  }
+  return NOVERLAP_SETTINGS.iterationsFloor;
+}
+var OUTLIER_RING_INNER_FACTOR = 1.25;
+var OUTLIER_RING_OUTER_FACTOR = 1.75;
+var OUTLIER_RING_MAX_RINGS = 4;
+var OUTLIER_RING_TARGET_PER_RING = 16;
+var OUTLIER_RING_MIN_RADIUS = 1;
+function siteCrawlGraphLayoutSettingsFingerprint(settings) {
+  return crypto16.createHash("sha256").update(JSON.stringify(settings)).digest("hex").slice(0, 8);
+}
+var SITE_CRAWL_GRAPH_LAYOUT_ALGORITHM = "site-health-fa2-v2";
+var SITE_CRAWL_GRAPH_LAYOUT_VERSION = `${SITE_CRAWL_GRAPH_LAYOUT_ALGORITHM}-${siteCrawlGraphLayoutSettingsFingerprint({
+  forceAtlas: FORCE_ATLAS_SETTINGS,
+  noverlap: NOVERLAP_SETTINGS,
+  nodeSizeExtentFraction: NODE_SIZE_EXTENT_FRACTION,
+  outlierRing: {
+    inner: OUTLIER_RING_INNER_FACTOR,
+    outer: OUTLIER_RING_OUTER_FACTOR,
+    maxRings: OUTLIER_RING_MAX_RINGS,
+    targetPerRing: OUTLIER_RING_TARGET_PER_RING,
+    minRadius: OUTLIER_RING_MIN_RADIUS
+  }
+})}`;
 var WORKER_SOURCE = String.raw`
 const {parentPort, workerData} = require('node:worker_threads');
 try {
   const graphologyModule = require(workerData.graphologyPath);
   const forceAtlasModule = require(workerData.forceAtlasPath);
+  const noverlapModule = require(workerData.noverlapPath);
   const MultiDirectedGraph = graphologyModule.MultiDirectedGraph;
   const forceAtlas2 = forceAtlasModule.default || forceAtlasModule;
+  const noverlap = noverlapModule.default || noverlapModule;
   const graph = new MultiDirectedGraph({allowSelfLoops: true});
   for (const node of workerData.input.nodes) {
     graph.addNode(node.nodeKey, {x: node.x, y: node.y});
@@ -6984,6 +7103,45 @@ try {
       settings: workerData.settings,
     });
   }
+  // Anti-overlap runs on the spatialization ForceAtlas2 just produced. Node
+  // size is uniform and derived from the graph's own extent, so the pass is
+  // scale invariant and stays deterministic for a fixed input.
+  if (graph.order > 1) {
+    let sumX = 0;
+    let sumY = 0;
+    graph.forEachNode(function (nodeKey, attributes) {
+      sumX += attributes.x;
+      sumY += attributes.y;
+    });
+    const centerX = sumX / graph.order;
+    const centerY = sumY / graph.order;
+    let extent = 0;
+    graph.forEachNode(function (nodeKey, attributes) {
+      extent = Math.max(extent, Math.abs(attributes.x - centerX), Math.abs(attributes.y - centerY));
+    });
+    if (Number.isFinite(extent) && extent > 0) {
+      // Whichever bound is tighter: one render-sized node, or the largest disc
+      // that still leaves the graph mostly empty space at this node count.
+      const byExtent = extent * workerData.nodeSizeExtentFraction;
+      const byArea = Math.sqrt(
+        (workerData.noverlap.maxPackingFraction * Math.pow(2 * extent, 2)) / graph.order,
+      ) / 2;
+      const nodeSize = Math.min(byExtent, byArea);
+      graph.forEachNode(function (nodeKey) {
+        graph.setNodeAttribute(nodeKey, 'size', nodeSize);
+      });
+      noverlap.assign(graph, {
+        maxIterations: workerData.noverlap.maxIterations,
+        settings: {
+          gridSize: workerData.noverlap.gridSize,
+          margin: nodeSize * workerData.noverlap.marginFactor,
+          expansion: workerData.noverlap.expansion,
+          ratio: workerData.noverlap.ratio,
+          speed: workerData.noverlap.speed,
+        },
+      });
+    }
+  }
   const positions = [];
   graph.forEachNode((nodeKey, attributes) => {
     positions.push({nodeKey, x: attributes.x, y: attributes.y});
@@ -7054,8 +7212,15 @@ async function computeForceAtlasPositions(input, options = {}) {
     workerData: {
       graphologyPath: requireFromPackage.resolve("graphology"),
       forceAtlasPath: requireFromPackage.resolve("graphology-layout-forceatlas2"),
+      noverlapPath: requireFromPackage.resolve("graphology-layout-noverlap"),
       input,
-      settings: FORCE_ATLAS_SETTINGS
+      settings: FORCE_ATLAS_SETTINGS,
+      noverlap: {
+        ...NOVERLAP_SETTINGS,
+        gridSize: noverlapGridSize(input.nodes.length),
+        maxIterations: noverlapMaxIterations(input.nodes.length)
+      },
+      nodeSizeExtentFraction: NODE_SIZE_EXTENT_FRACTION
     }
   });
   const timeoutMs = options.timeoutMs ?? SITE_CRAWL_GRAPH_LAYOUT_TIMEOUT_MS;
@@ -7084,6 +7249,77 @@ async function computeForceAtlasPositions(input, options = {}) {
     });
   });
 }
+function siteCrawlGraphComponents(nodeKeys, edges) {
+  const parent = new Map(nodeKeys.map((key) => [key, key]));
+  const find = (key) => {
+    let root = key;
+    while (parent.get(root) !== root) root = parent.get(root);
+    let cursor = key;
+    while (parent.get(cursor) !== root) {
+      const next = parent.get(cursor);
+      parent.set(cursor, root);
+      cursor = next;
+    }
+    return root;
+  };
+  for (const edge of edges) {
+    if (!parent.has(edge.sourceNodeKey) || !parent.has(edge.targetNodeKey)) continue;
+    const sourceRoot = find(edge.sourceNodeKey);
+    const targetRoot = find(edge.targetNodeKey);
+    if (sourceRoot === targetRoot) continue;
+    if (sourceRoot < targetRoot) parent.set(targetRoot, sourceRoot);
+    else parent.set(sourceRoot, targetRoot);
+  }
+  const members = /* @__PURE__ */ new Map();
+  for (const key of [...nodeKeys].sort()) {
+    const root = find(key);
+    const group = members.get(root);
+    if (group) group.push(key);
+    else members.set(root, [key]);
+  }
+  let mainRoot = null;
+  for (const [root, group] of members) {
+    if (mainRoot === null) {
+      mainRoot = root;
+      continue;
+    }
+    const best = members.get(mainRoot);
+    if (group.length > best.length || group.length === best.length && root < mainRoot) mainRoot = root;
+  }
+  const main = new Set(mainRoot === null ? [] : members.get(mainRoot));
+  const outliers = [...members.entries()].filter(([root]) => root !== mainRoot).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).flatMap(([, group]) => group);
+  return { main, outliers };
+}
+function frameDisconnectedNodes(positions, edges) {
+  const { main, outliers } = siteCrawlGraphComponents(positions.map((p) => p.nodeKey), edges);
+  if (outliers.length === 0 || main.size === 0) return [...positions];
+  const mainPositions = positions.filter((position) => main.has(position.nodeKey));
+  const centerX = mainPositions.reduce((sum, p) => sum + p.x, 0) / mainPositions.length;
+  const centerY = mainPositions.reduce((sum, p) => sum + p.y, 0) / mainPositions.length;
+  if (!Number.isFinite(centerX) || !Number.isFinite(centerY)) return [...positions];
+  const mainRadius = Math.max(
+    OUTLIER_RING_MIN_RADIUS,
+    ...mainPositions.map((p) => Math.hypot(p.x - centerX, p.y - centerY)).filter(Number.isFinite)
+  );
+  const ringCount = Math.max(1, Math.min(
+    OUTLIER_RING_MAX_RINGS,
+    Math.ceil(outliers.length / OUTLIER_RING_TARGET_PER_RING)
+  ));
+  const placed = /* @__PURE__ */ new Map();
+  for (const [index, nodeKey] of outliers.entries()) {
+    const ring = index % ringCount;
+    const ringRadius = mainRadius * (ringCount === 1 ? OUTLIER_RING_INNER_FACTOR : OUTLIER_RING_INNER_FACTOR + (OUTLIER_RING_OUTER_FACTOR - OUTLIER_RING_INNER_FACTOR) * (ring / (ringCount - 1)));
+    const slot = Math.floor(index / ringCount);
+    const slotsOnRing = Math.ceil((outliers.length - ring) / ringCount);
+    const angle = (slot + ring % 2 * 0.5) / Math.max(1, slotsOnRing) * Math.PI * 2;
+    placed.set(nodeKey, {
+      nodeKey,
+      x: centerX + Math.cos(angle) * ringRadius,
+      y: centerY + Math.sin(angle) * ringRadius
+    });
+  }
+  return positions.map((position) => placed.get(position.nodeKey) ?? position);
+}
 function normalizePositions(seededNodes, computed, rootNodeKey) {
   const byKey = new Map(computed.map((position) => [position.nodeKey, position]));
   if (byKey.size !== seededNodes.length) throw new Error("Graph layout returned an incomplete node set");
@@ -7131,6 +7367,7 @@ async function layoutSiteCrawlGraphInput(input, options = {}) {
       iterations: adaptiveForceAtlasIterations(input.nodes.length, input.edges.length)
     }, { signal: options.signal, timeoutMs: options.timeoutMs });
     options.signal?.throwIfAborted();
+    const framed = frameDisconnectedNodes(positions, input.edges);
     return {
       state: "ready",
       layoutVersion: SITE_CRAWL_GRAPH_LAYOUT_VERSION,
@@ -7138,7 +7375,7 @@ async function layoutSiteCrawlGraphInput(input, options = {}) {
       totalEdges: input.totalEdges,
       nodeCount: input.nodes.length,
       edgeCount: input.edges.length,
-      nodes: normalizePositions(seeded, positions, input.rootNodeKey),
+      nodes: normalizePositions(seeded, framed, input.rootNodeKey),
       edges: input.edges.map((edge, sampleRank) => ({ ...edge, sampleRank }))
     };
   } catch (error) {
@@ -8413,7 +8650,7 @@ function readStoredGroundingSources(rawResponse) {
   return result;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-WHC7B32V.js");
+  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-LQ6ZRWMF.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -14043,6 +14280,24 @@ async function createServer(opts) {
       return removed;
     }
   };
+  const cloudflareTrafficCredentialStore = {
+    getConnection: (projectName) => {
+      return getCloudflareTrafficConnection(opts.config, projectName);
+    },
+    getConnectionBySourceId: (sourceId) => {
+      return getCloudflareTrafficConnectionBySourceId(opts.config, sourceId);
+    },
+    upsertConnection: (record) => {
+      const updated = upsertCloudflareTrafficConnection(opts.config, record);
+      saveConfigPatch(opts.config);
+      return updated;
+    },
+    deleteConnection: (projectName) => {
+      const removed = removeCloudflareTrafficConnection(opts.config, projectName);
+      if (removed) saveConfigPatch(opts.config);
+      return removed;
+    }
+  };
   const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto25.randomBytes(32).toString("hex");
   const googleConnectionStore = {
     listConnections: (domain) => listGoogleConnections(opts.config, domain),
@@ -14652,6 +14907,8 @@ async function createServer(opts) {
     cloudRunCredentialStore,
     wordpressTrafficCredentialStore,
     vercelTrafficCredentialStore,
+    cloudflareTrafficCredentialStore,
+    cloudflareTrafficIngestUrl: buildCloudflareIngestUrlTemplate(opts.config),
     onTrafficSynced: (event) => {
       trackEvent(
         "traffic.synced",
@@ -15090,6 +15347,7 @@ export {
   backfillInsightsCommand,
   backfillSnapshotAttributionCommand,
   backfillTrafficClassificationCommand,
+  getCloudflareTrafficConnection,
   setGoogleAuthConfig,
   installSkills,
   listSkills,

package/dist/{chunk-AMPT2EP7.js → chunk-DEVAEC2S.js}

@@ -8561,7 +8561,24 @@ var siteCrawlSummarySchema = z24.object({
   counts: siteCrawlCountsSchema,
   deadLinks: siteCrawlDeadLinksSummarySchema
 });
+var siteCrawlTerminationSchema = z24.enum([
+  "complete",
+  "unknown",
+  "max-pages",
+  "max-edges",
+  "max-fetches",
+  "max-duration",
+  "max-bytes",
+  "max-page-bytes",
+  "max-depth",
+  "max-links-per-page",
+  "max-query-variants",
+  "max-sitemap-fanout",
+  "max-sitemap-urls",
+  "root-host-redirect"
+]);
 var siteHealthStateSchema = z24.enum(["eligible", "hidden", "failed", "unchecked"]);
+var SiteHealthStates = siteHealthStateSchema.enum;
 var SiteCrawlFetchStates = {
   discovered: "discovered",
   robotsBlocked: "robots-blocked",
@@ -8762,6 +8779,13 @@ var siteCrawlGraphEdgeSchema = z24.object({
   followable: z24.boolean(),
   occurrences: z24.number().int().positive()
 });
+var siteCrawlGraphLayoutUnavailableReasonSchema = z24.enum([
+  "no-crawl",
+  "legacy-snapshot",
+  "details-unavailable",
+  "layout-failed",
+  "empty-crawl"
+]);
 var siteCrawlGraphLayoutSchema = z24.discriminatedUnion("state", [
   z24.object({
     state: z24.literal("ready"),
@@ -8771,13 +8795,20 @@ var siteCrawlGraphLayoutSchema = z24.discriminatedUnion("state", [
   z24.object({
     state: z24.literal("unavailable"),
     version: z24.null(),
-    reason: z24.enum(["no-crawl", "legacy-snapshot", "details-unavailable", "layout-failed", "empty-crawl"])
+    reason: siteCrawlGraphLayoutUnavailableReasonSchema
   })
 ]);
 var siteCrawlGraphResponseSchema = z24.object({
   project: z24.string(),
   hasCrawlData: z24.boolean(),
   runId: z24.string().nullable(),
+  /**
+   * Server-owned identity of the crawl root, resolved from the snapshot root
+   * URL (or the depth-0 page). Consumers must not infer the home page from a
+   * path or a link score. It is null when the crawl persisted no page detail,
+   * and it can name a page that graph sampling left out of `nodes`.
+   */
+  rootNodeKey: z24.string().nullable(),
   layout: siteCrawlGraphLayoutSchema,
   /** Total canonical pages in the persisted crawl before graph sampling. */
   totalNodes: z24.number().int().nonnegative(),
@@ -9020,6 +9051,20 @@ var siteAuditRunResponseSchema = z24.object({
   runId: z24.string(),
   status: runStatusSchema
 });
+var siteHealthScanSchema = z24.object({
+  runId: z24.string(),
+  status: runStatusSchema,
+  createdAt: z24.string(),
+  startedAt: z24.string().nullable(),
+  finishedAt: z24.string().nullable(),
+  hasCrawlData: z24.boolean()
+});
+var siteHealthScansResponseSchema = z24.object({
+  project: z24.string(),
+  scans: z24.array(siteHealthScanSchema).default([])
+});
+var SITE_HEALTH_SCANS_DEFAULT_LIMIT = 20;
+var SITE_HEALTH_SCANS_MAX_LIMIT = 100;
 
 // ../contracts/src/schedule.ts
 import { z as z25 } from "zod";
@@ -12745,6 +12790,71 @@ var trafficConnectVercelRequestSchema = z44.object({
   environment: vercelTrafficEnvironmentSchema.optional(),
   displayName: z44.string().min(1).optional()
 });
+var cloudflareTrafficDeliveryModeSchema = z44.enum(["direct-push", "queue-pull"]);
+var CloudflareTrafficDeliveryModes = cloudflareTrafficDeliveryModeSchema.enum;
+var cloudflareTrafficSourceConfigSchema = z44.object({
+  schemaVersion: z44.literal(1),
+  deliveryMode: z44.literal(CloudflareTrafficDeliveryModes["direct-push"]).default("direct-push"),
+  /** Semver of the Worker script bundle that was generated at connect/rotate time. */
+  workerVersion: z44.string().min(1),
+  /** Identifier of the bot/referer keyword set baked into the deployed Worker. */
+  expectedBotListVersion: z44.string().min(1),
+  /** Target Cloudflare zone for the operator-managed Worker route. */
+  zoneId: z44.string().nullable(),
+  /** Cloudflare account id used to target the correct account during Wrangler deploy. */
+  accountId: z44.string().nullable()
+});
+var trafficConnectCloudflareRequestSchema = z44.object({
+  deliveryMode: z44.literal(CloudflareTrafficDeliveryModes["direct-push"]).default("direct-push"),
+  displayName: z44.string().min(1).optional(),
+  /** Target Cloudflare zone. Canonry does not validate it against Cloudflare. */
+  zoneId: z44.string().min(1).optional(),
+  /** Cloudflare account id. Set it when Wrangler can access more than one account. */
+  accountId: z44.string().min(1).optional()
+});
+var trafficConnectCloudflareResponseSchema = z44.object({
+  sourceId: z44.string().min(1),
+  deliveryMode: z44.literal(CloudflareTrafficDeliveryModes["direct-push"]),
+  workerScript: z44.string().min(1),
+  wranglerToml: z44.string().min(1),
+  workerVersion: z44.string().min(1),
+  instructions: z44.string().min(1)
+});
+var cloudflareEdgeEventSchema = z44.object({
+  /** Cloudflare `cf-ray` request id — globally unique per request. */
+  eventId: z44.string().min(1),
+  observedAt: z44.string().datetime(),
+  method: z44.string().nullable(),
+  host: z44.string().nullable(),
+  path: z44.string().min(1),
+  queryString: z44.string().nullable(),
+  status: z44.number().int().nullable(),
+  userAgent: z44.string().nullable(),
+  remoteIp: z44.string().nullable(),
+  referer: z44.string().nullable(),
+  cf: z44.object({
+    verifiedBot: z44.boolean().nullable(),
+    botScore: z44.number().int().nullable(),
+    country: z44.string().nullable(),
+    asn: z44.number().int().nullable(),
+    asOrganization: z44.string().nullable()
+  }).nullable()
+});
+var cloudflareEdgeEventBatchSchema = z44.object({
+  schemaVersion: z44.literal(1),
+  workerVersion: z44.string().min(1),
+  events: z44.array(cloudflareEdgeEventSchema).min(1).max(100)
+});
+var cloudflareWorkerIngestRequestSchema = cloudflareEdgeEventBatchSchema;
+var cloudflareWorkerIngestResponseSchema = z44.object({
+  acceptedEvents: z44.number().int(),
+  droppedEvents: z44.number().int(),
+  workerVersionAck: z44.string(),
+  crawlerBucketRows: z44.number().int(),
+  aiUserFetchBucketRows: z44.number().int(),
+  aiReferralBucketRows: z44.number().int(),
+  sampleRows: z44.number().int()
+});
 var trafficSyncResponseSchema = z44.object({
   sourceId: z44.string(),
   runId: z44.string(),
@@ -14634,6 +14744,7 @@ export {
   siteAuditPagesResponseSchema,
   siteAuditTrendResponseSchema,
   siteCrawlSummarySchema,
+  siteHealthStateSchema,
   SiteCrawlFetchedStates,
   deriveSiteHealthState,
   siteCrawlAuditFactorSchema,
@@ -14669,6 +14780,9 @@ export {
   normalizeSiteAuditRunRequest,
   siteAuditRequestIdentity,
   siteAuditRunResponseSchema,
+  siteHealthScansResponseSchema,
+  SITE_HEALTH_SCANS_DEFAULT_LIMIT,
+  SITE_HEALTH_SCANS_MAX_LIMIT,
   schedulableRunKindSchema,
   SchedulableRunKinds,
   scheduleDtoSchema,
@@ -14812,6 +14926,12 @@ export {
   trafficConnectCloudRunRequestSchema,
   trafficConnectWordpressRequestSchema,
   trafficConnectVercelRequestSchema,
+  CloudflareTrafficDeliveryModes,
+  cloudflareTrafficSourceConfigSchema,
+  trafficConnectCloudflareRequestSchema,
+  trafficConnectCloudflareResponseSchema,
+  cloudflareWorkerIngestRequestSchema,
+  cloudflareWorkerIngestResponseSchema,
   trafficSyncResponseSchema,
   trafficResetRequestSchema,
   trafficBackfillResponseSchema,

package/dist/{chunk-CPASKGUE.js → chunk-LK6YFHG4.js}

@@ -81,7 +81,7 @@ import {
   trafficConnectWordpressRequestSchema,
   trafficEventKindSchema,
   trafficSeriesGranularitySchema
-} from "./chunk-AMPT2EP7.js";
+} from "./chunk-DEVAEC2S.js";
 
 // src/config.ts
 import fs from "fs";
@@ -107,6 +107,14 @@ function normalizeWordpressConfig(config) {
     defaultEnv: connection.defaultEnv ?? "live"
   }));
 }
+function normalizeCloudflareTrafficConfig(config) {
+  for (const connection of config.cloudflareTraffic?.connections ?? []) {
+    const legacy = connection;
+    if (legacy.deliveryMode === void 0) {
+      legacy.deliveryMode = "direct-push";
+    }
+  }
+}
 function getConfigDir() {
   const override = process.env.CANONRY_CONFIG_DIR?.trim();
   if (override) {
@@ -152,6 +160,7 @@ Do not write config.yaml by hand; use "canonry init", "canonry settings", or "ca
   }
   normalizeGoogleConfig(parsed);
   normalizeWordpressConfig(parsed);
+  normalizeCloudflareTrafficConfig(parsed);
   const portOverride = process.env.CANONRY_PORT?.trim();
   if (portOverride) {
     try {
@@ -4695,6 +4704,22 @@ var postApiV1ProjectsByNameTrafficConnectVercel = (options) => {
     }
   });
 };
+var postApiV1ProjectsByNameTrafficConnectCloudflare = (options) => {
+  return (options.client ?? client).post({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v1/projects/{name}/traffic/connect/cloudflare",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 var postApiV1ProjectsByNameTrafficSourcesByIdSync = (options) => {
   return (options.client ?? client).post({
     security: [
@@ -6982,6 +7007,15 @@ var ApiClient = class {
       })
     );
   }
+  async trafficConnectCloudflare(project, body) {
+    return this.invoke(
+      () => postApiV1ProjectsByNameTrafficConnectCloudflare({
+        client: this.heyClient,
+        path: { name: project },
+        body
+      })
+    );
+  }
   async trafficSync(project, sourceId, body) {
     return this.invoke(
       () => postApiV1ProjectsByNameTrafficSourcesByIdSync({