Graph Model

// O(E) time to find neighbors of a node
const neighbors = edges.filter(edge => edge.from === nodeId);

// O(1) time to find neighbors
const neighbors = adjacencyList[nodeId];

// From graph.ts:124-220
public localShortestPath(
    from: string,
    to: string,
    allowedModes: ('walk' | 'local')[] = ['walk', 'local']
): PathResult {
    // Validate nodes
    if (!this.nodes.has(from) || !this.nodes.has(to)) {
        return { found: false, path: [], totalTime: Infinity, totalCost: 0, edges: [] };
    }
    
    // Initialize data structures
    const distances: Map<string, number> = new Map();
    const costs: Map<string, number> = new Map();
    const previous: Map<string, string | null> = new Map();
    const unvisited: Set<string> = new Set();
    
    this.nodes.forEach((_, nodeId) => {
        distances.set(nodeId, Infinity);
        costs.set(nodeId, 0);
        previous.set(nodeId, null);
        unvisited.add(nodeId);
    });
    
    distances.set(from, 0);
    
    // Main loop
    while (unvisited.size > 0) {
        // Find node with minimum distance
        let current: string | null = null;
        let minDist = Infinity;
        unvisited.forEach(nodeId => {
            const dist = distances.get(nodeId)!;
            if (dist < minDist) {
                minDist = dist;
                current = nodeId;
            }
        });
        
        if (current === null || minDist === Infinity) break;
        if (current === to) break; // Found destination
        
        unvisited.delete(current);
        
        // Relax neighbors
        const neighbors = this.getNeighbors(current);
        neighbors.forEach(edge => {
            if (!allowedModes.includes(edge.mode as any)) return;
            if (!unvisited.has(edge.to)) return;
            
            const newDist = distances.get(current!)! + edge.time_min;
            if (newDist < distances.get(edge.to)!) {
                distances.set(edge.to, newDist);
                costs.set(edge.to, costs.get(current!)! + edge.cost);
                previous.set(edge.to, current);
            }
        });
    }
    
    // Reconstruct path
    const finalDist = distances.get(to)!;
    if (finalDist === Infinity) {
        return { found: false, path: [], totalTime: Infinity, totalCost: 0, edges: [] };
    }
    
    const path: string[] = [];
    let current: string | null = to;
    while (current !== null) {
        path.unshift(current);
        current = previous.get(current) || null;
    }
    
    return {
        found: true,
        path,
        totalTime: finalDist,
        totalCost: costs.get(to)!,
        edges: [/* ... */]
    };
}