wiki-graph-core 0.3.1

package/dist/topology/snake-detector.js

@@ -0,0 +1,520 @@
+import { getReadingEdgeKey } from "./weights.js";
+const ATTRIBUTE_BONUS_WEIGHT = 3;
+const DEFAULT_LINK_STRENGTH_WEIGHT = 1;
+const DEFAULT_SNAKE_WORDS_COUNT = 280;
+const DECAY_FACTOR = 0.75;
+const MIN_EDGE_WEIGHT = 0.1;
+function splitConnectedComponents(input) {
+  const sortedChunkIds = [...input.chunkIds].sort(compareNumber);
+  const chunkIdRecord = createBooleanRecord();
+  const adjacentChunkIdsByChunkId = createNumberListRecord();
+  const visitedChunkIds = createBooleanRecord();
+  const components = [];
+  for (const chunkId of sortedChunkIds) {
+    chunkIdRecord[String(chunkId)] = true;
+  }
+  for (const edge of input.edges) {
+    if (chunkIdRecord[String(edge.fromId)] !== true || chunkIdRecord[String(edge.toId)] !== true) {
+      continue;
+    }
+    attachChunkAdjacency(adjacentChunkIdsByChunkId, edge.fromId, edge.toId);
+    attachChunkAdjacency(adjacentChunkIdsByChunkId, edge.toId, edge.fromId);
+  }
+  for (const chunkId of sortedChunkIds) {
+    if (visitedChunkIds[String(chunkId)] === true) {
+      continue;
+    }
+    const stack = [chunkId];
+    const component = [];
+    visitedChunkIds[String(chunkId)] = true;
+    while (stack.length > 0) {
+      const currentChunkId = stack.pop();
+      if (currentChunkId === void 0) {
+        continue;
+      }
+      component.push(currentChunkId);
+      for (const nextChunkId of adjacentChunkIdsByChunkId[String(currentChunkId)] ?? []) {
+        if (visitedChunkIds[String(nextChunkId)] === true) {
+          continue;
+        }
+        visitedChunkIds[String(nextChunkId)] = true;
+        stack.push(nextChunkId);
+      }
+    }
+    component.sort(compareNumber);
+    components.push(component);
+  }
+  components.sort((left, right) => {
+    const leftMinChunkId = left[0] ?? Number.POSITIVE_INFINITY;
+    const rightMinChunkId = right[0] ?? Number.POSITIVE_INFINITY;
+    return leftMinChunkId - rightMinChunkId;
+  });
+  return components;
+}
+function detectSnakesInComponent(input) {
+  if (input.chunks.length === 0) {
+    return [];
+  }
+  const graph = createDetectorGraph(input.chunks, input.edges);
+  if (!isWeaklyConnected(graph)) {
+    throw new Error(
+      "Snake detector requires a weakly connected component input"
+    );
+  }
+  const snakeWordsCount = input.snakeWordsCount ?? DEFAULT_SNAKE_WORDS_COUNT;
+  const totalWordsCount = input.chunks.reduce((sum, chunk) => {
+    return sum + chunk.wordsCount;
+  }, 0);
+  if (totalWordsCount <= snakeWordsCount) {
+    return [
+      [...input.chunks].sort(compareChunkBySentence).map((chunk) => chunk.id)
+    ];
+  }
+  const fingerprints = computeAllFingerprints(graph);
+  validateFingerprints(fingerprints);
+  const phaseOneClusters = greedyMerge(
+    graph,
+    fingerprints,
+    {
+      enableBonus: true,
+      snakeWordsCount
+    },
+    void 0
+  );
+  const phaseTwoClusters = greedyMerge(
+    graph,
+    fingerprints,
+    {
+      enableBonus: false,
+      snakeWordsCount
+    },
+    phaseOneClusters
+  );
+  return [...phaseTwoClusters.values()].map(
+    (cluster) => [...cluster].sort((leftId, rightId) => {
+      const leftChunk = graph.chunksById[String(leftId)];
+      const rightChunk = graph.chunksById[String(rightId)];
+      if (leftChunk === void 0 || rightChunk === void 0) {
+        return leftId - rightId;
+      }
+      return compareChunkBySentence(leftChunk, rightChunk);
+    })
+  );
+}
+function attachChunkAdjacency(adjacentChunkIdsByChunkId, fromId, toId) {
+  const existingAdjacentChunkIds = adjacentChunkIdsByChunkId[String(fromId)] ?? [];
+  if (existingAdjacentChunkIds.includes(toId)) {
+    return;
+  }
+  adjacentChunkIdsByChunkId[String(fromId)] = [
+    ...existingAdjacentChunkIds,
+    toId
+  ];
+}
+function clustersConnected(graph, leftCluster, rightCluster) {
+  for (const leftChunkId of leftCluster) {
+    for (const rightChunkId of rightCluster) {
+      if (graph.edgeByKey[getReadingEdgeKey(leftChunkId, rightChunkId)] !== void 0 || graph.edgeByKey[getReadingEdgeKey(rightChunkId, leftChunkId)] !== void 0) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function compareChunkBySentence(left, right) {
+  const [leftSerialId, leftSentenceIndex] = left.sentenceId;
+  const [rightSerialId, rightSentenceIndex] = right.sentenceId;
+  if (leftSerialId !== rightSerialId) {
+    return leftSerialId - rightSerialId;
+  }
+  if (leftSentenceIndex !== rightSentenceIndex) {
+    return leftSentenceIndex - rightSentenceIndex;
+  }
+  return left.id - right.id;
+}
+function compareEdgeQueueEntry(left, right) {
+  if (left.value !== right.value) {
+    return right.value - left.value;
+  }
+  if (left.leftClusterId !== right.leftClusterId) {
+    return left.leftClusterId - right.leftClusterId;
+  }
+  return left.rightClusterId - right.rightClusterId;
+}
+function compareNumber(left, right) {
+  return left - right;
+}
+function computeAllFingerprints(graph) {
+  const fingerprints = createNumberMatrixRecord();
+  for (const startChunkId of graph.sortedChunkIds) {
+    const concentrations = createNumberRecord();
+    let currentLayer = [startChunkId];
+    const visitedChunkIds = createBooleanRecord();
+    concentrations[String(startChunkId)] = 1;
+    visitedChunkIds[String(startChunkId)] = true;
+    while (currentLayer.length > 0) {
+      const nextLayerConcentrations = createNumberRecord();
+      for (const currentChunkId of currentLayer) {
+        const currentConcentration = concentrations[String(currentChunkId)] ?? 0;
+        let totalWeight = 0;
+        const neighbors = [];
+        for (const edge of graph.incomingEdgesByChunkId[String(currentChunkId)] ?? []) {
+          if (visitedChunkIds[String(edge.fromId)] === true) {
+            continue;
+          }
+          const weight = graph.fingerprintEdgeWeightsByKey[getReadingEdgeKey(edge.fromId, currentChunkId)] ?? graph.fingerprintEdgeWeightsByKey[getReadingEdgeKey(currentChunkId, edge.fromId)] ?? DEFAULT_LINK_STRENGTH_WEIGHT;
+          neighbors.push([edge.fromId, weight]);
+          totalWeight += weight;
+        }
+        for (const edge of graph.outgoingEdgesByChunkId[String(currentChunkId)] ?? []) {
+          if (visitedChunkIds[String(edge.toId)] === true) {
+            continue;
+          }
+          const weight = graph.fingerprintEdgeWeightsByKey[getReadingEdgeKey(currentChunkId, edge.toId)] ?? graph.fingerprintEdgeWeightsByKey[getReadingEdgeKey(edge.toId, currentChunkId)] ?? DEFAULT_LINK_STRENGTH_WEIGHT;
+          neighbors.push([edge.toId, weight]);
+          totalWeight += weight;
+        }
+        if (totalWeight <= 0) {
+          continue;
+        }
+        for (const [neighborChunkId, weight] of neighbors) {
+          const contribution = currentConcentration * (weight / totalWeight) * DECAY_FACTOR;
+          nextLayerConcentrations[String(neighborChunkId)] = (nextLayerConcentrations[String(neighborChunkId)] ?? 0) + contribution;
+        }
+      }
+      currentLayer = Object.keys(nextLayerConcentrations).map(Number);
+      for (const nextChunkId of currentLayer) {
+        concentrations[String(nextChunkId)] = nextLayerConcentrations[String(nextChunkId)] ?? 0;
+        visitedChunkIds[String(nextChunkId)] = true;
+      }
+    }
+    const totalConcentration = Object.values(concentrations).reduce(
+      (sum, concentration) => sum + concentration,
+      0
+    );
+    if (totalConcentration > 0) {
+      for (const chunkId of Object.keys(concentrations)) {
+        concentrations[chunkId] = (concentrations[chunkId] ?? 0) / totalConcentration;
+      }
+    }
+    fingerprints[String(startChunkId)] = concentrations;
+  }
+  return fingerprints;
+}
+function computeClusterWordsCount(graph, cluster) {
+  return cluster.reduce((sum, chunkId) => {
+    return sum + (graph.chunksById[String(chunkId)]?.wordsCount ?? 0);
+  }, 0);
+}
+function computeMergeValue(graph, leftCluster, rightCluster, fingerprints) {
+  let edgeCount = 0;
+  let minValue = Number.POSITIVE_INFINITY;
+  for (const leftChunkId of leftCluster) {
+    for (const rightChunkId of rightCluster) {
+      const edge = graph.edgeByKey[getReadingEdgeKey(leftChunkId, rightChunkId)] ?? graph.edgeByKey[getReadingEdgeKey(rightChunkId, leftChunkId)];
+      if (edge === void 0) {
+        continue;
+      }
+      edgeCount += 1;
+      const leftFingerprint = fingerprints[String(leftChunkId)] ?? {};
+      const rightFingerprint = fingerprints[String(rightChunkId)] ?? {};
+      let squaredSum = 0;
+      for (const targetChunkId of Object.keys(leftFingerprint)) {
+        const diff = (leftFingerprint[targetChunkId] ?? 0) - (rightFingerprint[targetChunkId] ?? 0);
+        squaredSum += diff * diff;
+      }
+      let deltaValue = getLinkStrengthWeight(edge.strength);
+      const leftChunk = graph.chunksById[String(leftChunkId)];
+      const rightChunk = graph.chunksById[String(rightChunkId)];
+      if (leftChunk?.retention !== void 0 && rightChunk?.retention !== void 0) {
+        deltaValue += ATTRIBUTE_BONUS_WEIGHT;
+      }
+      if (leftChunk?.importance !== void 0 && rightChunk?.importance !== void 0) {
+        deltaValue += ATTRIBUTE_BONUS_WEIGHT;
+      }
+      const distance = Math.sqrt(squaredSum);
+      const value = (1 - distance / 2) * deltaValue;
+      minValue = Math.min(minValue, value);
+    }
+  }
+  if (edgeCount === 0) {
+    return Number.NEGATIVE_INFINITY;
+  }
+  return minValue;
+}
+function createBooleanRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function createDetectorGraph(chunks, edges) {
+  const chunksById = createChunkRecord();
+  const edgeByKey = createEdgeRecord();
+  const incomingEdgesByChunkId = createReadingEdgeListRecord();
+  const outgoingEdgesByChunkId = createReadingEdgeListRecord();
+  const sortedChunkIds = [...chunks].map((chunk) => chunk.id).sort(compareNumber);
+  const undirectedAdjacentChunkIdsByChunkId = createNumberListRecord();
+  for (const chunk of chunks) {
+    chunksById[String(chunk.id)] = chunk;
+  }
+  for (const edge of edges) {
+    if (chunksById[String(edge.fromId)] === void 0 || chunksById[String(edge.toId)] === void 0) {
+      continue;
+    }
+    const edgeKey = getReadingEdgeKey(edge.fromId, edge.toId);
+    edgeByKey[edgeKey] = edge;
+    if (incomingEdgesByChunkId[String(edge.toId)] === void 0) {
+      incomingEdgesByChunkId[String(edge.toId)] = [];
+    }
+    if (outgoingEdgesByChunkId[String(edge.fromId)] === void 0) {
+      outgoingEdgesByChunkId[String(edge.fromId)] = [];
+    }
+    incomingEdgesByChunkId[String(edge.toId)]?.push(edge);
+    outgoingEdgesByChunkId[String(edge.fromId)]?.push(edge);
+    attachChunkAdjacency(
+      undirectedAdjacentChunkIdsByChunkId,
+      edge.fromId,
+      edge.toId
+    );
+    attachChunkAdjacency(
+      undirectedAdjacentChunkIdsByChunkId,
+      edge.toId,
+      edge.fromId
+    );
+  }
+  return {
+    chunksById,
+    edgeByKey,
+    fingerprintEdgeWeightsByKey: computeFingerprintEdgeWeights(
+      chunksById,
+      edges
+    ),
+    incomingEdgesByChunkId,
+    outgoingEdgesByChunkId,
+    sortedChunkIds,
+    undirectedAdjacentChunkIdsByChunkId
+  };
+}
+function createChunkRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function createEdgeQueueEntry(leftClusterId, rightClusterId, value) {
+  return {
+    leftClusterId,
+    rightClusterId,
+    value
+  };
+}
+function createEdgeRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function createReadingEdgeListRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function createNumberMatrixRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function createNumberListRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function createNumberRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function createOptionalNumberRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function getClusterPairKey(leftClusterId, rightClusterId) {
+  return leftClusterId < rightClusterId ? getReadingEdgeKey(leftClusterId, rightClusterId) : getReadingEdgeKey(rightClusterId, leftClusterId);
+}
+function getLinkStrengthWeight(strength) {
+  switch (strength) {
+    case "critical":
+      return 9;
+    case "important":
+      return 3;
+    case "helpful":
+      return 1;
+    default:
+      return DEFAULT_LINK_STRENGTH_WEIGHT;
+  }
+}
+function greedyMerge(graph, fingerprints, config, initialClusters) {
+  const clusters = initialClusters === void 0 ? new Map(
+    graph.sortedChunkIds.map((chunkId) => [chunkId, [chunkId]])
+  ) : new Map(
+    [...initialClusters.entries()].map(([clusterId, chunkIds]) => [
+      clusterId,
+      [...chunkIds]
+    ])
+  );
+  const nodeToCluster = createOptionalNumberRecord();
+  const edgeQueue = [];
+  const queuedClusterPairs = createBooleanRecord();
+  for (const [clusterId, chunkIds] of clusters.entries()) {
+    for (const chunkId of chunkIds) {
+      nodeToCluster[String(chunkId)] = clusterId;
+    }
+  }
+  for (const leftClusterId of clusters.keys()) {
+    for (const rightClusterId of clusters.keys()) {
+      if (leftClusterId >= rightClusterId) {
+        continue;
+      }
+      const leftCluster = clusters.get(leftClusterId);
+      const rightCluster = clusters.get(rightClusterId);
+      if (leftCluster === void 0 || rightCluster === void 0) {
+        continue;
+      }
+      if (!clustersConnected(graph, leftCluster, rightCluster)) {
+        continue;
+      }
+      edgeQueue.push(
+        createEdgeQueueEntry(
+          leftClusterId,
+          rightClusterId,
+          computeMergeValue(graph, leftCluster, rightCluster, fingerprints)
+        )
+      );
+      queuedClusterPairs[getClusterPairKey(leftClusterId, rightClusterId)] = true;
+    }
+  }
+  while (edgeQueue.length > 0) {
+    edgeQueue.sort(compareEdgeQueueEntry);
+    const nextEntry = edgeQueue.shift();
+    if (nextEntry === void 0) {
+      continue;
+    }
+    const currentLeftClusterId = nodeToCluster[String(nextEntry.leftClusterId)];
+    const currentRightClusterId = nodeToCluster[String(nextEntry.rightClusterId)];
+    if (currentLeftClusterId === void 0 || currentRightClusterId === void 0 || currentLeftClusterId === currentRightClusterId) {
+      continue;
+    }
+    const leftCluster = clusters.get(currentLeftClusterId);
+    const rightCluster = clusters.get(currentRightClusterId);
+    if (leftCluster === void 0 || rightCluster === void 0) {
+      continue;
+    }
+    if (!clustersConnected(graph, leftCluster, rightCluster)) {
+      continue;
+    }
+    if (config.enableBonus && leftCluster.length >= 2 && rightCluster.length >= 2) {
+      continue;
+    }
+    if (computeClusterWordsCount(graph, leftCluster) + computeClusterWordsCount(graph, rightCluster) > config.snakeWordsCount) {
+      continue;
+    }
+    leftCluster.push(...rightCluster);
+    clusters.delete(currentRightClusterId);
+    for (const chunkId of rightCluster) {
+      nodeToCluster[String(chunkId)] = currentLeftClusterId;
+    }
+    const neighborChunkIds = /* @__PURE__ */ new Set();
+    for (const chunkId of leftCluster) {
+      for (const neighborChunkId of graph.undirectedAdjacentChunkIdsByChunkId[String(chunkId)] ?? []) {
+        neighborChunkIds.add(neighborChunkId);
+      }
+    }
+    for (const neighborChunkId of neighborChunkIds) {
+      const neighborClusterId = nodeToCluster[String(neighborChunkId)];
+      if (neighborClusterId === void 0 || neighborClusterId === currentLeftClusterId) {
+        continue;
+      }
+      const neighborCluster = clusters.get(neighborClusterId);
+      if (neighborCluster === void 0) {
+        continue;
+      }
+      const clusterPairKey = getClusterPairKey(
+        currentLeftClusterId,
+        neighborClusterId
+      );
+      if (queuedClusterPairs[clusterPairKey] === true) {
+        continue;
+      }
+      edgeQueue.push(
+        createEdgeQueueEntry(
+          Math.min(currentLeftClusterId, neighborClusterId),
+          Math.max(currentLeftClusterId, neighborClusterId),
+          computeMergeValue(graph, leftCluster, neighborCluster, fingerprints)
+        )
+      );
+      queuedClusterPairs[clusterPairKey] = true;
+    }
+  }
+  return clusters;
+}
+function isWeaklyConnected(graph) {
+  const firstChunkId = graph.sortedChunkIds[0];
+  if (firstChunkId === void 0) {
+    return true;
+  }
+  const visitedChunkIds = createBooleanRecord();
+  const stack = [firstChunkId];
+  visitedChunkIds[String(firstChunkId)] = true;
+  while (stack.length > 0) {
+    const currentChunkId = stack.pop();
+    if (currentChunkId === void 0) {
+      continue;
+    }
+    for (const nextChunkId of graph.undirectedAdjacentChunkIdsByChunkId[String(currentChunkId)] ?? []) {
+      if (visitedChunkIds[String(nextChunkId)] === true) {
+        continue;
+      }
+      visitedChunkIds[String(nextChunkId)] = true;
+      stack.push(nextChunkId);
+    }
+  }
+  return graph.sortedChunkIds.every(
+    (chunkId) => visitedChunkIds[String(chunkId)] === true
+  );
+}
+function validateFingerprints(fingerprints) {
+  const firstChunkId = Object.keys(fingerprints)[0];
+  if (firstChunkId === void 0) {
+    return;
+  }
+  const referenceChunkIds = Object.keys(
+    fingerprints[firstChunkId] ?? {}
+  ).sort();
+  for (const [chunkId, fingerprint] of Object.entries(fingerprints)) {
+    const fingerprintChunkIds = Object.keys(fingerprint).sort();
+    if (fingerprintChunkIds.length !== referenceChunkIds.length || fingerprintChunkIds.some(
+      (targetChunkId, index) => targetChunkId !== referenceChunkIds[index]
+    )) {
+      throw new Error(`Fingerprint structure mismatch for chunk ${chunkId}`);
+    }
+  }
+}
+function computeFingerprintEdgeWeights(chunksById, edges) {
+  const totalStrengthsByChunkId = createNumberRecord();
+  for (const edge of edges) {
+    if (chunksById[String(edge.fromId)] === void 0 || chunksById[String(edge.toId)] === void 0) {
+      continue;
+    }
+    const strengthWeight = getLinkStrengthWeight(edge.strength);
+    totalStrengthsByChunkId[String(edge.fromId)] = (totalStrengthsByChunkId[String(edge.fromId)] ?? 0) + strengthWeight;
+    totalStrengthsByChunkId[String(edge.toId)] = (totalStrengthsByChunkId[String(edge.toId)] ?? 0) + strengthWeight;
+  }
+  const edgeWeightsByKey = createNumberRecord();
+  for (const edge of edges) {
+    const fromChunk = chunksById[String(edge.fromId)];
+    const toChunk = chunksById[String(edge.toId)];
+    if (fromChunk === void 0 || toChunk === void 0) {
+      continue;
+    }
+    const strengthWeight = getLinkStrengthWeight(edge.strength);
+    const fromTotalStrength = totalStrengthsByChunkId[String(edge.fromId)] ?? 0;
+    const toTotalStrength = totalStrengthsByChunkId[String(edge.toId)] ?? 0;
+    const fromHalfWeight = fromTotalStrength === 0 ? 0 : fromChunk.weight * (strengthWeight / fromTotalStrength);
+    const toHalfWeight = toTotalStrength === 0 ? 0 : toChunk.weight * (strengthWeight / toTotalStrength);
+    const finalWeight = Math.max(
+      fromHalfWeight + toHalfWeight,
+      MIN_EDGE_WEIGHT
+    );
+    edgeWeightsByKey[getReadingEdgeKey(edge.fromId, edge.toId)] = finalWeight;
+    edgeWeightsByKey[getReadingEdgeKey(edge.toId, edge.fromId)] = finalWeight;
+  }
+  return edgeWeightsByKey;
+}
+export {
+  detectSnakesInComponent,
+  splitConnectedComponents
+};
+//# sourceMappingURL=snake-detector.js.map

package/dist/topology/snake-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/topology/snake-detector.ts"],"sourcesContent":["import type { ChunkRecord, ReadingEdgeRecord } from \"../document/index.js\";\nimport { getReadingEdgeKey } from \"./weights.js\";\n\nconst ATTRIBUTE_BONUS_WEIGHT = 3;\nconst DEFAULT_LINK_STRENGTH_WEIGHT = 1;\nconst DEFAULT_SNAKE_WORDS_COUNT = 280;\nconst DECAY_FACTOR = 0.75;\nconst MIN_EDGE_WEIGHT = 0.1;\n\ninterface DetectorGraph {\n  readonly chunksById: Readonly<Record<string, ChunkRecord | undefined>>;\n  readonly edgeByKey: Readonly<Record<string, ReadingEdgeRecord | undefined>>;\n  readonly fingerprintEdgeWeightsByKey: Readonly<Record<string, number>>;\n  readonly incomingEdgesByChunkId: Readonly<\n    Record<string, readonly ReadingEdgeRecord[] | undefined>\n  >;\n  readonly outgoingEdgesByChunkId: Readonly<\n    Record<string, readonly ReadingEdgeRecord[] | undefined>\n  >;\n  readonly sortedChunkIds: readonly number[];\n  readonly undirectedAdjacentChunkIdsByChunkId: Readonly<\n    Record<string, readonly number[] | undefined>\n  >;\n}\n\ninterface MergeConfig {\n  readonly enableBonus: boolean;\n  readonly snakeWordsCount: number;\n}\n\nexport function splitConnectedComponents(input: {\n  chunkIds: readonly number[];\n  edges: readonly ReadingEdgeRecord[];\n}): number[][] {\n  const sortedChunkIds = [...input.chunkIds].sort(compareNumber);\n  const chunkIdRecord = createBooleanRecord();\n  const adjacentChunkIdsByChunkId = createNumberListRecord();\n  const visitedChunkIds = createBooleanRecord();\n  const components: number[][] = [];\n\n  for (const chunkId of sortedChunkIds) {\n    chunkIdRecord[String(chunkId)] = true;\n  }\n\n  for (const edge of input.edges) {\n    if (\n      chunkIdRecord[String(edge.fromId)] !== true ||\n      chunkIdRecord[String(edge.toId)] !== true\n    ) {\n      continue;\n    }\n\n    attachChunkAdjacency(adjacentChunkIdsByChunkId, edge.fromId, edge.toId);\n    attachChunkAdjacency(adjacentChunkIdsByChunkId, edge.toId, edge.fromId);\n  }\n\n  for (const chunkId of sortedChunkIds) {\n    if (visitedChunkIds[String(chunkId)] === true) {\n      continue;\n    }\n\n    const stack = [chunkId];\n    const component: number[] = [];\n    visitedChunkIds[String(chunkId)] = true;\n\n    while (stack.length > 0) {\n      const currentChunkId = stack.pop();\n\n      if (currentChunkId === undefined) {\n        continue;\n      }\n\n      component.push(currentChunkId);\n\n      for (const nextChunkId of adjacentChunkIdsByChunkId[\n        String(currentChunkId)\n      ] ?? []) {\n        if (visitedChunkIds[String(nextChunkId)] === true) {\n          continue;\n        }\n\n        visitedChunkIds[String(nextChunkId)] = true;\n        stack.push(nextChunkId);\n      }\n    }\n\n    component.sort(compareNumber);\n    components.push(component);\n  }\n\n  components.sort((left, right) => {\n    const leftMinChunkId = left[0] ?? Number.POSITIVE_INFINITY;\n    const rightMinChunkId = right[0] ?? Number.POSITIVE_INFINITY;\n\n    return leftMinChunkId - rightMinChunkId;\n  });\n\n  return components;\n}\n\nexport function detectSnakesInComponent(input: {\n  chunks: readonly ChunkRecord[];\n  edges: readonly ReadingEdgeRecord[];\n  snakeWordsCount?: number;\n}): number[][] {\n  if (input.chunks.length === 0) {\n    return [];\n  }\n\n  const graph = createDetectorGraph(input.chunks, input.edges);\n\n  if (!isWeaklyConnected(graph)) {\n    throw new Error(\n      \"Snake detector requires a weakly connected component input\",\n    );\n  }\n\n  const snakeWordsCount = input.snakeWordsCount ?? DEFAULT_SNAKE_WORDS_COUNT;\n  const totalWordsCount = input.chunks.reduce((sum, chunk) => {\n    return sum + chunk.wordsCount;\n  }, 0);\n\n  if (totalWordsCount <= snakeWordsCount) {\n    return [\n      [...input.chunks].sort(compareChunkBySentence).map((chunk) => chunk.id),\n    ];\n  }\n\n  const fingerprints = computeAllFingerprints(graph);\n\n  validateFingerprints(fingerprints);\n\n  const phaseOneClusters = greedyMerge(\n    graph,\n    fingerprints,\n    {\n      enableBonus: true,\n      snakeWordsCount,\n    },\n    undefined,\n  );\n  const phaseTwoClusters = greedyMerge(\n    graph,\n    fingerprints,\n    {\n      enableBonus: false,\n      snakeWordsCount,\n    },\n    phaseOneClusters,\n  );\n\n  return [...phaseTwoClusters.values()].map((cluster) =>\n    [...cluster].sort((leftId, rightId) => {\n      const leftChunk = graph.chunksById[String(leftId)];\n      const rightChunk = graph.chunksById[String(rightId)];\n\n      if (leftChunk === undefined || rightChunk === undefined) {\n        return leftId - rightId;\n      }\n\n      return compareChunkBySentence(leftChunk, rightChunk);\n    }),\n  );\n}\n\nfunction attachChunkAdjacency(\n  adjacentChunkIdsByChunkId: Record<string, number[] | undefined>,\n  fromId: number,\n  toId: number,\n): void {\n  const existingAdjacentChunkIds =\n    adjacentChunkIdsByChunkId[String(fromId)] ?? [];\n\n  if (existingAdjacentChunkIds.includes(toId)) {\n    return;\n  }\n\n  adjacentChunkIdsByChunkId[String(fromId)] = [\n    ...existingAdjacentChunkIds,\n    toId,\n  ];\n}\n\nfunction clustersConnected(\n  graph: DetectorGraph,\n  leftCluster: readonly number[],\n  rightCluster: readonly number[],\n): boolean {\n  for (const leftChunkId of leftCluster) {\n    for (const rightChunkId of rightCluster) {\n      if (\n        graph.edgeByKey[getReadingEdgeKey(leftChunkId, rightChunkId)] !==\n          undefined ||\n        graph.edgeByKey[getReadingEdgeKey(rightChunkId, leftChunkId)] !==\n          undefined\n      ) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n}\n\nfunction compareChunkBySentence(left: ChunkRecord, right: ChunkRecord): number {\n  const [leftSerialId, leftSentenceIndex] = left.sentenceId;\n  const [rightSerialId, rightSentenceIndex] = right.sentenceId;\n\n  if (leftSerialId !== rightSerialId) {\n    return leftSerialId - rightSerialId;\n  }\n\n  if (leftSentenceIndex !== rightSentenceIndex) {\n    return leftSentenceIndex - rightSentenceIndex;\n  }\n\n  return left.id - right.id;\n}\n\nfunction compareEdgeQueueEntry(\n  left: EdgeQueueEntry,\n  right: EdgeQueueEntry,\n): number {\n  if (left.value !== right.value) {\n    return right.value - left.value;\n  }\n\n  if (left.leftClusterId !== right.leftClusterId) {\n    return left.leftClusterId - right.leftClusterId;\n  }\n\n  return left.rightClusterId - right.rightClusterId;\n}\n\nfunction compareNumber(left: number, right: number): number {\n  return left - right;\n}\n\nfunction computeAllFingerprints(\n  graph: DetectorGraph,\n): Readonly<Record<string, Readonly<Record<string, number>>>> {\n  const fingerprints = createNumberMatrixRecord();\n\n  for (const startChunkId of graph.sortedChunkIds) {\n    const concentrations = createNumberRecord();\n    let currentLayer = [startChunkId];\n    const visitedChunkIds = createBooleanRecord();\n\n    concentrations[String(startChunkId)] = 1;\n    visitedChunkIds[String(startChunkId)] = true;\n\n    while (currentLayer.length > 0) {\n      const nextLayerConcentrations = createNumberRecord();\n\n      for (const currentChunkId of currentLayer) {\n        const currentConcentration =\n          concentrations[String(currentChunkId)] ?? 0;\n        let totalWeight = 0;\n        const neighbors: Array<readonly [number, number]> = [];\n\n        for (const edge of graph.incomingEdgesByChunkId[\n          String(currentChunkId)\n        ] ?? []) {\n          if (visitedChunkIds[String(edge.fromId)] === true) {\n            continue;\n          }\n\n          const weight =\n            graph.fingerprintEdgeWeightsByKey[\n              getReadingEdgeKey(edge.fromId, currentChunkId)\n            ] ??\n            graph.fingerprintEdgeWeightsByKey[\n              getReadingEdgeKey(currentChunkId, edge.fromId)\n            ] ??\n            DEFAULT_LINK_STRENGTH_WEIGHT;\n\n          neighbors.push([edge.fromId, weight]);\n          totalWeight += weight;\n        }\n\n        for (const edge of graph.outgoingEdgesByChunkId[\n          String(currentChunkId)\n        ] ?? []) {\n          if (visitedChunkIds[String(edge.toId)] === true) {\n            continue;\n          }\n\n          const weight =\n            graph.fingerprintEdgeWeightsByKey[\n              getReadingEdgeKey(currentChunkId, edge.toId)\n            ] ??\n            graph.fingerprintEdgeWeightsByKey[\n              getReadingEdgeKey(edge.toId, currentChunkId)\n            ] ??\n            DEFAULT_LINK_STRENGTH_WEIGHT;\n\n          neighbors.push([edge.toId, weight]);\n          totalWeight += weight;\n        }\n\n        if (totalWeight <= 0) {\n          continue;\n        }\n\n        for (const [neighborChunkId, weight] of neighbors) {\n          const contribution =\n            currentConcentration * (weight / totalWeight) * DECAY_FACTOR;\n\n          nextLayerConcentrations[String(neighborChunkId)] =\n            (nextLayerConcentrations[String(neighborChunkId)] ?? 0) +\n            contribution;\n        }\n      }\n\n      currentLayer = Object.keys(nextLayerConcentrations).map(Number);\n\n      for (const nextChunkId of currentLayer) {\n        concentrations[String(nextChunkId)] =\n          nextLayerConcentrations[String(nextChunkId)] ?? 0;\n        visitedChunkIds[String(nextChunkId)] = true;\n      }\n    }\n\n    const totalConcentration = Object.values(concentrations).reduce(\n      (sum, concentration) => sum + concentration,\n      0,\n    );\n\n    if (totalConcentration > 0) {\n      for (const chunkId of Object.keys(concentrations)) {\n        concentrations[chunkId] =\n          (concentrations[chunkId] ?? 0) / totalConcentration;\n      }\n    }\n\n    fingerprints[String(startChunkId)] = concentrations;\n  }\n\n  return fingerprints;\n}\n\nfunction computeClusterWordsCount(\n  graph: DetectorGraph,\n  cluster: readonly number[],\n): number {\n  return cluster.reduce((sum, chunkId) => {\n    return sum + (graph.chunksById[String(chunkId)]?.wordsCount ?? 0);\n  }, 0);\n}\n\nfunction computeMergeValue(\n  graph: DetectorGraph,\n  leftCluster: readonly number[],\n  rightCluster: readonly number[],\n  fingerprints: Readonly<Record<string, Readonly<Record<string, number>>>>,\n): number {\n  let edgeCount = 0;\n  let minValue = Number.POSITIVE_INFINITY;\n\n  for (const leftChunkId of leftCluster) {\n    for (const rightChunkId of rightCluster) {\n      const edge =\n        graph.edgeByKey[getReadingEdgeKey(leftChunkId, rightChunkId)] ??\n        graph.edgeByKey[getReadingEdgeKey(rightChunkId, leftChunkId)];\n\n      if (edge === undefined) {\n        continue;\n      }\n\n      edgeCount += 1;\n\n      const leftFingerprint = fingerprints[String(leftChunkId)] ?? {};\n      const rightFingerprint = fingerprints[String(rightChunkId)] ?? {};\n      let squaredSum = 0;\n\n      for (const targetChunkId of Object.keys(leftFingerprint)) {\n        const diff =\n          (leftFingerprint[targetChunkId] ?? 0) -\n          (rightFingerprint[targetChunkId] ?? 0);\n\n        squaredSum += diff * diff;\n      }\n\n      let deltaValue = getLinkStrengthWeight(edge.strength);\n      const leftChunk = graph.chunksById[String(leftChunkId)];\n      const rightChunk = graph.chunksById[String(rightChunkId)];\n\n      if (\n        leftChunk?.retention !== undefined &&\n        rightChunk?.retention !== undefined\n      ) {\n        deltaValue += ATTRIBUTE_BONUS_WEIGHT;\n      }\n      if (\n        leftChunk?.importance !== undefined &&\n        rightChunk?.importance !== undefined\n      ) {\n        deltaValue += ATTRIBUTE_BONUS_WEIGHT;\n      }\n\n      const distance = Math.sqrt(squaredSum);\n      const value = (1 - distance / 2) * deltaValue;\n\n      minValue = Math.min(minValue, value);\n    }\n  }\n\n  if (edgeCount === 0) {\n    return Number.NEGATIVE_INFINITY;\n  }\n\n  return minValue;\n}\n\nfunction createBooleanRecord(): Record<string, boolean | undefined> {\n  return Object.create(null) as Record<string, boolean | undefined>;\n}\n\nfunction createDetectorGraph(\n  chunks: readonly ChunkRecord[],\n  edges: readonly ReadingEdgeRecord[],\n): DetectorGraph {\n  const chunksById = createChunkRecord();\n  const edgeByKey = createEdgeRecord();\n  const incomingEdgesByChunkId = createReadingEdgeListRecord();\n  const outgoingEdgesByChunkId = createReadingEdgeListRecord();\n  const sortedChunkIds = [...chunks]\n    .map((chunk) => chunk.id)\n    .sort(compareNumber);\n  const undirectedAdjacentChunkIdsByChunkId = createNumberListRecord();\n\n  for (const chunk of chunks) {\n    chunksById[String(chunk.id)] = chunk;\n  }\n\n  for (const edge of edges) {\n    if (\n      chunksById[String(edge.fromId)] === undefined ||\n      chunksById[String(edge.toId)] === undefined\n    ) {\n      continue;\n    }\n\n    const edgeKey = getReadingEdgeKey(edge.fromId, edge.toId);\n\n    edgeByKey[edgeKey] = edge;\n    if (incomingEdgesByChunkId[String(edge.toId)] === undefined) {\n      incomingEdgesByChunkId[String(edge.toId)] = [];\n    }\n    if (outgoingEdgesByChunkId[String(edge.fromId)] === undefined) {\n      outgoingEdgesByChunkId[String(edge.fromId)] = [];\n    }\n\n    incomingEdgesByChunkId[String(edge.toId)]?.push(edge);\n    outgoingEdgesByChunkId[String(edge.fromId)]?.push(edge);\n    attachChunkAdjacency(\n      undirectedAdjacentChunkIdsByChunkId,\n      edge.fromId,\n      edge.toId,\n    );\n    attachChunkAdjacency(\n      undirectedAdjacentChunkIdsByChunkId,\n      edge.toId,\n      edge.fromId,\n    );\n  }\n\n  return {\n    chunksById,\n    edgeByKey,\n    fingerprintEdgeWeightsByKey: computeFingerprintEdgeWeights(\n      chunksById,\n      edges,\n    ),\n    incomingEdgesByChunkId,\n    outgoingEdgesByChunkId,\n    sortedChunkIds,\n    undirectedAdjacentChunkIdsByChunkId,\n  };\n}\n\nfunction createChunkRecord(): Record<string, ChunkRecord | undefined> {\n  return Object.create(null) as Record<string, ChunkRecord | undefined>;\n}\n\nfunction createEdgeQueueEntry(\n  leftClusterId: number,\n  rightClusterId: number,\n  value: number,\n): EdgeQueueEntry {\n  return {\n    leftClusterId,\n    rightClusterId,\n    value,\n  };\n}\n\nfunction createEdgeRecord(): Record<string, ReadingEdgeRecord | undefined> {\n  return Object.create(null) as Record<string, ReadingEdgeRecord | undefined>;\n}\n\nfunction createReadingEdgeListRecord(): Record<\n  string,\n  ReadingEdgeRecord[] | undefined\n> {\n  return Object.create(null) as Record<string, ReadingEdgeRecord[] | undefined>;\n}\n\nfunction createNumberMatrixRecord(): Record<string, Record<string, number>> {\n  return Object.create(null) as Record<string, Record<string, number>>;\n}\n\nfunction createNumberListRecord(): Record<string, number[] | undefined> {\n  return Object.create(null) as Record<string, number[] | undefined>;\n}\n\nfunction createNumberRecord(): Record<string, number> {\n  return Object.create(null) as Record<string, number>;\n}\n\nfunction createOptionalNumberRecord(): Record<string, number | undefined> {\n  return Object.create(null) as Record<string, number | undefined>;\n}\n\nfunction getClusterPairKey(\n  leftClusterId: number,\n  rightClusterId: number,\n): string {\n  return leftClusterId < rightClusterId\n    ? getReadingEdgeKey(leftClusterId, rightClusterId)\n    : getReadingEdgeKey(rightClusterId, leftClusterId);\n}\n\nfunction getLinkStrengthWeight(strength: string | undefined): number {\n  switch (strength) {\n    case \"critical\":\n      return 9;\n    case \"important\":\n      return 3;\n    case \"helpful\":\n      return 1;\n    default:\n      return DEFAULT_LINK_STRENGTH_WEIGHT;\n  }\n}\n\nfunction greedyMerge(\n  graph: DetectorGraph,\n  fingerprints: Readonly<Record<string, Readonly<Record<string, number>>>>,\n  config: MergeConfig,\n  initialClusters: ReadonlyMap<number, readonly number[]> | undefined,\n): Map<number, number[]> {\n  const clusters =\n    initialClusters === undefined\n      ? new Map<number, number[]>(\n          graph.sortedChunkIds.map((chunkId) => [chunkId, [chunkId]]),\n        )\n      : new Map(\n          [...initialClusters.entries()].map(([clusterId, chunkIds]) => [\n            clusterId,\n            [...chunkIds],\n          ]),\n        );\n  const nodeToCluster = createOptionalNumberRecord();\n  const edgeQueue: EdgeQueueEntry[] = [];\n  const queuedClusterPairs = createBooleanRecord();\n\n  for (const [clusterId, chunkIds] of clusters.entries()) {\n    for (const chunkId of chunkIds) {\n      nodeToCluster[String(chunkId)] = clusterId;\n    }\n  }\n\n  for (const leftClusterId of clusters.keys()) {\n    for (const rightClusterId of clusters.keys()) {\n      if (leftClusterId >= rightClusterId) {\n        continue;\n      }\n\n      const leftCluster = clusters.get(leftClusterId);\n      const rightCluster = clusters.get(rightClusterId);\n\n      if (leftCluster === undefined || rightCluster === undefined) {\n        continue;\n      }\n      if (!clustersConnected(graph, leftCluster, rightCluster)) {\n        continue;\n      }\n\n      edgeQueue.push(\n        createEdgeQueueEntry(\n          leftClusterId,\n          rightClusterId,\n          computeMergeValue(graph, leftCluster, rightCluster, fingerprints),\n        ),\n      );\n      queuedClusterPairs[getClusterPairKey(leftClusterId, rightClusterId)] =\n        true;\n    }\n  }\n\n  while (edgeQueue.length > 0) {\n    edgeQueue.sort(compareEdgeQueueEntry);\n\n    const nextEntry = edgeQueue.shift();\n\n    if (nextEntry === undefined) {\n      continue;\n    }\n\n    const currentLeftClusterId = nodeToCluster[String(nextEntry.leftClusterId)];\n    const currentRightClusterId =\n      nodeToCluster[String(nextEntry.rightClusterId)];\n\n    if (\n      currentLeftClusterId === undefined ||\n      currentRightClusterId === undefined ||\n      currentLeftClusterId === currentRightClusterId\n    ) {\n      continue;\n    }\n\n    const leftCluster = clusters.get(currentLeftClusterId);\n    const rightCluster = clusters.get(currentRightClusterId);\n\n    if (leftCluster === undefined || rightCluster === undefined) {\n      continue;\n    }\n    if (!clustersConnected(graph, leftCluster, rightCluster)) {\n      continue;\n    }\n\n    if (\n      config.enableBonus &&\n      leftCluster.length >= 2 &&\n      rightCluster.length >= 2\n    ) {\n      continue;\n    }\n\n    if (\n      computeClusterWordsCount(graph, leftCluster) +\n        computeClusterWordsCount(graph, rightCluster) >\n      config.snakeWordsCount\n    ) {\n      continue;\n    }\n\n    leftCluster.push(...rightCluster);\n    clusters.delete(currentRightClusterId);\n\n    for (const chunkId of rightCluster) {\n      nodeToCluster[String(chunkId)] = currentLeftClusterId;\n    }\n\n    const neighborChunkIds = new Set<number>();\n\n    for (const chunkId of leftCluster) {\n      for (const neighborChunkId of graph.undirectedAdjacentChunkIdsByChunkId[\n        String(chunkId)\n      ] ?? []) {\n        neighborChunkIds.add(neighborChunkId);\n      }\n    }\n\n    for (const neighborChunkId of neighborChunkIds) {\n      const neighborClusterId = nodeToCluster[String(neighborChunkId)];\n\n      if (\n        neighborClusterId === undefined ||\n        neighborClusterId === currentLeftClusterId\n      ) {\n        continue;\n      }\n\n      const neighborCluster = clusters.get(neighborClusterId);\n\n      if (neighborCluster === undefined) {\n        continue;\n      }\n\n      const clusterPairKey = getClusterPairKey(\n        currentLeftClusterId,\n        neighborClusterId,\n      );\n\n      if (queuedClusterPairs[clusterPairKey] === true) {\n        continue;\n      }\n\n      edgeQueue.push(\n        createEdgeQueueEntry(\n          Math.min(currentLeftClusterId, neighborClusterId),\n          Math.max(currentLeftClusterId, neighborClusterId),\n          computeMergeValue(graph, leftCluster, neighborCluster, fingerprints),\n        ),\n      );\n      queuedClusterPairs[clusterPairKey] = true;\n    }\n  }\n\n  return clusters;\n}\n\nfunction isWeaklyConnected(graph: DetectorGraph): boolean {\n  const firstChunkId = graph.sortedChunkIds[0];\n\n  if (firstChunkId === undefined) {\n    return true;\n  }\n\n  const visitedChunkIds = createBooleanRecord();\n  const stack = [firstChunkId];\n\n  visitedChunkIds[String(firstChunkId)] = true;\n\n  while (stack.length > 0) {\n    const currentChunkId = stack.pop();\n\n    if (currentChunkId === undefined) {\n      continue;\n    }\n\n    for (const nextChunkId of graph.undirectedAdjacentChunkIdsByChunkId[\n      String(currentChunkId)\n    ] ?? []) {\n      if (visitedChunkIds[String(nextChunkId)] === true) {\n        continue;\n      }\n\n      visitedChunkIds[String(nextChunkId)] = true;\n      stack.push(nextChunkId);\n    }\n  }\n\n  return graph.sortedChunkIds.every(\n    (chunkId) => visitedChunkIds[String(chunkId)] === true,\n  );\n}\n\nfunction validateFingerprints(\n  fingerprints: Readonly<Record<string, Readonly<Record<string, number>>>>,\n): void {\n  const firstChunkId = Object.keys(fingerprints)[0];\n\n  if (firstChunkId === undefined) {\n    return;\n  }\n\n  const referenceChunkIds = Object.keys(\n    fingerprints[firstChunkId] ?? {},\n  ).sort();\n\n  for (const [chunkId, fingerprint] of Object.entries(fingerprints)) {\n    const fingerprintChunkIds = Object.keys(fingerprint).sort();\n\n    if (\n      fingerprintChunkIds.length !== referenceChunkIds.length ||\n      fingerprintChunkIds.some(\n        (targetChunkId, index) => targetChunkId !== referenceChunkIds[index],\n      )\n    ) {\n      throw new Error(`Fingerprint structure mismatch for chunk ${chunkId}`);\n    }\n  }\n}\n\nfunction computeFingerprintEdgeWeights(\n  chunksById: Readonly<Record<string, ChunkRecord | undefined>>,\n  edges: readonly ReadingEdgeRecord[],\n): Readonly<Record<string, number>> {\n  const totalStrengthsByChunkId = createNumberRecord();\n\n  for (const edge of edges) {\n    if (\n      chunksById[String(edge.fromId)] === undefined ||\n      chunksById[String(edge.toId)] === undefined\n    ) {\n      continue;\n    }\n\n    const strengthWeight = getLinkStrengthWeight(edge.strength);\n\n    totalStrengthsByChunkId[String(edge.fromId)] =\n      (totalStrengthsByChunkId[String(edge.fromId)] ?? 0) + strengthWeight;\n    totalStrengthsByChunkId[String(edge.toId)] =\n      (totalStrengthsByChunkId[String(edge.toId)] ?? 0) + strengthWeight;\n  }\n\n  const edgeWeightsByKey = createNumberRecord();\n\n  for (const edge of edges) {\n    const fromChunk = chunksById[String(edge.fromId)];\n    const toChunk = chunksById[String(edge.toId)];\n\n    if (fromChunk === undefined || toChunk === undefined) {\n      continue;\n    }\n\n    const strengthWeight = getLinkStrengthWeight(edge.strength);\n    const fromTotalStrength = totalStrengthsByChunkId[String(edge.fromId)] ?? 0;\n    const toTotalStrength = totalStrengthsByChunkId[String(edge.toId)] ?? 0;\n    const fromHalfWeight =\n      fromTotalStrength === 0\n        ? 0\n        : fromChunk.weight * (strengthWeight / fromTotalStrength);\n    const toHalfWeight =\n      toTotalStrength === 0\n        ? 0\n        : toChunk.weight * (strengthWeight / toTotalStrength);\n    const finalWeight = Math.max(\n      fromHalfWeight + toHalfWeight,\n      MIN_EDGE_WEIGHT,\n    );\n\n    edgeWeightsByKey[getReadingEdgeKey(edge.fromId, edge.toId)] = finalWeight;\n    edgeWeightsByKey[getReadingEdgeKey(edge.toId, edge.fromId)] = finalWeight;\n  }\n\n  return edgeWeightsByKey;\n}\n\ninterface EdgeQueueEntry {\n  readonly leftClusterId: number;\n  readonly rightClusterId: number;\n  readonly value: number;\n}\n"],"mappings":"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","names":[]}

package/dist/topology/snake-graph-builder.d.ts

@@ -0,0 +1,14 @@
+import { ChunkRecord, ReadingEdgeRecord } from '../document/types.js';
+
+interface SnakeGraphEdge {
+    readonly fromSnakeIndex: number;
+    readonly toSnakeIndex: number;
+    readonly weight: number;
+}
+declare function buildSnakeGraph(input: {
+    chunksById: Readonly<Record<string, ChunkRecord | undefined>>;
+    edges: readonly ReadingEdgeRecord[];
+    snakes: readonly (readonly number[])[];
+}): SnakeGraphEdge[];
+
+export { type SnakeGraphEdge, buildSnakeGraph };