zexus 1.8.2 → 1.8.3

package/src/zexus/kernel/zir/__init__.py

@@ -0,0 +1,145 @@
+"""
+Zexus Intermediate Representation (ZIR) — Opcode catalogue and validation.
+
+This module formalises the opcodes the VM already uses, putting them into
+an enum so that tooling (LSP, debugger, profiler) and domain authors can
+reference them by name.  It does NOT replace the existing Opcode class in
+``vm/compiler.py`` — it sits alongside it as a typed reference.
+
+Opcode ranges
+-------------
+0x0001–0x00FF  Core operations (math, stack, variables)
+0x0100–0x01FF  Control flow (jump, call, return, try)
+0x0200–0x02FF  Memory / field access
+0x1000–0x1FFF  Domain-specific (registered at runtime via DomainRegistry)
+"""
+
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import Optional
+
+
+class CoreOpcode(IntEnum):
+    """Core opcodes understood by every execution backend.
+
+    These mirror the opcodes already defined in the VM — they provide
+    a stable, importable reference for tooling and domain code.
+    """
+
+    # -- Constants / stack --------------------------------------------------
+    LOAD_CONST    = 0x0001
+    LOAD_NAME     = 0x0002
+    STORE_NAME    = 0x0003
+    POP_TOP       = 0x0004
+    DUP_TOP       = 0x0005
+
+    # -- Arithmetic ---------------------------------------------------------
+    ADD           = 0x0010
+    SUB           = 0x0011
+    MUL           = 0x0012
+    DIV           = 0x0013
+    MOD           = 0x0014
+    POW           = 0x0015
+    NEG           = 0x0016
+
+    # -- Comparison ---------------------------------------------------------
+    EQ            = 0x0020
+    NEQ           = 0x0021
+    LT            = 0x0022
+    GT            = 0x0023
+    LTE           = 0x0024
+    GTE           = 0x0025
+
+    # -- Logic --------------------------------------------------------------
+    AND           = 0x0030
+    OR            = 0x0031
+    NOT           = 0x0032
+
+    # -- Collections --------------------------------------------------------
+    BUILD_LIST    = 0x0040
+    BUILD_MAP     = 0x0041
+    INDEX         = 0x0042
+    STORE_INDEX   = 0x0043
+
+    # -- Control flow -------------------------------------------------------
+    JUMP          = 0x0100
+    JUMP_IF_FALSE = 0x0101
+    CALL          = 0x0102
+    RETURN        = 0x0103
+    TRY           = 0x0104
+    THROW         = 0x0105
+
+    # -- Memory / fields ----------------------------------------------------
+    LOAD_FIELD    = 0x0200
+    STORE_FIELD   = 0x0201
+    ALLOC         = 0x0202
+
+
+# All valid core opcode values for fast membership testing
+_CORE_OPCODES = frozenset(int(op) for op in CoreOpcode)
+
+
+def is_core_opcode(opcode: int) -> bool:
+    """Return True if *opcode* is in the core range."""
+    return opcode in _CORE_OPCODES
+
+
+def resolve_opcode_name(opcode: int) -> Optional[str]:
+    """Human-readable name for any opcode (core or domain).
+
+    Returns ``None`` for completely unknown opcodes.
+    """
+    # Try core first
+    try:
+        return CoreOpcode(opcode).name
+    except ValueError:
+        pass
+
+    # Try domain registry
+    from ..registry import get_registry
+    owner = get_registry().resolve_opcode(opcode)
+    if owner is not None:
+        domain = get_registry().get_domain(owner)
+        if domain:
+            return domain.opcodes.get(opcode)
+    return None
+
+
+def validate_zir(
+    instructions: list,
+    *,
+    allowed_domains: Optional[set[str]] = None,
+) -> list[str]:
+    """Validate a sequence of ZIR instructions.
+
+    Returns a list of error strings (empty == valid).
+
+    Parameters
+    ----------
+    instructions
+        ``[(opcode, *operands), ...]``
+    allowed_domains
+        If given, only opcodes belonging to these domains (plus core)
+        are permitted.
+    """
+    from ..registry import get_registry
+
+    errors: list[str] = []
+    registry = get_registry()
+
+    for idx, instr in enumerate(instructions):
+        opcode = instr[0] if isinstance(instr, (list, tuple)) else instr
+
+        if opcode in _CORE_OPCODES:
+            continue
+
+        owner = registry.resolve_opcode(opcode)
+        if owner is None:
+            errors.append(f"Instruction {idx}: unknown opcode 0x{opcode:04X}")
+        elif allowed_domains is not None and owner not in allowed_domains:
+            errors.append(
+                f"Instruction {idx}: opcode 0x{opcode:04X} belongs to "
+                f"domain {owner!r} which is not in allowed set"
+            )
+    return errors

