@crawlith/core 0.1.0 → 0.1.2

package/dist/utils/chalk.js

@@ -0,0 +1,41 @@
+import { styleText } from 'node:util';
+const alias = {
+    grey: 'gray'
+};
+const chalk = createChalk([]);
+function createChalk(styles) {
+    const formatter = ((text) => applyStyles(styles, text));
+    return new Proxy(formatter, {
+        apply(_target, _thisArg, args) {
+            return applyStyles(styles, args[0]);
+        },
+        get(_target, prop) {
+            if (typeof prop !== 'string') {
+                return undefined;
+            }
+            const style = alias[prop] ?? prop;
+            return createChalk([...styles, style]);
+        }
+    });
+}
+function applyStyles(styles, text) {
+    const value = String(text ?? '');
+    if (styles.length === 0 || !isColorEnabled()) {
+        return value;
+    }
+    return styleText(styles, value);
+}
+function isColorEnabled() {
+    if (process.env.NO_COLOR !== undefined || process.env.NODE_DISABLE_COLORS !== undefined) {
+        return false;
+    }
+    const forceColor = process.env.FORCE_COLOR;
+    if (forceColor === '0') {
+        return false;
+    }
+    if (forceColor !== undefined) {
+        return true;
+    }
+    return Boolean(process.stdout?.isTTY);
+}
+export default chalk;

package/dist/utils/secureConfig.d.ts

@@ -0,0 +1,23 @@
+export interface CrawlithConfig {
+    [section: string]: {
+        key?: string;
+        createdAt?: number;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Resolve the canonical Crawlith config file path.
+ */
+export declare function getCrawlithConfigPath(): string;
+/**
+ * Return section config, or undefined if config file/section does not exist.
+ */
+export declare function getConfigSection(section: string): CrawlithConfig[string] | undefined;
+/**
+ * Encrypt and persist a section API key in ~/.crawlith/config.json.
+ */
+export declare function setEncryptedConfigKey(section: string, apiKey: string): void;
+/**
+ * Get and decrypt the API key for a config section.
+ */
+export declare function getDecryptedConfigKey(section: string): string;

package/dist/utils/secureConfig.js

@@ -0,0 +1,128 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+const CONFIG_DIR = path.join(os.homedir(), '.crawlith');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+/**
+ * Resolve the canonical Crawlith config file path.
+ */
+export function getCrawlithConfigPath() {
+    return CONFIG_PATH;
+}
+/**
+ * Return section config, or undefined if config file/section does not exist.
+ */
+export function getConfigSection(section) {
+    const config = readConfigFile(false);
+    if (!config)
+        return undefined;
+    return config[section];
+}
+/**
+ * Encrypt and persist a section API key in ~/.crawlith/config.json.
+ */
+export function setEncryptedConfigKey(section, apiKey) {
+    const config = readConfigFile(false) || {};
+    config[section] = {
+        ...(config[section] || {}),
+        key: encryptString(apiKey),
+        createdAt: Math.floor(Date.now() / 1000)
+    };
+    writeConfigFile(config);
+}
+/**
+ * Get and decrypt the API key for a config section.
+ */
+export function getDecryptedConfigKey(section) {
+    if (!fs.existsSync(CONFIG_PATH)) {
+        throw new Error(`Missing ${section} config. Run: crawlith config ${section} set <api_key>`);
+    }
+    const config = readConfigFile(true);
+    if (!config) {
+        throw new Error(`Missing ${section} config. Run: crawlith config ${section} set <api_key>`);
+    }
+    const payload = config[section]?.key;
+    if (!payload || typeof payload !== 'string') {
+        throw new Error(`Missing ${section} key in config. Run: crawlith config ${section} set <api_key>`);
+    }
+    return decryptString(payload);
+}
+/**
+ * Read config file from disk.
+ */
+function readConfigFile(required) {
+    if (!fs.existsSync(CONFIG_PATH)) {
+        if (required) {
+            throw new Error('Missing config file. Run: crawlith config <service> set <api_key>');
+        }
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+    }
+    catch {
+        throw new Error('Corrupt config file at ~/.crawlith/config.json. Refusing to continue.');
+    }
+}
+/**
+ * Persist config to disk with secure permissions.
+ */
+function writeConfigFile(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { encoding: 'utf8', mode: 0o600 });
+    fs.chmodSync(CONFIG_PATH, 0o600);
+}
+/**
+ * Build a machine-bound secret so encrypted config blobs are not portable across systems.
+ */
+function getMachineSecret() {
+    return `${os.hostname()}::${os.userInfo().username}`;
+}
+/**
+ * Encrypt plaintext using AES-256-GCM and scrypt-derived key.
+ */
+function encryptString(plaintext) {
+    const salt = crypto.randomBytes(16);
+    const iv = crypto.randomBytes(12);
+    const key = crypto.scryptSync(getMachineSecret(), salt, 32);
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+    const payload = {
+        salt: salt.toString('base64'),
+        iv: iv.toString('base64'),
+        tag: cipher.getAuthTag().toString('base64'),
+        data: encrypted.toString('base64')
+    };
+    return Buffer.from(JSON.stringify(payload), 'utf8').toString('base64');
+}
+/**
+ * Decrypt an encrypted base64 payload from config.json.
+ */
+function decryptString(encodedPayload) {
+    let payload;
+    try {
+        payload = JSON.parse(Buffer.from(encodedPayload, 'base64').toString('utf8'));
+    }
+    catch {
+        throw new Error('Corrupt config payload: unable to parse encrypted key data.');
+    }
+    if (!payload?.salt || !payload?.iv || !payload?.tag || !payload?.data) {
+        throw new Error('Corrupt config payload: required encryption fields are missing.');
+    }
+    try {
+        const salt = Buffer.from(payload.salt, 'base64');
+        const iv = Buffer.from(payload.iv, 'base64');
+        const tag = Buffer.from(payload.tag, 'base64');
+        const data = Buffer.from(payload.data, 'base64');
+        const key = crypto.scryptSync(getMachineSecret(), salt, 32);
+        const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+        decipher.setAuthTag(tag);
+        return Buffer.concat([decipher.update(data), decipher.final()]).toString('utf8');
+    }
+    catch {
+        throw new Error('Unable to decrypt config key. Config may be invalid or tied to another machine/user.');
+    }
+}

package/package.json

@@ -1,6 +1,8 @@
 {
   "name": "@crawlith/core",
-  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "version": "0.1.2",
+  "description": "Headless intelligence engine for Crawlith. Handles crawling, graph analysis, scoring, and data persistence.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,23 +13,27 @@
       "default": "./dist/index.js"
     }
   },
