zexus 1.6.7 → 1.7.1

package/README.md

@@ -2,14 +2,14 @@
 
 <div align="center">
 
-![Zexus Logo](https://img.shields.io/badge/Zexus-v1.6.7-FF6B35?style=for-the-badge)
+![Zexus Logo](https://img.shields.io/badge/Zexus-v1.7.1-FF6B35?style=for-the-badge)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge)](LICENSE)
 [![Python](https://img.shields.io/badge/Python-3.8+-3776AB?style=for-the-badge&logo=python)](https://python.org)
 [![GitHub](https://img.shields.io/badge/GitHub-Zaidux/zexus--interpreter-181717?style=for-the-badge&logo=github)](https://github.com/Zaidux/zexus-interpreter)
 
 **A modern, security-first programming language with built-in blockchain support, VM-accelerated execution, advanced memory management, and policy-as-code**
 
-[What's New](#-whats-new-in-v150) • [Features](#-key-features) • [Installation](#-installation) • [Quick Start](#-quick-start) • [Keywords](#-complete-keyword-reference) • [Documentation](#-documentation) • [Examples](#-examples) • [Troubleshooting](#-getting-help--troubleshooting)
+[What's New](#-whats-new-in-v171) • [Features](#-key-features) • [Installation](#-installation) • [Quick Start](#-quick-start) • [Keywords](#-complete-keyword-reference) • [Documentation](#-documentation) • [Examples](#-examples) • [Troubleshooting](#-getting-help--troubleshooting)
 
 </div>
 
@@ -18,7 +18,7 @@
 ## 📋 Table of Contents
 
 - [What is Zexus?](#-what-is-zexus)
-- [What's New](#-whats-new-in-v150)
+- [What's New](#-whats-new-in-v171)
 - [Key Features](#-key-features)
   - [VM-Accelerated Performance](#-vm-accelerated-performance-new)
   - [Security & Policy-as-Code](#-security--policy-as-code--verify-enhanced)
@@ -67,9 +67,16 @@ Zexus is a next-generation, general-purpose programming language designed for se
 
 ---
 
-## 🎉 What's New in v1.6.3
+## 🎉 What's New in v1.7.1
 
-### Latest Features (v1.6.3)
+### Latest Features (v1.7.1)
+
+✅ **FIND Keyword** - Declarative project search that resolves exact module paths with scope filtering and smart suggestions  
+✅ **LOAD Keyword & Manager** - Provider-aware configuration loader with built-in ENV, JSON, and YAML support plus caching  
+✅ **VM + Bytecode Support** - FIND/LOAD now compile to bytecode with helper bridges so scripts run identically in the VM and interpreter  
+✅ **Targeted Test Coverage** - Added regression tests that exercise both interpreter and VM paths for FIND/LOAD workflows  
+
+### Previous Features (v1.6.3)
 
 ✅ **Complete Database Ecosystem** - Production-ready database drivers  
 ✅ **4 Database Drivers** - SQLite, PostgreSQL, MySQL, MongoDB fully tested  

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zexus",
-  "version": "1.6.7",
+  "version": "1.7.1",
   "description": "A modern, security-first programming language with blockchain support",
   "main": "index.js",
   "bin": {

package/src/zexus/__init__.py

@@ -4,7 +4,7 @@ Zexus Programming Language
 A declarative, intent-based programming language for modern applications.
 """
 
-__version__ = "1.6.7"
+__version__ = "1.7.1"
 __author__ = "Ziver Labs"
 __email__ = "ziverofficial567@gmail.com"
 

package/src/zexus/capability_system.py

@@ -5,7 +5,8 @@ Implements fine-grained access control through capability tokens.
 Plugins declare required capabilities, and the evaluator enforces access.
 """
 
-from typing import Set, Dict, List, Callable, Optional, Tuple
+from typing import Set, Dict, List, Callable, Optional, Tuple, Any
+import uuid
 from dataclasses import dataclass, field
 from enum import Enum
 import time
@@ -173,6 +174,8 @@ class CapabilityManager:
         self.audit_log = CapabilityAuditLog()
         self.granted_capabilities: Dict[str, Set[str]] = {}  # requester -> capabilities
         self.required_capabilities: Dict[str, Set[str]] = {}  # requester -> required caps
+        self._contexts: Dict[str, "CapabilityContext"] = {}
+        self._context_counter = 0
         
         # Initialize with base capabilities
         for cap in self.BASE_CAPABILITIES:
@@ -197,6 +200,19 @@ class CapabilityManager:
         for cap in capabilities:
             self.grant_capability(requester, cap)
     
+    def revoke_capability(self, requester: str, capability: str):
+        """Revoke a specific capability from a requester."""
+        caps = self.granted_capabilities.get(requester)
+        if not caps:
+            return
+        caps.discard(capability)
+        if not caps:
+            self.granted_capabilities.pop(requester, None)
+
+    def revoke_all_capabilities(self, requester: str):
+        """Remove all capabilities granted to a requester."""
+        self.granted_capabilities.pop(requester, None)
+
     def check_capability(self, requester: str, capability: str, 
                         context: Optional[Dict] = None) -> Tuple[bool, str]:
         """
@@ -210,29 +226,49 @@ class CapabilityManager:
             requester=requester,
             context=context or {}
         )
-        
-        # 1. Check if policy allows all (AllowAllPolicy)
+
+        context_obj = self._contexts.get(requester)
+
+        # 1. Context-specific policy enforcement (takes precedence)
+        if context_obj and context_obj.policy:
+            policy_level = context_obj.policy.check(capability)
+            if policy_level in (CapabilityLevel.ALLOWED, CapabilityLevel.UNRESTRICTED, CapabilityLevel.RESTRICTED):
+                reason = (
+                    f"Capability {capability} allowed by context policy "
+                    f"'{context_obj.policy.name}'"
+                )
+                self.audit_log.log_request(request, True, reason)
+                return True, reason
+            if policy_level == CapabilityLevel.DENY:
+                reason = (
+                    f"Capability {capability} denied by context policy "
+                    f"'{context_obj.policy.name}'"
+                )
+                self.audit_log.log_request(request, False, reason)
+                return False, reason
+
+        # 2. Check if policy allows all (AllowAllPolicy)
         if isinstance(self.policy, AllowAllPolicy):
             reason = f"Capability {capability} allowed by policy (allow-all)"
             self.audit_log.log_request(request, True, reason)
             return True, reason
-        
-        # 2. Check if capability is base capability (always available)
+
+        # 3. Check if capability is base capability (always available)
         if capability in self.BASE_CAPABILITIES:
             reason = f"Base capability {capability} available"
             self.audit_log.log_request(request, True, reason)
             return True, reason
-        
-        # 3. Check if requester has been explicitly granted this capability
+
+        # 4. Check if requester has been explicitly granted this capability
         if requester in self.granted_capabilities:
             if capability in self.granted_capabilities[requester]:
                 reason = f"Capability {capability} granted to {requester}"
                 self.audit_log.log_request(request, True, reason)
                 return True, reason
         
-        # 4. Check if capability is allowed by policy
+        # 5. Check if capability is allowed by policy
         policy_level = self.policy.check(capability)
-        if policy_level == CapabilityLevel.ALLOWED:
+        if policy_level in (CapabilityLevel.ALLOWED, CapabilityLevel.UNRESTRICTED, CapabilityLevel.RESTRICTED):
             reason = f"Capability {capability} allowed by policy"
             self.audit_log.log_request(request, True, reason)
             return True, reason
@@ -291,6 +327,97 @@ class CapabilityManager:
         """Get audit statistics."""
         return self.audit_log.get_statistics()
 
+    def create_context(
+        self,
+        *,
+        capabilities: Optional[List[str]] = None,
+        policy: Optional[CapabilityPolicy] = None,
+        name: Optional[str] = None,
+        inherit_base: bool = True,
+    ) -> "CapabilityContext":
+        """Create a scoped capability context."""
+        self._context_counter += 1
+        context_name = name or f"context::{self._context_counter}:{uuid.uuid4().hex[:8]}"
+        context = CapabilityContext(
+            manager=self,
+            name=context_name,
+            capabilities=capabilities or [],
+            policy=policy,
+            inherit_base=inherit_base,
+        )
+        self._contexts[context.name] = context
+        return context
+
+    def destroy_context(self, name: str) -> Optional["CapabilityContext"]:
+        """Destroy a previously created context and revoke its grants."""
+        context = self._contexts.pop(name, None)
+        if context:
+            context.destroy()
+        return context
+
+    def get_context(self, name: str) -> Optional["CapabilityContext"]:
+        """Retrieve a context by name, if it exists."""
+        return self._contexts.get(name)
+
+
+class CapabilityContext:
+    """Lightweight wrapper for scoped capability enforcement."""
+
+    def __init__(
+        self,
+        *,
+        manager: CapabilityManager,
+        name: str,
+        capabilities: Optional[List[str]] = None,
+        policy: Optional[CapabilityPolicy] = None,
+        inherit_base: bool = True,
+    ) -> None:
+        self.manager = manager
+        self.name = name
+        self.policy = policy or SelectivePolicy(capabilities or [])
+        self.capabilities: Set[str] = set(capabilities or [])
+        self.inherit_base = inherit_base
+        self.created_at = time.time()
+
+        if self.capabilities:
+            self.manager.grant_capabilities(self.name, list(self.capabilities))
+        elif inherit_base:
+            # Ensure entry exists so future grants can be tracked cleanly
+            self.manager.granted_capabilities.setdefault(self.name, set())
+
+    def grant(self, capability: str) -> None:
+        """Grant an additional capability to this context."""
+        self.manager.grant_capability(self.name, capability)
+        self.capabilities.add(capability)
+
+    def revoke(self, capability: str) -> None:
+        """Revoke a capability from this context."""
+        self.manager.revoke_capability(self.name, capability)
+        self.capabilities.discard(capability)
+
+    def check(self, capability: str, *, context: Optional[Dict] = None) -> bool:
+        """Check if the context can access a capability."""
+        allowed, _ = self.manager.check_capability(self.name, capability, context)
+        return allowed
+
+    def require(self, capability: str, *, context: Optional[Dict] = None) -> bool:
+        """Require a capability, raising if unavailable."""
+        self.manager.require_capability(self.name, capability, context)
+        return True
+
+    def snapshot(self) -> Dict[str, Any]:
+        """Return a serializable snapshot of the context state."""
+        return {
+            "name": self.name,
+            "capabilities": self.manager.get_granted_capabilities(self.name),
+            "policy": getattr(self.policy, "name", None),
+            "created_at": self.created_at,
+        }
+
+    def destroy(self) -> None:
+        """Revoke all privileges associated with this context."""
+        self.manager.revoke_all_capabilities(self.name)
+
 
 class CapabilityError(Exception):
     """Exception raised when capability check fails."""
@@ -370,3 +497,51 @@ CAPABILITY_SETS = {
         "description": "Full system access (privileged code)"
     }
 }
+
+
+_DEFAULT_MANAGER: CapabilityManager = CapabilityManager()
+
+
+def get_capability_manager() -> CapabilityManager:
+    """Return the global capability manager singleton."""
+    return _DEFAULT_MANAGER
+
+
+def set_capability_manager(manager: CapabilityManager) -> None:
+    """Replace the global capability manager (primarily for tests)."""
+    global _DEFAULT_MANAGER
+    _DEFAULT_MANAGER = manager
+
+
+def reset_capability_manager(policy: Optional[CapabilityPolicy] = None) -> CapabilityManager:
+    """Reset the global capability manager to a fresh instance."""
+    manager = CapabilityManager(default_policy=policy)
+    set_capability_manager(manager)
+    return manager
+
+
+def check_capability(capability: str, requester: str, *, context: Optional[Dict] = None) -> bool:
+    """Convenience wrapper around the global manager's check."""
+    manager = get_capability_manager()
+    allowed, _ = manager.check_capability(requester, capability, context)
+    return allowed
+
+
+__all__ = [
+    "Capability",
+    "CapabilityLevel",
+    "CapabilityPolicy",
+    "CapabilityManager",
+    "CapabilityContext",
+    "CapabilityError",
+    "AllowAllPolicy",
+    "DenyAllPolicy",
+    "SelectivePolicy",
+    "CapabilityAuditLog",
+    "CapabilityRequest",
+    "CAPABILITY_SETS",
+    "get_capability_manager",
+    "set_capability_manager",
+    "reset_capability_manager",
+    "check_capability",
+]

package/src/zexus/cli/main.py

@@ -3,10 +3,66 @@ import click
 import sys
 import os
 from pathlib import Path
-from rich.console import Console
-from rich.syntax import Syntax
-from rich.panel import Panel
-from rich.table import Table
+
+try:  # Optional rich dependency for colorful CLI output
+    from rich.console import Console
+    from rich.syntax import Syntax
+    from rich.panel import Panel
+    from rich.table import Table
+    _RICH_AVAILABLE = True
+except ModuleNotFoundError:  # Fallback to minimal console utilities when rich is missing
+    _RICH_AVAILABLE = False
+
+    class Console:  # pragma: no cover - straightforward fallback
+        def print(self, *args, **kwargs):
+            sep = kwargs.get("sep", " ")
+            end = kwargs.get("end", "\n")
+            text = sep.join(str(arg) for arg in args)
+            sys.stdout.write(text)
+            if end is not None:
+                sys.stdout.write(end)
+
+        def rule(self, title=""):
+            line = "-" * 40
+            if title:
+                line = f"{line} {title} {line}"
+            self.print(line)
+
+    class Syntax:  # pragma: no cover - fallback keeps interface compatible
+        def __init__(self, code, *_args, **_kwargs):
+            self.code = code
+
+        def __str__(self):
+            return self.code
+
+    class Panel:  # pragma: no cover
+        def __init__(self, renderable, title=None):
+            self.renderable = renderable
+            self.title = title
+
+        def __str__(self):
+            if self.title:
+                return f"[{self.title}] {self.renderable}"
+            return str(self.renderable)
+
+    class Table:  # pragma: no cover
+        def __init__(self, **_kwargs):
+            self.columns = []
+            self.rows = []
+
+        def add_column(self, header, **_kwargs):
+            self.columns.append(header)
+
+        def add_row(self, *columns):
+            self.rows.append(columns)
+
+        def __str__(self):
+            lines = []
+            if self.columns:
+                lines.append(" | ".join(self.columns))
+            for row in self.rows:
+                lines.append(" | ".join(str(col) for col in row))
+            return "\n".join(lines)
 
 # Import your existing modules - UPDATED IMPORTS
 from ..lexer import Lexer
@@ -20,6 +76,9 @@ from ..hybrid_orchestrator import orchestrator
 from ..config import config
 # Import error handling
 from ..error_reporter import get_error_reporter, ZexusError, print_error
+# VM and Compiler for high-performance execution
+from ..vm.vm import VM, VMMode
+from ..vm.compiler import compile_ast_to_bytecode, UnsupportedNodeError
 
 console = Console()
 
@@ -91,7 +150,7 @@ 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.6.7", prog_name="Zexus")
+@click.version_option(version="1.7.1", 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,
@@ -133,8 +192,12 @@ def cli(ctx, syntax_style, advanced_parsing, execution_mode, debug, zexus):
 @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('--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.pass_context
-def run(ctx, file, args):
+def run(ctx, file, args, use_vm, vm_mode, no_optimize):
     """Run a Zexus program with hybrid execution"""
     # Register source for error reporting
     error_reporter = get_error_reporter()
@@ -155,6 +218,8 @@ def run(ctx, file, args):
         console.print(f"🔧 [bold blue]Execution mode:[/bold blue] {execution_mode}")
         console.print(f"📝 [bold blue]Syntax style:[/bold blue] {syntax_style}")
         console.print(f"🎯 [bold blue]Advanced parsing:[/bold blue] {'Enabled' if advanced_parsing else 'Disabled'}")
+        if use_vm:
+            console.print(f"⚡ [bold magenta]VM Mode:[/bold magenta] {vm_mode.upper()} | Optimizations: {'OFF' if no_optimize else 'ON'}")
         
         # Auto-detect syntax style if needed
         if syntax_style == 'auto':
@@ -221,8 +286,65 @@ def run(ctx, file, args):
             pass  # Unable to determine package name
         env.set("__PACKAGE__", package_name)
         
-        # UPDATED: Use the evaluate function from the evaluator package
-        result = evaluate(program, env, debug_mode=ctx.obj['DEBUG'])
+        # Execute based on mode
+        bytecode = None
+        fallback_reason = None
+
+        if use_vm:
+            # VM EXECUTION PATH (High Performance)
+            console.print("[dim]Compiling to bytecode...[/dim]", end="")
+            try:
+                bytecode = compile_ast_to_bytecode(program, optimize=not no_optimize)
+                console.print(" [green]done[/green]")
+                console.print(f"[dim]Bytecode: {len(bytecode.instructions)} instructions, {len(bytecode.constants)} constants[/dim]")
+            except UnsupportedNodeError as e:
+                console.print(" [yellow]unsupported[/yellow]")
+                console.print(f"[bold yellow]⚠️  VM fallback:[/bold yellow] {e}")
+                if ctx.obj.get('DEBUG'):
+                    import traceback
+                    traceback.print_exc()
+                fallback_reason = str(e)
+            except Exception as e:
+                console.print(" [red]failed[/red]")
+                console.print(f"[bold red]Bytecode compilation error:[/bold red] {str(e)}")
+                if ctx.obj.get('DEBUG'):
+                    import traceback
+                    traceback.print_exc()
+                fallback_reason = str(e)
+
+        if bytecode is not None and fallback_reason is None:
+            vm_mode_enum = {
+                'auto': VMMode.AUTO,
+                'stack': VMMode.STACK,
+                'register': VMMode.REGISTER,
+                'parallel': VMMode.PARALLEL
+            }[vm_mode]
+
+            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)
+            )
+            console.print(" [green]done[/green]")
+
+            console.print("[dim]Executing on VM...[/dim]")
+            try:
+                result = vm.execute(bytecode, debug=ctx.obj.get('DEBUG', False))
+            except Exception as e:
+                console.print(f"[bold red]VM Execution error:[/bold red] {str(e)}")
+                if ctx.obj.get('DEBUG'):
+                    import traceback
+                    traceback.print_exc()
+                fallback_reason = str(e)
+
+        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'])
+        elif bytecode is None:
+            # No bytecode generated but VM not requested or compile skipped
+            result = evaluate(program, env, debug_mode=ctx.obj['DEBUG'])
         
         if result and hasattr(result, 'inspect') and result.inspect() != 'null':
             console.print(f"\n✅ [bold green]Result:[/bold green] {result.inspect()}")

package/src/zexus/cli/zpm.py

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

package/src/zexus/compiler/bytecode.py

@@ -23,7 +23,9 @@ from .zexus_ast import (
     Program, LetStatement, ExpressionStatement, PrintStatement, ReturnStatement,
     IfStatement, WhileStatement, Identifier, IntegerLiteral, StringLiteral,
     Boolean as AST_Boolean, InfixExpression, PrefixExpression, CallExpression,
-    ActionStatement, BlockStatement, MapLiteral, ListLiteral, AwaitExpression
+    ActionStatement, BlockStatement, MapLiteral, ListLiteral, AwaitExpression,
+    EnumDeclaration, ImportStatement, EventDeclaration, ProtocolDeclaration,
+    EmitStatement
 )
 
 # --- Bytecode representation ---
@@ -47,12 +49,68 @@ class BytecodeGenerator:
 
     def generate(self, program: Program) -> Bytecode:
         self.bytecode = Bytecode()
-        for stmt in getattr(program, "statements", []):
-            self._emit_statement(stmt, self.bytecode)
+        statements = list(getattr(program, "statements", []) or [])
+        total = len(statements)
+        index = 0
+        while index < total:
+            stmt = statements[index]
+
+            # Pattern-match legacy import syntax: import "module" [as alias]
+            if (
+                isinstance(stmt, ExpressionStatement)
+                and isinstance(stmt.expression, Identifier)
+                and stmt.expression.value == "import"
+            ):
+                module_value = None
+                alias_value = None
+                consumed = 1
+
+                if index + 1 < total:
+                    module_stmt = statements[index + 1]
+                    if isinstance(module_stmt, ExpressionStatement):
+                        module_expr = getattr(module_stmt, "expression", None)
+                        if isinstance(module_expr, StringLiteral):
+                            module_value = module_expr.value
+                            consumed = 2
+                        elif isinstance(module_expr, Identifier):
+                            module_value = module_expr.value
+                            consumed = 2
+
+                if module_value is not None and index + consumed < total:
+                    next_stmt = statements[index + consumed]
+                    if (
+                        isinstance(next_stmt, ExpressionStatement)
+                        and isinstance(next_stmt.expression, Identifier)
+                        and next_stmt.expression.value == "as"
+                        and index + consumed + 1 < total
+                    ):
+                        alias_stmt = statements[index + consumed + 1]
+                        if isinstance(alias_stmt, ExpressionStatement) and isinstance(alias_stmt.expression, Identifier):
+                            alias_value = alias_stmt.expression.value
+                            consumed += 2
+
+                if module_value is not None:
+                    import_node = ImportStatement(module_path=module_value, alias=alias_value)
+                    self._emit_statement(
+                        import_node,
+                        self.bytecode,
+                        is_top_level=True,
+                        is_last=(index + consumed - 1 == total - 1),
+                    )
+                    index += consumed
+                    continue
+
+            self._emit_statement(
+                stmt,
+                self.bytecode,
+                is_top_level=True,
+                is_last=(index == total - 1),
+            )
+            index += 1
         return self.bytecode
 
     # Statement lowering
-    def _emit_statement(self, stmt, bc: Bytecode):
+    def _emit_statement(self, stmt, bc: Bytecode, *, is_top_level: bool = False, is_last: bool = False):
         t = type(stmt).__name__
 
         if t == "LetStatement":
@@ -64,8 +122,8 @@ class BytecodeGenerator:
 
         if t == "ExpressionStatement":
             self._emit_expression(stmt.expression, bc)
-            # drop result (no-op) or keep for top-level
-            bc.add_instruction("POP", None)
+            if not (is_top_level and is_last):
+                bc.add_instruction("POP", None)
             return
 
         if t == "PrintStatement":
@@ -125,7 +183,61 @@ class BytecodeGenerator:
             bc.instructions[jump_pos] = ("JUMP_IF_FALSE", end_pos)
             return
 
-        # Event/emit/enum/import handled at higher-level generator earlier; treat as NOP here
+        if t == "EnumDeclaration":
+            enum_name = getattr(stmt.name, "value", stmt.name)
+            members = getattr(stmt, "members", {}) or {}
+            resolved_members = {}
+            next_auto = 0
+            for key, explicit in members.items():
+                value = explicit if explicit is not None else next_auto
+                resolved_members[key] = value
+                next_auto = (value + 1) if explicit is not None else (next_auto + 1)
+
+            name_idx = bc.add_constant(enum_name)
+            members_idx = bc.add_constant(resolved_members)
+            bc.add_instruction("DEFINE_ENUM", (name_idx, members_idx))
+            return
+
+        if t == "ImportStatement":
+            module_idx = bc.add_constant(getattr(stmt, "module_path", None))
+            alias = getattr(stmt, "alias", None)
+            if alias is not None:
+                alias_idx = bc.add_constant(alias)
+                bc.add_instruction("IMPORT", (module_idx, alias_idx))
+            else:
+                bc.add_instruction("IMPORT", (module_idx,))
+            return
+
+        if t == "EventDeclaration":
+            event_name = getattr(stmt.name, "value", stmt.name)
+            name_idx = bc.add_constant(event_name)
+            bc.add_instruction("REGISTER_EVENT", name_idx)
+            return
+
+        if t == "ProtocolDeclaration":
+            proto_name = getattr(stmt.name, "value", stmt.name)
+            spec = getattr(stmt, "spec", {}) or {}
+            name_idx = bc.add_constant(proto_name)
+            spec_idx = bc.add_constant(spec)
+            bc.add_instruction("DEFINE_PROTOCOL", (name_idx, spec_idx))
+            return
+
+        if t == "EmitStatement":
+            event_name = getattr(stmt.name, "value", stmt.name)
+            name_idx = bc.add_constant(event_name)
+            if getattr(stmt, "payload", None) is not None:
+                self._emit_expression(stmt.payload, bc)
+            bc.add_instruction("EMIT_EVENT", (name_idx,))
+            return
+
+        if t == "StreamStatement":
+            # Streams are currently handled at runtime only; compiler no-op.
+            return
+
+        if t == "WatchStatement":
+            # Watch statements are runtime constructs; compiler emits no bytecode.
+            return
+
         return
 
     # Expression lowering
@@ -141,6 +253,11 @@ class BytecodeGenerator:
             bc.add_instruction("LOAD_CONST", const_idx)
             return
 
+        if typ == "FloatLiteral":
+            const_idx = bc.add_constant(float(expr.value))
+            bc.add_instruction("LOAD_CONST", const_idx)
+            return
+
         if typ == "StringLiteral":
             const_idx = bc.add_constant(expr.value)
             bc.add_instruction("LOAD_CONST", const_idx)