@intact-ebi/cytoscape-lumina 1.0.0 → 1.1.0

package/README.md

@@ -71,7 +71,7 @@ Options are split by who uses them:
 - **Force-only** options go under `force: { ... }` and are ignored when `layoutAlgorithm` is `'stress'`.
 - **Stress-only** options go under `stress: { ... }` and are ignored when `layoutAlgorithm` is `'force'`.
 
-Internally these map to upper-case constants (e.g. `idealLength` → `IDEAL_LENGTH`); `DEFAULT_PARAMS` and `resolveParams` are exported if you need them.
+`DEFAULT_PARAMS` and `resolveParams` are exported for consumers that need the complete resolved configuration.
 
 ### Algorithm
 
@@ -107,13 +107,14 @@ Internally these map to upper-case constants (e.g. `idealLength` → `IDEAL_LENG
 | --- | --- | --- |
 | `weightExponent` | `2` | Stress weights are `w_ij = 1 / d_ij ^ weightExponent`; `2` is classic stress majorization. |
 
+Stress shortest paths use weighted Dijkstra. Computed edge lengths (`idealLength` plus both virtual-node radii) must be finite and non-negative; invalid lengths throw a `RangeError`.
+
 ### Structure detection
 
 | Option | Default | Description |
 | --- | --- | --- |
 | `minStarLeaves` | `3` | Minimum leaf neighbours for a node to become a star centre. |
 | `minCycleLength` | `3` | Minimum number of nodes in a detected cycle. |
-| `maxCycleLength` | `30` | Reserved. Currently **not enforced** by the cycle search. |
 | `minChainLength` | `2` | Minimum number of nodes in a chain. |
 | `minParallelNeighbors` | `2` | Minimum shared neighbours for nodes to count as a parallel group. |
 
@@ -136,10 +137,6 @@ Internally these map to upper-case constants (e.g. `idealLength` → `IDEAL_LENG
 | `substructureLayout` | `false` | When `false` (default), each substructure is arranged internally (circle, rings, grid, ...). When `true`, that step is skipped. |
 | `stepByStep` | `false` | Record a snapshot after each stage (see below). |
 
-### Backward compatibility
-
-The old flat force options (`repulsion`, `springK`, `useAngularForce`, `angularStrength`) and the legacy upper-case `params: { ... }` object are still accepted. Nested `force` / `stress` objects take priority.
-
 ## Step-by-step debugging
 
 Set `stepByStep: true`, keep a reference to the layout, and run it:
@@ -148,7 +145,7 @@ Set `stepByStep: true`, keep a reference to the layout, and run it:
 const layout = cy.layout({ name: 'lumina', stepByStep: true });
 layout.run();
 
-layout.listSteps();   // print and return all captured steps
+const steps = layout.listSteps(); // return all captured steps
 layout.goToStep(3);   // jump to a step
 layout.nextStep();
 layout.prevStep();

package/dist/lumina-layout.d.ts

@@ -1,78 +1,66 @@
 import cytoscape from 'cytoscape';
 export type LayoutAlgorithm = 'force' | 'stress';
-/** Parameters shared by every algorithm */
-export interface CommonParams {
-    LAYOUT_ALGORITHM: LayoutAlgorithm;
+/** Options used only by the force-directed solver. */
+export interface LuminaForceOptions {
+    /** Node-node repulsion strength. */
+    repulsion?: number;
+    /** Spring stiffness of edges. */
+    springK?: number;
+    /** Multiplier applied to repulsion for overlapping virtual nodes. */
+    overlapRepulsionFactor?: number;
+    /** Exponent used by the simulated-annealing cooling function. */
+    coolingExponent?: number;
+    /** Whether to spread leaf virtual nodes evenly around their hub. */
+    useAngularForce?: boolean;
+    angularStrength?: number;
+    angularMaxForce?: number;
+}
+/** Options used only by the stress-majorization solver. */
+export interface LuminaStressOptions {
+    /** Exponent in the stress weight formula: w = 1 / distance ^ exponent. */
+    weightExponent?: number;
+}
+/** Public LUMINA options, excluding Cytoscape's required layout name. */
+export interface LuminaOptions {
+    layoutAlgorithm?: LayoutAlgorithm;
     /** Ideal surface-to-surface gap between connected virtual nodes
      *  (force: spring rest length; stress: base of the target distance;
-     *   both: radius of the initial radial placement of leaf vnodes) */
-    IDEAL_LENGTH: number;
-    /** Max iterations of the main solver loop */
-    ITERATIONS: number;
-    /** Stop early when the max movement of any vnode is below this (px) */
-    CONVERGENCE_THRESHOLD: number;
-    /** Extra gap enforced between vnodes in the anti-collision pass.
-     *  null => use IDEAL_LENGTH */
-    COLLISION_PADDING: number | null;
-    /** Safety cap for the anti-collision loop */
-    MAX_OVERLAP_ITERATIONS: number;
-    MIN_STAR_LEAVES: number;
-    MIN_CYCLE_LENGTH: number;
-    MAX_CYCLE_LENGTH: number;
-    MIN_CHAIN_LENGTH: number;
-    MIN_PARALLEL_NEIGHBORS: number;
-    CYCLE_NODE_SPACING: number;
-    STAR_RING_SPACING: number;
-    STAR_BASE_NODES_PER_RING: number;
-    CHAIN_MIN_RADIUS: number;
-    LEAF_NODE_DISTANCE: number;
-    RANDOMIZE_INITIAL_POSITIONS: boolean;
-    SPREAD_V_NODES: boolean;
-    SUBSTRUCTURE_LAYOUT: boolean;
-    STEP_BY_STEP: boolean;
+     *   both: radius of the initial radial placement of leaf virtual nodes). */
+    idealLength?: number;
+    iterations?: number;
+    convergenceThreshold?: number;
+    /** Extra gap in the anti-collision pass. Null uses `idealLength`. */
+    collisionPadding?: number | null;
+    maxOverlapIterations?: number;
+    minStarLeaves?: number;
+    minCycleLength?: number;
+    minChainLength?: number;
+    minParallelNeighbors?: number;
+    cycleNodeSpacing?: number;
+    starRingSpacing?: number;
+    starBaseNodesPerRing?: number;
+    chainMinRadius?: number;
+    leafNodeDistance?: number;
+    randomizeInitialPositions?: boolean;
+    spreadVNodes?: boolean;
+    substructureLayout?: boolean;
+    stepByStep?: boolean;
+    force?: LuminaForceOptions;
+    stress?: LuminaStressOptions;
 }
-/** Only for the 'force' algorithm */
-export interface ForceParams {
-    /** Node-node repulsion strength */
-    REPULSION: number;
-    /** Spring stiffness of edges */
-    SPRING_K: number;
-    /** Overlapping vnodes repel REPULSION * this factor harder */
-    OVERLAP_REPULSION_FACTOR: number;
-    /** Simulated-annealing cooling: cooling = (1 - iter/ITERATIONS) ^ this */
-    COOLING_EXPONENT: number;
-    /** Angular force that spreads leaf vnodes evenly around a hub */
-    USE_ANGULAR_FORCE: boolean;
-    ANGULAR_STRENGTH: number;
-    ANGULAR_MAX_FORCE: number;
+/** Options passed to `cy.layout()` for the LUMINA layout. */
+export interface LuminaLayoutOptions extends LuminaOptions, cytoscape.BaseLayoutOptions {
+    name: 'lumina' | 'substructure-layout';
 }
-/** Only for the 'stress' algorithm */
-export interface StressParams {
-    /** weight w_ij = 1 / d_ij ^ WEIGHT_EXPONENT (2 = classic stress majorization) */
-    WEIGHT_EXPONENT: number;
+/** Fully resolved options used internally by the layout. */
+export interface LuminaParameters extends Required<Omit<LuminaOptions, 'collisionPadding' | 'force' | 'stress'>> {
+    collisionPadding: number;
+    force: Required<LuminaForceOptions>;
+    stress: Required<LuminaStressOptions>;
 }
-export interface LayoutParameters extends CommonParams {
-    force: ForceParams;
-    stress: StressParams;
-}
-export declare const DEFAULT_PARAMS: LayoutParameters;
-/**
- * Build the final parameters from Cytoscape layout options.
- *
- * cy.layout({
- *   name: 'lumina',
- *   layoutAlgorithm: 'force',
- *   idealLength: 100,              // shared
- *   iterations: 600,               // shared
- *   force:  { repulsion: 300, springK: 0.15, useAngularForce: true },
- *   stress: { weightExponent: 2 }
- * })
- *
- * Backward compatibility: the old flat force options (repulsion, springK,
- * angularStrength, useAngularForce) and the legacy `params` object (flat,
- * upper-case) are still accepted. Nested `force` / `stress` take priority.
- */
-export declare function resolveParams(options: any): LayoutParameters;
+export declare const DEFAULT_PARAMS: LuminaParameters;
+/** Resolve optional public settings into the complete internal configuration. */
+export declare function resolveParams(options?: LuminaOptions): LuminaParameters;
 export interface LayoutStep {
     stepNumber: number;
     stepName: string;
@@ -152,4 +140,8 @@ export { LuminaLayout, LuminaLayout as SubstructureLayout };
 /**
  * Enhanced force-directed layout with structure awareness
  */
-declare function LuminaLayout(this: any, options: any): void;
+declare function LuminaLayout(this: any, options: LuminaLayoutOptions & {
+    cy?: cytoscape.Core;
+    eles?: cytoscape.CollectionReturnValue;
+    boundingBox?: cytoscape.BoundingBox12 | cytoscape.BoundingBoxWH;
+}): void;

package/dist/lumina-layout.js

@@ -1,143 +1,61 @@
+import FastPriorityQueue from 'fastpriorityqueue';
 export const DEFAULT_PARAMS = {
-    LAYOUT_ALGORITHM: 'stress',
+    layoutAlgorithm: 'stress',
     // shared solver
-    IDEAL_LENGTH: 100,
-    ITERATIONS: 600,
-    CONVERGENCE_THRESHOLD: 0.5,
-    COLLISION_PADDING: null,
-    MAX_OVERLAP_ITERATIONS: 300,
-    // structure detection
-    MIN_STAR_LEAVES: 3,
-    MIN_CYCLE_LENGTH: 3,
-    MAX_CYCLE_LENGTH: 30,
-    MIN_CHAIN_LENGTH: 2,
-    MIN_PARALLEL_NEIGHBORS: 2,
+    idealLength: 100,
+    iterations: 600,
+    convergenceThreshold: 0.5,
+    collisionPadding: 100,
+    maxOverlapIterations: 300,
+    // structure deteciton
+    minStarLeaves: 3,
+    minCycleLength: 3,
+    minChainLength: 2,
+    minParallelNeighbors: 2,
     // substructure spacing
-    CYCLE_NODE_SPACING: 100,
-    STAR_RING_SPACING: 100,
-    STAR_BASE_NODES_PER_RING: 6,
-    CHAIN_MIN_RADIUS: 150,
-    LEAF_NODE_DISTANCE: 200,
-    // flags
-    RANDOMIZE_INITIAL_POSITIONS: false,
-    SPREAD_V_NODES: true,
-    SUBSTRUCTURE_LAYOUT: false,
-    STEP_BY_STEP: false,
+    cycleNodeSpacing: 100,
+    starRingSpacing: 100,
+    starBaseNodesPerRing: 6,
+    chainMinRadius: 150,
+    leafNodeDistance: 200,
+    randomizeInitialPositions: false,
+    spreadVNodes: true,
+    substructureLayout: false,
+    stepByStep: false,
     force: {
-        REPULSION: 300,
-        SPRING_K: 0.15,
-        OVERLAP_REPULSION_FACTOR: 5,
-        COOLING_EXPONENT: 2,
-        USE_ANGULAR_FORCE: false,
-        ANGULAR_STRENGTH: 0.2,
-        ANGULAR_MAX_FORCE: 2.0
+        repulsion: 300,
+        springK: 0.15,
+        overlapRepulsionFactor: 5,
+        coolingExponent: 2,
+        useAngularForce: false,
+        angularStrength: 0.2,
+        angularMaxForce: 2.0
     },
     stress: {
-        WEIGHT_EXPONENT: 2
+        weightExponent: 2
     }
 };
-// ----------------------------------------------------------------------------
-// Public (Cytoscape camelCase) option names -> internal names
-// ----------------------------------------------------------------------------
-const COMMON_KEYS = {
-    layoutAlgorithm: 'LAYOUT_ALGORITHM',
-    idealLength: 'IDEAL_LENGTH',
-    iterations: 'ITERATIONS',
-    convergenceThreshold: 'CONVERGENCE_THRESHOLD',
-    collisionPadding: 'COLLISION_PADDING',
-    maxOverlapIterations: 'MAX_OVERLAP_ITERATIONS',
-    minStarLeaves: 'MIN_STAR_LEAVES',
-    minCycleLength: 'MIN_CYCLE_LENGTH',
-    maxCycleLength: 'MAX_CYCLE_LENGTH',
-    minChainLength: 'MIN_CHAIN_LENGTH',
-    minParallelNeighbors: 'MIN_PARALLEL_NEIGHBORS',
-    cycleNodeSpacing: 'CYCLE_NODE_SPACING',
-    starRingSpacing: 'STAR_RING_SPACING',
-    starBaseNodesPerRing: 'STAR_BASE_NODES_PER_RING',
-    chainMinRadius: 'CHAIN_MIN_RADIUS',
-    leafNodeDistance: 'LEAF_NODE_DISTANCE',
-    randomizeInitialPositions: 'RANDOMIZE_INITIAL_POSITIONS',
-    spreadVNodes: 'SPREAD_V_NODES',
-    substructureLayout: 'SUBSTRUCTURE_LAYOUT',
-    stepByStep: 'STEP_BY_STEP'
-};
-const FORCE_KEYS = {
-    repulsion: 'REPULSION',
-    springK: 'SPRING_K',
-    overlapRepulsionFactor: 'OVERLAP_REPULSION_FACTOR',
-    coolingExponent: 'COOLING_EXPONENT',
-    useAngularForce: 'USE_ANGULAR_FORCE',
-    angularStrength: 'ANGULAR_STRENGTH',
-    angularMaxForce: 'ANGULAR_MAX_FORCE'
-};
-const STRESS_KEYS = {
-    weightExponent: 'WEIGHT_EXPONENT'
-};
-function pick(src, map) {
-    const out = {};
-    if (!src)
-        return out;
-    for (const pub of Object.keys(map)) {
-        if (src[pub] !== undefined)
-            out[map[pub]] = src[pub];
+function applyDefaults(defaults, overrides) {
+    const resolved = { ...defaults };
+    for (const key of Object.keys(defaults)) {
+        if (overrides?.[key] !== undefined) {
+            resolved[key] = overrides[key];
+        }
     }
-    return out;
+    return resolved;
 }
-/**
- * Build the final parameters from Cytoscape layout options.
- *
- * cy.layout({
- *   name: 'lumina',
- *   layoutAlgorithm: 'force',
- *   idealLength: 100,              // shared
- *   iterations: 600,               // shared
- *   force:  { repulsion: 300, springK: 0.15, useAngularForce: true },
- *   stress: { weightExponent: 2 }
- * })
- *
- * Backward compatibility: the old flat force options (repulsion, springK,
- * angularStrength, useAngularForce) and the legacy `params` object (flat,
- * upper-case) are still accepted. Nested `force` / `stress` take priority.
- */
-export function resolveParams(options) {
-    options = options || {};
-    const legacy = options.params || {};
-    // flat legacy force options at top level
-    const legacyForce = pick(options, FORCE_KEYS);
-    // legacy upper-case flat `params`: route each key to the right group
-    const legacyCommon = {};
-    const legacyForceUpper = {};
-    const legacyStressUpper = {};
-    Object.keys(legacy).forEach((k) => {
-        if (k in DEFAULT_PARAMS.force)
-            legacyForceUpper[k] = legacy[k];
-        else if (k in DEFAULT_PARAMS.stress)
-            legacyStressUpper[k] = legacy[k];
-        else if (k !== 'force' && k !== 'stress')
-            legacyCommon[k] = legacy[k];
-    });
-    const params = {
-        ...DEFAULT_PARAMS,
-        ...legacyCommon,
-        ...pick(options, COMMON_KEYS),
-        force: {
-            ...DEFAULT_PARAMS.force,
-            ...legacyForceUpper,
-            ...(legacy.force || {}),
-            ...legacyForce,
-            ...pick(options.force, FORCE_KEYS)
-        },
-        stress: {
-            ...DEFAULT_PARAMS.stress,
-            ...legacyStressUpper,
-            ...(legacy.stress || {}),
-            ...pick(options.stress, STRESS_KEYS)
-        }
+/** Resolve optional public settings into the complete internal configuration. */
+export function resolveParams(options = {}) {
+    const { collisionPadding: _defaultCollisionPadding, force: defaultForce, stress: defaultStress, ...commonDefaults } = DEFAULT_PARAMS;
+    const common = applyDefaults(commonDefaults, options);
+    const idealLength = options.idealLength ?? common.idealLength;
+    return {
+        ...common,
+        idealLength,
+        collisionPadding: options.collisionPadding ?? idealLength,
+        force: applyDefaults(defaultForce, options.force),
+        stress: applyDefaults(defaultStress, options.stress)
     };
-    if (params.COLLISION_PADDING == null) {
-        params.COLLISION_PADDING = params.IDEAL_LENGTH;
-    }
-    return params;
 }
 class VNode {
     constructor(id, x, y, radius) {
@@ -193,6 +111,52 @@ class VEdge {
         };
     }
 }
+/** Dense stress distances from repeated weighted Dijkstra. */
+function computeStressDistances(nodes, edges, idealLength) {
+    const numNodes = nodes.length;
+    const nodeIndexMap = new Map();
+    nodes.forEach((node, index) => nodeIndexMap.set(node.id, index));
+    const adjacency = Array.from({ length: numNodes }, () => []);
+    edges.forEach(edge => {
+        if (!edge.source || !edge.target) {
+            return;
+        }
+        const source = nodeIndexMap.get(edge.source.id);
+        const target = nodeIndexMap.get(edge.target.id);
+        if (source === undefined || target === undefined) {
+            return;
+        }
+        const distance = idealLength + edge.source.radius + edge.target.radius;
+        if (distance < 0 || !Number.isFinite(distance)) {
+            throw new RangeError('cytoscape-lumina: stress edge lengths must be finite and non-negative');
+        }
+        adjacency[source].push({ node: target, distance });
+        adjacency[target].push({ node: source, distance });
+    });
+    const distances = Array.from({ length: numNodes }, (_, index) => {
+        const row = new Array(numNodes).fill(Infinity);
+        row[index] = 0;
+        return row;
+    });
+    for (let source = 0; source < numNodes; source++) {
+        const row = distances[source];
+        const heap = new FastPriorityQueue((a, b) => a.distance < b.distance || (a.distance === b.distance && a.node < b.node));
+        heap.add({ node: source, distance: 0 });
+        let current;
+        while ((current = heap.poll()) !== undefined) {
+            if (current.distance !== row[current.node])
+                continue;
+            for (const neighbor of adjacency[current.node]) {
+                const candidate = current.distance + neighbor.distance;
+                if (candidate < row[neighbor.node]) {
+                    row[neighbor.node] = candidate;
+                    heap.add({ node: neighbor.node, distance: candidate });
+                }
+            }
+        }
+    }
+    return distances;
+}
 /**
  * Register this layout as a Cytoscape.js layout extension.
  *
@@ -241,15 +205,12 @@ export { LuminaLayout, LuminaLayout as SubstructureLayout };
 function LuminaLayout(options) {
     this.options = options || {};
     this.cy = this.options.cy;
-    this.eles = this.options.eles || this.cy.elements();
-    this.boundingBox = this.options.boundingBox;
-    this.stopped = false;
     if (!this.cy) {
         throw new Error('cytoscape-lumina: options.cy is required');
     }
-    // Public Cytoscape.js options use camelCase; shared options are flat,
-    // algorithm-specific ones live under `force: {...}` / `stress: {...}`.
-    // See the parameter section at the top of this file. The legacy `params` object is still accepted.
+    this.eles = this.options.eles || this.cy.elements();
+    this.boundingBox = this.options.boundingBox;
+    this.stopped = false;
     this.params = resolveParams(this.options);
     // Instance-specific arrays instead of global
     this.vnodes = [];
@@ -262,7 +223,7 @@ function LuminaLayout(options) {
  * Capture a snapshot of the current layout state
  */
 LuminaLayout.prototype.captureStep = function (stepName, description, metadata) {
-    if (!this.params.STEP_BY_STEP)
+    if (!this.params.stepByStep)
         return;
     const nodes = this.cy.nodes();
     const nodePositions = {};
@@ -289,18 +250,8 @@ LuminaLayout.prototype.captureStep = function (stepName, description, metadata)
     };
     this.steps.push(step);
     this.currentStepIndex = this.steps.length - 1;
-    console.log(`[Step ${step.stepNumber}] ${stepName}: ${description}`);
+    console.debug(`[Step ${step.stepNumber}] ${stepName}: ${description}`);
 };
-/////////////// Check whether two node arrays are identical, ignoring order
-function areNodesEqual(arr1, arr2) {
-    // 1. Different lengths mean they are definitely different
-    if (arr1.length !== arr2.length)
-        return false;
-    // 2. Extract all IDs and put them into a Set
-    const ids1 = new Set(arr1.map((node) => node.id()));
-    // 3. Check whether every ID in arr2 exists in the Set
-    return arr2.every(node => ids1.has(node.id()));
-}
 ////////////////sum length of all edges ////////////////
 function totalEdgeLength(edges) {
     let total = 0;
@@ -379,6 +330,17 @@ function layoutRectangular(nodes, center, dirVector, rowSpacing = 60, colSpacing
 }
 LuminaLayout.prototype.identifyStructures = function (nodes) {
     const params = this.params;
+    // Topology stays fixed during detection; structure markers are filtered dynamically.
+    const neighborhoodCache = new Map();
+    const neighborsOf = (node) => {
+        const id = node.id();
+        let neighbors = neighborhoodCache.get(id);
+        if (neighbors === undefined) {
+            neighbors = node.neighborhood().nodes();
+            neighborhoodCache.set(id, neighbors);
+        }
+        return neighbors;
+    };
     // 0. Reset all markers
     nodes.data('structType', 'Normal');
     // nodes.data('structColor', '#999999');
@@ -390,7 +352,7 @@ LuminaLayout.prototype.identifyStructures = function (nodes) {
     ///////////////////////////// 2. detecting Cycle - by DFS algorithm /////////////////
     const allCycles = []; // each sub-array represents an independent cycle
     if (1) {
-        const normalNodes = nodes.toArray().filter((n) => n.data('structType') === 'Normal' && n.neighborhood().nodes().length >= 2);
+        const normalNodes = nodes.toArray().filter((n) => n.data('structType') === 'Normal' && neighborsOf(n).length >= 2);
         const seenCycles = new Set();
         // To avoid duplicate cycles (like A-B-C and B-C-A), we sort and stringify for a check
         normalNodes.forEach((startNode, startIndex) => {
@@ -398,12 +360,12 @@ LuminaLayout.prototype.identifyStructures = function (nodes) {
             // This is a massive optimization to prevent finding the same cycle N times
             const startId = startNode.id();
             const findCycles = (u, parent, path) => {
-                const neighbors = u.neighborhood().nodes().toArray().filter((n) => n.data('structType') === 'Normal');
+                const neighbors = neighborsOf(u).toArray().filter((n) => n.data('structType') === 'Normal');
                 if (neighbors.length < 8) { // If a node has too many neighbors, it is unlikely to be part of a cycle; this mainly improves efficiency and prevents the search from getting stuck here
                     for (const v of neighbors) {
                         const vId = v.id();
                         // 1. Found a cycle back to our specific START node
-                        if (vId === startId && path.length >= params.MIN_CYCLE_LENGTH) {
+                        if (vId === startId && path.length >= params.minCycleLength) {
                             const cycle = [...path];
                             const sortedKey = [...cycle].sort().join(',');
                             if (!seenCycles.has(sortedKey)) {
@@ -479,11 +441,10 @@ LuminaLayout.prototype.identifyStructures = function (nodes) {
         });
         circleIndex++;
     });
-    console.log("num of cycles: ", filteredCycles.length);
     const chains = [];
     const processedNodeIds = new Set(); // avoid processing nodes more than once
     // 2. Find all leaf nodes (Normal type with degree 1)
-    const leafNodes = nodes.filter((n) => n.data('structType') === 'Normal' && n.neighborhood().nodes().length === 1);
+    const leafNodes = nodes.filter((n) => n.data('structType') === 'Normal' && neighborsOf(n).length === 1);
     let chainId = 0;
     leafNodes.forEach((leaf) => {
         if (processedNodeIds.has(leaf.id()))
@@ -496,8 +457,7 @@ LuminaLayout.prototype.identifyStructures = function (nodes) {
             currentChainNodes.push(currentNode);
             processedNodeIds.add(currentNode.id());
             // Find the next neighbor
-            const neighbors = currentNode
-                .neighborhood('node')
+            const neighbors = neighborsOf(currentNode)
                 .filter((n) => n.id() !== currentNode.id() &&
                 n.data('structType') === 'Normal' &&
                 !processedNodeIds.has(n.id()));
@@ -506,8 +466,7 @@ LuminaLayout.prototype.identifyStructures = function (nodes) {
             // 2. The neighbor must not have a high degree (if degree > 2, a branching point has been reached and the chain ends)
             if (neighbors.length === 1) {
                 const nextNode = neighbors[0];
-                const nextNodeNeighborCount = nextNode
-                    .neighborhood('node')
+                const nextNodeNeighborCount = neighborsOf(nextNode)
                     .filter((n) => n.id() !== nextNode.id())
                     .length;
                 if (nextNodeNeighborCount > 2) {
@@ -521,7 +480,7 @@ LuminaLayout.prototype.identifyStructures = function (nodes) {
             }
         }
         // 4. Save the chain that was found
-        if (currentChainNodes.length >= params.MIN_CHAIN_LENGTH) {
+        if (currentChainNodes.length >= params.minChainLength) {
             nodeId = 0;
             currentChainNodes.forEach((node) => {
                 node.addClass('substructure-chain');
@@ -561,12 +520,12 @@ LuminaLayout.prototype.identifyStructures = function (nodes) {
     ///////////////////////////////// Star structure ///////////
     let starIndex = 0;
     nodes.forEach((node) => {
-        const neighbors = node.neighborhood().nodes();
+        const neighbors = neighborsOf(node);
         // Number of distinct neighbors
         const neighborCount = neighbors.length;
         // Check whether the neighbors consist only of distinct neighbor nodes
-        const leafNeighbors = neighbors.filter((n) => n.neighborhood().nodes().length === 1);
-        if (leafNeighbors.length >= params.MIN_STAR_LEAVES && neighborCount >= params.MIN_STAR_LEAVES) {
+        const leafNeighbors = neighbors.filter((n) => neighborsOf(n).length === 1);
+        if (leafNeighbors.length >= params.minStarLeaves && neighborCount >= params.minStarLeaves) {
             if (node.data('structType') !== 'Cycle' && node.data('structType') !== 'Chain') {
                 const groupId = 'Star_' + starIndex;
                 node.addClass(['substructure-star', 'substructure-star-center']);
@@ -594,56 +553,57 @@ LuminaLayout.prototype.identifyStructures = function (nodes) {
         }
     });
     /////////////////////////////// Find parallel/diamond structures ///////////////////////////////////
-    // let diamonds = [];
-    let parallelId = 0;
-    // Whether any two nodes have common neighbors
-    for (let i = 0; i < nodes.length; i++) {
-        let nodeVecParallel = [];
-        const u = nodes[i];
-        const u1 = u.neighborhood().nodes();
-        if (u.data('structType') === 'Normal') {
-            for (let j = 0; j < nodes.length; j++) {
-                if (i === j)
-                    continue;
-                const v = nodes[j];
-                if (v.data('structType') === 'Normal') {
-                    const v1 = v.neighborhood().nodes();
-                    if (areNodesEqual(v1, u1) && v1.length >= params.MIN_PARALLEL_NEIGHBORS && u1.length >= params.MIN_PARALLEL_NEIGHBORS) {
-                        if (nodeVecParallel.length === 0) {
-                            nodeVecParallel.push(u.id());
-                        }
-                        nodeVecParallel.push(v.id());
-                    }
-                }
-            }
+    const nodesById = new Map();
+    const parallelGroups = new Map();
+    nodes.forEach((node) => {
+        nodesById.set(node.id(), node);
+        if (node.data("structType") !== "Normal") {
+            return;
         }
-        if (nodeVecParallel.length >= 2) {
-            nodeVecParallel.forEach(v => {
-                nodes.forEach((node) => {
-                    if (node.id() == v) {
-                        node.addClass('substructure-parallel');
-                        node.data('structType', 'Parallel');
-                        // node.data('structColor', '#50C878');
-                        node.data('groupId', 'Parallel' + parallelId);
-                        node.data('structs', {
-                            ...node.data('structs'), Parallel: {
-                                color: '#50C878', groupId: `Parallel_${parallelId}`
-                            }
-                        });
-                    }
-                });
-            });
-            u1.forEach((v1) => {
-                nodes.forEach((node) => {
-                    if (node.id() == v1.id()) {
-                        node.data('parallelGroupIdVec', [...node.data('parallelGroupIdVec'), 'Parallel' + parallelId]);
-                    }
-                });
-            });
-            parallelId++;
+        const neighbors = neighborsOf(node);
+        if (!(neighbors.length >= params.minParallelNeighbors)) {
+            return;
         }
+        // Encode a sorted copy so IDs cannot collide and cached neighbor order stays intact.
+        const signature = JSON.stringify(neighbors.map((neighbor) => neighbor.id()).sort());
+        const group = parallelGroups.get(signature);
+        if (group) {
+            group.push(node);
+        }
+        else {
+            parallelGroups.set(signature, [node]);
+        }
+    });
+    // Map insertion order preserves group numbering by the first eligible member.
+    let parallelId = 0;
+    for (const group of parallelGroups.values()) {
+        if (group.length < 2)
+            continue;
+        const groupId = "Parallel" + parallelId;
+        group.forEach((node) => {
+            node.addClass("substructure-parallel");
+            node.data("structType", "Parallel");
+            node.data("groupId", groupId);
+            node.data("structs", {
+                ...node.data("structs"),
+                Parallel: {
+                    color: "#50C878",
+                    groupId: `Parallel_${parallelId}`,
+                },
+            });
+        });
+        neighborsOf(group[0]).forEach((neighbor) => {
+            // Neighborhoods may include nodes outside the supplied collection.
+            const node = nodesById.get(neighbor.id());
+            if (node) {
+                node.data("parallelGroupIdVec", [
+                    ...node.data("parallelGroupIdVec"),
+                    groupId,
+                ]);
+            }
+        });
+        parallelId++;
     }
-    console.log("num of chains: ", chains.length);
 };
 LuminaLayout.prototype.run = function () {
     this.stopped = false;
@@ -669,7 +629,6 @@ LuminaLayout.prototype.run = function () {
     components.forEach((component, index) => {
         this.vnodes = [];
         this.vedges = [];
-        console.log(`independent net: ${index + 1}`);
         // 1. get user defined boundingBox，if not then default cy container
         const bb = this.boundingBox || this.cy.extent();
         const width = bb.x2 - bb.x1;
@@ -691,15 +650,13 @@ LuminaLayout.prototype.run = function () {
             return true;
         });
         // 2. NOW define your collections to get the updated state
-        if (params.RANDOMIZE_INITIAL_POSITIONS) {
+        if (params.randomizeInitialPositions) {
             nodes.forEach((node) => {
                 node.position({
                     x: bb.x1 + Math.random() * width, y: bb.y1 + Math.random() * height
                 });
             });
         }
-        console.log("num of nodes: " + nodes.length);
-        console.log("num of edges: " + edgeSet.length);
         // Capture initial state
         this.captureStep('Initial', 'Initial node positions before any layout', {
             nodeCount: nodes.length, edgeCount: edgeSet.length
@@ -905,8 +862,8 @@ LuminaLayout.prototype.run = function () {
             this.vnodes.forEach((v1) => {
                 if (v1.type == 'Star') {
                     const allMemberNode = v1.nodes.filter((node) => node.data('structType') !== 'Star-Center');
-                    const ringSpacing = params.STAR_RING_SPACING;
-                    const baseNodesInFirstRing = params.STAR_BASE_NODES_PER_RING;
+                    const ringSpacing = params.starRingSpacing;
+                    const baseNodesInFirstRing = params.starBaseNodesPerRing;
                     // 1. Pre-calculate how many nodes go into each ring
                     const rings = [];
                     let tempNodes = [...allMemberNode];
@@ -921,7 +878,7 @@ LuminaLayout.prototype.run = function () {
                 }
                 else if (v1.type == 'Cycle') {
                     const count = v1.nodes.length;
-                    const k = params.CYCLE_NODE_SPACING;
+                    const k = params.cycleNodeSpacing;
                     v1.radius = (count * k) / (2 * Math.PI);
                 }
                 else if (v1.type == 'Parallel') {
@@ -949,8 +906,8 @@ LuminaLayout.prototype.run = function () {
                 }
                 else if (v1.type == 'Chain') {
                     const count = v1.nodes.length;
-                    const miniMumRadius = params.CHAIN_MIN_RADIUS;
-                    v1.radius = Math.max((count * params.CYCLE_NODE_SPACING) / (2 * Math.PI), miniMumRadius);
+                    const miniMumRadius = params.chainMinRadius;
+                    v1.radius = Math.max((count * params.cycleNodeSpacing) / (2 * Math.PI), miniMumRadius);
                 }
                 else {
                     v1.radius = 10;
@@ -959,21 +916,20 @@ LuminaLayout.prototype.run = function () {
         }
         this.captureStep('Virtual Nodes Positioned', 'Virtual node centers and radii calculated', null);
         //******************** virtual node force layout ************************
-        // Uses: shared params (IDEAL_LENGTH, ITERATIONS, CONVERGENCE_THRESHOLD,
-        // COLLISION_PADDING) + force-only params (params.force.*)
-        if (params.LAYOUT_ALGORITHM === 'force') {
+        // Shared settings are on params; solver-specific settings are nested.
+        if (params.layoutAlgorithm === 'force') {
             const fp = params.force;
-            const IDEAL_LENGTH = params.IDEAL_LENGTH;
-            const REPULSION = fp.REPULSION;
-            const SPRING_K = fp.SPRING_K;
-            const ITERATIONS = params.ITERATIONS;
+            const idealLength = params.idealLength;
+            const repulsion = fp.repulsion;
+            const springK = fp.springK;
+            const iterations = params.iterations;
             var colisionFlag = true;
             let iter = 0;
             var maxAttractMove = 10e10;
             var maxRepulsetMove = 10e10;
             var numOfCollision = 0;
             // Only consider the whole graph truly stationary when the maximum movement of every node is below this threshold
-            const ENERGY_THRESHOLD = params.CONVERGENCE_THRESHOLD;
+            const convergenceThreshold = params.convergenceThreshold;
             // Build the adjacency list in advance so it can be reused seamlessly for both "initial ordering" and the "later angular force"
             const adj = new Map();
             this.vedges.forEach((e) => {
@@ -1000,13 +956,13 @@ LuminaLayout.prototype.run = function () {
                         // Also give them an initial star-shaped radial geometric distribution that is guaranteed not to cross
                         leafNeighbors.forEach((nb, index) => {
                             const initAngle = (Math.PI * 2 / leafNeighbors.length) * index;
-                            nb.center_x = node.center_x + Math.cos(initAngle) * IDEAL_LENGTH;
-                            nb.center_y = node.center_y + Math.sin(initAngle) * IDEAL_LENGTH;
+                            nb.center_x = node.center_x + Math.cos(initAngle) * idealLength;
+                            nb.center_y = node.center_y + Math.sin(initAngle) * idealLength;
                         });
                     }
                 }
             });
-            while (iter < ITERATIONS) {
+            while (iter < iterations) {
                 if (this.stopped) {
                     break;
                 }
@@ -1039,7 +995,7 @@ LuminaLayout.prototype.run = function () {
                     }
                 }
                 // Calculate the current global cooling factor (the core simulated-annealing control)
-                const cooling = Math.pow(1 - iter / ITERATIONS, fp.COOLING_EXPONENT);
+                const cooling = Math.pow(1 - iter / iterations, fp.coolingExponent);
                 /* ---------- A. Attraction (Spring) ---------- */
                 if (1) {
                     this.vedges.forEach((e) => {
@@ -1051,9 +1007,9 @@ LuminaLayout.prototype.run = function () {
                         const dy = t.center_y - s.center_y;
                         const centerDist = Math.max(Math.sqrt(dx * dx + dy * dy), 1);
                         const surfaceDist = centerDist - (s.radius + t.radius);
-                        const delta = Math.max(0, surfaceDist - IDEAL_LENGTH);
+                        const delta = Math.max(0, surfaceDist - idealLength);
                         // Apply the cooling factor to the attractive force
-                        let force = SPRING_K * delta * cooling;
+                        let force = springK * delta * cooling;
                         const fx = (force * dx) / centerDist;
                         const fy = (force * dy) / centerDist;
                         s.center_x += fx;
@@ -1065,7 +1021,7 @@ LuminaLayout.prototype.run = function () {
                 }
                 /* ---------- B. Repulsion ---------- */
                 if (1) {
-                    const MIN_GAP = 0.1;
+                    const minGap = 0.1;
                     for (let i = 0; i < this.vnodes.length; i++) {
                         for (let j = i + 1; j < this.vnodes.length; j++) {
                             const n1 = this.vnodes[i];
@@ -1081,15 +1037,15 @@ LuminaLayout.prototype.run = function () {
                             let force = 0;
                             if (centerDist < minDistance) {
                                 const overlap = minDistance - centerDist;
-                                force = (REPULSION * fp.OVERLAP_REPULSION_FACTOR) * (overlap / (centerDist + MIN_GAP));
+                                force = (repulsion * fp.overlapRepulsionFactor) * (overlap / (centerDist + minGap));
                             }
                             else {
                                 const gap = centerDist - minDistance;
-                                force = REPULSION / (gap * gap + 20);
+                                force = repulsion / (gap * gap + 20);
                             }
                             // Apply the cooling factor to the repulsive force
                             force *= cooling;
-                            const maxForceLimit = REPULSION * 2 * cooling;
+                            const maxForceLimit = repulsion * 2 * cooling;
                             if (force > maxForceLimit)
                                 force = maxForceLimit;
                             const fx = (force * dx) / centerDist;
@@ -1103,10 +1059,10 @@ LuminaLayout.prototype.run = function () {
                     }
                 }
                 /* ---------- C. Angular Repulsion ---------- */
-                if (fp.USE_ANGULAR_FORCE) {
+                if (fp.useAngularForce) {
                     const norm = (a) => Math.atan2(Math.sin(a), Math.cos(a));
-                    const ANGULAR_STRENGTH = fp.ANGULAR_STRENGTH;
-                    const MAX_FORCE = fp.ANGULAR_MAX_FORCE;
+                    const angularStrength = fp.angularStrength;
+                    const maxForce = fp.angularMaxForce;
                     this.vnodes.forEach((node) => {
                         if (!node._permanentOrder || node._permanentOrder.length < 2) {
                             return;
@@ -1139,8 +1095,8 @@ LuminaLayout.prototype.run = function () {
                                 continue;
                             }
                             const gapError = idealGap - gap;
-                            let force = gapError * ANGULAR_STRENGTH;
-                            force = Math.min(force, MAX_FORCE);
+                            let force = gapError * angularStrength;
+                            force = Math.min(force, maxForce);
                             // Tangential direction of the left item
                             const ltx = -left.dy / left.dist;
                             const lty = left.dx / left.dist;
@@ -1160,7 +1116,7 @@ LuminaLayout.prototype.run = function () {
                 }
                 // [Exit criterion] Only allow an early safe exit when all movement energy in the graph has completely settled and become extremely small
                 const totalMaxMovement = Math.max(maxAttractMove, maxRepulsetMove, maxAngularMove);
-                if (totalMaxMovement < ENERGY_THRESHOLD && iter > 10) {
+                if (totalMaxMovement < convergenceThreshold && iter > 10) {
                     break;
                 }
             }
@@ -1174,8 +1130,9 @@ LuminaLayout.prototype.run = function () {
             if (1) {
                 colisionFlag = true;
                 numOfCollision = 0;
-                const padding = params.COLLISION_PADDING;
+                const padding = params.collisionPadding;
                 let iter = 0;
+                let overlapLimitReached = false;
                 while (colisionFlag) {
                     if (this.stopped) {
                         break;
@@ -1218,12 +1175,17 @@ LuminaLayout.prototype.run = function () {
                     }
                     // [Optimization 3] Safety valve: exit directly if the iteration count becomes too large (typically when nodes are extremely dense)
                     if (numOfCollision > 10000) {
-                        console.warn("avoid dead loop");
+                        overlapLimitReached = true;
                         break;
                     }
-                    // this.captureStep('Anti-collision', 'Eliminate all collisions ' + iter, { iterations: ITERATIONS });
                 }
-                this.captureStep('Anti-collision', 'Eliminate all collisions', { iterations: ITERATIONS });
+                this.captureStep("Anti-collision", overlapLimitReached
+                    ? "Overlap removal stopped at safety limit"
+                    : "Eliminate all collisions", {
+                    iterations,
+                    overlapIterations: iter,
+                    overlapLimitReached,
+                });
                 if (1) {
                     numOfCollision = 0;
                     for (let i = 0; i < this.vnodes.length; i++) {
@@ -1233,32 +1195,30 @@ LuminaLayout.prototype.run = function () {
                             let dx = n1.center_x - n2.center_x;
                             let dy = n1.center_y - n2.center_y;
                             const centerDist = Math.sqrt(dx * dx + dy * dy);
-                            if (centerDist < (IDEAL_LENGTH + n1.radius + n2.radius)) {
+                            if (centerDist < (idealLength + n1.radius + n2.radius)) {
                                 numOfCollision++;
                             }
                         }
                     }
                 }
             }
-            this.captureStep('Virtual Node Layout', 'Force-directed layout applied to virtual nodes', { iterations: ITERATIONS });
+            this.captureStep('Virtual Node Layout', 'Force-directed layout applied to virtual nodes', { iterations });
         }
         //******************** stress force layout ************************
         // Stress Majorization algorithm
         // All-Pairs shortest-path calculation and Guttman Transform (weighted Laplacian updates),
         // while retaining the polar-coordinate initialization for leaf nodes and the Anti-Collision post-processing in the original code
-        // Uses: shared params (IDEAL_LENGTH, ITERATIONS, CONVERGENCE_THRESHOLD,
-        // COLLISION_PADDING, MAX_OVERLAP_ITERATIONS) + stress-only params (params.stress.*)
-        if (params.LAYOUT_ALGORITHM === 'stress') {
+        // Shared settings are on params; solver-specific settings are nested.
+        if (params.layoutAlgorithm === 'stress') {
             const sp = params.stress;
-            const IDEAL_LENGTH = params.IDEAL_LENGTH;
-            const ITERATIONS = params.ITERATIONS;
-            const ENERGY_THRESHOLD = params.CONVERGENCE_THRESHOLD;
+            const idealLength = params.idealLength;
+            const iterations = params.iterations;
+            const convergenceThreshold = params.convergenceThreshold;
             const numNodes = this.vnodes.length;
             if (numNodes === 0)
                 return;
             // Index mapping: ID -> array index, for matrix operations
-            const nodeIndexMap = new Map();
-            this.vnodes.forEach((v, i) => nodeIndexMap.set(v.id, i));
+            // The distance helper builds the index alongside its weighted adjacency.
             // Extract the adjacency list for reuse during initialization
             const adj = new Map();
             this.vedges.forEach((e) => {
@@ -1272,42 +1232,18 @@ LuminaLayout.prototype.run = function () {
                 adj.get(e.target.id).push(e.source);
             });
             // -------------------------------------------------------------
-            // [Preprocessing 1] Calculate the shortest-path distance matrix between every pair of nodes in the graph (APSP - Floyd Warshall)
+            // [Preprocessing 1] Calculate all-pairs shortest paths using weighted Dijkstra
             // -------------------------------------------------------------
-            const distMatrix = Array.from({ length: numNodes }, () => new Array(numNodes).fill(Infinity));
+            const distMatrix = computeStressDistances(this.vnodes, this.vedges, idealLength);
             const weightMatrix = Array.from({ length: numNodes }, () => new Array(numNodes).fill(0));
-            for (let i = 0; i < numNodes; i++)
-                distMatrix[i][i] = 0;
-            // Assign the ideal distance baseline based on real edges
-            this.vedges.forEach((e) => {
-                if (!e.source || !e.target)
-                    return;
-                const u = nodeIndexMap.get(e.source.id);
-                const v = nodeIndexMap.get(e.target.id);
-                if (u !== undefined && v !== undefined) {
-                    const idealDist = IDEAL_LENGTH + e.source.radius + e.target.radius;
-                    distMatrix[u][v] = Math.min(distMatrix[u][v], idealDist);
-                    distMatrix[v][u] = Math.min(distMatrix[v][u], idealDist);
-                }
-            });
-            // Use Floyd-Warshall to compute shortest paths between all node pairs
-            for (let k = 0; k < numNodes; k++) {
-                for (let i = 0; i < numNodes; i++) {
-                    for (let j = 0; j < numNodes; j++) {
-                        if (distMatrix[i][k] + distMatrix[k][j] < distMatrix[i][j]) {
-                            distMatrix[i][j] = distMatrix[i][k] + distMatrix[k][j];
-                        }
-                    }
-                }
-            }
-            // Calculate the weight matrix W_ij = 1 / (d_ij ^ WEIGHT_EXPONENT)
+            // Calculate the weight matrix W_ij = 1 / (d_ij ^ weightExponent)
             for (let i = 0; i < numNodes; i++) {
                 for (let j = 0; j < numNodes; j++) {
                     if (i !== j && distMatrix[i][j] !== Infinity) {
                         // Account for the actual node radius to prevent excessive crowding
                         const minR = this.vnodes[i].radius + this.vnodes[j].radius;
                         const d = Math.max(distMatrix[i][j], minR);
-                        weightMatrix[i][j] = 1 / Math.pow(d, sp.WEIGHT_EXPONENT);
+                        weightMatrix[i][j] = 1 / Math.pow(d, sp.weightExponent);
                     }
                 }
             }
@@ -1326,8 +1262,8 @@ LuminaLayout.prototype.run = function () {
                         node._permanentOrder = leafNeighbors.map((a) => a.id);
                         leafNeighbors.forEach((nb, index) => {
                             const initAngle = (Math.PI * 2 / leafNeighbors.length) * index;
-                            nb.center_x = node.center_x + Math.cos(initAngle) * IDEAL_LENGTH;
-                            nb.center_y = node.center_y + Math.sin(initAngle) * IDEAL_LENGTH;
+                            nb.center_x = node.center_x + Math.cos(initAngle) * idealLength;
+                            nb.center_y = node.center_y + Math.sin(initAngle) * idealLength;
                         });
                     }
                 }
@@ -1336,7 +1272,7 @@ LuminaLayout.prototype.run = function () {
             // [Main loop] Stress Majorization iteration (Guttman Transform)
             // -------------------------------------------------------------
             let iter = 0;
-            while (iter < ITERATIONS) {
+            while (iter < iterations) {
                 if (this.stopped) {
                     break;
                 }
@@ -1390,7 +1326,7 @@ LuminaLayout.prototype.run = function () {
                     vi.center_y = nextY[i];
                 }
                 // Check the convergence condition and exit early
-                if (maxStressMove < ENERGY_THRESHOLD && iter > 10) {
+                if (maxStressMove < convergenceThreshold && iter > 10) {
                     break;
                 }
             }
@@ -1407,8 +1343,9 @@ LuminaLayout.prototype.run = function () {
             if (1) {
                 let colisionFlag = true;
                 let numOfCollision = 0;
-                const padding = params.COLLISION_PADDING;
+                const padding = params.collisionPadding;
                 let overlapIter = 0;
+                let overlapLimitReached = false;
                 while (colisionFlag) {
                     if (this.stopped) {
                         break;
@@ -1441,18 +1378,24 @@ LuminaLayout.prototype.run = function () {
                             }
                         }
                     }
-                    if (numOfCollision > 10000 || overlapIter > params.MAX_OVERLAP_ITERATIONS) {
-                        console.warn("Avoid dead loop in overlap removal");
+                    if (numOfCollision > 10000 || overlapIter > params.maxOverlapIterations) {
+                        overlapLimitReached = true;
                         break;
                     }
                 }
-                this.captureStep('Anti-collision', 'Eliminate all collisions', { iterations: ITERATIONS });
+                this.captureStep("Anti-collision", overlapLimitReached
+                    ? "Overlap removal stopped at safety limit"
+                    : "Eliminate all collisions", {
+                    iterations,
+                    overlapIterations: overlapIter,
+                    overlapLimitReached,
+                });
             }
-            this.captureStep('Virtual Node Layout', 'Stress Majorization layout applied to virtual nodes', { iterations: ITERATIONS });
+            this.captureStep('Virtual Node Layout', 'Stress Majorization layout applied to virtual nodes', { iterations });
         }
         /////////////////////////////////////////////////////////////////////////////
         if (1) {
-            if (params.SPREAD_V_NODES) {
+            if (params.spreadVNodes) {
                 this.vnodes.forEach((v) => {
                     v.nodes.forEach((n) => {
                         n.position().x = v.center_x + Math.random() * 5;
@@ -1463,15 +1406,15 @@ LuminaLayout.prototype.run = function () {
             }
         }
         /////////////////////  Delete the old layout so that only virtual-node VNode layout remains  ////////////////
-        if (!params.SUBSTRUCTURE_LAYOUT) {
-            const IDEAL_LENGTH = params.LEAF_NODE_DISTANCE;
+        if (!params.substructureLayout) {
+            const idealLength = params.leafNodeDistance;
             this.vnodes.forEach((v) => {
                 if (v.type == 'Star') {
                     // if(targetNode){    // star is an independent star, not attached to a Cycle
                     if (1) {
                         const allMemberNode = v.nodes.filter((node) => node.data('structType') !== 'Star-Center');
-                        const ringSpacing = params.STAR_RING_SPACING;
-                        const baseNodesInFirstRing = params.STAR_BASE_NODES_PER_RING;
+                        const ringSpacing = params.starRingSpacing;
+                        const baseNodesInFirstRing = params.starBaseNodesPerRing;
                         // 1. Pre-calculate how many nodes go into each ring
                         const rings = [];
                         let tempNodes = [...allMemberNode];
@@ -1540,10 +1483,10 @@ LuminaLayout.prototype.run = function () {
                                 cx /= count;
                                 cy /= count;
                                 // 2. Special handling: exactly 3 nodes form a strict equilateral triangle
-                                //    (do not use CHAIN_MIN_RADIUS, so the triangle is not artificially enlarged)
+                                //    (do not use chainMinRadius, so the triangle is not artificially enlarged)
                                 if (count === 3) {
                                     // CYCLE_NODE_SPACING represents the desired node spacing (triangle side length)
-                                    const sideLength = params.CYCLE_NODE_SPACING;
+                                    const sideLength = params.cycleNodeSpacing;
                                     // Circumradius of the equilateral triangle: radius = side / sqrt(3)
                                     const radius = sideLength / Math.sqrt(3);
                                     // 3. Search for the best rotation angle (0°, 10°, ... 350°),
@@ -1580,8 +1523,8 @@ LuminaLayout.prototype.run = function () {
                                 // 3. count > 3
                                 //    gNodes[0] -> center node, gNodes[1...] -> circumference nodes
                                 // 4. Calculate the standard radius based on the number of nodes
-                                const miniMumRadius = params.CHAIN_MIN_RADIUS;
-                                const radius = Math.max((count * params.CYCLE_NODE_SPACING) / (2 * Math.PI), miniMumRadius);
+                                const miniMumRadius = params.chainMinRadius;
+                                const radius = Math.max((count * params.cycleNodeSpacing) / (2 * Math.PI), miniMumRadius);
                                 // 5. Circumference nodes
                                 const sorted = gNodes.slice(1);
                                 // 6. Search for the best rotation angle
@@ -1648,7 +1591,7 @@ LuminaLayout.prototype.run = function () {
                     }
                     // 2. Calculate the standard radius based on the number of nodes (to keep node spacing close to k)
                     const count = v.nodes.length;
-                    const k = params.CYCLE_NODE_SPACING;
+                    const k = params.cycleNodeSpacing;
                     const radius = (count * k) / (2 * Math.PI);
                     // 3. Sort to prevent nodes from flickering around the circumference
                     const sorted = v.nodes;
@@ -1713,14 +1656,14 @@ LuminaLayout.prototype.run = function () {
                     let bestRotate = 0; //Find the best rotation angle
                     let aroundNodesVec = [];
                     nodes.forEach((nd, i) => {
-                        if (((nd.position().x - fatherPos.x) * (nd.position().x - fatherPos.x) + (nd.position().y - fatherPos.y) * (nd.position().y - fatherPos.y)) < 2 * IDEAL_LENGTH * IDEAL_LENGTH) {
+                        if (((nd.position().x - fatherPos.x) * (nd.position().x - fatherPos.x) + (nd.position().y - fatherPos.y) * (nd.position().y - fatherPos.y)) < 2 * idealLength * idealLength) {
                             aroundNodesVec.push(nd);
                         }
                     });
                     for (let rotate = 0; rotate <= 360; rotate = rotate + 10) {
                         n.position({
-                            x: fatherPos.x + Math.cos(rotate * 3.14 / 180) * IDEAL_LENGTH,
-                            y: fatherPos.y + Math.sin(rotate * 3.14 / 180) * IDEAL_LENGTH
+                            x: fatherPos.x + Math.cos(rotate * 3.14 / 180) * idealLength,
+                            y: fatherPos.y + Math.sin(rotate * 3.14 / 180) * idealLength
                         });
                         let totalLength = 0;
                         aroundNodesVec.forEach((nd, i) => {
@@ -1736,8 +1679,8 @@ LuminaLayout.prototype.run = function () {
                     }
                     //
                     n.position({
-                        x: fatherPos.x + Math.cos(bestRotate * 3.14 / 180) * IDEAL_LENGTH,
-                        y: fatherPos.y + Math.sin(bestRotate * 3.14 / 180) * IDEAL_LENGTH
+                        x: fatherPos.x + Math.cos(bestRotate * 3.14 / 180) * idealLength,
+                        y: fatherPos.y + Math.sin(bestRotate * 3.14 / 180) * idealLength
                     });
                 }
             });
@@ -1758,34 +1701,6 @@ LuminaLayout.prototype.run = function () {
             nodes[2].position().y = 90;
         }
         rotateNetworkToMinimumBoundingBox(nodes);
-        if (1) {
-            let maxDis = 0;
-            let maxS = 0;
-            let maxT = 0;
-            let minDist = 10e10;
-            let minS = 0;
-            let minT = 0;
-            let avgDis = 0;
-            edgeSet.forEach((e) => {
-                const s = e.source();
-                const t = e.target();
-                const distance = Math.sqrt(Math.pow(s.position().x - t.position().x, 2) + Math.pow(s.position().y - t.position().y, 2));
-                if (maxDis < distance) {
-                    maxDis = distance;
-                    maxS = s.id();
-                    maxT = t.id();
-                }
-                if (minDist > distance) {
-                    minDist = distance;
-                    minS = s.id();
-                    minT = t.id();
-                }
-                avgDis += distance;
-            });
-            console.log("maxDis:", maxDis, " ", maxS, "->", maxT);
-            console.log("minDist:", minDist, " ", minS, "->", minT);
-            console.log("avgDis:", avgDis / edgeSet.length);
-        }
         const bb2 = nodes.boundingBox();
         networkInfos.push({
             component: component,
@@ -2357,7 +2272,7 @@ LuminaLayout.prototype.packNetworks = function (networks) {
  * Navigate to a specific step in step-by-step mode
  */
 LuminaLayout.prototype.goToStep = function (stepIndex) {
-    if (!this.params.STEP_BY_STEP || this.steps.length === 0) {
+    if (!this.params.stepByStep || this.steps.length === 0) {
         console.warn('Step-by-step mode is not enabled or no steps have been captured');
         return this;
     }
@@ -2377,7 +2292,7 @@ LuminaLayout.prototype.goToStep = function (stepIndex) {
     });
     // Visualize virtual nodes if they exist at this step
     this.visualizeVirtualNodes(step);
-    console.log(`[Step ${step.stepNumber}/${this.steps.length - 1}] ${step.stepName}: ${step.description}`);
+    console.debug(`[Step ${step.stepNumber}/${this.steps.length - 1}] ${step.stepName}: ${step.description}`);
     this.cy.fit(null, 50);
     return this;
 };
@@ -2389,7 +2304,7 @@ LuminaLayout.prototype.nextStep = function () {
         return this.goToStep(this.currentStepIndex + 1);
     }
     else {
-        console.log('Already at the last step');
+        console.debug("Already at the last step");
         return this;
     }
 };
@@ -2401,7 +2316,7 @@ LuminaLayout.prototype.prevStep = function () {
         return this.goToStep(this.currentStepIndex - 1);
     }
     else {
-        console.log('Already at the first step');
+        console.debug("Already at the first step");
         return this;
     }
 };
@@ -2409,15 +2324,10 @@ LuminaLayout.prototype.prevStep = function () {
  * Get information about all steps
  */
 LuminaLayout.prototype.listSteps = function () {
-    if (!this.params.STEP_BY_STEP || this.steps.length === 0) {
-        console.log('No steps available');
+    if (!this.params.stepByStep || this.steps.length === 0) {
+        console.debug("No steps available");
         return [];
     }
-    console.log(`Total steps: ${this.steps.length}`);
-    this.steps.forEach((step, index) => {
-        const current = index === this.currentStepIndex ? ' ← CURRENT' : '';
-        console.log(`  [${index}] ${step.stepName}: ${step.description}${current}`);
-    });
     return this.steps.map((s) => ({
         stepNumber: s.stepNumber,
         stepName: s.stepName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intact-ebi/cytoscape-lumina",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "LUMINA: a structure-aware Cytoscape.js layout that detects cycles, chains, stars and parallel groups and lays them out with force-directed or stress-majorization solvers.",
   "type": "module",
   "main": "dist/index.js",
@@ -26,8 +26,9 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "tsc && cp demo/favicon.ico dist/favicon.ico && cp demo/index.html dist/index.html && cp node_modules/cytoscape/dist/cytoscape.min.js dist/ && if [ -d demo/data ]; then cp -r demo/data dist/data; fi && touch dist/.nojekyll",
-    "dev": "npm run build && concurrently \"tsc --watch\" \"node watch.cjs\" \"http-server dist -p 8080 -c-1\"",
+    "build": "npm run build:lib && npm run build:browser && cp demo/favicon.ico dist/favicon.ico && cp demo/index.html dist/index.html && cp node_modules/cytoscape/dist/cytoscape.min.js dist/ && if [ -d demo/data ]; then cp -r demo/data dist/data; fi && touch dist/.nojekyll",
+    "build:browser": "esbuild src/index.ts --bundle --format=esm --platform=browser --target=es2020 --external:cytoscape --outfile=dist/lumina-browser.js",
+    "dev": "npm run build && concurrently \"tsc --watch\" \"npm run build:browser -- --watch\" \"node watch.cjs\" \"http-server dist -p 8080 -c-1\"",
     "deploy": "./deploy.sh",
     "build:lib": "tsc",
     "local-publish": "npm run build:lib && yalc push",
@@ -37,6 +38,7 @@
   "devDependencies": {
     "concurrently": "^9.2.4",
     "cytoscape": "^3.33.1",
+    "esbuild": "^0.28.2",
     "gh-pages": "^6.3.0",
     "http-server": "^14.1.1",
     "typescript": "^5.9.3",
@@ -65,5 +67,8 @@
   },
   "allowScripts": {
     "fsevents@2.3.3": true
+  },
+  "dependencies": {
+    "fastpriorityqueue": "^0.8.0"
   }
 }