pywire 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

pywire/compiler/codegen/generator.py

@@ -0,0 +1,2341 @@
+"""Main code generator orchestrator."""
+
+import ast
+import re
+from typing import Any, Dict, List, Optional, Set, Tuple, Type, Union, cast
+
+from pywire.compiler.ast_nodes import (
+    ComponentDirective,
+    Directive,
+    EventAttribute,
+    FormValidationSchema,
+    InjectDirective,
+    LayoutDirective,
+    NoSpaDirective,
+    ParsedPyWire,
+    PathDirective,
+    PropsDirective,
+    ProvideDirective,
+    SpecialAttribute,
+    TemplateNode,
+)
+from pywire.compiler.codegen.attributes.base import AttributeCodegen
+from pywire.compiler.codegen.attributes.events import EventAttributeCodegen
+from pywire.compiler.codegen.directives.base import DirectiveCodegen
+from pywire.compiler.codegen.directives.path import PathDirectiveCodegen
+from pywire.compiler.codegen.template import TemplateCodegen
+
+
+class CodeGenerator:
+    """Generates Python module from ParsedPyWire AST."""
+
+    def __init__(self) -> None:
+        self.directive_handlers: Dict[Type[Directive], DirectiveCodegen] = {
+            PathDirective: PathDirectiveCodegen(),
+            # Future: LayoutDirective: LayoutDirectiveCodegen(), etc.
+        }
+
+        self.attribute_handlers: Dict[Type[SpecialAttribute], AttributeCodegen] = {
+            EventAttribute: EventAttributeCodegen(),
+            # Future: BindAttribute: BindAttributeCodegen(), etc.
+        }
+
+        self.template_codegen = TemplateCodegen()
+
+    def _generate_component_loading(
+        self, parsed: ParsedPyWire
+    ) -> Tuple[List[ast.stmt], Dict[str, str]]:
+        """
+        Generate code to load components and return Tag -> ClassName map.
+        Returns: (stmts, component_map)
+        """
+        stmts: List[ast.stmt] = []
+        component_map = {}
+
+        for directive in parsed.directives:
+            if isinstance(directive, ComponentDirective):
+                # Name = load_component("path", __file_path__)
+
+                # Check for "as Name" collision with imports or other components?
+                # Python handles it (overwrite), but maybe warn?
+
+                target_name = directive.component_name
+                path = directive.path
+
+                # component_map[target_name] = target_name (class is assigned to this var)
+                # Parse lowercases HTML tags, so we map lowercase name to actual class name
+                component_map[target_name.lower()] = target_name
+
+                stmts.append(
+                    ast.Assign(
+                        targets=[ast.Name(id=target_name, ctx=ast.Store())],
+                        value=ast.Call(
+                            func=ast.Name(id="load_component", ctx=ast.Load()),
+                            args=[
+                                ast.Constant(value=path),
+                                ast.Constant(value=parsed.file_path),
+                            ],
+                            keywords=[],
+                        ),
+                    )
+                )
+
+        return stmts, component_map
+
+    def generate(self, parsed: ParsedPyWire) -> ast.Module:
+        """Generate complete module AST."""
+        self.file_path = parsed.file_path
+        self._has_top_level_init = False
+        self._collected_mount_hooks: List[str] = []
+        module_body = []
+
+        # Imports
+        module_body.extend(self._generate_imports())
+
+        # Add asyncio import for handle_event
+        module_body.append(ast.Import(names=[ast.alias(name="asyncio", asname=None)]))
+
+        # Component loading (early, so they are available)
+        comp_stmts, component_map = self._generate_component_loading(parsed)
+        module_body.extend(comp_stmts)
+
+        # Layout logic
+        layout_directive = parsed.get_directive_by_type(LayoutDirective)
+
+        if layout_directive:
+            layout_directive = cast(LayoutDirective, layout_directive)
+            # Import load_layout
+            module_body.append(
+                ast.ImportFrom(
+                    module="pywire.runtime.loader",
+                    names=[ast.alias(name="load_layout", asname=None)],
+                    level=0,
+                )
+            )
+            # Load layout class
+            # _LayoutBase = load_layout("path", __file_path__)
+            module_body.append(
+                ast.Assign(
+                    targets=[ast.Name(id="_LayoutBase", ctx=ast.Store())],
+                    value=ast.Call(
+                        func=ast.Name(id="load_layout", ctx=ast.Load()),
+                        args=[
+                            ast.Constant(value=layout_directive.layout_path),
+                            ast.Constant(
+                                value=parsed.file_path
+                            ),  # Pass page file path for relative resolution
+                        ],
+                        keywords=[],
+                    ),
+                )
+            )
+            # Extract user imports from Python section
+        if parsed.python_ast:
+            module_body.extend(self._extract_user_imports(parsed.python_ast))
+            # Extract user classes to module level (Pydantic models, etc.)
+            module_body.extend(self._extract_user_classes(parsed.python_ast))
+
+        # Extract method names early for binding logic
+        known_methods, known_vars, async_methods = self._collect_global_names(
+            parsed.python_ast
+        )
+
+        # Include explicit variable assignments
+        known_vars.update(self._extract_user_variables(parsed.python_ast))
+
+        known_imports = self._extract_import_names(parsed.python_ast)
+        all_globals = known_methods.union(known_vars).union(known_imports)
+
+        # Inline handlers (with method names)
+        # Note: Handlers only need to know about globals to avoid "self." prefixing if needed,
+        # but _process_handlers mostly cares about wrapping logic.
+        # Actually _process_handlers calls _transform_inline_code which uses known_methods.
+        # Ideally it should know about all globals too.
+        handlers, allowed_handlers = self._process_handlers(
+            parsed, all_globals, async_methods
+        )
+
+        # Page class
+        page_class = self._generate_page_class(
+            parsed,
+            handlers,
+            known_methods,
+            known_vars,
+            known_imports,
+            async_methods,
+            component_map,
+            allowed_handlers,
+        )
+        module_body.append(page_class)
+
+        # Export reference to main class
+        module_body.append(
+            ast.Assign(
+                targets=[ast.Name(id="__page_class__", ctx=ast.Store())],
+                value=ast.Name(id=page_class.name, ctx=ast.Load()),
+            )
+        )
+
+        module = ast.Module(body=module_body, type_ignores=[])
+        ast.fix_missing_locations(module)
+
+        return module
+
+    def _generate_imports(self) -> List[ast.stmt]:
+        """Generate framework imports."""
+        imports: List[ast.stmt] = [
+            ast.ImportFrom(
+                module="pywire.runtime.page",
+                names=[ast.alias(name="BasePage", asname=None)],
+                level=0,
+            ),
+            ast.ImportFrom(
+                module="pywire.core.wire",
+                names=[ast.alias(name="wire", asname=None)],
+                level=0,
+            ),
+            ast.ImportFrom(
+                module="starlette.responses",
+                names=[ast.alias(name="Response", asname=None)],
+                level=0,
+            ),
+            ast.Import(names=[ast.alias(name="json", asname=None)]),
+            # Form validation imports
+            ast.ImportFrom(
+                module="pywire.runtime.validation",
+                names=[
+                    ast.alias(name="form_validator", asname=None),
+                    ast.alias(name="FieldRules", asname=None),
+                    ast.alias(name="FormValidationSchema", asname=None),
+                ],
+                level=0,
+            ),
+            ast.ImportFrom(
+                module="pywire.runtime.pydantic_integration",
+                names=[ast.alias(name="validate_with_model", asname=None)],
+                level=0,
+            ),
+            ast.ImportFrom(
+                module="pywire.runtime.loader",
+                names=[ast.alias(name="load_component", asname=None)],
+                level=0,
+            ),
+            ast.ImportFrom(
+                module="pywire.runtime.helpers",
+                names=[
+                    ast.alias(name="unwrap_wire", asname=None),
+                    ast.alias(name="set_render_context", asname=None),
+                    ast.alias(name="reset_render_context", asname=None),
+                ],
+                level=0,
+            ),
+        ]
+        return imports
+
+    def _generate_component_imports(
+        self, parsed: ParsedPyWire
+    ) -> Tuple[List[ast.stmt], Dict[str, str]]:
+        """
+        Generate imports for components and return a map of TagName -> ClassName.
+        Returns: (import_stmts, component_map)
+        """
+        imports: List[ast.stmt] = []
+        component_map: Dict[str, str] = {}
+
+        from pywire.compiler.ast_nodes import ComponentDirective
+
+        for directive in parsed.directives:
+            if isinstance(directive, ComponentDirective):
+                # !component 'path' as Name
+                # We need to resolve 'path' to a python module path.
+                # Assuming 'path' is relative to project root or use loader helper?
+                # Actually, generated code will run in server context.
+                # Better to use our dynamic loader:
+                # Name = load_component('path', __file_path__)
+
+                # Import load_component if not already
+                # (handled in _generate_imports? No, let's assume we import a loader helper)
+
+                # We'll generate:
+                # Name = load_component("path", __file_path__)
+                # But imports are usually at module level.
+                # If we use load_component, it's an assignment, not an import.
+                # That's fine, we can add it to module body.
+
+                # However, cleaner if we can generate `from x import Y`.
+                # But we don't know the exact class name inside the file (it's generated).
+                # The dynamic loader `load_component` is robust.
+
+                # Let's add `load_component` to imports
+                pass
+
+        return imports, component_map
+
+    def _extract_user_imports(self, python_ast: ast.Module) -> List[ast.stmt]:
+        """Extract import statements from user Python code."""
+        imports: List[ast.stmt] = []
+        for node in python_ast.body:
+            if isinstance(node, (ast.Import, ast.ImportFrom)):
+                imports.append(node)
+        return imports
+
+    def _extract_user_classes(self, python_ast: ast.Module) -> List[ast.stmt]:
+        """Extract class definitions from user Python code."""
+        classes: List[ast.stmt] = []
+        for node in python_ast.body:
+            if isinstance(node, ast.ClassDef):
+                classes.append(node)
+        return classes
+
+    def _extract_import_names(self, python_ast: Optional[ast.Module]) -> Set[str]:
+        """Extract names defined by imports."""
+        names = set()
+        # Add default imports
+        names.add("json")
+        names.add("form_validator")
+        names.add("FieldRules")
+
+        if python_ast:
+            for node in python_ast.body:
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        names.add(alias.asname or alias.name)
+                elif isinstance(node, ast.ImportFrom):
+                    for alias in node.names:
+                        names.add(alias.asname or alias.name)
+        return names
+
+    def _extract_user_variables(self, python_ast: Optional[ast.Module]) -> Set[str]:
+        """Extract variable names assigned at the top level of user code."""
+        vars: Set[str] = set()
+        if not python_ast:
+            return vars
+
+        for node in python_ast.body:
+            if isinstance(node, ast.Assign):
+                for target in node.targets:
+                    if isinstance(target, ast.Name):
+                        vars.add(target.id)
+            elif isinstance(node, ast.AnnAssign):
+                if isinstance(node.target, ast.Name):
+                    vars.add(node.target.id)
+        return vars
+
+    def _extract_route_params_from_pattern(self, pattern: str) -> Set[str]:
+        params: Set[str] = set()
+        if not pattern:
+            return params
+
+        for name in re.findall(r"\{([a-zA-Z_]\w*)(?::[^}]+)?\}", pattern):
+            if not name.isidentifier():
+                continue
+            params.add(name)
+
+        for name in re.findall(r":([a-zA-Z_]\w*)(?::[^/]+)?", pattern):
+            if not name.isidentifier():
+                continue
+            params.add(name)
+
+        return params
+
+    def _extract_route_params_from_file_path(
+        self, file_path: Optional[str]
+    ) -> Set[str]:
+        params: Set[str] = set()
+        if not file_path:
+            return params
+
+        from pathlib import Path
+
+        path = Path(file_path)
+
+        for part in path.parts:
+            if not part:
+                continue
+            if not (part.startswith("[") and part.endswith("]")):
+                continue
+            name = part[1:-1]
+            if not name:
+                continue
+            if not name.isidentifier():
+                continue
+            params.add(name)
+
+        stem = path.stem
+        if stem.startswith("[") and stem.endswith("]"):
+            name = stem[1:-1]
+            if name and name.isidentifier():
+                params.add(name)
+
+        return params
+
+    def _extract_route_params(self, parsed: ParsedPyWire) -> Set[str]:
+        params: Set[str] = set()
+
+        path_directive = parsed.get_directive_by_type(PathDirective)
+        if path_directive:
+            assert isinstance(path_directive, PathDirective)
+            for pattern in path_directive.routes.values():
+                params.update(self._extract_route_params_from_pattern(pattern))
+
+        params.update(self._extract_route_params_from_file_path(parsed.file_path))
+
+        return params
+
+    def _generate_page_class(
+        self,
+        parsed: ParsedPyWire,
+        handlers: List[ast.AsyncFunctionDef],
+        known_methods: Set[str],
+        known_vars: Set[str],
+        known_imports: Set[str],
+        async_methods: Set[str],
+        component_map: Dict[str, str],
+        allowed_handlers: Optional[Set[str]] = None,
+    ) -> ast.ClassDef:
+        """Generate page class definition."""
+        class_body: List[ast.stmt] = []
+
+        # Add generated handlers
+        class_body.extend(handlers)
+
+        # Generate __allowed_handlers__ for security (prevents arbitrary method invocation)
+        if allowed_handlers is None:
+            allowed_handlers = set()
+        # Include _handle_bind_* handlers that may be generated later
+        # These will be added dynamically, but we pre-allow the pattern
+        class_body.append(
+            ast.Assign(
+                targets=[ast.Name(id="__allowed_handlers__", ctx=ast.Store())],
+                value=ast.Set(
+                    elts=[ast.Constant(value=h) for h in sorted(allowed_handlers)]
+                )
+                if allowed_handlers
+                else ast.Call(
+                    func=ast.Name(id="set", ctx=ast.Load()), args=[], keywords=[]
+                ),
+            )
+        )
+
+        # Generate directive assignments (e.g., __routes__)
+        for directive in parsed.directives:
+            handler = self.directive_handlers.get(type(directive))
+            if handler:
+                class_body.extend(handler.generate(directive))
+
+        # Generate SPA navigation metadata
+        class_body.extend(self._generate_spa_metadata(parsed))
+
+        # Inject __no_spa__ flag if !no_spa was detected
+        if parsed.get_directive_by_type(NoSpaDirective):
+            class_body.append(
+                ast.Assign(
+                    targets=[ast.Name(id="__no_spa__", ctx=ast.Store())],
+                    value=ast.Constant(value=True),
+                )
+            )
+
+        # Transform user Python code to class methods (Must run before __init__ to set flags)
+        route_params = self._extract_route_params(parsed)
+        all_globals = known_methods.union(known_vars).union(route_params)
+        user_code_stmts: List[ast.stmt] = []
+        if parsed.python_ast:
+            user_code_stmts = self._transform_user_code(parsed.python_ast, all_globals)
+
+        # Generate __init__ method
+        class_body.append(self._generate_init_method(parsed))
+
+        # Add user code
+        class_body.extend(user_code_stmts)
+
+        # Generate form validation schemas and wrappers
+        # MUST happen before render generation as it updates EventAttributes to point to wrappers
+        form_validation_methods = self._generate_form_validation_methods(
+            parsed, all_globals
+        )
+        class_body.extend(form_validation_methods)
+        # Generate _render_template method AND binding methods
+        # Pass ALL globals to avoid auto-calling variables and prefixing imports
+        all_globals = (
+            known_methods.union(known_vars).union(route_params).union(known_imports)
+        )
+
+        render_func, binding_funcs = self._generate_render_template_method(
+            parsed, known_methods, all_globals, async_methods, component_map
+        )
+        if render_func:
+            class_body.append(render_func)
+        class_body.extend(binding_funcs)
+
+        # Inject __has_uploads__ flag if file inputs were detected
+        if self.template_codegen.has_file_inputs:
+            class_body.append(
+                ast.Assign(
+                    targets=[ast.Name(id="__has_uploads__", ctx=ast.Store())],
+                    value=ast.Constant(value=True),
+                )
+            )
+
+        # Determine base class
+        base_id = "BasePage"
+        if parsed.get_directive_by_type(LayoutDirective):
+            base_id = "_LayoutBase"
+
+        # Inject LAYOUT_ID if we determined one is needed
+        # We need to calculate it here too or pass it back from _generate_render_template_method
+        # Since we need it for class attribute, let's calculate it early.
+        layout_id_to_inject = None
+        if parsed.file_path:
+            import hashlib
+
+            layout_id_hash = hashlib.md5(str(parsed.file_path).encode()).hexdigest()
+            # Recursive check for slots
+            has_slots = self._has_slots_recursive(parsed.template)
+            if has_slots:
+                layout_id_to_inject = layout_id_hash
+
+        if layout_id_to_inject:
+            class_body.append(
+                ast.Assign(
+                    targets=[ast.Name(id="LAYOUT_ID", ctx=ast.Store())],
+                    value=ast.Constant(value=layout_id_to_inject),
+                )
+            )
+
+        # Lifecycle hooks calculation
+        init_hooks = []
+        # If we found @mount decorated methods
+        if hasattr(self, "_collected_mount_hooks") and self._collected_mount_hooks:
+            init_hooks.extend(self._collected_mount_hooks)
+
+        # Ensure 'on_before_load' and 'on_load' are present
+        final_init_hooks = []
+
+        # Standard hooks - REMOVED per user request
+        # final_init_hooks.append('on_before_load')
+        # final_init_hooks.append('on_load')
+
+        # Add mount hooks
+        if hasattr(self, "_collected_mount_hooks") and self._collected_mount_hooks:
+            final_init_hooks.extend(self._collected_mount_hooks)
+
+        class_body.append(
+            ast.Assign(
+                targets=[ast.Name(id="INIT_HOOKS", ctx=ast.Store())],
+                value=ast.List(
+                    elts=[ast.Constant(value=h) for h in final_init_hooks],
+                    ctx=ast.Load(),
+                ),
+            )
+        )
+        cls_def = ast.ClassDef(
+            name=self._get_class_name(parsed),
+            bases=[ast.Name(id=base_id, ctx=ast.Load())],
+            keywords=[],
+            body=class_body,
+            decorator_list=[],
+        )
+        cls_def.lineno = 1
+        cls_def.col_offset = 0
+        return cls_def
+
+    def _collect_global_names(
+        self, python_ast: Optional[ast.Module]
+    ) -> Tuple[Set[str], Set[str], Set[str]]:
+        """Collect defined function names and variables, and identify async functions.
+        Returns: (method_names, variable_names, async_method_names)
+        """
+        methods = set()
+        variables = {
+            "path",
+            "params",
+            "query",
+            "url",
+            "request",
+            "error_code",
+            "error_detail",
+            "error_trace",
+        }
+        async_methods = set()
+
+        if python_ast:
+            for node in python_ast.body:
+                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    methods.add(node.name)
+                    if isinstance(node, ast.AsyncFunctionDef):
+                        async_methods.add(node.name)
+                elif isinstance(node, ast.Assign):
+                    for target in node.targets:
+                        for child in ast.walk(target):
+                            if isinstance(child, ast.Name) and isinstance(
+                                child.ctx, ast.Store
+                            ):
+                                variables.add(child.id)
+                elif isinstance(node, ast.AnnAssign):
+                    if isinstance(node.target, ast.Name):
+                        variables.add(node.target.id)
+
+        # Add implicit params from filename if available
+        if hasattr(self, "file_path") and self.file_path:
+            import re
+            from pathlib import Path
+
+            path_obj = Path(self.file_path)
+            # Check current file name and parent directories for [param] syntax
+            for part in path_obj.parts:
+                match = re.match(r"^\[(.*?)\]$", part.replace(".pywire", ""))
+                if match:
+                    variables.add(match.group(1))
+
+        return methods, variables, async_methods
+
+    def _process_handlers(
+        self, parsed: ParsedPyWire, known_methods: Set[str], async_methods: Set[str]
+    ) -> Tuple[List[ast.AsyncFunctionDef], Set[str]]:
+        """Extract inline handlers and wrap handlers for bindings.
+
+        Returns:
+            Tuple of (handler_methods, allowed_handler_names)
+        """
+        handlers = []
+        allowed_handlers: Set[str] = set()
+        handler_count = 0
+        from pywire.compiler.ast_nodes import EventAttribute
+
+        def visit_nodes(nodes: List[TemplateNode]) -> None:
+            nonlocal handler_count
+            for node in nodes:
+                # Check for events
+                for attr in node.special_attributes:
+                    if isinstance(attr, EventAttribute):
+                        # Pre-processing: Strip wrapping braces if present (e.g. from {code} syntax)
+                        # This ensures code inside is processed correctly whether quoted or not in
+                        # source
+                        raw = attr.handler_name.strip()
+                        if raw.startswith("{") and raw.endswith("}"):
+                            attr.handler_name = raw[1:-1].strip()
+
+                        is_identifier = attr.handler_name.isidentifier()
+                        needs_wrapper = not is_identifier
+
+                        if needs_wrapper:
+                            # Create distinct handler methods
+                            method_name = f"_handler_{handler_count}"
+                            handler_count += 1
+
+                            try:
+                                # Transform body logic
+                                code_to_transform = attr.handler_name
+
+                                body, args = self._transform_inline_code(
+                                    code_to_transform, known_methods, async_methods
+                                )
+
+                                # Store extracted args
+                                attr.args = args
+
+                                # Create handler method
+                                # async def _handler_X(self, arg0, arg1...):
+                                arg_definitions = [ast.arg(arg="self")]
+                                for i in range(len(args)):
+                                    arg_definitions.append(ast.arg(arg=f"arg{i}"))
+
+                                handlers.append(
+                                    ast.AsyncFunctionDef(
+                                        name=method_name,
+                                        args=ast.arguments(
+                                            posonlyargs=[],
+                                            args=arg_definitions,
+                                            vararg=None,
+                                            kwonlyargs=[],
+                                            kw_defaults=[],
+                                            defaults=[],
+                                        ),
+                                        body=body,
+                                        decorator_list=[],
+                                        returns=None,
+                                    )
+                                )
+
+                                attr.handler_name = method_name
+                                # Add generated handler to allowlist
+                                allowed_handlers.add(method_name)
+
+                            except Exception as e:
+                                print(
+                                    f"Error compiling handler '{attr.handler_name}': {e}"
+                                )
+                        else:
+                            # Simple identifier handler - add to allowlist
+                            allowed_handlers.add(attr.handler_name)
+
+                visit_nodes(node.children)
+
+        visit_nodes(parsed.template)
+        return handlers, allowed_handlers
+
+    def _transform_inline_code(
+        self,
+        code: str,
+        known_methods: Set[str] = set(),
+        async_methods: Set[str] = set(),
+    ) -> Tuple[List[ast.stmt], List[str]]:
+        """Transform inline code: lift arguments and prefix globals with self."""
+        import builtins
+
+        # Map $event to event for Alpine compatibility
+        code = code.replace("$event", "event")
+
+        from pywire.compiler.preprocessor import preprocess_python_code
+
+        code = preprocess_python_code(code)
+
+        tree = ast.parse(code)
+        extracted_args: List[str] = []
+
+        class ArgumentLifter(ast.NodeTransformer):
+            def visit_Call(self, node: ast.Call) -> Any:
+                # Check arguments for unbound variables
+                new_args: List[ast.expr] = []
+                for arg in node.args:
+                    # Quick check: does this arg contain unbound names?
+                    unbound = False
+                    for child in ast.walk(arg):
+                        if isinstance(child, ast.Name):
+                            if child.id not in known_methods and child.id not in dir(
+                                builtins
+                            ):
+                                unbound = True
+                                break
+
+                    if unbound:
+                        # Lift it!
+                        arg_index = len(extracted_args)
+                        extracted_args.append(ast.unparse(arg))
+                        new_args.append(ast.Name(id=f"arg{arg_index}", ctx=ast.Load()))
+                    else:
+                        new_args.append(self.visit(arg))
+
+                node.args = new_args
+                return self.generic_visit(node)
+
+            def visit_Name(self, node: ast.Name) -> Any:
+                # Transform known methods and globals to self.X
+                if node.id in known_methods:
+                    return ast.Attribute(
+                        value=ast.Name(id="self", ctx=ast.Load()),
+                        attr=node.id,
+                        ctx=node.ctx,
+                    )
+                return node
+
+        # Run transformer
+        transformer = ArgumentLifter()
+        new_tree = transformer.visit(tree)
+
+        if async_methods:
+
+            class AsyncCallTransformer(ast.NodeTransformer):
+                def visit_Call(self, node: ast.Call) -> Any:
+                    # Check if call to self.async_method
+                    # The func is now (after ArgumentLifter/Name visit) self.method_name
+                    if (
+                        isinstance(node.func, ast.Attribute)
+                        and isinstance(node.func.value, ast.Name)
+                        and node.func.value.id == "self"
+                        and node.func.attr in async_methods
+                    ):
+                        return ast.Await(value=node)
+                    return self.generic_visit(node)
+
+            AsyncCallTransformer().visit(new_tree)
+
+        ast.fix_missing_locations(new_tree)
+
+        return new_tree.body, extracted_args
+
+    def _generate_form_validation_methods(
+        self, parsed: ParsedPyWire, known_globals: Set[str]
+    ) -> List[ast.stmt]:
+        """Generate validation schema and wrapper methods for forms with @submit."""
+        methods: List[ast.stmt] = []
+        form_count = 0
+
+        def visit_nodes(nodes: List[TemplateNode]) -> None:
+            nonlocal form_count
+            for node in nodes:
+                # Check for form with @submit that has validation schema
+                if node.tag and node.tag.lower() == "form":
+                    for attr in node.special_attributes:
+                        if (
+                            isinstance(attr, EventAttribute)
+                            and attr.event_type == "submit"
+                        ):
+                            if attr.validation_schema and attr.validation_schema.fields:
+                                form_id = form_count
+                                form_count += 1
+
+                                # Generate validation schema as class attribute
+                                schema_name = f"_form_schema_{form_id}"
+                                original_handler = attr.handler_name
+
+                                # Build dict literal for schema fields
+                                schema_methods = self._generate_form_schema_literal(
+                                    attr.validation_schema, schema_name, known_globals
+                                )
+                                methods.extend(schema_methods)
+
+                                # Generate wrapper handler
+                                wrapper = self._generate_form_wrapper(
+                                    form_id,
+                                    original_handler,
+                                    schema_name,
+                                    attr.validation_schema,
+                                    known_globals,
+                                )
+                                methods.append(wrapper)
+
+                                # Update handler name to point to wrapper
+                                attr.handler_name = f"_form_submit_{form_id}"
+
+                # Recurse
+                visit_nodes(node.children)
+
+        visit_nodes(parsed.template)
+        return methods
+
+    def _generate_form_schema_literal(
+        self, schema: FormValidationSchema, schema_name: str, known_globals: Set[str]
+    ) -> List[ast.stmt]:
+        """Generate validation schema as a class attribute."""
+        field_items = []
+        for field_name, rules in schema.fields.items():
+            keywords = []
+
+            if rules.required:
+                keywords.append(
+                    ast.keyword(arg="required", value=ast.Constant(value=True))
+                )
+            if rules.required_expr:
+                expr_ast = self.template_codegen._transform_expr(
+                    rules.required_expr, set(), known_globals
+                )
+                expr_str = ast.unparse(expr_ast)
+                keywords.append(
+                    ast.keyword(arg="required_expr", value=ast.Constant(value=expr_str))
+                )
+            if rules.pattern:
+                keywords.append(
+                    ast.keyword(arg="pattern", value=ast.Constant(value=rules.pattern))
+                )
+            if rules.minlength is not None:
+                keywords.append(
+                    ast.keyword(
+                        arg="minlength", value=ast.Constant(value=rules.minlength)
+                    )
+                )
+            if rules.maxlength is not None:
+                keywords.append(
+                    ast.keyword(
+                        arg="maxlength", value=ast.Constant(value=rules.maxlength)
+                    )
+                )
+            if rules.min_value:
+                keywords.append(
+                    ast.keyword(
+                        arg="min_value", value=ast.Constant(value=rules.min_value)
+                    )
+                )
+            if rules.min_expr:
+                expr_ast = self.template_codegen._transform_expr(
+                    rules.min_expr, set(), known_globals
+                )
+                expr_str = ast.unparse(expr_ast)
+                keywords.append(
+                    ast.keyword(arg="min_expr", value=ast.Constant(value=expr_str))
+                )
+            if rules.max_value:
+                keywords.append(
+                    ast.keyword(
+                        arg="max_value", value=ast.Constant(value=rules.max_value)
+                    )
+                )
+            if rules.max_expr:
+                expr_ast = self.template_codegen._transform_expr(
+                    rules.max_expr, set(), known_globals
+                )
+                expr_str = ast.unparse(expr_ast)
+                keywords.append(
+                    ast.keyword(arg="max_expr", value=ast.Constant(value=expr_str))
+                )
+            if rules.step:
+                keywords.append(
+                    ast.keyword(arg="step", value=ast.Constant(value=rules.step))
+                )
+            if rules.input_type != "text":
+                keywords.append(
+                    ast.keyword(
+                        arg="input_type", value=ast.Constant(value=rules.input_type)
+                    )
+                )
+            if rules.title:
+                keywords.append(
+                    ast.keyword(arg="title", value=ast.Constant(value=rules.title))
+                )
+            if rules.max_size is not None:
+                keywords.append(
+                    ast.keyword(
+                        arg="max_size", value=ast.Constant(value=rules.max_size)
+                    )
+                )
+            if rules.allowed_types:
+                keywords.append(
+                    ast.keyword(
+                        arg="allowed_types",
+                        value=ast.List(
+                            elts=[ast.Constant(value=t) for t in rules.allowed_types],
+                            ctx=ast.Load(),
+                        ),
+                    )
+                )
+
+            field_rules_call = ast.Call(
+                func=ast.Name(id="FieldRules", ctx=ast.Load()),
+                args=[],
+                keywords=keywords,
+            )
+
+            field_items.append((ast.Constant(value=field_name), field_rules_call))
+
+        schema_dict = ast.Dict(
+            keys=[k for k, v in field_items], values=[v for k, v in field_items]
+        )
+
+        schema_call = ast.Call(
+            func=ast.Name(id="FormValidationSchema", ctx=ast.Load()),
+            args=[],
+            keywords=[ast.keyword(arg="fields", value=schema_dict)],
+        )
+
+        if schema.model_name:
+            schema_call.keywords.append(
+                ast.keyword(
+                    arg="model_name", value=ast.Constant(value=schema.model_name)
+                )
+            )
+
+        return [
+            ast.Assign(
+                targets=[ast.Name(id=schema_name, ctx=ast.Store())], value=schema_call
+            )
+        ]
+
+    def _generate_form_wrapper(
+        self,
+        form_id: int,
+        original_handler: str,
+        schema_name: str,
+        schema: FormValidationSchema,
+        known_globals: Set[str],
+    ) -> ast.AsyncFunctionDef:
+        """Generate wrapper handler that validates then calls original handler."""
+        wrapper_name = f"_form_submit_{form_id}"
+
+        # Generate:
+        # async def _form_submit_0(self, **kwargs):
+        #     form_data = kwargs.get('formData', {})
+        #
+        #     # Build state getter for conditional validation
+        #     def get_state(expr):
+        #         return eval(expr, {'self': self})
+        #
+        #     # Validate
+        #     self.errors = form_validator.validate_form(form_data, self._form_schema_0, get_state)
+        #     if self.errors:
+        #         return
+        #
+        #     # Call original handler
+        #     await self.original_handler(form_data)
+
+        body: List[ast.stmt] = []
+
+        # form_data = kwargs.get('formData', {})
+        body.append(
+            ast.Assign(
+                targets=[ast.Name(id="form_data", ctx=ast.Store())],
+                value=ast.Call(
+                    func=ast.Attribute(
+                        value=ast.Name(id="kwargs", ctx=ast.Load()),
+                        attr="get",
+                        ctx=ast.Load(),
+                    ),
+                    args=[ast.Constant(value="formData"), ast.Dict(keys=[], values=[])],
+                    keywords=[],
+                ),
+            )
+        )
+
+        # Define state getter for conditional validation
+        # def get_state(expr):
+        #     return eval(expr, {'self': self})
+        state_getter = ast.FunctionDef(
+            name="get_state",
+            args=ast.arguments(
+                posonlyargs=[],
+                args=[ast.arg(arg="expr")],
+                vararg=None,
+                kwonlyargs=[],
+                kw_defaults=[],
+                defaults=[],
+            ),
+            body=[
+                ast.Return(
+                    value=ast.Call(
+                        func=ast.Name(id="eval", ctx=ast.Load()),
+                        args=[
+                            ast.Name(id="expr", ctx=ast.Load()),
+                            # Use module globals (imports, classes)
+                            ast.Call(
+                                func=ast.Name(id="globals", ctx=ast.Load()),
+                                args=[],
+                                keywords=[],
+                            ),
+                            # Locals: just self, because _transform_expr converts other names
+                            # to self.x
+                            ast.Dict(
+                                keys=[ast.Constant(value="self")],
+                                values=[ast.Name(id="self", ctx=ast.Load())],
+                            ),
+                        ],
+                        keywords=[],
+                    )
+                )
+            ],
+            decorator_list=[],
+            returns=None,
+        )
+        body.append(state_getter)
+
+        # cleaned_data, self.errors = form_validator.validate_form(
+        #     form_data, self._form_schema_X.fields, get_state
+        # )
+        # Note: pass .fields from the schema object
+        body.append(
+            ast.Assign(
+                targets=[
+                    ast.Tuple(
+                        elts=[
+                            ast.Name(id="cleaned_data", ctx=ast.Store()),
+                            ast.Attribute(
+                                value=ast.Name(id="self", ctx=ast.Load()),
+                                attr="errors",
+                                ctx=ast.Store(),
+                            ),
+                        ],
+                        ctx=ast.Store(),
+                    )
+                ],
+                value=ast.Call(
+                    func=ast.Attribute(
+                        value=ast.Name(id="form_validator", ctx=ast.Load()),
+                        attr="validate_form",
+                        ctx=ast.Load(),
+                    ),
+                    args=[
+                        ast.Name(id="form_data", ctx=ast.Load()),
+                        ast.Attribute(
+                            value=ast.Attribute(
+                                value=ast.Name(id="self", ctx=ast.Load()),
+                                attr=schema_name,
+                                ctx=ast.Load(),
+                            ),
+                            attr="fields",
+                            ctx=ast.Load(),
+                        ),
+                        ast.Name(id="get_state", ctx=ast.Load()),
+                    ],
+                    keywords=[],
+                ),
+            )
+        )
+
+        # If Pydantic model is used:
+        # if not self.errors and self._form_schema_X.model_name:
+        #    model_instance, pydantic_errors = validate_with_model(
+        #        cleaned_data, globals()[self._form_schema_X.model_name]
+        #    )
+        #    if pydantic_errors:
+        #        self.errors.update(pydantic_errors)
+        #    else:
+        #        cleaned_data = model_instance # Replace dict with model instance
+
+        if schema.model_name:
+            pydantic_block: List[ast.stmt] = []
+
+            # model_instance, pydantic_errors = validate_with_model(cleaned_data, ModelClass)
+
+            # PARSE NESTED DATA FIRST
+            # nested_data = form_validator.parse_nested_data(cleaned_data)
+            pydantic_block.append(
+                ast.Assign(
+                    targets=[ast.Name(id="nested_data", ctx=ast.Store())],
+                    value=ast.Call(
+                        func=ast.Attribute(
+                            value=ast.Name(id="form_validator", ctx=ast.Load()),
+                            attr="parse_nested_data",
+                            ctx=ast.Load(),
+                        ),
+                        args=[ast.Name(id="cleaned_data", ctx=ast.Load())],
+                        keywords=[],
+                    ),
+                )
+            )
+
+            validate_call = ast.Call(
+                func=ast.Name(id="validate_with_model", ctx=ast.Load()),
+                args=[
+                    ast.Name(id="nested_data", ctx=ast.Load()),
+                    ast.Name(id=schema.model_name, ctx=ast.Load()),
+                ],
+                keywords=[],
+            )
+
+            pydantic_block.append(
+                ast.Assign(
+                    targets=[
+                        ast.Tuple(
+                            elts=[
+                                ast.Name(id="model_instance", ctx=ast.Store()),
+                                ast.Name(id="pydantic_errors", ctx=ast.Store()),
+                            ],
+                            ctx=ast.Store(),
+                        )
+                    ],
+                    value=validate_call,
+                )
+            )
+
+            # if pydantic_errors: self.errors.update(pydantic_errors)
+            # else: cleaned_data = model_instance
+            pydantic_block.append(
+                ast.If(
+                    test=ast.Name(id="pydantic_errors", ctx=ast.Load()),
+                    body=[
+                        ast.Expr(
+                            value=ast.Call(
+                                func=ast.Attribute(
+                                    value=ast.Attribute(
+                                        value=ast.Name(id="self", ctx=ast.Load()),
+                                        attr="errors",
+                                        ctx=ast.Load(),
+                                    ),
+                                    attr="update",
+                                    ctx=ast.Load(),
+                                ),
+                                args=[ast.Name(id="pydantic_errors", ctx=ast.Load())],
+                                keywords=[],
+                            )
+                        )
+                    ],
+                    orelse=[
+                        ast.Assign(
+                            targets=[ast.Name(id="cleaned_data", ctx=ast.Store())],
+                            value=ast.Name(id="model_instance", ctx=ast.Load()),
+                        )
+                    ],
+                )
+            )
+
+            # Wrap in check: if not self.errors:
+            body.append(
+                ast.If(
+                    test=ast.UnaryOp(
+                        op=ast.Not(),
+                        operand=ast.Attribute(
+                            value=ast.Name(id="self", ctx=ast.Load()),
+                            attr="errors",
+                            ctx=ast.Load(),
+                        ),
+                    ),
+                    body=pydantic_block,
+                    orelse=[],
+                )
+            )
+
+        # if self.errors: return
+        body.append(
+            ast.If(
+                test=ast.Attribute(
+                    value=ast.Name(id="self", ctx=ast.Load()),
+                    attr="errors",
+                    ctx=ast.Load(),
+                ),
+                body=[ast.Return(value=None)],
+                orelse=[],
+            )
+        )
+
+        # Call original handler - need to check if it's async
+        handler_call = ast.Call(
+            func=ast.Attribute(
+                value=ast.Name(id="self", ctx=ast.Load()),
+                attr=original_handler,
+                ctx=ast.Load(),
+            ),
+            args=[ast.Name(id="cleaned_data", ctx=ast.Load())],
+            keywords=[],
+        )
+
+        # Assume async for safety - await it
+        body.append(ast.Expr(value=ast.Await(value=handler_call)))
+
+        return ast.AsyncFunctionDef(
+            name=wrapper_name,
+            args=ast.arguments(
+                posonlyargs=[],
+                args=[ast.arg(arg="self")],
+                vararg=None,
+                kwonlyargs=[],
+                kw_defaults=[],
+                kwarg=ast.arg(arg="kwargs"),
+                defaults=[],
+            ),
+            body=body,
+            decorator_list=[],
+            returns=None,
+        )
+
+    def _generate_spa_metadata(self, parsed: ParsedPyWire) -> List[ast.stmt]:
+        """Generate __spa_enabled__ and __sibling_paths__ class attributes."""
+        stmts: List[ast.stmt] = []
+
+        # Get path directive
+        path_directive = cast(
+            Optional[PathDirective], parsed.get_directive_by_type(PathDirective)
+        )
+        if path_directive:
+            # assert isinstance(path_directive, PathDirective)
+            pass
+        is_multi_path = path_directive and not path_directive.is_simple_string
+
+        # Check for !no_spa directive
+        no_spa = parsed.get_directive_by_type(NoSpaDirective) is not None
+
+        # SPA is enabled for multi-path pages unless !no_spa is present
+        spa_enabled = is_multi_path and not no_spa
+
+        # __spa_enabled__ = True/False
+        stmts.append(
+            ast.Assign(
+                targets=[ast.Name(id="__spa_enabled__", ctx=ast.Store())],
+                value=ast.Constant(value=bool(spa_enabled)),
+            )
+        )
+
+        # __sibling_paths__ = ['/path1', '/path2', ...]
+        if path_directive and not path_directive.is_simple_string:
+            paths = list(path_directive.routes.values())
+        else:
+            paths = []
+
+        stmts.append(
+            ast.Assign(
+                targets=[ast.Name(id="__sibling_paths__", ctx=ast.Store())],
+                value=ast.List(
+                    elts=[ast.Constant(value=p) for p in paths], ctx=ast.Load()
+                ),
+            )
+        )
+
+        # Inject __file_path__ for hot reload route cleanup
+        if parsed.file_path:
+            stmts.append(
+                ast.Assign(
+                    targets=[ast.Name(id="__file_path__", ctx=ast.Store())],
+                    value=ast.Constant(value=str(parsed.file_path)),
+                )
+            )
+
+        return stmts
+
+    def _get_class_name(self, parsed: ParsedPyWire) -> str:
+        """Generate class name from file path."""
+        if not parsed.file_path:
+            return "Page"
+
+        from pathlib import Path
+
+        path = Path(parsed.file_path)
+        # Convert pages/index.pywire -> IndexPage
+        name = path.stem
+        return "".join(word.capitalize() for word in name.split("_")) + "Page"
+
+    def _generate_init_method(self, parsed: ParsedPyWire) -> ast.FunctionDef:
+        """Generate __init__ method."""
+        # Base init args
+        init_args = [
+            ast.arg(arg="self"),
+            ast.arg(arg="request"),
+            ast.arg(arg="params"),
+            ast.arg(arg="query"),
+            ast.arg(arg="path"),
+            ast.arg(arg="url"),
+        ]
+        defaults: List[ast.expr] = [ast.Constant(value=None), ast.Constant(value=None)]
+        props_assigns: List[ast.stmt] = []
+
+        # Handle Props directive
+        props_directive = parsed.get_directive_by_type(PropsDirective)
+        if props_directive:
+            assert isinstance(props_directive, PropsDirective)
+            # !props(name: type, arg=default)
+            # Add to init_args
+            for name, type_hint, default_val in props_directive.args:
+                # Annotation
+                annotation = (
+                    ast.parse(type_hint, mode="eval").body if type_hint else None
+                )
+
+                # Default
+                if default_val is not None:
+                    # Parse default value expr
+                    defaults.append(ast.parse(default_val, mode="eval").body)
+                else:
+                    # No default: must come before args with defaults?
+                    # Standard python rules: non-default args first.
+                    # But we are appending AFTER request/params etc which DON'T have defaults
+                    # (except path/url which do)
+                    # Wait, request, params, query don't have defaults in base method signature
+                    # we generated before:
+                    # args=[arg('self'), arg('request')...]
+                    # defaults=[None, None] (for path/url?)
+
+                    # Actually standard signature above was:
+                    # args: self, request, params, query, path, url
+                    # defaults: path=None, url=None
+
+                    # So if we add a non-default prop after 'url=None', it's invalid syntax.
+                    # "non-default argument follows default argument"
+
+                    # Strategy: Make ALL props keyword-only or ensure order?
+                    # Components are instantiated with kwargs mostly?
+                    # Or we just add them to the end and expect users to provide defaults if we
+                    # have defaults before?
+                    # Simpler: Make them keyword arguments (kwonlyargs).
+                    pass
+
+            # Implementation: Use kwonlyargs for props to avoid mess with positional defaults
+            kwonlyargs: List[ast.arg] = []
+            kw_defaults: List[Optional[ast.expr]] = []
+
+            for name, type_hint, default_val in props_directive.args:
+                annotation = (
+                    ast.parse(type_hint, mode="eval").body if type_hint else None
+                )
+                kwonlyargs.append(ast.arg(arg=name, annotation=annotation))
+
+                if default_val is not None:
+                    kw_defaults.append(ast.parse(default_val, mode="eval").body)
+                else:
+                    kw_defaults.append(None)  # Required kwarg
+
+                # Assign to self
+                # self.name = name
+                props_assigns.append(
+                    ast.Assign(
+                        targets=[
+                            ast.Attribute(
+                                value=ast.Name(id="self", ctx=ast.Load()),
+                                attr=name,
+                                ctx=ast.Store(),
+                            )
+                        ],
+                        value=ast.Name(id=name, ctx=ast.Load()),
+                    )
+                )
+
+        else:
+            kwonlyargs = []
+            kw_defaults = []
+
+        body: List[ast.stmt] = [
+            ast.Expr(
+                value=ast.Call(
+                    func=ast.Attribute(
+                        value=ast.Call(
+                            func=ast.Name(id="super", ctx=ast.Load()),
+                            args=[],
+                            keywords=[],
+                        ),
+                        attr="__init__",
+                        ctx=ast.Load(),
+                    ),
+                    args=[
+                        ast.Name(id="request", ctx=ast.Load()),
+                        ast.Name(id="params", ctx=ast.Load()),
+                        ast.Name(id="query", ctx=ast.Load()),
+                        ast.Name(id="path", ctx=ast.Load()),
+                        ast.Name(id="url", ctx=ast.Load()),
+                    ],
+                    keywords=[
+                        ast.keyword(
+                            arg=None, value=ast.Name(id="kwargs", ctx=ast.Load())
+                        )
+                    ],
+                )
+            )
+        ]
+
+        # Add prop assignments
+        body.extend(props_assigns)
+
+        # NOTE: !provide is now handled in _generate_render_template_method to ensure reactivity
+
+        # Handle !inject - retrieve values from context
+        inject_directive = parsed.get_directive_by_type(InjectDirective)
+        if inject_directive:
+            assert isinstance(inject_directive, InjectDirective)
+            # self.local_var = self.context.get('GLOBAL_KEY')
+            for local_var, global_key in inject_directive.mapping.items():
+                body.append(
+                    ast.Assign(
+                        targets=[
+                            ast.Attribute(
+                                value=ast.Name(id="self", ctx=ast.Load()),
+                                attr=local_var,
+                                ctx=ast.Store(),
+                            )
+                        ],
+                        value=ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Attribute(
+                                    value=ast.Name(id="self", ctx=ast.Load()),
+                                    attr="context",
+                                    ctx=ast.Load(),
+                                ),
+                                attr="get",
+                                ctx=ast.Load(),
+                            ),
+                            args=[ast.Constant(value=global_key)],
+                            keywords=[],
+                        ),
+                    )
+                )
+
+        # Call _init_slots
+        body.append(
+            ast.Expr(
+                value=ast.Call(
+                    func=ast.Attribute(
+                        value=ast.Name(id="self", ctx=ast.Load()),
+                        attr="_init_slots",
+                        ctx=ast.Load(),
+                    ),
+                    args=[],
+                    keywords=[],
+                )
+            )
+        )
+
+        # Call __top_level_init__ if it exists (for wire() and mutable init)
+        if hasattr(self, "_has_top_level_init") and self._has_top_level_init:
+            body.append(
+                ast.Expr(
+                    value=ast.Call(
+                        func=ast.Attribute(
+                            value=ast.Name(id="self", ctx=ast.Load()),
+                            attr="__top_level_init__",
+                            ctx=ast.Load(),
+                        ),
+                        args=[],
+                        keywords=[],
+                    )
+                )
+            )
+
+        return ast.FunctionDef(
+            name="__init__",
+            args=ast.arguments(
+                posonlyargs=[],
+                args=init_args,
+                vararg=None,
+                kwonlyargs=kwonlyargs,
+                kw_defaults=kw_defaults,
+                kwarg=ast.arg(arg="kwargs", annotation=None),
+                defaults=defaults,
+            ),
+            body=body,
+            decorator_list=[],
+            returns=None,
+        )
+
+    def _transform_user_code(
+        self, python_ast: ast.Module, known_globals: Optional[Set[str]] = None
+    ) -> List[ast.stmt]:
+        """Transform user Python code to class methods/attributes."""
+        transformed: List[ast.stmt] = []
+        if known_globals is None:
+            known_globals = set()
+
+        # Collect hooks
+        self._collected_mount_hooks = []
+        self._has_top_level_init = False
+
+        top_level_statements: List[ast.stmt] = []
+
+        for node in python_ast.body:
+            if isinstance(node, (ast.Import, ast.ImportFrom)):
+                # Skip imports - already handled
+                continue
+            elif isinstance(node, ast.Assign):
+                # Module-level assignments become class attributes
+                # UNLESS they target 'self' (e.g. self.x = 1), which makes no sense at class level
+                # and implies instance initialization.
+
+                is_instance_assign = False
+                for target in node.targets:
+                    # Check if target is Attribute(value=Name(id='self'))
+                    if (
+                        isinstance(target, ast.Attribute)
+                        and isinstance(target.value, ast.Name)
+                        and target.value.id == "self"
+                    ):
+                        is_instance_assign = True
+                        break
+
+                # Also check if value is a Call (like wire()) or mutable structure.
+                # These should be instance-level to avoid shared state.
+                is_mutable_init = isinstance(
+                    node.value,
+                    (
+                        ast.Call,
+                        ast.List,
+                        ast.Dict,
+                        ast.Set,
+                        ast.ListComp,
+                        ast.DictComp,
+                        ast.SetComp,
+                    ),
+                )
+
+                if is_instance_assign or is_mutable_init:
+                    top_level_statements.append(node)
+                else:
+                    # Simple literals (int, str) stay class attributes
+                    transformed.append(node)
+
+            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                # Check for decorators
+                new_decorators = []
+                for dec in node.decorator_list:
+                    if isinstance(dec, ast.Name) and dec.id == "mount":
+                        self._collected_mount_hooks.append(node.name)
+                    elif isinstance(dec, ast.Name) and dec.id == "unmount":
+                        # Placeholder for future unmount
+                        pass
+                    else:
+                        new_decorators.append(dec)
+
+                node.decorator_list = new_decorators
+
+                # Functions become methods - transform them
+                transformed.append(self._transform_to_method(node, known_globals))
+            elif isinstance(node, ast.ClassDef):
+                # Classes are moved to module level, skip here
+                continue
+            else:
+                # Other statements (Expr, If, For, While, Try)
+                # Move to top-level init
+                top_level_statements.append(node)
+
+        if top_level_statements:
+            self._has_top_level_init = True
+            transformed.append(
+                self._generate_top_level_init(top_level_statements, known_globals)
+            )
+
+        return transformed
+
+    def _generate_top_level_init(
+        self, statements: List[ast.stmt], known_globals: Set[str]
+    ) -> ast.FunctionDef:
+        """Generate __top_level_init__ method from top-level statements."""
+
+        # 1. Collect all variables assigned in this scope to promote them to instance attributes.
+        # This ensures 'x = 1' inside match/if/for becomes 'self.x = 1'.
+        local_assignments = set()
+
+        class AssignmentCollector(ast.NodeVisitor):
+            def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+                # Do not recurse into nested functions
+                pass
+
+            def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+                pass
+
+            def visit_ClassDef(self, node: ast.ClassDef) -> None:
+                pass
+
+            def visit_Name(self, node: ast.Name) -> None:
+                # If name is being stored (assigned to), collect it
+                if isinstance(node.ctx, ast.Store):
+                    local_assignments.add(node.id)
+
+        collector = AssignmentCollector()
+        for stmt in statements:
+            collector.visit(stmt)
+
+        # Combine with explicit known globals
+        # We start with a copy to avoid mutating the passed set if it's used elsewhere
+        # (though it seems local usually)
+        combined_globals = set(known_globals)
+        combined_globals.update(local_assignments)
+
+        # Wrap statements in sync method (must be sync for __init__)
+        # Transform variables to self.X
+
+        wrapper = ast.FunctionDef(
+            name="__top_level_init__",
+            args=ast.arguments(
+                posonlyargs=[],
+                args=[ast.arg(arg="self")],
+                vararg=None,
+                kwonlyargs=[],
+                kw_defaults=[],
+                defaults=[],
+            ),
+            body=statements,
+            decorator_list=[],
+            returns=None,
+        )
+
+        return cast(
+            ast.FunctionDef, self._transform_to_method(wrapper, combined_globals)
+        )
+
+    def _transform_to_method(
+        self, node: Any, known_methods: Optional[Set[str]] = None
+    ) -> Any:
+        """Transform a function into a method (add self, handle globals)."""
+        # 1. Add self argument if not present
+        if not (node.args.args and node.args.args[0].arg == "self"):
+            node.args.args.insert(0, ast.arg(arg="self"))
+
+        # 2. Find global declarations and include known methods
+        global_vars = set()
+        if known_methods:
+            global_vars.update(known_methods)
+
+        new_body = []
+        for stmt in node.body:
+            if isinstance(stmt, ast.Global):
+                global_vars.update(stmt.names)
+            else:
+                new_body.append(stmt)
+
+        node.body = new_body
+
+        # 3. Transform variable access
+        if global_vars:
+
+            class GlobalToSelf(ast.NodeTransformer):
+                def visit_Name(self, n: ast.Name) -> ast.AST:
+                    if n.id in global_vars:
+                        return ast.Attribute(
+                            value=ast.Name(id="self", ctx=ast.Load()),
+                            attr=n.id,
+                            ctx=n.ctx,
+                        )
+                    return n
+
+            # Apply transformation
+            transformer = GlobalToSelf()
+            for i, stmt in enumerate(node.body):
+                node.body[i] = transformer.visit(stmt)
+
+            # Fix locations
+            for stmt in node.body:
+                ast.fix_missing_locations(stmt)
+
+        return node
+
+    def _generate_render_method(self) -> ast.AsyncFunctionDef:
+        """Generate render method."""
+        return ast.AsyncFunctionDef(
+            name="render",
+            args=ast.arguments(
+                posonlyargs=[],
+                args=[ast.arg(arg="self")],
+                vararg=None,
+                kwonlyargs=[],
+                kw_defaults=[],
+                defaults=[],
+            ),
+            body=[
+                ast.Return(
+                    value=ast.Call(
+                        func=ast.Name(id="Response", ctx=ast.Load()),
+                        args=[
+                            ast.Await(
+                                value=ast.Call(
+                                    func=ast.Attribute(
+                                        value=ast.Name(id="self", ctx=ast.Load()),
+                                        attr="_render_template",
+                                        ctx=ast.Load(),
+                                    ),
+                                    args=[],
+                                    keywords=[],
+                                )
+                            )
+                        ],
+                        keywords=[
+                            ast.keyword(
+                                arg="media_type", value=ast.Constant(value="text/html")
+                            )
+                        ],
+                    )
+                )
+            ],
+            decorator_list=[],
+            returns=None,
+        )
+
+    def _generate_render_template_method(
+        self,
+        parsed: ParsedPyWire,
+        known_methods: Optional[Set[str]] = None,
+        known_globals: Optional[Set[str]] = None,
+        async_methods: Optional[Set[str]] = None,
+        component_map: Optional[Dict[str, str]] = None,
+    ) -> Tuple[
+        Optional[Union[ast.FunctionDef, ast.AsyncFunctionDef]],
+        List[ast.stmt],
+    ]:
+        """Generate _render_template method and binding/slot handlers."""
+        if component_map is None:
+            component_map = {}
+        # Check for layout
+        layout_directive = parsed.get_directive_by_type(LayoutDirective)
+        if layout_directive:
+            # assert isinstance(layout_directive, LayoutDirective) # Mypy narrowing issue
+            pass
+
+        binding_funcs: List[ast.stmt] = []
+        render_func = None
+
+        if layout_directive:
+            layout_directive = cast(LayoutDirective, layout_directive)
+            # === Layout Mode ===
+            file_id = parsed.file_path or ""
+
+            # Ensure layout_id is generated for intermediate layouts
+            import hashlib
+
+            layout_id = (
+                hashlib.md5(str(parsed.file_path).encode()).hexdigest()
+                if parsed.file_path
+                else None
+            )
+
+            slot_funcs_methods, aux_funcs = self.template_codegen.generate_slot_methods(
+                parsed.template,
+                file_id=file_id,
+                known_globals=known_globals,
+                layout_id=layout_id,
+                component_map=component_map,
+            )
+
+            file_hash = hashlib.md5(file_id.encode()).hexdigest()[:8] if file_id else ""
+
+            # Add slot methods directly (they are ASTs now)
+            for slot_name, func_ast in slot_funcs_methods.items():
+                binding_funcs.append(func_ast)
+
+            # Add aux funcs
+            binding_funcs.extend(aux_funcs)
+
+            # Generate _init_slots
+
+            # Resolve parent layout path
+            from pathlib import Path
+
+            parent_layout_path = layout_directive.layout_path
+            if not Path(parent_layout_path).is_absolute():
+                base_dir = (
+                    Path(parsed.file_path).parent if parsed.file_path else Path.cwd()
+                )
+                parent_layout_path = str((base_dir / parent_layout_path).resolve())
+            else:
+                parent_layout_path = str(Path(parent_layout_path).resolve())
+
+            def make_parent_layout_id() -> ast.Constant:
+                import hashlib
+
+                parent_hash = hashlib.md5(parent_layout_path.encode()).hexdigest()
+                return ast.Constant(value=parent_hash)
+
+            init_slots_body: List[ast.stmt] = []
+
+            # Chain super
+            super_check = ast.If(
+                test=ast.Call(
+                    func=ast.Name(id="hasattr", ctx=ast.Load()),
+                    args=[
+                        ast.Call(
+                            func=ast.Name(id="super", ctx=ast.Load()),
+                            args=[],
+                            keywords=[],
+                        ),
+                        ast.Constant(value="_init_slots"),
+                    ],
+                    keywords=[],
+                ),
+                body=[
+                    ast.Expr(
+                        value=ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Call(
+                                    func=ast.Name(id="super", ctx=ast.Load()),
+                                    args=[],
+                                    keywords=[],
+                                ),
+                                attr="_init_slots",
+                                ctx=ast.Load(),
+                            ),
+                            args=[],
+                            keywords=[],
+                        )
+                    )
+                ],
+                orelse=[],
+            )
+            init_slots_body.append(super_check)
+
+            for slot_name in slot_funcs_methods.keys():
+                safe_name = (
+                    slot_name.replace("$", "_head_").replace("-", "_")
+                    if slot_name.startswith("$")
+                    else slot_name.replace("-", "_")
+                )
+                func_name = (
+                    f"_render_slot_fill_{safe_name}_{file_hash}"
+                    if file_hash
+                    else f"_render_slot_fill_{safe_name}"
+                )
+
+                if slot_name == "$head":
+                    reg_call = ast.Expr(
+                        value=ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Name(id="self", ctx=ast.Load()),
+                                attr="register_head_slot",
+                                ctx=ast.Load(),
+                            ),
+                            args=[
+                                make_parent_layout_id(),
+                                ast.Attribute(
+                                    value=ast.Name(id="self", ctx=ast.Load()),
+                                    attr=func_name,
+                                    ctx=ast.Load(),
+                                ),
+                            ],
+                            keywords=[],
+                        )
+                    )
+                else:
+                    reg_call = ast.Expr(
+                        value=ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Name(id="self", ctx=ast.Load()),
+                                attr="register_slot",
+                                ctx=ast.Load(),
+                            ),
+                            args=[
+                                make_parent_layout_id(),
+                                ast.Constant(value=slot_name),
+                                ast.Attribute(
+                                    value=ast.Name(id="self", ctx=ast.Load()),
+                                    attr=func_name,
+                                    ctx=ast.Load(),
+                                ),
+                            ],
+                            keywords=[],
+                        )
+                    )
+                init_slots_body.append(reg_call)
+
+            init_slots_func = ast.FunctionDef(
+                name="_init_slots",
+                args=ast.arguments(
+                    posonlyargs=[],
+                    args=[ast.arg(arg="self")],
+                    vararg=None,
+                    kwonlyargs=[],
+                    kw_defaults=[],
+                    defaults=[],
+                ),
+                body=init_slots_body,
+                decorator_list=[],
+                returns=None,
+            )
+            binding_funcs.append(init_slots_func)
+
+            # Handle !provide - Override render() to update context before layout rendering
+            provide_directive = cast(
+                Optional[ProvideDirective],
+                parsed.get_directive_by_type(ProvideDirective),
+            )
+            if provide_directive:
+                provide_body: List[ast.stmt] = []
+                for key, val_expr in provide_directive.mapping.items():
+                    val_ast = self.template_codegen._transform_expr(
+                        val_expr, set(), known_globals
+                    )
+                    provide_body.append(
+                        ast.Assign(
+                            targets=[
+                                ast.Subscript(
+                                    value=ast.Attribute(
+                                        value=ast.Name(id="self", ctx=ast.Load()),
+                                        attr="context",
+                                        ctx=ast.Load(),
+                                    ),
+                                    slice=ast.Constant(value=key),
+                                    ctx=ast.Store(),
+                                )
+                            ],
+                            value=val_ast,
+                        )
+                    )
+
+                # return await super().render(init)
+                render_call = ast.Call(
+                    func=ast.Attribute(
+                        value=ast.Call(
+                            func=ast.Name(id="super", ctx=ast.Load()),
+                            args=[],
+                            keywords=[],
+                        ),
+                        attr="render",
+                        ctx=ast.Load(),
+                    ),
+                    args=[ast.Name(id="init", ctx=ast.Load())],
+                    keywords=[],
+                )
+                provide_body.append(ast.Return(value=ast.Await(value=render_call)))
+
+                render_override = ast.AsyncFunctionDef(
+                    name="render",
+                    args=ast.arguments(
+                        posonlyargs=[],
+                        args=[
+                            ast.arg(arg="self"),
+                            ast.arg(
+                                arg="init",
+                                annotation=ast.Name(id="bool", ctx=ast.Load()),
+                            ),
+                        ],
+                        vararg=None,
+                        kwonlyargs=[],
+                        kw_defaults=[],
+                        defaults=[ast.Constant(value=True)],
+                    ),
+                    body=provide_body,
+                    decorator_list=[],
+                    returns=None,
+                )
+                binding_funcs.append(render_override)
+
+        else:
+            # === Standard Mode ===
+            # We no longer aggressively generate layout_id/scope_id for everything
+            # to avoid breaking existing tests.
+            layout_id = None
+            scope_id = None
+
+            if parsed.file_path:
+                import hashlib
+
+                layout_id_hash = hashlib.md5(str(parsed.file_path).encode()).hexdigest()
+                # Use as layout_id if we have slots to fill for ourselves (as a component)
+                # Or for scoping if <style scoped> is present
+                has_scoped_style = any(
+                    n.tag == "style" and "scoped" in n.attributes
+                    for n in parsed.template
+                )
+                if has_scoped_style:
+                    scope_id = layout_id_hash[:8]
+
+                # If we are a layout (referenced by others), we should have a LAYOUT_ID.
+                # But we don't know if we ARE a layout here.
+                # We'll assume if there are <slot> tags, we might be a layout.
+                has_slots = self._has_slots_recursive(parsed.template)
+                if has_slots:
+                    layout_id = layout_id_hash
+
+            # Extract Props to Unpack
+
+            prop_names = set()
+            props_unpack_stmts = []
+
+            # Using imported PropsDirective from earlier context or get it again
+            # We are inside the method, 'parsed' is available.
+            props_directive = cast(
+                Optional[PropsDirective], parsed.get_directive_by_type(PropsDirective)
+            )
+            if props_directive:
+                for name, _, _ in props_directive.args:
+                    prop_names.add(name)
+                    # prop = self.prop
+                    props_unpack_stmts.append(
+                        ast.Assign(
+                            targets=[ast.Name(id=name, ctx=ast.Store())],
+                            value=ast.Attribute(
+                                value=ast.Name(id="self", ctx=ast.Load()),
+                                attr=name,
+                                ctx=ast.Load(),
+                            ),
+                        )
+                    )
+
+            render_func, aux_funcs = self.template_codegen.generate_render_method(
+                parsed.template,
+                layout_id=layout_id or "",
+                known_methods=known_methods,
+                known_globals=known_globals,
+                async_methods=async_methods,
+                component_map=component_map,
+                scope_id=scope_id,
+                initial_locals=prop_names,
+            )
+
+            # Prepend unpack statements to render_func body
+            if render_func and props_unpack_stmts:
+                render_func.body[0:0] = props_unpack_stmts
+
+            # Handle !provide - Update context values at start of render to catch state changes
+            provide_directive = cast(
+                Optional[ProvideDirective],
+                parsed.get_directive_by_type(ProvideDirective),
+            )
+            if provide_directive and render_func:
+                provide_stmts = []
+                for key, val_expr in provide_directive.mapping.items():
+                    # Transform expression using known globals for this page scope
+                    # Note: val_expr is string. We need to parse it or use transform helper.
+
+                    val_ast = self.template_codegen._transform_expr(
+                        val_expr, set(), known_globals
+                    )
+
+                    provide_stmts.append(
+                        ast.Assign(
+                            targets=[
+                                ast.Subscript(
+                                    value=ast.Attribute(
+                                        value=ast.Name(id="self", ctx=ast.Load()),
+                                        attr="context",
+                                        ctx=ast.Load(),
+                                    ),
+                                    slice=ast.Constant(value=key),
+                                    ctx=ast.Store(),
+                                )
+                            ],
+                            value=val_ast,
+                        )
+                    )
+
+                # Insert after props unpacking (if any)
+                insert_idx = len(props_unpack_stmts) if props_unpack_stmts else 0
+                render_func.body[insert_idx:insert_idx] = provide_stmts
+
+            binding_funcs.extend(aux_funcs)
+
+            # SPA injection
+            # (path_directive search removed if unused)
+
+            # Determine injection point (before final return)
+
+            spa_check = ast.If(
+                test=ast.BoolOp(
+                    op=ast.And(),
+                    values=[
+                        ast.UnaryOp(
+                            op=ast.Not(),
+                            operand=ast.Call(
+                                func=ast.Name(id="getattr", ctx=ast.Load()),
+                                args=[
+                                    ast.Name(id="self", ctx=ast.Load()),
+                                    ast.Constant(value="__no_spa__"),
+                                    ast.Constant(value=False),
+                                ],
+                                keywords=[],
+                            ),
+                        ),
+                        ast.UnaryOp(
+                            op=ast.Not(),
+                            operand=ast.Call(
+                                func=ast.Name(id="getattr", ctx=ast.Load()),
+                                args=[
+                                    ast.Name(id="self", ctx=ast.Load()),
+                                    ast.Constant(value="__is_component__"),
+                                    ast.Constant(value=False),
+                                ],
+                                keywords=[],
+                            ),
+                        ),
+                        ast.BoolOp(
+                            op=ast.Or(),
+                            values=[
+                                ast.Call(
+                                    func=ast.Name(id="getattr", ctx=ast.Load()),
+                                    args=[
+                                        ast.Name(id="self", ctx=ast.Load()),
+                                        ast.Constant(value="__spa_enabled__"),
+                                        ast.Constant(value=False),
+                                    ],
+                                    keywords=[],
+                                ),
+                                ast.Call(
+                                    func=ast.Name(id="getattr", ctx=ast.Load()),
+                                    args=[
+                                        ast.Attribute(
+                                            value=ast.Attribute(
+                                                value=ast.Attribute(
+                                                    value=ast.Name(
+                                                        id="self", ctx=ast.Load()
+                                                    ),
+                                                    attr="request",
+                                                    ctx=ast.Load(),
+                                                ),
+                                                attr="app",
+                                                ctx=ast.Load(),
+                                            ),
+                                            attr="state",
+                                            ctx=ast.Load(),
+                                        ),
+                                        ast.Constant(value="enable_pjax"),
+                                        ast.Constant(value=False),
+                                    ],
+                                    keywords=[],
+                                ),
+                            ],
+                        ),
+                    ],
+                ),
+                body=[
+                    # sibling_paths = ...
+                    ast.Assign(
+                        targets=[ast.Name(id="sibling_paths", ctx=ast.Store())],
+                        value=ast.Call(
+                            func=ast.Name(id="getattr", ctx=ast.Load()),
+                            args=[
+                                ast.Name(id="self", ctx=ast.Load()),
+                                ast.Constant(value="__sibling_paths__"),
+                                ast.List(elts=[], ctx=ast.Load()),
+                            ],
+                            keywords=[],
+                        ),
+                    ),
+                    # pjax_enabled = ...
+                    ast.Assign(
+                        targets=[ast.Name(id="pjax_enabled", ctx=ast.Store())],
+                        value=ast.Call(
+                            func=ast.Name(id="getattr", ctx=ast.Load()),
+                            args=[
+                                ast.Attribute(
+                                    value=ast.Attribute(
+                                        value=ast.Attribute(
+                                            value=ast.Name(id="self", ctx=ast.Load()),
+                                            attr="request",
+                                            ctx=ast.Load(),
+                                        ),
+                                        attr="app",
+                                        ctx=ast.Load(),
+                                    ),
+                                    attr="state",
+                                    ctx=ast.Load(),
+                                ),
+                                ast.Constant(value="enable_pjax"),
+                                ast.Constant(value=False),
+                            ],
+                            keywords=[],
+                        ),
+                    ),
+                    # debug = ...
+                    ast.Assign(
+                        targets=[ast.Name(id="debug", ctx=ast.Store())],
+                        value=ast.Call(
+                            func=ast.Name(id="getattr", ctx=ast.Load()),
+                            args=[
+                                ast.Attribute(
+                                    value=ast.Attribute(
+                                        value=ast.Attribute(
+                                            value=ast.Name(id="self", ctx=ast.Load()),
+                                            attr="request",
+                                            ctx=ast.Load(),
+                                        ),
+                                        attr="app",
+                                        ctx=ast.Load(),
+                                    ),
+                                    attr="state",
+                                    ctx=ast.Load(),
+                                ),
+                                ast.Constant(value="debug"),
+                                ast.Constant(value=False),
+                            ],
+                            keywords=[],
+                        ),
+                    ),
+                    # parts.append(script tag)
+                    ast.Expr(
+                        value=ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Name(id="parts", ctx=ast.Load()),
+                                attr="append",
+                                ctx=ast.Load(),
+                            ),
+                            args=[
+                                ast.Constant(
+                                    value='<script id="_pywire_spa_meta" type="application/json">'
+                                )
+                            ],
+                            keywords=[],
+                        )
+                    ),
+                    # parts.append(json.dumps(...))
+                    ast.Expr(
+                        value=ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Name(id="parts", ctx=ast.Load()),
+                                attr="append",
+                                ctx=ast.Load(),
+                            ),
+                            args=[
+                                ast.Call(
+                                    func=ast.Attribute(
+                                        value=ast.Name(id="json", ctx=ast.Load()),
+                                        attr="dumps",
+                                        ctx=ast.Load(),
+                                    ),
+                                    args=[
+                                        ast.Dict(
+                                            keys=[
+                                                ast.Constant(value="sibling_paths"),
+                                                ast.Constant(value="enable_pjax"),
+                                                ast.Constant(value="debug"),
+                                            ],
+                                            values=[
+                                                ast.Name(
+                                                    id="sibling_paths", ctx=ast.Load()
+                                                ),
+                                                ast.Name(
+                                                    id="pjax_enabled", ctx=ast.Load()
+                                                ),
+                                                ast.Name(id="debug", ctx=ast.Load()),
+                                            ],
+                                        )
+                                    ],
+                                    keywords=[],
+                                )
+                            ],
+                            keywords=[],
+                        )
+                    ),
+                    ast.Expr(
+                        value=ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Name(id="parts", ctx=ast.Load()),
+                                attr="append",
+                                ctx=ast.Load(),
+                            ),
+                            args=[ast.Constant(value="</script>")],
+                            keywords=[],
+                        )
+                    ),
+                    ast.Expr(
+                        value=ast.Call(
+                            func=ast.Attribute(
+                                value=ast.Name(id="parts", ctx=ast.Load()),
+                                attr="append",
+                                ctx=ast.Load(),
+                            ),
+                            args=[
+                                ast.JoinedStr(
+                                    values=[
+                                        ast.Constant(value='<script src="'),
+                                        ast.FormattedValue(
+                                            value=ast.Call(
+                                                func=cast(
+                                                    ast.Expr,
+                                                    ast.parse(
+                                                        "self.request.app.state.pywire._get_client_script_url"
+                                                    ).body[0],
+                                                ).value,
+                                                args=[],
+                                                keywords=[],
+                                            ),
+                                            conversion=-1,
+                                            format_spec=None,
+                                        ),
+                                        ast.Constant(value='"></script>'),
+                                    ]
+                                )
+                            ],
+                            keywords=[],
+                        )
+                    ),
+                ],
+                orelse=[],
+            )
+
+            # Insert before last statement
+            if render_func.body and isinstance(render_func.body[-1], ast.Return):
+                render_func.body.insert(-1, spa_check)
+            else:
+                render_func.body.append(spa_check)
+
+            # Add no-op _init_slots
+            binding_funcs.append(
+                ast.FunctionDef(
+                    name="_init_slots",
+                    args=ast.arguments(
+                        posonlyargs=[],
+                        args=[ast.arg(arg="self")],
+                        vararg=None,
+                        kwonlyargs=[],
+                        kw_defaults=[],
+                        defaults=[],
+                    ),
+                    body=[ast.Pass()],
+                    decorator_list=[],
+                    returns=None,
+                )
+            )
+
+        if self.template_codegen.region_renderers:
+            region_keys: List[ast.expr | None] = []
+            region_vals: List[ast.expr] = []
+            for (
+                region_id,
+                method_name,
+            ) in self.template_codegen.region_renderers.items():
+                region_keys.append(ast.Constant(value=region_id))
+                region_vals.append(ast.Constant(value=method_name))
+            binding_funcs.append(
+                ast.Assign(
+                    targets=[ast.Name(id="__region_renderers__", ctx=ast.Store())],
+                    value=ast.Dict(keys=region_keys, values=region_vals),
+                )
+            )
+
+        return render_func, binding_funcs
+
+    def _has_slots_recursive(self, nodes: List[TemplateNode]) -> bool:
+        """Check recursively if the template contains any <slot> elements."""
+        for node in nodes:
+            if node.tag == "slot":
+                return True
+            if self._has_slots_recursive(node.children):
+                return True
+        return False