IncludeCPP 3.7.1__py3-none-any.whl → 3.7.25__py3-none-any.whl

includecpp/core/cssl/cssl_runtime.py

@@ -19,6 +19,45 @@ from .cssl_types import (
 )
 
 
+# Global custom filter registry
+# Structure: { "type::helper": callback_function }
+# Callback signature: (source, filter_value, runtime) -> Any
+_custom_filters: Dict[str, Callable[[Any, Any, Any], Any]] = {}
+
+
+def register_filter(filter_type: str, helper: str, callback: Callable[[Any, Any, Any], Any]) -> None:
+    """Register a custom filter.
+
+    Args:
+        filter_type: The filter type (e.g., "mytype")
+        helper: The helper name (e.g., "where", "index", or "*" for catch-all)
+        callback: Function(source, filter_value, runtime) -> filtered_result
+
+    Usage in CSSL:
+        result <==[mytype::where="value"] source;
+
+    Usage from Python:
+        from includecpp.core.cssl.cssl_runtime import register_filter
+        register_filter("mytype", "where", lambda src, val, rt: ...)
+    """
+    key = f"{filter_type}::{helper}"
+    _custom_filters[key] = callback
+
+
+def unregister_filter(filter_type: str, helper: str) -> bool:
+    """Unregister a custom filter."""
+    key = f"{filter_type}::{helper}"
+    if key in _custom_filters:
+        del _custom_filters[key]
+        return True
+    return False
+
+
+def get_custom_filters() -> Dict[str, Callable]:
+    """Get all registered custom filters."""
+    return _custom_filters.copy()
+
+
 class CSSLRuntimeError(Exception):
     """Runtime error during CSSL execution with detailed context"""
     def __init__(self, message: str, line: int = 0, context: str = None, hint: str = None):
@@ -401,6 +440,9 @@ class CSSLRuntime:
             elif child.type == 'instance_declaration':
                 # Handle instance declaration: instance<"name"> varName;
                 result = self._exec_instance_declaration(child)
+            elif child.type == 'super_func':
+                # Super-function for .cssl-pl payload files (#$run, #$exec, #$printl)
+                result = self._exec_super_func(child)
             elif child.type in ('assignment', 'expression', 'inject', 'receive', 'flow',
                                'if', 'while', 'for', 'c_for', 'foreach', 'switch', 'try'):
                 result = self._execute_node(child)
@@ -788,8 +830,18 @@ class CSSLRuntime:
                 if hasattr(instance, 'append'):
                     instance.append(init_value)
 
+        # Check for global modifier
+        modifiers = decl.get('modifiers', [])
+        is_global = 'global' in modifiers
+
         # Store in scope
         self.scope.set(var_name, instance)
+
+        # If global, also store in promoted_globals and global_scope
+        if is_global:
+            self._promoted_globals[var_name] = instance
+            self.global_scope.set(var_name, instance)
+
         return instance
 
     def _exec_instance_declaration(self, node: ASTNode) -> Any:
@@ -820,6 +872,82 @@ class CSSLRuntime:
         self.scope.set(var_name, instance)
         return instance
 
