feat(core): compile board graph topology on first execution

[SBALAVIGNESH123]

Summary

Resolves #71 — Graphs should be compiled on first execution or version creation to speed-up future executions and loading times.

Problem

Every call to InternalRun::new_with_run_id() performs ~370 lines of O(N²+E) graph construction:

1. Create InternalPins from board pins — O(N×P)
2. Wire OnceLock connections — O(edges)
3. Instantiate nodes from registry — O(N)
4. Instantiate function layer nodes — O(L×N)
5. Dependency resolution — O(N²) worst case

All of this is deterministic for a given board version and repeated identically every execution.

Solution

Cache the compiled graph topology (pins, nodes, dependencies) on first execution, keyed by a content hash (HighwayHash) of the board. Subsequent runs reuse the cached topology and only reset mutable runtime state.

Key design insight: InternalPin uses OnceLock for graph wiring (connected_to, depends_on, node), making the topology immutable after construction. Only pin.value: RwLock<Option<Value>> is mutable — and pin.reset() already clears it.

Changes

File	Change
compiled.rs	NEW — CompiledBoard struct with compile(), reset_for_new_run(), compute_board_hash(), is_valid_for()
execution.rs	Cache lookup at top of new_with_run_id() + from_compiled() fast path + cache store after slow path
state.rs	compiled_boards: DashMap field on FlowLikeState

Fast Path Performance

• Skips: O(N×P + E + N²) graph construction entirely
• Reset cost: O(P + N) with zero allocations (atomic stores + RwLock writes)
• Per-run: Fresh Run, variables, cache for full isolation

Safety

• Graph topology (OnceLock) is never modified after compilation
• Each InternalRun gets its own Run, variables, and cache
• Content hash invalidation: any board change → hash mismatch → recompile
• Zero changes to node APIs — completely transparent to all catalog nodes
• Existing new_with_run_id() preserved as fallback (slow path)

[gemini-code-assist]

Code Review

This pull request introduces a caching layer for board graph topologies to improve execution performance by skipping expensive graph construction phases. A new CompiledBoard struct handles the compilation and hashing of board structures, while InternalRun is updated with a fast-path initialization method. However, the review highlights a critical concurrency issue where mutable runtime state, such as pin values and execution counters, is shared across concurrent runs using the same cached topology. There is also significant code duplication between the new caching logic and existing initialization paths that should be refactored to ensure maintainability. Other feedback includes replacing println! with the tracing crate for diagnostics and removing an unused variable in the compilation logic.

[codacy-production]

Up to standards ✅

🟢 Issues 0 issues

Results:
0 new issues

View in Codacy

🟢 Metrics 14 complexity

Metric	Results
Complexity	14

View in Codacy

_{NEW Get contextual insights on your PRs based on Codacy's metrics, along with PR and Jira context, without leaving GitHub. Enable AI reviewer
TIP This summary will be updated as you push new changes.}

[SBALAVIGNESH123]

Thanks for the thorough review! All valid points — I've pushed a v2 that addresses everything:

Concurrency bug (critical) — You're absolutely right, sharing Arc across concurrent runs would corrupt pin values. Fixed by restructuring CompiledBoard to only cache the stateless Arc instances (which are Send + Sync by trait contract and take &self in run()). Each execution now creates its own fresh pins, nodes, and wiring — no mutable state is shared between runs.

Code duplication — Removed the standalone compile() method entirely. from_compiled() now follows the same phase structure as new_with_run_id() (pin creation → wiring → node instantiation → dependency resolution), just swapping registry.instantiate() for a cached logic lookup. Happy to extract shared helpers in a follow-up if you'd prefer less duplication, but wanted to keep this PR's diff minimal against the existing code.

Unused variable & println — Removed pin_to_node from the old compile path, replaced println! with tracing::info!.

The main perf win is skipping registry.instantiate() on subsequent runs — especially useful for WASM nodes where that can involve module loading. Graph wiring still runs fresh each time, which is the right tradeoff for correctness.

[felix-schultz]

Thank you very much for the PR! I will review it later :)