+  "files": [
+    "dist"
+  ],
   "dependencies": {
     "better-sqlite3": "^12.6.2",
-    "chalk": "^5.3.0",
     "cheerio": "^1.0.0-rc.12",
-    "p-limit": "^5.0.0",
+    "commander": "^12.1.0",
+    "p-limit": "^7.3.0",
     "robots-parser": "^3.0.1",
-    "undici": "^6.13.0",
-    "vite": "7.3.1"
+    "undici": "^6.13.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
+    "@types/cheerio": "0.22.35",
     "@types/node": "^20.12.7",
     "typescript": "^5.4.5",
+    "vite": "7.3.1",
     "vitest": "^4.0.18"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node scripts/copy-assets.js",
     "test": "vitest run"
   }
 }

package/CHANGELOG.md

@@ -1,7 +0,0 @@
-# @crawlith/core
-
-## 0.1.0
-
-### Minor Changes
-
-- First test

package/dist/db/schema.d.ts

@@ -1,2 +0,0 @@
-import { Database } from 'better-sqlite3';
-export declare function initSchema(db: Database): void;

package/dist/graph/cluster.d.ts

@@ -1,6 +0,0 @@
-import { Graph, ClusterInfo } from './graph.js';
-/**
- * Detects content clusters using 64-bit SimHash and Hamming Distance.
- * Uses band optimization to reduce O(n^2) comparisons.
- */
-export declare function detectContentClusters(graph: Graph, threshold?: number, minSize?: number): ClusterInfo[];

package/dist/graph/cluster.js

