zexus 1.6.8 → 1.7.2

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)

package/src/zexus/compiler/compat_runtime.py

@@ -182,8 +182,12 @@ except Exception as e:
     def unwrap_return_value(obj):
         return obj
 
-    # Minimal renderer fallback
-    RENDER_REGISTRY = {'screens': {}, 'components': {}, 'themes': {}, 'canvases': {}, 'current_theme': None}
+    # Minimal renderer fallback (used when the real backend is unavailable)
+    try:
+        from ..renderer import backend as _BACKEND
+        RENDER_REGISTRY = _BACKEND.inspect_registry()
+    except Exception:
+        RENDER_REGISTRY = {'screens': {}, 'components': {}, 'themes': {}, 'canvases': {}, 'current_theme': None}
 
     # Try to create small wrappers for builtin functions by reading from object.File when present
     try:

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
@@ -211,6 +216,10 @@ class Lexer:
             "action": ACTION,
             "async": ASYNC,
             "await": AWAIT,
+            "event": EVENT,
+            "emit": EMIT,
+            "import": IMPORT,
+            "as": AS,
             "enum": ENUM,
             "protocol": PROTOCOL,
             "interface": INTERFACE,
@@ -232,6 +241,8 @@ class Lexer:
             "catch": CATCH,
             "external": EXTERNAL,
             "from": FROM,
+            "stream": STREAM,
+            "watch": WATCH,
             # Blockchain & Smart Contract keywords
             "ledger": LEDGER,
             "state": STATE,

package/src/zexus/compiler/parser.py

@@ -119,6 +119,10 @@ class ProductionParser:
                 return self.parse_protocol_declaration()
             elif self.cur_token_is(IMPORT):
                 return self.parse_import_statement()
+            elif self.cur_token_is(STREAM):
+                return self.parse_stream_statement()
+            elif self.cur_token_is(WATCH):
+                return self.parse_watch_statement()
             else:
                 return self.parse_expression_statement()
         except Exception as e:
@@ -666,8 +670,32 @@ class ProductionParser:
         if not self.expect_peek(IDENT):
             return None
         name = Identifier(self.cur_token.literal)
-        body = self.parse_block()
-        return EventDeclaration(name=name, properties=body)
+        if not self.expect_peek(LBRACE):
+            return None
+
+        properties = {}
+        self.next_token()
+        while not self.cur_token_is(RBRACE) and not self.cur_token_is(EOF):
+            if self.cur_token_is(IDENT) or self.cur_token_is(STRING):
+                key = self.cur_token.literal
+                value = None
+                if self.peek_token_is(COLON):
+                    self.next_token()
+                    self.next_token()
+                    value = self.parse_expression(LOWEST)
+                properties[key] = value
+
+            if self.peek_token_is(COMMA):
+                self.next_token()
+                self.next_token()
+                continue
+            self.next_token()
+
+        if not self.cur_token_is(RBRACE):
+            self.errors.append("Unclosed event declaration")
+            return None
+
+        return EventDeclaration(name=name, properties=properties)
 
     def parse_emit_statement(self):
         if not self.expect_peek(IDENT):
@@ -740,15 +768,88 @@ class ProductionParser:
     def parse_import_statement(self):
         if not self.expect_peek(STRING):
             return None
+
         module_path = self.cur_token.literal
         alias = None
-        if self.peek_token_is(IDENT) and self.peek_token.literal == "as":
-            self.next_token()
-            self.next_token()
-            if self.cur_token_is(IDENT):
-                alias = self.cur_token.literal
+
+        if self.peek_token_is(AS) or (self.peek_token_is(IDENT) and self.peek_token.literal == "as"):
+            self.next_token()  # advance to 'as'
+
+            if not self.expect_peek(IDENT):
+                self.errors.append(f"Line {self.cur_token.line}: Expected identifier after 'as' in import statement")
+                return None
+
+            alias = self.cur_token.literal
+
         return ImportStatement(module_path=module_path, alias=alias)
 