+    def _exec_super_func(self, node: ASTNode) -> Any:
+        """Execute super-function for .cssl-pl payload files.
+
+        Super-functions are pre-execution hooks that run when payload() loads a file.
+
+        Supported super-functions:
+            #$run(funcName)        - Call a function defined in the payload
+            #$exec(expression)     - Execute an expression immediately
+            #$printl(message)      - Print a message during load
+
+        Example .cssl-pl file:
+            void initDatabase() {
+                printl("DB initialized");
+            }
+
+            #$run(initDatabase);       // Calls initDatabase when payload loads
+            #$printl("Payload loaded"); // Prints during load
+        """
+        super_info = node.value
+        super_name = super_info.get('name', '')  # e.g., "#$run", "#$exec", "#$printl"
+        args = super_info.get('args', [])
+
+        # Extract the function name part (after #$)
+        if super_name.startswith('#$'):
+            func_type = super_name[2:]  # "run", "exec", "printl"
+        else:
+            func_type = super_name
+
+        if func_type == 'run':
+            # #$run(funcName) - Call a function by name
+            if args:
+                func_ref = args[0]
+                if isinstance(func_ref, ASTNode):
+                    if func_ref.type == 'identifier':
+                        func_name = func_ref.value
+                    elif func_ref.type == 'call':
+                        # Direct call like #$run(setup())
+                        return self._eval_call(func_ref)
+                    else:
+                        func_name = self._evaluate(func_ref)
+                else:
+                    func_name = str(func_ref)
+
+                # Look up and call the function
+                func_node = self.scope.get(func_name)
+                if func_node and isinstance(func_node, ASTNode) and func_node.type == 'function':
+                    return self._call_function(func_node, [])
+                else:
+                    raise CSSLRuntimeError(f"#$run: Function '{func_name}' not found", node.line)
+
+        elif func_type == 'exec':
+            # #$exec(expression) - Execute an expression
+            if args:
+                return self._evaluate(args[0])
+
+        elif func_type == 'printl':
+            # #$printl(message) - Print a message
+            if args:
+                msg = self._evaluate(args[0])
+                print(str(msg))
+                self.output_buffer.append(str(msg))
+                return None
+
+        elif func_type == 'print':
+            # #$print(message) - Print without newline
+            if args:
+                msg = self._evaluate(args[0])
+                print(str(msg), end='')
+                self.output_buffer.append(str(msg))
+                return None
+
+        else:
+            raise CSSLRuntimeError(f"Unknown super-function: {super_name}", node.line)
+
+        return None
+
     def _exec_global_assignment(self, node: ASTNode) -> Any:
         """Execute global variable assignment: global Name = value
 
@@ -860,6 +988,14 @@ class CSSLRuntime:
             result = self._evaluate(inner.value)
             return result
 
+        # Handle typed declaration: global datastruct<int> data;
+        elif inner.type == 'typed_declaration':
+            # Add global modifier to the declaration
+            if isinstance(inner.value, dict):
+                inner.value['modifiers'] = inner.value.get('modifiers', []) + ['global']
+            result = self._exec_typed_declaration(inner)
+            return result
+
         # Fallback: execute normally
         return self._execute_node(inner)
 
@@ -884,10 +1020,20 @@ class CSSLRuntime:
 
         # Bind parameters - handle both positional and named arguments
         for i, param in enumerate(params):
-            # Extract param name from dict format: {'name': 'a', 'type': 'int'}
-            param_name = param['name'] if isinstance(param, dict) else param
-
-            if param_name in kwargs:
+            # Extract param name and type from dict format: {'name': 'a', 'type': 'int'}
+            if isinstance(param, dict):
+                param_name = param['name']
+                param_type = param.get('type', '')
+            else:
+                param_name = param
+                param_type = ''
+
+            # Check if this is an 'open' parameter - receives all args as a list
+            if param_type == 'open' or param_name == 'Params':
+                # 'open Params' receives all arguments as a list
+                new_scope.set(param_name, list(args))
+                new_scope.set('Params', list(args))  # Also set 'Params' for OpenFind
+            elif param_name in kwargs:
                 # Named argument takes priority
                 new_scope.set(param_name, kwargs[param_name])
             elif i < len(args):
@@ -1097,8 +1243,20 @@ class CSSLRuntime:
         return None
 
     def _exec_return(self, node: ASTNode) -> Any:
-        """Execute return statement"""
-        value = self._evaluate(node.value) if node.value else None
+        """Execute return statement.
+
+        Supports multiple return values for shuffled functions:
+            return a, b, c;  // Returns tuple (a, b, c)
+        """
+        if node.value is None:
+            raise CSSLReturn(None)
+
+        # Check if this is a multiple return value
+        if isinstance(node.value, dict) and node.value.get('multiple'):
+            values = [self._evaluate(v) for v in node.value.get('values', [])]
+            raise CSSLReturn(tuple(values))
+
+        value = self._evaluate(node.value)
         raise CSSLReturn(value)
 
     def _exec_break(self, node: ASTNode) -> Any:
@@ -1173,8 +1331,11 @@ class CSSLRuntime:
 
         return command_name
 
-    def _apply_injection_filter(self, source: Any, filter_info: dict) -> Any:
-        """Apply injection filter to extract specific data from source.
+    def _apply_injection_filter(self, source: Any, filter_info) -> Any:
+        """Apply injection filter(s) to extract specific data from source.
+
+        Supports both single filter dict and list of filter dicts for chained filters.
+        Example: [dynamic::content=10][dynamic::content=100] applies both filters.
 
         All BruteInjector Helpers:
         - string::where=VALUE - Filter strings containing VALUE
@@ -1191,10 +1352,31 @@ class CSSLRuntime:
         - combo::blocked - Get blocked items from combo
         - dynamic::VarName=VALUE - Filter by dynamic variable value
         - sql::data - Return only SQL-compatible data
+        - instance::class - Get classes from object
+        - instance::method - Get methods from object
+        - instance::var - Get variables from object
+        - instance::all - Get all categorized (methods, classes, vars)
+        - instance::"ClassName" - Get specific class by name
+        - name::"Name" - Filter by name (class, dict key, attribute)
         """
         if not filter_info:
             return source
 
