Add compiler plugin hooks and plugins and move compilation pipeline out of App

[FarhanAliRaza]

Summary

• Introduce a CompilerPlugin protocol with enter_component/leave_component/eval_page/compile_page hooks, enabling third-party plugins to participate in the frontend compilation pipeline
• Move the frontend compilation pipeline from App._compile() into compiler.compile_app(), decoupling compilation logic from the App class
• Remove ExecutorType/ExecutorSafeFunctions abstractions from environment.py in favor of a sequential plugin-driven compilation model
• Add built-in plugins: DefaultPagePlugin, ApplyStylePlugin, DefaultCollectorPlugin that replicate the existing compilation behavior
• Fix memo component compilation ordering so app-wrap components are included
• Fix DefaultPagePlugin to preserve Var-backed page titles instead of replacing them with the default string

Key Changes

• packages/reflex-core/src/reflex_core/plugins/compiler.py (new): Core plugin infrastructure — CompilerPlugin protocol, CompileContext, PageContext, CompilerHooks, and component tree traversal logic
• reflex/compiler/plugins/builtin.py (new): Built-in plugins (DefaultPagePlugin, ApplyStylePlugin, DefaultCollectorPlugin) that replicate existing compilation behavior
• reflex/compiler/compiler.py: Refactored compile_app() to use plugin-driven compilation via CompilerHooks
• reflex/app.py: Removed ~430 lines of compilation logic, App._compile() now delegates to compiler.compile_app()
• packages/reflex-core/src/reflex_core/environment.py: Removed ExecutorType and ExecutorSafeFunctions (no longer needed)

Test Plan

• New unit tests in tests/units/compiler/test_plugins.py (855 lines) covering:
  • Plugin hook dispatch (enter/leave component, eval/compile page)
  • CompileContext lifecycle and state management
  • DefaultPagePlugin behavior including Var-backed titles
  • ApplyStylePlugin style application
  • DefaultCollectorPlugin import/custom code collection
  • Route deduplication and error handling
  • End-to-end compilation matching legacy output
• New test in tests/units/test_app.py verifying memo components are written to shared components module
• Existing test suite passes without modification

All Submissions:

• Have you followed the guidelines stated in CONTRIBUTING.md file?
• Have you checked to ensure there aren't any other open Pull Requests for the desired changed?

Type of change

Please delete options that are not relevant.

• New feature (non-breaking change which adds functionality)

New Feature Submission:

• Does your submission pass the tests?
• Have you linted your code locally prior to submission?

Changes To Core Features:

• Have you added an explanation of what your changes do and why you'd like us to include them?
• Have you written new tests for your core changes, as applicable?
• Have you successfully ran tests with your changes locally?

closes #6210
closes #6211
closes #6212
Closes #6213

[greptile-apps]

Greptile Summary

This PR lays the plugin-architecture foundations for single-pass page compilation in Reflex, introducing reflex/compiler/plugins.py with CompilerPlugin protocol, CompilerHooks dispatcher, and BaseContext/PageContext/CompileContext task-local context managers. It also fixes a flaky Redis oplock-contention test and ships a comprehensive 435-line test suite.

Key changes:

• CompilerPlugin protocol with three async hooks (eval_page, compile_page, compile_component as an async generator for pre/post tree traversal)
• CompilerHooks implements stop-on-first-result semantics for eval_page and middleware-style enter/unwind for compile_component
• BaseContext.__init_subclass__ creates a per-subclass ContextVar, giving each context type task-local isolation without requiring manual registration
• PageContext accumulates imports, hooks, custom code, dynamic imports, refs, and app-wrap components; CompileContext orchestrates multi-page compilation with duplicate-route detection
• Redis test fix replaces a racy shared event (set by whichever of two tasks happened to run first) with a counter that only fires after both contenders have executed past their synchronous setup

Findings:

• Prop-component traversal in compile_component discards the return value — no inline comment at the call site to warn plugin authors
• Unwind loop's _compile_children call can receive None if a plugin yields a malformed tuple — a defensive assertion would give a clearer error
• mark_contender_started is defined twice with identical logic in two test functions

Confidence Score: 5/5

Safe to merge — all remaining findings are P2 style and documentation suggestions with no impact on runtime correctness.

The core plugin machinery is well-designed and the test coverage is thorough. All three findings are P2: a missing inline comment on the intentional prop-component side-effect-only traversal, a defensive assertion that would improve error messages for malformed plugin generators (not triggerable by correctly-typed plugins), and duplicated test helper logic. None affect correctness or reliability.

reflex/compiler/plugins.py — the prop-component traversal asymmetry and the unwind-loop None-children path are worth a second look before the plugin API is widely adopted.

Important Files Changed

