@ainyc/canonry 5.1.4 → 5.2.0

package/dist/chunk-5VONCLVQ.js

@@ -0,0 +1,652 @@
+import {
+  siteCrawlEdges,
+  siteCrawlGraphEdges,
+  siteCrawlGraphLayouts,
+  siteCrawlGraphNodes,
+  siteCrawlPages,
+  siteCrawlSnapshots
+} from "./chunk-YQNKULAD.js";
+import {
+  SITE_CRAWL_GRAPH_MAX_EDGES,
+  SITE_CRAWL_GRAPH_MAX_NODES,
+  TEMPLATE_LINK_RATIO_THRESHOLD
+} from "./chunk-2U5IW3G5.js";
+
+// src/site-crawl-graph-layout.ts
+import crypto from "crypto";
+import { createRequire } from "module";
+import { Worker } from "worker_threads";
+import { and, asc, count, desc, eq, isNull, ne, or, sql } from "drizzle-orm";
+import { alias } from "drizzle-orm/sqlite-core";
+var SITE_CRAWL_GRAPH_LAYOUT_TIMEOUT_MS = 15e3;
+var SITE_CRAWL_GRAPH_SEED_SCALE = 100;
+var graphSourcePage = alias(siteCrawlPages, "layout_graph_source_page");
+var graphTargetPage = alias(siteCrawlPages, "layout_graph_target_page");
+var FORCE_ATLAS_SETTINGS = Object.freeze({
+  adjustSizes: false,
+  barnesHutOptimize: true,
+  barnesHutTheta: 0.5,
+  edgeWeightInfluence: 0.5,
+  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;
+function siteCrawlGraphNodeSize(extent, nodeCount) {
+  if (!Number.isFinite(extent) || extent <= 0 || nodeCount <= 0) return 0;
+  const byExtent = extent * NODE_SIZE_EXTENT_FRACTION;
+  const byArea = Math.sqrt(NOVERLAP_SETTINGS.maxPackingFraction * (2 * extent) ** 2 / nodeCount) / 2;
+  return Math.min(byExtent, byArea);
+}
+function siteCrawlGraphExtent(positions) {
+  if (positions.length === 0) return 0;
+  const centerX = positions.reduce((sum, p) => sum + p.x, 0) / positions.length;
+  const centerY = positions.reduce((sum, p) => sum + p.y, 0) / positions.length;
+  let extent = 0;
+  for (const position of positions) {
+    extent = Math.max(extent, Math.abs(position.x - centerX), Math.abs(position.y - centerY));
+  }
+  return extent;
+}
+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 COMPONENT_PACKING_SPACING_FACTOR = 3;
+function siteCrawlGraphLayoutSettingsFingerprint(settings) {
+  return crypto.createHash("sha256").update(JSON.stringify(settings)).digest("hex").slice(0, 8);
+}
+var SITE_CRAWL_GRAPH_LAYOUT_ALGORITHM = "site-health-fa2-v5";
+var SITE_CRAWL_GRAPH_LAYOUT_VERSION = `${SITE_CRAWL_GRAPH_LAYOUT_ALGORITHM}-${siteCrawlGraphLayoutSettingsFingerprint({
+  forceAtlas: FORCE_ATLAS_SETTINGS,
+  noverlap: NOVERLAP_SETTINGS,
+  nodeSizeExtentFraction: NODE_SIZE_EXTENT_FRACTION,
+  componentPackingSpacingFactor: COMPONENT_PACKING_SPACING_FACTOR,
+  templateLinkRatioThreshold: TEMPLATE_LINK_RATIO_THRESHOLD
+})}`;
+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});
+  }
+  for (const edge of workerData.input.edges) {
+    graph.addDirectedEdgeWithKey(edge.edgeKey, edge.sourceNodeKey, edge.targetNodeKey, {
+      weight: 1 + Math.log2(Math.max(1, edge.occurrences)),
+    });
+  }
+  if (graph.order > 1 && graph.size > 0) {
+    forceAtlas2.assign(graph, {
+      iterations: workerData.input.iterations,
+      settings: workerData.settings,
+    });
+  }
+  let nodeSize = 0;
+  // 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.
+      // Mirrors siteCrawlGraphNodeSize; a test asserts the two agree.
+      const byExtent = extent * workerData.nodeSizeExtentFraction;
+      const byArea = Math.sqrt(
+        (workerData.noverlap.maxPackingFraction * Math.pow(2 * extent, 2)) / graph.order,
+      ) / 2;
+      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});
+  });
+  parentPort.postMessage({ok: true, positions, nodeSize});
+} catch (error) {
+  parentPort.postMessage({
+    ok: false,
+    error: error && typeof error.message === 'string' ? error.message : String(error),
+  });
+}
+`;
+var GraphLayoutTimeoutError = class extends Error {
+  name = "GraphLayoutTimeoutError";
+};
+function hashUnit(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0) / 4294967296;
+}
+function pathSection(path) {
+  return path.split("/").filter(Boolean)[0] ?? "__root__";
+}
+function seedSiteCrawlGraphNodes(nodes, rootNodeKey, priorPositions) {
+  return [...nodes].sort((a, b) => a.sampleRank - b.sampleRank || a.nodeKey.localeCompare(b.nodeKey)).map((node) => {
+    const prior = priorPositions?.get(node.nodeKey);
+    if (prior && Number.isFinite(prior.x) && Number.isFinite(prior.y)) {
+      return {
+        ...node,
+        x: prior.x * SITE_CRAWL_GRAPH_SEED_SCALE,
+        y: prior.y * SITE_CRAWL_GRAPH_SEED_SCALE
+      };
+    }
+    if (node.nodeKey === rootNodeKey) return { ...node, x: 0, y: 0 };
+    const section = pathSection(node.path);
+    const sectionAngle = hashUnit(`section:${section}`) * Math.PI * 2;
+    const sectionRadius = section === "__root__" ? 24 : 100;
+    const clusterX = Math.cos(sectionAngle) * sectionRadius;
+    const clusterY = Math.sin(sectionAngle) * sectionRadius;
+    const localAngle = hashUnit(`node-angle:${node.nodeKey}`) * Math.PI * 2;
+    const depth = Math.max(0, Math.min(12, node.depth ?? 4));
+    const localRadius = 4 + depth * 2.5 + Math.sqrt(hashUnit(`node-radius:${node.nodeKey}`)) * 14;
+    return {
+      ...node,
+      x: clusterX + Math.cos(localAngle) * localRadius,
+      y: clusterY + Math.sin(localAngle) * localRadius
+    };
+  });
+}
+function adaptiveForceAtlasIterations(nodeCount, edgeCount) {
+  if (nodeCount <= 100 && edgeCount <= 500) return 100;
+  if (nodeCount <= 500 && edgeCount <= 2500) return 70;
+  if (nodeCount <= 2e3 && edgeCount <= 1e4) return 40;
+  if (nodeCount <= 5e3 && edgeCount <= 2e4) return 24;
+  if (nodeCount <= 1e4 && edgeCount <= 35e3) return 12;
+  return 6;
+}
+async function computeForceAtlasPositions(input, options = {}) {
+  if (input.nodes.length <= 1 || input.edges.length === 0) {
+    const positions = input.nodes.map(({ nodeKey, x, y }) => ({ nodeKey, x, y }));
+    return { positions, nodeSize: siteCrawlGraphNodeSize(siteCrawlGraphExtent(positions), positions.length) };
+  }
+  const requireFromPackage = createRequire(import.meta.url);
+  const worker = new Worker(WORKER_SOURCE, {
+    eval: true,
+    workerData: {
+      graphologyPath: requireFromPackage.resolve("graphology"),
+      forceAtlasPath: requireFromPackage.resolve("graphology-layout-forceatlas2"),
+      noverlapPath: requireFromPackage.resolve("graphology-layout-noverlap"),
+      input,
+      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;
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      void worker.terminate();
+      if (result.error) reject(result.error instanceof Error ? result.error : new Error("Graph layout failed with a non-Error reason", { cause: result.error }));
+      else resolve({ positions: result.positions ?? [], nodeSize: result.nodeSize ?? 0 });
+    };
+    const onAbort = () => finish({ error: options.signal?.reason ?? new DOMException("Layout aborted", "AbortError") });
+    const timer = setTimeout(() => finish({ error: new GraphLayoutTimeoutError(`Graph layout exceeded ${timeoutMs}ms`) }), timeoutMs);
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    if (options.signal?.aborted) return onAbort();
+    worker.once("message", (message) => {
+      if (!message.ok) finish({ error: new Error(message.error ?? "Graph layout worker failed") });
+      else finish({ positions: message.positions, nodeSize: message.nodeSize });
+    });
+    worker.once("error", (error) => finish({ error }));
+    worker.once("exit", (code) => {
+      if (code !== 0 && !settled) finish({ error: new Error(`Graph layout worker exited with code ${code}`) });
+    });
+  });
+}
+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]);
+  }
+  return [...members.values()].sort((left, right) => right.length - left.length || (left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0));
+}
+function describeComponent(nodeKeys, byKey) {
+  let sumX = 0;
+  let sumY = 0;
+  for (const nodeKey of nodeKeys) {
+    const position = byKey.get(nodeKey);
+    sumX += position.x;
+    sumY += position.y;
+  }
+  const centerX = sumX / nodeKeys.length;
+  const centerY = sumY / nodeKeys.length;
+  let radius = 0;
+  for (const nodeKey of nodeKeys) {
+    const position = byKey.get(nodeKey);
+    radius = Math.max(radius, Math.hypot(position.x - centerX, position.y - centerY));
+  }
+  return { nodeKeys, centerX, centerY, radius };
+}
+function packSiteCrawlGraphComponents(positions, edges, nodeSpacing) {
+  const components = siteCrawlGraphComponents(positions.map((position) => position.nodeKey), edges);
+  if (components.length <= 1) return [...positions];
+  const byKey = new Map(positions.map((position) => [position.nodeKey, position]));
+  if (positions.some((position) => !Number.isFinite(position.x) || !Number.isFinite(position.y))) {
+    return [...positions];
+  }
+  const described = components.map((nodeKeys) => describeComponent(nodeKeys, byKey));
+  const [anchor, ...rest] = described;
+  const spacing = Math.max(nodeSpacing, Number.EPSILON) * COMPONENT_PACKING_SPACING_FACTOR;
+  const ordered = [...rest].sort((left, right) => right.radius - left.radius || (left.nodeKeys[0] < right.nodeKeys[0] ? -1 : left.nodeKeys[0] > right.nodeKeys[0] ? 1 : 0));
+  const moved = /* @__PURE__ */ new Map();
+  let ringRadius = anchor.radius + spacing;
+  let ringPitch = 0;
+  let placedOnRing = 0;
+  let ringCapacity = 0;
+  for (const component of ordered) {
+    if (placedOnRing >= ringCapacity) {
+      ringPitch = 2 * component.radius + spacing;
+      ringRadius += ringPitch / 2 + (placedOnRing === 0 ? 0 : ringPitch / 2);
+      ringCapacity = Math.max(1, Math.floor(2 * Math.PI * ringRadius / ringPitch));
+      placedOnRing = 0;
+    }
+    const angle = placedOnRing / ringCapacity * Math.PI * 2;
+    placedOnRing += 1;
+    const targetX = anchor.centerX + Math.cos(angle) * ringRadius;
+    const targetY = anchor.centerY + Math.sin(angle) * ringRadius;
+    const shiftX = targetX - component.centerX;
+    const shiftY = targetY - component.centerY;
+    for (const nodeKey of component.nodeKeys) {
+      const position = byKey.get(nodeKey);
+      moved.set(nodeKey, { nodeKey, x: position.x + shiftX, y: position.y + shiftY });
+    }
+  }
+  return positions.map((position) => moved.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");
+  const root = rootNodeKey ? byKey.get(rootNodeKey) : null;
+  const centerX = root?.x ?? computed.reduce((sum, position) => sum + position.x, 0) / Math.max(1, computed.length);
+  const centerY = root?.y ?? computed.reduce((sum, position) => sum + position.y, 0) / Math.max(1, computed.length);
+  if (!Number.isFinite(centerX) || !Number.isFinite(centerY)) throw new Error("Graph layout returned a non-finite center");
+  let scale = 0;
+  for (const position of computed) {
+    if (!Number.isFinite(position.x) || !Number.isFinite(position.y)) throw new Error("Graph layout returned non-finite coordinates");
+    scale = Math.max(scale, Math.abs(position.x - centerX), Math.abs(position.y - centerY));
+  }
+  scale = scale > 0 ? scale : 1;
+  return seededNodes.map((node) => {
+    const position = byKey.get(node.nodeKey);
+    if (!position) throw new Error(`Graph layout omitted ${node.nodeKey}`);
+    return {
+      nodeKey: node.nodeKey,
+      sampleRank: node.sampleRank,
+      x: Math.round((position.x - centerX) / scale * 1e6) / 1e6,
+      y: Math.round((position.y - centerY) / scale * 1e6) / 1e6
+    };
+  });
+}
+async function layoutSiteCrawlGraphInput(input, options = {}) {
+  options.signal?.throwIfAborted();
+  if (input.nodes.length === 0) {
+    return {
+      state: "unavailable",
+      failureCode: "empty-crawl",
+      totalNodes: input.totalNodes,
+      totalEdges: input.totalEdges,
+      totalTemplateEdges: input.totalTemplateEdges,
+      nodeCount: 0,
+      edgeCount: 0,
+      nodes: [],
+      edges: []
+    };
+  }
+  const layoutEdges = input.edges.filter((edge) => !edge.isTemplate);
+  const seeded = seedSiteCrawlGraphNodes(input.nodes, input.rootNodeKey, input.priorPositions);
+  const timeoutMs = options.timeoutMs ?? SITE_CRAWL_GRAPH_LAYOUT_TIMEOUT_MS;
+  const deadline = Date.now() + timeoutMs;
+  const assertWithinBudget = () => {
+    options.signal?.throwIfAborted();
+    if (Date.now() > deadline) throw new GraphLayoutTimeoutError(`Graph layout exceeded ${timeoutMs}ms`);
+  };
+  try {
+    const compute = options.computePositions ?? computeForceAtlasPositions;
+    const { positions, nodeSize } = await compute({
+      nodes: seeded,
+      edges: layoutEdges,
+      iterations: adaptiveForceAtlasIterations(input.nodes.length, layoutEdges.length)
+    }, { signal: options.signal, timeoutMs: Math.max(1, deadline - Date.now()) });
+    assertWithinBudget();
+    const framed = packSiteCrawlGraphComponents(positions, layoutEdges, nodeSize);
+    assertWithinBudget();
+    return {
+      state: "ready",
+      layoutVersion: SITE_CRAWL_GRAPH_LAYOUT_VERSION,
+      totalNodes: input.totalNodes,
+      totalEdges: input.totalEdges,
+      totalTemplateEdges: input.totalTemplateEdges,
+      nodeCount: input.nodes.length,
+      edgeCount: input.edges.length,
+      templateLinksExcluded: true,
+      nodes: normalizePositions(seeded, framed, input.rootNodeKey),
+      edges: input.edges.map((edge, sampleRank) => ({ ...edge, sampleRank }))
+    };
+  } catch (error) {
+    if (options.signal?.aborted) options.signal.throwIfAborted();
+    if (error instanceof DOMException && error.name === "AbortError") throw error;
+    return {
+      state: "unavailable",
+      failureCode: error instanceof GraphLayoutTimeoutError ? "layout-timeout" : "layout-error",
+      totalNodes: input.totalNodes,
+      totalEdges: input.totalEdges,
+      totalTemplateEdges: input.totalTemplateEdges,
+      nodeCount: 0,
+      edgeCount: 0,
+      nodes: [],
+      edges: []
+    };
+  }
+}
+function loadPriorSiteCrawlGraphPositions(db, scope) {
+  const prior = db.select({
+    runId: siteCrawlSnapshots.runId,
+    attemptId: siteCrawlSnapshots.attemptId
+  }).from(siteCrawlSnapshots).innerJoin(siteCrawlGraphLayouts, and(
+    eq(siteCrawlGraphLayouts.projectId, siteCrawlSnapshots.projectId),
+    eq(siteCrawlGraphLayouts.runId, siteCrawlSnapshots.runId),
+    eq(siteCrawlGraphLayouts.attemptId, siteCrawlSnapshots.attemptId)
+  )).where(and(
+    eq(siteCrawlSnapshots.projectId, scope.projectId),
+    ne(siteCrawlSnapshots.runId, scope.runId),
+    eq(siteCrawlSnapshots.complete, true),
+    eq(siteCrawlGraphLayouts.state, "ready"),
+    eq(siteCrawlGraphLayouts.layoutVersion, SITE_CRAWL_GRAPH_LAYOUT_VERSION)
+  )).orderBy(desc(siteCrawlSnapshots.createdAt), desc(siteCrawlSnapshots.id)).limit(1).get();
+  if (!prior?.attemptId) return /* @__PURE__ */ new Map();
+  return new Map(db.select({
+    nodeKey: siteCrawlGraphNodes.nodeKey,
+    x: siteCrawlGraphNodes.x,
+    y: siteCrawlGraphNodes.y
+  }).from(siteCrawlGraphNodes).where(and(
+    eq(siteCrawlGraphNodes.projectId, scope.projectId),
+    eq(siteCrawlGraphNodes.runId, prior.runId),
+    eq(siteCrawlGraphNodes.attemptId, prior.attemptId)
+  )).all().map((node) => [node.nodeKey, { x: node.x, y: node.y }]));
+}
+async function prepareSiteCrawlGraphLayout(db, scope, options = {}) {
+  let totalNodes = 0;
+  let totalEdges = 0;
+  let totalTemplateEdges = 0;
+  try {
+    const assertNotAborted = () => options.signal?.throwIfAborted();
+    assertNotAborted();
+    const pageScope = [
+      eq(siteCrawlPages.projectId, scope.projectId),
+      eq(siteCrawlPages.runId, scope.runId),
+      eq(siteCrawlPages.attemptId, scope.attemptId)
+    ];
+    const edgeScope = [
+      eq(siteCrawlEdges.projectId, scope.projectId),
+      eq(siteCrawlEdges.runId, scope.runId),
+      eq(siteCrawlEdges.attemptId, scope.attemptId),
+      eq(siteCrawlEdges.internal, true),
+      eq(siteCrawlEdges.relation, "anchor")
+    ];
+    totalNodes = db.select({ value: count() }).from(siteCrawlPages).where(and(...pageScope)).get()?.value ?? 0;
+    assertNotAborted();
+    const countGraphCompatibleEdges = (...extra) => db.select({ value: count() }).from(siteCrawlEdges).innerJoin(graphSourcePage, and(
+      eq(graphSourcePage.projectId, scope.projectId),
+      eq(graphSourcePage.runId, scope.runId),
+      eq(graphSourcePage.attemptId, scope.attemptId),
+      eq(graphSourcePage.nodeKey, siteCrawlEdges.sourceNodeKey)
+    )).innerJoin(graphTargetPage, and(
+      eq(graphTargetPage.projectId, scope.projectId),
+      eq(graphTargetPage.runId, scope.runId),
+      eq(graphTargetPage.attemptId, scope.attemptId),
+      eq(graphTargetPage.nodeKey, siteCrawlEdges.targetNodeKey)
+    )).where(and(...edgeScope, ...extra)).get()?.value ?? 0;
+    totalEdges = countGraphCompatibleEdges();
+    assertNotAborted();
+    totalTemplateEdges = countGraphCompatibleEdges(eq(siteCrawlEdges.isTemplate, true));
+    assertNotAborted();
+    const graphSeedColumns = {
+      nodeKey: siteCrawlPages.nodeKey,
+      path: siteCrawlPages.path,
+      depth: siteCrawlPages.depth
+    };
+    const rootRows = db.select(graphSeedColumns).from(siteCrawlPages).where(and(...pageScope, eq(siteCrawlPages.url, scope.rootUrl))).orderBy(asc(siteCrawlPages.nodeKey)).limit(1).all();
+    assertNotAborted();
+    const retainedRows = [...rootRows];
+    if (retainedRows.length < SITE_CRAWL_GRAPH_MAX_NODES) {
+      retainedRows.push(...db.select(graphSeedColumns).from(siteCrawlPages).where(and(...pageScope, eq(siteCrawlPages.depth, 0), ne(siteCrawlPages.url, scope.rootUrl))).orderBy(asc(siteCrawlPages.nodeKey)).limit(SITE_CRAWL_GRAPH_MAX_NODES - retainedRows.length).all());
+    }
+    assertNotAborted();
+    if (retainedRows.length < SITE_CRAWL_GRAPH_MAX_NODES) {
+      retainedRows.push(...db.select(graphSeedColumns).from(siteCrawlPages).where(and(
+        ...pageScope,
+        or(isNull(siteCrawlPages.depth), ne(siteCrawlPages.depth, 0)),
+        ne(siteCrawlPages.url, scope.rootUrl)
+      )).orderBy(desc(siteCrawlPages.linkScoreNormalized), asc(siteCrawlPages.nodeKey)).limit(SITE_CRAWL_GRAPH_MAX_NODES - retainedRows.length).all());
+    }
+    assertNotAborted();
+    const nodes = retainedRows.map((row, sampleRank) => ({
+      nodeKey: row.nodeKey,
+      path: row.path,
+      depth: row.depth,
+      sampleRank
+    }));
+    const rootNodeKey = rootRows[0]?.nodeKey ?? null;
+    const priorPositions = loadPriorSiteCrawlGraphPositions(db, scope);
+    assertNotAborted();
+    const selectedKeys = JSON.stringify(nodes.map((node) => node.nodeKey));
+    const edgeRows = nodes.length === 0 ? [] : db.all(sql`
+      WITH selected(node_key) AS (SELECT value FROM json_each(${selectedKeys}))
+      SELECT
+        edge.edge_key AS edgeKey,
+        edge.source_node_key AS sourceNodeKey,
+        edge.target_node_key AS targetNodeKey,
+        edge.followable AS followable,
+        edge.occurrences AS occurrences,
+        edge.is_template AS isTemplate
+      FROM site_crawl_edges AS edge
+      INNER JOIN selected AS source ON source.node_key = edge.source_node_key
+      INNER JOIN selected AS target ON target.node_key = edge.target_node_key
+      WHERE edge.project_id = ${scope.projectId}
+        AND edge.run_id = ${scope.runId}
+        AND edge.attempt_id = ${scope.attemptId}
+        AND edge.internal = 1
+        AND edge.relation = 'anchor'
+      ORDER BY edge.occurrences DESC, edge.edge_key ASC
+      LIMIT ${SITE_CRAWL_GRAPH_MAX_EDGES}
+    `);
+    assertNotAborted();
+    return await layoutSiteCrawlGraphInput({
+      totalNodes,
+      totalEdges,
+      totalTemplateEdges,
+      nodes,
+      edges: edgeRows.map((row) => ({ ...row, isTemplate: Boolean(row.isTemplate) })),
+      rootNodeKey,
+      priorPositions
+    }, options);
+  } catch (error) {
+    if (options.signal?.aborted) options.signal.throwIfAborted();
+    if (error instanceof DOMException && error.name === "AbortError") throw error;
+    return {
+      state: "unavailable",
+      failureCode: "layout-error",
+      totalNodes,
+      totalEdges,
+      totalTemplateEdges,
+      nodeCount: 0,
+      edgeCount: 0,
+      nodes: [],
+      edges: []
+    };
+  }
+}
+function persistSiteCrawlGraphLayout(db, scope, layout, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  db.transaction((tx) => {
+    tx.delete(siteCrawlGraphLayouts).where(and(
+      eq(siteCrawlGraphLayouts.projectId, scope.projectId),
+      eq(siteCrawlGraphLayouts.runId, scope.runId),
+      eq(siteCrawlGraphLayouts.attemptId, scope.attemptId)
+    )).run();
+    tx.insert(siteCrawlGraphLayouts).values({
+      id: crypto.randomUUID(),
+      projectId: scope.projectId,
+      runId: scope.runId,
+      attemptId: scope.attemptId,
+      state: layout.state,
+      layoutVersion: layout.state === "ready" ? layout.layoutVersion : null,
+      failureCode: layout.state === "unavailable" ? layout.failureCode : null,
+      totalNodes: layout.totalNodes,
+      totalEdges: layout.totalEdges,
+      totalTemplateEdges: layout.totalTemplateEdges,
+      nodeCount: layout.nodeCount,
+      edgeCount: layout.edgeCount,
+      templateLinksExcluded: layout.state === "ready",
+      createdAt: now,
+      updatedAt: now
+    }).run();
+    if (layout.state !== "ready") return;
+    const batchSize = 250;
+    for (let offset = 0; offset < layout.nodes.length; offset += batchSize) {
+      tx.insert(siteCrawlGraphNodes).values(layout.nodes.slice(offset, offset + batchSize).map((node) => ({
+        id: crypto.randomUUID(),
+        projectId: scope.projectId,
+        runId: scope.runId,
+        attemptId: scope.attemptId,
+        nodeKey: node.nodeKey,
+        sampleRank: node.sampleRank,
+        x: node.x,
+        y: node.y,
+        createdAt: now
+      }))).run();
+    }
+    for (let offset = 0; offset < layout.edges.length; offset += batchSize) {
+      tx.insert(siteCrawlGraphEdges).values(layout.edges.slice(offset, offset + batchSize).map((edge) => ({
+        id: crypto.randomUUID(),
+        projectId: scope.projectId,
+        runId: scope.runId,
+        attemptId: scope.attemptId,
+        edgeKey: edge.edgeKey,
+        sampleRank: edge.sampleRank,
+        sourceNodeKey: edge.sourceNodeKey,
+        targetNodeKey: edge.targetNodeKey,
+        followable: edge.followable,
+        occurrences: edge.occurrences,
+        isTemplate: edge.isTemplate,
+        createdAt: now
+      }))).run();
+    }
+  });
+}
+function deleteSiteCrawlGraphLayout(db, scope) {
+  db.delete(siteCrawlGraphLayouts).where(and(
+    eq(siteCrawlGraphLayouts.projectId, scope.projectId),
+    eq(siteCrawlGraphLayouts.runId, scope.runId),
+    eq(siteCrawlGraphLayouts.attemptId, scope.attemptId)
+  )).run();
+}
+
+export {
+  layoutSiteCrawlGraphInput,
+  prepareSiteCrawlGraphLayout,
+  persistSiteCrawlGraphLayout,
+  deleteSiteCrawlGraphLayout
+};

package/dist/chunk-AOJU5LKX.js

@@ -0,0 +1,8 @@
+// src/package-version.ts
+import { createRequire } from "module";
+var _require = createRequire(import.meta.url);
+var PACKAGE_VERSION = _require("../package.json").version;
+
+export {
+  PACKAGE_VERSION
+};

package/dist/{chunk-KJM4DRZN.js → chunk-C7PITYL3.js}

@@ -1,15 +1,17 @@
 import {
   BUNDLED_SKILL_NAMES,
-  PACKAGE_VERSION,
   configExists,
   installSkills,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-AEE5DGTE.js";
+} from "./chunk-IOP36L3C.js";
+import {
+  PACKAGE_VERSION
+} from "./chunk-AOJU5LKX.js";
 import {
   SKILL_MANIFEST_FILENAME,
   SkillsClients
-} from "./chunk-MMSPU72Z.js";
+} from "./chunk-2U5IW3G5.js";
 
 // src/skills-autosync.ts
 import fs from "fs";