+        # Handle list of filters (chained filters)
+        if isinstance(filter_info, list):
+            result = source
+            for single_filter in filter_info:
+                result = self._apply_single_filter(result, single_filter)
+            return result
+
+        # Single filter (dict)
+        return self._apply_single_filter(source, filter_info)
+
+    def _apply_single_filter(self, source: Any, filter_info: dict) -> Any:
+        """Apply a single injection filter to extract specific data from source."""
+        if not filter_info:
+            return source
+
         result = source
 
         for filter_key, filter_value in filter_info.items():
@@ -1202,6 +1384,18 @@ class CSSLRuntime:
                 filter_type, helper = filter_key.split('::', 1)
                 filter_val = self._evaluate(filter_value) if isinstance(filter_value, ASTNode) else filter_value
 
+                # === CHECK CUSTOM FILTERS FIRST ===
+                custom_key = f"{filter_type}::{helper}"
+                if custom_key in _custom_filters:
+                    result = _custom_filters[custom_key](result, filter_val, self)
+                    continue
+
+                # Check for catch-all custom filter (type::*)
+                catchall_key = f"{filter_type}::*"
+                if catchall_key in _custom_filters:
+                    result = _custom_filters[catchall_key](result, filter_val, self)
+                    continue
+
                 # === STRING HELPERS ===
                 if filter_type == 'string':
                     if helper == 'where':
@@ -1378,13 +1572,112 @@ class CSSLRuntime:
 
                 # === DYNAMIC HELPERS ===
                 elif filter_type == 'dynamic':
