Q:

How to avoid event's lag with KineticJS?

I am in the prototyping stage of making a 2d map builder for a hybrid web/text adventure game and so far KineticJS seems like an ideal fit.  Only issue currently is that given enough velocity on mouse movement, it will skip over cells and never fire their mouseover event handler.
2 core functionality goals:  When the user highlights a cell, it would be marked as "active".  Additionally if they're holding the mouse down and move across the grid, cells would be flipped on or off ( this maybe refactored to set all on if not if the first cell is not active, or vice versa ).
My question:  Is there a way to ensure all cells are triggered, regardless of mouse cursor velocity?   If not, is there a better way to draw a line over the cells so that it consistently triggers all relevant cells?
The entire prototype has been put into jsFiddle ( http://jsfiddle.net/7ggS4/ ) but for future sake, the rest will be copied below as well.
    <head>
    <title>KineticJS</title>
    <script src="//cdnjs.cloudflare.com/ajax/libs/kineticjs/4.7.2/kinetic.min.js"></script>
</head>
<body>
    <div id="canvas"></div>
</body>
<script defer="defer">

    /**
    Return's a KS layer

    */
    function Grid(cells, stage) {
        //Constants
        // Illrelevant comment - It seriously pisses me off that canvas uses
        // string color codes ( either name or string hexidecimal ) instead of taking an
        // integer or actual hexidecimal 0xFFFF values.  This just seems painfully inefficient.
        this.activeCellColor = "green";
        this.clearCellColor = "blue";
        this.highlightCellColor = "red";

        this.cells = cells,
        this.layer = new Kinetic.Layer(),
        this.grid = new Array(),
        this.isMouseDown = false,
        this.mouseLeft = false,
        this.mouseRight = false,
        this.adjRow = stage.getWidth() / cells,
        this.adjCol = stage.getHeight() / cells;
        this.generate();
        stage.add(this.layer)

    }

    Grid.prototype.generate = function(){
        var i, rx, ry, rect;

        for (i = 0; i < this.cells * this.cells; i++) {
            rx = Math.floor(i / this.cells) * this.adjRow;
            ry = (i % this.cells) * this.adjCol;

            rect = new Kinetic.Rect({
                x: rx,
                y: ry,
                width: this.adjRow,
                height: this.adjCol,
                fill: this.clearCellColor,
                stroke: 'black',
                strokeWidth: .2,
                cell: {x: Math.floor(i / this.cells), y: i % this.cells},
                active: false,
                grid: this //Just in case .bind(this) doesn't work right
            });
            rect.on('mouseenter', this.onMouseEnter.bind(this));
            rect.on('mouseleave', this.onMouseLeave.bind(this));
            rect.on('mousedown', this.onMouseDown.bind(this));
            rect.on('mouseup', this.onMouseUp.bind(this));

            this.grid.push(rect);
            this.layer.add(rect);

        }

    }

    Grid.prototype.onMouseEnter = function(evt) {
        var src = evt.targetNode;
        console.log(evt.type, this.isMouseDown, src.attrs.cell)

        if (this.isMouseDown == true) {
            src.attrs.active = ! src.attrs.active;
        }

        if (src.attrs.active == false) {
            src.setFill(this.highlightCellColor);
        } else {
            src.setFill(this.activeCellColor);
        }

        this.layer.batchDraw();
    }

    Grid.prototype.onMouseLeave = function(evt) {
        var src = evt.targetNode;
        console.log(evt.type, this.isMouseDown, src.attrs.cell)

        if (src.attrs.active == false) {
            src.setFill(this.clearCellColor);
            this.layer.batchDraw();
        }

    }

    Grid.prototype.onMouseUp = function(evt){
        var src = evt.targetNode;
        console.log(evt.type, this.isMouseDown, src.attrs.cell)
        this.isMouseDown = false;
    }

    Grid.prototype.onMouseDown = function(evt){
        var src = evt.targetNode;
        console.log(evt.type, this.isMouseDown, src.attrs.cell)
        this.isMouseDown = true;
        src.attrs.active = ! src.attrs.active;

        if (src.attrs.active) {
            src.setFill(this.activeCellColor);
        } else {
            src.setFill(this.clearCellColor);
        }
        this.layer.batchDraw();
    }

    var stage = new Kinetic.Stage({
        container: 'canvas',
        width: 600,
        height: 600
      }),

    myGrid = new Grid(50, stage);

</script>

A:

50x50=2500 active objects: that's too many for Kinetic to handle. 
Remember that each "intelligent" Kinetic cell has a lot of overhead associated with it.  
How about reducing your grid to 20x20?  
Alternatively, you will have to separate the mouse handling from the cell handling to gain the required performance.  
Mouse Handling
Your mouse handling would only involve capturing mouse points into an array of accumulated points. You can use this kind of code to capture mouse points on the stage:
$(stage.getContent()).on('click', function (event) {
    myPointsArray.push(stage.getMousePosition());
});

Cell processing
The cell processing would involve applying those accumulated points to affect your grid cells.  An effective place to do this code would be in a requestAnimationFrame (RAF) loop.  You won't be doing animations, but RAF gives high performance because it is aware of the availability of system resources.  An RAF loop would look like this:
function processPointsArray(array){

    // request another loop even before we're done with this one
    requestAnimationFrame(processPointsArray);

    // process the points array and affect your cells here

}

A processing efficiency
RAF is called up to 60 times per second, so your user will probably navagate only a small portion of your grid during that time.  You can increase performance by calculating the min/max x and y coordinates in the accumulated points array and only process those grid cells within that boundary.