package/src/zexus/lexer.py

@@ -915,6 +915,13 @@ class Lexer:
                 return token
             return IDENT
 
+        # 'storage' is only a keyword after 'persistent' (for 'persistent storage ...')
+        # In all other contexts, treat as a regular identifier.
+        if ident == "storage":
+            if self.last_token_type == PERSISTENT:
+                return token  # STORAGE keyword
+            return IDENT
+
         if ident in _STRICT_KEYWORDS:
             return token
 

package/src/zexus/object.py

@@ -11,7 +11,7 @@ from threading import Lock
 
 
 # ===============================================
-# SECURITY: Path & Identifier Sanitization (v1.8.1)
+# SECURITY: Path & Identifier Sanitization (v1.8.3)
 # ===============================================
 
 def _safe_resolve_path(path: str, sandbox: str = None) -> str:
@@ -183,6 +183,11 @@ class List(Object):
             self.elements.extend(other_list.elements)
         return self
 
+    def is_empty(self):
+        """Q-002 fix: Check if list is empty, returns Boolean"""
+        from .object import Boolean
+        return Boolean(len(self.elements) == 0)
+
 class Map(Object):
     def __init__(self, pairs):
         self.pairs = pairs
@@ -242,9 +247,17 @@ class Map(Object):
         return Array([Array([k, v]) for k, v in self.pairs.items()])
 
     def has(self, key):
-        """Check if key exists in map"""
+        """Check if key exists in map (with key normalization)"""
         from .object import Boolean
-        return Boolean(key in self.pairs)
+        # Q-001 fix: Try direct, then normalized key lookup (same as get())
+        if key in self.pairs:
+            return Boolean(True)
+        if isinstance(key, str):
+            str_key = String(key)
+            if str_key in self.pairs:
+                return Boolean(True)
+        norm_key = self._normalize_key(key)
+        return Boolean(norm_key in self.pairs)
 
     def size(self):
         """Return number of entries in map"""
@@ -1193,8 +1206,18 @@ class Environment:
         return val
 
     def clone_for_closure(self):
-        """Create a shallow copy of the environment for closure capture."""
-        cloned = Environment(outer=self.outer, persistence_scope=self.persistence_scope)
+        """Create a shallow copy of the environment for closure capture.
+        
+        The clone uses the original environment as its outer scope so that
+        identifiers registered after cloning (e.g. contracts/entities defined
+        later in sequential evaluation) remain reachable through the scope
+        chain.  Mutations via ``assign()`` also propagate back to the
+        original environment, fixing R-018/R-019 (side-effects from
+        module-level helpers called inside contract methods silently dropped).
+        """
+        # Use *self* (the live env) as outer instead of self.outer so that
+        # names added to the original env after cloning are still visible.
+        cloned = Environment(outer=self, persistence_scope=self.persistence_scope)
         cloned.store = dict(self.store)
         cloned.const_vars = set(self.const_vars)
         cloned.exports = dict(self.exports)

package/src/zexus/parser/parser.py

@@ -2919,7 +2919,19 @@ class UltimateParser:
             self.errors.append("Expected identifier after 'each' in for-each loop")
             return None
 
-        stmt.item = Identifier(value=self.cur_token.literal)
+        first_ident = Identifier(value=self.cur_token.literal)
+
+        # R-006/R-007 fix: Support two-variable form: for each i, item in list
+        # or: for each key, val in map
+        if self.peek_token_is(COMMA):
+            self.next_token()  # consume comma
+            if not self.expect_peek(IDENT):
+                self.errors.append("Expected second identifier after ',' in for-each loop")
+                return None
+            stmt.index = first_ident
+            stmt.item = Identifier(value=self.cur_token.literal)
+        else:
+            stmt.item = first_ident
 
         if not self.expect_peek(IN):
             self.errors.append("Expected 'in' after item identifier in for-each loop")
