hyprconf2lua 1.2.0__py3-none-any.whl

hyprconf2lua/codegen.py

@@ -0,0 +1,931 @@
+from __future__ import annotations
+import re
+from typing import Dict, List, Optional
+
+from hyprconf2lua.ast import *
+from hyprconf2lua.mappings import *
+
+
+KNOWN_SECTIONS = {
+    "general", "decoration", "input", "animations", "gestures",
+    "misc", "binds", "cursor", "debug", "dwindle", "master",
+    "group", "render", "xwayland", "opengl", "ecosystem",
+    "experimental", "layout", "scrolling", "quirks", "blur",
+    "shadow", "touchpad", "tablet", "windowing", "startup",
+    "autostart", "window", "monitor", "workspace", "layer",
+}
+
+
+class Codegen:
+    def __init__(self):
+        self.lines: List[str] = []
+        self.indent_level = 0
+        self.variables: Dict[str, str] = {}
+        self.has_exec = False
+        self.has_animation = False
+        self.has_bezier = False
+        self.has_bind = False
+        self.main_mod_var: Optional[str] = None
+        self.pending_execs: List[str] = []
+        self.pending_exec_ones: List[str] = []
+        self.pending_exec_shutdowns: List[str] = []
+        self.flag_count = 0
+        self.translated_count = 0
+        self.passthrough_count = 0
+
+    def indent(self):
+        self.indent_level += 1
+
+    def dedent(self):
+        self.indent_level = max(0, self.indent_level - 1)
+
+    def emit(self, line: str = ""):
+        if line:
+            self.lines.append("    " * self.indent_level + line)
+        else:
+            self.lines.append("")
+
+    def emit_block(self, lines: List[str]):
+        for line in lines:
+            self.emit(line)
+
+    def generate(self, config: ConfigFile) -> str:
+        self.lines = []
+        self.emit("-- Generated by hyprconf2lua v1.2.0")
+        self.emit("-- https://github.com/yourusername/hyprconf2lua")
+        self.emit("-- Manual review may be needed for complex directives")
+        self.emit("")
+        self.emit('---@module \'hl\'')
+        self.emit("")
+
+        for stmt in config.body:
+            self.visit(stmt)
+            self.emit()
+
+        self.emit_pending_execs()
+        self.finalize_vars()
+
+        return "\n".join(self.lines)
+
+    def visit(self, stmt: BlockStmt):
+        if isinstance(stmt, Comment):
+            self.emit("--" + stmt.text[1:])
+        elif isinstance(stmt, VariableDef):
+            self.visit_variable(stmt)
+        elif isinstance(stmt, Directive):
+            self.visit_directive(stmt)
+        elif isinstance(stmt, Section):
+            self.visit_section(stmt)
+        elif isinstance(stmt, BindDirective):
+            self.visit_bind(stmt)
+        elif isinstance(stmt, MonitorDirective):
+            self.visit_monitor(stmt)
+        elif isinstance(stmt, WindowRule):
+            self.visit_windowrule(stmt)
+        elif isinstance(stmt, WindowRuleBlock):
+            self.visit_windowrule_block(stmt)
+        elif isinstance(stmt, ExecDirective):
+            self.visit_exec(stmt)
+        elif isinstance(stmt, AnimationDirective):
+            self.visit_animation(stmt)
+        elif isinstance(stmt, BezierDirective):
+            self.visit_bezier(stmt)
+        elif isinstance(stmt, EnvDirective):
+            self.visit_env(stmt)
+        elif isinstance(stmt, SourceDirective):
+            self.visit_source(stmt)
+        elif isinstance(stmt, DeviceSection):
+            self.visit_device(stmt)
+        elif isinstance(stmt, GestureDirective):
+            self.visit_gesture(stmt)
+        elif isinstance(stmt, WorkspaceDirective):
+            self.visit_workspace(stmt)
+        elif isinstance(stmt, SubmapDef):
+            self.visit_submap(stmt)
+        elif isinstance(stmt, LayerRuleDirective):
+            self.visit_layerrule(stmt)
+        elif isinstance(stmt, LayerRuleBlock):
+            self.visit_layerrule_block(stmt)
+        else:
+            self.flag_count += 1
+            self.emit(f"-- TODO: manual review (unknown statement type: {type(stmt).__name__})")
+
+    def resolve_val(self, val: str) -> str:
+        def _repl(m: re.Match) -> str:
+            var_name = m.group(1)
+            if var_name in self.variables:
+                return self.variables[var_name]
+            return "local_var_" + var_name
+        return re.sub(r'\$(\w+)', _repl, val)
+
+    def needs_quotes(self, val: str) -> bool:
+        if not val:
+            return True
+        if val.startswith('"') and val.endswith('"'):
+            return False
+        if re.match(r'^-?\d+(\.\d+)?$', val):
+            return False
+        if val in ("true", "false", "nil"):
+            return False
+        if val in self.variables or val in ("mainMod", "terminal", "fileManager", "menu"):
+            return False
+        if re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', val) and val in self.variables:
+            return False
+        return True
+
+    def quote(self, val: str) -> str:
+        if self.needs_quotes(val):
+            escaped = val.replace("\\", "\\\\").replace('"', '\\"')
+            return f'"{escaped}"'
+        return val
+
+    def to_lua_val(self, val: str):
+        val = self.resolve_val(val)
+        if val.startswith("local_var_"):
+            return val[len("local_var_"):]
+        if val.lower() in ("true", "on", "yes"):
+            return "true"
+        if val.lower() in ("false", "off", "no"):
+            return "false"
+        try:
+            int(val)
+            return val
+        except ValueError:
+            pass
+        try:
+            float(val)
+            return val
+        except ValueError:
+            pass
+        return self.quote(val)
+
+    def visit_variable(self, stmt: VariableDef):
+        val = self.resolve_val(stmt.value)
+        self.variables[stmt.name] = val
+        self.translated_count += 1
+        if stmt.name.upper() == "MAINMOD" or stmt.name == "mainMod":
+            self.main_mod_var = stmt.name
+            self.emit(f'local {stmt.name} = "{val}"')
+        else:
+            if self.needs_quotes(val):
+                self.emit(f'local {stmt.name} = {self.quote(val)}')
+            else:
+                self.emit(f'local {stmt.name} = {val}')
+
+    def finalize_vars(self):
+        if self.main_mod_var is None:
+            for name, val in self.variables.items():
+                if val == "SUPER" or val == "ALT" or val == "CTRL" or val == "SHIFT":
+                    self.main_mod_var = name
+                    break
+
+    def emit_pending_execs(self):
+        if self.pending_exec_ones:
+            self.emit("-- Autostart")
+            self.emit('hl.on("hyprland.start", function()')
+            self.indent()
+            for cmd in self.pending_exec_ones:
+                resolved = self.resolve_val(cmd)
+                if resolved.startswith("$") and resolved[1:] in self.variables:
+                    self.emit(f"hl.exec_cmd({resolved[1:]})")
+                else:
+                    self.emit(f"hl.exec_cmd({self.quote(resolved)})")
+            self.dedent()
+            self.emit("end)")
+            self.emit("")
+
+        if self.pending_execs:
+            self.emit("-- Exec (run every reload)")
+            self.emit('hl.on("config.reloaded", function()')
+            self.indent()
+            for cmd in self.pending_execs:
+                resolved = self.resolve_val(cmd)
+                if resolved.startswith("$") and resolved[1:] in self.variables:
+                    self.emit(f"hl.exec_cmd({resolved[1:]})")
+                else:
+                    self.emit(f"hl.exec_cmd({self.quote(resolved)})")
+            self.dedent()
+            self.emit("end)")
+            self.emit("")
+
+        if self.pending_exec_shutdowns:
+            self.emit("-- Shutdown")
+            self.emit('hl.on("hyprland.shutdown", function()')
+            self.indent()
+            for cmd in self.pending_exec_shutdowns:
+                resolved = self.resolve_val(cmd)
+                if resolved.startswith("$") and resolved[1:] in self.variables:
+                    self.emit(f"hl.exec_cmd({resolved[1:]})")
+                else:
+                    self.emit(f"hl.exec_cmd({self.quote(resolved)})")
+            self.dedent()
+            self.emit("end)")
+            self.emit("")
+
+    def emit_section_config(self, section_name: str, directives: List[BlockStmt]):
+        if not directives:
+            return
+
+        self.emit(f"hl.config({{")
+        self.indent()
+        self.emit(f"{section_name} = {{")
+        self.indent()
+
+        for d in directives:
+            if isinstance(d, Comment):
+                self.emit(f"--{d.text[1:]}")
+            elif isinstance(d, Section):
+                sub_name = d.name
+                self.emit(f"{sub_name} = {{")
+                self.indent()
+                for sd in d.body:
+                    if isinstance(sd, Comment):
+                        self.emit(f"--{sd.text[1:]}")
+                    elif isinstance(sd, Directive):
+                        self.translated_count += 1
+                        key = sd.key
+                        if len(sd.value) == 1:
+                            val = self.to_lua_val(sd.value[0])
+                            self.emit(f"{key} = {val},")
+                        else:
+                            vals = [self.to_lua_val(v) for v in sd.value]
+                            self.emit(f"{key} = {{ {', '.join(vals)} }},")
+                    elif isinstance(sd, Section):
+                        self.passthrough_count += 1
+                        self.emit(f"-- Nested subsection {sd.name}:")
+                        for ssd in sd.body:
+                            if isinstance(ssd, Directive):
+                                k = ssd.key
+                                vv = self.to_lua_val(ssd.value[0]) if ssd.value else "true"
+                                self.emit(f"{k} = {vv},")
+                self.dedent()
+                self.emit("},")
+            elif isinstance(d, Directive):
+                self.translated_count += 1
+                key = d.key
+                if len(d.value) == 1:
+                    val = self.to_lua_val(d.value[0])
+                    self.emit(f"{key} = {val},")
+                else:
+                    vals = [self.to_lua_val(v) for v in d.value]
+                    self.emit(f"{key} = {{ {', '.join(vals)} }},")
+
+        self.dedent()
+        self.emit("},")
+        self.dedent()
+        self.emit("})")
+
+    def flush_subsection(self, name: str, directives: List[Directive]):
+        if not directives:
+            return
+        self.emit(f"{name} = {{")
+        self.indent()
+        for d in directives:
+            key = d.key
+            if len(d.value) == 1:
+                val = self.to_lua_val(d.value[0])
+                self.emit(f"{key} = {val},")
+            else:
+                vals = [self.to_lua_val(v) for v in d.value]
+                self.emit(f"{key} = {{ {', '.join(vals)} }},")
+        self.dedent()
+        self.emit("},")
+
+    def visit_section(self, stmt: Section):
+        if stmt.name == "plugin":
+            self.translated_count += 1
+            has_plugins = False
+            for child in stmt.body:
+                if isinstance(child, Section):
+                    has_plugins = True
+                    plugin_name = child.name
+                    self.emit(f"hl.plugin({self.quote(plugin_name)}, function()")
+                    self.indent()
+                    for sd in child.body:
+                        if isinstance(sd, Comment):
+                            self.emit(f"--{sd.text[1:]}")
+                        elif isinstance(sd, Directive):
+                            k = sd.key
+                            if len(sd.value) == 1:
+                                v = self.to_lua_val(sd.value[0])
+                                self.emit(f"{k} = {v},")
+                            else:
+                                vals = [self.to_lua_val(v) for v in sd.value]
+                                self.emit(f"{k} = {{ {', '.join(vals)} }},")
+                    self.dedent()
+                    self.emit("end)")
+                elif isinstance(child, Directive):
+                    has_plugins = True
+                    name = child.key
+                    vals = ", ".join(self.quote(self.resolve_val(v)) for v in child.value)
+                    self.emit(f"hl.plugin({self.quote(name)}, {{{vals}}})")
+            if not has_plugins:
+                self.emit("-- TODO: manual review (plugin config)")
+            return
+        if stmt.name in KNOWN_SECTIONS:
+            self.emit_section_config(stmt.name, stmt.body)
+        else:
+            self.translated_count += 1
+            self.emit(f"hl.config({{")
+            self.indent()
+            self.emit(f"{stmt.name} = {{")
+            self.indent()
+            for child in stmt.body:
+                if isinstance(child, Comment):
+                    self.emit(f"--{child.text[1:]}")
+                elif isinstance(child, Directive):
+                    k = child.key
+                    if len(child.value) == 1:
+                        v = self.to_lua_val(child.value[0])
+                        self.emit(f"{k} = {v},")
+                    else:
+                        vals = [self.to_lua_val(v) for v in child.value]
+                        self.emit(f"{k} = {{ {', '.join(vals)} }},")
+            self.dedent()
+            self.emit("},")
+            self.dedent()
+            self.emit("})")
+            self.emit(f"-- NOTE: Section '{stmt.name}' may be a plugin or custom section; verify the output")
+
+    def visit_directive(self, stmt: Directive):
+        if stmt.key in ("submap", "submap_reset"):
+            return
+        if stmt.key == "unbind":
+            self.translated_count += 1
+            mods_str = stmt.value[0].strip() if stmt.value else ""
+            key_str = stmt.value[1].strip() if len(stmt.value) > 1 else ""
+            mods = [m.strip() for m in mods_str.replace(",", " ").split()] if mods_str else []
+            combo_expr = self.build_unbind_combo(mods, key_str)
+            self.emit(f"hl.unbind({combo_expr})")
+            return
+
+        self.passthrough_count += 1
+        vals = ", ".join(self.quote(self.resolve_val(v)) for v in stmt.value)
+        self.emit(f"-- TODO: manual review: {stmt.key} = {vals}")
+
+    def build_unbind_combo(self, mods: List[str], key: str) -> str:
+        if not mods:
+            return self.quote(key) if key else '""'
+        parts = [self.quote(m) for m in mods]
+        all_str = " + ".join(p.strip('"') for p in parts)
+        return self.quote(all_str) + ' .. " + " .. ' + (self.quote(key) if key else '""')
+
+    def visit_bind(self, stmt: BindDirective):
+        self.translated_count += 1
+        self.has_bind = True
+
+        combo_expr = self.build_combo_expr(stmt.mods, stmt.key)
+
+        dispatcher = stmt.dispatcher
+        params = stmt.params
+
+        if stmt.key.startswith("mouse:") and not params:
+            if dispatcher == "movewindow":
+                dsp_code = "hl.dsp.window.drag()"
+            elif dispatcher == "resizewindow":
+                dsp_code = "hl.dsp.window.resize()"
+            else:
+                dsp_code = self.build_dispatcher(dispatcher, params)
+        else:
+            dsp_code = self.build_dispatcher(dispatcher, params)
+        if dsp_code is None and params:
+            first_param = params[0]
+            rest = params[1:]
+            dsp_code = self.build_dispatcher(first_param, rest)
+            if dsp_code is not None:
+                dispatcher = first_param
+                params = rest
+
+        if dsp_code is None:
+            self.flag_count += 1
+            mods_str = " + ".join(stmt.mods) if stmt.mods else ""
+            self.emit(f'-- TODO: manual review (unknown dispatcher: {stmt.dispatcher})')
+            pstr = ", ".join(self.quote(self.resolve_val(p)) for p in stmt.params)
+            self.emit(f'-- hl.bind("{mods_str} + {stmt.key}", hl.dsp.{stmt.dispatcher}({pstr}))')
+            return
+
+        opt_parts = []
+        if stmt.flags:
+            for f in stmt.flags:
+                if f in BIND_FLAGS_TO_OPTIONS:
+                    opt_key, opt_val = BIND_FLAGS_TO_OPTIONS[f]
+                    opt_parts.append(f"{opt_key} = {opt_val}")
+
+        if opt_parts:
+            opts = ", { " + ", ".join(opt_parts) + " }"
+        else:
+            opts = ""
+
+        self.emit(f"hl.bind({combo_expr}, {dsp_code}{opts})")
+
+    def build_combo_expr(self, mods: List[str], key: str) -> str:
+        parts = []
+
+        is_key_var = key.startswith("$")
+        key_resolved = self.resolve_val(key) if is_key_var else None
+        key_str = key_resolved if is_key_var else self.quote(key)
+
+        for m in mods:
+            is_var = m.startswith("$")
+            if is_var:
+                var_name = m[1:]
+                if var_name in self.variables:
+                    parts.append(var_name)
+                else:
+                    parts.append(self.quote(m))
+            else:
+                parts.append(self.quote(m))
+
+        if not parts:
+            return key_str
+
+        has_var = any(not p.startswith('"') for p in parts)
+
+        if not has_var:
+            all_str = " + ".join(p.strip('"') for p in parts)
+            return self.quote(all_str) + ' .. " + " .. ' + key_str
+
+        segments = []
+        current_str = None
+        for p in parts:
+            if p.startswith('"'):
+                lit = p.strip('"')
+                if current_str is None:
+                    current_str = lit
+                else:
+                    current_str += " + " + lit
+            else:
+                if current_str is not None:
+                    segments.append(self.quote(current_str))
+                    current_str = None
+                segments.append(p)
+        if current_str is not None:
+            segments.append(self.quote(current_str))
+
+        separator = ' .. " + " .. '
+        result = separator.join(segments) + separator + key_str
+        return result
+
+    def build_dispatcher(self, dispatcher: str, params: List[str]) -> Optional[str]:
+        if dispatcher in DISPATCHER_MAP:
+            func, needs_args = DISPATCHER_MAP[dispatcher]
+
+            if dispatcher == "movetoworkspacesilent":
+                args = self.build_dispatcher_args(params, needs_args)
+                return f'{func}({args}, {{ follow = false }})'
+
+            if dispatcher == "movefocus":
+                dir_map = {"l": "left", "r": "right", "u": "up", "d": "down"}
+                if params and params[0] in dir_map:
+                    return f'{func}({{ direction = "{dir_map[params[0]]}" }})'
+                return f'{func}({{ direction = {self.quote(params[0]) if params else "nil"} }})'
+
+            if dispatcher == "cyclenext":
+                if params and params[0].lower() == "prev":
+                    return f'{func}({{ next = false }})'
+                return f'{func}()'
+
+            if dispatcher == "movewindow":
+                if params and params[0].startswith("into_group:"):
+                    return f'{func}({{ into_group = {self.quote(params[0][len("into_group:"):])} }})'
+                if params and params[0] == "out_of_group":
+                    return f'{func}({{ out_of_group = true }})'
+                return self.build_dispatcher_args(params, needs_args, func)
+
+            if dispatcher == "swapwindow":
+                if params and params[0] in ("l", "r", "u", "d"):
+                    dir_map = {"l": "left", "r": "right", "u": "up", "d": "down"}
+                    return f'{func}({{ direction = "{dir_map[params[0]]}" }})'
+                if params and params[0].startswith("class:"):
+                    return f'{func}({{ target = {self.quote(params[0])} }})'
+                return self.build_dispatcher_args(params, needs_args, func)
+
+            if dispatcher == "changegroupactive":
+                if params and params[0].lower() == "f":
+                    return f'{func}()'
+                return f'{func}({{ forward = false }})'
+
+            if dispatcher == "movegroupwindow":
+                if params and params[0].lower() == "b":
+                    return f'{func}({{ forward = false }})'
+                return f'{func}({{ forward = true }})'
+
+            if dispatcher == "workspace":
+                return self.build_workspace_dispatcher(func, params)
+
+            if dispatcher == "focuswindow":
+                return self.build_focus_dispatcher(func, params)
+
+            if dispatcher == "focusurgentorlast":
+                return f'{func}({{ urgent = true }})'
+
+            if dispatcher == "focuscurrentorlast":
+                return f'{func}({{ last = true }})'
+
+            if dispatcher == "focusonemonitor":
+                return f'{func}({{ on_monitor = true }})'
+
+            if dispatcher == "mouse":
+                mouse_actions = {"272": "drag", "273": "resize"}
+                if params and params[0] in mouse_actions:
+                    return f'hl.dsp.window.{mouse_actions[params[0]]}()'
+                return None
+
+            if dispatcher in ("exec", "execr"):
+                resolved = self.resolve_val(params[0]) if params else ""
+                return f'{func}({self.quote(resolved)})'
+
+            args = self.build_dispatcher_args(params, needs_args)
+            return f'{func}({args})' if needs_args else f'{func}()'
+
+        if dispatcher == "mouse":
+            mouse_actions = {"272": "drag", "273": "resize"}
+            if params and params[0] in mouse_actions:
+                return f'hl.dsp.window.{mouse_actions[params[0]]}()'
+            return None
+
+        if dispatcher in ("moveintogroup",):
+            if params:
+                dir_map = {"l": "left", "r": "right", "u": "up", "d": "down"}
+                d = dir_map.get(params[0], params[0])
+                return f'hl.dsp.window.move({{ into_group = "{d}" }})'
+            return None
+
+        elif dispatcher in ("moveoutofgroup",):
+            return f'hl.dsp.window.move({{ out_of_group = true }})'
+
+        return None
+
+    def build_workspace_dispatcher(self, func: str, params: List[str]) -> str:
+        if not params:
+            return f'{func}({{ workspace = "e+1" }})'
+        p = params[0]
+        if p.isdigit() or (p.startswith("-") and p[1:].isdigit()):
+            return f'{func}({{ workspace = {p} }})'
+        if p.startswith("special"):
+            if ":" in p:
+                return f'{func}({{ workspace = {self.quote(p)} }})'
+            return f'{func}({{ workspace = "special" }})'
+        if p in ("e+1", "e-1", "m+1", "m-1", "r", "empty", "previous"):
+            short_map = {"previous": "previous", "empty": "empty", "r": "r"}
+            return f'{func}({{ workspace = {self.quote(short_map.get(p, p))} }})'
+        if p.startswith("name:"):
+            return f'{func}({{ workspace = {self.quote(p[len("name:"):])} }})'
+        return f'{func}({{ workspace = {self.quote(p)} }})'
+
+    def build_focus_dispatcher(self, func: str, params: List[str]) -> str:
+        if not params:
+            return f'{func}({{ window = "" }})'
+        p = params[0]
+        if p.startswith("class:"):
+            return f'{func}({{ window = {self.quote(p)} }})'
+        if p.startswith("title:"):
+            return f'{func}({{ window = {self.quote(p)} }})'
+        if p.startswith("address:"):
+            return f'{func}({{ window = {self.quote(p)} }})'
+        return f'{func}({{ window = {self.quote(p)} }})'
+
+    def build_dispatcher_args(self, params: List[str], needs_args: bool,
+                               func: Optional[str] = None) -> str:
+        if not params:
+            return "" if not needs_args else "nil"
+
+        if len(params) == 1:
+            p = params[0]
+            if func and func == "hl.dsp.window.move":
+                if p.startswith("special"):
+                    return f'{{ workspace = {self.quote(p)} }}'
+                if p.isdigit():
+                    return f'{{ workspace = {p} }}'
+                return f'{{ direction = {self.quote(p)} }}'
+            return self.quote(self.resolve_val(p))
+
+        parts = []
+        for p in params:
+            parts.append(self.quote(self.resolve_val(p)))
+        return ", ".join(parts)
+
+    def visit_monitor(self, stmt: MonitorDirective):
+        self.translated_count += 1
+        self.emit("hl.monitor({")
+        self.indent()
+        self.emit(f'output   = {self.quote(stmt.name)},')
+        self.emit(f'mode     = {self.quote(stmt.mode)},')
+        self.emit(f'position = {self.quote(stmt.position)},')
+        self.emit(f'scale    = {self.quote(stmt.scale)},')
+        for key, val in stmt.extra.items():
+            lua_val = self.to_lua_val(val)
+            self.emit(f'{key} = {lua_val},')
+        self.dedent()
+        self.emit("})")
+
+    def visit_windowrule(self, stmt: WindowRule):
+        self.translated_count += 1
+        rule = stmt.rule
+        match_params = stmt.match_params
+
+        match = {}
+        effects = {}
+
+        for mp in match_params:
+            colon_idx = mp.find(":")
+            if colon_idx > 0:
+                prefix = mp[:colon_idx].strip()
+                value = mp[colon_idx + 1:].strip()
+                match_key = prefix
+                if value.lower() == "true":
+                    match[match_key] = "true"
+                elif value.lower() == "false":
+                    match[match_key] = "false"
+                else:
+                    match[match_key] = self.quote(value)
+
+        if not match and not stmt.is_v2:
+            if match_params:
+                class_val = match_params[0]
+                match["class"] = self.quote(class_val)
+
+        self.emit("hl.window_rule({")
+        self.indent()
+
+        name_str = re.sub(r'[^a-zA-Z0-9_-]', '_', rule[:20].lower())
+        self.emit(f'name  = "{name_str}",')
+
+        self.emit("match = {")
+        self.indent()
+        for k, v in match.items():
+            self.emit(f"{k} = {v},")
+        self.dedent()
+        self.emit("},")
+
+        rule_lower = rule.lower().strip()
+        applied = False
+
+        if rule_lower in WINDOW_RULE_MAP:
+            k, v = WINDOW_RULE_MAP[rule_lower]
+            self.emit(f"{k} = {v},")
+            applied = True
+        else:
+            parts = rule.split(None, 1)
+            if parts and parts[0] in WINDOW_RULE_PARAM_MAP:
+                k, needs_val = WINDOW_RULE_PARAM_MAP[parts[0]]
+                if needs_val and len(parts) > 1:
+                    val = self.to_lua_val(parts[1])
+                    self.emit(f"{k} = {val},")
+                elif needs_val:
+                    self.emit(f"{k} = true,")
+                else:
+                    self.emit(f"{k} = true,")
+                applied = True
+
+        if not applied:
+            self.flag_count += 1
+            self.emit(f'-- TODO: review rule: {self.quote(rule)}')
+
+        self.dedent()
+        self.emit("})")
+
+    def visit_windowrule_block(self, stmt: WindowRuleBlock):
+        self.translated_count += 1
+        name_str = stmt.name if stmt.name else re.sub(r'[^a-zA-Z0-9_-]', '_', f'rule_{stmt.line}')
+
+        self.emit("hl.window_rule({")
+        self.indent()
+        self.emit(f'name  = "{name_str}",')
+
+        if stmt.match:
+            self.emit("match = {")
+            self.indent()
+            for k, v in stmt.match.items():
+                self.emit(f"{k} = {self.quote(v)},")
+            self.dedent()
+            self.emit("},")
+
+        for key, vals in stmt.effects.items():
+            if len(vals) == 1:
+                parts = vals[0].split()
+                if len(parts) == 1:
+                    self.emit(f"{key} = {self.to_lua_val(parts[0])},")
+                else:
+                    lua_parts = [self.to_lua_val(p) for p in parts]
+                    self.emit(f"{key} = {{ {', '.join(lua_parts)} }},")
+            else:
+                lua_vals = [self.to_lua_val(v) for v in vals]
+                self.emit(f"{key} = {{ {', '.join(lua_vals)} }},")
+
+        self.dedent()
+        self.emit("})")
+
+    def visit_exec(self, stmt: ExecDirective):
+        self.translated_count += 1
+        resolved = self.resolve_val(stmt.command)
+        if stmt.kind in ("exec-once", "execr-once"):
+            self.pending_exec_ones.append(stmt.command)
+        elif stmt.kind == "exec-shutdown":
+            self.pending_exec_shutdowns.append(stmt.command)
+        else:
+            self.pending_execs.append(stmt.command)
+
+    def visit_animation(self, stmt: AnimationDirective):
+        self.translated_count += 1
+        name = stmt.name
+        style = stmt.style
+        speed = stmt.speed
+        curve = stmt.curve
+
+        try:
+            float(speed)
+            speed_lit = speed
+        except ValueError:
+            speed_lit = self.quote(speed)
+
+        style_extra = ""
+        if style and style != "default":
+            if " " in style:
+                style_name, *style_args = style.split()
+                style_extra = f', style = {self.quote(style)}'
+            else:
+                style_extra = f', style = {self.quote(style)}'
+
+        if curve and curve != "default":
+            if re.match(r'^\d+(\.\d+)?$', curve):
+                return self.emit(f"-- TODO: manual review (numeric curve ref in animation: {stmt.name})")
+
+            if curve.startswith("spring"):
+                spring_parts = curve.split()
+                if len(spring_parts) >= 4:
+                    self.passthrough_count += 1
+                    self.emit(f'hl.animation({{ leaf = "{name}", enabled = true, speed = {speed_lit}, spring = {self.quote(curve)}{style_extra} }})')
+                else:
+                    self.emit(f'hl.animation({{ leaf = "{name}", enabled = true, speed = {speed_lit}, spring = {self.quote(curve)}{style_extra} }})')
+            else:
+                self.emit(f'hl.animation({{ leaf = "{name}", enabled = true, speed = {speed_lit}, bezier = {self.quote(curve)}{style_extra} }})')
+        else:
+            self.emit(f'hl.animation({{ leaf = "{name}", enabled = true, speed = {speed_lit}{style_extra} }})')
+
+    def visit_bezier(self, stmt: BezierDirective):
+        self.translated_count += 1
+        self.emit(f'hl.curve({self.quote(stmt.name)}, {{')
+        self.indent()
+        self.emit(f'type = "bezier",')
+        self.emit(f'points = {{ {{ {stmt.p1x}, {stmt.p1y} }}, {{ {stmt.p2x}, {stmt.p2y} }} }},')
+        self.dedent()
+        self.emit("})")
+
+    def visit_env(self, stmt: EnvDirective):
+        self.translated_count += 1
+        resolved_name = self.resolve_val(stmt.name)
+        resolved_val = self.resolve_val(stmt.value)
+        name_q = self.quote(resolved_name)
+        val_q = self.quote(resolved_val)
+        self.emit(f"hl.env({name_q}, {val_q})")
+
+    def visit_source(self, stmt: SourceDirective):
+        self.passthrough_count += 1
+        path = stmt.path
+
+        lua_path = path.replace(".conf", "")
+        lua_path = lua_path.replace("~", "os.getenv(\"HOME\")")
+        lua_path = lua_path.replace("/", ".")
+
+        if path.endswith("/*.conf"):
+            self.emit(f'-- source = {path}')
+            self.emit(f"-- NOTE: glob sources need manual handling")
+            self.emit(f"-- Directory contents must be required individually")
+            return
+
+        self.emit(f'-- source = {path} -> requires manual conversion')
+        home_relative = path.replace("~", "").replace(os_path := "", ".hypr/")
+
+        import os as _os
+        just_name = _os.path.splitext(_os.path.basename(path))[0]
+        self.emit(f'-- local {just_name} = require("{just_name}")')
+        self.emit(f'-- TODO: convert {path} to .lua and use require()')
+
+    def visit_device(self, stmt: DeviceSection):
+        self.translated_count += 1
+        self.emit(f"hl.device({{")
+        self.indent()
+        self.emit(f'name = {self.quote(stmt.name)},')
+        for d in stmt.body:
+            if isinstance(d, Directive):
+                key = d.key
+                val = self.to_lua_val(d.value[0]) if d.value else "true"
+                self.emit(f"{key} = {val},")
+        self.dedent()
+        self.emit("})")
+
+    def visit_gesture(self, stmt: GestureDirective):
+        self.translated_count += 1
+        props = {}
+        for d in stmt.body:
+            if isinstance(d, Directive):
+                props[d.key] = d.value[0] if d.value else "true"
+
+        self.emit("hl.gesture({")
+        self.indent()
+        for k, v in props.items():
+            lua_v = self.to_lua_val(v)
+            lua_k = k.replace("_", " ")
+            self.emit(f"[{self.quote(lua_k)}] = {lua_v},")
+        self.dedent()
+        self.emit("})")
+
+    def visit_submap(self, stmt: SubmapDef):
+        self.translated_count += 1
+        self.emit(f'hl.define_submap({self.quote(stmt.name)}, function()')
+        self.indent()
+        for s in stmt.body:
+            if isinstance(s, Comment):
+                self.emit("--" + s.text[1:])
+            elif isinstance(s, BindDirective):
+                self.visit_bind(s)
+            elif isinstance(s, Directive):
+                if s.key == "submap_reset":
+                    continue
+                self.emit(f'-- submap: {s.key} = {", ".join(s.value)}')
+        self.dedent()
+        self.emit("end)")
+        self.emit("")
+
+    def visit_workspace(self, stmt: WorkspaceDirective):
+        self.translated_count += 1
+        self.emit("hl.workspace_rule({")
+        self.indent()
+        self.emit(f'workspace = {self.quote(stmt.name)},')
+        for param in stmt.params:
+            colon_idx = param.find(":")
+            if colon_idx > 0:
+                key = param[:colon_idx].strip()
+                val = param[colon_idx + 1:].strip()
+                lua_key = WORKSPACE_RULE_MAP.get(key, key)
+                lua_val = self.to_lua_val(val)
+                self.emit(f"{lua_key} = {lua_val},")
+            else:
+                self.emit(f'-- {param} (unrecognized workspace param)')
+        self.dedent()
+        self.emit("})")
+
+    def visit_layerrule(self, stmt: LayerRuleDirective):
+        self.translated_count += 1
+        rule_lower = stmt.rule.lower()
+        ns = stmt.namespace
+
+        self.emit("hl.layer_rule({")
+        self.indent()
+        self.emit("match = {")
+        self.indent()
+        self.emit(f'namespace = {self.quote(ns)},')
+        self.dedent()
+        self.emit("},")
+
+        if rule_lower in LAYER_RULE_MAP:
+            k, v = LAYER_RULE_MAP[rule_lower]
+            if v == "true":
+                self.emit(f"{k} = {v},")
+            else:
+                self.emit(f"{k} = {self.to_lua_val(v)},")
+        else:
+            parts = rule_lower.split(None, 1)
+            if parts:
+                self.emit(f"{parts[0]} = {self.quote(parts[1]) if len(parts) > 1 else 'true'},")
+
+        self.dedent()
+        self.emit("})")
+
+    def visit_layerrule_block(self, stmt: LayerRuleBlock):
+        self.translated_count += 1
+        name_str = stmt.name if stmt.name else f'layerrule_{stmt.line}'
+
+        self.emit("hl.layer_rule({")
+        self.indent()
+
+        if stmt.match:
+            self.emit("match = {")
+            self.indent()
+            for k, v in stmt.match.items():
+                self.emit(f"{k} = {self.quote(v)},")
+            self.dedent()
+            self.emit("},")
+
+        for key, vals in stmt.effects.items():
+            if len(vals) == 1:
+                parts = vals[0].split()
+                if len(parts) == 1:
+                    self.emit(f"{key} = {self.to_lua_val(parts[0])},")
+                else:
+                    lua_parts = [self.to_lua_val(p) for p in parts]
+                    self.emit(f"{key} = {{ {', '.join(lua_parts)} }},")
+            else:
+                lua_vals = [self.to_lua_val(v) for v in vals]
+                self.emit(f"{key} = {{ {', '.join(lua_vals)} }},")
+
+        self.dedent()
+        self.emit("})")
+
+    def get_report(self) -> dict:
+        return {
+            "translated": self.translated_count,
+            "passthrough": self.passthrough_count,
+            "flagged": self.flag_count,
+        }