+    def parse_stream_statement(self):
+        token = self.cur_token
+
+        if not self.expect_peek(IDENT):
+            return None
+        stream_name = self.cur_token.literal
+
+        if not self.expect_peek(AS):
+            return None
+
+        if self.peek_token_is(IDENT) or self.peek_token_is(EVENT):
+            self.next_token()
+        else:
+            self.errors.append(f"Line {getattr(token, 'line', 'unknown')}: Expected event identifier after 'as'")
+            return None
+
+        event_token = self.cur_token
+        event_literal = getattr(event_token, 'literal', None) or getattr(event_token, 'value', None)
+        if not event_literal:
+            event_literal = event_token.type.lower()
+        event_var = Identifier(event_literal)
+
+        if not self.expect_peek(LAMBDA):
+            return None
+
+        self.next_token()
+
+        if self.cur_token_is(LBRACE):
+            handler = self.parse_block()
+        else:
+            handler_expr = self.parse_expression(LOWEST)
+            if handler_expr is None:
+                return None
+            handler = BlockStatement()
+            handler.statements.append(ExpressionStatement(handler_expr))
+
+        return StreamStatement(stream_name=stream_name, event_var=event_var, handler=handler)
+
+    def parse_watch_statement(self):
+        self.next_token()
+
+        lambda_handler = self.infix_parse_fns.pop(LAMBDA, None)
+        try:
+            watched_expr = self.parse_expression(LOWEST)
+        finally:
+            if lambda_handler is not None:
+                self.infix_parse_fns[LAMBDA] = lambda_handler
+
+        if watched_expr is None:
+            return None
+
+        if not self.expect_peek(LAMBDA):
+            return None
+
+        self.next_token()
+
+        if self.cur_token_is(LBRACE):
+            reaction = self.parse_block()
+        else:
+            reaction = BlockStatement()
+            stmt = self.parse_statement()
+            if stmt is None:
+                return None
+            reaction.statements.append(stmt)
+
+        return WatchStatement(watched_expr=watched_expr, reaction=reaction)
+
     # Token utilities
     def next_token(self):
         self.cur_token = self.peek_token

package/src/zexus/compiler/semantic.py

@@ -54,31 +54,33 @@ class SemanticAnalyzer:
 				errors.append("Invalid AST: missing 'statements' list")
 				return errors
 
-			# Run new checks: await usage and protocol/event validation
-			# Walk AST with context
+			visited = set()
+
 			def walk(node, in_async=False):
-				# Protect against cycles by tracking visited node ids
-				if not hasattr(walk, '_visited'):
-					walk._visited = set()
 				if node is None:
 					return
 				node_id = id(node)
-				if node_id in walk._visited:
+				if node_id in visited:
 					return
-				walk._visited.add(node_id)
-				# Quick type checks for relevant nodes
+				visited.add(node_id)
+
 				if isinstance(node, AwaitExpression):
 					if not in_async:
 						errors.append("Semantic error: 'await' used outside an async function")
-				# ActionStatement may have is_async flag
+						return
+					expr = getattr(node, "expression", None)
+					if hasattr(expr, "__dict__"):
+						walk(expr, in_async=True)
+					return
+
 				if isinstance(node, ActionStatement):
 					body = getattr(node, "body", None)
 					async_flag = getattr(node, "is_async", False)
 					if body:
-						# walk body with in_async = async_flag
 						for s in getattr(body, "statements", []):
 							walk(s, in_async=async_flag)
 					return
+
 				if isinstance(node, ProtocolDeclaration):
 					spec = getattr(node, "spec", {})
 					methods = spec.get("methods") if isinstance(spec, dict) else None
@@ -89,26 +91,23 @@ class SemanticAnalyzer:
 							if not isinstance(m, str):
 								errors.append(f"Protocol '{node.name.value}' has non-string method name: {m}")
 					return
+
 				if isinstance(node, EventDeclaration):
 					props = getattr(node, "properties", None)
-					if not isinstance(props, (MapLiteral, BlockStatement)):
+					if not isinstance(props, (MapLiteral, BlockStatement, dict)):
 						errors.append(f"Event '{node.name.value}' properties should be a map or block")
-					# further checks can be added
 					return
 
-				# Generic traversal
-				for attr in dir(node):
-					if attr.startswith("_") or attr in ("token_literal", "__repr__"):
+				for attr, val in vars(node).items():
+					if attr.startswith("_") or attr in ("token", "token_literal"):
 						continue
-					val = getattr(node, attr)
 					if isinstance(val, list):
 						for item in val:
-							if hasattr(item, "__class__"):
+							if hasattr(item, "__dict__"):
 								walk(item, in_async=in_async)
-					elif hasattr(val, "__class__"):
+					elif hasattr(val, "__dict__"):
 						walk(val, in_async=in_async)
 
-			# Walk top-level statements
 			for s in stmts:
 				walk(s, in_async=False)
 

package/src/zexus/compiler/zexus_ast.py

@@ -451,4 +451,29 @@ class ImportStatement(Statement):
         return "import"
 
     def __repr__(self):
-        return f"ImportStatement({self.module_path} as {self.alias})"
+        return f"ImportStatement({self.module_path} as {self.alias})"
+
+
+class StreamStatement(Statement):
+    def __init__(self, stream_name, event_var, handler):
+        self.stream_name = stream_name
+        self.event_var = event_var
+        self.handler = handler
+
+    def token_literal(self):
+        return "stream"
+
+    def __repr__(self):
+        return f"StreamStatement({self.stream_name})"
+
+
+class WatchStatement(Statement):
+    def __init__(self, watched_expr, reaction):
+        self.watched_expr = watched_expr
+        self.reaction = reaction
+
+    def token_literal(self):
+        return "watch"
+
+    def __repr__(self):
+        return f"WatchStatement({self.watched_expr})"

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)