@@ -1,173 +0,0 @@
-import { SimHash } from './simhash.js';
-/**
- * Detects content clusters using 64-bit SimHash and Hamming Distance.
- * Uses band optimization to reduce O(n^2) comparisons.
- */
-export function detectContentClusters(graph, threshold = 10, minSize = 3) {
-    const nodes = graph.getNodes().filter(n => n.simhash && n.status === 200);
-    if (nodes.length === 0)
-        return [];
-    const adjacency = new Map();
-    // Banding Optimization (4 bands of 16 bits)
-    // Note: For threshold > 3, this is a heuristic and may miss some pairs,
-    // but it dramatically reduces the search space as requested.
-    const bands = 4;
-    const bandWidth = 16;
-    const buckets = Array.from({ length: bands }, () => new Map());
-    for (const node of nodes) {
-        const hash = BigInt(node.simhash);
-        for (let b = 0; b < bands; b++) {
-            const bandValue = Number((hash >> BigInt(b * bandWidth)) & 0xffffn);
-            if (!buckets[b].has(bandValue)) {
-                buckets[b].set(bandValue, new Set());
-            }
-            buckets[b].get(bandValue).add(node.url);
-        }
-    }
-    const checkedPairs = new Set();
-    for (let b = 0; b < bands; b++) {
-        for (const bucket of buckets[b].values()) {
-            if (bucket.size < 2)
-                continue;
-            const bucketNodes = Array.from(bucket);
-            for (let i = 0; i < bucketNodes.length; i++) {
-                for (let j = i + 1; j < bucketNodes.length; j++) {
-                    const u1 = bucketNodes[i];
-                    const u2 = bucketNodes[j];
-                    if (u1 === u2)
-                        continue;
-                    const pairKey = u1 < u2 ? `${u1}|${u2}` : `${u2}|${u1}`;
-                    if (checkedPairs.has(pairKey))
-                        continue;
-                    checkedPairs.add(pairKey);
-                    const n1 = graph.nodes.get(u1);
-                    const n2 = graph.nodes.get(u2);
-                    const dist = SimHash.hammingDistance(BigInt(n1.simhash), BigInt(n2.simhash));
-                    if (dist <= threshold) {
-                        if (!adjacency.has(u1))
-                            adjacency.set(u1, new Set());
-                        if (!adjacency.has(u2))
-                            adjacency.set(u2, new Set());
-                        adjacency.get(u1).add(u2);
-                        adjacency.get(u2).add(u1);
-                    }
-                }
-            }
-        }
-    }
-    // Find connected components (Clusters)
-    const visited = new Set();
-    const clusters = [];
-    for (const node of nodes) {
-        if (visited.has(node.url))
-            continue;
-        const component = [];
-        const queue = [node.url];
-        visited.add(node.url);
-        while (queue.length > 0) {
-            const current = queue.shift();
-            component.push(current);
-            const neighbors = adjacency.get(current);
-            if (neighbors) {
-                for (const neighbor of neighbors) {
-                    if (!visited.has(neighbor)) {
-                        visited.add(neighbor);
-                        queue.push(neighbor);
-                    }
-                }
-            }
-        }
-        if (component.length >= minSize) {
-            clusters.push(component);
-        }
-    }
-    // Sort clusters by size (descending) then by primary URL (ascending) for deterministic IDs
-    clusters.sort((a, b) => {
-        if (b.length !== a.length)
-            return b.length - a.length;
-        const aPrimary = selectPrimaryUrl(a, graph);
-        const bPrimary = selectPrimaryUrl(b, graph);
-        return aPrimary.localeCompare(bPrimary);
-    });
-    const clusterInfos = [];
-    clusters.forEach((memberUrls, index) => {
-        const clusterId = index + 1;
-        const clusterNodes = memberUrls.map(url => graph.nodes.get(url));
-        for (const node of clusterNodes) {
-            node.clusterId = clusterId;
-        }
-        const primaryUrl = selectPrimaryUrl(memberUrls, graph);
-        const risk = calculateClusterRisk(clusterNodes);
-        const sharedPathPrefix = findSharedPathPrefix(memberUrls);
-        clusterInfos.push({
-            id: clusterId,
-            count: memberUrls.length,
-            primaryUrl,
-            risk,
-            sharedPathPrefix
-        });
-    });
-    graph.contentClusters = clusterInfos;
-    return clusterInfos;
-}
-/**
- * Selects the primary URL for a cluster based on:
- * 1. Highest PageRank
- * 2. Shortest URL
- * 3. Lexicographic fallback
- */
-function selectPrimaryUrl(urls, graph) {
-    return urls.reduce((best, current) => {
-        const nBest = graph.nodes.get(best);
-        const nCurrent = graph.nodes.get(current);
-        if ((nCurrent.pageRank || 0) > (nBest.pageRank || 0))
-            return current;
-        if ((nCurrent.pageRank || 0) < (nBest.pageRank || 0))
-            return best;
-        if (current.length < best.length)
-            return current;
-        if (current.length > best.length)
-            return best;
-        return current.localeCompare(best) < 0 ? current : best;
-    });
-}
-/**
- * Calculates cannibalization risk based on title and H1 similarity within the cluster.
- */
-function calculateClusterRisk(nodes) {
-    // Logic: Check if there's significant overlap in Titles or H1s among cluster members.
-    // This is a heuristic as requested.
-    // Simplified heuristic: risk is based on cluster density and size
-    // Large clusters of highly similar content are high risk.
-    // Fallback to a safe categorization
-    if (nodes.length > 5)
-        return 'high';
-    if (nodes.length > 2)
-        return 'medium';
-    return 'low';
-}
-/**
- * Finds the common path prefix among a set of URLs.
- */
-function findSharedPathPrefix(urls) {
-    if (urls.length < 2)
-        return undefined;
-    try {
-        const paths = urls.map(u => new URL(u).pathname.split('/').filter(Boolean));
-        const first = paths[0];
-        const common = [];
-        for (let i = 0; i < first.length; i++) {
-            const segment = first[i];
-            if (paths.every(p => p[i] === segment)) {
-                common.push(segment);
-            }
-            else {
-                break;
-            }
-        }
-        return common.length > 0 ? '/' + common.join('/') : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/graph/duplicate.d.ts

@@ -1,10 +0,0 @@
-import { Graph } from './graph.js';
-export interface DuplicateOptions {
-    collapse?: boolean;
-    simhashThreshold?: number;
-}
-/**
- * Detects exact and near duplicates, identifies canonical conflicts,
- * and performs non-destructive collapse of edges.
- */
-export declare function detectDuplicates(graph: Graph, options?: DuplicateOptions): void;

package/dist/graph/duplicate.js

@@ -1,251 +0,0 @@
-import { SimHash } from './simhash.js';
-/**
- * Detects exact and near duplicates, identifies canonical conflicts,
- * and performs non-destructive collapse of edges.
- */
-export function detectDuplicates(graph, options = {}) {
-    const collapse = options.collapse !== false; // Default to true
-    const threshold = options.simhashThreshold ?? 3;
-    const exactClusters = [];
-    const nearClusters = [];
-    const nodes = graph.getNodes();
-    // Phase 1 & 2: Exact Duplicate Detection
-    const exactMap = new Map();
-    for (const node of nodes) {
-        if (!node.contentHash || node.status !== 200)
-            continue;
-        // Safety check: if there's no soft404 signal (soft404 is handled elsewhere, but just filter 200 OKs)
-        let arr = exactMap.get(node.contentHash);
-        if (!arr) {
-            arr = [];
-            exactMap.set(node.contentHash, arr);
-        }
-        arr.push(node);
-    }
-    // Nodes that are NOT part of an exact duplicate group are candidates for near duplicate checks
-    const nearCandidates = [];
-    let clusterCounter = 1;
-    for (const [_hash, group] of exactMap.entries()) {
-        if (group.length > 1) {
-            const id = `cluster_exact_${clusterCounter++}`;
-            exactClusters.push({ id, type: 'exact', nodes: group });
-            // Mark nodes
-            for (const n of group) {
-                n.duplicateClusterId = id;
-                n.duplicateType = 'exact';
-            }
-        }
-        else {
-            nearCandidates.push(group[0]);
-        }
-    }
-    // Phase 3: Near Duplicate Detection (SimHash with Bands)
-    // 64-bit simhash -> split into 4 bands of 16 bits.
-    const bandsMaps = [
-        new Map(),
-        new Map(),
-        new Map(),
-        new Map()
-    ];
-    for (const node of nearCandidates) {
-        if (!node.simhash)
-            continue;
-        const simhash = BigInt(node.simhash);
-        // Extract 16 bit bands
-        const b0 = Number(simhash & 0xffffn);
-        const b1 = Number((simhash >> 16n) & 0xffffn);
-        const b2 = Number((simhash >> 32n) & 0xffffn);
-        const b3 = Number((simhash >> 48n) & 0xffffn);
-        const bands = [b0, b1, b2, b3];
-        for (let i = 0; i < 4; i++) {
-            let arr = bandsMaps[i].get(bands[i]);
-            if (!arr) {
-                arr = [];
-                bandsMaps[i].set(bands[i], arr);
-            }
-            arr.push(node);
-        }
-    }
-    // Find candidate pairs
-    const nearGroupMap = new Map(); // node.url -> cluster set
-    const checkedPairs = new Set();
-    for (let i = 0; i < 4; i++) {
-        for (const [_bandVal, bucketNodes] of bandsMaps[i].entries()) {
-            if (bucketNodes.length < 2)
-                continue; // nothing to compare
-            // Compare all nodes in this bucket
-            for (let j = 0; j < bucketNodes.length; j++) {
-                for (let k = j + 1; k < bucketNodes.length; k++) {
-                    const n1 = bucketNodes[j];
-                    const n2 = bucketNodes[k];
-                    // Ensure n1 < n2 lexicographically to avoid duplicate pairs
-                    const [a, b] = n1.url < n2.url ? [n1, n2] : [n2, n1];
-                    const pairKey = `${a.url}|${b.url}`;
-                    if (checkedPairs.has(pairKey))
-                        continue;
-                    checkedPairs.add(pairKey);
-                    const dist = SimHash.hammingDistance(BigInt(a.simhash), BigInt(b.simhash));
-                    if (dist <= threshold) {
-                        // They are near duplicates. 
-                        // Find or create their cluster set using union-find or reference propagation
-                        const setA = nearGroupMap.get(a.url);
-                        const setB = nearGroupMap.get(b.url);
-                        if (!setA && !setB) {
-                            const newSet = new Set([a, b]);
-                            nearGroupMap.set(a.url, newSet);
-                            nearGroupMap.set(b.url, newSet);
-                        }
-                        else if (setA && !setB) {
-                            setA.add(b);
-                            nearGroupMap.set(b.url, setA);
-                        }
-                        else if (setB && !setA) {
-                            setB.add(a);
-                            nearGroupMap.set(a.url, setB);
-                        }
-                        else if (setA && setB && setA !== setB) {
-                            // Merge sets
-                            for (const node of setB) {
-                                setA.add(node);
-                                nearGroupMap.set(node.url, setA);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    // Compile near duplicate clusters (deduplicated by Set reference)
-    const uniqueNearSets = new Set();
-    for (const group of nearGroupMap.values()) {
-        uniqueNearSets.add(group);
-    }
-    for (const groupSet of uniqueNearSets) {
-        if (groupSet.size > 1) {
-            const id = `cluster_near_${clusterCounter++}`;
-            const groupArr = Array.from(groupSet);
-            nearClusters.push({ id, type: 'near', nodes: groupArr });
-            for (const n of groupArr) {
-                n.duplicateClusterId = id;
-                n.duplicateType = 'near';
-            }
-        }
-    }
-    const allClusters = [...exactClusters, ...nearClusters];
-    // Phase 4: Template-Heavy Detection
-    // Mark classes as 'template_heavy' if ratio < 0.3
-    for (const cluster of allClusters) {
-        const avgRatio = cluster.nodes.reduce((sum, n) => sum + (n.uniqueTokenRatio || 0), 0) / cluster.nodes.length;
-        if (avgRatio < 0.3) {
-            cluster.type = 'template_heavy';
-            cluster.nodes.forEach(n => n.duplicateType = 'template_heavy');
-        }
-    }
-    // Phase 5: Canonical Conflict & Representative Selection
-    for (const cluster of allClusters) {
-        const canonicals = new Set();
-        let hasMissing = false;
-        for (const n of cluster.nodes) {
-            if (!n.canonical)
-                hasMissing = true;
-            // We compare full absolute canonical URLs (assuming they are normalized during crawl)
-            else
-                canonicals.add(n.canonical);
-        }
-        if (hasMissing || canonicals.size > 1) {
-            cluster.severity = 'high';
-        }
-        else if (cluster.type === 'near') {
-            cluster.severity = 'medium';
-        }
-        else {
-            cluster.severity = 'low';
-        }
-        // Phase 6: Select Representative
-        // 1. Valid Canonical target in cluster
-        // 2. Highest internal in-degree
-        // 3. Shortest URL
-        // 4. First discovered (relying on array order, which is from BFS map roughly)
-        let representativeNode = cluster.nodes[0];
-        // Evaluate best rep
-        const urlsInCluster = new Set(cluster.nodes.map(n => n.url));
-        const validCanonicals = cluster.nodes.filter(n => n.canonical && urlsInCluster.has(n.canonical) && n.url === n.canonical);
-        if (validCanonicals.length > 0) {
-            representativeNode = validCanonicals[0]; // If multiple, just pick first matching self
-        }
-        else {
-            representativeNode = cluster.nodes.reduce((best, current) => {
-                if (current.inLinks > best.inLinks)
-                    return current;
-                if (current.inLinks < best.inLinks)
-                    return best;
-                if (current.url.length < best.url.length)
-                    return current;
-                return best;
-            });
-        }
-        cluster.representative = representativeNode.url;
-        cluster.nodes.forEach(n => {
-            n.isClusterPrimary = n.url === representativeNode.url;
-            n.isCollapsed = false; // default for JSON
-            n.collapseInto = undefined;
-        });
-        // Push to Graph's final cluster list
-        graph.duplicateClusters.push({
-            id: cluster.id,
-            type: cluster.type,
-            size: cluster.nodes.length,
-            representative: representativeNode.url,
-            severity: cluster.severity
-        });
-        // Controlled Collapse
-        if (collapse) {
-            for (const n of cluster.nodes) {
-                if (n.url !== representativeNode.url) {
-                    n.isCollapsed = true;
-                    n.collapseInto = representativeNode.url;
-                }
-            }
-        }
-    }
-    // Final Edge Transfer if Collapsing
-    if (collapse) {
-        const edges = graph.getEdges();
-        const updatedEdges = new Map();
-        for (const edge of edges) {
-            const sourceNode = graph.nodes.get(edge.source);
-            const targetNode = graph.nodes.get(edge.target);
-            if (!sourceNode || !targetNode)
-                continue;
-            // We do NOT modify source structure for out-bound edges of collapsed nodes? 
-            // Spec: "Ignore edges from collapsed nodes. Transfer inbound edges to representative."
-            // Actually, if a node links TO a collapsed node, we repoint the edge to the representative.
-            // If a collapsed node links to X, we ignore it (PageRank will filter it out).
-            const actualSource = edge.source;
-            // repoint target
-            const actualTarget = targetNode.isCollapsed && targetNode.collapseInto ? targetNode.collapseInto : edge.target;
-            // Skip self-referential edges caused by repointing
-            if (actualSource === actualTarget)
-                continue;
-            const edgeKey = `${actualSource}|${actualTarget}`;
-            const existingWeight = updatedEdges.get(edgeKey) || 0;
-            updatedEdges.set(edgeKey, Math.max(existingWeight, edge.weight)); // deduplicate
-        }
-        // Update graph edges in-place
-        graph.edges = updatedEdges;
-        // Re-calculate inLinks and outLinks based on collapsed edges
-        for (const node of graph.getNodes()) {
-            node.inLinks = 0;
-            node.outLinks = 0;
-        }
-        for (const [edgeKey, _weight] of updatedEdges.entries()) {
-            const [src, tgt] = edgeKey.split('|');
-            const sn = graph.nodes.get(src);
-            const tn = graph.nodes.get(tgt);
-            if (sn)
-                sn.outLinks++;
-            if (tn)
-                tn.inLinks++;
-        }
-    }
-}