-                    # dynamic::VarName=VALUE - Match if variable equals value
-                    var_name = helper
-                    var_value = self.scope.get(var_name)
-                    if var_value == filter_val:
-                        pass  # Keep result
+                    if helper == 'content':
+                        # dynamic::content=VALUE - General content filter for any type
+                        # Filters elements where content equals VALUE
+                        if isinstance(result, (list, tuple)):
+                            # Filter list/tuple elements by content value
+                            result = [item for item in result if item == filter_val]
+                        elif isinstance(result, dict):
+                            # Filter dict by values matching filter_val
+                            result = {k: v for k, v in result.items() if v == filter_val}
+                        elif result == filter_val:
+                            pass  # Keep result if it matches
+                        else:
+                            result = None
+                    elif helper == 'not':
+                        # dynamic::not=VALUE - Exclude elements equal to VALUE
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item != filter_val]
+                        elif isinstance(result, dict):
+                            result = {k: v for k, v in result.items() if v != filter_val}
+                        elif result != filter_val:
+                            pass  # Keep result if it doesn't match
+                        else:
+                            result = None
+                    elif helper == 'gt':
+                        # dynamic::gt=VALUE - Greater than
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item > filter_val]
+                        elif result > filter_val:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'lt':
+                        # dynamic::lt=VALUE - Less than
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item < filter_val]
+                        elif result < filter_val:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'gte':
+                        # dynamic::gte=VALUE - Greater than or equal
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item >= filter_val]
+                        elif result >= filter_val:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'lte':
+                        # dynamic::lte=VALUE - Less than or equal
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if item <= filter_val]
+                        elif result <= filter_val:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'mod':
+                        # dynamic::mod=VALUE - Modulo filter (item % VALUE == 0)
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if isinstance(item, (int, float)) and item % filter_val == 0]
+                        elif isinstance(result, (int, float)) and result % filter_val == 0:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'range':
+                        # dynamic::range="min:max" - Filter values in range
+                        if isinstance(filter_val, str) and ':' in filter_val:
+                            parts = filter_val.split(':')
+                            min_val = int(parts[0]) if parts[0] else None
+                            max_val = int(parts[1]) if parts[1] else None
+                            if isinstance(result, (list, tuple)):
+                                def in_range(x):
+                                    if min_val is not None and x < min_val:
+                                        return False
+                                    if max_val is not None and x > max_val:
+                                        return False
+                                    return True
+                                result = [item for item in result if in_range(item)]
+                            elif isinstance(result, (int, float)):
+                                if min_val is not None and result < min_val:
+                                    result = None
+                                elif max_val is not None and result > max_val:
+                                    result = None
+                    elif helper == 'even':
+                        # dynamic::even - Filter even numbers
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if isinstance(item, int) and item % 2 == 0]
+                        elif isinstance(result, int) and result % 2 == 0:
+                            pass
+                        else:
+                            result = None
+                    elif helper == 'odd':
+                        # dynamic::odd - Filter odd numbers
+                        if isinstance(result, (list, tuple)):
+                            result = [item for item in result if isinstance(item, int) and item % 2 != 0]
+                        elif isinstance(result, int) and result % 2 != 0:
+                            pass
+                        else:
+                            result = None
                     else:
-                        result = None
+                        # dynamic::VarName=VALUE - Match if variable equals value
+                        var_name = helper
+                        var_value = self.scope.get(var_name)
+                        if var_value == filter_val:
+                            pass  # Keep result
+                        else:
+                            result = None
 
                 # === SQL HELPERS ===
                 elif filter_type == 'sql':
@@ -1395,6 +1688,128 @@ class CSSLRuntime:
                         else:
                             result = str(result)  # Convert to string
 
