IncludeCPP 3.8.9__py3-none-any.whl → 4.0.0__py3-none-any.whl

includecpp/core/cssl/CSSL_DOCUMENTATION.md

@@ -1,65 +1,56 @@
 # CSSL - C-Style Scripting Language
 
-> Version 3.8.9 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
+> Version 4.0.0 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
 
 ---
 
 ## Table of Contents
 
 1. [Quick Start](#quick-start)
-2. [Basics](#basics)
+2. [Syntax Basics](#syntax-basics)
 3. [Data Types](#data-types)
-4. [Container Types](#container-types)
-5. [Variables & Globals](#variables--globals)
-6. [Control Structures](#control-structures)
+4. [Variables & Globals](#variables--globals)
+5. [Operators](#operators)
+6. [Control Flow](#control-flow)
 7. [Functions](#functions)
-8. [Function Keywords](#function-keywords)
-9. [String Methods](#string-methods)
-10. [File I/O](#file-io)
-11. [JSON Functions](#json-functions)
-12. [Instance Management](#instance-management)
-13. [Live Object Sharing](#live-object-sharing)
-14. [CodeInfusion](#codeinfusion)
-15. [Value Capture](#value-capture)
-16. [BruteInjection](#bruteinjection)
-17. [Filter Syntax](#filter-syntax)
-18. [Module System](#module-system)
-19. [Parameter Bridge](#parameter-bridge)
-20. [Classes & OOP](#classes--oop)
-21. [Map Container](#map-container)
-22. [Structures](#structures)
-23. [Error Handling](#error-handling)
-24. [CLI Commands](#cli-commands)
-25. [Examples](#examples)
+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. [Error Handling](#error-handling)
+16. [Quick Reference](#quick-reference)
 
 ---
 
 ## Quick Start
 
-### Installation & Usage
+### Installation
+
+```bash
+pip install includecpp
+```
+
+### Python Usage
 
 ```python
 from includecpp import CSSL
 
-# Execute code (v3.7.6+: use run() instead of exec())
-CSSL.run("""
+# Execute CSSL code
+CSSL.run('''
     printl("Hello CSSL!");
-""")
+''')
 
 # With parameters and return value
-result = CSSL.run("""
+result = CSSL.run('''
     string name = parameter.get(0);
     printl("Hello " + name);
     parameter.return(true);
-""", "World")
+''', "World")
 
 print(result)  # True
-
-# Create typed scripts and modules (v3.7.6+)
-main = CSSL.script("cssl", '''printl("Main");''')
-payload = CSSL.script("cssl-pl", '''void helper() { printl("Helper!"); }''')
-mod = CSSL.makemodule(main, payload, "mymod")
-mod.helper()  # Call function directly
 ```
 
 ### CLI Execution
@@ -68,92 +59,58 @@ mod.helper()  # Call function directly
 # Execute CSSL file
 python -m includecpp cssl exec myfile.cssl
 
-# Create module
+# Create module from Python file
 python -m includecpp cssl makemodule mylib.py -o mylib.cssl-mod
 ```
 
-### First Steps
+### First Script
 
 ```cssl
-// Declare variables
+// Variables
 string name = "CSSL";
 int version = 3;
 
 // Output
 printl("Welcome to " + name);
-printl(version);
 
-// Define function
+// Function
 void greet(string msg) {
     printl(msg);
 }
+
 greet("Hello World!");
 ```
 
 ---
 
-## Basics
+## Syntax Basics
 
 ### Comments
 
 ```cssl
-// Single-line comment
-
-/*
-   Multi-line
-   comment
-*/
+// Single-line comment (C-style)
+# Single-line comment (Python-style)
 ```
 
-### Output
+### Semicolons
+
+Semicolons are optional but recommended for clarity.
 
 ```cssl
-printl("Text");              // With newline
-printl(variable);            // Print variable
-printl("Value: " + var);     // String concatenation
-printl("Number: " + 42);     // String + Int works!
+printl("Hello")    // Works
+printl("Hello");   // Also works (recommended)
 ```
 
-### Operators
-
-#### Arithmetic Operators
-
-| Operator | Description | Example |
-|----------|-------------|---------|
-| `+` | Addition / String concatenation | `a + b` |
-| `-` | Subtraction | `a - b` |
-| `*` | Multiplication | `a * b` |
-| `/` | Division | `a / b` |
-| `%` | Modulo (remainder) | `a % b` |
-
-#### Comparison Operators
-
-| Operator | Description | Example |
-|----------|-------------|---------|
-| `==` | Equality | `a == b` |
-| `!=` | Inequality | `a != b` |
-| `<` | Less than | `a < b` |
-| `>` | Greater than | `a > b` |
-| `<=` | Less than or equal | `a <= b` |
-| `>=` | Greater than or equal | `a >= b` |
-
-#### Logical Operators
-
-| Operator | Description | Example |
-|----------|-------------|---------|
-| `&&` | Logical AND | `a && b` |
-| `\|\|` | Logical OR | `a \|\| b` |
-| `!` | Logical NOT | `!condition` |
-| `not` | Logical NOT (alternative) | `not condition` |
+### Output Functions
 
-#### Increment/Decrement (only in C-style for-loops)
-
-| Operator | Description | Example |
-|----------|-------------|---------|
-| `++` | Increment | `i++` |
-| `--` | Decrement | `i--` |
-| `+=` | Addition assignment | `i += 1` |
-| `-=` | Subtraction assignment | `i -= 1` |
+```cssl
+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
+```
 
 ---
 
@@ -163,232 +120,254 @@ printl("Number: " + 42);     // String + Int works!
 
 | Type | Description | Example |
 |------|-------------|---------|
-| `string` | Text string | `string s = "Hello";` |
-| `int` | Integer | `int i = 42;` |
+| `int` | Integer | `int x = 42;` |
 | `float` | Floating point | `float f = 3.14;` |
+| `string` | Text string | `string s = "Hello";` |
 | `bool` | Boolean | `bool b = true;` |
-| `json` | JSON object | `json j;` |
-| `dynamic` | Dynamic type | `dynamic x = "anything";` |
+| `dynamic` | Any type (flexible) | `dynamic x = "text";` |
+| `void` | No return value | `void func() { }` |
+| `null` | Absence of value | `dynamic x = null;` |
 
-### Examples
+### Generic Container Types
 
-```cssl
-// String
-string greeting = "Hello";
-string name = "World";
-string combined = greeting + " " + name;
-printl(combined);  // "Hello World"
+| 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;` |
 
-// Integer
-int count = 10;
-int doubled = count * 2;
-printl(doubled);  // 20
+### Type Conversion
 
-// Float
-float price = 19.99;
-printl(price);
+```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
+```
 
-// Boolean
-bool active = true;
-bool disabled = false;
+### Type Checking
 
-// Dynamic (flexible, but slower)
-dynamic anything = "first string";
-anything = 123;  // now int
-anything = 3.14; // now float
+```cssl
+typeof(42);           // "int"
+typeof("hello");      // "str"
+isinstance(42, "int"); // true
+isint(42);            // true
+isstr("hello");       // true
+isnull(null);         // true
 ```
 
 ---
 
-## Container Types
+## Variables & Globals
 
-### stack\<T\>
+### Scope Behavior
 
-LIFO data structure (Last In, First Out).
+Variables are **local by default**. Each function/class has its own scope - variables defined inside a function only exist within that function.
 
 ```cssl
-stack<string> names;
-names.push("Alice");
-names.push("Bob");
-names.push("Charlie");
+define myFunction() {
+    string name = "Alice";  // Local to myFunction
+    printl(name);           // Works
+}
 
-printl(names);           // ['Alice', 'Bob', 'Charlie']
-printl(names[0]);        // "Alice" (index access)
-printl(len(names));      // 3
+myFunction();
+// printl(name);  // Error! 'name' doesn't exist here
 
-string last = names.pop();
-printl(last);            // "Charlie"
-```
+// Same variable name in different scopes = different variables
+string name = "Bob";
 
-**Methods:**
+define otherFunction() {
+    string name = "Charlie";  // Different variable, local to otherFunction
+    printl(name);             // "Charlie"
+}
 
-| Method | Description |
-|--------|-------------|
-| `.push(value)` | Add element |
-| `.pop()` | Remove and return last element |
-| `[index]` | Get element at index |
-| `len(stack)` | Number of elements |
+otherFunction();
+printl(name);  // "Bob" - outer scope unchanged
+```
 
----
+### Everything is Local by Default
 
-### vector\<T\>
+All elements (variables, functions, classes) are **local by default** and must be explicitly marked global.
 
-Dynamic array.
+| 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 { }` |
 
-```cssl
-vector<int> numbers;
-numbers.push(10);
-numbers.push(20);
-numbers.push(30);
+### Local Variables
 
-printl(numbers);      // [10, 20, 30]
-printl(numbers[1]);   // 20
+```cssl
+string name = "Alice";
+int count = 10;
+float price = 19.99;
+bool active = true;
 ```
 
-**Methods:**
+### Global Variables
 
-| Method | Description |
-|--------|-------------|
-| `.push(value)` | Add element |
-| `.pop()` | Remove last element |
-| `[index]` | Element at index |
+Use `global` keyword or `@`/`r@` prefix to create/access global variables:
 
----
+```cssl
+// Declaration with 'global' keyword
+global myGlobal = "visible everywhere";
 
-### array\<T\>
+// Access with '@' prefix
+printl(@myGlobal);
 
-Static array.
+// Direct global assignment with @ or r@
+@anotherGlobal = "also global";
+r@yetAnother = "and this too";
 
-```cssl
-array<string> items;
-items.push("A");
-items.push("B");
-printl(items);
+// Always read globals with @
+printl(@x);
 ```
 
----
+### Global Functions
 
-### datastruct\<T\>
+```cssl
+// Global function with 'global' keyword
+global define helper() {
+    printl("I'm global!");
+}
 
-Universal container for BruteInjection operations.
+// Alternative: @ prefix syntax
+define @anotherHelper() {
+    printl("Also global!");
+}
 
-```cssl
-datastruct<string> data;
-data +<== someStack;  // Copy data into it
+// Global typed function
+global void @utilityFunc(string msg) {
+    printl(msg);
+}
 ```
 
----
+### Global Classes
 
-### dataspace\<T\>
+```cssl
+// Global class with 'global' keyword
+global class SharedClass {
+    string value;
+}
 
-Extended data space for complex operations.
+// Alternative: @ prefix syntax
+class @AnotherShared {
+    int count;
+}
 
-```cssl
-dataspace<dynamic> storage;
+// Instantiate global class with @ prefix
+instance = new @SharedClass();
 ```
 
----
+### Prefix Reference
 
-### combo\<T\>
+| 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` |
 
-Combo space for filtered searches.
+### Shared Objects ($)
+
+Access Python objects shared via `CSSL.share()`:
 
 ```cssl
-combo<string> searchSpace;
-combo<open&string> filter = combo<open&string>::like="Hannes";
-```
+// Access shared Python object
+$counter.value = 100;
+$counter.increment();
 
----
+// Delete shared object
+delete("counter");
+```
 
-### iterator\<T\>
+### Captured References (%)
 
-For iterations over data structures.
+Capture value at registration time:
 
 ```cssl
-iterator<int> it;
-
-// 2D iterator with 16 fields
-iterator<iterator<int, 16>> Map;
-Map.insert(3, 12);
-Map.fill(0);
-int value = Map.at(3);
+string version = "1.0";
+savedVersion <<== { %version; }
+version = "2.0";
+printl(savedVersion);  // Still "1.0"
 ```
 
----
-
-### shuffled\<T\>
+### Class Member Access (this->)
 
-Container for multiple return values.
+Inside classes, use `this->` to access instance members:
 
 ```cssl
-shuffled<string> results;
+class Person {
+    string name;
 
-shuffled string getMultiple() {
-    return "first", "second", "third";
+    void setName(string n) {
+        this->name = n;  // Instance member
+    }
 }
 ```
 
 ---
 
-## Variables & Globals
-
-### Local Variables
-
-```cssl
-string local = "only visible here";
-int number = 42;
-```
-
-### Global Variables
-
-```cssl
-// Declaration with 'global'
-global myGlobal = "visible everywhere";
-
-// Access with '@' prefix
-printl(@myGlobal);
+## Operators
 
-// Or access directly without '@' (since v3.5.9)
-printl(myGlobal);  // Works the same!
+### Arithmetic
 
-// Alternative: r@ syntax for declaration
-r@anotherGlobal = "also global";
-printl(@anotherGlobal);
-printl(anotherGlobal);  // Also works
-```
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `+` | Addition / Concatenation | `a + b` |
+| `-` | Subtraction | `a - b` |
+| `*` | Multiplication | `a * b` |
+| `/` | Division | `a / b` |
+| `%` | Modulo | `a % b` |
 
-### Lookup Order
+### Comparison
 
-When accessing a variable, CSSL checks in order:
-1. Local scope
-2. Global scope
-3. Promoted globals
-4. Built-in functions
+| 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` |
 
-### Usage in Functions
+### Logical
 
-```cssl
-global counter = 0;
+| 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` |
 
-void increment() {
-    @counter = @counter + 1;
-    printl(@counter);
-}
+### Increment/Decrement (in for-loops)
 
-increment();  // 1
-increment();  // 2
-increment();  // 3
-```
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `++` | Increment | `i++` |
+| `--` | Decrement | `i--` |
+| `+=` | Add assign | `i += 1` |
+| `-=` | Subtract assign | `i -= 1` |
 
 ---
 
-## Control Structures
+## Control Flow
 
 ### If / Else If / Else
 
 ```cssl
-int x = 10;
-
 if (x < 5) {
     printl("Small");
 } else if (x < 15) {
@@ -397,29 +376,17 @@ if (x < 5) {
     printl("Large");
 }
 
-// With logical operators
-if (x > 0 && x < 100) {
-    printl("In range");
-}
-
-// Negation
-if (!active) {
-    printl("Not active");
-}
-
-// Alternative negation
-if (not active) {
-    printl("Not active");
+// elif also works
+if (x < 5) {
+    printl("Small");
+} elif (x < 15) {
+    printl("Medium");
 }
 ```
 
----
-
 ### Switch / Case
 
 ```cssl
-int day = 3;
-
 switch (day) {
     case 1:
         printl("Monday");
@@ -427,16 +394,11 @@ switch (day) {
     case 2:
         printl("Tuesday");
         break;
-    case 3:
-        printl("Wednesday");
-        break;
     default:
-        printl("Other day");
+        printl("Other");
 }
 ```
 
----
-
 ### While Loop
 
 ```cssl
@@ -447,19 +409,17 @@ while (i < 5) {
 }
 ```
 
----
-
 ### For Loop (Python-Style)
 
 ```cssl
 // Range-based
-for (i in range(0, 5)) {
+for (i in range(5)) {
     printl(i);  // 0, 1, 2, 3, 4
 }
 
 // With start and end
-for (x in range(10, 15)) {
-    printl(x);  // 10, 11, 12, 13, 14
+for (i in range(10, 15)) {
+    printl(i);  // 10, 11, 12, 13, 14
 }
 
 // With step
@@ -468,66 +428,42 @@ for (i in range(0, 10, 2)) {
 }
 ```
 
----
-
 ### For Loop (C-Style)
 
 ```cssl
-// Classic C-style syntax
 for (int i = 0; i < 10; i++) {
     printl(i);
 }
 
-// With decrement
 for (int i = 10; i > 0; i--) {
     printl(i);
 }
-
-// With +=
-for (int i = 0; i < 100; i += 10) {
-    printl(i);  // 0, 10, 20, ...
-}
 ```
 
----
-
 ### Foreach
 
 ```cssl
 stack<string> names;
 names.push("Alice");
 names.push("Bob");
-names.push("Charlie");
 
-// Syntax 1: foreach (item in collection)
+// Syntax 1
 foreach (name in names) {
     printl(name);
 }
 
-// Syntax 2: foreach collection as item
+// Syntax 2
 foreach names as name {
     printl(name);
 }
 ```
 
----
-
 ### Break & Continue
 
 ```cssl
-// Break - exit loop early
-for (i in range(0, 10)) {
-    if (i == 5) {
-        break;  // Stops at 5
-    }
-    printl(i);
-}
-
-// Continue - skip iteration
-for (i in range(0, 10)) {
-    if (i == 3) {
-        continue;  // Skips 3
-    }
+for (i in range(10)) {
+    if (i == 5) break;     // Exit loop
+    if (i == 3) continue;  // Skip iteration
     printl(i);
 }
 ```
@@ -553,619 +489,731 @@ string getName() {
 int add(int a, int b) {
     return a + b;
 }
-
-// Call
-sayHello();
-string n = getName();
-int sum = add(5, 3);
-```
-
-### Named Parameters
-
-Functions can be called with named parameters for clarity.
-
-```cssl
-// Define function
-int calculate(int base, int multiplier, int offset) {
-    return base * multiplier + offset;
-}
-
-// Call with positional arguments
-int r1 = calculate(10, 5, 3);  // 53
-
-// Call with named parameters
-int r2 = calculate(base=10, multiplier=5, offset=3);  // 53
-
-// Mix positional and named (positional must come first)
-int r3 = calculate(10, multiplier=5, offset=3);  // 53
-
-// Named parameters can be in any order
-int r4 = calculate(offset=3, base=10, multiplier=5);  // 53
 ```
 
-### Nested Functions
+### Define Functions
 
 ```cssl
-void inner() {
-    printl("Inner function");
+// Simple function without type
+define greet() {
+    printl("Hello!");
 }
 
-void outer() {
-    printl("Outer function");
-    inner();
+// With parameters
+define greet(string name) {
+    printl("Hello " + name);
 }
-
-outer();
 ```
 
----
-
-## Function Keywords
-
-### undefined
+### Function Modifiers
 
-Function silently ignores errors.
-
-```cssl
+| 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();  // Errors are ignored
+    riskyOperation();
 }
-mayFail();  // No crash
-```
-
----
-
-### dynamic
-
-No type declaration needed.
-
-```cssl
-dynamic x = "string";
-x = 123;        // now int
-x = 3.14;       // now float
-```
-
----
-
-### define
 
-Constant function without type and return.
-
-```cssl
-define LOG_MESSAGE() {
-    printl("Log message");
+// Protected from injection
+closed void protected() {
+    printl("Protected");
 }
-LOG_MESSAGE();
-```
-
----
-
-### closed
 
-Protects from external code injection.
-
-```cssl
-closed void protectedFunc() {
-    printl("Protected from external injections");
+// Multiple returns
+shuffled string getNames() {
+    return "Alice", "Bob", "Charlie";
 }
-// This injection will be BLOCKED:
-protectedFunc() <<== { printl("Blocked!"); }
-```
 
----
+a, b, c = getNames();
 
-### private
+// Any order of modifiers works
+private string *@Myfunc() {
+    println("Hello from global private non-null function!");
+    return "Hey";
+}
 
-Blocks ALL injections.
+// Const function
+const void immutableFunc() {
+    printl("I'm constant");
+}
 
-```cssl
-private void superSecure() {
-    printl("Absolutely protected");
+// Global private const
+global private const void @MyGlobalFunc() {
+    printl("Complex modifiers in any order");
 }
 ```
 
----
-
-### virtual
+### Typed Functions (Enforced Returns)
 
-Allows import cycles.
+Functions with a return type (like `int`, `string`, `vector<T>`) MUST return that type:
 
 ```cssl
-virtual void safeForImport() {
-    printl("Import-cycle-safe");
+// MUST return string
+string getName() {
+    return "Alice";        // OK
+    // return 42;          // Error! Expected string
 }
-```
 
----
-
-### meta
-
-Declares function as source (must return).
+// MUST return int
+int getAge() {
+    return 30;             // OK
+}
 
-```cssl
-meta string getSource() {
-    return "Meta source";
+// 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
 }
 ```
 
----
-
-### super
+### Non-Null Functions (*)
 
-Forces execution without exceptions.
+Functions that must never return null:
 
 ```cssl
-super void forceRun() {
-    printl("Will ALWAYS execute");
+// Non-null function
+define *alwaysReturns() {
+    return "Always a value";
 }
-```
 
----
+// Non-null assertion on value
+this->name = *$System.os;  // Error if null
+```
 
-### shuffled
+### Type Exclusion Filter (*[type])
 
-Allows multiple return values with tuple unpacking.
+Functions that must NOT return a specific type:
 
 ```cssl
-shuffled string getNames() {
-    return "Alice", "Bob", "Charlie";
+// Must NOT return string
+shuffled *[string] getNumbers() {
+    return 1, 2, 3;  // OK
+    // return "text";  // Error!
 }
 
-// Tuple unpacking (v3.7.6+)
-a, b, c = getNames();
-printl(a);  // "Alice"
-printl(b);  // "Bob"
-printl(c);  // "Charlie"
-
-// Works with any types
-shuffled getValues() {
-    return "text", 42, true;
+// Must NOT return null
+define *[null] getValue() {
+    return 42;  // OK
 }
-name, num, flag = getValues();
 ```
 
----
-
-### open
-
-Accepts any parameters.
+### Open Parameters
 
 ```cssl
 open define flexibleFunc(open Params) {
     string name = OpenFind<string>(0);
     int num = OpenFind<int>(0);
-    printl(name);
-    printl(num);
+    printl(name + " " + num);
 }
 
-flexibleFunc("Hello", 123, true, "World");
+flexibleFunc("Hello", 123, true);
 ```
 
 ---
 
-## String Methods
-
-CSSL offers 40+ string methods:
+## Classes & OOP
 
-### Search & Check
+### Class Definition
 
 ```cssl
-string s = "Hello World";
+class Person {
+    string name;
+    int age;
 
-// Contains
-bool has = s.contains("World");     // true
+    // Constructor
+    void Person(string n, int a) {
+        this->name = n;
+        this->age = a;
+    }
 
-// Find position
-int pos = s.indexOf("o");           // 4
-int last = s.lastIndexOf("o");      // 7
+    void greet() {
+        printl("Hello, I'm " + this->name);
+    }
 
-// Start/end check
-bool start = s.startsWith("Hello"); // true
-bool end = s.endsWith("World");     // true
+    string getName() {
+        return this->name;
+    }
+}
 ```
 
-### Manipulation
+### Creating Instances
 
 ```cssl
-string s = "Hello World";
+Person p = new Person("Alice", 30);
+p.greet();
+printl(p.name);
+```
 
-// Replace
-string r1 = s.replace("World", "CSSL");     // "Hello CSSL"
-string r2 = s.replaceAll("l", "L");         // "HeLLo WorLd"
+### Constructor with `constr` Keyword
 
-// Case
-string upper = s.toUpperCase();   // "HELLO WORLD"
-string lower = s.toLowerCase();   // "hello world"
+```cssl
+class Vehicle {
+    string brand;
 
-// Trim
-string padded = "  text  ";
-string trimmed = padded.trim();   // "text"
+    constr Initialize(string b) {
+        this->brand = b;
+    }
 
-// Repeat
-string rep = "ab".repeat(3);      // "ababab"
+    constr SetupDefaults() {
+        printl("Vehicle ready");
+    }
+}
 
-// Reverse
-string rev = s.reverse();         // "dlroW olleH"
+Vehicle v = new Vehicle("Toyota");
 ```
 
-### Split & Join
+### Class Inheritance
 
 ```cssl
-string csv = "a,b,c,d";
-
-// Split
-stack<string> parts = csv.split(",");  // ["a", "b", "c", "d"]
+class Animal {
+    string name;
 
-// Join
-string joined = parts.join("-");       // "a-b-c-d"
-```
+    void Animal(string n) {
+        this->name = n;
+    }
 
-### Extract
+    void speak() {
+        printl("Sound");
+    }
+}
 
-```cssl
-string s = "Hello World";
+class Dog : extends Animal {
+    void Dog(string n) {
+        this->name = n;
+    }
 
-// Substring
-string sub = s.substring(0, 5);   // "Hello"
-string slc = s.slice(6, 11);      // "World"
+    void speak() {
+        printl("Woof! I'm " + this->name);
+    }
+}
 
-// Character
-string ch = s.charAt(0);          // "H"
-int code = s.charCodeAt(0);       // 72
+Dog d = new Dog("Buddy");
+d.speak();  // "Woof! I'm Buddy"
 ```
 
-### Padding
+### super() and super::method()
 
 ```cssl
-string num = "42";
+class Child : extends Parent {
+    constr ChildInit(string name) {
+        super(name);  // Call parent constructor
+    }
 
-string padded1 = num.padStart(5, "0");  // "00042"
-string padded2 = num.padEnd(5, ".");    // "42..."
+    void speak() {
+        super::speak();  // Call parent method
+        printl("Child speaking");
+    }
+}
 ```
 
-### All String Methods
-
-| Method | Description |
-|--------|-------------|
-| `.contains(str)` | Check if string contains |
-| `.indexOf(str)` | First position of str |
-| `.lastIndexOf(str)` | Last position of str |
-| `.startsWith(str)` | Starts with str? |
-| `.endsWith(str)` | Ends with str? |
-| `.find(str)` | Find position (-1 if not found) |
-| `.split(delimiter)` | Split into array |
-| `.join(delimiter)` | Join array to string |
-| `.replace(old, new)` | Replace first occurrence |
-| `.replaceAll(old, new)` | Replace all occurrences |
-| `.substring(start, end)` | Extract substring |
-| `.slice(start, end)` | Substring (like substring) |
-| `.substr(start, length)` | Substring with length |
-| `.toLowerCase()` | To lowercase |
-| `.toUpperCase()` | To uppercase |
-| `.trim()` | Remove whitespace |
-| `.charAt(index)` | Character at position |
-| `.charCodeAt(index)` | ASCII code at position |
-| `.padStart(len, char)` | Pad left |
-| `.padEnd(len, char)` | Pad right |
-| `.repeat(n)` | Repeat n times |
-| `.reverse()` | Reverse |
-| `.count(str)` | Count occurrences |
-| `len(string)` | String length |
+### Append Mode (++)
 
----
+Extend constructors/functions while keeping original code:
 
-## File I/O
+```cssl
+// Original function
+define BaseFunc() {
+    printl("Base functionality");
+}
 
-CSSL provides built-in functions for file operations.
+// Append to BaseFunc
+define ExtendedFunc() &BaseFunc ++ {
+    printl("Extended functionality");
+}
 
-### Basic File Operations
+ExtendedFunc();
+// Output:
+// Base functionality
+// Extended functionality
+```
 
 ```cssl
-// Read entire file
-string content = read("/path/to/file.txt");
-printl(content);
+class MyClass {
+    constr MyClassConstructor() {
+        printl("MyClass constructor");
+        this->value = 10;
+    }
+}
 
-// Read specific line (1-indexed)
-string line5 = readline(5, "/path/to/file.txt");
-printl(line5);
+class BetterClass :: extends MyClass {
+    constr BetterConstructor() &MyClass::MyClassConstructor ++ {
+        printl("BetterClass - added code");
+        this->extra = 20;
+    }
+}
+```
 
-// Write to file (overwrites)
-write("/path/to/file.txt", "Hello World");
+### Non-Null Class
 
-// Write/replace specific line
-writeline(3, "New line content", "/path/to/file.txt");
+```cssl
+class *MyClass {
+    // All methods must return non-null
+    string getValue() {
+        return "Value";
+    }
+}
 ```
 
-### Extended File Functions
+---
+
+## Container Types
+
+### stack\<T\> - LIFO Stack
 
 ```cssl
-// Read all lines as array
-stack<string> lines = readlines("/path/to/file.txt");
+stack<string> names;
+names.push("Alice");
+names.push("Bob");
 
-// Append to file
-appendfile("/path/to/file.txt", "\nNew content");
+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 |
 
-// File checks
-bool exists = pathexists("/path/to/file.txt");
-bool isFile = isfile("/path/to/file.txt");
-bool isDir = isdir("/path/to/folder");
+### vector\<T\> - Dynamic Array
 
-// File size
-int size = filesize("/path/to/file.txt");
+```cssl
+vector<int> nums;
+nums.push(10);
+nums.push(20);
 
-// Directory listing
-stack<string> files = listdir("/path/to/folder");
+printl(nums.at(0));     // 10
+printl(nums.front());   // 10
+printl(nums.back());    // 20
 ```
 
-### Path Functions
+**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
-// Path manipulation
-string base = basename("/path/to/file.txt");    // "file.txt"
-string dir = dirname("/path/to/file.txt");       // "/path/to"
-string full = joinpath("/path", "to", "file.txt"); // "/path/to/file.txt"
-string abs = abspath("./file.txt");              // "/current/dir/file.txt"
+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");
 ```
 
-### All File I/O Functions
+**Methods:**
 
-| Function | Description |
-|----------|-------------|
-| `read(path)` | Read entire file content |
-| `readline(line, path)` | Read specific line (1-indexed) |
-| `write(path, content)` | Write content to file |
-| `writeline(line, content, path)` | Write/replace specific line |
-| `readfile(path)` | Read file (alias for read) |
-| `writefile(path, content)` | Write file (alias for write) |
-| `readlines(path)` | Read all lines as array |
-| `appendfile(path, content)` | Append to file |
-| `pathexists(path)` | Check if path exists |
-| `isfile(path)` | Check if is file |
-| `isdir(path)` | Check if is directory |
-| `filesize(path)` | Get file size in bytes |
-| `listdir(path)` | List directory contents |
-| `makedirs(path)` | Create directories |
-| `removefile(path)` | Delete file |
-| `removedir(path)` | Delete empty directory |
-| `copyfile(src, dst)` | Copy file |
-| `movefile(src, dst)` | Move file |
+| 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
+```
 
-## JSON Functions
+**Methods:**
 
-CSSL provides namespace-style JSON functions with the `json::` prefix.
+| 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 |
 
-### Reading & Writing JSON Files
+### shuffled\<T\> - Multiple Returns
 
 ```cssl
-// Read and parse JSON file
-json data = json::read("/path/to/config.json");
-printl(data.name);
+shuffled string getInfo() {
+    return "Alice", "Bob", "Charlie";
+}
 
-// Write data to JSON file
-json::write("/path/to/output.json", data);
+a, b, c = getInfo();
+printl(a);  // "Alice"
 ```
 
-### JSON Parsing & Stringifying
+---
+
+## Built-in Functions
+
+### String Operations
 
 ```cssl
-// Parse JSON string
-string jsonStr = '{"name": "Alice", "age": 30}';
-json obj = json::parse(jsonStr);
+string s = "Hello World";
 
-// Convert to JSON string
-string str = json::stringify(obj);
+// Case
+upper(s);              // "HELLO WORLD"
+lower(s);              // "hello world"
+capitalize(s);         // "Hello world"
+title(s);              // "Hello World"
 
-// Pretty print with indentation
-string pretty = json::pretty(obj);
-printl(pretty);
-```
+// 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"
 
-### JSON Path Operations
+// 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
 
-```cssl
-json data = json::read("config.json");
+// 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]
 
-// Get value by dot-path
-string name = json::get(data, "user.name");
-int age = json::get(data, "user.profile.age");
-string city = json::get(data, "address.city", "Unknown");  // with default
+// 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
 
-// Set value by dot-path
-data = json::set(data, "user.name", "Bob");
-data = json::set(data, "settings.theme", "dark");
+// 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
 
-// Check if path exists
-if (json::has(data, "user.email")) {
-    printl("Email exists");
-}
+// 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"}
 ```
 
-### JSON Object Operations
+### Math Functions
 
 ```cssl
-json obj = json::read("data.json");
+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
 
-// Get all keys
-stack<string> keys = json::keys(obj);
-foreach (key in keys) {
-    printl(key);
-}
+round(3.14159, 2);       // 3.14
+floor(3.9);              // 3
+ceil(3.1);               // 4
 
-// Get all values
-stack<dynamic> values = json::values(obj);
+pow(2, 3);               // 8
+sqrt(16);                // 4
+mod(7, 3);               // 1
 
-// Deep merge objects
-json merged = json::merge(obj1, obj2, obj3);
-```
+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
 
-### All JSON Functions
+log(e());                // 1.0
+log10(100);              // 2.0
+exp(1);                  // 2.71828
 
-| Function | Description |
-|----------|-------------|
-| `json::read(path)` | Read and parse JSON file |
-| `json::write(path, data)` | Write data to JSON file |
-| `json::parse(str)` | Parse JSON string to object |
-| `json::stringify(data)` | Convert to JSON string |
-| `json::pretty(data)` | Pretty print JSON |
-| `json::get(data, path, default)` | Get value by dot-path |
-| `json::set(data, path, value)` | Set value by dot-path |
-| `json::has(data, path)` | Check if path exists |
-| `json::keys(data)` | Get all keys |
-| `json::values(data)` | Get all values |
-| `json::merge(obj1, obj2, ...)` | Deep merge objects |
+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
+```
 
-## Instance Management
+### File I/O Functions
 
-CSSL provides `instance<"name">` syntax and `instance::` namespace for working with shared instances.
+```cssl
+// Read
+string content = read("file.txt");
+string line5 = readline(5, "file.txt");
+stack<string> lines = readlines("file.txt");
 
-### Instance Declaration
+// Write
+write("file.txt", "Hello");
+writeline(3, "New line", "file.txt");
+appendfile("file.txt", "\nMore");
 
-```cssl
-// Get/create shared instance by name
-instance<"MyApp"> app;
+// 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");
 
-// With initialization
-instance<"tk"> tk = include("tkinter.cssl-mod");
+// Checks
+pathexists("file.txt");  // true/false
+isfile("file.txt");      // true/false
+isdir("folder");         // true/false
+filesize("file.txt");    // bytes
 
-// Register object as shared instance
-myModule ==> $AppModule
-// Or using instance syntax:
-myModule ==> instance<"AppModule">
+// Directory
+listdir("./");           // ["file1", "file2"]
+makedirs("new/folder");
+removefile("file.txt");
+removedir("folder");
+copyfile("src", "dst");
+movefile("old", "new");
 ```
 
-### Instance Introspection
+### JSON Functions (json:: namespace)
 
 ```cssl
-@tk = include("tk.cssl-mod");
-
-// Get all methods from module
-stack<string> methods = instance::getMethods(@tk);
-foreach (m in methods) {
-    printl("Method: " + m);
-}
+// File operations
+json data = json::read("config.json");
+json::write("output.json", data);
 
-// Get all classes
-stack<string> classes = instance::getClasses(@tk);
+// Parse/Stringify
+json obj = json::parse('{"name": "Alice"}');
+string str = json::stringify(obj);
+string pretty = json::pretty(obj);
 
-// Get all variables
-stack<string> vars = instance::getVars(@tk);
+// 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");
 
-// Get everything categorized
-json all = instance::getAll(@tk);
-printl(all.methods);   // ["method1", "method2", ...]
-printl(all.classes);   // ["Class1", "Class2", ...]
-printl(all.vars);      // ["var1", "var2", ...]
+// Object operations
+json::keys(obj);         // ["name"]
+json::values(obj);       // ["Alice"]
+json::merge(obj1, obj2); // Deep merge
 ```
 
-### Dynamic Method Calls
+### Instance Functions (instance:: namespace)
 
 ```cssl
-// Call method dynamically by name
-result = instance::call(@module, "methodName", arg1, arg2);
+@module = include("lib.cssl-mod");
 
-// Check if method/attribute exists
-if (instance::has(@module, "initialize")) {
-    instance::call(@module, "initialize");
-}
+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
 
-// Get type name
-string typeName = instance::type(@module);
-printl(typeName);  // "module"
+isavailable("sharedName");       // Check if exists
 ```
 
-### All Instance Functions
+### Regex Functions
 
-| Function | Description |
-|----------|-------------|
-| `instance<"name"> var` | Declare instance variable |
-| `obj ==> instance<"name">` | Register as shared instance |
-| `instance::getMethods(obj)` | Get all method names |
-| `instance::getClasses(obj)` | Get all class names |
-| `instance::getVars(obj)` | Get all variable names |
-| `instance::getAll(obj)` | Get categorized dict |
-| `instance::call(obj, 'name', ...)` | Call method dynamically |
-| `instance::has(obj, 'name')` | Check if attribute exists |
-| `instance::type(obj)` | Get type name |
-| `isavailable("name")` | Check if shared instance exists |
-| `instance::exists("name")` | Alias for isavailable |
+```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
 
-## Live Object Sharing
+```cssl
+md5("hello");            // 32 hex chars
+sha1("hello");           // 40 hex chars
+sha256("hello");         // 64 hex chars
+```
 
-Share Python objects with CSSL. Changes in CSSL reflect back to Python.
+### System Functions
 
-### Python Side
+```cssl
+exit(0);                 // Exit with code
+input("Enter name: ");   // Read user input
 
-```python
-from includecpp import CSSL
+env("PATH");             // Get env variable
+setenv("MY_VAR", "val"); // Set env variable
 
-class Counter:
-    def __init__(self):
-        self.value = 100
+copy(obj);               // Shallow copy
+deepcopy(obj);           // Deep copy
 
-counter = Counter()
-cssl = CSSL.CsslLang()
-cssl.share(counter, "cnt")
+clear();                 // Clear console
 
-# Changes in CSSL will reflect in Python!
-cssl.exec('''
-    $cnt.value = $cnt.value - 10;
-    printl($cnt.value);  // 90
-''')
+pyimport("os");          // Import Python module
+include("lib.cssl-mod"); // Import CSSL module
+payload("helper.cssl-pl"); // Load payload
 
-print(counter.value)  # 90 - Changed!
+isLinux();               // Platform checks
+isWindows();
+isMac();
 ```
 
-### CSSL Syntax
-
-| Syntax | Description |
-|--------|-------------|
-| `$name` | Access shared object |
-| `$name.property` | Access/modify properties |
-| `$name.method()` | Call methods |
-| `delete("name")` | Remove shared object |
-
-### Loop Modifications
-
-```python
-# Python
-class Stats:
-    def __init__(self):
-        self.total = 100
-
-stats = Stats()
-cssl = CSSL.CsslLang()
-cssl.share(stats, "s")
-
-cssl.exec('''
-    for (i in range(0, 5)) {
-        $s.total = $s.total - 10;
-    }
-    printl($s.total);  // 50
-''')
+### Filter Functions (filter:: namespace)
 
-print(stats.total)  # 50 - Persisted!
+```cssl
+// Register custom filter
+filter::register("custom", "handler", callback);
+filter::unregister("custom", "handler");
+filter::list();          // All registered filters
+filter::exists("custom", "handler");
 ```
 
 ---
 
 ## CodeInfusion
 
-CodeInfusion enables modifying functions at runtime.
-
-> **Important**: Injection operators must be written **without spaces**:
-> - ✓ `func() <<==` / `func() +<<==` / `func() -<<==` (correct)
-> - ✗ `func() < <==` / `func() + <<==` / `func() - <<==` (wrong)
+Modify functions at runtime.
 
 ### <<== (Replace)
 
-Replaces function content.
-
 ```cssl
 void original() {
     printl("Original");
@@ -1178,11 +1226,7 @@ original() <<== {
 original();  // "Replaced"
 ```
 
----
-
-### +<<== (Add)
-
-Adds code to function (executes BEFORE original).
+### +<<== (Add Before)
 
 ```cssl
 void base() {
@@ -1199,12 +1243,8 @@ base();
 // Base
 ```
 
----
-
 ### -<<== (Remove)
 
-Removes code from function.
-
 ```cssl
 void withExtra() {
     printl("Important");
@@ -1218,114 +1258,35 @@ withExtra() -<<== {
 withExtra();  // Only "Important"
 ```
 
----
-
-### exit() Injection
-
-Special injection for program end.
+### Exit Injection
 
 ```cssl
 exit() <<== {
-    printl("Cleanup before exit...");
+    printl("Cleanup...");
 }
 
-// Later:
 exit();  // Executes injection
 ```
 
 ---
 
-## Value Capture
-
-The `%identifier` syntax captures values at registration time, useful for saving original functions before replacement.
-
-### Capturing Variables
-
-```cssl
-string version = "1.0.0";
-
-// Capture current value
-v <== { %version; }
-printl(v);  // "1.0.0"
-
-// Even if version changes later, v keeps captured value
-version = "2.0.0";
-printl(v);  // Still "1.0.0"
-```
-
-### Capturing Functions
-
-```cssl
-// Save original exit function before replacing
-originalExit <<== { %exit(); }
-
-// Replace exit with custom behavior
-exit() <<== {
-    printl("Custom cleanup...");
-    originalExit();  // Call saved original
-}
-
-exit();
-// Output:
-// Custom cleanup...
-// (original exit behavior)
-```
-
-### Use Cases
-
-```cssl
-// 1. Preserving original behavior
-void myFunc() {
-    printl("Original");
-}
-
-savedFunc <<== { %myFunc(); }
-
-myFunc() <<== {
-    printl("Modified");
-}
-
-myFunc();      // "Modified"
-savedFunc();   // "Original"
-
-// 2. Capturing configuration at startup
-global config = loadConfig();
-startupConfig <== { %config; }
-
-// 3. Snapshot values for later comparison
-int counter = 0;
-initial <== { %counter; }
-// ... operations ...
-if (counter != initial) {
-    printl("Counter changed!");
-}
-```
-
----
-
 ## BruteInjection
 
-BruteInjection copies/moves data between containers.
+Transfer data between containers.
 
 ### +<== (Copy)
 
-Copies data to target (source unchanged).
-
 ```cssl
 stack<string> source;
 source.push("A");
 source.push("B");
 
 datastruct<string> target;
-target +<== source;  // Copies A, B
+target +<== source;  // Copy A, B (source unchanged)
 ```
 
----
-
 ### -<== (Move)
 
-Moves data (removes from source).
-
 ```cssl
 stack<string> src;
 src.push("Data");
@@ -1334,25 +1295,17 @@ datastruct<string> dst;
 dst -<== src;  // src is empty after
 ```
 
----
-
 ### ==> (Replace)
 
-Replaces target data completely.
-
 ```cssl
 stack<string> data;
 data.push("New");
 
 datastruct<string> container;
-container ==> data;
+container ==> data;  // Replace container content
 ```
 
----
-
-### ==>- (Receive Minus)
-
-Removes matching items from target.
+### ==>- (Remove Matching)
 
 ```cssl
 stack<string> names;
@@ -1363,1142 +1316,186 @@ names.push("Alice");
 stack<string> toRemove;
 toRemove.push("Alice");
 
-// Remove all "Alice" from names
 names ==>- toRemove;
 printl(names);  // ["Bob"]
 ```
 
----
-
-## Filter Syntax
-
-Filters enable targeted data operations in BruteInjection.
-
-### Syntax
+### Filter Syntax
 
 ```cssl
 target +<== [type::filter=value] source;
-```
-
-### String Filters
-
-```cssl
-stack<string> fruits;
-fruits.push("Apple");
-fruits.push("Banana");
-fruits.push("Apricot");
-
-datastruct<string> result;
 
-// Exact match
+// String filters
 result +<== [string::where="Apple"] fruits;
-
-// Everything except
 result +<== [string::not="Banana"] fruits;
+result +<== [string::contains="App"] fruits;
+result +<== [string::length=5] fruits;
+result +<== [string::cut=3] version;
+result +<== [string::cutAfter="."] version;
 
-// Contains substring
-result +<== [string::contains="App"] fruits;  // Apple, Apricot
-
-// String length
-result +<== [string::length=5] fruits;  // Apple
+// Other filters
+result +<== [integer::where=42] numbers;
+result +<== [json::key="name"] objects;
 ```
 
-### String Cutting Filters
+---
+
+## Value Capture
 
-Cut strings at specific positions or substrings.
+Capture values at registration time with `%`:
 
 ```cssl
-string version = "1.0.0-beta";
+string version = "1.0.0";
+savedVersion <<== { %version; }
 
-// Cut at position (integer index)
-x = <==[string::cut=3] version;
-printl(x);  // "1.0" (first 3 chars)
+version = "2.0.0";
+printl(savedVersion);  // "1.0.0" (captured value)
+```
 
-// Cut at substring position
-x = <==[string::cut="0-"] version;
-printl(x);  // "1.0." (before "0-")
+### Capturing Functions
 
-// Get everything after substring
-x = <==[string::cutAfter=".0."] version;
-printl(x);  // "0-beta" (after ".0.")
+```cssl
+originalExit <<== { %exit(); }
 
-// Cut after at position
-x = <==[string::cutAfter=4] version;
-printl(x);  // ".0-beta" (after index 4)
+exit() <<== {
+    printl("Custom cleanup");
+    originalExit();
+}
 ```
 
-### All Filters
-
-| Filter | Description |
-|--------|-------------|
-| `string::where=VALUE` | Exact string match |
-| `string::not=VALUE` | Everything except this value |
-| `string::contains=VALUE` | Contains substring |
-| `string::length=LENGTH` | Exact string length |
-| `string::cut=INDEX` | Cut at index (returns first N chars) |
-| `string::cut="SUBSTR"` | Cut at substring position |
-| `string::cutAfter=INDEX` | Get everything after index |
-| `string::cutAfter="SUBSTR"` | Get everything after substring |
-| `integer::where=VALUE` | Exact int match |
-| `json::key=KEYNAME` | Filter by JSON key |
-| `json::value=VALUE` | Filter by JSON value |
-| `array::index=INDEX` | By array index |
-| `vector::where=VALUE` | Exact vector match |
-| `combo::filterdb` | Combo FilterDB |
-
 ---
 
 ## Module System
 
-### Create Module
-
-Create CSSL module from Python file:
-
-```bash
-python -m includecpp cssl makemodule mylib.py -o mylib.cssl-mod
-```
-
-### Import Module
+### Import CSSL Module
 
 ```cssl
-// Import Python module
-@Math = include("mymath.cssl-mod");
-
-// Import CSSL file
-@Utils = include("utils.cssl");
-
-// Call module functions
+@Math = include("mathlib.cssl-mod");
 int result = @Math.add(5, 3);
-string text = @Utils.format("Hello");
 ```
 
-### Example: Python Module
-
-**mathlib.py:**
-```python
-def add(a, b):
-    return a + b
+### Import Python Module
 
-def multiply(a, b):
-    return a * b
+```cssl
+@os = pyimport("os");
+string cwd = @os.getcwd();
 
-def square(x):
-    return x * x
+@datetime = pyimport("datetime");
+@datetime.datetime.now();
 ```
 
-**Create module:**
-```bash
-python -m includecpp cssl makemodule mathlib.py -o mathlib.cssl-mod
-```
+### Load Payload
 
-**Use in CSSL:**
 ```cssl
-@Math = include("mathlib.cssl-mod");
+payload("helpers.cssl-pl");
+```
 
-int sum = @Math.add(10, 20);      // 30
-int product = @Math.multiply(5, 6); // 30
-int sq = @Math.square(8);          // 64
+### Create Module (CLI)
 
-printl(sum);
-printl(product);
-printl(sq);
+```bash
+python -m includecpp cssl makemodule mylib.py -o mylib.cssl-mod
 ```
 
 ---
 
-## Parameter Bridge
-
-Communication between Python and CSSL.
-
-### parameter.get()
+## Error Handling
 
-Receive parameters from Python:
+### Try / Catch
 
 ```cssl
-// In CSSL
-string name = parameter.get(0);    // First parameter
-int count = parameter.get(1);      // Second parameter
-printl(name);
-printl(count);
-```
-
-```python
-# In Python
-CSSL.exec(code, "Alice", 42)
-```
-
-### parameter.return()
-
-Return value to Python:
-
-```cssl
-// In CSSL
-int result = 10 + 20;
-parameter.return(result);
-```
-
-```python
-# In Python
-result = CSSL.exec(code)
-print(result)  # 30
-```
-
-### Complete Example
-
-```python
-from includecpp import CSSL
-
-CSSL.CsslLang()
-
-code = """
-    int a = parameter.get(0);
-    int b = parameter.get(1);
-    int sum = a + b;
-    parameter.return(sum);
-"""
-
-result = CSSL.exec(code, 15, 27)
-print(f"Result: {result}")  # Result: 42
-```
-
-### Supported Return Types
-
-```cssl
-parameter.return(true);           // bool
-parameter.return(42);             // int
-parameter.return(3.14);           // float
-parameter.return("Hello");        // string
-parameter.return(myStack);        // stack/array
-parameter.return(myObject);       // JSON/dict
-```
-
----
-
-## Classes & OOP
-
-CSSL supports object-oriented programming with classes, constructors, and the `this->` keyword for member access.
-
-### Defining a Class
-
-```cssl
-class Person {
-    // Member variables
-    string name;
-    int age;
-
-    // Constructor (same name as class)
-    void Person(string n, int a) {
-        this->name = n;
-        this->age = a;
-    }
-
-    // Methods
-    void greet() {
-        printl("Hello, I'm " + this->name);
-    }
-
-    string getName() {
-        return this->name;
-    }
-
-    void setAge(int a) {
-        this->age = a;
-    }
-}
-```
-
-### Creating Instances
-
-```cssl
-// Use 'new' keyword to instantiate
-Person p = new Person("Alice", 30);
-
-// Call methods
-p.greet();                    // prints: "Hello, I'm Alice"
-string name = p.getName();    // returns "Alice"
-
-// Access members (if public)
-printl(p.name);              // prints: "Alice"
-p.age = 31;                  // set member directly
-```
-
-### The `this->` Keyword
-
-Inside class methods, use `this->` to access instance members:
-
-```cssl
-class Counter {
-    int count;
-
-    void Counter() {
-        this->count = 0;
-    }
-
-    void increment() {
-        this->count = this->count + 1;
-    }
-
-    void add(int n) {
-        this->count = this->count + n;
-    }
-
-    int get() {
-        return this->count;
-    }
-}
-
-Counter c = new Counter();
-c.increment();
-c.add(5);
-printl(c.get());  // prints: 6
-```
-
-### Constructor Variations
-
-```cssl
-class MyClass {
-    // Constructor with same name as class
-    void MyClass(int x) {
-        this->value = x;
-    }
-}
-
-// Alternative: use __init__
-class MyClass2 {
-    void __init__(int x) {
-        this->value = x;
-    }
-}
-```
-
-### Method Chaining
-
-```cssl
-class Builder {
-    string result;
-
-    void Builder() {
-        this->result = "";
-    }
-
-    Builder add(string s) {
-        this->result = this->result + s;
-        return this;
-    }
-
-    string build() {
-        return this->result;
-    }
-}
-
-Builder b = new Builder();
-string result = b.add("Hello ").add("World!").build();
-printl(result);  // prints: "Hello World!"
-```
-
-### Class Inheritance (extends)
-
-CSSL supports class inheritance using the `: extends` syntax:
-
-```cssl
-// Base class
-class Animal {
-    string name;
-
-    void Animal(string n) {
-        this->name = n;
-    }
-
-    void speak() {
-        printl("Some sound");
-    }
-}
-
-// Derived class - inherits all members and methods from Animal
-class Dog : extends Animal {
-    void Dog(string n) {
-        this->name = n;
-    }
-
-    // Override parent method
-    void speak() {
-        printl("Woof! I'm " + this->name);
-    }
-
-    // New method only in Dog
-    void fetch() {
-        printl(this->name + " fetches the ball!");
-    }
-}
-
-Dog d = new Dog("Buddy");
-d.speak();    // "Woof! I'm Buddy"
-d.fetch();    // "Buddy fetches the ball!"
-```
-
-### Extending Python Objects
-
-You can extend Python classes/objects directly:
-
-```cssl
-// Extend a Python object using $
-class ExtendedGame : extends $GameEngine {
-    void newFeature() {
-        printl("New CSSL feature!");
-    }
-
-    // Override a Python method
-    void showUsername() {
-        printl("Custom username display: " + this->username);
-    }
-}
-```
-
-In Python:
-```python
-class GameEngine:
-    def __init__(self):
-        self.username = "Player1"
-    def showUsername(self):
-        print(f"Username: {self.username}")
-
-cssl = CSSL.CsslLang()
-cssl.share('GameEngine', GameEngine())
-cssl.run('''
-    class MyGame : extends $GameEngine {
-        void customMethod() {
-            printl("Extended from Python!");
-        }
-    }
-''')
-```
-
-### Class Overwrites
-
-Use `: overwrites` to replace methods in an existing class/object:
-
-```cssl
-// Overwrite methods in a Python object
-class MyOverrides : extends $GameEngine : overwrites $GameEngine {
-    // This method will REPLACE the original showUsername() in $GameEngine
-    void showUsername() {
-        printl("OVERWRITTEN: " + this->username);
-    }
-}
-```
-
-When you use `: overwrites TargetClass`, all methods defined in your class will replace the corresponding methods in the target. This works with:
-- Other CSSL classes
-- Python objects via `$ObjectName`
-- Shared objects
-
-### python::csslize() - Import Python Objects
-
-Convert Python objects to CSSL-compatible wrappers:
-
-```cssl
-// Import a Python object
-py_obj <== python::csslize($MyPythonInstance);
-
-// Now use it like a CSSL object
-py_obj.someMethod();
-printl(py_obj.someProperty);
-
-// Or use it as a base class
-class Extended : extends py_obj {
-    void newMethod() { ... }
-}
-```
-
-In Python:
-```python
-class MyPythonClass:
-    def __init__(self, name):
-        self.name = name
-    def greet(self):
-        return f"Hello, {self.name}!"
-
-cssl = CSSL.CsslLang()
-cssl.share('MyPython', MyPythonClass("World"))
-result = cssl.run('''
-    py_obj <== python::csslize($MyPython);
-    printl(py_obj.greet());  // "Hello, World!"
-''')
-```
-
-### Function Extends & Overwrites
-
-Functions can also extend or overwrite other functions:
-
-```cssl
-// Base function
-define baseFunction() {
-    string greeting = "Hello";
-    int count = 42;
-    printl(greeting);
-}
-
-// Extend: inherit local variables from baseFunction
-define extendedFunc : extends baseFunction() {
-    // 'greeting' and 'count' are available here!
-    printl(greeting + " World! Count: " + count);
-}
-
-// Overwrite: replace the original function
-define myReplacement : overwrites baseFunction() {
-    printl("This replaces baseFunction entirely!");
-}
-
-// After defining myReplacement, calling baseFunction()
-// will now execute myReplacement instead
-baseFunction();  // prints: "This replaces baseFunction entirely!"
-```
-
-Overwriting Python functions:
-```cssl
-// Replace a shared Python function
-define myVersion : overwrites $pythonFunc() {
-    printl("CSSL implementation replaces Python!");
-}
-```
-
-### Non-Null Declarations
-
-Use `*` prefix to declare non-nullable items:
-
-```cssl
-// Non-null variable - can never be None
-vector<dynamic> *myList;  // Always initialized, never null
-
-// Non-null function - must never return None
-define *alwaysReturns() {
-    return "Always a value";  // Error if returns null
-}
-
-// Non-null class - all methods return non-null
-class *MyClass {
-    string getValue() {
-        return "Value";  // All methods must return non-null
-    }
-}
-
-// Non-null open parameter - filters out None values
-define process(open *Params) {
-    // Params will never contain None values
-    foreach item in Params {
-        printl(item);  // Guaranteed non-null
-    }
-}
-```
-
-### Class Constructors with `constr` Keyword
-
-The `constr` keyword defines explicit constructors inside classes. Multiple constructors can be defined and will be executed in order.
-
-```cssl
-// Class with constructor parameters in declaration
-class Vehicle (string brand, int year) {
-    string make;
-    int modelYear;
-
-    // Constructor using constr keyword
-    constr Initialize() {
-        // brand and year are available from class parameters
-        this->make = brand;
-        this->modelYear = year;
-    }
-
-    // Additional constructor - executed after Initialize
-    constr SetupDefaults() {
-        printl("Vehicle created: " + this->make);
-    }
-}
-
-Vehicle v = new Vehicle("Toyota", 2024);
-```
-
-### Constructor Inheritance with `super()`
-
-Use `super()` to call parent class constructors and methods:
-
-```cssl
-class Animal {
-    string name;
-
-    void Animal(string n) {
-        this->name = n;
-    }
-
-    void speak() {
-        printl("Generic sound");
-    }
-}
-
-class Dog : extends Animal {
-    string breed;
-
-    constr DogInit(string n, string b) {
-        super(n);  // Call parent constructor with name
-        this->breed = b;
-    }
-
-    void speak() {
-        super::speak();  // Call parent's speak method
-        printl("Woof! I'm " + this->name);
-    }
-}
-
-Dog d = new Dog("Buddy", "Labrador");
-d.speak();
-// Output:
-// Generic sound
-// Woof! I'm Buddy
-```
-
-### Constructor Extends with Arguments
-
-Pass arguments to parent constructors in class declaration:
-
-```cssl
-class Parent {
-    int value;
-
-    void Parent(int v) {
-        this->value = v;
-    }
-}
-
-// Pass arguments to parent constructor using extends (arg1, arg2)
-class Child : extends Parent ("defaultValue") {
-    constr ChildInit() {
-        // Parent constructor already called with "defaultValue"
-        printl("Child value: " + this->value);
-    }
-}
-```
-
-### Method-Level Extends & Overwrites
-
-Functions and methods can extend or overwrite specific methods in parent classes using `::` syntax:
-
-```cssl
-class Base {
-    constr Init() {
-        printl("Base init");
-    }
-
-    void process() {
-        printl("Base processing");
-    }
-}
-
-class Derived : extends Base {
-    // Extend specific parent constructor
-    constr DerivedInit() :: extends Base::Init {
-        // Base::Init local vars are available here
-        printl("Derived init");
-    }
-
-    // Or define a method that extends parent method
-    define customProcess :: extends Base::process() {
-        // Has access to Base::process local variables
-        printl("Extended processing");
-    }
-}
-```
-
-### Append Mode with `++` Operator
-
-The `++` append operator allows you to extend constructors and functions by keeping the original code and adding new code. This is useful for extending behavior without completely replacing it.
-
-#### Basic Function Append
-
-```cssl
-// Original function
-define BaseFunc() {
-    printl("Base functionality");
-}
-
-// Append to BaseFunc - keeps original + adds new
-define ExtendedFunc() &BaseFunc ++ {
-    printl("Extended functionality");
-}
-
-ExtendedFunc();
-// Output:
-// Base functionality
-// Extended functionality
-```
-
-#### Constructor Append with Class Reference
-
-```cssl
-class MyClass {
-    constr MyClassConstructor() {
-        printl("MyClass constructor");
-        this->value = 10;
-    }
-}
-
-class BetterClass :: extends MyClass {
-    // Append to specific parent constructor
-    constr BetterConstructor() &MyClass::MyClassConstructor ++ {
-        printl("BetterClass - added code");
-        this->extra = 20;
-    }
-}
-
-$instance = new BetterClass();
-// Output:
-// MyClass constructor
-// BetterClass - added code
-printl($instance.value);  // 10
-printl($instance.extra);  // 20
-```
-
-#### Method Append
-
-```cssl
-class Parent {
-    define greet() {
-        printl("Hello from Parent");
-    }
-}
-
-class Child :: extends Parent {
-    // Append to parent method
-    define betterGreet() &Parent::greet ++ {
-        printl("And also from Child!");
-    }
-}
-
-$child = new Child();
-$child.betterGreet();
-// Output:
-// Hello from Parent
-// And also from Child!
-```
-
-#### Dynamic Instance Reference
-
-You can also reference methods from instances using `&$instanceVar::member`:
-
-```cssl
-global $myInstance = new SomeClass();
-
-class Extended {
-    define extendedMethod() &$myInstance::originalMethod ++ {
-        printl("Added to instance method");
-    }
-}
-```
-
-#### Append Mode Syntax Summary
-
-| Syntax | Description |
-|--------|-------------|
-| `&FunctionName ++` | Append to a function |
-| `&ClassName::member ++` | Append to a class member (constructor/method) |
-| `&$instanceVar::member ++` | Append to an instance member |
-| `&ClassName::constructors ++` | Append to all constructors of a class |
-
----
-
-## Map Container
-
-The `map<>` type provides C++ style ordered key-value storage.
-
-### Creating Maps
-
-```cssl
-map<string, int> ages;
-map<string, string> config;
-```
-
-### Basic Operations
-
-```cssl
-map<string, int> ages;
-
-// Insert values
-ages.insert("Alice", 30);
-ages.insert("Bob", 25);
-
-// Find values
-int age = ages.find("Alice");  // returns 30
-
-// Check existence
-if (ages.contains("Alice")) {
-    printl("Found!");
-}
-
-// Erase entries
-ages.erase("Bob");
-
-// Get with exception if not found
-int a = ages.at("Alice");  // throws if not found
-
-// Size and empty check
-int size = ages.size();
-bool empty = ages.empty();
-```
-
-### Iteration and Bounds
-
-```cssl
-map<string, int> data;
-data.insert("apple", 1);
-data.insert("banana", 2);
-data.insert("cherry", 3);
-
-// Get first/last elements
-tuple first = data.begin();  // ("apple", 1)
-tuple last = data.end();     // ("cherry", 3)
-
-// Find bounds (for sorted keys)
-string lb = data.lower_bound("b");  // "banana" (first key >= "b")
-string ub = data.upper_bound("b");  // "cherry" (first key > "b")
-```
-
----
-
-## Structures
-
-Structures are user-defined data types.
-
-```cssl
-structure Person {
-    string name;
-    int age;
-    string email;
-}
-
-// Create instance
-Person user;
-user.name = "Max";
-user.age = 25;
-user.email = "max@example.com";
-
-printl(user.name);   // "Max"
-printl(user.age);    // 25
-```
-
-### With Functions
-
-```cssl
-structure Rectangle {
-    int width;
-    int height;
-}
-
-int calculateArea(Rectangle rect) {
-    return rect.width * rect.height;
+try {
+    riskyOperation();
+} catch (error) {
+    printl("Error: " + error);
 }
 
-Rectangle r;
-r.width = 10;
-r.height = 5;
-int area = calculateArea(r);
-printl(area);  // 50
-```
-
----
-
-## Error Handling
-
-### Try / Catch
-
-```cssl
 try {
-    // Risky code
-    int result = riskyOperation();
-    printl(result);
-} catch {
-    printl("An error occurred");
+    operation();
+} catch (error) {
+    printl("Error");
+} finally {
+    printl("Always runs");
 }
 ```
 
-### With undefined
+### Undefined Functions
 
 ```cssl
 undefined void safeOperation() {
-    // Errors are silently ignored
-    dangerousCode();
+    dangerousCode();  // Errors ignored
 }
-
-safeOperation();  // No crash
 ```
 
----
-
-## CLI Commands
-
-### Execute
-
-```bash
-# Execute CSSL file
-python -m includecpp cssl exec script.cssl
-
-# Execute CSSL code directly
-python -m includecpp cssl exec -c "printl('Hello');"
-```
-
-### Create Module
-
-```bash
-# From Python file
-python -m includecpp cssl makemodule mylib.py -o mylib.cssl-mod
-
-# With output path
-python -m includecpp cssl makemodule src/utils.py -o modules/utils.cssl-mod
-```
-
-### Help
-
-```bash
-python -m includecpp cssl --help
-python -m includecpp cssl exec --help
-python -m includecpp cssl makemodule --help
-```
-
----
-
-## Examples
-
-### Tkinter GUI Calendar
+### Assert
 
 ```cssl
-// Import modules
-@Gui = include("modules/tkgui.cssl-mod");
-
-// Global state
-global currentMonth = 0;
-global currentYear = 0;
-
-// Initialize
-void init() {
-    @currentYear = @Gui.get_current_year();
-    @currentMonth = @Gui.get_current_month();
-}
-
-// Build calendar
-void buildCalendar() {
-    stack<string> days;
-    days.push("Mo");
-    days.push("Tu");
-    days.push("We");
-    days.push("Th");
-    days.push("Fr");
-    days.push("Sa");
-    days.push("Su");
-
-    // Header with for-loop
-    for (i in range(0, 7)) {
-        @Gui.add_label(days[i], i * 40, 50);
-    }
-
-    // Days with C-style for
-    int daysInMonth = @Gui.get_days_in_month(@currentYear, @currentMonth);
-    for (int d = 1; d <= daysInMonth; d++) {
-        @Gui.add_button("" + d, d);
-    }
-}
-
-// Main
-init();
-@Gui.create_window("CSSL Calendar", 350, 400);
-buildCalendar();
-@Gui.run();
+assert(x > 0, "x must be positive");
 ```
 
 ---
 
-### Task Manager with CodeInfusion
-
-```cssl
-global tasks = stack<string>;
-
-void addTask(string task) {
-    @tasks.push(task);
-    printl("+ " + task);
-}
-
-void showTasks() {
-    printl("=== Tasks ===");
-    foreach (task in @tasks) {
-        printl("- " + task);
-    }
-}
-
-void completeTask() {
-    string done = @tasks.pop();
-    printl("Completed: " + done);
-}
-
-// Add logging via CodeInfusion
-addTask() +<<== {
-    printl("[LOG] Adding task...");
-}
-
-// Exit handler
-exit() <<== {
-    printl("Shutting down Task Manager...");
-}
-
-// Application
-addTask("Write code");
-addTask("Run tests");
-addTask("Update documentation");
-showTasks();
-completeTask();
-exit();
-```
-
----
-
-### Data Pipeline with BruteInjection
-
-```cssl
-// Source data
-stack<string> rawData;
-rawData.push("Alice");
-rawData.push("Bob");
-rawData.push("Charlie");
-rawData.push("Alex");
-rawData.push("Anna");
-
-// Filter: Only names containing "A"
-datastruct<string> aNames;
-aNames +<== [string::contains="A"] rawData;
-
-// Output
-printl("Names with A:");
-foreach (name in aNames) {
-    printl("  - " + name);
-}
-// Output: Alice, Alex, Anna
-```
-
----
-
-### Python-CSSL Bridge
-
-```python
-from includecpp import CSSL
-
-CSSL.CsslLang()
-
-# Syntax checker in CSSL
-checker = """
-global errors = stack<string>;
-
-void checkLine(string line) {
-    if (line.startsWith("def ") && !line.endsWith(":")) {
-        @errors.push("Missing colon after def");
-    }
-    if (line.startsWith("if ") && !line.endsWith(":")) {
-        @errors.push("Missing colon after if");
-    }
-}
-
-define analyze() {
-    string code = parameter.get(0);
-    stack<string> lines = code.split("\\n");
-
-    foreach (line in lines) {
-        checkLine(line);
-    }
-
-    if (len(@errors) == 0) {
-        parameter.return("OK");
-    } else {
-        parameter.return(@errors);
-    }
-}
-
-analyze();
-"""
-
-# Check Python code
-test_code = """def hello()
-    print("world")"""
-
-result = CSSL.exec(checker, test_code)
-print(result)  # ["Missing colon after def"]
-```
-
----
-
-## Reference Table
+## Quick Reference
 
 ### Keywords
 
 | Keyword | Description |
 |---------|-------------|
-| `void` | Function without return |
+| `void` | No return value |
 | `return` | Return value |
-| `global` | Declare global variable |
-| `r@` | Alternative global syntax |
-| `@` | Access global variable |
-| `if` / `else if` / `else` | Conditions |
+| `global` | Declare global |
+| `if` / `else` / `elif` | Conditionals |
 | `switch` / `case` / `default` | Switch statement |
 | `for` / `foreach` / `while` | Loops |
 | `break` / `continue` | Loop control |
-| `try` / `catch` | Error handling |
+| `try` / `catch` / `finally` | Error handling |
+| `class` / `new` / `this` | OOP |
+| `extends` / `overwrites` | Inheritance |
+| `constr` | Constructor |
+| `define` | Function definition |
 | `undefined` | Ignore errors |
-| `dynamic` | Dynamic type |
-| `define` | Constant function |
-| `closed` | Block external injection |
-| `private` | Block all injections |
-| `virtual` | Import-cycle-safe |
-| `meta` | Source function |
-| `super` | Forced execution |
+| `closed` / `private` | Injection protection |
+| `virtual` | Import-safe |
+| `meta` / `super` | Special function types |
 | `shuffled` | Multiple returns |
 | `open` | Any parameters |
-| `structure` | User-defined type |
-| `include` | Import module |
+| `include` / `get` | Import modules |
 
 ### Injection Operators
 
 | Operator | Type | Description |
 |----------|------|-------------|
 | `<<==` | CodeInfusion | Replace function |
-| `+<<==` | CodeInfusion | Add code (before) |
+| `+<<==` | CodeInfusion | Add code before |
 | `-<<==` | CodeInfusion | Remove code |
-| `<==` | ValueCapture | Capture/assign value |
+| `<==` | ValueCapture | Capture/assign |
 | `+<==` | BruteInjection | Copy data |
 | `-<==` | BruteInjection | Move data |
 | `==>` | BruteInjection | Replace data |
-| `==>-` | BruteInjection | Remove matching items |
-| `++` | AppendMode | Append to parent (with `&ref`) |
+| `==>-` | BruteInjection | Remove matching |
+| `++` | AppendMode | Append to parent |
 
 ### Special Syntax
 
 | Syntax | Description |
 |--------|-------------|
-| `%identifier` | Capture value at registration time |
-| `json::func()` | Namespace function call |
-| `@name` | Access global variable |
-| `$name` | Access shared Python object |
-| `s@name` | Self-reference to struct |
-| `r@name` | Global variable declaration |
-| `&ClassName::member` | Reference class member for append mode |
-| `&$instance::member` | Reference instance member for append mode |
-| `&FunctionName ++` | Append to function (keeps old + adds new) |
-
----
-
-## Tips & Best Practices
-
-1. **Type Safety**: Use explicit types instead of `dynamic` for better performance
-2. **Global Variables**: Use sparingly, always access with `@`
-3. **For Loops**: Python-style for simple iterations, C-style when `++`/`--` needed
-4. **CodeInfusion**: Protect with `closed`/`private` when necessary
-5. **Modules**: Python modules for complex logic, CSSL for business logic
-6. **Error Handling**: `try/catch` for external calls, `undefined` for optional operations
-7. **String Operations**: Use built-in methods instead of manual manipulation
-8. **Live Objects**: Use `$name` syntax for bidirectional Python-CSSL data sharing
+| `@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 |
 
 ---
 
-*CSSL v3.6.3 - Developed as part of IncludeCPP*
+*CSSL v4.0.0 - Developed as part of IncludeCPP*