IncludeCPP 4.0.2__py3-none-any.whl → 4.1.0__py3-none-any.whl

includecpp/core/cssl/cssl_runtime.py

@@ -278,6 +278,26 @@ class CSSLRuntime:
         self._setup_modules()
         self._setup_builtins()
 
+    def output(self, text: str, level: str = 'normal') -> None:
+        """Output text, using callback if available, otherwise print."""
+        if self._output_callback:
+            self._output_callback(text, level)
+        else:
+            print(text, end='')
+        self.output_buffer.append(text)
+
+    def debug(self, text: str) -> None:
+        """Debug output."""
+        self.output(f"[DEBUG] {text}\n", 'debug')
+
+    def error(self, text: str) -> None:
+        """Error output."""
+        self.output(f"[ERROR] {text}\n", 'error')
+
+    def warn(self, text: str) -> None:
+        """Warning output."""
+        self.output(f"[WARN] {text}\n", 'warning')
+
     def _setup_modules(self):
         """Setup module references for @KernelClient, @VSRAM, etc."""
         if self.service_engine:
@@ -1310,29 +1330,38 @@ class CSSLRuntime:
     def _exec_instance_declaration(self, node: ASTNode) -> Any:
         """Execute instance declaration: instance<"name"> varName;
 
-        Gets or creates a shared instance by name.
+        Gets or creates a universal shared instance by name.
+        Universal instances are accessible from CSSL, Python, and C++.
+
+        Usage:
+            instance<"myContainer"> container;  // Creates or gets instance
+            container.member = "value";         // Set member
+            container +<<== { void func() {} }  // Inject methods
         """
-        from ..cssl_bridge import _live_objects, SharedObjectProxy
+        from .cssl_types import UniversalInstance
+
         decl = node.value
         instance_name = decl.get('instance_name')
         var_name = decl.get('name')
         value_node = decl.get('value')
 
-        # Get existing shared instance
-        instance = None
-        if instance_name in _live_objects:
-            instance = SharedObjectProxy(instance_name, _live_objects[instance_name])
-        elif self.global_scope.has(f'${instance_name}'):
-            instance = self.global_scope.get(f'${instance_name}')
+        # Get existing or create new universal instance
+        instance = UniversalInstance.get_or_create(instance_name)
 
-        # If value is provided, use that and register as shared
+        # If value is provided, set it as initial content
         if value_node:
-            instance = self._evaluate(value_node)
-            # Register in global scope for future access
-            self.global_scope.set(f'${instance_name}', instance)
+            initial_value = self._evaluate(value_node)
+            # If it's a dict, set all keys as members
+            if isinstance(initial_value, dict):
+                for key, val in initial_value.items():
+                    instance.set_member(key, val)
+            else:
+                instance.set_member('value', initial_value)
 
-        # Store in scope
+        # Store in scope and global scope for access
         self.scope.set(var_name, instance)
+        self.global_scope.set(f'${instance_name}', instance)
+
         return instance
 
     def _exec_super_func(self, node: ASTNode) -> Any:
@@ -2520,24 +2549,60 @@ class CSSLRuntime:
         if filter_info:
             source = self._apply_injection_filter(source, filter_info)
 
-        # Get current target value for add/move modes
+        # Get current target value for add/move/replace modes (needed for UniversalInstance handling)
         current_value = None
-        if mode in ('add', 'move'):
-            try:
-                current_value = self._evaluate(target)
-            except Exception:
-                # Target might not exist yet, that's okay for add mode
-                current_value = None
+        try:
+            current_value = self._evaluate(target)
+        except Exception:
+            # Target might not exist yet, that's okay for add mode
+            current_value = None
 
         # Determine final value based on mode
         if mode == 'replace':
