zexus 1.7.1 → 1.7.2

package/src/zexus/cli/main.py

@@ -68,12 +68,13 @@ except ModuleNotFoundError:  # Fallback to minimal console utilities when rich i
 from ..lexer import Lexer
 from ..parser import Parser
 # UPDATED: Import evaluate from evaluator package
-from ..evaluator import evaluate
+from ..evaluator import evaluate, Evaluator
 # UPDATED: Import Environment and String from object module
 from ..object import Environment, String
 from ..syntax_validator import SyntaxValidator
 from ..hybrid_orchestrator import orchestrator
 from ..config import config
+from ..runtime.file_flags import parse_file_flags, apply_vm_config
 # Import error handling
 from ..error_reporter import get_error_reporter, ZexusError, print_error
 # VM and Compiler for high-performance execution
@@ -92,6 +93,7 @@ def show_all_commands():
     
     commands = [
         ("zx run <file>", "Execute a Zexus program"),
+        ("zx -r \"<code>\"", "Run inline Zexus code (like python -c)"),
         ("zx run --zexus", "Show this command list"),
         ("zx check <file>", "Check syntax with detailed validation"),
         ("zx validate <file>", "Validate and auto-fix syntax errors"),
@@ -106,7 +108,9 @@ def show_all_commands():
         ("--syntax-style=<style>", "universal, tolerable, or auto (default)"),
         ("--execution-mode=<mode>", "interpreter, compiler, or auto (default)"),
         ("--advanced-parsing", "Enable multi-strategy parsing (default: on)"),
-        ("--debug", "Enable debug output"),
+        ("--debug <on|off|minimal|full>", "Enable/disable debug output"),
+        ("--no-debug", "Disable debug output"),
+        ("--no-vm", "Disable VM execution for run"),
         ("--version", "Show Zexus version"),
         ("--help", "Show detailed help"),
         ("", ""),
@@ -122,6 +126,8 @@ def show_all_commands():
         ("zx check --debug program.zx", "Check syntax with debug info"),
         ("zx profile myapp.zx", "Profile with memory tracking"),
         ("zx profile --no-memory --top 10 app.zx", "Profile without memory, show top 10"),
+        ("zx -r \"print(42)\"", "Execute inline code directly"),
+        ("zx -r \"let x = 10; print(x * 2)\"", "Run multi-statement inline code"),
         ("", ""),
         ("[bold]Built-in Functions:[/bold]", "100+ functions available"),
         ("", "Memory: persist_set, persist_get, track_memory"),
@@ -150,54 +156,189 @@ def show_all_commands():
     console.print("\n[bold green]💡 Tip:[/bold green] Use 'zx <command> --help' for detailed command options\n")
 
 @click.group(invoke_without_command=True)
-@click.version_option(version="1.7.1", prog_name="Zexus")
+@click.version_option(version="1.7.2", prog_name="Zexus")
 @click.option('--syntax-style', type=click.Choice(['universal', 'tolerable', 'auto']),
               default='auto', help='Syntax style to use (universal=strict, tolerable=flexible)')
 @click.option('--advanced-parsing', is_flag=True, default=True,
               help='Enable advanced multi-strategy parsing (recommended)')
 @click.option('--execution-mode', type=click.Choice(['interpreter', 'compiler', 'auto']),
               default='auto', help='Execution engine to use')
-@click.option('--debug', is_flag=True, help='Enable debug logging')
+@click.option('--debug', type=click.Choice(['on', 'off', 'minimal', 'full', 'none']),
+              help='Enable/disable debug logging (on/off/minimal/full)')
+@click.option('--no-debug', is_flag=True, help='Disable debug logging')
 @click.option('--zexus', is_flag=True, help='Show all available Zexus commands')
+@click.option('-r', '--run-code', type=str, default=None,
+              help='Execute inline Zexus code (like python -c)')
 @click.pass_context
-def cli(ctx, syntax_style, advanced_parsing, execution_mode, debug, zexus):
+def cli(ctx, syntax_style, advanced_parsing, execution_mode, debug, no_debug, zexus, run_code):
     """Zexus Programming Language - Hybrid Interpreter/Compiler
     
     Use 'zx run --zexus' or 'zx --zexus' to see all available commands.
+    Use 'zx -r "<code>"' to execute inline Zexus code.
     """
     
     if zexus:
         show_all_commands()
         sys.exit(0)
     
-    # If no command provided, show help
-    if ctx.invoked_subcommand is None:
-        click.echo(ctx.get_help())
-        return
-    
     ctx.ensure_object(dict)
     ctx.obj['SYNTAX_STYLE'] = syntax_style
     ctx.obj['ADVANCED_PARSING'] = advanced_parsing
     ctx.obj['EXECUTION_MODE'] = execution_mode
-    ctx.obj['DEBUG'] = debug
+    ctx.obj['DEBUG'] = False
     
     # Update config based on CLI flags
-    if debug:
+    if no_debug or debug in ('off', 'none'):
+        config.disable_debug()
+        config.enable_debug_logs = False
+        ctx.obj['DEBUG'] = False
+    elif debug in ('on', 'full'):
+        config.enable_debug('full')
+        config.enable_debug_logs = True
+        ctx.obj['DEBUG'] = True
+    elif debug == 'minimal':
+        config.enable_debug('minimal')
         config.enable_debug_logs = True
+        ctx.obj['DEBUG'] = True
+
+    # Handle inline code execution: zx -r "<code>"
+    if run_code is not None:
+        _execute_inline_code(ctx, run_code)
+        return
+
+    # If no command provided, show help
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+        return
     if execution_mode == 'compiler':
         config.use_hybrid_compiler = True
     elif execution_mode == 'interpreter':
         config.use_hybrid_compiler = False
 
+
+def _execute_inline_code(ctx, source_code):
+    """Execute inline Zexus code passed via -r flag.
+    
+    Examples:
+        zx -r "print(42)"
+        zx -r "let x = 10; print(x * 2)"
+        zx -r "action greet(name) { print(\"Hello \" + name) }; greet(\"World\")"
+    """
+    error_reporter = get_error_reporter()
+
+    try:
+        # Register source for error reporting
+        error_reporter.register_source("<inline>", source_code)
+
+        syntax_style = ctx.obj['SYNTAX_STYLE']
+        advanced_parsing = ctx.obj['ADVANCED_PARSING']
+        debug_mode = ctx.obj.get('DEBUG', False)
+        validator = SyntaxValidator()
+
+        # Auto-detect syntax style if needed
+        if syntax_style == 'auto':
+            syntax_style = validator.suggest_syntax_style(source_code)
+
+        # Parse the program
+        lexer = Lexer(source_code, filename="<inline>")
+        parser = Parser(lexer, syntax_style, enable_advanced_strategies=advanced_parsing)
+        program = parser.parse_program()
+
+        if parser.errors and any("critical" in e.lower() for e in parser.errors):
+            console.print("[bold red]❌ Parse error in inline code:[/bold red]")
+            for error in parser.errors:
+                console.print(f"  ❌ {error}")
+            sys.exit(1)
+
+        # Set up environment
+        env = Environment()
+        env.set("__file__", String("<inline>"))
+        env.set("__FILE__", String("<inline>"))
+        env.set("__MODULE__", String("__main__"))
+        env.set("__DIR__", String(os.getcwd()))
+
+        from ..object import List as ZList
+        env.set("__ARGS__", ZList([]))
+        env.set("__ARGV__", ZList([]))
+        env.set("__PACKAGE__", String(""))
+
+        # Attempt VM execution first, fall back to interpreter
+        bytecode = None
+        fallback_reason = None
+
+        try:
+            bytecode = compile_ast_to_bytecode(program, optimize=True)
+        except UnsupportedNodeError as e:
+            fallback_reason = str(e)
+        except Exception as e:
+            fallback_reason = str(e)
+
+        if bytecode is not None and fallback_reason is None:
+            vm = VM(
+                mode=VMMode.AUTO,
+                use_jit=True,
+                max_heap_mb=512,
+                debug=debug_mode,
+                gas_limit=10000000
+            )
+            # Load builtins into VM
+            try:
+                builtin_evaluator = Evaluator(use_vm=False)
+                vm.builtins.update(dict(builtin_evaluator.builtins))
+            except Exception:
+                pass
+
+            vm.env["__file__"] = "<inline>"
+            vm.env["__FILE__"] = "<inline>"
+            vm.env["__MODULE__"] = "__main__"
+            vm.env["__DIR__"] = os.getcwd()
+            vm.env["__ARGS__"] = ()
+            vm.env["__ARGV__"] = ()
+            vm.env["__PACKAGE__"] = ""
+
+            try:
+                result = vm.execute(bytecode, debug=debug_mode)
+            except Exception as e:
+                if debug_mode:
+                    import traceback
+                    traceback.print_exc()
+                fallback_reason = str(e)
+
+        if fallback_reason is not None:
+            result = evaluate(program, env, debug_mode=debug_mode, use_vm=False)
+        elif bytecode is None:
+            result = evaluate(program, env, debug_mode=debug_mode, use_vm=False)
+
+        # Print result if meaningful
+        if result and hasattr(result, 'inspect') and result.inspect() != 'null':
+            console.print(result.inspect())
+        elif isinstance(result, str) and result:
+            console.print(result)
+        elif hasattr(result, 'value') and result.value is not None:
+            console.print(str(result.value))
+
+    except ZexusError as e:
+        print_error(e)
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {str(e)}")
+        if ctx.obj.get('DEBUG'):
+            import traceback
+            traceback.print_exc()
+        sys.exit(1)
+
+
 @cli.command()
 @click.argument('file', type=click.Path(exists=True))
 @click.argument('args', nargs=-1)  # Accept any number of additional arguments
-@click.option('--use-vm', is_flag=True, default=True, help='Use VM for execution (default: enabled for performance)')
+@click.option('--use-vm/--no-vm', default=True, help='Use VM for execution (default: enabled for performance)')
 @click.option('--vm-mode', type=click.Choice(['auto', 'stack', 'register', 'parallel']),
               default='auto', help='VM execution mode (auto=best performance)')
 @click.option('--no-optimize', is_flag=True, default=False, help='Disable bytecode optimizations')
+@click.option('--precompile-modules', is_flag=True, default=False,
+              help='Pre-parse and cache all imported modules before execution')
 @click.pass_context
-def run(ctx, file, args, use_vm, vm_mode, no_optimize):
+def run(ctx, file, args, use_vm, vm_mode, no_optimize, precompile_modules):
     """Run a Zexus program with hybrid execution"""
     # Register source for error reporting
     error_reporter = get_error_reporter()
@@ -208,6 +349,37 @@ def run(ctx, file, args, use_vm, vm_mode, no_optimize):
         
         # Register source with error reporter
         error_reporter.register_source(file, source_code)
+
+        # Apply in-file execution flags (if any)
+        file_flags = parse_file_flags(source_code)
+        vm_config = {}
+        if file_flags:
+            if 'use_vm' in file_flags:
+                use_vm = bool(file_flags.get('use_vm'))
+            if 'vm_mode' in file_flags:
+                vm_mode = str(file_flags.get('vm_mode')).lower()
+            if 'no_optimize' in file_flags:
+                no_optimize = bool(file_flags.get('no_optimize'))
+            if 'precompile_modules' in file_flags:
+                precompile_modules = bool(file_flags.get('precompile_modules'))
+            if 'syntax_style' in file_flags:
+                ctx.obj['SYNTAX_STYLE'] = str(file_flags.get('syntax_style'))
+            if 'advanced_parsing' in file_flags:
+                ctx.obj['ADVANCED_PARSING'] = bool(file_flags.get('advanced_parsing'))
+            if 'execution_mode' in file_flags:
+                ctx.obj['EXECUTION_MODE'] = str(file_flags.get('execution_mode'))
+            if 'debug' in file_flags:
+                dbg = file_flags.get('debug')
+                if isinstance(dbg, str):
+                    config.debug_level = dbg
+                    ctx.obj['DEBUG'] = dbg != 'none'
+                else:
+                    ctx.obj['DEBUG'] = bool(dbg)
+                    config.enable_debug_logs = ctx.obj['DEBUG']
+            if 'vm_config' in file_flags and isinstance(file_flags.get('vm_config'), dict):
+                vm_config = dict(file_flags.get('vm_config'))
+
+            console.print("[dim]Applied file flags (@zexus) overrides[/dim]")
         
         syntax_style = ctx.obj['SYNTAX_STYLE']
         advanced_parsing = ctx.obj['ADVANCED_PARSING']
@@ -256,7 +428,36 @@ def run(ctx, file, args, use_vm, vm_mode, no_optimize):
             for error in parser.errors:
                 console.print(f"  ❌ {error}")
             sys.exit(1)
-        
+
+        # Pre-compile imported modules (parse + optional bytecode) before execution
+        if precompile_modules:
+            console.print("[dim]Pre-compiling imported modules...[/dim]", end="")
+            try:
+                from ..module_cache import precompile_modules as _precompile
+                import os as _os
+                _abs = _os.path.abspath(file)
+                precompiled = _precompile(program, _abs, compile_bytecode=use_vm)
+                if precompiled:
+                    console.print(f" [green]done[/green] ({len(precompiled)} module(s) cached)")
+                else:
+                    console.print(" [green]done[/green] (no external modules)")
+            except Exception as e:
+                console.print(f" [yellow]warning:[/yellow] {e}")
+
+        # Static type checking pass
+        try:
+            from ..type_checker import StaticTypeChecker
+            _tc = StaticTypeChecker()
+            _type_diags = _tc.check(program)
+            if _type_diags:
+                for _d in _type_diags:
+                    if _d.level == "error":
+                        console.print(f"  [bold red]✗ {_d}[/bold red]")
+                    else:
+                        console.print(f"  [yellow]⚠ {_d}[/yellow]")
+        except Exception:
+            pass  # type checker should never block execution
+
         # Use the evaluator package
         env = Environment()
         
@@ -287,6 +488,11 @@ def run(ctx, file, args, use_vm, vm_mode, no_optimize):
         env.set("__PACKAGE__", package_name)
         
         # Execute based on mode
+        if not use_vm:
+            try:
+                env.disable_vm = True
+            except Exception:
+                pass
         bytecode = None
         fallback_reason = None
 
@@ -313,20 +519,41 @@ def run(ctx, file, args, use_vm, vm_mode, no_optimize):
                 fallback_reason = str(e)
 
         if bytecode is not None and fallback_reason is None:
-            vm_mode_enum = {
+            vm_mode_map = {
                 'auto': VMMode.AUTO,
                 'stack': VMMode.STACK,
                 'register': VMMode.REGISTER,
                 'parallel': VMMode.PARALLEL
-            }[vm_mode]
+            }
+            vm_mode_value = vm_mode if vm_mode in vm_mode_map else 'auto'
+            vm_mode_enum = vm_mode_map[vm_mode_value]
+
+            vm_builtins = {}
+            try:
+                builtin_evaluator = Evaluator(use_vm=False)
+                vm_builtins = dict(builtin_evaluator.builtins)
+            except Exception:
+                vm_builtins = {}
 
             console.print(f"[dim]Initializing VM ({vm_mode} mode)...[/dim]", end="")
             vm = VM(
                 mode=vm_mode_enum,
                 use_jit=not no_optimize,
                 max_heap_mb=1000,  # 1GB heap limit
-                debug=ctx.obj.get('DEBUG', False)
+                debug=ctx.obj.get('DEBUG', False),
+                gas_limit=100000000  # 100M instructions for heavy checks
             )
+            if vm_builtins:
+                vm.builtins.update(vm_builtins)
+            apply_vm_config(vm, vm_config)
+            # Mirror interpreter module context for relative imports in VM
+            vm.env["__file__"] = abs_file
+            vm.env["__FILE__"] = abs_file
+            vm.env["__MODULE__"] = "__main__"
+            vm.env["__DIR__"] = os.path.dirname(abs_file)
+            vm.env["__ARGS__"] = args
+            vm.env["__ARGV__"] = args
+            vm.env["__PACKAGE__"] = package_name.value if hasattr(package_name, "value") else package_name
             console.print(" [green]done[/green]")
 
             console.print("[dim]Executing on VM...[/dim]")
@@ -341,10 +568,10 @@ def run(ctx, file, args, use_vm, vm_mode, no_optimize):
 
         if fallback_reason is not None:
             console.print("[bold yellow]🔄 Falling back to interpreter execution...[/bold yellow]")
-            result = evaluate(program, env, debug_mode=ctx.obj['DEBUG'])
+            result = evaluate(program, env, debug_mode=ctx.obj['DEBUG'], use_vm=False)
         elif bytecode is None:
             # No bytecode generated but VM not requested or compile skipped
-            result = evaluate(program, env, debug_mode=ctx.obj['DEBUG'])
+            result = evaluate(program, env, debug_mode=ctx.obj['DEBUG'], use_vm=False)
         
         if result and hasattr(result, 'inspect') and result.inspect() != 'null':
             console.print(f"\n✅ [bold green]Result:[/bold green] {result.inspect()}")
@@ -428,6 +655,59 @@ def check(ctx, file):
         console.print(f"[bold red]Error:[/bold red] {str(e)}")
         sys.exit(1)
 
+
+@cli.command()
+@click.argument('file', type=click.Path(exists=True))
+@click.option('--target', '-t', type=click.Choice(['wasm']), default='wasm',
+              help='Compilation target (default: wasm)')
+@click.option('-o', '--output', type=click.Path(), default=None,
+              help='Output file path (default: <input>.wasm)')
+@click.pass_context
+def compile(ctx, file, target, output):
+    """Compile a Zexus file to a target format (e.g. WebAssembly)."""
+    import os
+    try:
+        with open(file, 'r') as f:
+            source_code = f.read()
+
+        syntax_style = ctx.obj['SYNTAX_STYLE']
+        advanced_parsing = ctx.obj['ADVANCED_PARSING']
+
+        lexer = Lexer(source_code)
+        parser = Parser(lexer, syntax_style, enable_advanced_strategies=advanced_parsing)
+        program = parser.parse_program()
+
+        if parser.errors:
+            console.print("[bold red]❌ Parse errors — cannot compile:[/bold red]")
+            for err in parser.errors:
+                console.print(f"  🚫 {err}")
+            sys.exit(1)
+
+        # Compile AST → bytecode
+        from ..vm.compiler import BytecodeCompiler as BCCompiler
+        bc_compiler = BCCompiler()
+        bytecode = bc_compiler.compile(program)
+
+        if target == 'wasm':
+            from ..vm.wasm_compiler import WasmCompiler
+            wasm = WasmCompiler().compile(bytecode)
+
+            out_path = output or os.path.splitext(file)[0] + '.wasm'
+            with open(out_path, 'wb') as wf:
+                wf.write(wasm)
+
+            console.print(f"[bold green]✅ Compiled to WASM:[/bold green] {out_path} ({len(wasm)} bytes)")
+        else:
+            console.print(f"[bold red]Unknown target: {target}[/bold red]")
+            sys.exit(1)
+
+    except Exception as e:
+        console.print(f"[bold red]Compile error:[/bold red] {str(e)}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
 @cli.command()
 @click.argument('file', type=click.Path(exists=True))
 @click.pass_context

package/src/zexus/cli/zpm.py

@@ -18,7 +18,7 @@ console = Console()
 
 
 @click.group()
-@click.version_option(version="1.7.1", prog_name="ZPM")
+@click.version_option(version="1.7.2", prog_name="ZPM")
 def cli():
     """ZPM - Zexus Package Manager
     

package/src/zexus/compiler/lexer.py

@@ -39,12 +39,17 @@ class Lexer:
             return self.input[self.read_position]
 
     def next_token(self):
-        self.skip_whitespace()
+        # Avoid recursion: long files can contain thousands of consecutive
+        # comments/blank lines.
+        while True:
+            self.skip_whitespace()
+
+            # Skip single line comments
+            if self.ch == '#' and self.peek_char() != '{':
+                self.skip_comment()
+                continue
 
-        # Skip single line comments
-        if self.ch == '#' and self.peek_char() != '{':
-            self.skip_comment()
-            return self.next_token()
+            break
 
         tok = None
         current_line = self.line

package/src/zexus/concurrency_system.py

@@ -468,6 +468,85 @@ class ConcurrencyManager:
                 f"tasks={stats['tasks_completed']}/{stats['tasks_total']})")
 
 
+# ---------------------------------------------------------------------------
+# AsyncChannel — asyncio-native channel for the shared event loop
+# ---------------------------------------------------------------------------
+
+class AsyncChannel:
+    """
+    Async-native channel backed by :class:`asyncio.Queue`.
+
+    Unlike :class:`Channel` (which uses ``threading`` primitives), this
+    channel is designed to be used inside coroutines running on the shared
+    Zexus event loop.  ``send`` and ``receive`` are ``async`` methods.
+
+    Example (inside a Zexus ``async action``)::
+
+        ch = AsyncChannel("numbers", capacity=10)
+        await ch.send(42)
+        val = await ch.receive()  # 42
+        ch.close()
+    """
+
+    def __init__(self, name: str, element_type: Optional[str] = None,
+                 capacity: int = 0):
+        self.name = name
+        self.element_type = element_type
+        self.capacity = capacity
+        self._closed = False
+
+        import asyncio as _asyncio
+        if capacity > 0:
+            self._queue: _asyncio.Queue = _asyncio.Queue(maxsize=capacity)
+        else:
+            self._queue = _asyncio.Queue()
+
+    @property
+    def is_open(self) -> bool:
+        return not self._closed
+
+    async def send(self, value, *, timeout: Optional[float] = None):
+        """Send *value* into the channel (async, may block if full)."""
+        if self._closed:
+            raise RuntimeError(f"Cannot send on closed async channel '{self.name}'")
+        import asyncio as _asyncio
+        if timeout is not None:
+            await _asyncio.wait_for(self._queue.put(value), timeout=timeout)
+        else:
+            await self._queue.put(value)
+
+    async def receive(self, *, timeout: Optional[float] = None):
+        """Receive a value from the channel (async, may block if empty)."""
+        if self._closed and self._queue.empty():
+            return None
+        import asyncio as _asyncio
+        try:
+            if timeout is not None:
+                value = await _asyncio.wait_for(self._queue.get(), timeout=timeout)
+            else:
+                value = await self._queue.get()
+            if isinstance(value, _ChannelClosedSentinel):
+                return None
+            return value
+        except _asyncio.TimeoutError:
+            if self._closed:
+                return None
+            raise RuntimeError(f"Timeout receiving from async channel '{self.name}'")
+
+    def close(self):
+        """Close the channel.  Pending receivers will get ``None``."""
+        self._closed = True
+        try:
+            self._queue.put_nowait(_CHANNEL_CLOSED_SENTINEL)
+        except Exception:
+            pass
+
+    def __repr__(self) -> str:
+        mode = f"buffered({self.capacity})" if self.capacity > 0 else "unbuffered"
+        status = "closed" if self._closed else "open"
+        return f"AsyncChannel<{self.element_type}>({self.name}, {mode}, {status})"
+
+
 # Global singleton instance
 _concurrency_manager: Optional[ConcurrencyManager] = None
 

package/src/zexus/config.py

@@ -28,6 +28,11 @@ DEFAULT_RUNTIME = {
     'enable_advanced_parsing': True,
     'enable_debug_logs': False,
     'enable_parser_debug': False,  # OPTIMIZATION: Disable parser debug output for speed
+    # Large-file stability: advanced parsing does extra analysis and can be
+    # significantly heavier on very large sources. For big files, we prefer the
+    # traditional streaming parser for stability.
+    'advanced_parsing_max_lines': 2000,
+    'advanced_parsing_max_tokens': 50000,
     # Legacy runtime flags expected by older modules
     'use_hybrid_compiler': True,
     'fallback_to_interpreter': True,
@@ -40,8 +45,15 @@ class Config:
     def __init__(self):
         self.config_dir = Path.home() / ".zexus"
         self.config_file = self.config_dir / "config.json"
+        
+        # Fast caching attribute for hot paths
+        self.fast_debug_enabled = False
+        
         self._data = DEFAULT_CONFIG.copy()
         self._ensure_loaded()
+        
+        # Update cache from initial loaded data
+        self.fast_debug_enabled = (self.debug_level != 'none')
 
         # ensure runtime defaults exist for backward compatibility
         self._data.setdefault('runtime', {})
@@ -93,6 +105,7 @@ class Config:
             raise ValueError('Invalid debug level')
         self._data.setdefault('debug', {})['level'] = value
         self._data['debug']['enabled'] = (value != 'none')
+        self.fast_debug_enabled = (value != 'none')
         self._write()
 
     def enable_debug(self, level='full'):
@@ -143,6 +156,47 @@ class Config:
             self.debug_level = 'none'
 
     # Legacy runtime properties
+    @property
+    def enable_parser_debug(self):
+        return bool(self._data.get('runtime', {}).get('enable_parser_debug', False))
+
+    @enable_parser_debug.setter
+    def enable_parser_debug(self, value):
+        self._data.setdefault('runtime', {})['enable_parser_debug'] = bool(value)
+        self._write()
+
+    @property
+    def advanced_parsing_max_lines(self):
+        try:
+            return int(self._data.get('runtime', {}).get('advanced_parsing_max_lines', 2000))
+        except Exception:
+            return 2000
+
+    @advanced_parsing_max_lines.setter
+    def advanced_parsing_max_lines(self, value):
+        try:
+            v = int(value)
+        except Exception:
+            v = 2000
+        self._data.setdefault('runtime', {})['advanced_parsing_max_lines'] = v
+        self._write()
+
+    @property
+    def advanced_parsing_max_tokens(self):
+        try:
+            return int(self._data.get('runtime', {}).get('advanced_parsing_max_tokens', 50000))
+        except Exception:
+            return 50000
+
+    @advanced_parsing_max_tokens.setter
+    def advanced_parsing_max_tokens(self, value):
+        try:
+            v = int(value)
+        except Exception:
+            v = 50000
+        self._data.setdefault('runtime', {})['advanced_parsing_max_tokens'] = v
+        self._write()
+
     @property
     def use_hybrid_compiler(self):
         return self._data.get('runtime', {}).get('use_hybrid_compiler', True)