@@ -3417,8 +3429,9 @@ class UltimateParser:
                         self.cur_token = saved_cur
                         self.peek_token = saved_peek
                         
-                        # If next token after IDENT is LBRACKET or ASSIGN, it's likely a new statement
-                        if next_next.type in (LBRACKET, ASSIGN, LPAREN):
+                        # If next token after IDENT is LBRACKET, ASSIGN, LPAREN, or DOT,
+                        # it's likely a new statement (e.g., this.x = 1\nthis.y = 2)
+                        if next_next.type in (LBRACKET, ASSIGN, LPAREN, DOT):
                             break
                     else:
                         break
@@ -3944,7 +3957,7 @@ class UltimateParser:
                     methods.append(method)
                 continue
             
-            if self.cur_token_is(IDENT):
+            if self.cur_token_is(IDENT) or (self.cur_token.literal and self.peek_token_is(COLON)):
                 prop_name = self.cur_token.literal
 
                 # Expect colon after property name
@@ -3960,9 +3973,17 @@ class UltimateParser:
                 if self.cur_token_is(IDENT):
                     prop_type = self.cur_token.literal
 
+                    # Check for default value: = expression
+                    default_value = None
+                    if self.peek_token_is(ASSIGN):
+                        self.next_token()  # Move to =
+                        self.next_token()  # Move to expression
+                        default_value = self.parse_expression(LOWEST)
+
                     properties.append({
                         "name": prop_name,
-                        "type": prop_type
+                        "type": prop_type,
+                        "default_value": default_value
                     })
 
                     # Check for comma or new property
@@ -4070,12 +4091,33 @@ class UltimateParser:
 
             # Check for state variable declaration
             if self.cur_token_is(STATE):
-                state_stmt = self.parse_state_statement()
-                if state_stmt:
-                    # Attach parsed modifiers
-                    state_stmt.modifiers = modifiers
-                    storage_vars.append(state_stmt)
-                    print(f"DEBUG: Parsed state {state_stmt.name.value} modifiers={modifiers}")
+                # R-013 fix: Support state { field: val, field2: val2 } block syntax
+                if self.peek_token_is(LBRACE):
+                    self.next_token()  # consume '{'
+                    self.next_token()  # move to first field or '}'
+                    while not self.cur_token_is(RBRACE) and not self.cur_token_is(EOF):
+                        if self.cur_token_is(IDENT):
+                            field_name = self.cur_token.literal
+                            # Expect colon or '=' after field name
+                            if self.peek_token_is(COLON) or self.peek_token_is(ASSIGN):
+                                self.next_token()  # consume ':' or '='
+                                self.next_token()  # move to value
+                                field_value = self.parse_expression(LOWEST)
+                                from ..zexus_ast import StateStatement as _SS
+                                state_stmt = _SS(Identifier(field_name), field_value, modifiers=modifiers)
+                                storage_vars.append(state_stmt)
+                            # Consume optional comma or semicolon
+                            if self.peek_token_is(COMMA):
+                                self.next_token()
+                            if self.peek_token_is(SEMICOLON):
+                                self.next_token()
+                        self.next_token()
+                else:
+                    state_stmt = self.parse_state_statement()
+                    if state_stmt:
+                        # Attach parsed modifiers
+                        state_stmt.modifiers = modifiers
+                        storage_vars.append(state_stmt)
 
             # Check for data member declaration
             elif self.cur_token_is(DATA):

package/src/zexus/parser/strategy_context.py

@@ -1514,7 +1514,8 @@ class ContextStackParser:
                     continue
                 
                 # Parse regular properties
-                if tokens[i].type == IDENT:
+                # Accept IDENT and keywords (like DEBUG, DATA, etc.) as property names
+                if tokens[i].type == IDENT or (tokens[i].literal and i + 1 < brace_end and tokens[i + 1].type == COLON):
                     prop_name = tokens[i].literal
                     parser_debug(f"  📝 Found property name: {prop_name}")
 
@@ -1522,14 +1523,48 @@ class ContextStackParser:
                     if i + 1 < brace_end and tokens[i + 1].type == COLON:
                         if i + 2 < brace_end:
                             prop_type = tokens[i + 2].literal