+                # === INSTANCE HELPERS ===
+                # Works on CSSLInstance, Python objects, dicts, modules
+                elif filter_type == 'instance':
+                    from .cssl_types import CSSLInstance
+                    import inspect
+
+                    if isinstance(result, CSSLInstance):
+                        # Filter CSSL instances
+                        if helper in ('class', 'classes'):
+                            classes = {}
+                            for name, member in result._members.items():
+                                if isinstance(member, CSSLInstance):
+                                    classes[name] = member
+                            result = classes if classes else None
+                        elif helper in ('method', 'methods'):
+                            result = dict(result._class.methods)
+                        elif helper in ('var', 'vars', 'variable', 'variables'):
+                            vars_dict = {}
+                            for name, member in result._members.items():
+                                if not isinstance(member, CSSLInstance):
+                                    vars_dict[name] = member
+                            result = vars_dict
+                        elif helper in ('all',):
+                            result = {
+                                'methods': list(result._class.methods.keys()),
+                                'classes': [result._class.name] + [m._class.name for m in result._members.values() if isinstance(m, CSSLInstance)],
+                                'vars': [n for n, m in result._members.items() if not isinstance(m, CSSLInstance)]
+                            }
+                        else:
+                            # Filter by class name
+                            class_name = filter_val if filter_val else helper
+                            found = None
+                            if result._class.name == class_name:
+                                found = result
+                            else:
+                                for name, member in result._members.items():
+                                    if isinstance(member, CSSLInstance) and member._class.name == class_name:
+                                        found = member
+                                        break
+                            result = found
+                    elif isinstance(result, dict):
+                        # Filter dicts
+                        if helper in ('class', 'classes'):
+                            result = {k: v for k, v in result.items() if inspect.isclass(v)}
+                        elif helper in ('method', 'methods', 'func', 'function', 'functions'):
+                            result = {k: v for k, v in result.items() if callable(v)}
+                        elif helper in ('var', 'vars', 'variable', 'variables'):
+                            result = {k: v for k, v in result.items() if not callable(v) and not inspect.isclass(v)}
+                        else:
+                            # Get by key
+                            key_name = filter_val if filter_val else helper
+                            result = result.get(key_name)
+                    elif hasattr(result, '__dict__') or hasattr(result, '__class__'):
+                        # Filter Python objects/modules
+                        if helper in ('class', 'classes'):
+                            classes = {}
+                            for name in dir(result):
+                                if not name.startswith('_'):
+                                    attr = getattr(result, name, None)
+                                    if inspect.isclass(attr):
+                                        classes[name] = attr
+                            result = classes if classes else None
+                        elif helper in ('method', 'methods', 'func', 'function', 'functions'):
+                            methods = {}
+                            for name in dir(result):
+                                if not name.startswith('_'):
+                                    attr = getattr(result, name, None)
+                                    if callable(attr):
+                                        methods[name] = attr
+                            result = methods if methods else None
+                        elif helper in ('var', 'vars', 'variable', 'variables'):
+                            vars_dict = {}
+                            for name in dir(result):
+                                if not name.startswith('_'):
+                                    attr = getattr(result, name, None)
+                                    if not callable(attr) and not inspect.isclass(attr):
+                                        vars_dict[name] = attr
+                            result = vars_dict if vars_dict else None
+                        elif helper in ('all',):
+                            all_info = {'methods': [], 'classes': [], 'vars': []}
+                            for name in dir(result):
+                                if not name.startswith('_'):
+                                    attr = getattr(result, name, None)
+                                    if inspect.isclass(attr):
+                                        all_info['classes'].append(name)
+                                    elif callable(attr):
+                                        all_info['methods'].append(name)
+                                    else:
+                                        all_info['vars'].append(name)
+                            result = all_info
+                        else:
+                            # Get attribute by name
+                            attr_name = filter_val if filter_val else helper
+                            result = getattr(result, attr_name, None)
+
+                # === NAME HELPERS ===
+                # General name filter for any object type
+                elif filter_type == 'name':
+                    from .cssl_types import CSSLInstance
+                    target_name = filter_val if filter_val else helper
+
+                    if isinstance(result, CSSLInstance):
+                        if result._class.name == target_name:
+                            pass  # Keep result
+                        else:
+                            found = None
+                            for name, member in result._members.items():
+                                if isinstance(member, CSSLInstance) and member._class.name == target_name:
+                                    found = member
+                                    break
+                            result = found
+                    elif isinstance(result, dict):
+                        result = result.get(target_name)
+                    elif isinstance(result, list):
+                        result = [item for item in result if str(item) == target_name or (hasattr(item, 'name') and item.name == target_name)]
+                    elif hasattr(result, target_name):
+                        result = getattr(result, target_name)
+                    elif hasattr(result, '__class__') and result.__class__.__name__ == target_name:
+                        pass  # Keep result if class name matches
+                    else:
+                        result = None
+
         return result
 
     def _exec_inject(self, node: ASTNode) -> Any:
@@ -1452,7 +1867,15 @@ class CSSLRuntime:
             final_value = source
         elif mode == 'add':
             # Copy & add - preserve target and add source
-            if isinstance(current_value, list):
+            from .cssl_types import CSSLInstance
+
+            # Special handling for CSSLInstance - merge classes
+            if isinstance(current_value, CSSLInstance) and isinstance(source, CSSLInstance):
+                # Add the new class instance as a member with class name as key
+                class_name = source._class.name
+                current_value._members[class_name] = source
+                final_value = current_value
+            elif isinstance(current_value, list):
                 if isinstance(source, list):
                     final_value = current_value + source
                 else:
