IncludeCPP 4.6.0__py3-none-any.whl → 4.9.3__py3-none-any.whl

includecpp/core/cssl/CSSL_DOCUMENTATION.md

@@ -1,1720 +1,2074 @@
-    # CSSL - C-Style Scripting Language
+# CSSL - C-Style Scripting Language
 
-    > Version 4.1.0 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, Python Interop, and Multi-Language Support.
+> Version 4.9.3 | A modern scripting language with C++-style syntax featuring async/await, generators, CodeInfusion, BruteInjection, Snapshots, Python/C++ Interop, Multi-Language Support, and 330+ built-in functions.
 
-    ---
+---
 
-    ## Table of Contents
+## Table of Contents
 
-    1. [Quick Start](#quick-start)
-    2. [Syntax Basics](#syntax-basics)
-    3. [Data Types](#data-types)
-    4. [Variables & Globals](#variables--globals)
-    5. [Operators](#operators)
-    6. [Control Flow](#control-flow)
-    7. [Functions](#functions)
-    8. [Classes & OOP](#classes--oop)
-    9. [Container Types](#container-types)
-    10. [Built-in Functions](#built-in-functions)
-    11. [CodeInfusion](#codeinfusion)
-    12. [BruteInjection](#bruteinjection)
-    13. [Value Capture](#value-capture)
-    14. [Module System](#module-system)
-    15. [Multi-Language Support](#multi-language-support)
-    16. [Error Handling](#error-handling)
-    17. [Quick Reference](#quick-reference)
+1. [Quick Start](#quick-start)
+2. [Syntax Basics](#syntax-basics)
+3. [Data Types](#data-types)
+4. [Variables & Scope](#variables--scope)
+5. [Operators](#operators)
+6. [Control Flow](#control-flow)
+7. [Functions](#functions)
+8. [Classes & OOP](#classes--oop)
+9. [Namespaces](#namespaces)
+10. [Enums & Structs](#enums--structs)
+11. [Container Types](#container-types)
+12. [Built-in Functions](#built-in-functions)
+13. [CodeInfusion](#codeinfusion)
+14. [BruteInjection](#bruteinjection)
+15. [Snapshot System](#snapshot-system)
+16. [C++ I/O Streams](#c-io-streams)
+17. [Module System](#module-system)
+18. [C++ Integration](#c-integration)
+19. [Python Interop](#python-interop)
+20. [Multi-Language Support](#multi-language-support)
+21. [Async/Await System](#asyncawait-system-v493)
+22. [Error Handling](#error-handling)
+23. [CLI Reference](#cli-reference)
+24. [Quick Reference](#quick-reference)
 
-    ---
+---
 
-    ## Quick Start
+## Quick Start
 
-    ### Installation
+### Installation
 
-    ```bash
-    pip install includecpp
-    ```
+```bash
+pip install includecpp
+```
 
-    ### Python Usage
+### Python Usage
 
-    ```python
-    from includecpp import CSSL
+```python
+from includecpp import CSSL
 
-    # Execute CSSL code
-    CSSL.run('''
-        printl("Hello CSSL!");
-    ''')
+# Execute CSSL code
+CSSL.run('''
+    printl("Hello CSSL!");
+''')
 
-    # With parameters and return value
-    result = CSSL.run('''
-        string name = parameter.get(0);
-        printl("Hello " + name);
-        parameter.return(true);
-    ''', "World")
+# With parameters and return value
+result = CSSL.run('''
+    string name = parameter.get(0);
+    printl("Hello " + name);
+    parameter.return(true);
+''', "World")
 
-    print(result)  # True
-    ```
+print(result)  # True
+```
 
-    ### CLI Execution
+### CLI Execution
 
-    ```bash
-    # Execute CSSL file
-    python -m includecpp cssl exec myfile.cssl
+```bash
+# Execute CSSL file
+includecpp cssl run myfile.cssl
 
-    # Create module from Python file
-    python -m includecpp cssl makemodule mylib.py -o mylib.cssl-mod
-    ```
+# Run inline code
+includecpp cssl run -c 'printl("Hello!");'
 
-    ### First Script
+# Create module from Python file
+includecpp cssl makemodule mylib.py -o mylib.cssl-mod
 
-    ```cssl
-    // Variables
-    string name = "CSSL";
-    int version = 3;
+# Format CSSL file
+includecpp cssl format myfile.cssl
+```
 
-    // Output
-    printl("Welcome to " + name);
+### First Script
 
-    // Function
-    void greet(string msg) {
-        printl(msg);
-    }
+```cssl
+// Variables
+string name = "CSSL";
+int version = 4;
 
-    greet("Hello World!");
-    ```
+// Output
+printl("Welcome to " + name + " v" + version);
 
-    ---
+// Function
+void greet(string msg) {
+    printl(msg);
+}
 
-    ## Syntax Basics
+greet("Hello World!");
+
+// Class
+class Greeter {
+    string prefix = "Hello";
 
-    ### Comments
+    constr(string p) {
+        this->prefix = p;
+    }
+
+    void say(string name) {
+        printl(this->prefix + ", " + name + "!");
+    }
+}
+
+@g = new Greeter("Hi");
+g.say("CSSL");
+```
+
+---
+
+## Syntax Basics
+
+### Comments
+
+```cssl
+// Single-line comment (C-style)
+# Single-line comment (Python-style)
+/* Multi-line
+   comment */
+```
 
-    ```cssl
-    // Single-line comment (C-style)
-    # Single-line comment (Python-style)
-    ```
+### Semicolons
 
-    ### Semicolons
+Semicolons are optional but recommended for clarity.
 
-    Semicolons are optional but recommended for clarity.
+```cssl
+printl("Hello")    // Works
+printl("Hello");   // Also works (recommended)
+```
 
-    ```cssl
-    printl("Hello")    // Works
-    printl("Hello");   // Also works (recommended)
-    ```
+### I/O Functions
+
+```cssl
+// Output
+printl("Text");              // Print with newline
+println("Text");             // Alias for printl
+print("No newline");         // Print without newline
+debug("Debug info");         // Print with [DEBUG] prefix
+error("Error message");      // Print with [ERROR] prefix
+warn("Warning");             // Print with [WARN] prefix
+log("INFO", "Message");      // Print with custom prefix
+
+// Input
+string name = input("Enter your name: ");
+int age = int(input("Enter your age: "));
+string raw = input();        // Without prompt
+```
+
+### String Syntax
+
+```cssl
+// Basic strings
+string s1 = "Double quoted";
+string s2 = 'Single quoted';
+string s3 = `Raw string (no escape processing)`;
+
+// String interpolation
+string name = "CSSL";
+printl("Welcome to <name>");  // "Welcome to CSSL"
+
+// F-strings (v4.6.3)
+printl(f"Hello {name}!");
+printl(f"{red('Error:')} Something went wrong");
+printl(f"Result: {bold(str(42))}");
+
+// Escape sequences
+"\n"  // Newline
+"\t"  // Tab
+"\\"  // Backslash
+"\""  // Double quote
+```
+
+---
+
+## Data Types
+
+### Primitive Types
+
+| Type | Description | Example |
+|------|-------------|---------|
+| `int` | Integer | `int x = 42;` |
+| `float` | Floating point | `float f = 3.14;` |
+| `string` | Text string | `string s = "Hello";` |
+| `bool` | Boolean | `bool b = true;` |
+| `bit` | Binary 0 or 1 (v4.9.0) | `bit flag = 1;` |
+| `byte` | 8-bit value (v4.9.0) | `byte b = 1^200;` |
+| `address` | Memory reference (v4.9.0) | `address addr = memory(x).get("address");` |
+| `dynamic` | Any type (flexible) | `dynamic x = "text";` |
+| `void` | No return value | `void func() { }` |
+| `undefined` | Function errors ignored | `undefined func() { }` |
+| `null` / `None` | Absence of value | `dynamic x = null;` |
+| `json` | JSON type | `json data = {"key": "value"};` |
+
+### Boolean Values
+
+```cssl
+// Python-style
+bool a = True;
+bool b = False;
+
+// C-style
+bool c = true;
+bool d = false;
+```
+
+### Type Conversion
+
+```cssl
+int("42");          // String to int: 42
+float("3.14");      // String to float: 3.14
+str(42);            // Int to string: "42"
+bool(1);            // Int to bool: true
+int("ff", 16);      // Hex to int: 255
+list("abc");        // String to list: ['a', 'b', 'c']
+dict([["a", 1]]);   // List to dict
+```
+
+### Type Checking
+
+```cssl
+typeof(42);              // "int"
+typeof("hello");         // "str"
+typeof([1, 2]);          // "list"
+isinstance(42, "int");   // true
+isint(42);               // true
+isfloat(3.14);           // true
+isstr("hello");          // true
+isbool(true);            // true
+islist([1, 2]);          // true
+isdict({"a": 1});        // true
+isnull(null);            // true
+```
+
+### Binary Types (v4.9.0)
+
+**bit** - Single binary value (0 or 1):
+```cssl
+bit flag = 1;
+printl(flag);           // 1
+
+flag.switch();          // Toggle: 1 -> 0
+printl(flag);           // 0
+
+flag.set(1);            // Set to 1
+flag.clear();           // Set to 0
+
+bit copy = flag.copy(); // Create copy
+```
+
+**byte** - 8-bit value with x^y notation:
+```cssl
+// x^y notation: x = base (0/1), y = weight (0-255)
+byte b = 1^200;         // Value = 200
+
+printl(b.value());      // 200
+printl(b.to_str());     // "11001000" (binary)
+printl(b.info());       // Full info dict
+
+// Bit operations
+printl(b.at(7));        // Get bit 7
+b.switch(7);            // Toggle bit 7
+b.set(0, 1);            // Set bit 0 to 1
+b.write(0, 4);          // Set bits 0-3 to 1
+
+// Copy and reverse
+byte r = b.reverse();   // Reverse bit order
+byte c = b.copy();      // Copy byte
+```
+
+**address** - Memory reference (pointer-like):
+```cssl
+string text = "Hello";
+
+// Get memory address
+address addr = memory(text).get("address");
+
+// Reflect to get object back
+obj = addr.reflect();   // Returns the original object
+// Or use builtin
+obj = reflect(addr);    // Same result
+
+printl(obj);            // "Hello"
+```
+
+---
+
+## Variables & Scope
+
+### Basic Variable Declaration
+
+```cssl
+// Typed variables (recommended)
+int count = 0;
+string name = "CSSL";
+float pi = 3.14159;
+bool active = true;
+
+// Dynamic variables (flexible but slower)
+dynamic value = "text";
+value = 42;  // Can change type
+```
+
+### Scope Behavior
+
+Variables are **local by default**. Each function/class has its own scope.
+
+```cssl
+define myFunction() {
+    string name = "Alice";  // Local to myFunction
+    printl(name);           // Works
+}
+
+myFunction();
+// printl(name);  // Error! 'name' doesn't exist here
+```
+
+### Global Variables
+
+```cssl
+// Method 1: global keyword
+global counter = 0;
+
+define increment() {
+    global(counter);  // Access global
+    counter = counter + 1;
+}
+
+// Method 2: r@ prefix
+r@globalVar = 100;
+
+define readGlobal() {
+    printl(r@globalVar);  // Access global
+}
+
+// Method 3: global modifier on function
+global define myFunc() {
+    // This function is globally accessible
+}
 
-    ### I/O Functions
+// Method 4: global variable declaration
+global int sharedCounter = 0;
+```
 
-    ```cssl
-    // Output
-    printl("Text");              // Print with newline
-    print("No newline");         // Print without newline
-    debug("Debug info");         // Print with [DEBUG] prefix
-    error("Error message");      // Print with [ERROR] prefix
-    warn("Warning");             // Print with [WARN] prefix
-    log("INFO", "Message");      // Print with custom prefix
+### Variable References
+
+```cssl
+// Module reference (@)
+@Module = include("mymodule.cssl");
+@ModuleName.function();
+
+// Global reference (r@)
+r@globalVar = "shared";
+
+// Struct self-reference (s@)
+s@Backend.Loop.timer;   // Access global struct member
+
+// Shared object reference ($)
+$SharedData = {"key": "value"};
+$SharedData.key;  // Access shared
+
+// Captured reference (% for snapshots)
+snapshot(myVar);
+printl(%myVar);  // Access snapshotted value
+```
+
+---
+
+## Operators
+
+### Arithmetic Operators
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `+` | Addition | `5 + 3` → `8` |
+| `-` | Subtraction | `5 - 3` → `2` |
+| `*` | Multiplication | `5 * 3` → `15` |
+| `/` | Division | `6 / 2` → `3` |
+| `%` | Modulo | `7 % 3` → `1` |
+
+### Comparison Operators
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `==` | Equal to | `5 == 5` → `true` |
+| `!=` | Not equal to | `5 != 3` → `true` |
+| `<` | Less than | `3 < 5` → `true` |
+| `>` | Greater than | `5 > 3` → `true` |
+| `<=` | Less or equal | `3 <= 3` → `true` |
+| `>=` | Greater or equal | `5 >= 3` → `true` |
+
+### Logical Operators
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `&&` / `and` | Logical AND | `true && false` → `false` |
+| `\|\|` / `or` | Logical OR | `true \|\| false` → `true` |
+| `!` / `not` | Logical NOT | `!true` → `false` |
+
+### Special Operators
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `in` | Containment | `"a" in "abc"` → `true` |
+| `::` | Namespace access | `json::parse(s)` |
+| `.` | Member access | `obj.method()` |
+| `->` | C++ style access | `this->member` |
+| `\|` | Pipe operator | `data \| filter \| process` |
+| `<<` | Stream output | `cout << "text"` |
+| `>>` | Stream input | `cin >> variable` |
+| `~` | Destructor | `~object` |
+| `&` | Reference | `&variable` |
+| `++` | Append | `constr++ { }` |
+
+### Injection Operators
+
+| Operator | Name | Description |
+|----------|------|-------------|
+| `<==` | Inject Left | Replace target with source |
+| `==>` | Inject Right | Right-side injection |
+| `+<==` | Brute+ Left | Keep old + add new |
+| `==>+` | Brute+ Right | Keep old + add new (right) |
+| `-<==` | Brute- Left | Move and remove old |
+| `===>-` | Brute- Right | Move and remove (right) |
+| `<<==` | Infuse Left | Code infusion |
+| `==>>` | Infuse Right | Code infusion (right) |
+| `+<<==` | Infuse+ Left | Code copy & add |
+| `==>>+` | Infuse+ Right | Code copy & add (right) |
+
+### Flow Operators
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `->` | Flow right | `data -> process` |
+| `<-` | Flow left | `result <- compute` |
+
+---
+
+## Control Flow
+
+### If/Else
+
+```cssl
+if (condition) {
+    // code
+} elif (other_condition) {
+    // code
+} else {
+    // code
+}
+
+// Without parentheses
+if condition {
+    // code
+}
+```
+
+### While Loop
+
+```cssl
+int i = 0;
+while (i < 10) {
+    printl(i);
+    i = i + 1;
+}
+```
+
+### For Loop
+
+```cssl
+// C-style for loop
+for (int i = 0; i < 10; i = i + 1) {
+    printl(i);
+}
+
+// Foreach with range
+foreach (i in range(10)) {
+    printl(i);
+}
+
+// Foreach with collection
+list items = [1, 2, 3];
+foreach (item in items) {
+    printl(item);
+}
+
+// For-in loop
+for item in items {
+    printl(item);
+}
+```
+
+### Switch/Case
+
+```cssl
+switch (value) {
+    case 1:
+        printl("One");
+        break;
+    case 2:
+    case 3:
+        printl("Two or Three");
+        break;
+    default:
+        printl("Other");
+}
+```
+
+### Break/Continue
+
+```cssl
+foreach (i in range(10)) {
+    if (i == 5) {
+        break;     // Exit loop
+    }
+    if (i % 2 == 0) {
+        continue;  // Skip to next iteration
+    }
+    printl(i);
+}
+```
+
+---
+
+## Functions
+
+### Basic Functions
+
+```cssl
+// Simple function
+define greet() {
+    printl("Hello!");
+}
+
+// Typed function with return
+int add(int a, int b) {
+    return a + b;
+}
+
+// Dynamic parameters
+void process(dynamic data) {
+    printl(typeof(data) + ": " + str(data));
+}
+
+// C++ style void function
+void myFunction() {
+    printl("C++ style");
+}
+```
+
+### Function Modifiers
+
+```cssl
+// const - Immutable function (no side effects)
+const define pureFunc() {
+    return 42;
+}
+
+// private - No external injections
+private define secureFunc() {
+    // Protected from injection
+}
+
+// static - No instance overhead
+static define staticFunc() {
+    // Optimized static function
+}
+
+// global - Globally accessible
+global define globalFunc() {
+    // Accessible from anywhere
+}
+
+// embedded - Immediate &target replacement (v4.2.5)
+embedded define override &println {
+    print("[LOG] ");
+    %println(args);  // Call original
+}
 
-    // Input
-    string name = input("Enter your name: ");
-    int age = int(input("Enter your age: "));
-    string raw = input();        // Without prompt
-    ```
+// native - Force C++ execution (v4.6.0)
+native define fastFunc() {
+    // Runs in C++ interpreter
+}
 
-    ---
+// unative - Force Python execution (v4.6.5)
+unative define pythonFunc() {
+    // Runs in Python interpreter
+}
 
-    ## Data Types
+// meta - Source function (must return)
+meta define mustReturn() {
+    return true;
+}
 
-    ### Primitive Types
+// closed - Protect from external injection
+closed define protectedFunc() {
+    // Cannot be injected from outside
+}
 
-    | Type | Description | Example |
-    |------|-------------|---------|
-    | `int` | Integer | `int x = 42;` |
-    | `float` | Floating point | `float f = 3.14;` |
-    | `string` | Text string | `string s = "Hello";` |
-    | `bool` | Boolean | `bool b = true;` |
-    | `dynamic` | Any type (flexible) | `dynamic x = "text";` |
-    | `void` | No return value | `void func() { }` |
-    | `null` | Absence of value | `dynamic x = null;` |
+// open - Accept any parameter type
+open define flexibleFunc(open param) {
+    printl(typeof(param));
+}
+```
 
-    ### Generic Container Types
+### Function Appending
 
-    | Type | Description | Example |
-    |------|-------------|---------|
-    | `stack<T>` | LIFO stack | `stack<string> names;` |
-    | `vector<T>` | Dynamic array | `vector<int> nums;` |
-    | `array<T>` | Standard array | `array<float> values;` |
-    | `map<K,V>` | Ordered key-value | `map<string, int> ages;` |
-    | `list` | Python-like list | `list items = [1, 2, 3];` |
-    | `dict` | Dictionary | `dict data = {"a": 1};` |
-    | `datastruct<T>` | Universal container | `datastruct<string> data;` |
-    | `iterator<T>` | Programmable iterator | `iterator<int> it;` |
-    | `shuffled<T>` | Multi-value returns | `shuffled<string> results;` |
-    | `combo<T>` | Filter/search space | `combo<string> search;` |
+```cssl
+// Original function
+define myFunc() {
+    printl("Original");
+}
 
-    ### Type Conversion
+// Append to existing function (keeps old + adds new)
+myFunc++ {
+    printl("Added behavior");
+}
 
-    ```cssl
-    int("42");        // String to int: 42
-    float("3.14");    // String to float: 3.14
-    str(42);          // Int to string: "42"
-    bool(1);          // Int to bool: true
-    int("ff", 16);    // Hex to int: 255
-    ```
+// Calling myFunc now outputs:
+// "Original"
+// "Added behavior"
+```
 
-    ### Type Checking
+### Parameter Switch (v4.2.5)
 
-    ```cssl
-    typeof(42);           // "int"
-    typeof("hello");      // "str"
-    isinstance(42, "int"); // true
-    isint(42);            // true
-    isstr("hello");       // true
-    isnull(null);         // true
-    ```
+```cssl
+define processData(...params)
+except {
+    // Handle invalid parameters
+    printl("Invalid parameters!");
+}
+always {
+    // Always execute (like finally)
+    printl("Cleanup");
+}
+```
 
-    ---
+---
 
-    ## Variables & Globals
+## Classes & OOP
 
-    ### Scope Behavior
+### Basic Class
 
-    Variables are **local by default**. Each function/class has its own scope - variables defined inside a function only exist within that function.
+```cssl
+class Person {
+    string name = "";
+    int age = 0;
 
-    ```cssl
-    define myFunction() {
-        string name = "Alice";  // Local to myFunction
-        printl(name);           // Works
+    // Constructor
+    constr(string n, int a) {
+        this->name = n;
+        this->age = a;
     }
 
-    myFunction();
-    // printl(name);  // Error! 'name' doesn't exist here
-
-    // Same variable name in different scopes = different variables
-    string name = "Bob";
-
-    define otherFunction() {
-        string name = "Charlie";  // Different variable, local to otherFunction
-        printl(name);             // "Charlie"
+    // Method
+    void introduce() {
+        printl("I'm " + this->name + ", " + this->age + " years old");
     }
+}
 
-    otherFunction();
-    printl(name);  // "Bob" - outer scope unchanged
-    ```
-
-    ### Everything is Local by Default
-
-    All elements (variables, functions, classes) are **local by default** and must be explicitly marked global.
-
-    | Element | Local (default) | Global |
-    |---------|-----------------|--------|
-    | **Variables** | `string x = "text";` | `global x = "text";` or `@x = "text";` |
-    | **Functions** | `define myFunc() { }` | `global define myFunc() { }` or `define @myFunc() { }` |
-    | **Typed functions** | `void myFunc() { }` | `global void myFunc() { }` or `void @myFunc() { }` |
-    | **Classes** | `class MyClass { }` | `global class MyClass { }` or `class @MyClass { }` |
-
-    ### Local Variables
-
-    ```cssl
-    string name = "Alice";
-    int count = 10;
-    float price = 19.99;
-    bool active = true;
-    ```
-
-    ### Global Variables
-
-    Use `global` keyword or `@`/`r@` prefix to create/access global variables:
-
-    ```cssl
-    // Declaration with 'global' keyword
-    global myGlobal = "visible everywhere";
-
-    // Access with '@' prefix
-    printl(@myGlobal);
-
-    // Direct global assignment with @ or r@
-    @anotherGlobal = "also global";
-    r@yetAnother = "and this too";
+// Create instance
+@p = new Person("Alice", 25);
+p.introduce();
+```
 
-    // Always read globals with @
-    printl(@x);
-    ```
+### Inheritance
 
-    ### Global Functions
+```cssl
+class Animal {
+    string name = "";
 
-    ```cssl
-    // Global function with 'global' keyword
-    global define helper() {
-        printl("I'm global!");
+    constr(string n) {
+        this->name = n;
     }
 
-    // Alternative: @ prefix syntax
-    define @anotherHelper() {
-        printl("Also global!");
+    void speak() {
+        printl("...");
     }
+}
 
-    // Global typed function
-    global void @utilityFunc(string msg) {
-        printl(msg);
+// C++ style inheritance (with 'extends')
+class Dog extends Animal {
+    constr(string n) {
+        super(n);  // Call parent constructor
     }
-    ```
 
-    ### Global Classes
-
-    ```cssl
-    // Global class with 'global' keyword
-    global class SharedClass {
-        string value;
+    void speak() {
+        printl(this->name + " says: Woof!");
     }
 
-    // Alternative: @ prefix syntax
-    class @AnotherShared {
-        int count;
+    void fetch() {
+        printl(this->name + " fetches the ball!");
     }
+}
 
-    // Instantiate global class with @ prefix
-    instance = new @SharedClass();
-    ```
+@dog = new Dog("Buddy");
+dog.speak();   // "Buddy says: Woof!"
+dog.fetch();   // "Buddy fetches the ball!"
+```
 
-    ### Prefix Reference
+### Super Proxy (v4.8.8)
 
-    | Prefix | Name | Usage |
-    |--------|------|-------|
-    | `@` | Global/Module | Read global vars, access modules: `@myVar`, `@os.getcwd()` |
-    | `r@` | Global Ref | Assign to global scope: `r@name = value` |
-    | `$` | Shared | Access Python objects: `$counter.value` |
-    | `%` | Captured | Capture value at registration: `%version` |
-    | `s@` | Self-Ref | Access global structs: `s@Backend.config` |
+```cssl
+class Parent {
+    void greet() {
+        printl("Hello from Parent");
+    }
+}
 
-    ### Shared Objects ($)
+class Child extends Parent {
+    void greet() {
+        super->greet();  // Call parent method
+        printl("Hello from Child");
+    }
+}
 
-    Access Python objects shared via `CSSL.share()`:
+@c = new Child();
+c.greet();
+// Output:
+// "Hello from Parent"
+// "Hello from Child"
+```
 
-    ```cssl
-    // Access shared Python object
-    $counter.value = 100;
-    $counter.increment();
+### Destructor (v4.8.8)
 
-    // Delete shared object
-    delete("counter");
-    ```
+```cssl
+class Resource {
+    constr() {
+        printl("Resource acquired");
+    }
 
-    ### Captured References (%)
+    // Destructor
+    ~constr() {
+        printl("Resource released");
+    }
+}
 
-    Capture value at registration time:
+@r = new Resource();  // "Resource acquired"
+~r;                    // "Resource released"
+// Or: instance::delete(r);
+```
 
-    ```cssl
-    string version = "1.0";
-    savedVersion <<== { %version; }
-    version = "2.0";
-    printl(savedVersion);  // Still "1.0"
-    ```
+### Constructor Modifiers (v4.8.8)
 
-    ### Class Member Access (this->)
+```cssl
+class SafeResource {
+    // secure - Constructor runs only on exception
+    secure constr() {
+        printl("Handling error...");
+    }
+}
 
-    Inside classes, use `this->` to access instance members:
+class ManualInit {
+    // callable - Constructor must be manually called
+    callable constr() {
+        printl("Initialized!");
+    }
+}
 
-    ```cssl
-    class Person {
-        string name;
+@m = new ManualInit();           // NOT initialized
+instance::call_constructor(m);   // "Initialized!"
+```
 
-        void setName(string n) {
-            this->name = n;  // Instance member
-        }
-    }
-    ```
-
-    ---
-
-    ## Operators
-
-    ### Arithmetic
-
-    | Operator | Description | Example |
-    |----------|-------------|---------|
-    | `+` | Addition / Concatenation | `a + b` |
-    | `-` | Subtraction | `a - b` |
-    | `*` | Multiplication | `a * b` |
-    | `/` | Division | `a / b` |
-    | `%` | Modulo | `a % b` |
-
-    ### Comparison
-
-    | Operator | Description | Example |
-    |----------|-------------|---------|
-    | `==` | Equal | `a == b` |
-    | `!=` | Not equal | `a != b` |
-    | `<` | Less than | `a < b` |
-    | `>` | Greater than | `a > b` |
-    | `<=` | Less or equal | `a <= b` |
-    | `>=` | Greater or equal | `a >= b` |
-
-    ### Logical
-
-    | Operator | Description | Example |
-    |----------|-------------|---------|
-    | `&&` | AND | `a && b` |
-    | `\|\|` | OR | `a \|\| b` |
-    | `!` | NOT | `!a` |
-    | `and` | AND (keyword) | `a and b` |
-    | `or` | OR (keyword) | `a or b` |
-    | `not` | NOT (keyword) | `not a` |
-
-    ### Increment/Decrement (in for-loops)
-
-    | Operator | Description | Example |
-    |----------|-------------|---------|
-    | `++` | Increment | `i++` |
-    | `--` | Decrement | `i--` |
-    | `+=` | Add assign | `i += 1` |
-    | `-=` | Subtract assign | `i -= 1` |
-
-    ---
-
-    ## Control Flow
-
-    ### If / Else If / Else
-
-    ```cssl
-    if (x < 5) {
-        printl("Small");
-    } else if (x < 15) {
-        printl("Medium");
-    } else {
-        printl("Large");
-    }
+### Global/Embedded Classes
 
-    // elif also works
-    if (x < 5) {
-        printl("Small");
-    } elif (x < 15) {
-        printl("Medium");
-    }
-    ```
-
-    ### Switch / Case
-
-    ```cssl
-    switch (day) {
-        case 1:
-            printl("Monday");
-            break;
-        case 2:
-            printl("Tuesday");
-            break;
-        default:
-            printl("Other");
-    }
-    ```
-
-    ### Parameter Switch (Open Params)
-
-    Pattern matching on which named parameters were provided to a function.
-
-    ```cssl
-    define greet(...) {
-        switch (open) {
-            case name & age:
-                printl("Hello " + OpenFind<string, "name"> + ", age " + OpenFind<int, "age">);
-            case name:
-                printl("Hello " + OpenFind<string, "name">);
-            except name:
-                printl("No name provided!");
-            default:
-                printl("Unknown parameters");
-            always:
-                printl("-- greeting complete --");
-            finally:
-                printl("== cleanup ==");
-        }
+```cssl
+// Global class - accessible everywhere
+global class GlobalHelper {
+    static void help() {
+        printl("Help!");
     }
+}
 
-    greet(name="Alice");              // case name matches
-    greet(name="Bob", age=25);        // case name & age matches
-    greet(foo="bar");                 // except name matches (no name)
-    ```
+// Embedded class - auto-replaces target
+embedded class @TargetClass {
+    // Replaces TargetClass
+}
+```
 
-    **Syntax:**
-    - `case param:` - executes if parameter exists
-    - `case param1 & param2:` - executes if ALL parameters exist
-    - `case param1 & not param2:` - AND with negation
-    - `except param:` - executes if parameter does NOT exist
-    - `default:` - executes if no case matched
-    - `always:` - executes after any matching case (not after except/default)
-    - `finally:` - always executes (cleanup, like try/finally)
+---
 
-    > **Note:** Cases are checked in order. Place more specific cases first (`case name & age` before `case name`).
+## Namespaces
 
-    ### While Loop
+### Basic Namespace
 
-    ```cssl
-    int i = 0;
-    while (i < 5) {
-        printl(i);
-        i = i + 1;
+```cssl
+namespace utils {
+    void log(string msg) {
+        printl("[LOG] " + msg);
     }
-    ```
 
-    ### For Loop (Python-Style)
-
-    ```cssl
-    // Range-based
-    for (i in range(5)) {
-        printl(i);  // 0, 1, 2, 3, 4
+    int add(int a, int b) {
+        return a + b;
     }
 
-    // With start and end
-    for (i in range(10, 15)) {
-        printl(i);  // 10, 11, 12, 13, 14
+    class Helper {
+        void assist() {
+            printl("Helping!");
+        }
     }
+}
 
-    // With step
-    for (i in range(0, 10, 2)) {
-        printl(i);  // 0, 2, 4, 6, 8
-    }
-    ```
+// Usage
+utils::log("Hello");           // "[LOG] Hello"
+int sum = utils::add(1, 2);    // 3
+@h = new utils::Helper();
+h.assist();                    // "Helping!"
+```
 
-    ### For Loop (C-Style)
+### Nested Namespaces
 
-    ```cssl
-    for (int i = 0; i < 10; i++) {
-        printl(i);
+```cssl
+namespace app {
+    namespace core {
+        namespace utils {
+            void helper() {
+                printl("Deep helper");
+            }
+        }
     }
+}
 
-    for (int i = 10; i > 0; i--) {
-        printl(i);
-    }
-    ```
+app::core::utils::helper();  // "Deep helper"
+```
 
-    ### Foreach
+---
 
-    ```cssl
-    stack<string> names;
-    names.push("Alice");
-    names.push("Bob");
+## Enums & Structs
 
-    // Syntax 1
-    foreach (name in names) {
-        printl(name);
-    }
+### Enums
 
-    // Syntax 2
-    foreach names as name {
-        printl(name);
-    }
-    ```
+```cssl
+enum Color {
+    RED = 0,
+    GREEN = 1,
+    BLUE = 2
+}
 
-    ### Break & Continue
+enum Status {
+    PENDING,    // 0
+    ACTIVE,     // 1
+    COMPLETED   // 2
+}
 
-    ```cssl
-    for (i in range(10)) {
-        if (i == 5) break;     // Exit loop
-        if (i == 3) continue;  // Skip iteration
-        printl(i);
-    }
-    ```
+int c = Color.RED;        // 0
+int s = Status.ACTIVE;    // 1
 
-    ---
+// Embedded enum (replaces target)
+embedded enum @TargetEnum {
+    NEW_VALUE = 100
+}
+```
 
-    ## Functions
+### Structs
 
-    ### Basic Syntax
+```cssl
+struct Point {
+    x: 0,
+    y: 0,
+    name: "origin"
+}
 
-    ```cssl
-    // Without return
-    void sayHello() {
-        printl("Hello!");
-    }
+struct Config {
+    host: "localhost",
+    port: 8080,
+    ssl: false
+}
 
-    // With return
-    string getName() {
-        return "CSSL";
-    }
+// Access struct
+printl(Point.x);       // 0
+printl(Config.host);   // "localhost"
 
-    // With parameters
-    int add(int a, int b) {
-        return a + b;
-    }
-    ```
+// Global struct reference
+s@Config.port = 9000;  // Modify global struct
+```
 
-    ### Define Functions
+---
 
-    ```cssl
-    // Simple function without type
-    define greet() {
-        printl("Hello!");
-    }
+## Container Types
 
-    // With parameters
-    define greet(string name) {
-        printl("Hello " + name);
-    }
-    ```
-
-    ### Function Modifiers
-
-    | Modifier | Description |
-    |----------|-------------|
-    | `undefined` | Silently ignore errors |
-    | `closed` | Block external CodeInfusion |
-    | `private` | Block all CodeInfusion |
-    | `virtual` | Import-cycle safe |
-    | `meta` | Source function (any return type allowed) |
-    | `super` | Force execution (no exceptions) |
-    | `open` | Accept any parameters |
-    | `shuffled` | Return multiple values |
-    | `const` | Immutable function (like C++) |
-    | `static` | Static method/function |
-    | `public` | Explicitly public (default) |
-    | `global` | Makes function globally accessible |
-
-    **Flexible Modifier Order**: Modifiers can appear in any order before the function declaration.
-
-    ```cssl
-    // Ignore errors
-    undefined void mayFail() {
-        riskyOperation();
-    }
+### Stack
 
-    // Protected from injection
-    closed void protected() {
-        printl("Protected");
-    }
+```cssl
+stack<string> names;
+names.push("Alice");
+names.push("Bob");
+
+string top = names.pop();    // "Bob"
+string peek = names.peek();  // "Alice"
+int size = names.size();     // 1
+bool empty = names.empty();  // false
+```
+
+### Vector
+
+```cssl
+vector<int> nums;
+nums.push_back(1);
+nums.push_back(2);
+nums.push_back(3);
+
+int first = nums[0];           // 1
+int size = nums.size();        // 3
+nums.insert(1, 10);            // [1, 10, 2, 3]
+nums.erase(2);                 // [1, 10, 3]
+nums.clear();                  // []
+```
+
+### Array
+
+```cssl
+array<float> values;
+values.push(1.0);
+values.push(2.0);
+
+float v = values.get(0);  // 1.0
+values.set(0, 5.0);       // [5.0, 2.0]
+```
+
+### Map
+
+```cssl
+map<string, int> ages;
+ages.set("Alice", 25);
+ages.set("Bob", 30);
+
+int age = ages.get("Alice");     // 25
+bool has = ages.has("Charlie");  // false
+list keys = ages.keys();         // ["Alice", "Bob"]
+list vals = ages.values();       // [25, 30]
+```
+
+### Queue (v4.7)
+
+```cssl
+queue<int> tasks;
+tasks.enqueue(1);
+tasks.enqueue(2);
+tasks.enqueue(3);
+
+int first = tasks.dequeue();  // 1
+int peek = tasks.peek();      // 2
+int size = tasks.size();      // 2
+bool empty = tasks.empty();   // false
+tasks.clear();                // []
+```
+
+### DataStruct (Universal Container)
+
+```cssl
+datastruct<dynamic> data;
+data.add("text");
+data.add(42);
+data.add(true);
+
+// Access by index
+printl(data[0]);  // "text"
+
+// As lazy declarator
+datastruct<string> lazy;
+lazy.declare("key", "value");
+printl(lazy.get("key"));  // "value"
+```
+
+### Iterator
+
+```cssl
+iterator<int> it = range(5);
+
+while (it.has_next()) {
+    printl(it.next());
+}
+
+// With task
+iterator<int> taskIt;
+taskIt.add_task(lambda x: x * 2);
+taskIt.set_data([1, 2, 3]);
+// Results: [2, 4, 6]
+```
+
+### List & Dict
+
+```cssl
+// Python-style list
+list items = [1, 2, 3, 4, 5];
+items.append(6);
+items.remove(3);
+int first = items[0];
+
+// Python-style dict
+dict config = {
+    "host": "localhost",
+    "port": 8080
+};
+config["ssl"] = true;
+printl(config["host"]);
+```
+
+---
+
+## Built-in Functions
+
+### Output Functions
+
+```cssl
+print("no newline");
+printl("with newline");
+println("alias for printl");
+debug("debug message");    // [DEBUG] prefix
+error("error message");    // [ERROR] prefix
+warn("warning");           // [WARN] prefix
+log("CUSTOM", "message");  // [CUSTOM] prefix
+```
+
+### String Functions
+
+```cssl
+len("hello");                    // 5
+upper("hello");                  // "HELLO"
+lower("HELLO");                  // "hello"
+trim("  text  ");                // "text"
+split("a,b,c", ",");             // ["a", "b", "c"]
+join(["a", "b"], "-");           // "a-b"
+replace("hello", "l", "x");      // "hexxo"
+substr("hello", 1, 3);           // "ell"
+contains("hello", "ell");        // true
+startswith("hello", "he");       // true
+endswith("hello", "lo");         // true
+indexof("hello", "l");           // 2
+format("Hello {}!", "World");    // "Hello World!"
+repeat("ab", 3);                 // "ababab"
+reverse("hello");                // "olleh"
+capitalize("hello");             // "Hello"
+title("hello world");            // "Hello World"
+padleft("42", 5, "0");           // "00042"
+padright("42", 5, "0");          // "42000"
+ord("A");                        // 65
+chr(65);                         // "A"
+isalpha("abc");                  // true
+isdigit("123");                  // true
+```
+
+### List Functions
+
+```cssl
+push(list, item);           // Add to end
+pop(list);                  // Remove from end
+shift(list);                // Remove from start
+unshift(list, item);        // Add to start
+slice(list, 1, 3);          // Sublist
+sort(list);                 // Sort ascending
+rsort(list);                // Sort descending
+unique(list);               // Remove duplicates
+flatten([[1], [2, 3]]);     // [1, 2, 3]
+filter(list, func);         // Filter elements
+map(list, func);            // Transform elements
+reduce(list, func, init);   // Reduce to single value
+find(list, value);          // Find first match
+findindex(list, value);     // Find index
+every(list, func);          // All match?
+some(list, func);           // Any match?
+range(5);                   // [0, 1, 2, 3, 4]
+range(1, 5);                // [1, 2, 3, 4]
+range(0, 10, 2);            // [0, 2, 4, 6, 8]
+enumerate(list);            // [[0, a], [1, b], ...]
+zip(list1, list2);          // Pair elements
+reversed(list);             // Reverse copy
+sorted(list);               // Sorted copy
+count(list, value);         // Count occurrences
+first(list);                // First element
+last(list);                 // Last element
+take(list, n);              // First n elements
+drop(list, n);              // All except first n
+chunk(list, size);          // Split into chunks
+shuffle(list);              // Randomize order
+sample(list, n);            // Random n elements
+```
+
+### Dictionary Functions
+
+```cssl
+keys(dict);                     // Get keys
+values(dict);                   // Get values
+items(dict);                    // Get key-value pairs
+haskey(dict, "key");            // Check key exists
+getkey(dict, "key", default);   // Get with default
+setkey(dict, "key", value);     // Set key
+delkey(dict, "key");            // Delete key
+merge(dict1, dict2);            // Merge dictionaries
+update(dict1, dict2);           // Update in place
+fromkeys(["a", "b"], 0);        // {"a": 0, "b": 0}
+invert(dict);                   // Swap keys/values
+pick(dict, ["key1", "key2"]);   // Select keys
+omit(dict, ["key1"]);           // Exclude keys
+```
+
+### Math Functions
+
+```cssl
+abs(-5);                // 5
+min(1, 2, 3);           // 1
+max(1, 2, 3);           // 3
+sum([1, 2, 3]);         // 6
+avg([1, 2, 3]);         // 2.0
+round(3.7);             // 4
+floor(3.7);             // 3
+ceil(3.2);              // 4
+pow(2, 3);              // 8
+sqrt(16);               // 4.0
+mod(7, 3);              // 1
+random();               // 0.0-1.0
+randint(1, 10);         // 1-10
+sin(0);                 // 0.0
+cos(0);                 // 1.0
+tan(0);                 // 0.0
+asin(0);                // 0.0
+acos(1);                // 0.0
+atan(0);                // 0.0
+atan2(1, 1);            // 0.785...
+exp(1);                 // 2.718...
+log(10);                // 2.302...
+log10(100);             // 2.0
+radians(180);           // 3.14159...
+degrees(3.14159);       // ~180
+
+// Constants
+pi;                     // 3.14159...
+e;                      // 2.71828...
+```
+
+### Time/Date Functions
+
+```cssl
+now();                  // Current timestamp
+timestamp();            // Unix timestamp
+sleep(1000);            // Sleep 1 second (ms)
+delay(500);             // Delay 500ms
+date();                 // Current date string
+time();                 // Current time string
+datetime();             // Full datetime
+strftime("%Y-%m-%d");   // Format time
+CurrentTime;            // Alternative current time
+```
+
+### File Functions
+
+```cssl
+pathexists("file.txt");         // Check exists
+exists("file.txt");             // Alias
+isfile("file.txt");             // Is file?
+isdir("folder");                // Is directory?
+basename("/path/file.txt");     // "file.txt"
+dirname("/path/file.txt");      // "/path"
+joinpath("dir", "file.txt");    // "dir/file.txt"
+abspath("relative");            // Full path
+normpath("a//b/../c");          // "a/c"
+
+readfile("file.txt");           // Read entire file
+writefile("file.txt", "data");  // Write file
+appendfile("file.txt", "more"); // Append to file
+readlines("file.txt");          // Read as lines
+
+listdir("folder");              // List directory
+makedirs("a/b/c");              // Create nested dirs
+removefile("file.txt");         // Delete file
+removedir("folder");            // Delete empty dir
+copyfile("src", "dst");         // Copy file
+movefile("src", "dst");         // Move file
+rename("old", "new");           // Rename
+filesize("file.txt");           // Get size in bytes
+```
+
+### JSON Functions
+
+```cssl
+tojson({"a": 1});               // '{"a": 1}'
+fromjson('{"a": 1}');           // {"a": 1}
+json::read("file.json");        // Read JSON file
+json::write("file.json", data); // Write JSON file
+json::parse(str);               // Parse JSON string
+json::stringify(obj);           // Stringify object
+json::pretty(obj);              // Pretty print
+json::keys(obj);                // Get keys
+json::values(obj);              // Get values
+json::get(obj, "key");          // Get nested value
+json::set(obj, "key", value);   // Set nested value
+json::has(obj, "key");          // Check key exists
+json::merge(obj1, obj2);        // Merge objects
+```
+
+### Hash Functions
+
+```cssl
+md5("text");            // MD5 hash
+sha1("text");           // SHA-1 hash
+sha256("text");         // SHA-256 hash
+```
+
+### Regex Functions
+
+```cssl
+match("hello123", "\\d+");          // "123"
+search("hello123world", "\\d+");    // Match object
+findall("a1b2c3", "\\d");           // ["1", "2", "3"]
+sub("hello123", "\\d+", "XXX");     // "helloXXX"
+```
+
+### System Functions
+
+```cssl
+getcwd();               // Current working directory
+chdir("path");          // Change directory
+mkdir("folder");        // Create directory
+rmdir("folder");        // Remove directory
+clear();                // Clear screen
+cls();                  // Alias for clear
+env("HOME");            // Get env variable
+setenv("VAR", "value"); // Set env variable
+exit(0);                // Exit with code
+platform();             // "Windows", "Linux", etc.
+version();              // Python version
+argv();                 // Command line args
+argc();                 // Argument count
+isLinux();              // true if Linux
+isWindows();            // true if Windows
+isMac();                // true if macOS
+```
+
+### Color Functions (v4.6.5)
+
+```cssl
+// Named colors
+red("error text");
+green("success text");
+blue("info text");
+yellow("warning text");
+cyan("note text");
+magenta("special text");
+white("white text");
+black("black text");
+
+// Bright variants
+bright_red("bright error");
+bright_green("bright success");
+// ... and more
+
+// Background colors
+bg_red("red background");
+bg_blue("blue background");
+bg_rgb(255, 200, 0, "custom bg");
+
+// RGB color
+rgb(255, 128, 0, "orange text");
+
+// Styles
+bold("bold text");
+italic("italic text");
+underline("underlined");
+dim("dimmed text");
+blink("blinking");
+strikethrough("crossed out");
+reset();  // Reset all styles
+
+// In f-strings
+printl(f"{red('Error:')} {bold('Something failed')}");
+```
+
+### Instance Functions
+
+```cssl
+instance::getMethods(obj);      // Get all methods
+instance::getClasses(obj);      // Get all classes
+instance::getVars(obj);         // Get all variables
+instance::getAll(obj);          // Get all members
+instance::call(obj, "method");  // Call method
+instance::has(obj, "member");   // Check member exists
+instance::type(obj);            // Get type name
+instance::exists(obj);          // Check if valid
+instance::isavailable(obj);     // Alias
+instance::delete(obj);          // Call destructor (v4.8.8)
+instance::call_constructor(obj);// Manual init (v4.8.8)
+```
+
+### Watcher Functions (v4.6.5)
+
+```cssl
+watcher::get(name);      // Get live Python instance value
+watcher::set(name, val); // Set live Python instance value
+watcher::list();         // List all watched instances
+watcher::exists(name);   // Check if watcher exists
+watcher::refresh(name);  // Refresh watched instance
+```
+
+---
+
+## CodeInfusion
+
+CodeInfusion allows injecting code into existing functions.
+
+### Basic Code Infusion
+
+```cssl
+define original() {
+    printl("Original behavior");
+}
+
+// Replace with new code (<<==)
+original <<== {
+    printl("New behavior");
+}
+
+original();  // "New behavior"
+```
+
+### Add to Existing (Keep Original)
+
+```cssl
+define myFunc() {
+    printl("Original");
+}
 
-    // Multiple returns
-    shuffled string getNames() {
-        return "Alice", "Bob", "Charlie";
-    }
+// Add code before original (+<<==)
+myFunc +<<== {
+    printl("Before");
+}
 
-    a, b, c = getNames();
+myFunc();
+// Output:
+// "Before"
+// "Original"
+```
 
-    // Any order of modifiers works
-    private string *@Myfunc() {
-        println("Hello from global private non-null function!");
-        return "Hey";
-    }
+### Using Captured Values
 
-    // Const function
-    const void immutableFunc() {
-        printl("I'm constant");
-    }
+```cssl
+define logger(string msg) {
+    printl(msg);
+}
 
-    // Global private const
-    global private const void @MyGlobalFunc() {
-        printl("Complex modifiers in any order");
-    }
-    ```
+// Override with access to original via %
+logger <<== {
+    printl("[LOG] " + args[0]);
+    %logger(args[0]);  // Call original
+}
+```
 
-    ### Typed Functions (Enforced Returns)
+---
 
-    Functions with a return type (like `int`, `string`, `vector<T>`) MUST return that type:
+## BruteInjection
 
-    ```cssl
-    // MUST return string
-    string getName() {
-        return "Alice";        // OK
-        // return 42;          // Error! Expected string
-    }
+BruteInjection allows value/function injection with powerful filtering.
 
-    // MUST return int
-    int getAge() {
-        return 30;             // OK
-    }
+### Basic Injection
 
-    // meta modifier bypasses type checking
-    meta datastruct<string> getData() {
-        return "just a string";  // OK despite declared type
-        return 42;               // Also OK - meta allows any type
-    }
-    ```
+```cssl
+// Replace value
+target <== source;
 
-    ### Non-Null Functions (*)
+// Right injection
+source ==> target;
+```
 
-    Functions that must never return null:
+### Copy & Add
 
-    ```cssl
-    // Non-null function
-    define *alwaysReturns() {
-        return "Always a value";
-    }
+```cssl
+// Keep old + add new
+target +<== newValue;
+```
 
-    // Non-null assertion on value
-    this->name = *$System.os;  // Error if null
-    ```
+### Move & Remove
 
-    ### Type Exclusion Filter (*[type])
+```cssl
+// Move and remove original
+target -<== source;
+```
 
-    Functions that must NOT return a specific type:
+### Injection Filters
 
-    ```cssl
-    // Must NOT return string
-    shuffled *[string] getNumbers() {
-        return 1, 2, 3;  // OK
-        // return "text";  // Error!
-    }
+```cssl
+// Integer filter
+result [integer::gt=5] <== numbers;     // Greater than 5
+result [integer::lt=10] <== numbers;    // Less than 10
+result [integer::range=1,100] <== nums; // Range 1-100
 
-    // Must NOT return null
-    define *[null] getValue() {
-        return 42;  // OK
-    }
-    ```
+// String filter
+result [string::startswith="test"] <== strings;
+result [string::contains="key"] <== strings;
+result [string::where="abc"] <== strings;
 
-    ### Open Parameters
+// JSON filter
+result [json::has="key"] <== objects;
+result [json::where="key=value"] <== objects;
 
-    ```cssl
-    open define flexibleFunc(open Params) {
-        string name = OpenFind<string>(0);
-        int num = OpenFind<int>(0);
-        printl(name + " " + num);
-    }
+// Type filter
+result [type::filter=string] <== mixed;  // Only strings
 
-    flexibleFunc("Hello", 123, true);
-    ```
+// Custom filter
+register_filter("mytype", "myhelper", func);
+result [mytype::myhelper=value] <== data;
+```
 
-    ---
+---
 
-    ## Classes & OOP
+## Snapshot System
 
-    ### Class Definition
+The Snapshot system (v4.8.8) allows capturing and restoring variable states.
 
-    ```cssl
-    class Person {
-        string name;
-        int age;
+### Basic Snapshots
 
-        // Constructor
-        void Person(string n, int a) {
-            this->name = n;
-            this->age = a;
-        }
+```cssl
+string version = "1.0";
+snapshot(version);  // Capture current value
 
-        void greet() {
-            printl("Hello, I'm " + this->name);
-        }
+version = "2.0";    // Modify
 
-        string getName() {
-            return this->name;
-        }
-    }
-    ```
+printl(version);        // "2.0"
+printl(%version);       // "1.0" (snapshotted value)
+```
 
-    ### Creating Instances
+### Named Snapshots
 
-    ```cssl
-    Person p = new Person("Alice", 30);
-    p.greet();
-    printl(p.name);
-    ```
+```cssl
+int counter = 100;
+snapshot(counter, "backup");  // Custom name
 
-    ### Constructor with `constr` Keyword
+counter = 500;
 
-    ```cssl
-    class Vehicle {
-        string brand;
+printl(get_snapshot("backup"));  // 100
+```
 
-        constr Initialize(string b) {
-            this->brand = b;
-        }
+### Snapshot Functions
 
-        constr SetupDefaults() {
-            printl("Vehicle ready");
-        }
-    }
+```cssl
+// Capture
+snapshot(variable);              // Auto-name
+snapshot(variable, "name");      // Custom name
 
-    Vehicle v = new Vehicle("Toyota");
-    ```
+// Retrieve
+get_snapshot("name");            // Get value
+%name;                           // Shorthand access
 
-    ### Class Inheritance
+// Check
+has_snapshot("name");            // true/false
+list_snapshots();                // ["name1", "name2", ...]
 
-    ```cssl
-    class Animal {
-        string name;
+// Manage
+clear_snapshot("name");          // Delete one
+clear_snapshots();               // Delete all
+restore_snapshot("name");        // Restore to current
 
-        void Animal(string n) {
-            this->name = n;
-        }
+// Function snapshots
+snapshot(printl);                // Capture function
+embedded define override &printl {
+    %printl("Prefix: " + args[0]);  // Call original
+}
+```
 
-        void speak() {
-            printl("Sound");
-        }
-    }
+### Direct Snapshot Assignment (v4.8.9)
 
-    class Dog : extends Animal {
-        void Dog(string n) {
-            this->name = n;
-        }
+Assign values directly to snapshots using the `%name = value` syntax:
 
-        void speak() {
-            printl("Woof! I'm " + this->name);
-        }
-    }
+```cssl
+// Assign variable value to snapshot
+string greeting = "Hello";
+%savedGreeting = greeting;       // Snapshot now holds "Hello"
 
-    Dog d = new Dog("Buddy");
-    d.speak();  // "Woof! I'm Buddy"
-    ```
+// Assign literal directly
+%message = "World";              // Create snapshot with literal
 
-    ### super() and super::method()
+// Typed expression assignment
+%config = (int maxRetries = 3);  // Creates variable AND snapshot
+// Now 'maxRetries' = 3 and '%config' = 3
 
-    ```cssl
-    class Child : extends Parent {
-        constr ChildInit(string name) {
-            super(name);  // Call parent constructor
-        }
+// Call snapshotted function
+%savedGreeting = somefunc;
+%savedGreeting();                // Call the snapshotted function
+```
 
-        void speak() {
-            super::speak();  // Call parent method
-            printl("Child speaking");
-        }
-    }
-    ```
+---
 
-    ### Append Mode (++)
+## C++ I/O Streams
 
-    Extend constructors/functions while keeping original code:
+CSSL supports C++ style I/O streams (v4.8.4).
 
-    ```cssl
-    // Original function
-    define BaseFunc() {
-        printl("Base functionality");
-    }
+### Standard Streams
 
-    // Append to BaseFunc
-    define ExtendedFunc() &BaseFunc ++ {
-        printl("Extended functionality");
-    }
+```cssl
+// Output
+cout << "Hello";
+cout << " World" << endl;
 
-    ExtendedFunc();
-    // Output:
-    // Base functionality
-    // Extended functionality
-    ```
-
-    ```cssl
-    class MyClass {
-        constr MyClassConstructor() {
-            printl("MyClass constructor");
-            this->value = 10;
-        }
-    }
+// Error output
+cerr << "Error message" << endl;
 
-    class BetterClass :: extends MyClass {
-        constr BetterConstructor() &MyClass::MyClassConstructor ++ {
-            printl("BetterClass - added code");
-            this->extra = 20;
-        }
-    }
-    ```
+// Log output
+clog << "Log message" << endl;
 
-    ### Non-Null Class
+// Input
+string name;
+cout << "Enter name: ";
+cin >> name;
 
-    ```cssl
-    class *MyClass {
-        // All methods must return non-null
-        string getValue() {
-            return "Value";
-        }
-    }
-    ```
-
-    ---
-
-    ## Container Types
-
-    ### stack\<T\> - LIFO Stack
-
-    ```cssl
-    stack<string> names;
-    names.push("Alice");
-    names.push("Bob");
-
-    printl(names.pop());     // "Bob"
-    printl(names.peek());    // "Alice" (doesn't remove)
-    printl(names.size());    // 1
-    printl(names.isEmpty()); // false
-    ```
-
-    **Methods:**
-
-    | Method | Description |
-    |--------|-------------|
-    | `push(value)` | Add to top |
-    | `pop()` | Remove and return top |
-    | `peek()` | View top without removing |
-    | `size()` / `length()` | Element count |
-    | `isEmpty()` / `is_empty()` | Check if empty |
-    | `contains(value)` | Check if contains |
-    | `indexOf(value)` | Find index (-1 if not found) |
-    | `toArray()` | Convert to list |
-    | `swap()` | Swap top two elements |
-    | `dup()` | Duplicate top element |
-
-    ### vector\<T\> - Dynamic Array
-
-    ```cssl
-    vector<int> nums;
-    nums.push(10);
-    nums.push(20);
-
-    printl(nums.at(0));     // 10
-    printl(nums.front());   // 10
-    printl(nums.back());    // 20
-    ```
-
-    **Methods:**
-
-    | Method | Description |
-    |--------|-------------|
-    | `push(value)` / `push_back(value)` | Add to end |
-    | `push_front(value)` | Add to front |
-    | `pop_back()` | Remove from end |
-    | `pop_front()` | Remove from front |
-    | `at(index)` | Get element |
-    | `set(index, value)` | Set element |
-    | `front()` | Get first |
-    | `back()` | Get last |
-    | `size()` / `length()` | Element count |
-    | `empty()` / `isEmpty()` | Check if empty |
-    | `contains(value)` | Check if contains |
-    | `indexOf(value)` | Find first index |
-    | `lastIndexOf(value)` | Find last index |
-    | `slice(start, end)` | Get sub-vector |
-    | `join(separator)` | Join to string |
-    | `map(func)` | Apply function |
-    | `filter(predicate)` | Filter elements |
-    | `forEach(func)` | Execute for each |
-    | `every(predicate)` | Check all match |
-    | `some(predicate)` | Check any match |
-    | `reduce(func, initial)` | Reduce to value |
-    | `toArray()` | Convert to list |
-
-    ### map\<K,V\> - Ordered Key-Value
-
-    ```cssl
-    map<string, int> ages;
-    ages.insert("Alice", 30);
-    ages.insert("Bob", 25);
-
-    printl(ages.find("Alice"));   // 30
-    printl(ages.contains("Bob")); // true
-    ages.erase("Bob");
-    ```
-
-    **Methods:**
-
-    | Method | Description |
-    |--------|-------------|
-    | `insert(key, value)` | Insert/update pair |
-    | `find(key)` | Get value (null if not found) |
-    | `at(key)` | Get value (throws if not found) |
-    | `erase(key)` | Remove key |
-    | `contains(key)` | Check if key exists |
-    | `count(key)` | Count (0 or 1) |
-    | `size()` | Pair count |
-    | `empty()` | Check if empty |
-    | `begin()` | First key-value tuple |
-    | `end()` | Last key-value tuple |
-    | `lower_bound(key)` | First key >= given |
-    | `upper_bound(key)` | First key > given |
-
-    ### datastruct\<T\> - Universal Container
-
-    Primary target for BruteInjection operations.
-
-    ```cssl
-    datastruct<string> data;
-    data.add("item1");
-    data.add("item2");
-
-    printl(data.content());  // All elements
-    ```
-
-    **Methods:**
-
-    | Method | Description |
-    |--------|-------------|
-    | `content()` | Get all elements |
-    | `add(value)` | Add element |
-    | `remove_where(predicate)` | Remove matching |
-    | `find_where(predicate)` | Find first matching |
-    | `convert(type)` | Convert first element |
-
-    ### shuffled\<T\> - Multiple Returns
-
-    ```cssl
-    shuffled string getInfo() {
-        return "Alice", "Bob", "Charlie";
-    }
+// Getline
+string line = getline(cin);
+```
 
-    a, b, c = getInfo();
-    printl(a);  // "Alice"
-    ```
-
-    ---
-
-    ## Built-in Functions
-
-    ### String Operations
-
-    ```cssl
-    string s = "Hello World";
-
-    // Case
-    upper(s);              // "HELLO WORLD"
-    lower(s);              // "hello world"
-    capitalize(s);         // "Hello world"
-    title(s);              // "Hello World"
-
-    // Trim
-    trim("  text  ");      // "text"
-    ltrim("  text");       // "text"
-    rtrim("text  ");       // "text"
-
-    // Search
-    contains(s, "World");  // true
-    startswith(s, "Hello"); // true
-    endswith(s, "World");  // true
-    indexof(s, "o");       // 4
-    lastindexof(s, "o");   // 7
-
-    // Manipulation
-    replace(s, "World", "CSSL");  // "Hello CSSL"
-    substr(s, 0, 5);              // "Hello"
-    split(s, " ");                // ["Hello", "World"]
-    join("-", ["a", "b"]);        // "a-b"
-    repeat("ab", 3);              // "ababab"
-    reverse(s);                   // "dlroW olleH"
-
-    // Padding
-    padleft("42", 5, "0");   // "00042"
-    padright("42", 5, ".");  // "42..."
-    center("hi", 6, "-");    // "--hi--"
-    zfill("42", 5);          // "00042"
-
-    // Character
-    len(s);                  // 11
-    chars("abc");            // ["a", "b", "c"]
-    ord("A");                // 65
-    chr(65);                 // "A"
-
-    // Checks
-    isalpha("abc");          // true
-    isdigit("123");          // true
-    isalnum("abc123");       // true
-    isspace("  ");           // true
-    ```
-
-    ### Array/List Operations
-
-    ```cssl
-    stack<int> arr = [1, 2, 3, 4, 5];
-
-    // Add/Remove
-    push(arr, 6);            // Add to end
-    pop(arr);                // Remove last
-    shift(arr);              // Remove first
-    unshift(arr, 0);         // Add to front
-
-    // Access
-    first(arr);              // First element
-    last(arr);               // Last element
-    slice(arr, 1, 3);        // [2, 3]
-
-    // Transform
-    sort(arr);               // Sort ascending
-    rsort(arr);              // Sort descending
-    reversed(arr);           // Reverse copy
-    shuffle(arr);            // Random order
-    unique(arr);             // Remove duplicates
-    flatten([[1,2],[3,4]]);  // [1, 2, 3, 4]
-
-    // Search
-    find(arr, x => x > 3);   // First matching
-    findindex(arr, x => x > 3);
-    every(arr, x => x > 0);  // All match?
-    some(arr, x => x > 3);   // Any match?
-    count(arr, 2);           // Count of 2
-
-    // Functional
-    map(arr, x => x * 2);    // [2, 4, 6, 8, 10]
-    filter(arr, x => x > 2); // [3, 4, 5]
-    reduce(arr, (a,b) => a+b, 0); // 15
-
-    // Utilities
-    range(5);                // [0, 1, 2, 3, 4]
-    range(1, 5);             // [1, 2, 3, 4]
-    range(0, 10, 2);         // [0, 2, 4, 6, 8]
-    enumerate(arr);          // [(0,1), (1,2), ...]
-    zip([1,2], ["a","b"]);   // [(1,"a"), (2,"b")]
-    take(arr, 3);            // First 3 elements
-    drop(arr, 2);            // Skip first 2
-    chunk(arr, 2);           // [[1,2], [3,4], [5]]
-    sample(arr, 2);          // 2 random elements
-    ```
-
-    ### Dictionary Operations
-
-    ```cssl
-    dict d = {"name": "Alice", "age": 30};
-
-    keys(d);                 // ["name", "age"]
-    values(d);               // ["Alice", 30]
-    items(d);                // [("name","Alice"), ...]
-    haskey(d, "name");       // true
-    getkey(d, "name");       // "Alice"
-    getkey(d, "x", "default"); // "default"
-    setkey(d, "city", "NYC"); // Add key
-    delkey(d, "age");        // Remove key
-    merge(d1, d2);           // Merge dicts
-    update(d, {"new": 1});   // Update in place
-    fromkeys(["a","b"], 0);  // {"a": 0, "b": 0}
-    invert({"a": 1});        // {1: "a"}
-    pick(d, "name");         // {"name": "Alice"}
-    omit(d, "age");          // {"name": "Alice"}
-    ```
-
-    ### Math Functions
-
-    ```cssl
-    abs(-5);                 // 5
-    min(3, 1, 2);            // 1
-    max(3, 1, 2);            // 3
-    sum([1, 2, 3]);          // 6
-    avg([1, 2, 3, 4, 5]);    // 3.0
-
-    round(3.14159, 2);       // 3.14
-    floor(3.9);              // 3
-    ceil(3.1);               // 4
-
-    pow(2, 3);               // 8
-    sqrt(16);                // 4
-    mod(7, 3);               // 1
-
-    sin(0);                  // 0.0
-    cos(0);                  // 1.0
-    tan(0);                  // 0.0
-    asin(1);                 // 1.5708
-    acos(0);                 // 1.5708
-    atan(1);                 // 0.7854
-    atan2(1, 1);             // 0.7854
-
-    log(e());                // 1.0
-    log10(100);              // 2.0
-    exp(1);                  // 2.71828
-
-    pi();                    // 3.14159...
-    e();                     // 2.71828...
-    radians(180);            // 3.14159
-    degrees(3.14159);        // 180
-
-    random();                // 0.0 to 1.0
-    randint(1, 6);           // 1 to 6
-    ```
-
-    ### Date/Time Functions
-
-    ```cssl
-    now();                   // Unix timestamp (float)
-    timestamp();             // Unix timestamp (int)
-    date();                  // "2025-12-30"
-    date("%d/%m/%Y");        // "30/12/2025"
-    time();                  // "14:30:45"
-    datetime();              // "2025-12-30 14:30:45"
-    strftime("%Y-%m-%d", ts);
-
-    sleep(1.5);              // Wait 1.5 seconds
-    delay(500);              // Wait 500 milliseconds
-    ```
-
-    ### File I/O Functions
-
-    ```cssl
-    // Read
-    string content = read("file.txt");
-    string line5 = readline(5, "file.txt");
-    stack<string> lines = readlines("file.txt");
-
-    // Write
-    write("file.txt", "Hello");
-    writeline(3, "New line", "file.txt");
-    appendfile("file.txt", "\nMore");
-
-    // Path operations
-    basename("/path/to/file.txt");  // "file.txt"
-    dirname("/path/to/file.txt");   // "/path/to"
-    joinpath("/path", "file.txt");  // "/path/file.txt"
-    abspath("./file.txt");
-    normpath("/path/../other");
-
-    // Checks
-    pathexists("file.txt");  // true/false
-    isfile("file.txt");      // true/false
-    isdir("folder");         // true/false
-    filesize("file.txt");    // bytes
-
-    // Directory
-    listdir("./");           // ["file1", "file2"]
-    makedirs("new/folder");
-    removefile("file.txt");
-    removedir("folder");
-    copyfile("src", "dst");
-    movefile("old", "new");
-    ```
-
-    ### JSON Functions (json:: namespace)
-
-    ```cssl
-    // File operations
-    json data = json::read("config.json");
-    json::write("output.json", data);
-
-    // Parse/Stringify
-    json obj = json::parse('{"name": "Alice"}');
-    string str = json::stringify(obj);
-    string pretty = json::pretty(obj);
-
-    // Path operations
-    json::get(data, "user.name");
-    json::get(data, "user.age", 0);  // with default
-    json::set(data, "user.name", "Bob");
-    json::has(data, "user.email");
-
-    // Object operations
-    json::keys(obj);         // ["name"]
-    json::values(obj);       // ["Alice"]
-    json::merge(obj1, obj2); // Deep merge
-    ```
-
-    ### Instance Functions (instance:: namespace)
-
-    ```cssl
-    @module = include("lib.cssl-mod");
-
-    instance::getMethods(@module);   // Method names
-    instance::getClasses(@module);   // Class names
-    instance::getVars(@module);      // Variable names
-    instance::getAll(@module);       // Categorized dict
-
-    instance::call(@module, "methodName", arg1);
-    instance::has(@module, "attribute");
-    instance::type(@module);         // Type name
-
-    isavailable("sharedName");       // Check if exists
-    ```
-
-    ### Regex Functions
-
-    ```cssl
-    match("\\d+", "abc123");         // Match at start
-    search("\\d+", "abc123");        // Search anywhere
-    findall("\\d+", "a1b2c3");       // ["1", "2", "3"]
-    sub("\\d", "X", "a1b2");         // "aXbX"
-    sub("\\d", "X", "a1b2", 1);      // "aXb2" (count=1)
-    ```
-
-    ### Hash Functions
-
-    ```cssl
-    md5("hello");            // 32 hex chars
-    sha1("hello");           // 40 hex chars
-    sha256("hello");         // 64 hex chars
-    ```
-
-    ### System Functions
+### File Streams
 
-    ```cssl
-    exit(0);                 // Exit with code
-    input("Enter name: ");   // Read user input
+```cssl
+// Write to file
+@file = ofstream("output.txt");
+file << "Hello" << endl;
+file << "World" << endl;
+file.close();
 
-    env("PATH");             // Get env variable
-    setenv("MY_VAR", "val"); // Set env variable
-
-    copy(obj);               // Shallow copy
-    deepcopy(obj);           // Deep copy
-
-    clear();                 // Clear console
+// Read from file
+@input = ifstream("input.txt");
+string line;
+while (getline(input, line)) {
+    printl(line);
+}
+input.close();
 
-    pyimport("os");          // Import Python module
-    include("lib.cssl-mod"); // Import CSSL module
-    payload("helper.cssl-pl"); // Load payload
+// Read/write
+@rw = fstream("data.txt", "r+");
+```
 
-    isLinux();               // Platform checks
-    isWindows();
-    isMac();
-    ```
+### Stream Manipulators
 
-    ### Filter Functions (filter:: namespace)
+```cssl
+// Precision
+cout << setprecision(2) << 3.14159 << endl;  // "3.14"
 
-    ```cssl
-    // Register custom filter
-    filter::register("custom", "handler", callback);
-    filter::unregister("custom", "handler");
-    filter::list();          // All registered filters
-    filter::exists("custom", "handler");
-    ```
+// Width and fill
+cout << setw(10) << setfill('0') << 42 << endl;  // "0000000042"
 
-    ---
+// Number format
+cout << fixed << 3.14159 << endl;       // Fixed point
+cout << scientific << 3.14159 << endl;  // Scientific
+```
 
-    ## CodeInfusion
+---
 
-    Modify functions at runtime.
+## Module System
 
-    ### <<== (Replace)
+### Include Files
 
-    ```cssl
-    void original() {
-        printl("Original");
-    }
+```cssl
+// Include CSSL file
+include "utils.cssl";
 
-    original() <<== {
-        printl("Replaced");
-    }
+// Include as module
+@utils = include("utils.cssl");
+utils.helper();
 
-    original();  // "Replaced"
-    ```
+// Include with alias
+@lib = include("library.cssl");
+lib::function();
+```
 
-    ### +<<== (Add Before)
+### CSSL Modules (.cssl-mod)
 
-    ```cssl
-    void base() {
-        printl("Base");
-    }
+Create modules from Python files:
 
-    base() +<<== {
-        printl("Added");
-    }
+```bash
+includecpp cssl makemodule mylib.py -o mylib.cssl-mod
+```
 
-    base();
-    // Output:
-    // Added
-    // Base
-    ```
+Use in CSSL:
 
-    ### -<<== (Remove)
+```cssl
+include "mylib.cssl-mod";
+mylib.function();
+```
 
-    ```cssl
-    void withExtra() {
-        printl("Important");
-        printl("Unimportant");
-    }
+### Package System
 
-    withExtra() -<<== {
-        printl("Unimportant");
+```cssl
+package "myapp" {
+    package-includes {
+        include "lib1.cssl"
+        include "lib2.cssl"
     }
 
-    withExtra();  // Only "Important"
-    ```
+    exec package {
+        // Main package code
+        printl("Package loaded");
+    }
+}
+```
 
-    ### Exit Injection
+### Service Definition
 
-    ```cssl
-    exit() <<== {
-        printl("Cleanup...");
-    }
+```cssl
+service:
+    name: "MyService"
+    version: "1.0.0"
+    author: "Developer"
 
-    exit();  // Executes injection
-    ```
+service-init {
+    // Initialization
+    printl("Service initializing...");
+}
 
-    ---
+service-include {
+    include "dependencies.cssl"
+}
 
-    ## BruteInjection
+service-run {
+    // Main service code
+    printl("Service running");
+}
+```
 
-    Transfer data between containers.
+---
 
-    ### +<== (Copy)
+## C++ Integration
 
-    ```cssl
-    stack<string> source;
-    source.push("A");
-    source.push("B");
+### Import C++ Modules (v4.8.8)
 
-    datastruct<string> target;
-    target +<== source;  // Copy A, B (source unchanged)
-    ```
+```cssl
+// Import pre-built C++ module
+@math = includecpp("C:/projects/mylib/cpp.proj", "fastmath");
 
-    ### -<== (Move)
+// Use module
+result = math.fibonacci(10);      // 55
+heavy = math.heavy_compute(100);  // Fast C++ execution
+```
 
-    ```cssl
-    stack<string> src;
-    src.push("Data");
+### C++ Operations
 
-    datastruct<string> dst;
-    dst -<== src;  // src is empty after
-    ```
+```cssl
+sizeof(int);                    // Get type size
+memcpy(dest, src, size);        // Memory copy
+memset(buffer, value, size);    // Memory set
+```
 
-    ### ==> (Replace)
+### Native/Unative Functions
 
-    ```cssl
-    stack<string> data;
-    data.push("New");
+```cssl
+// Force C++ execution (v4.6.0)
+native define fastFunction() {
+    // Runs in C++ interpreter for speed
+    foreach (i in range(1000000)) {
+        // Fast loop
+    }
+}
 
-    datastruct<string> container;
-    container ==> data;  // Replace container content
-    ```
+// Force Python execution (v4.6.5)
+unative define pythonFunction() {
+    // Runs in Python for compatibility
+    // Use for advanced CSSL features
+}
+```
 
-    ### ==>- (Remove Matching)
+### Memory Binding (v4.9.0)
 
-    ```cssl
-    stack<string> names;
-    names.push("Alice");
-    names.push("Bob");
-    names.push("Alice");
+Bind functions or classes to a memory address for deferred execution:
 
-    stack<string> toRemove;
-    toRemove.push("Alice");
+```cssl
+// Get memory info about an object
+data = memory(myObject);
+addr = data.get("address");  // Memory address as hex string
+type = data.get("type");     // Type name
+methods = data.get("methods"); // List of methods
 
-    names ==>- toRemove;
-    printl(names);  // ["Bob"]
-    ```
+// Bind function to execute when host is called
+define myFunc() : uses memory(hostFunction) {
+    printl("Runs before hostFunction executes");
+}
 
-    ### Filter Syntax
+// When hostFunction is called, myFunc runs first, then hostFunction
 
-    ```cssl
-    target +<== [type::filter=value] source;
+// Bind class to execute constructor when host class is instantiated
+class MyClass : uses memory(HostClass) {
+    constr MyClass() {
+        printl("Runs when HostClass constructor is called");
+    }
+}
 
-    // String filters
-    result +<== [string::where="Apple"] fruits;
-    result +<== [string::not="Banana"] fruits;
-    result +<== [string::contains="App"] fruits;
-    result +<== [string::length=5] fruits;
-    result +<== [string::cut=3] version;
-    result +<== [string::cutAfter="."] version;
+// Practical example: Hook into existing function
+define logCalls() : uses memory(printl) {
+    // This runs every time printl is called
+}
+```
 
-    // Other filters
-    result +<== [integer::where=42] numbers;
-    result +<== [json::key="name"] objects;
-    ```
+---
 
-    ---
+## Python Interop
 
-    ## Value Capture
+### Import Python Modules
 
-    Capture values at registration time with `%`:
+```cssl
+@math = pyimport("math");
+printl(math.sqrt(16));  // 4.0
 
-    ```cssl
-    string version = "1.0.0";
-    savedVersion <<== { %version; }
+@json = pyimport("json");
+data = json.loads('{"key": "value"}');
+```
 
-    version = "2.0.0";
-    printl(savedVersion);  // "1.0.0" (captured value)
-    ```
+### Python Type Conversion
 
-    ### Capturing Functions
+```cssl
+// Convert CSSL to Python
+python::pythonize(csslObject);
+python::wrap(csslObject);
+python::export(csslObject);
 
-    ```cssl
-    originalExit <<== { %exit(); }
+// Convert Python to CSSL
+python::csslize(pythonObject);
+python::import(pythonObject);
+```
 
-    exit() <<== {
-        printl("Custom cleanup");
-        originalExit();
-    }
-    ```
+### Parameter Exchange
 
-    ---
+```cssl
+// In Python:
+// CSSL.run(code, param1, param2)
 
-    ## Module System
+// In CSSL:
+val = parameter.get(0);      // Get first parameter
+parameter.return(result);    // Return to Python
 
-    ### Import CSSL Module
+// Or via python namespace
+val = python::param_get(0);
+python::param_return(result);
 
-    ```cssl
-    @Math = include("mathlib.cssl-mod");
-    int result = @Math.add(5, 3);
-    ```
+// Count and check
+n = python::param_count();
+has = python::param_has(0);
+all = python::param_all();
+```
 
-    ### Import Python Module
+---
 
-    ```cssl
-    @os = pyimport("os");
-    string cwd = @os.getcwd();
+## Multi-Language Support
 
-    @datetime = pyimport("datetime");
-    @datetime.datetime.now();
-    ```
+CSSL supports multi-language code blocks (v4.1.0).
 
-    ### Load Payload
+### Language Blocks
 
-    ```cssl
-    payload("helpers.cssl-pl");
-    ```
+```cssl
+supports python {
+    # Python code here
+    def helper():
+        return 42
+}
 
-    ### Create Module (CLI)
+supports javascript {
+    // JS-like code
+    function jsHelper() {
+        return "hello";
+    }
+}
+```
 
-    ```bash
-    python -m includecpp cssl makemodule mylib.py -o mylib.cssl-mod
-    ```
+### Cross-Language Instance Access
 
-    ---
+```cssl
+// Access C++ class
+cpp$MyClass.method();
+cpp$MyClass.property = value;
 
-    ## Multi-Language Support
+// Access Python object
+py$PyObject.method();
+py$PyObject.attribute;
 
-    CSSL v4.1.0 introduces multi-language support for interoperability with other programming languages.
+// Access JavaScript object (if JS support enabled)
+js$JsObject.function();
+```
 
-    ### libinclude - Load Language Support
+### Library Include
 
-    Use `libinclude()` to load a language support module:
+```cssl
+// Include language-specific library
+libinclude("numpy", "python");
+libinclude("lodash", "javascript");
+```
 
-    ```cssl
-    // Load language support
-    @py = libinclude("python");
-    cpp = libinclude("c++");
-    java = libinclude("java");
-    csharp = libinclude("c#");
-    js = libinclude("javascript");
-    ```
+---
 
-    **Supported Languages:**
+## Async/Await System (v4.9.3)
 
-    | Language | Identifiers |
-    |----------|-------------|
-    | Python | `python`, `py` |
-    | C++ | `c++`, `cpp` |
-    | Java | `java` |
-    | C# | `c#`, `csharp` |
-    | JavaScript | `javascript`, `js` |
+CSSL provides full async/await support for concurrent operations with generators for lazy iteration.
 
-    ### supports - Multi-Language Syntax
+### Async Functions
 
-    Use the `supports` keyword to write functions or classes using another language's syntax:
+```cssl
+// Define async function with 'async' modifier
+async define fetchData(string url) {
+    result = http.get(url);
+    return result;
+}
 
-    ```cssl
-    // Python-style function
-    define calculate(numbers) : supports python {
-        total = 0
-        for n in numbers:
-            total = total + n
-        return total
-    }
+// Calling async function returns a Future immediately
+future f = fetchData("http://example.com");
 
-    // C++ style class
-    class Engine : supports cpp {
-        int power;
-        bool running;
+// Wait for result with await
+data = await f;
+printl(data);
+```
 
-        void start() {
-            this->running = true;
-        }
-    }
+### Using the Async Module
 
-    // JavaScript style function
-    define fetchData(url) : supports javascript {
-        let response = fetch(url);
-        console.log("Fetched: " + url);
-        return response;
-    }
-    ```
+```cssl
+// Run any function asynchronously
+future f = async.run(slowFunction, arg1, arg2);
 
-    ### Cross-Language Instance Access
+// Wait for result
+result = async.wait(f);
 
-    Access instances shared from other languages using `lang$InstanceName` syntax:
+// Or use await keyword
+result = await f;
 
-    ```cssl
-    cpp = libinclude("c++");
+// Cancel operation
+async.stop(f);
 
-    // Access C++ shared instance
-    engine = cpp$MyEngine;
-    printl(engine.power);
+// Async sleep (milliseconds)
+async.sleep(1000);
+```
 
-    // Cross-language inheritance
-    class TurboEngine : extends cpp$Engine {
-        int turboBoost;
+### Multiple Async Operations
 
-        constr TurboEngine(int boost) {
-            this->turboBoost = boost;
-        }
-    }
-    ```
+```cssl
+// Wait for all to complete
+future f1 = async.run(task1);
+future f2 = async.run(task2);
+future f3 = async.run(task3);
 
-    ### Instance Sharing API
+results = async.all([f1, f2, f3]);
+// results = [result1, result2, result3]
 
-    Share instances between languages using the `share()` and `get_instance()` methods:
+// Race - first to complete wins
+winner = async.race([f1, f2, f3]);
+```
 
-    ```cssl
-    // Get language support
-    cpp = libinclude("c++");
+### Generators with Yield
 
-    // Share a CSSL instance with C++
-    class MyClass {
-        string value;
+```cssl
+// Generator function using yield
+generator<int> define Range(int n) {
+    int i = 0;
+    while (i < n) {
+        yield i;
+        i = i + 1;
     }
-    instance = new MyClass();
-    cpp.share("MyClass", instance);
+}
 
-    // Access from C++:
-    // auto* obj = CSSL_GET(MyClass, "MyClass");
-    ```
+// Use generator
+gen = Range(5);
+while (gen.has_next()) {
+    printl(gen.next());  // 0, 1, 2, 3, 4
+}
 
-    ### Language SDKs
+// Convert to list
+numbers = Range(10).to_list();
+```
 
-    SDKs are available for sharing instances from other languages into CSSL:
+### Generator Methods
 
-    **C++ SDK:**
-    ```cpp
-    #include "includecpp.h"
+```cssl
+gen = myGenerator();
 
-    class Engine { public: int power = 100; };
+gen.next()      // Get next value
+gen.has_next()  // Check if more values
+gen.send(val)   // Send value into generator
+gen.to_list()   // Consume all into list
+gen.take(n)     // Take up to n values
+gen.skip(n)     // Skip n values
+```
 
-    Engine engine;
-    CSSL_SHARE(Engine, &engine);
-    // Now accessible as cpp$Engine in CSSL
-    ```
+### Future States
 
-    **Java SDK:**
-    ```java
-    import com.includecpp.CSSL;
+```cssl
+future f = async.run(myFunc);
 
-    MyService svc = new MyService();
-    CSSL.share("MyService", svc);
-    // Now accessible as java$MyService in CSSL
-    ```
+// Check state
+if (f.is_done()) {
+    result = f.result();
+}
 
-    **C# SDK:**
-    ```csharp
-    using IncludeCPP;
+// Chain callbacks
+f.then(lambda result: printl("Got: " + result));
 
-    var service = new MyService();
-    CSSL.Share("MyService", service);
-    // Now accessible as csharp$MyService in CSSL
-    ```
+// Cancel if needed
+f.cancel();
+```
 
-    **JavaScript SDK:**
-    ```javascript
-    import { CSSL } from 'includecpp-cssl';
+### Practical Example
 
-    class DataProcessor { process(data) { } }
-    CSSL.share('DataProcessor', new DataProcessor());
-    // Now accessible as js$DataProcessor in CSSL
-    ```
+```cssl
+// Async HTTP requests in parallel
+async define fetchAll(array urls) {
+    futures = [];
+    foreach (url in urls) {
+        futures.push(async.run(http.get, url));
+    }
+    return async.all(futures);
+}
 
-    ### SDK API Reference
+// Use it
+data = await fetchAll(["http://api1.com", "http://api2.com"]);
+```
 
-    All language SDKs provide these methods:
+---
 
-    | Method | Description |
-    |--------|-------------|
-    | `share(name, instance)` | Share an instance by name |
-    | `get(name)` | Get a shared instance |
-    | `has(name)` | Check if instance exists |
-    | `remove(name)` | Remove a shared instance |
-    | `list()` | Get all instance names |
-    | `clear()` | Clear all instances |
+## Error Handling
 
-    ---
+### Try/Catch/Finally
 
-    ## Error Handling
+```cssl
+try {
+    // Code that might fail
+    result = riskyOperation();
+}
+catch (e) {
+    // Handle error
+    printl("Error: " + e);
+}
+finally {
+    // Always executes
+    cleanup();
+}
+```
 
-    ### Try / Catch
+### Throw Exceptions
 
-    ```cssl
-    try {
-        riskyOperation();
-    } catch (error) {
-        printl("Error: " + error);
+```cssl
+define validate(int x) {
+    if (x < 0) {
+        throw "Value must be positive";
     }
+    return x;
+}
 
-    try {
-        operation();
-    } catch (error) {
-        printl("Error");
-    } finally {
-        printl("Always runs");
-    }
-    ```
+try {
+    validate(-5);
+}
+catch (e) {
+    printl("Caught: " + e);
+}
+```
 
-    ### Undefined Functions
+### Assertions
 
-    ```cssl
-    undefined void safeOperation() {
-        dangerousCode();  // Errors ignored
-    }
-    ```
-
-    ### Assert
-
-    ```cssl
-    assert(x > 0, "x must be positive");
-    ```
-
-    ---
-
-    ## Quick Reference
-
-    ### Keywords
-
-    | Keyword | Description |
-    |---------|-------------|
-    | `void` | No return value |
-    | `return` | Return value |
-    | `global` | Declare global |
-    | `if` / `else` / `elif` | Conditionals |
-    | `switch` / `case` / `default` | Switch statement |
-    | `for` / `foreach` / `while` | Loops |
-    | `break` / `continue` | Loop control |
-    | `try` / `catch` / `finally` | Error handling |
-    | `class` / `new` / `this` | OOP |
-    | `extends` / `overwrites` | Inheritance |
-    | `constr` | Constructor |
-    | `define` | Function definition |
-    | `undefined` | Ignore errors |
-    | `closed` / `private` | Injection protection |
-    | `virtual` | Import-safe |
-    | `meta` / `super` | Special function types |
-    | `shuffled` | Multiple returns |
-    | `open` | Any parameters |
-    | `include` / `get` | Import modules |
-
-    ### Injection Operators
-
-    | Operator | Type | Description |
-    |----------|------|-------------|
-    | `<<==` | CodeInfusion | Replace function |
-    | `+<<==` | CodeInfusion | Add code before |
-    | `-<<==` | CodeInfusion | Remove code |
-    | `<==` | ValueCapture | Capture/assign |
-    | `+<==` | BruteInjection | Copy data |
-    | `-<==` | BruteInjection | Move data |
-    | `==>` | BruteInjection | Replace data |
-    | `==>-` | BruteInjection | Remove matching |
-    | `++` | AppendMode | Append to parent |
-
-    ### Special Syntax
-
-    | Syntax | Description |
-    |--------|-------------|
-    | `@name` | Global variable access |
-    | `@name = value` | Global variable assignment |
-    | `r@name = value` | Global reference assignment |
-    | `$name` | Shared Python object |
-    | `%name` | Captured value |
-    | `this->` | Class member access |
-    | `super::method()` | Parent method call |
-    | `json::func()` | Namespace function |
-    | `&ClassName::member` | Class member reference |
-    | `&FunctionName ++` | Append to function |
-    | `*func()` | Non-null function |
-    | `*[type]func()` | Type exclusion filter |
-    | `global class Name` | Global class declaration |
-    | `class @Name` | Global class (alt syntax) |
-    | `global define func()` | Global function declaration |
-    | `define @func()` | Global function (alt syntax) |
-    | `new @ClassName()` | Instantiate global class |
-    | `libinclude("lang")` | Load language support module |
-    | `supports lang` | Use other language syntax |
-    | `lang$InstanceName` | Cross-language instance access |
-
-    ### Multi-Language Keywords
-
-    | Keyword | Description |
-    |---------|-------------|
-    | `libinclude` | Load language support module |
-    | `supports` | Use another language's syntax in function/class |
-
-    ### Cross-Language Syntax
-
-    | Syntax | Description | Example |
-    |--------|-------------|---------|
-    | `libinclude("lang")` | Load language support | `cpp = libinclude("c++")` |
-    | `: supports lang` | Use language syntax | `define func() : supports python { }` |
-    | `lang$Name` | Access shared instance | `cpp$Engine`, `java$Service` |
-    | `extends lang$Name` | Inherit from shared class | `class Child : extends cpp$Parent { }` |
-
-    ---
-
-    *CSSL v4.1.0 - Developed as part of IncludeCPP*
+```cssl
+assert(x > 0, "x must be positive");
+assert(list.length > 0);  // Default message
+```
+
+---
+
+## CLI Reference
+
+### CSSL Commands
+
+```bash
+# Run CSSL file
+includecpp cssl run myfile.cssl
+
+# Run inline code
+includecpp cssl run -c 'printl("Hello!");'
+
+# Run with parameters
+includecpp cssl run script.cssl --args "param1" "param2"
+
+# Format CSSL file
+includecpp cssl format myfile.cssl
+includecpp cssl format myfile.cssl --inplace
+
+# Create module from Python
+includecpp cssl makemodule mylib.py -o mylib.cssl-mod
+
+# Show CSSL version
+includecpp cssl version
+
+# Validate CSSL syntax
+includecpp cssl check myfile.cssl
+```
+
+### C++ Build Commands
+
+```bash
+# Build all modules
+includecpp rebuild
+
+# Build specific module
+includecpp rebuild --modules mymodule
+
+# Clean build
+includecpp rebuild --clean
+
+# Verbose output
+includecpp rebuild --verbose
+```
+
+---
+
+## Quick Reference
+
+### Variable Prefixes
+
+| Prefix | Meaning | Example |
+|--------|---------|---------|
+| `@` | Module/local | `@Module = include("m.cssl")` |
+| `r@` | Global | `r@globalVar = 1` |
+| `s@` | Struct self | `s@Config.port` |
+| `$` | Shared | `$SharedData = {}` |
+| `%` | Snapshot | `%capturedVar` |
+
+### Function Modifiers
+
+| Modifier | Effect |
+|----------|--------|
+| `const` | Immutable, no side effects |
+| `private` | No external injections |
+| `static` | No instance overhead |
+| `global` | Globally accessible |
+| `native` | Force C++ execution |
+| `unative` | Force Python execution |
+| `embedded` | Immediate &target replacement |
+| `meta` | Must return value |
+| `closed` | Protected from injection |
+| `open` | Accept any parameter type |
+| `secure` | Constructor on exception only |
+| `callable` | Manual constructor call |
+
+### Container Quick Reference
+
+| Type | Creation | Add | Remove | Access |
+|------|----------|-----|--------|--------|
+| `stack<T>` | `stack<T> s;` | `s.push(x)` | `s.pop()` | `s.peek()` |
+| `vector<T>` | `vector<T> v;` | `v.push_back(x)` | `v.erase(i)` | `v[i]` |
+| `array<T>` | `array<T> a;` | `a.push(x)` | `a.remove(i)` | `a.get(i)` |
+| `map<K,V>` | `map<K,V> m;` | `m.set(k,v)` | `m.remove(k)` | `m.get(k)` |
+| `queue<T>` | `queue<T> q;` | `q.enqueue(x)` | `q.dequeue()` | `q.peek()` |
+| `list` | `list l = [];` | `l.append(x)` | `l.remove(x)` | `l[i]` |
+| `dict` | `dict d = {};` | `d["k"] = v` | `del d["k"]` | `d["k"]` |
+
+### Operator Priority (High to Low)
+
+1. `()` `[]` `.` `->` `::`
+2. `~` `!` `not`
+3. `*` `/` `%`
+4. `+` `-`
+5. `<<` `>>`
+6. `<` `<=` `>` `>=`
+7. `==` `!=`
+8. `&&` `and`
+9. `||` `or`
+10. `<==` `==>` `<<==` `==>>`
+11. `=`
+
+---
+
+## Version History
+
+- **v4.9.0** - Complete documentation update, includecpp() builtin, snapshot system enhancements
+- **v4.8.8** - Snapshot system, super->method(), destructor support, callable/secure constructors
+- **v4.8.4** - C++ I/O streams (cout, cin, fstream)
+- **v4.7.0** - Thread-safe Queue type
+- **v4.6.5** - Color functions, watcher namespace, unative modifier
+- **v4.6.3** - F-strings support
+- **v4.6.0** - Native modifier for C++ execution
+- **v4.2.5** - Embedded functions, parameter switch, bytearrayed
+- **v4.1.0** - Multi-language support, libinclude
+
+---
+
+*CSSL is part of IncludeCPP - Professional C++/Python Integration*