string.length: int                              // Property, not method
string.lower(): string                          // "Hello" → "hello"
string.upper(): string                          // "Hello" → "HELLO"
string.trim(): string                           // "  hi  " → "hi"
string.trim_start(): string                     // "  hi  " → "hi  "
string.trim_end(): string                       // "  hi  " → "  hi"
string.contains(sub: string): bool              // "hello".contains("ell") → true
string.starts_with(prefix: string): bool        // "hello".starts_with("he") → true
string.ends_with(suffix: string): bool          // "hello".ends_with("lo") → true
string.replace(old: string, new: string): string // "aaba".replace("a", "x") → "xxbx"
string.replace_first(old: string, new: string): string
string.split(sep: string): array[string]        // "a,b,c".split(",") → ["a","b","c"]
string.slice(start: int, end: int?): string     // "hello".slice(1,3) → "el"
string.index_of(sub: string): int?              // "hello".index_of("ll") → 2, null if not found
string.pad_start(length: int, fill: string = " "): string
string.pad_end(length: int, fill: string = " "): string
string.repeat(n: int): string                   // "ab".repeat(3) → "ababab"
string.matches(pattern: string): bool           // Simple glob matching (* and ?)
string.is_empty(): bool                         // "".is_empty() → true

array[T].length: int                            // Property
array[T].first: T?                              // Null if empty
array[T].last: T?                               // Null if empty
array[T].is_empty(): bool

// Functional transforms (return new arrays)
array[T].map(fn: (T) => U): array[U]
array[T].filter(fn: (T) => bool): array[T]
array[T].flat_map(fn: (T) => array[U]): array[U]
array[T].sort(fn: ((T, T) => int)?): array[T]   // Comparator optional for primitives
array[T].reverse(): array[T]
array[T].unique(): array[T]                     // Remove duplicates (by value equality)
array[T].take(n: int): array[T]                 // First n elements
array[T].drop(n: int): array[T]                 // Skip first n elements
array[T].slice(start: int, end: int?): array[T]
array[T].zip(other: array[U]): array[{ first: T, second: U }]
array[T].group_by(fn: (T) => K): map[K, array[T]]
array[T].chunk(size: int): array[array[T]]

// Aggregation (reduce to single value)
array[T].sum(fn: ((T) => float)?): float        // fn optional for numeric arrays
array[T].min(fn: ((T) => float)?): T?
array[T].max(fn: ((T) => float)?): T?
array[T].count(fn: ((T) => bool)?): int         // Count matching, or total if no fn
array[T].any(fn: (T) => bool): bool             // True if any element matches
array[T].all(fn: (T) => bool): bool             // True if all elements match
array[T].none(fn: (T) => bool): bool            // True if no element matches
array[T].find(fn: (T) => bool): T?              // First match, or null
array[T].find_index(fn: (T) => bool): int?      // Index of first match, or null
array[T].reduce(fn: (acc: U, item: T) => U, initial: U): U

// Building
array[T].append(item: T): array[T]              // Returns new array with item added
array[T].prepend(item: T): array[T]
array[T].concat(other: array[T]): array[T]
array[T].insert(index: int, item: T): array[T]
array[T].remove_at(index: int): array[T]

// Conversion
array[T].join(sep: string): string              // ["a","b"].join(",") → "a,b"
array[T].to_map(key_fn: (T) => K, val_fn: (T) => V): map[K, V]

// Access
array[T][index: int]: T                         // Index access (0-based, negative from end)
array[T].contains(item: T): bool                // Value equality check

map[K, V].size: int                             // Property
map[K, V].is_empty(): bool
map[K, V].keys(): array[K]
map[K, V].values(): array[V]
map[K, V].entries(): array[{ key: K, value: V }]
map[K, V].contains_key(key: K): bool
map[K, V].get(key: K): V?                       // Null if not found
map[K, V].get_or(key: K, default: V): V
map[K, V][key: K]: V                            // Index access (throws if not found)

// Transforms (return new maps)
map[K, V].set(key: K, value: V): map[K, V]     // Returns new map with key set
map[K, V].remove(key: K): map[K, V]            // Returns new map with key removed
map[K, V].merge(other: map[K, V]): map[K, V]   // other's values win on conflict
map[K, V].map_values(fn: (V) => U): map[K, U]
map[K, V].filter(fn: (K, V) => bool): map[K, V]

abs(x: float | int): float | int
min(a: float | int, b: float | int): float | int
max(a: float | int, b: float | int): float | int
round(x: float, decimals: int = 0): float
floor(x: float): int
ceil(x: float): int
clamp(x: float, low: float, high: float): float

string(value: any): string              // Any value to its string representation
int(value: string | float | bool): int  // Parse/convert to int
float(value: string | int): float       // Parse/convert to float
bool(value: string | int): bool         // "true"/1 → true, "false"/0 → false

now(): datetime                         // Current UTC datetime
today(): date                           // Current UTC date
date(year: int, month: int, day: int): date
datetime(year: int, month: int, day: int, hour: int = 0, min: int = 0, sec: int = 0): datetime
duration(days: int = 0, hours: int = 0, minutes: int = 0, seconds: int = 0, ms: int = 0): duration
parse_date(s: string, format: string?): date        // ISO 8601 default
parse_datetime(s: string, format: string?): datetime

// Date/datetime methods
date.year: int
date.month: int
date.day: int
date.day_of_week: int                   // 1=Monday, 7=Sunday
date.format(pattern: string): string
date.add(d: duration): date
date.diff(other: date): duration

datetime.date: date                     // Extract date part
datetime.hour: int
datetime.minute: int
datetime.second: int
datetime.timestamp_ms: int              // Unix milliseconds
datetime.format(pattern: string): string
datetime.add(d: duration): datetime
datetime.diff(other: datetime): duration
datetime.is_before(other: datetime): bool
datetime.is_after(other: datetime): bool

duration.total_ms: int
duration.total_seconds: float
duration.total_minutes: float
duration.total_hours: float
duration.total_days: float

money.amount: float
money.currency: string                  // ISO 4217 code
money.abs(): money
money.round(decimals: int = 2): money
money.format(): string                  // "€1,234.56" (locale-aware)

generate_id(): uuid                     // Random UUID v4
diff(a: string, b: string): string      // Text diff (for logging/debugging)
hash(value: string, algo: string = "sha256"): string
json_encode(value: any): string         // Serialize to JSON string
json_decode(s: string): any             // Parse JSON string (returns object/array/primitive)
base64_encode(data: bytes): string
base64_decode(s: string): bytes
url_encode(s: string): string
url_decode(s: string): string

log.info(message: string): void
log.warn(message: string): void
log.error(message: string, error: Error?): void
log.debug(message: string): void        // Only in @debug blocks or debug builds

trace.start(operation: string): void    // Start a named span
trace.end(): void                       // End the current span
trace.tag(key: string, value: string): void

execution.id: string                    // Unique execution ID
execution.origin: ExecutionOrigin       // How this execution was triggered
execution.started_at: datetime          // When this execution started
execution.usage: UsageMetrics           // Current metering counters

core.instances.list_active(): array[InstanceInfo]
core.instances.exists(key: string): bool
core.instances.count_active(): int

emit event_name { field1 = value1, field2 = value2 }