-            final_value = source
+            from .cssl_types import CSSLInstance, UniversalInstance, CSSLClass
+            # Special handling for UniversalInstance targets - inject instead of replace
+            if isinstance(current_value, UniversalInstance):
+                if isinstance(source, CSSLClass):
+                    current_value.set_member(source.name, source)
+                    final_value = current_value
+                elif isinstance(source, ASTNode) and source.type == 'function':
+                    func_info = source.value
+                    func_name = func_info.get('name') if isinstance(func_info, dict) else None
+                    if func_name:
+                        current_value.set_method(func_name, source, self)
+                    final_value = current_value
+                elif isinstance(source, CSSLInstance):
+                    current_value.set_member(source._class.name, source)
+                    final_value = current_value
+                else:
+                    # For other types, store as member with source type name
+                    final_value = source
+            else:
+                final_value = source
         elif mode == 'add':
             # Copy & add - preserve target and add source
-            from .cssl_types import CSSLInstance
+            from .cssl_types import CSSLInstance, UniversalInstance, CSSLClass
 
+            # Special handling for UniversalInstance + CSSLClass
+            if isinstance(current_value, UniversalInstance) and isinstance(source, CSSLClass):
+                # Inject class definition into universal instance
+                current_value.set_member(source.name, source)
+                final_value = current_value
+            # Special handling for UniversalInstance + Function (AST node)
+            elif isinstance(current_value, UniversalInstance) and isinstance(source, ASTNode) and source.type == 'function':
+                # Inject function as a method into universal instance
+                func_info = source.value
+                func_name = func_info.get('name') if isinstance(func_info, dict) else None
+                if func_name:
+                    current_value.set_method(func_name, source, self)
+                final_value = current_value
+            # Special handling for UniversalInstance + CSSLInstance
+            elif isinstance(current_value, UniversalInstance) and isinstance(source, CSSLInstance):
+                class_name = source._class.name
+                current_value.set_member(class_name, source)
+                final_value = current_value
             # Special handling for CSSLInstance - merge classes
-            if isinstance(current_value, CSSLInstance) and isinstance(source, CSSLInstance):
+            elif 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
@@ -2736,8 +2801,13 @@ class CSSLRuntime:
         - add: func +<<== { code } - ADDS code to function (both execute)
         - remove: func -<<== { code } - REMOVES matching code from function
 