@@ -1468,9 +1891,14 @@ class CSSLRuntime:
         elif mode == 'move':
             # Move & remove from source
             final_value = source
-            # Clear the source
-            if isinstance(source_node, ASTNode) and source_node.type == 'identifier':
-                self.scope.set(source_node.value, None)
+            # Clear the source - handle all node types
+            if isinstance(source_node, ASTNode):
+                if source_node.type == 'identifier':
+                    self.scope.set(source_node.value, None)
+                elif source_node.type == 'module_ref':
+                    self._set_module_value(source_node.value, None)
+                elif source_node.type == 'member_access':
+                    self._set_member(source_node, None)
         else:
             final_value = source
 
@@ -1542,9 +1970,36 @@ class CSSLRuntime:
                 final_value = [current_value, source]
         elif mode == 'move':
             final_value = source
-            # Clear the source
-            if isinstance(source_node, ASTNode) and source_node.type == 'identifier':
-                self.scope.set(source_node.value, None)
+            # Remove filtered elements from source (not clear entirely)
+            if isinstance(source_node, ASTNode):
+                if filter_info:
+                    # Get original source value
+                    original_source = self._evaluate(source_node)
+                    if isinstance(original_source, list) and isinstance(final_value, list):
+                        # Remove filtered items from original list
+                        remaining = [item for item in original_source if item not in final_value]
+                        if source_node.type == 'identifier':
+                            self.scope.set(source_node.value, remaining)
+                        elif source_node.type == 'module_ref':
+                            self._set_module_value(source_node.value, remaining)
+                        elif source_node.type == 'member_access':
+                            self._set_member(source_node, remaining)
+                    else:
+                        # Single value filter - set source to None
+                        if source_node.type == 'identifier':
+                            self.scope.set(source_node.value, None)
+                        elif source_node.type == 'module_ref':
+                            self._set_module_value(source_node.value, None)
+                        elif source_node.type == 'member_access':
+                            self._set_member(source_node, None)
+                else:
+                    # No filter - clear entire source
+                    if source_node.type == 'identifier':
+                        self.scope.set(source_node.value, None)
+                    elif source_node.type == 'module_ref':
+                        self._set_module_value(source_node.value, None)
+                    elif source_node.type == 'member_access':
+                        self._set_member(source_node, None)
         else:
             final_value = source
 
@@ -1567,6 +2022,42 @@ class CSSLRuntime:
             self.global_scope.set(f'${name}', SharedObjectProxy(name, final_value))
         elif target.type == 'member_access':
             self._set_member(target, final_value)
+        elif target.type == 'typed_declaration':
+            # Handle typed target: source ==> datastruct<dynamic> Output
+            var_name = target.value.get('name')
+            type_name = target.value.get('type_name')
+            element_type = target.value.get('element_type', 'dynamic')
+
+            # Create appropriate container with final_value
+            from .cssl_types import (create_datastruct, create_vector, create_array,
+                                      create_stack, create_list, create_dictionary, create_map)
+
+            container = None
+            if type_name == 'datastruct':
+                container = create_datastruct(element_type)
+            elif type_name == 'vector':
+                container = create_vector(element_type)
+            elif type_name == 'array':
+                container = create_array(element_type)
+            elif type_name == 'stack':
+                container = create_stack(element_type)
+            elif type_name == 'list':
+                container = create_list(element_type)
+            elif type_name == 'dictionary':
+                container = create_dictionary()
+            elif type_name == 'map':
+                container = create_map()
+
+            if container is not None:
+                # Add final_value to container
+                if isinstance(final_value, (list, tuple)):
+                    container.extend(final_value)
+                elif final_value is not None:
+                    container.append(final_value)
+                self.scope.set(var_name, container)
+            else:
+                # Unknown type, just set the value directly
+                self.scope.set(var_name, final_value)
 
         return final_value
 
@@ -1725,10 +2216,44 @@ class CSSLRuntime:
 
         return value
 
