@canonry/canonry 4.157.0 → 4.158.0

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

@@ -10,7 +10,7 @@ import {
   loadConfig,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-KMTRO56O.js";
+} from "./chunk-LK6YFHG4.js";
 import {
   CC_CACHE_DIR,
   DUCKDB_SPEC,
@@ -136,7 +136,7 @@ import {
   siteCrawlSnapshots,
   toAlertView,
   usageCounters
-} from "./chunk-MEBL4EJO.js";
+} from "./chunk-YP4K2KXH.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_PROVIDER_IDS,
@@ -236,7 +236,7 @@ import {
   validationError,
   winnabilityClassLabel,
   withRetry
-} from "./chunk-TRRVBTU5.js";
+} from "./chunk-DEVAEC2S.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -7004,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");
@@ -7014,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});
@@ -7043,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});
@@ -7113,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;
@@ -7143,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");
@@ -7190,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,
@@ -7197,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) {
@@ -8472,7 +8650,7 @@ function readStoredGroundingSources(rawResponse) {
   return result;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-YUUPSJRC.js");
+  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-LQ6ZRWMF.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);

package/dist/{chunk-TRRVBTU5.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";
@@ -14699,6 +14744,7 @@ export {
   siteAuditPagesResponseSchema,
   siteAuditTrendResponseSchema,
   siteCrawlSummarySchema,
+  siteHealthStateSchema,
   SiteCrawlFetchedStates,
   deriveSiteHealthState,
   siteCrawlAuditFactorSchema,
@@ -14734,6 +14780,9 @@ export {
   normalizeSiteAuditRunRequest,
   siteAuditRequestIdentity,
   siteAuditRunResponseSchema,
+  siteHealthScansResponseSchema,
+  SITE_HEALTH_SCANS_DEFAULT_LIMIT,
+  SITE_HEALTH_SCANS_MAX_LIMIT,
   schedulableRunKindSchema,
   SchedulableRunKinds,
   scheduleDtoSchema,

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

@@ -81,7 +81,7 @@ import {
   trafficConnectWordpressRequestSchema,
   trafficEventKindSchema,
   trafficSeriesGranularitySchema
-} from "./chunk-TRRVBTU5.js";
+} from "./chunk-DEVAEC2S.js";
 
 // src/config.ts
 import fs from "fs";