+        Also supports instance injection:
+        - instance +<<== { void method() { ... } } - ADDS methods to UniversalInstance
+
         Also supports expression form: func <<== %exit() (wraps in action_block)
         """
+        from .cssl_types import UniversalInstance
+
         target = node.value.get('target')
         code_block = node.value.get('code')
         source_expr = node.value.get('source')  # For expression form: func <<== expr
@@ -2749,6 +2819,17 @@ class CSSLRuntime:
             expr_node = ASTNode('expression', value=source_expr)
             code_block = ASTNode('action_block', children=[expr_node])
 
+        # Check if target is a UniversalInstance
+        target_value = None
+        if isinstance(target, ASTNode) and target.type == 'identifier':
+            target_value = self.scope.get(target.value)
+            if target_value is None:
+                target_value = self.global_scope.get(target.value)
+
+        # Handle UniversalInstance injection
+        if isinstance(target_value, UniversalInstance):
+            return self._inject_into_instance(target_value, code_block, mode)
+
         # Get function name from target
         func_name = None
         if isinstance(target, ASTNode):
@@ -2796,6 +2877,60 @@ class CSSLRuntime:
 
         return None
 
+    def _inject_into_instance(self, instance: Any, code_block: Any, mode: str) -> Any:
+        """Inject code/methods into a UniversalInstance.
+
+        Usage:
+            instance<"myContainer"> container;
+            container +<<== {
+                void sayHello() { printl("Hello!"); }
+                int value = 42;
+            }
+        """
+        from .cssl_types import UniversalInstance
+
+        if not isinstance(instance, UniversalInstance):
+            return None
+
+        if code_block is None:
+            return None
+
+        # Store the raw injection
+        instance.add_injection(code_block)
+
+        # Parse the code block for function definitions and variable declarations
+        if isinstance(code_block, ASTNode):
+            children = code_block.children if hasattr(code_block, 'children') else []
+
+            for child in children:
+                if isinstance(child, ASTNode):
+                    if child.type == 'function':
+                        # Extract function name and store the AST node
+                        func_info = child.value
+                        func_name = func_info.get('name') if isinstance(func_info, dict) else None
+                        if func_name:
+                            instance.set_method(func_name, child, self)
+                    elif child.type == 'var_declaration':
+                        # Extract variable and value
+                        var_info = child.value
+                        if isinstance(var_info, dict):
+                            var_name = var_info.get('name')
+                            value_node = var_info.get('value')
+                            if var_name:
+                                value = self._evaluate(value_node) if value_node else None
+                                instance.set_member(var_name, value)
+                    elif child.type == 'typed_var_declaration':
+                        # Typed variable declaration
+                        var_info = child.value
+                        if isinstance(var_info, dict):
+                            var_name = var_info.get('name')
+                            value_node = var_info.get('value')
+                            if var_name:
+                                value = self._evaluate(value_node) if value_node else None
+                                instance.set_member(var_name, value)
+
+        return instance
+
     def _exec_infuse_right(self, node: ASTNode) -> Any:
         """Execute right-side code infusion (==>>)"""
         source = node.value.get('source')
@@ -3115,6 +3250,45 @@ class CSSLRuntime:
             # Return None if instance doesn't exist (can be created via ==>)
             return None
 
+        # v4.1.0: Cross-language instance reference: cpp$ClassName, py$Object
+        if node.type == 'lang_instance_ref':
+            ref = node.value  # {'lang': 'cpp', 'instance': 'ClassName'}
+            lang_id = ref['lang']
+            instance_name = ref['instance']
+
+            # First, try to get the language support object from scope
+            lang_support = self.scope.get(lang_id)
+            if lang_support is None:
+                lang_support = self.global_scope.get(lang_id)
+
+            # If not found in scope, try to get from modules
+            if lang_support is None:
+                lang_support = self._modules.get(lang_id)
+
+            # If still not found, try getting default language support
+            if lang_support is None:
+                from .cssl_languages import get_language
+                lang_support = get_language(lang_id)
+
+            if lang_support is not None:
+                # Check if it's a LanguageSupport object with get_instance method
+                if hasattr(lang_support, 'get_instance'):
+                    instance = lang_support.get_instance(instance_name)
+                    if instance is not None:
+                        return instance
+                # Check _instances dict directly
+                if hasattr(lang_support, '_instances'):
+                    if instance_name in lang_support._instances:
+                        return lang_support._instances[instance_name]
+
+            # Build helpful error message
+            hint = f"Use '{lang_id}.share(\"{instance_name}\", instance)' to register the instance first."
+            raise self._format_error(
+                node.line if hasattr(node, 'line') else 0,
+                f"Cross-language instance '{lang_id}${instance_name}' not found",
+                hint
+            )
+
         if node.type == 'new':
             # Create new instance of a class: new ClassName(args)
             return self._eval_new(node)
@@ -3188,6 +3362,14 @@ class CSSLRuntime:
         if node.type == 'unary':
             return self._eval_unary(node)
 
+        # Increment: ++i or i++
+        if node.type == 'increment':
+            return self._eval_increment(node)
+
+        # Decrement: --i or i--
+        if node.type == 'decrement':
+            return self._eval_decrement(node)
+
         if node.type == 'non_null_assert':
             # *$var, *@module, *identifier - assert value is not null/None
             operand = node.value.get('operand')
@@ -3473,6 +3655,74 @@ class CSSLRuntime:
 
         return None
 
+    def _eval_increment(self, node: ASTNode) -> Any:
+        """Evaluate increment operation (++i or i++)"""
+        op_type = node.value.get('op')  # 'prefix' or 'postfix'
+        operand = node.value.get('operand')
+
+        # Get variable name
+        var_name = None
+        if isinstance(operand, ASTNode):
+            if operand.type == 'identifier':
+                var_name = operand.value
+            elif operand.type == 'shared_ref':
+                # Handle $var++
+                var_name = operand.value
+                current = self.shared_vars.get(var_name, 0)
+                if op_type == 'prefix':
+                    self.shared_vars[var_name] = current + 1
+                    return current + 1
+                else:  # postfix
+                    self.shared_vars[var_name] = current + 1
+                    return current
+
+        if var_name:
+            current = self.scope.get(var_name, 0)
+            if op_type == 'prefix':
+                # ++i: increment then return
+                self.scope.set(var_name, current + 1)
+                return current + 1
+            else:
+                # i++: return then increment
+                self.scope.set(var_name, current + 1)
+                return current
+
+        return None
+
+    def _eval_decrement(self, node: ASTNode) -> Any:
+        """Evaluate decrement operation (--i or i--)"""
+        op_type = node.value.get('op')  # 'prefix' or 'postfix'
+        operand = node.value.get('operand')
+
+        # Get variable name
+        var_name = None
+        if isinstance(operand, ASTNode):
+            if operand.type == 'identifier':
+                var_name = operand.value
+            elif operand.type == 'shared_ref':
+                # Handle $var--
+                var_name = operand.value
+                current = self.shared_vars.get(var_name, 0)
+                if op_type == 'prefix':
+                    self.shared_vars[var_name] = current - 1
+                    return current - 1
+                else:  # postfix
+                    self.shared_vars[var_name] = current - 1
+                    return current
+
+        if var_name:
+            current = self.scope.get(var_name, 0)
+            if op_type == 'prefix':
+                # --i: decrement then return
+                self.scope.set(var_name, current - 1)
+                return current - 1
+            else:
+                # i--: return then decrement
+                self.scope.set(var_name, current - 1)
+                return current
+
+        return None
+
     def _eval_call(self, node: ASTNode) -> Any:
         """Evaluate function call with optional named arguments"""
         callee_node = node.value.get('callee')
@@ -3516,7 +3766,33 @@ class CSSLRuntime:
         if isinstance(callee, ASTNode) and callee.type == 'function':
             return self._call_function(callee, args, kwargs)
 
-        callee_name = callee_node.value if isinstance(callee_node, ASTNode) and hasattr(callee_node, 'value') else str(callee_node)
+        # Extract callee name for error messages
+        if isinstance(callee_node, ASTNode) and hasattr(callee_node, 'value'):
+            val = callee_node.value
+            if isinstance(val, str):
+                callee_name = val
+            elif isinstance(val, dict):
+                # For member access nodes like obj.method, get the member name
+                if 'member' in val:
+                    obj_node = val.get('object')
+                    member = val.get('member')
+                    obj_name = obj_node.value if isinstance(obj_node, ASTNode) else str(obj_node)
+                    callee_name = f"{obj_name}.{member}"
+                # For call nodes, try to get the callee name
+                elif 'callee' in val:
+                    callee_val = val.get('callee')
+                    if isinstance(callee_val, ASTNode):
+                        callee_name = callee_val.value if isinstance(callee_val.value, str) else str(callee_val.value)
+                    else:
+                        callee_name = str(callee_val)
+                elif 'name' in val:
+                    callee_name = str(val.get('name'))
+                else:
+                    callee_name = str(val)
+            else:
+                callee_name = str(val)
+        else:
+            callee_name = str(callee_node)
 
         # Build detailed error with suggestions
         available_funcs = _get_available_functions(self.scope, self.global_scope, self.builtins)
@@ -3658,6 +3934,22 @@ class CSSLRuntime:
                 hint
             )
 
+        # If we got a variable that holds a class reference, use that class
+        if not isinstance(class_def, CSSLClass):
+            # Check if it's a variable holding a class (dynamic class instantiation)
+            if hasattr(class_def, '__class__') and isinstance(class_def, CSSLClass):
+                pass  # Already a CSSLClass, continue
+            elif isinstance(class_def, dict) and 'class_def' in class_def:
+                # Injected class reference from +<== operator
+                class_def = class_def['class_def']
+            else:
+                # Not a class - show error
+                raise CSSLRuntimeError(
+                    f"'{class_name}' is not a class",
+                    node.line,
+                    hint=f"'{class_name}' is of type {type(class_def).__name__}"
+                )
+
         if not isinstance(class_def, CSSLClass):
             raise CSSLRuntimeError(
                 f"'{class_name}' is not a class",
@@ -4112,6 +4404,48 @@ class CSSLRuntime:
                 hint
             )
 
+        # === UNIVERSAL INSTANCE METHODS ===
+        from .cssl_types import UniversalInstance
+        if isinstance(obj, UniversalInstance):
+            # Check for member variable
+            if obj.has_member(member):
+                return obj.get_member(member)
+            # Check for method
+            if obj.has_method(member):
+                method_node = obj.get_method(member)
+                # Create a callable that executes the method in context
+                def instance_method_caller(*args, **kwargs):
+                    # Set 'this' to refer to the instance
+                    old_this = self.scope.get('this')
+                    self.scope.set('this', obj)
+                    try:
+                        return self._call_function(method_node, list(args))
+                    finally:
+                        if old_this is not None:
+                            self.scope.set('this', old_this)
+                        else:
+                            self.scope.remove('this') if hasattr(self.scope, 'remove') else None
+                return instance_method_caller
+            # Build helpful error with available members
+            instance_name = obj.name
+            available_members = list(obj.get_all_members().keys())
+            available_methods = list(obj.get_all_methods().keys())
+            all_available = available_members + available_methods
+            similar = _find_similar_names(member, all_available)
+
+            if similar:
+                hint = f"Did you mean: {', '.join(similar)}?"
+            elif all_available:
+                hint = f"Available: {', '.join(all_available[:5])}"
+            else:
+                hint = f"Instance '{instance_name}' has no accessible members."
+
+            raise self._format_error(
+                node.line,
+                f"Instance '{instance_name}' has no member or method '{member}'",
+                hint
+            )
+
         # === STRING METHODS ===
         if isinstance(obj, str):
             string_methods = self._get_string_method(obj, member)
@@ -4350,6 +4684,12 @@ class CSSLRuntime:
             obj.set_member(member, value)
             return
 
+        # Check for UniversalInstance - use set_member method
+        from .cssl_types import UniversalInstance
+        if isinstance(obj, UniversalInstance):
+            obj.set_member(member, value)
+            return
+
         # Check for SharedObjectProxy - directly access underlying object
         # This is more robust than relying on the proxy's __setattr__
         if hasattr(obj, '_direct_object') and hasattr(obj, '_name'):

includecpp/core/cssl/cssl_syntax.py

@@ -31,6 +31,11 @@ class TokenCategory(Enum):
     NULL = auto()             # null, None
     PACKAGE_KW = auto()       # package, package-includes - NEW
     TYPE_LITERAL = auto()     # list, dict - NEW
+    # v4.1.0: Multi-language support
+    SUPPORTS_KW = auto()      # supports keyword (magenta)
+    LIBINCLUDE_KW = auto()    # libinclude (yellow/gold)
+    LANG_PREFIX = auto()      # Language prefix before $ (cyan): cpp$, py$, java$
+    LANG_INSTANCE = auto()    # Instance name after $ (orange): cpp$ClassName
 
 
 @dataclass
@@ -52,9 +57,17 @@ KEYWORDS = {
     'start', 'stop', 'wait_for', 'on_event', 'emit_event',
     'await',
     # NEW: Extended keywords
-    'package', 'package-includes', 'exec', 'as', 'global'
+    'package', 'package-includes', 'exec', 'as', 'global',
+    # v4.1.0: Multi-language support (handled separately for special colors)
+    # 'supports', 'libinclude' - see MULTI_LANG_KEYWORDS
 }
 
+# v4.1.0: Multi-language keywords with special highlighting
+MULTI_LANG_KEYWORDS = {'supports', 'libinclude'}
+
+# v4.1.0: Language identifiers for cross-language instance access
+LANGUAGE_IDS = {'cpp', 'py', 'python', 'java', 'csharp', 'js', 'javascript'}
+
 # NEW: Package-related keywords for special highlighting
 PACKAGE_KEYWORDS = {'package', 'package-includes'}
 
@@ -145,6 +158,33 @@ class CSSLSyntaxRules:
             category=TokenCategory.TYPE_LITERAL
         ))
 
+        # v4.1.0: Multi-language support keywords
+        # 'supports' keyword (magenta) - must be before regular keywords
+        rules.append(HighlightRule(
+            pattern=r'\bsupports\b',
+            category=TokenCategory.SUPPORTS_KW
+        ))
+
+        # 'libinclude' keyword (yellow/gold)
+        rules.append(HighlightRule(
+            pattern=r'\blibinclude\b',
+            category=TokenCategory.LIBINCLUDE_KW
+        ))
+
+        # v4.1.0: Language$Instance patterns (cpp$ClassName, py$Object)
+        # Match language prefix before $ (cyan)
+        rules.append(HighlightRule(
+            pattern=r'\b(cpp|py|python|java|csharp|js|javascript)\$',
+            category=TokenCategory.LANG_PREFIX,
+            group=1
+        ))
+        # Match instance name after $ (orange)
+        rules.append(HighlightRule(
+            pattern=r'\b(?:cpp|py|python|java|csharp|js|javascript)\$([A-Za-z_][A-Za-z0-9_]*)',
+            category=TokenCategory.LANG_INSTANCE,
+            group=1
+        ))
+
         # Self-references (s@Name, s@Backend.Loop)
         rules.append(HighlightRule(
             pattern=r's@[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*',
@@ -233,6 +273,11 @@ class ColorScheme:
         TokenCategory.NULL: '#ff6464',         # Red
         TokenCategory.PACKAGE_KW: '#bd93f9',   # Purple for package - NEW
         TokenCategory.TYPE_LITERAL: '#8be9fd', # Cyan for type literals - NEW
+        # v4.1.0: Multi-language support colors
+        TokenCategory.SUPPORTS_KW: '#ff79c6',  # Magenta/Pink for 'supports'
+        TokenCategory.LIBINCLUDE_KW: '#f1fa8c',# Yellow/Gold for 'libinclude'
+        TokenCategory.LANG_PREFIX: '#8be9fd',  # Cyan for language prefix (cpp$)
+        TokenCategory.LANG_INSTANCE: '#ffb86c',# Orange for instance name ($ClassName)
     }
 
     # Light theme variant
@@ -252,6 +297,11 @@ class ColorScheme:
         TokenCategory.NULL: '#ff0000',         # Red
         TokenCategory.PACKAGE_KW: '#8b008b',   # DarkMagenta for package - NEW
         TokenCategory.TYPE_LITERAL: '#008b8b', # Dark cyan for type literals - NEW
+        # v4.1.0: Multi-language support colors
+        TokenCategory.SUPPORTS_KW: '#d63384',  # Dark Magenta for 'supports'
+        TokenCategory.LIBINCLUDE_KW: '#b8860b',# DarkGoldenrod for 'libinclude'
+        TokenCategory.LANG_PREFIX: '#0d6efd',  # Blue for language prefix (cpp$)
+        TokenCategory.LANG_INSTANCE: '#fd7e14',# Orange for instance name ($ClassName)
     }
 
 
@@ -334,6 +384,11 @@ def highlight_cssl_ansi(source: str) -> str:
         TokenCategory.NULL: '\033[91m',         # Red
         TokenCategory.PACKAGE_KW: '\033[95m',   # Magenta for package - NEW
         TokenCategory.TYPE_LITERAL: '\033[96m', # Cyan for type literals - NEW
+        # v4.1.0: Multi-language support colors
+        TokenCategory.SUPPORTS_KW: '\033[95m',  # Magenta for 'supports'
+        TokenCategory.LIBINCLUDE_KW: '\033[93m',# Yellow for 'libinclude'
+        TokenCategory.LANG_PREFIX: '\033[96m',  # Cyan for language prefix (cpp$)
+        TokenCategory.LANG_INSTANCE: '\033[33m',# Orange/Yellow for instance name
     }
     RESET = '\033[0m'
 
@@ -439,6 +494,10 @@ def export_textmate_grammar() -> dict:
                 "name": "comment.line.cssl",
                 "match": "#.*$"
             },
+            {
+                "name": "comment.line.double-slash.cssl",
+                "match": "//.*$"
+            },
             {
                 "name": "string.quoted.double.cssl",
                 "match": '"(?:[^"\\\\]|\\\\.)*"'
@@ -447,6 +506,23 @@ def export_textmate_grammar() -> dict:
                 "name": "string.quoted.single.cssl",
                 "match": "'(?:[^'\\\\]|\\\\.)*'"
             },
+            # v4.1.0: Multi-language support
+            {
+                "name": "keyword.control.supports.cssl",
+                "match": "\\bsupports\\b"
+            },
+            {
+                "name": "support.function.libinclude.cssl",
+                "match": "\\blibinclude\\b"
+            },
+            {
+                "name": "variable.language.lang-instance.cssl",
+                "match": "\\b(cpp|py|python|java|csharp|js|javascript)\\$([A-Za-z_][A-Za-z0-9_]*)",
+                "captures": {
+                    "1": {"name": "entity.name.type.language.cssl"},
+                    "2": {"name": "variable.other.instance.cssl"}
+                }
+            },
             {
                 "name": "variable.other.self-reference.cssl",
                 "match": "s@[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*"
@@ -455,9 +531,13 @@ def export_textmate_grammar() -> dict:
                 "name": "variable.other.module-reference.cssl",
                 "match": "@[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*"
             },
+            {
+                "name": "keyword.other.package.cssl",
+                "match": "\\b(package|package-includes)\\b"
+            },
             {
                 "name": "keyword.control.cssl",
-                "match": "\\b(service-init|service-run|service-include|struct|define|if|else|elif|while|for|foreach|in|switch|case|default|break|continue|return|try|catch|await)\\b"
+                "match": "\\b(service-init|service-run|service-include|struct|define|class|constr|if|else|elif|while|for|foreach|in|switch|case|default|break|continue|return|try|catch|finally|throw|await|extends|overwrites|global|as|exec)\\b"
             },
             {
                 "name": "keyword.operator.cssl",
@@ -465,7 +545,7 @@ def export_textmate_grammar() -> dict:
             },
             {
                 "name": "constant.language.cssl",
-                "match": "\\b(True|False|true|false|null|None)\\b"
+                "match": "\\b(True|False|true|false|null|None|none)\\b"
             },
             {
                 "name": "constant.numeric.cssl",
@@ -473,7 +553,11 @@ def export_textmate_grammar() -> dict:
             },
             {
                 "name": "keyword.operator.assignment.cssl",
-                "match": "<==|==>|->|<-"
+                "match": "<==|==>|->|<-|::"
+            },
+            {
+                "name": "support.type.cssl",
+                "match": "\\b(list|dict)\\b(?!\\s*\\()"
             }
         ]
     }