fix(terminal): start precision

[emir-karabeg]

Summary

Addresses a timing discrepancy where fast-executing blocks, particularly the "start" block, would often report 0ms or inconsistent durations due to the millisecond precision of Date.now(). This PR replaces Date.now() with performance.now() for all execution timing measurements in the block executor and engine, providing sub-millisecond precision for accurate duration tracking.

Type of Change

• Bug fix
• New feature
• Breaking change
• Documentation
• Other: ___________

Testing

The changes were verified by:

• Running all existing engine tests (29 tests)
• Running all existing start-block tests (8 tests)
• Passing lint checks
• Passing TypeScript type checks

Reviewers should focus on ensuring that the switch to performance.now() does not introduce any unexpected side effects in timing calculations or logging, particularly regarding the endTime which now uses new Date().toISOString() for the timestamp while performance.now() is used for duration calculation.

Checklist

• Code follows project style guidelines
• Self-reviewed my changes
• Tests added/updated and passing
• No new warnings introduced
• I confirm that I have read and agree to the terms outlined in the Contributor License Agreement (CLA)

Screenshots/Videos

---

 

[cursor]

Cursor Agent can help with this pull request. Just @cursor in comments and I'll start working on changes in this branch.
_{Learn more about Cursor Agents}

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

1 Skipped Deployment

Project	Deployment	Actions	Updated (UTC)
docs	Skipped		Jan 30, 2026 8:44pm

[emir-karabeg]

@greptile

[greptile-apps]

Greptile Overview

Greptile Summary

This PR improves timing precision in block execution by replacing Date.now() with performance.now() for all duration measurements.

Key Changes:

• block-executor.ts: Updated 3 timing measurements (line 74, 148, 224) to use performance.now() for block execution duration tracking
• engine.ts: Updated execution duration tracking (lines 104, 128, 149, 436) while correctly preserving Date.now() for cancellation check intervals (line 81)

Implementation Details:

• performance.now() provides sub-millisecond precision (microseconds) vs Date.now()'s millisecond precision
• Duration calculations now use performance.now() for startTime and endTime
• ISO timestamp for metadata.endTime correctly changed from new Date(endTime).toISOString() to new Date().toISOString() since performance.now() returns elapsed time, not epoch time
• Cancellation interval checking appropriately kept Date.now() as it needs wall-clock time

Impact:
Fast-executing blocks (especially the "start" block) will now show accurate sub-millisecond durations instead of often reporting 0ms.

Confidence Score: 5/5

• This PR is safe to merge with minimal risk
• The changes are surgical and well-contained. The PR correctly distinguishes between duration measurement (now using performance.now()) and wall-clock time intervals (correctly kept as Date.now()). All tests pass, the implementation properly handles the epoch-time vs elapsed-time distinction for timestamps, and the changes only affect timing precision without altering any business logic.
• No files require special attention

Important Files Changed

Filename	Overview
apps/sim/executor/execution/block-executor.ts	replaced Date.now() with performance.now() for precise block execution timing (3 instances)
apps/sim/executor/execution/engine.ts	replaced Date.now() with performance.now() for precise workflow execution duration, correctly preserved Date.now() for cancellation check intervals

Sequence Diagram

sequenceDiagram
    participant Client
    participant Engine as ExecutionEngine
    participant BlockExec as BlockExecutor
    participant Handler as BlockHandler
    
    Client->>Engine: run(triggerBlockId?)
    Note over Engine: startTime = performance.now()
    
    Engine->>Engine: initializeQueue()
    
    loop While has work
        Engine->>Engine: processQueue()
        Engine->>Engine: executeNodeAsync(nodeId)
        Engine->>BlockExec: execute(ctx, node, block)
        Note over BlockExec: startTime = performance.now()
        
        BlockExec->>BlockExec: resolveInputs()
        BlockExec->>Handler: execute(ctx, block, inputs)
        Handler-->>BlockExec: output
        
        Note over BlockExec: duration = performance.now() - startTime
        BlockExec->>BlockExec: Update blockLog with duration
        BlockExec-->>Engine: NormalizedBlockOutput
        
        Engine->>Engine: handleNodeCompletion()
    end
    
    Note over Engine: endTime = performance.now()<br/>duration = endTime - startTime<br/>metadata.endTime = new Date().toISOString()
    Engine-->>Client: ExecutionResult with precise duration

Loading

[greptile-apps]

_{2 files reviewed, no comments}

_{Edit Code Review Agent Settings | Greptile}

[greptile-apps]

_{2 files reviewed, no comments}

_{Edit Code Review Agent Settings | Greptile}

[waleedlatif1]

@cursor review