+                            default_value = None
+                            prop_end = i + 3
+                            
+                            # Check for default value: = expression
+                            if prop_end < brace_end and tokens[prop_end].type == ASSIGN:
+                                prop_end += 1  # Skip =
+                                # Collect default value tokens until comma, newline-property, or end
+                                val_tokens = []
+                                nesting = 0
+                                while prop_end < brace_end:
+                                    vt = tokens[prop_end]
+                                    if vt.type in {LPAREN, LBRACE, LBRACKET}:
+                                        nesting += 1
+                                    elif vt.type in {RPAREN, RBRACE, RBRACKET}:
+                                        nesting -= 1
+                                    elif nesting == 0 and vt.type == COMMA:
+                                        prop_end += 1  # Skip comma
+                                        break
+                                    elif nesting == 0 and len(val_tokens) > 0:
+                                        # New property on next line (detect by newline + colon lookahead)
+                                        prev_vt = val_tokens[-1]
+                                        if vt.line > prev_vt.line:
+                                            # Check if this token is followed by COLON (indicating property name)
+                                            if prop_end + 1 < brace_end and tokens[prop_end + 1].type == COLON:
+                                                break
+                                    val_tokens.append(vt)
+                                    prop_end += 1
+                                
+                                if val_tokens:
+                                    default_value = self._parse_expression(val_tokens)
+                            
                             # Use AstNodeShim so evaluator can use .name.value
                             properties.append(AstNodeShim(
                                 name=Identifier(prop_name),
                                 type=Identifier(prop_type),
-                                default_value=None
+                                default_value=default_value
                             ))
-                            parser_debug(f"  📝 Property: {prop_name}: {prop_type}")
-                            i += 3
+                            parser_debug(f"  📝 Property: {prop_name}: {prop_type}" + (f" = {default_value}" if default_value else ""))
+                            i = prop_end
+                            # Skip trailing comma
+                            if i < brace_end and tokens[i].type == COMMA:
+                                i += 1
                             continue
 
                 i += 1
@@ -1720,6 +1755,56 @@ class ContextStackParser:
                     # Move to identifier after "state"
                     i += 1
                     
+                    # R-013 fix: Support state { field: val, field2: val2 } block syntax
+                    if i < brace_end and tokens[i].type == LBRACE:
+                        # Multi-field state block
+                        i += 1  # skip opening brace
+                        state_brace_depth = 1
+                        while i < brace_end and state_brace_depth > 0:
+                            if tokens[i].type == RBRACE:
+                                state_brace_depth -= 1
+                                if state_brace_depth == 0:
+                                    i += 1
+                                    break
+                            elif tokens[i].type == LBRACE:
+                                state_brace_depth += 1
+                                i += 1
+                            elif tokens[i].type == IDENT or (hasattr(tokens[i], 'literal') and tokens[i].type not in (COMMA, SEMICOLON)):
+                                field_name = tokens[i].literal
+                                field_val = None
+                                ci = i + 1
+                                # Expect colon or =
+                                if ci < brace_end and tokens[ci].type in (COLON, ASSIGN):
+                                    ci += 1
+                                    if ci < brace_end:
+                                        vt = tokens[ci]
+                                        if vt.type == STRING:
+                                            field_val = StringLiteral(vt.literal)
+                                        elif vt.type == INT:
+                                            field_val = IntegerLiteral(int(vt.literal))
+                                        elif vt.type == FLOAT:
+                                            field_val = FloatLiteral(float(vt.literal))
+                                        elif vt.type == TRUE:
+                                            field_val = Boolean(True)
+                                        elif vt.type == FALSE:
+                                            field_val = Boolean(False)
+                                        elif vt.type == IDENT:
+                                            field_val = Identifier(vt.literal)
+                                        ci += 1
+                                # Skip optional comma
+                                if ci < brace_end and tokens[ci].type == COMMA:
+                                    ci += 1
+                                storage_vars.append(AstNodeShim(
+                                    name=Identifier(field_name),
+                                    type=Identifier("any"),
+                                    initial_value=field_val,
+                                    default_value=field_val
+                                ))
+                                i = ci
+                            else:
+                                i += 1
+                        continue
+                    
                     # State variable name can be an identifier OR a keyword being used as an identifier
                     # (e.g., "state data = {}" where "data" is a keyword but used as a variable name)
                     if i < brace_end and (tokens[i].type == IDENT or hasattr(tokens[i], 'literal')):