+    def _exec_tuple_assignment(self, node: ASTNode) -> Any:
+        """Execute tuple unpacking assignment: a, b, c = shuffled_func()
+
+        Used with shuffled functions that return multiple values.
+        """
+        targets = node.value.get('targets', [])
+        value = self._evaluate(node.value.get('value'))
+
+        # Convert value to list if it's a tuple or iterable
+        if isinstance(value, (list, tuple)):
+            values = list(value)
+        elif hasattr(value, '__iter__') and not isinstance(value, (str, dict)):
+            values = list(value)
+        else:
+            # Single value - assign to first target only
+            values = [value]
+
+        # Assign values to targets
+        for i, target in enumerate(targets):
+            if i < len(values):
+                var_name = target.value if isinstance(target, ASTNode) else target
+                self.scope.set(var_name, values[i])
+            else:
+                # More targets than values - set to None
+                var_name = target.value if isinstance(target, ASTNode) else target
+                self.scope.set(var_name, None)
+
+        # Assignment statements don't produce a visible result
+        return None
+
     def _exec_expression(self, node: ASTNode) -> Any:
         """Execute expression statement"""
         return self._evaluate(node.value)
 
+    def _exec_type_instantiation(self, node: ASTNode) -> Any:
+        """Execute type instantiation as statement (e.g., vector<int>)"""
+        return self._evaluate(node)
+
     def _exec_await(self, node: ASTNode) -> Any:
         """Execute await statement - waits for expression to complete"""
         # Evaluate the awaited expression
@@ -1778,9 +2303,12 @@ class CSSLRuntime:
 
         if node.type == 'literal':
             value = node.value
-            # NEW: String interpolation - replace <variable> with scope values
-            if isinstance(value, str) and '<' in value and '>' in value:
-                value = self._interpolate_string(value)
+            # String interpolation - replace {var} or <var> with scope values
+            if isinstance(value, str):
+                has_fstring = '{' in value and '}' in value
+                has_legacy = '<' in value and '>' in value
+                if has_fstring or has_legacy:
+                    value = self._interpolate_string(value)
             return value
 
         # NEW: Type literals (list, dict) - create empty instances
@@ -1807,12 +2335,13 @@ class CSSLRuntime:
             return value
 
         if node.type == 'module_ref':
-            # Check modules first, then promoted globals, then scope
-            value = self.get_module(node.value)
-            if value is None:
-                value = self._promoted_globals.get(node.value)
+            # User-defined globals have priority over SDK modules
+            # Check promoted globals first, then global scope, then SDK modules
+            value = self._promoted_globals.get(node.value)
             if value is None:
                 value = self.global_scope.get(node.value)
+            if value is None:
+                value = self.get_module(node.value)  # SDK modules as fallback
             return value
 
         if node.type == 'self_ref':
@@ -1890,16 +2419,34 @@ class CSSLRuntime:
             return self._eval_this_access(node)
 
         if node.type == 'type_instantiation':
-            # Create new instance of a type: stack<string>, vector<int>, etc.
+            # Create new instance of a type: stack<string>, vector<int>, map<K,V>, etc.
             type_name = node.value.get('type')
             element_type = node.value.get('element_type', 'dynamic')
+            value_type = node.value.get('value_type')  # For map<K, V>
+            init_values = node.value.get('init_values')  # For inline init: map<K,V>{...}
+
+            # Helper to populate container with init values
+            def _populate_container(container, init_vals):
+                if init_vals and isinstance(init_vals, list):
+                    for val_node in init_vals:
+                        val = self._evaluate(val_node) if isinstance(val_node, ASTNode) else val_node
+                        if hasattr(container, 'push'):
+                            container.push(val)
+                        elif hasattr(container, 'add'):
+                            container.add(val)
+                        elif hasattr(container, 'append'):
+                            container.append(val)
+                return container
 
             if type_name == 'stack':
-                return Stack(element_type)
+                s = Stack(element_type)
+                return _populate_container(s, init_values)
             elif type_name == 'vector':