Filename	Overview
reflex/compiler/plugins.py	New module introducing plugin protocol, CompilerHooks dispatcher, BaseContext/PageContext/CompileContext — well-structured; minor issue with silently-discarded prop-component return values and a latent None-children path in the unwind loop.
tests/units/compiler/test_plugins.py	Comprehensive 435-line test suite covering plugin dispatch ordering, tree traversal, context lifecycle, data accumulation, duplicate-route rejection, and factory isolation — thorough and well-organized.
tests/units/istate/manager/test_redis.py	Flaky-test fix replaces racy single-event pattern with a counter that fires only after both contending tasks have started; correct for asyncio's cooperative scheduler. Minor: mark_contender_started logic is duplicated in two test functions.
pyproject.toml	Adds "asend" to codespell's ignore list to suppress false positives from the async generator send API.

Sequence Diagram

sequenceDiagram
    participant CC as CompileContext.compile()
    participant CH as CompilerHooks
    participant PC as PageContext
    participant P as Plugin (ordered chain)

    CC->>CH: eval_page(page_fn) [stop-on-first]
    CH->>P: eval_page() — first plugin returning non-None wins
    P-->>CH: PageContext
    CH-->>CC: PageContext

    CC->>PC: async with page_ctx (attach ContextVar)

    loop For each structural child
        CC->>CH: compile_component(comp)
        CH->>P: plugin.compile_component() → AsyncGenerator
        Note over P: PRE: anext(gen) — enter phase (registration order)
        CH->>CH: _compile_children(structural_children) [recursive]
        CH->>CH: compile_component(prop_components) [side-effects only]
        Note over P: POST: gen.asend((comp, children)) — unwind (reverse order)
        CH-->>CC: compiled_component
    end

    CC->>CH: compile_page(page_ctx)
    CH->>P: compile_page() — all plugins, registration order
    P-->>CH: (void)

    CC->>PC: exit async with (detach ContextVar)
    CC->>CC: compiled_pages[route] = page_ctx

Loading

_{Reviews (2): Last reviewed commit: "removed the extra stuff no related to is..." | Re-trigger Greptile}

[codspeed-hq]

Merging this PR will improve performance by ×11

⚠️ Different runtime environments detected

Some benchmarks with significant performance changes were compared across different runtime environments,
which may affect the accuracy of the results.

Open the report in CodSpeed to investigate

⚡ 5 improved benchmarks
✅ 2 untouched benchmarks
🆕 10 new benchmarks
⏩ 2 skipped benchmarks¹

Performance Changes

	Benchmark	BASE	HEAD	Efficiency
⚡	test_compile_page[_complicated_page]	91.4 ms	8.3 ms	×11
🆕	test_get_all_imports_single_pass[_complicated_page]	N/A	3.2 ms	N/A
🆕	test_compile_page_full_context[_complicated_page]	N/A	157.4 ms	N/A
🆕	test_evaluate_page_single_pass[_complicated_page]	N/A	46.9 ms	N/A
🆕	test_get_all_imports_single_pass[_stateful_page]	N/A	744.1 µs	N/A
⚡	test_evaluate_page[_complicated_page]	47.7 ms	46 ms	+3.6%
🆕	test_compile_page_full_context[_stateful_page]	N/A	30.1 ms	N/A
⚡	test_get_all_imports[_stateful_page]	3,119.1 µs	496.3 µs	×6.3
⚡	test_compile_page[_stateful_page]	10.7 ms	1.7 ms	×6.4
🆕	test_compile_single_pass_all_artifacts[_stateful_page]	N/A	26.8 ms	N/A
⚡	test_get_all_imports[_complicated_page]	23.1 ms	2.4 ms	×9.4
🆕	test_compile_single_pass_all_artifacts[_complicated_page]	N/A	139.4 ms	N/A
🆕	test_compile_page_single_pass[_stateful_page]	N/A	27.4 ms	N/A
🆕	test_evaluate_page_single_pass[_stateful_page]	N/A	7.3 ms	N/A
🆕	test_compile_page_single_pass[_complicated_page]	N/A	144.1 ms	N/A

---

_{Comparing FarhanAliRaza:compiler-hooks (50e8877) with main (db61392)}

Footnotes

1. 2 benchmarks were skipped, so the baseline results were used instead. If they were deleted from the codebase, click here and archive them to remove them from the performance reports. ↩

[masenf]

we need a test case for the child replacement logic when traversing the tree; we might not strictly need it now, but it will be important when moving the StatefulComponent compilation into the plugin system.

[masenf]

Khaleel and I were discussing this a bit further, and I think it would be better to add these new plugin hooks and hook dispatching system to the existing Plugin base in packages/reflex-core

[FarhanAliRaza]

@masenf i dont know why the tests are failing.

[masenf]

why does it del the local vars?

[FarhanAliRaza]

They are gonna be overloaded by the actual plugin. So Claude is i think, just trying to use it. Deleting it.

[masenf]

is this protocol needed since we have the base plugin definition?

[masenf]

this class also gets defined in my backend event loop PR as reflex_base.context.base depending on whose merges first, we can refactor

[masenf]

is this still making the recursive call? isn't this information cached in the PageContext as imports?