@@ -2461,8 +2546,13 @@ class ContextStackParser:
                         j += 1  # Skip the semicolon
                         break
                     # Stop at statement keywords when not nested
+                    # But NOT if the previous token was DOT (property/method access)
                     elif nesting == 0 and t.type in statement_starters and j > i + 1:
-                        break
+                        prev_t = tokens[j - 1] if j > 0 else None
+                        if prev_t and prev_t.type == DOT:
+                            pass  # Don't break - it's a property name
+                        else:
+                            break
                     j += 1
 
                 print_tokens = tokens[i:j]
@@ -3489,8 +3579,70 @@ class ContextStackParser:
                     
                     elif tokens[j].type == ELSE:
                         j += 1
+                        # Check for "else if" pattern (ELSE followed by IF = elif chain)
+                        if j < len(tokens) and tokens[j].type == IF:
+                            # Handle "else if" inline as an elif chain entry
+                            # Parse the else-if condition (same as elif)
+                            j += 1  # Skip the IF token
+                            elif_cond_tokens = []
+                            elif_paren_depth = 0
+                            elif_skipped_outer = False
+                            while j < len(tokens) and tokens[j].type not in [LBRACE, COLON]:
+                                if tokens[j].type == LPAREN:
+                                    if len(elif_cond_tokens) == 0 and elif_paren_depth == 0:
+                                        j += 1
+                                        elif_paren_depth += 1
+                                        elif_skipped_outer = True
+                                        continue
+                                    else:
+                                        elif_paren_depth += 1
+                                elif tokens[j].type == RPAREN:
+                                    elif_paren_depth -= 1
+                                    if elif_paren_depth == 0 and elif_skipped_outer and len(elif_cond_tokens) > 0:
+                                        j += 1
+                                        if j < len(tokens) and tokens[j].type in [LBRACE, COLON]:
+                                            break
+                                        elif_skipped_outer = False
+                                        continue
+                                elif_cond_tokens.append(tokens[j])
+                                j += 1
+                            
+                            elif_cond = self._parse_expression(elif_cond_tokens) if elif_cond_tokens else Identifier("true")
+                            
+                            # Collect else-if block
+                            if j < len(tokens) and tokens[j].type == LBRACE:
+                                j += 1
+                                elif_inner = []
+                                depth = 1
+                                while j < len(tokens) and depth > 0:
+                                    if tokens[j].type == LBRACE:
+                                        depth += 1
+                                    elif tokens[j].type == RBRACE:
+                                        depth -= 1
+                                        if depth == 0:
+                                            break
+                                    elif_inner.append(tokens[j])
+                                    j += 1
+                                elif_block = BlockStatement()
+                                elif_block.statements = self._parse_block_statements(elif_inner)
+                                j += 1
+                            elif j < len(tokens) and tokens[j].type == COLON:
+                                j += 1
+                                elif_inner = []
+                                while j < len(tokens):
+                                    if tokens[j].type in [IF, ELIF, ELSE, WHILE, FOR, ACTION, FUNCTION, LET, CONST, RETURN, CONTINUE, USE, EXPORT]:
+                                        break
+                                    elif_inner.append(tokens[j])
+                                    j += 1
+                                elif_block = BlockStatement()
+                                elif_block.statements = self._parse_block_statements(elif_inner)
+                            else:
+                                elif_block = BlockStatement()
+                            
+                            elif_parts.append((elif_cond, elif_block))
+                            continue  # Continue the while loop to check for more elif/else
                         # Collect else block
-                        if j < len(tokens) and tokens[j].type == LBRACE:
+                        elif j < len(tokens) and tokens[j].type == LBRACE:
                             # Brace-style
                             j += 1
                             else_inner = []
@@ -3611,7 +3763,10 @@ class ContextStackParser:
                         # Don't break on statement starters that are inside braces
                         # Only break if it's truly a new statement (e.g., not FUNCTION inside return expr)
                         # ALSO: Don't break on the FIRST token (the return value itself), even if it's a keyword
-                        if len(value_tokens) > 0 and t.type in statement_starters and t.type not in {FUNCTION, ACTION, RETURN}:
+                        # ALSO: Don't break on tokens that follow a DOT (property/method access)
+                        prev_val_token = value_tokens[-1] if value_tokens else None
+                        is_after_dot = prev_val_token and prev_val_token.type == DOT
+                        if len(value_tokens) > 0 and t.type in statement_starters and t.type not in {FUNCTION, ACTION, RETURN} and not is_after_dot:
                             break
                     
                     value_tokens.append(t)