-                return Vector(element_type)
+                v = Vector(element_type)
+                return _populate_container(v, init_values)
             elif type_name == 'datastruct':
-                return DataStruct(element_type)
+                d = DataStruct(element_type)
+                return _populate_container(d, init_values)
             elif type_name == 'shuffled':
                 return Shuffled(element_type)
             elif type_name == 'iterator':
@@ -1911,11 +2458,22 @@ class CSSLRuntime:
             elif type_name == 'openquote':
                 return OpenQuote()
             elif type_name == 'array':
-                return Array(element_type)
+                a = Array(element_type)
+                return _populate_container(a, init_values)
             elif type_name == 'list':
-                return List(element_type)
+                l = List(element_type)
+                return _populate_container(l, init_values)
             elif type_name in ('dictionary', 'dict'):
                 return Dictionary(element_type)
+            elif type_name == 'map':
+                # Create Map with key_type and value_type
+                m = Map(element_type, value_type or 'dynamic')
+                # If inline initialization provided, populate the map
+                if init_values:
+                    for key, value_node in init_values.items():
+                        value = self._evaluate(value_node)
+                        m.insert(key, value)
+                return m
             else:
                 return None
 
@@ -2691,12 +3249,20 @@ class CSSLRuntime:
                 pass
 
     def _set_module_value(self, path: str, value: Any):
-        """Set a value on a module path"""
+        """Set a value on a module path or promoted global"""
         parts = path.split('.')
         if len(parts) < 2:
+            # Single name (no dots) - set in promoted_globals and global_scope
+            self._promoted_globals[path] = value
+            self.global_scope.set(path, value)
             return
 
         obj = self._modules.get(parts[0])
+        # Also check promoted_globals for the base object
+        if obj is None:
+            obj = self._promoted_globals.get(parts[0])
+        if obj is None:
+            obj = self.global_scope.get(parts[0])
         if obj is None:
             return
 
@@ -2714,14 +3280,24 @@ class CSSLRuntime:
         elif isinstance(obj, dict):
             obj[final_attr] = value
 
-    # NEW: String interpolation
+    # String interpolation (supports both <var> and {var} syntax)
     def _interpolate_string(self, string: str) -> str:
-        """Replace <variable> placeholders with values from scope - NEW
+        """Replace {variable} and <variable> placeholders with values from scope.
+
+        Both syntaxes are supported (variables only, not expressions):
+            "Hello {name}!"   -> "Hello John!"  (f-string style)
+            "Hello <name>!"   -> "Hello John!"  (legacy CSSL style)
+
+        Examples:
+            string name = "Alice";
+            int age = 30;
+            printl("Hello {name}, you are {age} years old!");
+            printl("Hello <name>, you are <age> years old!");
 
-        Example: "Hello <name>!" becomes "Hello John!" if name = "John"
+        Note: Only simple variable names are supported, not expressions.
+        Use string concatenation for complex expressions.
         """
         import re
-        pattern = r'<([A-Za-z_][A-Za-z0-9_]*)>'
 
         def replacer(match):
             var_name = match.group(1)
@@ -2733,10 +3309,23 @@ class CSSLRuntime:
             # Try modules
             if value is None:
                 value = self._modules.get(var_name)
+            # Try global scope
+            if value is None:
+                value = self.global_scope.get(var_name)
             # Return string representation or empty string if None
             return str(value) if value is not None else ''
 
-        return re.sub(pattern, replacer, string)
+        # Support both {var} and <var> syntax - simple variable names only
+        # Pattern: {identifier} or <identifier>
+        patterns = [
+            r'\{([A-Za-z_][A-Za-z0-9_]*)\}',  # {name} f-string style
+            r'<([A-Za-z_][A-Za-z0-9_]*)>',     # <name> legacy CSSL style
+        ]
+
+        result = string
+        for pattern in patterns:
+            result = re.sub(pattern, replacer, result)
+        return result
 
     # NEW: Promote variable to global scope via global()
     def promote_to_global(self, s_ref_name: str):