zexus 1.6.8 → 1.7.2

package/src/zexus/parser/strategy_structural.py

@@ -28,6 +28,8 @@ class StructuralAnalyzer:
         block_id = 0
         n = len(tokens)
 
+        debug_enabled = zexus_config.enable_debug_logs
+
         # helper sets for stopping heuristics (mirrors context parser)
         stop_types = {SEMICOLON, RBRACE}
         
@@ -37,10 +39,11 @@ class StructuralAnalyzer:
         # Statement starters (keywords that begin a new statement)
         # NOTE: SEND and RECEIVE removed - they can be used as function calls in expressions
         statement_starters = {
-              LET, CONST, DATA, PRINT, FOR, IF, WHILE, RETURN, CONTINUE, BREAK, THROW, ACTION, FUNCTION, TRY, EXTERNAL,
-              SCREEN, EXPORT, USE, DEBUG, ENTITY, CONTRACT, VERIFY, PROTECT, SEAL, PERSISTENT, AUDIT,
+              LET, CONST, DATA, PRINT, FOR, IF, WHILE, RETURN, CONTINUE, BREAK, THROW, ACTION, FUNCTION, TRY, FINALLY, EXTERNAL,
+              SCREEN, COLOR, CANVAS, GRAPHICS, ANIMATION, CLOCK,
+              EXPORT, USE, DEBUG, ENTITY, CONTRACT, VERIFY, PROTECT, SEAL, PERSISTENT, AUDIT,
               RESTRICT, SANDBOX, TRAIL, GC, BUFFER, SIMD,
-              DEFER, PATTERN, ENUM, STREAM, WATCH,
+              DEFER, PATTERN, ENUM, STREAM, WATCH, MATCH,
               CAPABILITY, GRANT, REVOKE, VALIDATE, SANITIZE, IMMUTABLE,
               INTERFACE, TYPE_ALIAS, MODULE, PACKAGE, USING,
               CHANNEL, ATOMIC,
@@ -134,13 +137,44 @@ class StructuralAnalyzer:
                     declaration_type = tokens[i].type
                     export_tokens.append(tokens[i])
                     i += 1
-                    # Now collect the rest of the declaration (NAME = VALUE)
-                    while i < n and tokens[i].type not in stop_types:
-                        # Stop if we see another statement starter (but not CONST/LET since we just saw it)
-                        if tokens[i].type in statement_starters and tokens[i].type not in [CONST, LET]:
-                            break
-                        export_tokens.append(tokens[i])
+
+                    # Track nesting counts so that braces/parentheses inside the value don't prematurely terminate the statement
+                    paren_depth = 0
+                    brace_depth = 0
+                    bracket_depth = 0
+
+                    while i < n:
+                        current = tokens[i]
+
+                        # Update nesting counters before applying boundary heuristics
+                        if current.type == LPAREN:
+                            paren_depth += 1
+                        elif current.type == RPAREN:
+                            paren_depth = max(paren_depth - 1, 0)
+                        elif current.type == LBRACE:
+                            brace_depth += 1
+                        elif current.type == RBRACE:
+                            brace_depth = max(brace_depth - 1, 0)
+                        elif current.type == LBRACKET:
+                            bracket_depth += 1
+                        elif current.type == RBRACKET:
+                            bracket_depth = max(bracket_depth - 1, 0)
+
+                        export_tokens.append(current)
                         i += 1
+
+                        in_nested_structure = (paren_depth > 0 or brace_depth > 0 or bracket_depth > 0)
+
+                        # Stop if we reach a clear boundary at top level (first semicolon or closing brace outside of literal)
+                        if not in_nested_structure and current.type in stop_types:
+                            break
+
+                        # Stop if we see another statement starter at top level (but not CONST/LET since we just saw it)
+                        if not in_nested_structure and current.type in statement_starters and current.type not in [CONST, LET]:
+                            # Remove the boundary token so the next statement sees it
+                            export_tokens.pop()
+                            i -= 1
+                            break
                 elif i < n and tokens[i].type == CONTRACT:
                     # export contract Name { ... } - collect entire contract
                     export_tokens.append(tokens[i])
@@ -170,6 +204,30 @@ class StructuralAnalyzer:
                         elif tokens[i].type == RBRACE:
                             brace_count -= 1
                         i += 1
+                elif i < n and tokens[i].type == DATA:
+                    # export data Name { ... } - collect entire data declaration
+                    export_tokens.append(tokens[i])
+                    i += 1
+
+                    brace_count = 0
+
+                    # Collect modifiers, type params, and until first brace
+                    while i < n:
+                        export_tokens.append(tokens[i])
+                        if tokens[i].type == LBRACE:
+                            brace_count = 1
+                            i += 1
+                            break
+                        i += 1
+
+                    # Collect body until matching closing brace
+                    while i < n and brace_count > 0:
+                        export_tokens.append(tokens[i])
+                        if tokens[i].type == LBRACE:
+                            brace_count += 1
+                        elif tokens[i].type == RBRACE:
+                            brace_count -= 1
+                        i += 1
                 elif i < n and tokens[i].type == FUNCTION:
                     # export function name(...) { ... } - collect entire function
                     export_tokens.append(tokens[i])
@@ -450,8 +508,16 @@ class StructuralAnalyzer:
                     catch_tokens = [catch_token] + pre_brace_tokens + catch_block_tokens
                     final_idx = after_catch_idx
                 
+                # Check for finally block
+                finally_tokens = []
+                if final_idx < n and tokens[final_idx].type == FINALLY:
+                    finally_token = tokens[final_idx]
+                    finally_block_tokens, after_finally_idx = self._collect_brace_block(tokens, final_idx + 1)
+                    finally_tokens = [finally_token] + finally_block_tokens
+                    final_idx = after_finally_idx
+                
                 # Combine all tokens
-                full_tokens = [t] + try_block_tokens + catch_tokens
+                full_tokens = [t] + try_block_tokens + catch_tokens + finally_tokens
                 full_tokens = [tk for tk in full_tokens if not _is_empty_token(tk)]
                 
                 # Create the main try-catch block
@@ -743,7 +809,27 @@ class StructuralAnalyzer:
                             # Break if we've already completed the LET/CONST and this is an indexed assignment
                             if is_indexed_assignment and in_assignment and seen_assign:
                                 break
-                        # IDENT followed by LPAREN is a function call (already handled below, but listed for clarity)
+                        
+                        # Pattern 4: IDENT followed by LPAREN is a function call expression
+                        # This is a NEW statement if we're in LET/CONST and have seen the main assign
+                        # and the function call is on a new line (prevents absorbing next statement)
+                        elif tj.type == IDENT and j + 1 < n and tokens[j + 1].type == LPAREN:
+                            if stmt_tokens and in_assignment and seen_assign:
+                                last_token = stmt_tokens[-1]
+                                last_line = getattr(last_token, 'line', None)
+                                current_line = getattr(tj, 'line', None)
+                                if last_line is not None and current_line is not None and current_line > last_line:
+                                    # Safety: don't break if previous token is an infix operator
+                                    # (e.g., let x = foo() +\n bar() across two lines)
+                                    _infix_ops = {PLUS, MINUS, STAR, SLASH, MOD, AND, OR,
+                                                  EQ, NOT_EQ, LT, GT, LTE, GTE, POWER,
+                                                  DOT, COMMA, ASSIGN, QUESTION, NULLISH,
+                                                  PLUS_ASSIGN, MINUS_ASSIGN, STAR_ASSIGN,
+                                                  SLASH_ASSIGN, MOD_ASSIGN, POWER_ASSIGN,
+                                                  APPEND, IMPORT_OP}
+                                    if last_token.type not in _infix_ops:
+                                        # New line after completed assignment - this is a new statement
+                                        break
                     
                     # Detect colon-based block (tolerable syntax for action/function/if/while etc.)
                     if tj.type == COLON and nesting == 0 and t.type in {ACTION, FUNCTION, IF, WHILE, FOR}:
@@ -759,8 +845,10 @@ class StructuralAnalyzer:
                     # Track nesting level BEFORE dedent check (so we don't break inside {...} or [...] or (...))
                     if tj.type in {LPAREN, LBRACE, LBRACKET}:
                         # Only mark as brace block if NOT already in colon block (to distinguish code blocks from data literals)
+                        # ALSO: Don't mark as brace block for destructuring patterns in LET/CONST before '='
                         if tj.type == LBRACE and not found_colon_block:
-                            found_brace_block = True
+                            if not (in_assignment and not seen_assign):
+                                found_brace_block = True
                         nesting += 1
                     elif tj.type in {RPAREN, RBRACE, RBRACKET}:
                         nesting -= 1
@@ -791,10 +879,16 @@ class StructuralAnalyzer:
                                 # We're still parsing the condition - don't break yet
                                 pass
                             else:
-                                # For LET/CONST, allow FUNCTION, SANDBOX, SANITIZE as RHS (expressions)
+                                # For LET/CONST, allow FUNCTION, SANDBOX, SANITIZE, MATCH as RHS (expressions)
                                 # Also allow DEBUG when followed by ( for debug(x) function calls in assignments
                                 # Also allow IF when followed by THEN (if-then-else expression)
-                                allow_in_assignment = tj.type in {FUNCTION, SANDBOX, SANITIZE}
+                                allow_in_assignment = tj.type in {FUNCTION, SANDBOX, SANITIZE, MATCH}
+                                if in_assignment and allow_in_assignment and stmt_tokens:
+                                    prev_token = stmt_tokens[-1]
+                                    prev_line = getattr(prev_token, 'line', None)
+                                    current_line = getattr(tj, 'line', None)
+                                    if prev_line is not None and current_line is not None and current_line > prev_line:
+                                        allow_in_assignment = False
                                 allow_debug_call = tj.type == DEBUG and j + 1 < n and tokens[j + 1].type == LPAREN
                                 allow_if_then_else = False
                                 if tj.type == IF:
@@ -964,10 +1058,12 @@ class StructuralAnalyzer:
                                     # CRITICAL FIX: Don't break if the previous token was ASSIGN
                                     # This means the IDENT is the RHS value, not a new statement
                                     prev_tok = run_tokens[-1] if run_tokens else None
-                                    print(f"      prev_tok={prev_tok.literal if prev_tok else None}, type={prev_tok.type if prev_tok else None}")
+                                    if debug_enabled:
+                                        print(f"      prev_tok={prev_tok.literal if prev_tok else None}, type={prev_tok.type if prev_tok else None}")
                                     if prev_tok and prev_tok.type == ASSIGN:
                                         # This IDENT is the RHS of the assignment, not a new statement
-                                        print(f"      -> Continuing (RHS of assignment)")
+                                        if debug_enabled:
+                                            print("      -> Continuing (RHS of assignment)")
                                         pass  # Don't break, continue collecting
                                     else:
                                         # This is likely a new statement on a new line
@@ -1109,8 +1205,9 @@ class StructuralAnalyzer:
         stop_types = {SEMICOLON, RBRACE}
         # NOTE: SEND and RECEIVE removed - they can be used as function calls in expressions
         statement_starters = {
-              LET, CONST, DATA, PRINT, FOR, IF, WHILE, RETURN, CONTINUE, BREAK, THROW, ACTION, FUNCTION, TRY, EXTERNAL, 
-              SCREEN, EXPORT, USE, DEBUG, ENTITY, CONTRACT, VERIFY, PROTECT, SEAL, AUDIT,
+              LET, CONST, DATA, PRINT, FOR, IF, WHILE, RETURN, CONTINUE, BREAK, THROW, ACTION, FUNCTION, TRY, FINALLY, EXTERNAL, 
+              SCREEN, COLOR, CANVAS, GRAPHICS, ANIMATION, CLOCK,
+              EXPORT, USE, DEBUG, ENTITY, CONTRACT, VERIFY, PROTECT, SEAL, AUDIT,
               RESTRICT, SANDBOX, TRAIL, NATIVE, GC, INLINE, BUFFER, SIMD,
               DEFER, PATTERN, ENUM, STREAM, WATCH,
               CAPABILITY, GRANT, REVOKE, VALIDATE, SANITIZE, IMMUTABLE,
@@ -1167,7 +1264,8 @@ class StructuralAnalyzer:
 
             # Export statement detection - collect export keyword + following declaration
             if t.type == EXPORT:
-                print(f"[DEBUG STRUCT] Found EXPORT token at index {i}")
+                if debug_enabled:
+                    print(f"[DEBUG STRUCT] Found EXPORT token at index {i}")
                 if cur:
                     results.append(cur)
                     cur = []
@@ -1177,9 +1275,11 @@ class StructuralAnalyzer:
                 i += 1
 
                 # Check if followed by const/let declaration (export const X = value)
-                print(f"[DEBUG STRUCT] Next token at {i}: {tokens[i].type if i < n else 'EOF'}, CONST={CONST}, LET={LET}")
+                if debug_enabled:
+                    print(f"[DEBUG STRUCT] Next token at {i}: {tokens[i].type if i < n else 'EOF'}, CONST={CONST}, LET={LET}")
                 if i < n and tokens[i].type in [CONST, LET]:
-                    print(f"[DEBUG STRUCT] Export followed by CONST/LET, collecting declaration")
+                    if debug_enabled:
+                        print(f"[DEBUG STRUCT] Export followed by CONST/LET, collecting declaration")
                     # Collect the entire declaration
                     while i < n and tokens[i].type not in stop_types:
                         export_tokens.append(tokens[i])

package/src/zexus/persistence.py

@@ -315,6 +315,19 @@ class PersistentStorage:
             cursor = self.conn.cursor()
             cursor.execute('DELETE FROM variables')
             self.conn.commit()
+
+    def _key_to_str(self, key):
+        """Convert a Zexus object key to a Python string for JSON serialization."""
+        if isinstance(key, String):
+            return key.value
+        if isinstance(key, Integer):
+            return str(key.value)
+        if isinstance(key, Float):
+            return str(key.value)
+        if isinstance(key, BooleanObj):
+            return str(key.value)
+        # Fallback for other types
+        return str(key)
     
     def _serialize(self, obj: Object) -> Dict[str, str]:
         """Serialize Zexus object to JSON"""
@@ -330,7 +343,8 @@ class PersistentStorage:
             serialized = [self._serialize(e) for e in obj.elements]
             return {'type': 'list', 'value': json.dumps(serialized)}
         elif isinstance(obj, Map):
-            serialized = {k: self._serialize(v) for k, v in obj.pairs.items()}
+            # Convert Zexus String keys to Python strings for JSON compatibility
+            serialized = {self._key_to_str(k): self._serialize(v) for k, v in obj.pairs.items()}
             return {'type': 'map', 'value': json.dumps(serialized)}
         elif obj is Null or obj is NULL:
             return {'type': 'null', 'value': json.dumps(None)}

package/src/zexus/renderer/__init__.py

@@ -0,0 +1,61 @@
+"""Zexus renderer package.
+
+This package exposes a cohesive rendering subsystem that can be consumed by
+both the interpreter and the VM/compiler paths.  The public API mirrors the
+previous top-level ``renderer`` module so existing call sites remain
+compatible while the implementation now lives alongside the core runtime.
+"""
+from __future__ import annotations
+
+from .backend import (
+    RendererBackend,
+    add_to_screen,
+    create_canvas,
+    create_named_canvas,
+    define_color,
+    define_component,
+    define_screen,
+    draw_line,
+    draw_text,
+    inspect_registry,
+    mix,
+    register_animation,
+    register_clock,
+    register_graphics,
+    render_screen,
+    set_theme,
+)
+
+__all__ = [
+    "RendererBackend",
+    "add_to_screen",
+    "create_canvas",
+    "create_named_canvas",
+    "define_color",
+    "define_component",
+    "define_screen",
+    "draw_line",
+    "draw_text",
+    "inspect_registry",
+    "mix",
+    "register_animation",
+    "register_clock",
+    "register_graphics",
+    "render_screen",
+    "set_theme",
+    # GUI backends
+    "TkBackend",
+    "WebBackend",
+    "create_tk_backend",
+    "create_web_backend",
+]
+
+# Lazy imports for GUI backends (tkinter may not be installed)
+def __getattr__(name: str):
+    if name in ("TkBackend", "create_tk_backend"):
+        from .tk_backend import TkBackend, create_tk_backend
+        return TkBackend if name == "TkBackend" else create_tk_backend
+    if name in ("WebBackend", "create_web_backend"):
+        from .web_backend import WebBackend, create_web_backend
+        return WebBackend if name == "WebBackend" else create_web_backend
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

package/src/zexus/renderer/backend.py

@@ -0,0 +1,261 @@
+"""Renderer backend exposed to the evaluator and VM implementations."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import re
+from typing import Any, Dict, Iterable, Optional
+
+from .canvas import CanvasRegistry
+from .color_system import ColorPalette, RGBColor, Theme
+from .layout import Screen, ScreenRegistry
+from .main_renderer import ZexusScreenRenderer
+
+
+@dataclass
+class RendererState:
+    screens: ScreenRegistry = field(default_factory=ScreenRegistry)
+    canvases: CanvasRegistry = field(default_factory=CanvasRegistry)
+    themes: Dict[str, Theme] = field(default_factory=dict)
+    current_theme: Optional[str] = None
+    colours: Dict[str, str] = field(default_factory=dict)
+    graphics: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+    animations: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+    clocks: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+    canvas_aliases: Dict[str, str] = field(default_factory=dict)
+
+
+class RendererBackend:
+    def __init__(self) -> None:
+        self.palette = ColorPalette()
+        self.state = RendererState()
+        self.renderer = ZexusScreenRenderer(self.state.screens)
+
+    # ------------------------------------------------------------------
+    # Colour helpers
+    # ------------------------------------------------------------------
+    def mix(self, colour_a: str, colour_b: str, ratio: float = 0.5) -> RGBColor:
+        return self.palette.mix(colour_a, colour_b, ratio)
+
+    def define_color(self, name: str, spec: object) -> RGBColor:
+        colour = self._coerce_colour(spec)
+        self.palette.define(name, colour)
+        self.state.colours[name] = str(colour)
+        return colour
+
+    # ------------------------------------------------------------------
+    # Screen/component management
+    # ------------------------------------------------------------------
+    def define_screen(self, name: str, properties: Dict[str, Any] | None = None) -> None:
+        self.renderer.define_screen(name, **(properties or {}))
+
+    def define_component(self, name: str, properties: Dict[str, Any] | None = None) -> None:
+        props = dict(properties or {})
+        component_type = props.pop("type", None)
+        self.renderer.define_component(name, component_type, **props)
+
+    def add_to_screen(self, screen_name: str, component_name: str, overrides: Dict[str, Any] | None = None) -> None:
+        self.renderer.add_to_screen(screen_name, component_name, **(overrides or {}))
+
+    def render_screen(self, name: str, overrides: Dict[str, Any] | None = None) -> str:
+        return self.renderer.render_screen(name, **(overrides or {}))
+
+    # ------------------------------------------------------------------
+    # Theme handling
+    # ------------------------------------------------------------------
+    def set_theme(self, target_or_theme: str, theme_name: str | None = None) -> None:
+        if theme_name is None:
+            self.state.current_theme = target_or_theme
+            if target_or_theme not in self.state.themes:
+                self.state.themes[target_or_theme] = Theme(target_or_theme, self.palette)
+            return
+
+        if target_or_theme in self.state.screens.list_screens():
+            screen = self.state.screens.get_screen(target_or_theme)
+            screen.properties["theme"] = theme_name
+            if theme_name not in self.state.themes:
+                self.state.themes[theme_name] = Theme(theme_name, self.palette)
+        else:
+            if theme_name not in self.state.themes:
+                self.state.themes[theme_name] = Theme(theme_name, self.palette)
+
+    # ------------------------------------------------------------------
+    # Canvas helpers
+    # ------------------------------------------------------------------
+    def create_canvas(self, width: int, height: int) -> str:
+        return self.state.canvases.create(width=width, height=height)
+
+    def create_named_canvas(self, name: str, width: int, height: int) -> str:
+        identifier = self.create_canvas(width, height)
+        self.state.canvas_aliases[name] = identifier
+        return identifier
+
+    def draw_line(self, canvas_id: str, x1: int, y1: int, x2: int, y2: int) -> None:
+        canvas = self.state.canvases.get(self._resolve_canvas_identifier(canvas_id))
+        canvas.draw_line(x1, y1, x2, y2)
+
+    def draw_text(self, canvas_id: str, x: int, y: int, text: str) -> None:
+        canvas = self.state.canvases.get(self._resolve_canvas_identifier(canvas_id))
+        canvas.draw_text(x, y, text)
+
+    # ------------------------------------------------------------------
+    # Higher-level registries
+    # ------------------------------------------------------------------
+    def register_graphics(self, name: str, layers: Iterable[str] | Dict[str, Any]) -> None:
+        if isinstance(layers, dict):
+            payload = dict(layers)
+        else:
+            payload = {f"layer_{idx}": layer for idx, layer in enumerate(layers)}
+        self.state.graphics[name] = payload
+
+    def register_animation(self, name: str, frames: Dict[str, Any]) -> None:
+        self.state.animations[name] = dict(frames)
+
+    def register_clock(self, name: str, config: Dict[str, Any]) -> None:
+        self.state.clocks[name] = dict(config)
+
+    # ------------------------------------------------------------------
+    def inspect_registry(self) -> Dict[str, Any]:
+        return {
+            "screens": {
+                name: {
+                    "properties": dict(screen.properties),
+                    "children": [child.name for child in screen.children],
+                    "theme": screen.properties.get("theme"),
+                }
+                for name, screen in self.state.screens.snapshot().items()
+            },
+            "components": {
+                name: dict(component.properties)
+                for name, component in self.state.screens.component_snapshot().items()
+            },
+            "themes": {name: theme.snapshot() for name, theme in self.state.themes.items()},
+            "canvases": self.state.canvases.snapshot(),
+            "canvas_aliases": dict(self.state.canvas_aliases),
+            "colours": dict(self.state.colours),
+            "graphics": {name: dict(data) for name, data in self.state.graphics.items()},
+            "animations": {name: dict(data) for name, data in self.state.animations.items()},
+            "clocks": {name: dict(data) for name, data in self.state.clocks.items()},
+            "current_theme": self.state.current_theme,
+        }
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+    def _resolve_canvas_identifier(self, identifier: str) -> str:
+        if identifier in self.state.canvases.canvases:
+            return identifier
+        return self.state.canvas_aliases.get(identifier, identifier)
+
+    def _coerce_colour(self, spec: object) -> RGBColor:
+        if isinstance(spec, RGBColor):
+            return spec
+
+        if isinstance(spec, str):
+            text = spec.strip()
+            match = re.fullmatch(r"#?([0-9a-fA-F]{6})", text)
+            if match:
+                raw = match.group(1)
+                return RGBColor(int(raw[0:2], 16), int(raw[2:4], 16), int(raw[4:6], 16))
+            try:
+                return self.palette.get(text)
+            except KeyError as exc:
+                raise ValueError(str(exc)) from exc
+
+        if isinstance(spec, dict):
+            if {"r", "g", "b"}.issubset(spec):
+                return RGBColor(int(spec["r"]), int(spec["g"]), int(spec["b"]))
+            if {"red", "green", "blue"}.issubset(spec):
+                return RGBColor(int(spec["red"]), int(spec["green"]), int(spec["blue"]))
+            if "hex" in spec:
+                return self._coerce_colour(str(spec["hex"]))
+            raise ValueError("Colour map must include r/g/b values or hex")
+
+        if isinstance(spec, (list, tuple)) and len(spec) == 3:
+            r, g, b = spec
+            return RGBColor(int(r), int(g), int(b))
+
+        raise ValueError(f"Unsupported colour specification: {spec}")
+
+
+# Module level helper mirroring the legacy API -------------------------
+_BACKEND = RendererBackend()
+
+
+def mix(colour_a: str, colour_b: str, ratio: float = 0.5) -> RGBColor:
+    return _BACKEND.mix(colour_a, colour_b, ratio)
+
+
+def define_color(name: str, spec: object) -> RGBColor:
+    return _BACKEND.define_color(name, spec)
+
+
+def define_screen(name: str, properties: Dict[str, Any] | None = None) -> None:
+    _BACKEND.define_screen(name, properties)
+
+
+def define_component(name: str, properties: Dict[str, Any] | None = None) -> None:
+    _BACKEND.define_component(name, properties)
+
+
+def add_to_screen(screen_name: str, component_name: str, overrides: Dict[str, Any] | None = None) -> None:
+    _BACKEND.add_to_screen(screen_name, component_name, overrides)
+
+
+def render_screen(name: str, overrides: Dict[str, Any] | None = None) -> str:
+    return _BACKEND.render_screen(name, overrides)
+
+
+def set_theme(target_or_theme: str, theme_name: str | None = None) -> None:
+    _BACKEND.set_theme(target_or_theme, theme_name)
+
+
+def create_canvas(width: int, height: int) -> str:
+    return _BACKEND.create_canvas(width, height)
+
+
+def create_named_canvas(name: str, width: int, height: int) -> str:
+    return _BACKEND.create_named_canvas(name, width, height)
+
+
+def draw_line(canvas_id: str, x1: int, y1: int, x2: int, y2: int) -> None:
+    _BACKEND.draw_line(canvas_id, x1, y1, x2, y2)
+
+
+def draw_text(canvas_id: str, x: int, y: int, text: str) -> None:
+    _BACKEND.draw_text(canvas_id, x, y, text)
+
+
+def register_graphics(name: str, data: Dict[str, Any] | Iterable[str]) -> None:
+    _BACKEND.register_graphics(name, data)
+
+
+def register_animation(name: str, data: Dict[str, Any]) -> None:
+    _BACKEND.register_animation(name, data)
+
+
+def register_clock(name: str, data: Dict[str, Any]) -> None:
+    _BACKEND.register_clock(name, data)
+
+
+def inspect_registry() -> Dict[str, Any]:
+    return _BACKEND.inspect_registry()
+
+
+__all__ = [
+    "RendererBackend",
+    "add_to_screen",
+    "create_canvas",
+    "create_named_canvas",
+    "define_color",
+    "define_component",
+    "define_screen",
+    "draw_line",
+    "draw_text",
+    "inspect_registry",
+    "mix",
+    "register_animation",
+    "register_clock",
+    "register_graphics",
+    "render_screen",
+    "set_theme",
+]