@@ -3764,9 +3919,22 @@ class ContextStackParser:
                     
                     # Collect iterator variable name
                     item_name = None
+                    index_name = None
                     if j < len(tokens) and tokens[j].type == IDENT:
-                        item_name = tokens[j].literal
+                        first_ident = tokens[j].literal
                         j += 1
+                        
+                        # R-006/R-007 fix: Check for two-variable form: for each i, item in ...
+                        if j < len(tokens) and tokens[j].type == COMMA:
+                            j += 1  # skip comma
+                            if j < len(tokens) and tokens[j].type == IDENT:
+                                index_name = first_ident
+                                item_name = tokens[j].literal
+                                j += 1
+                            else:
+                                item_name = first_ident
+                        else:
+                            item_name = first_ident
                     
                     # Expect IN keyword
                     if j < len(tokens) and tokens[j].type == IN:
@@ -3807,7 +3975,8 @@ class ContextStackParser:
                         stmt = ForEachStatement(
                             item=Identifier(item_name if item_name else 'item'),
                             iterable=iterable,
-                            body=body_block
+                            body=body_block,
+                            index=Identifier(index_name) if index_name else None
                         )
                         if stmt:
                             statements.append(stmt)
@@ -4165,7 +4334,7 @@ class ContextStackParser:
                     # Only check when we've completed a previous statement (e.g., after function call)
                     # Don't check if the last token was DOT (we're in the middle of property access)
                     # Don't check if the last token was ASSIGN (we're in the RHS of an assignment)
-                    if nesting == 0 and len(run_tokens) > 0 and t.type == IDENT:
+                    if nesting == 0 and len(run_tokens) > 0 and t.type in (IDENT, THIS):
                         # Only detect new assignment if previous token suggests end of previous statement
                         # E.g., after RPAREN (end of function call) or after a complete value
                         prev_token = run_tokens[-1] if run_tokens else None

package/src/zexus/security.py

@@ -1466,6 +1466,11 @@ class SmartContract:
         instance.deploy(evaluated_storage_values=initial_storage)
         instance.parent_contract = self
         
+        # R-004 fix: Auto-call init() if it exists in the contract actions
+        if 'init' in instance.actions:
+            init_args = args if args else []
+            instance.call_method('init', init_args)
+        
         return instance
 
     def __call__(self, *args):
@@ -1694,7 +1699,10 @@ class SmartContract:
                 result = evaluator.eval_node(action.body, action_env, stack_trace=[])
             
             # Save any modified state variables back to storage
-            # SKIP variables that were set via this.property (direct storage updates)
+            # For variables updated via this.property (direct storage updates),
+            # also refresh action_env so that subsequent in-place mutations on
+            # OTHER state vars are not overwritten with stale references.
+            # This fixes R-015: push after map[key]=val being silently ignored.
             for var_node in self.storage_vars:
                 # Extract variable name from node (same logic as above)
                 var_name = None
@@ -1706,11 +1714,27 @@ class SmartContract:
                     var_name = var_node
                 
                 if var_name:
-                    # Skip if this was updated via this.property = value
                     if var_name in self._direct_storage_updates:
+                        # Variable was set directly via this.prop = val.
+                        # Storage already has the authoritative value.
+                        # Refresh action_env to keep references consistent.
+                        latest = self.storage.get(var_name)
+                        if latest is not None:
+                            action_env.set(var_name, latest)
                         continue
                     
+                    # For vars NOT directly updated, sync action_env → storage.
+                    # Also check if the storage version was mutated in-place
+                    # (e.g. via this.list.push()) and prefer the latest reference.
                     current_value = action_env.get(var_name)
+                    storage_value = self.storage.get(var_name)
+                    
+                    # Use the storage reference if it's a mutable collection
+                    # that may have been mutated in-place via this.X access
+                    if storage_value is not None and storage_value is not current_value:
+                        # Storage was mutated independently — prefer storage version
+                        current_value = storage_value
+                    
                     if var_name == 'chain' and zexus_config.should_log('debug'):
                         size = None
                         try: