zexus 1.6.3 → 1.6.5

package/README.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-![Zexus Logo](https://img.shields.io/badge/Zexus-v1.6.3-FF6B35?style=for-the-badge)
+![Zexus Logo](https://img.shields.io/badge/Zexus-v1.6.5-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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zexus",
-  "version": "1.6.3",
+  "version": "1.6.5",
   "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.3"
+__version__ = "1.6.5"
 __author__ = "Ziver Labs"
 __email__ = "ziverofficial567@gmail.com"
 

package/src/zexus/cli/main.py

@@ -91,7 +91,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.3", prog_name="Zexus")
+@click.version_option(version="1.6.5", 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,

package/src/zexus/cli/zpm.py

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

package/src/zexus/evaluator/core.py

@@ -517,30 +517,21 @@ class Evaluator(ExpressionEvaluatorMixin, StatementEvaluatorMixin, FunctionEvalu
                 if is_error(obj): 
                     return obj
                 
-                # Safely extract property name - property can be Identifier, IntegerLiteral, or other expression
-                # IMPORTANT: For Identifier nodes in index expressions (arr[i]), we need to evaluate them first!
-                if isinstance(node.property, zexus_ast.Identifier):
-                    # This could be either a property name (obj.prop) or an index variable (arr[i])
-                    # We need to check if it's being used as an index (numeric) or property (string)
-                    # First try to evaluate it as an identifier (variable lookup)
-                    prop_result = self.eval_identifier(node.property, env)
-                    if not is_error(prop_result) and not isinstance(prop_result, type(NULL)):
-                        # Successfully found a variable, use its value as the property/index
-                        property_name = prop_result.value if hasattr(prop_result, 'value') else str(prop_result)
-                    else:
-                        # Not found as variable, treat as literal property name (for obj.prop syntax)
-                        property_name = node.property.value
-                elif isinstance(node.property, zexus_ast.IntegerLiteral):
-                    # Direct integer index like arr[0]
-                    property_name = node.property.value
-                elif isinstance(node.property, zexus_ast.PropertyAccessExpression):
-                    # Nested property access - evaluate it
+                # Determine property name based on whether it's computed (obj[expr]) or literal (obj.prop)
+                if hasattr(node, 'computed') and node.computed:
+                    # Computed property (obj[expr]) - always evaluate the expression
                     prop_result = self.eval_node(node.property, env, stack_trace)
                     if is_error(prop_result):
                         return prop_result
                     property_name = prop_result.value if hasattr(prop_result, 'value') else str(prop_result)
+                elif isinstance(node.property, zexus_ast.Identifier):
+                    # Literal property (obj.prop) - use the identifier name directly
+                    property_name = node.property.value
+                elif isinstance(node.property, zexus_ast.IntegerLiteral):
+                    # Direct integer index like arr[0] (for backwards compatibility)
+                    property_name = node.property.value
                 else:
-                    # Evaluate the property expression to get the key
+                    # Fallback: evaluate the property expression
                     prop_result = self.eval_node(node.property, env, stack_trace)
                     if is_error(prop_result):
                         return prop_result

package/src/zexus/evaluator/functions.py

@@ -354,42 +354,67 @@ class FunctionEvaluatorMixin:
             
             elif isinstance(fn, EntityDefinition):
                 debug_log("  Creating entity instance (old format)")
-                # Entity constructor: Person("Alice", 30)
+                # Entity constructor: Person("Alice", 30) or Person{name: "Alice", age: 30}
                 # Create instance with positional arguments mapped to properties
                 from ..object import EntityInstance, String, Integer
                 
                 values = {}
-                # Map positional arguments to property names
-                if isinstance(fn.properties, dict):
-                    prop_names = list(fn.properties.keys())
-                else:
-                    prop_names = [prop['name'] for prop in fn.properties]
                 
-                for i, arg in enumerate(args):
-                    if i < len(prop_names):
-                        values[prop_names[i]] = arg
+                # Special case: If single argument is a Map, use it as field values
+                # This handles Entity{field: value} syntax which becomes Entity(Map{...})
+                if len(args) == 1 and isinstance(args[0], Map):
+                    debug_log("  Single Map argument detected - using as field values")
+                    map_arg = args[0]
+                    # Extract key-value pairs from the Map
+                    for key, value in map_arg.pairs.items():
+                        # Convert key to string if it's a String object
+                        key_str = key.value if isinstance(key, String) else str(key)
+                        values[key_str] = value
+                else:
+                    # Map positional arguments to property names
+                    if isinstance(fn.properties, dict):
+                        prop_names = list(fn.properties.keys())
+                    else:
+                        prop_names = [prop['name'] for prop in fn.properties]
+                    
+                    for i, arg in enumerate(args):
+                        if i < len(prop_names):
+                            values[prop_names[i]] = arg
                 
                 return EntityInstance(fn, values)
             
             # Handle SecurityEntityDefinition (from security.py with methods support)
             from ..security import EntityDefinition as SecurityEntityDef, EntityInstance as SecurityEntityInstance
+            from ..object import String
             if isinstance(fn, SecurityEntityDef):
                 debug_log("  Creating entity instance (with methods)")
                 
                 values = {}
-                # Map positional arguments to property names, INCLUDING INHERITED PROPERTIES
-                # Use get_all_properties() to get the full property list in correct order
-                if hasattr(fn, 'get_all_properties'):
-                    # Get all properties (parent + child) in correct order
-                    all_props = fn.get_all_properties()
-                    prop_names = list(all_props.keys())
-                else:
-                    # Fallback for old-style properties
-                    prop_names = list(fn.properties.keys()) if isinstance(fn.properties, dict) else [prop['name'] for prop in fn.properties]
                 
-                for i, arg in enumerate(args):
-                    if i < len(prop_names):
-                        values[prop_names[i]] = arg
+                # Special case: If single argument is a Map, use it as field values
+                # This handles Entity{field: value} syntax which becomes Entity(Map{...})
+                if len(args) == 1 and isinstance(args[0], Map):
+                    debug_log("  Single Map argument detected - using as field values")
+                    map_arg = args[0]
+                    # Extract key-value pairs from the Map
+                    for key, value in map_arg.pairs.items():
+                        # Convert key to string if it's a String object
+                        key_str = key.value if isinstance(key, String) else str(key)
+                        values[key_str] = value
+                else:
+                    # Map positional arguments to property names, INCLUDING INHERITED PROPERTIES
+                    # Use get_all_properties() to get the full property list in correct order
+                    if hasattr(fn, 'get_all_properties'):
+                        # Get all properties (parent + child) in correct order
+                        all_props = fn.get_all_properties()
+                        prop_names = list(all_props.keys())
+                    else:
+                        # Fallback for old-style properties
+                        prop_names = list(fn.properties.keys()) if isinstance(fn.properties, dict) else [prop['name'] for prop in fn.properties]
+                    
+                    for i, arg in enumerate(args):
+                        if i < len(prop_names):
+                            values[prop_names[i]] = arg
                 
                 debug_log(f"  Entity instance created with {len(values)} properties: {list(values.keys())}")
                 # Use create_instance to handle dependency injection
@@ -1977,6 +2002,8 @@ class FunctionEvaluatorMixin:
                 return Integer(len(arg.value))
             if isinstance(arg, List): 
                 return Integer(len(arg.elements))
+            if isinstance(arg, Map):
+                return Integer(len(arg.pairs))
             # Handle Python list (shouldn't happen, but defensive)
             if isinstance(arg, list):
                 return Integer(len(arg))

package/src/zexus/evaluator/statements.py

@@ -221,7 +221,7 @@ class StatementEvaluatorMixin:
             return value
         
         # Set as const in environment
-        env.set_const(node.name.value, value)
+        env.set(node.name.value, value)
         return NULL
     
     def eval_data_statement(self, node, env, stack_trace):
@@ -337,6 +337,14 @@ class StatementEvaluatorMixin:
             instance.pairs[String("__immutable__")] = Boolean(is_immutable)
             instance.pairs[String("__verified__")] = Boolean(is_verified)
             
+            # Check if single argument is a Map (from MapLiteral syntax like Block{index: 42})
+            # If so, extract field values from the map instead of treating it as positional args
+            kwargs = None
+            if len(args) == 1 and isinstance(args[0], Map):
+                # Extract keyword arguments from the Map
+                kwargs = args[0].pairs
+                debug_log("dataclass_constructor", f"Extracted {len(kwargs)} kwargs from Map")
+            
             # Process each field with validation (parent fields first, then child fields)
             arg_index = 0
             for field in all_fields:
@@ -348,8 +356,20 @@ class StatementEvaluatorMixin:
                 
                 field_value = NULL
                 
-                # Get value from arguments or default
-                if arg_index < len(args):
+                # Get value from keyword args (map syntax) or positional args
+                if kwargs is not None:
+                    # Try to get value from keyword arguments (map)
+                    field_value = kwargs.get(field_name, NULL)
+                    if field_value == NULL:
+                        # Try with String key
+                        field_value = kwargs.get(String(field_name), NULL)
+                    if field_value == NULL and field.default_value is not None:
+                        # Use default if not provided
+                        field_value = evaluator_self.eval_node(field.default_value, parent_env, stack_trace)
+                        if is_error(field_value):
+                            return field_value
+                elif arg_index < len(args):
+                    # Positional argument
                     field_value = args[arg_index]
                     arg_index += 1
                 elif field.default_value is not None:
@@ -702,10 +722,10 @@ class StatementEvaluatorMixin:
             "default": Builtin(default_static)
         }
         
-        # Register constructor in environment as const
+        # Register constructor in environment
         # For specialized generics (e.g., Box<number>), don't fail if already registered
         try:
-            env.set_const(type_name, constructor)
+            env.set(type_name, constructor)
         except ValueError as e:
             # If it's a specialized generic that's already registered, just return the existing one
             if '<' in type_name and '>' in type_name:
@@ -757,15 +777,23 @@ class StatementEvaluatorMixin:
             if is_error(obj):
                 return obj
 
-            # Safely extract property key
-            if hasattr(node.name.property, 'value'):
-                prop_key = node.name.property.value
-            else:
-                # Evaluate property expression
+            # Determine property key based on whether it's computed (obj[expr]) or literal (obj.prop)
+            if hasattr(node.name, 'computed') and node.name.computed:
+                # Computed property (obj[expr]) - evaluate the expression
                 prop_result = self.eval_node(node.name.property, env, stack_trace)
                 if is_error(prop_result):
                     return prop_result
                 prop_key = prop_result.value if hasattr(prop_result, 'value') else str(prop_result)
+            else:
+                # Literal property (obj.prop) - use the identifier name directly
+                if hasattr(node.name.property, 'value'):
+                    prop_key = node.name.property.value
+                else:
+                    # Fallback: evaluate it
+                    prop_result = self.eval_node(node.name.property, env, stack_trace)
+                    if is_error(prop_result):
+                        return prop_result
+                    prop_key = prop_result.value if hasattr(prop_result, 'value') else str(prop_result)
 
             # Evaluate value first
             value = self.eval_node(node.value, env, stack_trace)
@@ -1708,11 +1736,10 @@ class StatementEvaluatorMixin:
         
         # Pass the AST nodes as storage_vars, not the storage dict
         contract = SmartContract(node.name.value, node.storage_vars, actions)
-        contract.deploy()
+        # Deploy with evaluated storage values to avoid storing AST nodes
+        contract.deploy(evaluated_storage_values=storage)
         
-        # Initialize storage with evaluated initial values
-        for var_name, init_val in storage.items():
-            contract.storage.set(var_name, init_val)
+        # Storage values are now set during deploy(), no need to set again
         
         # Check if contract has a constructor and execute it
         if 'constructor' in actions:

package/src/zexus/lexer.py

@@ -473,7 +473,7 @@ class Lexer:
             "break": BREAK,      # NEW: Break loop keyword
             "throw": THROW,      # NEW: Throw error keyword
             "external": EXTERNAL, # NEW: External keyword
-            "from": FROM,        # NEW: From keyword
+            # "from": FROM,        # NOT a keyword - only recognized contextually in import statements
             "screen": SCREEN,         # NEW: renderer keyword
             "component": COMPONENT,   # NEW: renderer keyword
             "theme": THEME,           # NEW: renderer keyword

package/src/zexus/parser/parser.py

@@ -27,6 +27,7 @@ precedences = {
     SLASH: PRODUCT, STAR: PRODUCT, MOD: PRODUCT,
     LPAREN: CALL,
     LBRACKET: CALL,
+    LBRACE: CALL,  # Entity{...} constructor syntax
     DOT: CALL,
 }
 
@@ -103,6 +104,7 @@ class UltimateParser:
             ASSIGN: self.parse_assignment_expression,
             LAMBDA: self.parse_lambda_infix,  # support arrow-style lambdas: params => body
             LPAREN: self.parse_call_expression,
+            LBRACE: self.parse_constructor_call_expression,  # Entity{field: value} syntax
             LBRACKET: self.parse_index_expression,
             DOT: self.parse_method_call_expression,
         }
@@ -1506,7 +1508,7 @@ class UltimateParser:
             arguments = self.parse_expression_list(RPAREN)
             return MethodCallExpression(object=left, method=method, arguments=arguments)
         else:
-            return PropertyAccessExpression(object=left, property=method)
+            return PropertyAccessExpression(object=left, property=method, computed=False)
 
     def parse_export_statement(self):
         token = self.cur_token
@@ -1709,7 +1711,7 @@ class UltimateParser:
             return None
 
         field_name = Identifier(self.cur_token.literal)
-        target = PropertyAccessExpression(obj_name, field_name)
+        target = PropertyAccessExpression(obj_name, field_name, computed=False)
 
         # Expect assignment
         if not self.expect_peek(ASSIGN):
@@ -2664,6 +2666,43 @@ class UltimateParser:
                not self.peek_token_is(RBRACKET) and 
                precedence <= self.peek_precedence()):
 
+            # CRITICAL FIX: Stop if next token is on a new line and could start a new statement
+            # This prevents expressions from spanning multiple logical lines
+            if self.cur_token.line < self.peek_token.line:
+                # Next token is on a new line - check if it could start a new statement
+                next_could_be_statement = (
+                    self.peek_token.type == IDENT or
+                    self.peek_token.type == LET or
+                    self.peek_token.type == CONST or
+                    self.peek_token.type == RETURN or
+                    self.peek_token.type == IF or
+                    self.peek_token.type == WHILE or
+                    self.peek_token.type == FOR
+                )
+                if next_could_be_statement:
+                    # Additional check: is the next token followed by [ or = ?
+                    # This would indicate it's an assignment/index expression starting
+                    if self.peek_token.type == IDENT:
+                        # Save current state to peek ahead
+                        saved_cur = self.cur_token
+                        saved_peek = self.peek_token
+                        saved_pos = self.cur_pos
+                        
+                        # Peek ahead one more token
+                        self.next_token()  # Now peek_token is what we want to check
+                        next_next = self.peek_token
+                        
+                        # Restore state
+                        self.cur_token = saved_cur
+                        self.peek_token = saved_peek
+                        self.cur_pos = saved_pos
+                        
+                        # If next token after IDENT is LBRACKET or ASSIGN, it's likely a new statement
+                        if next_next.type in (LBRACKET, ASSIGN, LPAREN):
+                            break
+                    else:
+                        break
+
             if self.peek_token.type not in self.infix_parse_fns:
                 return left_exp
 
@@ -2728,6 +2767,18 @@ class UltimateParser:
         exp.arguments = self.parse_expression_list(RPAREN)
         return exp
 
+    def parse_constructor_call_expression(self, function):
+        """Parse constructor call with map literal syntax: Entity{field: value, ...}
+        
+        This converts Entity{a: 1, b: 2} into Entity({a: 1, b: 2})
+        """
+        # Current token is LBRACE, parse it as a map literal
+        map_literal = self.parse_map_literal()
+        
+        # Create a call expression with the map as the single argument
+        exp = CallExpression(function=function, arguments=[map_literal])
+        return exp
+
     def parse_prefix_expression(self):
         expression = PrefixExpression(operator=self.cur_token.literal, right=None)
         self.next_token()
@@ -2800,7 +2851,7 @@ class UltimateParser:
         # Expect closing bracket
         if not self.expect_peek(RBRACKET):
             return None
-        return PropertyAccessExpression(object=left, property=index_expr)
+        return PropertyAccessExpression(object=left, property=index_expr, computed=True)
 
     def _lookahead_token_after_matching_paren(self):
         """Character-level lookahead: detect if the matching ')' is followed by '=>' (arrow).

package/src/zexus/parser/strategy_context.py

@@ -1533,9 +1533,40 @@ class ContextStackParser:
                                     default_val = BooleanLiteral(True)
                                 elif val_token.type == FALSE:
                                     default_val = BooleanLiteral(False)
+                                elif val_token.type == LBRACE:
+                                    # Map literal: {}
+                                    # Find matching RBRACE
+                                    map_start = current_idx
+                                    depth = 1
+                                    current_idx += 1
+                                    while current_idx < brace_end and depth > 0:
+                                        if tokens[current_idx].type == LBRACE:
+                                            depth += 1
+                                        elif tokens[current_idx].type == RBRACE:
+                                            depth -= 1
+                                        current_idx += 1
+                                    # Parse the map literal
+                                    map_tokens = tokens[map_start:current_idx]
+                                    default_val = self._parse_map_literal(map_tokens)
+                                elif val_token.type == LBRACKET:
+                                    # List literal: []
+                                    # Find matching RBRACKET
+                                    list_start = current_idx
+                                    depth = 1
+                                    current_idx += 1
+                                    while current_idx < brace_end and depth > 0:
+                                        if tokens[current_idx].type == LBRACKET:
+                                            depth += 1
+                                        elif tokens[current_idx].type == RBRACKET:
+                                            depth -= 1
+                                        current_idx += 1
+                                    # Parse the list literal
+                                    list_tokens = tokens[list_start:current_idx]
+                                    default_val = self._parse_list_literal(list_tokens)
                                 elif val_token.type == IDENT:
                                     default_val = Identifier(val_token.literal)
-                                current_idx += 1
+                                    current_idx += 1
+                                # Note: current_idx already advanced for LBRACE and LBRACKET cases
 
                         # Use AstNodeShim for compatibility with evaluator
                         storage_vars.append(AstNodeShim(
@@ -3361,6 +3392,11 @@ class ContextStackParser:
                         # E.g., after RPAREN (end of function call) or after a complete value
                         prev_token = run_tokens[-1] if run_tokens else None
                         if prev_token and prev_token.type not in {DOT, LPAREN, LBRACKET, LBRACE, ASSIGN}:
+                            # CRITICAL: Also check for newline - new line + IDENT often indicates new statement
+                            last_line = prev_token.line if hasattr(prev_token, 'line') else 0
+                            current_line = t.line if hasattr(t, 'line') else 0
+                            is_new_line = current_line > last_line
+                            
                             # Check if this starts a new statement (assignment or function call)
                             k = j + 1
                             is_new_statement_start = False
@@ -3373,6 +3409,22 @@ class ContextStackParser:
                                 # Assignment: ident = or ident.prop =
                                 elif next_tok.type == ASSIGN:
                                     is_new_statement_start = True
+                                # CRITICAL FIX: Indexed assignment: ident[...]  =
+                                elif next_tok.type == LBRACKET:
+                                    # Scan for matching RBRACKET followed by ASSIGN
+                                    bracket_depth = 1
+                                    scan_idx = k + 1
+                                    while scan_idx < len(tokens) and scan_idx < k + 20:
+                                        if tokens[scan_idx].type == LBRACKET:
+                                            bracket_depth += 1
+                                        elif tokens[scan_idx].type == RBRACKET:
+                                            bracket_depth -= 1
+                                            if bracket_depth == 0:
+                                                # Found matching closing bracket, check for ASSIGN
+                                                if scan_idx + 1 < len(tokens) and tokens[scan_idx + 1].type == ASSIGN:
+                                                    is_new_statement_start = True
+                                                break
+                                        scan_idx += 1
                                 elif next_tok.type == DOT:
                                     # Property assignment: scan for ASSIGN
                                     while k < len(tokens) and k < j + 10:
@@ -3388,7 +3440,9 @@ class ContextStackParser:
                                         else:
                                             break
                             
-                            if is_new_statement_start:
+                            # Break if this is a new statement AND on a new line
+                            # (or if we're sure it's a new statement regardless of line)
+                            if is_new_statement_start and (is_new_line or prev_token.type == RPAREN):
                                 break
                     
                     # update nesting for parentheses/brackets/braces
@@ -3932,6 +3986,24 @@ class ContextStackParser:
                     if i < n and tokens[i].type == RPAREN:
                         i += 1  # Skip RPAREN
                     return CallExpression(Identifier(name), args, type_args=type_args)
+                
+                # Check for constructor call with map literal: Entity{field: value, ...}
+                elif i < n and tokens[i].type == LBRACE:
+                    # Parse the map literal as the single argument
+                    start = i
+                    depth = 1
+                    i += 1  # Skip LBRACE
+                    # Find matching RBRACE
+                    while i < n and depth > 0:
+                        if tokens[i].type == LBRACE:
+                            depth += 1
+                        elif tokens[i].type == RBRACE:
+                            depth -= 1
+                        i += 1
+                    # Parse the map literal tokens (including braces)
+                    map_literal = self._parse_map_literal(tokens[start:i])
+                    return CallExpression(Identifier(name), [map_literal], type_args=type_args)
+                
                 else:
                     return Identifier(name)
 
@@ -3997,7 +4069,8 @@ class ContextStackParser:
                     # Property access: expr.name
                     current_expr = PropertyAccessExpression(
                         object=current_expr,
-                        property=Identifier(name_token.literal)
+                        property=Identifier(name_token.literal),
+                        computed=False
                     )
                 continue
 
@@ -4052,7 +4125,8 @@ class ContextStackParser:
                 prop_expr = self._parse_expression(inner_tokens) if inner_tokens else Identifier('')
                 current_expr = PropertyAccessExpression(
                     object=current_expr,
-                    property=prop_expr
+                    property=prop_expr,
+                    computed=True
                 )
                 continue
 

package/src/zexus/parser/strategy_structural.py

@@ -728,9 +728,11 @@ class StructuralAnalyzer:
                     if tj.line > last_line:
                         # Check if we have balanced parens in run_tokens (statement is syntactically complete)
                         paren_count = sum(1 if tok.type == LPAREN else -1 if tok.type == RPAREN else 0 for tok in run_tokens)
-                        if paren_count == 0:
+                        bracket_count = sum(1 if tok.type == LBRACKET else -1 if tok.type == RBRACKET else 0 for tok in run_tokens)
+                        if paren_count == 0 and bracket_count == 0:
                             # Check if run_tokens contains an assignment (this is a complete assignment statement)
                             has_assign = any(tok.type == ASSIGN for tok in run_tokens)
+                            print(f"    has_assign={has_assign}, tj.type={tj.type}")
                             if has_assign:
                                 # Current token is on a new line and could start a new statement
                                 # Check if it's IDENT (could be method call, function call, or property access)
@@ -738,8 +740,10 @@ 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 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)")
                                         pass  # Don't break, continue collecting
                                     else:
                                         # This is likely a new statement on a new line
@@ -760,6 +764,26 @@ class StructuralAnalyzer:
                         # Look ahead: IDENT DOT IDENT ASSIGN is a property assignment
                         if j + 3 < n and tokens[j + 2].type == IDENT and tokens[j + 3].type == ASSIGN:
                             is_assignment_start = True
+                    # Pattern 3: IDENT followed by LBRACKET could be indexed assignment (arr[i] = ...)
+                    elif tj.type == IDENT and j + 1 < n and tokens[j + 1].type == LBRACKET:
+                        # Look ahead to find matching RBRACKET and then ASSIGN
+                        # This pattern is: IDENT [ ... ] ASSIGN
+                        bracket_depth = 0
+                        k = j + 1
+                        found_assign_after_bracket = False
+                        while k < n:
+                            if tokens[k].type == LBRACKET:
+                                bracket_depth += 1
+                            elif tokens[k].type == RBRACKET:
+                                bracket_depth -= 1
+                                if bracket_depth == 0:
+                                    # Found matching closing bracket, check if next is ASSIGN
+                                    if k + 1 < n and tokens[k + 1].type == ASSIGN:
+                                        found_assign_after_bracket = True
+                                    break
+                            k += 1
+                        if found_assign_after_bracket:
+                            is_assignment_start = True
                     
                     is_new_statement = (
                         tj.type in stop_types or 
@@ -993,11 +1017,12 @@ class StructuralAnalyzer:
                         continue
             
             # NEW: Check for line-based statement boundaries
-            # If we have balanced parens and the next token is on a new line and could start a new statement, create boundary
+            # If we have balanced parens/brackets and the next token is on a new line and could start a new statement, create boundary
             if cur:
-                # Check if parens are balanced
+                # Check if parens and brackets are balanced
                 paren_count = sum(1 if tok.type == LPAREN else -1 if tok.type == RPAREN else 0 for tok in cur)
-                if paren_count == 0:
+                bracket_count = sum(1 if tok.type == LBRACKET else -1 if tok.type == RBRACKET else 0 for tok in cur)
+                if paren_count == 0 and bracket_count == 0:
                     # Check if there's an ASSIGN in cur (this is a complete assignment statement)
                     has_assign = any(tok.type == ASSIGN for tok in cur)
                     if has_assign:
@@ -1005,7 +1030,7 @@ class StructuralAnalyzer:
                         last_line = cur[-1].line if cur else 0
                         if t.line > last_line:
                             # Check if current token could start a new statement
-                            # IDENT followed by DOT or LPAREN could be a new statement
+                            # IDENT could be a new statement (including indexed assignments like map[key] = val)
                             if t.type == IDENT:
                                 # This is likely a new statement on a new line
                                 results.append(cur)

package/src/zexus/security.py

@@ -734,8 +734,10 @@ class StorageBackend:
 class InMemoryBackend(StorageBackend):
     def __init__(self):
         self.data = {}
-    def set(self, key, value): self.data[key] = value
-    def get(self, key): return self.data.get(key)
+    def set(self, key, value):
+        self.data[key] = value
+    def get(self, key):
+        return self.data.get(key)
     def delete(self, key): 
         if key in self.data: del self.data[key]
 
@@ -954,8 +956,24 @@ class SmartContract:
         
         print(f"   🔗 Contract Address: {new_address}")
 
-        # Deploy the instance (initialize storage)
-        instance.deploy()
+        # Copy initial storage values from the template contract
+        # This ensures instances get the evaluated initial values
+        initial_storage = {}
+        for var_node in self.storage_vars:
+            var_name = None
+            if hasattr(var_node, 'name'):
+                var_name = var_node.name.value if hasattr(var_node.name, 'value') else var_node.name
+            elif isinstance(var_node, dict):
+                var_name = var_node.get("name")
+            
+            if var_name:
+                # Get the initial value from the template contract's storage
+                value = self.storage.get(var_name)
+                if value is not None:
+                    initial_storage[var_name] = value
+        
+        # Deploy the instance with the copied initial values
+        instance.deploy(evaluated_storage_values=initial_storage)
         instance.parent_contract = self
         
         print(f"   Available actions: {list(self.actions.keys())}")
@@ -964,32 +982,32 @@ class SmartContract:
     def __call__(self, *args):
         return self.instantiate(args)
 
-    def deploy(self):
-        """Deploy the contract and initialize persistent storage"""
+    def deploy(self, evaluated_storage_values=None):
+        """Deploy the contract and initialize persistent storage
+        
+        Args:
+            evaluated_storage_values: Optional dict of evaluated initial values
+        """
         # Checks if we should reset storage or strictly load existing
         # For simplicity in this VM, subsequent runs act like "loading" if DB exists
         self.is_deployed = True
         
-        # Initialize storage only if key doesn't exist (preserve persistence)
-        for var_node in self.storage_vars:
-            var_name = None
-            default_value = None
-
-            if hasattr(var_node, 'initial_value'):
-                var_name = var_node.name.value if hasattr(var_node.name, 'value') else var_node.name
-                default_value = var_node.initial_value
-            elif isinstance(var_node, dict) and "initial_value" in var_node:
-                var_name = var_node.get("name")
-                default_value = var_node["initial_value"]
-
-            if var_name:
-                # ONLY set if not already in DB (Persistence Logic)
+        # If evaluated values are provided, use them (from evaluator)
+        if evaluated_storage_values:
+            for var_name, value in evaluated_storage_values.items():
                 if self.storage.get(var_name) is None:
-                    if default_value is not None:
-                        self.storage.set(var_name, default_value)
-                    else:
-                        # Set reasonable defaults for types if null
-                        self.storage.set(var_name, Null)
+                    self.storage.set(var_name, value)
+        else:
+            # Fallback: Initialize storage with NULL for declared variables
+            for var_node in self.storage_vars:
+                var_name = None
+                if hasattr(var_node, 'name'):
+                    var_name = var_node.name.value if hasattr(var_node.name, 'value') else var_node.name
+                elif isinstance(var_node, dict):
+                    var_name = var_node.get("name")
+                
+                if var_name and self.storage.get(var_name) is None:
+                    self.storage.set(var_name, Null)
 
     def call_method(self, action_name, args):
         """Call a contract action - similar to EntityInstance.call_method"""

package/src/zexus/zexus_ast.py

@@ -592,12 +592,13 @@ class LiteralPattern:
         return f"LiteralPattern({self.value})"
 
 class PropertyAccessExpression(Expression):
-    def __init__(self, object, property):
+    def __init__(self, object, property, computed=False):
         self.object = object
         self.property = property
+        self.computed = computed  # True for obj[expr], False for obj.prop
 
     def __repr__(self):
-        return f"PropertyAccessExpression(object={self.object}, property={self.property})"
+        return f"PropertyAccessExpression(object={self.object}, property={self.property}, computed={self.computed})"
 
 class AssignmentExpression(Expression):
     def __init__(self, name, value):

package/src/zexus/zpm/package_manager.py

@@ -23,7 +23,7 @@ class PackageManager:
         self.installer = PackageInstaller(self.zpm_dir)
         self.publisher = PackagePublisher(self.registry)
         
-    def init(self, name: str = None, version: str = "1.6.3") -> Dict:
+    def init(self, name: str = None, version: str = "1.6.5") -> Dict:
         """Initialize a new Zexus project with package.json"""
         if self.config_file.exists():
             print(f"⚠️  {self.config_file} already exists")

package/src/zexus.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zexus
-Version: 1.6.3
+Version: 1.6.5
 Summary: A modern, security-first programming language with blockchain support
 Home-page: https://github.com/Zaidux/zexus-interpreter
 Author: Zaidux
@@ -50,7 +50,7 @@ Dynamic: requires-python
 
 <div align="center">
 
-![Zexus Logo](https://img.shields.io/badge/Zexus-v1.6.3-FF6B35?style=for-the-badge)
+![Zexus Logo](https://img.shields.io/badge/Zexus-v1.6.5-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)

package/src/zexus.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 .gitattributes
 .gitignore
 CHANGELOG.md
+FIX_SUMMARY.md
 LICENSE
 PUBLISH_TO_NPM.md
 README.md
@@ -29,9 +30,7 @@ setup.cfg
 setup.py
 setup_stdlib.sh
 shared_config.json
-test_const_time_debug.zx
 test_data.json
-test_sqlite_python.py
 ultimate_test.zx
 zexus.json
 zpics
@@ -348,6 +347,8 @@ examples/test_postgres.zx
 examples/test_sqlite.zx
 examples/token_contract.zx
 examples/ziver_chain_test.zx
+issues/ISSUE2.md
+issues/ISSUSE1.md
 linguist-submission/SUBMISSION_INSTRUCTIONS.md
 linguist-submission/grammars.yml
 linguist-submission/languages.yml