version bump

another MI bug fixed, added tests for MI serialization
added test for scope locality
2025-11-17 15:25:26 +01:00 · 2025-11-17 15:09:02 +01:00 · 2025-11-17 14:15:38 +01:00 · 2025-11-17 14:08:32 +01:00 · 2025-11-17 00:28:07 +01:00 · 2025-11-16 00:17:15 +01:00
201 changed files with 16751 additions and 1294 deletions
@@ -1,54 +0,0 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle
-
-name: Java CI with Gradle
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-  workflow_call:
-
-permissions:
-  contents: read
-
-jobs:
-  build:
-    strategy:
-      matrix:
-        include:
-          - target: iosSimulatorArm64Test
-            os: macos-latest
-          - target: jvmTest
-            os: ubuntu-latest
-          - target: linuxX64Test
-            os: ubuntu-latest
-          - target: testDebugUnitTest
-            os: ubuntu-latest
-          - target: testReleaseUnitTest
-            os: ubuntu-latest
-    runs-on: ${{ matrix.os }}
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Validate Gradle Wrapper
-      uses: gradle/actions/wrapper-validation@v3
-    - uses: actions/cache@v3
-      with:
-        path: |
-          ~/.konan
-        key: ${{ runner.os }}-${{ hashFiles('**/.lock') }}
-    - name: Set up JDK 17
-      uses: actions/setup-java@v3
-      with:
-        java-version: '17'
-        distribution: 'temurin'
-    - name: Build with Gradle
-      uses: gradle/gradle-build-action@ce999babab2de1c4b649dc15f0ee67e6246c994f
-      with:
-        arguments: ${{ matrix.target }}
@@ -1,25 +0,0 @@
-name: Publish
-on:
-  release:
-    types: [released, prereleased]
-jobs:
-  publish:
-    name: Release build and publish
-    runs-on: macOS-latest
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Set up JDK 21
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'zulu'
-          java-version: 21
-      - name: Publish to MavenCentral
-        run: ./gradlew publishToMavenCentral --no-configuration-cache
-        env:
-          ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.MAVEN_CENTRAL_USERNAME }}
-          ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.MAVEN_CENTRAL_PASSWORD }}
-          ORG_GRADLE_PROJECT_signingInMemoryKeyId: ${{ secrets.SIGNING_KEY_ID }}
-          ORG_GRADLE_PROJECT_signingInMemoryKeyPassword: ${{ secrets.SIGNING_PASSWORD }}
-          ORG_GRADLE_PROJECT_signingInMemoryKey: ${{ secrets.GPG_KEY_CONTENTS }}
-
@@ -15,3 +15,4 @@ xcuserdata
 /kotlin-js-store/yarn.lock
 /test.lyng
 /sample_texts/1.txt.gz
+/kotlin-js-store/wasm/yarn.lock
@@ -0,0 +1,28 @@
+## Changelog
+
+### Unreleased
+
+- Multiple Inheritance (MI) completed and enabled by default:
+  - Active C3 Method Resolution Order (MRO) for deterministic, monotonic lookup across complex hierarchies and diamonds.
+  - Qualified dispatch:
+    - `this@Type.member(...)` inside class bodies starts lookup at the specified ancestor.
+    - Cast-based disambiguation: `(expr as Type).member(...)`, `(expr as? Type)?.member(...)` (works with existing safe-call `?.`).
+  - Field inheritance (`val`/`var`) under MI:
+    - Instance storage is disambiguated per declaring class; unqualified read/write resolves to the first match in MRO.
+    - Qualified read/write targets the chosen ancestor’s storage.
+  - Constructors and initialization:
+    - Direct bases are initialized left-to-right; each ancestor is initialized at most once (diamond-safe de-duplication).
+    - Header-specified constructor arguments are passed to direct bases.
+  - Visibility enforcement under MI:
+    - `private` visible only inside the declaring class body.
+    - `protected` visible inside the declaring class and any of its transitive subclasses; unrelated contexts cannot access it (qualification/casts do not bypass).
+  - Diagnostics improvements:
+    - Missing member/field messages include receiver class and linearization order; hints for `this@Type` or casts when helpful.
+    - Invalid `this@Type` reports that the qualifier is not an ancestor and shows the receiver lineage.
+    - `as`/`as?` cast errors include actual and target type names.
+
+- Documentation updated (docs/OOP.md and tutorial quick-start) to reflect MI with active C3 MRO.
+
+Notes:
+- Existing single-inheritance code continues to work; resolution reduces to the single base.
+- If code previously relied on non-deterministic parent set iteration, C3 MRO provides a predictable order; disambiguate explicitly if needed using `this@Type`/casts.
@@ -0,0 +1,3 @@
+The Lyng programming language.
+Copyright (c) 2024-2025 Sergey Chernov real.sergeych@gmail.com
+
@@ -2,7 +2,7 @@

 A KMP library and a standalone interpreter

- simple, compact, intuitive and elegant modern code style:
+- simple, compact, intuitive and elegant modern code:

 ```
 class Point(x,y) {
@@ -15,23 +15,31 @@ fun swapEnds(first, args..., last, f) {
 } 
 ```

- extremely simple Kotlin integration on any platform
+- extremely simple Kotlin integration on any platform (JVM, JS, WasmJS, Lunux, MacOS, iOS, Windows)
 - 100% secure: no access to any API you didn't explicitly provide
- 100% coroutines! Every function/script is a coroutine, it does not block the thread, no async/await/suspend keyword garbage:
+- 100% coroutines! Every function/script is a coroutine, it does not block the thread, no async/await/suspend keyword garbage, see [parallelism]

 ```
+  val deferred = launch {
    delay(1.5) // coroutine is delayed for 1.5s, thread is not blocked!
+    "done"
+  }
+  // ...
+  // suspend current coroutine, no thread is blocked again,
+  // and wait for deferred to return something:
+  assertEquals("donw", deferred.await())
 ```
 and it is multithreaded on platforms supporting it (automatically, no code changes required, just
-`launch` more coroutines and they will be executed concurrently if possible)/
+`launch` more coroutines and they will be executed concurrently if possible). See [parallelism]

 - functional style and OOP together, multiple inheritance, implementing interfaces for existing classes, writing extensions.
- Any unicode letters can be used as identifiers: `assert( sin(π/2) == 1 )`.
+- Any Unicode letters can be used as identifiers: `assert( sin(π/2) == 1 )`.

 ## Resources: 

 - [introduction and tutorial](docs/tutorial.md) - start here please
 - [Samples directory](docs/samples)
+- [Books directory](docs)

 ## Integration in Kotlin multiplatform

@@ -84,8 +92,8 @@ import com.sun.source.tree.Scope
 import new.sergeych.lyng.*

 // simple function
-val scope = Scope().apply {
-    addFn("addArgs") {
+val scope = Script.newScope().apply {
+    addFn("sumOf") {
        var sum = 0.0
        for (a in args) sum += a.toDouble()
        ObjReal(sum)
@@ -96,12 +104,14 @@ val scope = Scope().apply {
    // suspend fun doSomeWork(text: String): Int
    addFn("doSomeWork") {
        // this _is_ a suspend lambda, we can call suspend function,
-        // and it won't consume the thread:
-        doSomeWork(args[0].toString()).toObj()
+        // and it won't consume the thread.
+        // note that in kotlin handler, `args` is a list of `Obj` arguments
+        // and return value from this lambda should be Obj too:
+        doSomeWork(args[0]).toObj()
    }
 }
 // adding constant:
-scope.eval("addArgs(1,2,3)") // <- 6
+scope.eval("sumOf(1,2,3)") // <- 6
 ```
 Note that the scope stores all changes in it so you can make calls on a single scope to preserve state between calls.

@@ -119,12 +129,24 @@ Designed to add scripting to kotlin multiplatform application in easy and effici

 - Javascript, WasmJS, native, JVM, android - batteries included.
 - dynamic types in most elegant and concise way
- async, 100% coroutines, supports multiple cores where platofrm supports thread
+- async, 100% coroutines, supports multiple cores where platform supports thread
 - good for functional an object-oriented style

 # Language Roadmap

-## v1.0.0
+```mermaid
+flowchart
+    v0([the idea])
+    v1([v1: make it happen])
+    v2([v1.5: testmake it fasted and rich featured])
+    v3([v2: ideal script language])
+    v0 --code MVP--> v1
+    v1 --refine and extend--> v2
+    v2 -- optimize --> v3
+    
+```
+
+## v1.0.0 "Make it happen"

 Planned autumn 2025. Complete dynamic language with sufficient standard library:

@@ -139,29 +161,41 @@ Ready features:
 - [x] exception handling: throw, try-catch-finally, exception classes.
 - [x] multiplatform maven publication
 - [x] documentation for the current state
+- [x] maps, sets and sequences (flows?)
+- [x] modules
+- [x] string formatting and tools
+- [x] launch, deferred, CompletableDeferred, Mutex, etc.
+- [x] multiline strings
+- [x] typesafe bit-effective serialization
+- [x] compression/decompression (integrated in serialization)
+- [x] dynamic fields
+- [x] function annotations
+- [x] better stack reporting

-Under way: 
+###  Under way: 

- [ ] maps, sets and sequences (flows?)
- [ ] regular exceptions
- [ ] modules
- [ ] string interpolation and more string tools
- [ ] multiple inheritance for user classes
- [ ] launch, deferred, coroutineScope, mutex, etc.
+- [x] regular exceptions + extended `when`
+- [x] multiple inheritance for user classes
 - [ ] site with integrated interpreter to give a try
 - [ ] kotlin part public API good docs, integration focused
- [ ] better stack reporting

-## v1.1+
+## plan: v1.0 - v1.5 "Rich and stable"
+
+Estimated spring of 2026

 Planned features.

 - [ ] type specifications
+- [ ] language server or compose-based lyng-aware editor
 - [ ] source docs and maybe lyng.md to a standard
- [ ] moacro-style kotlin integration or something else to simplify it
+- [ ] metadata first class access from lyng

-Further
+## After 1.5 "Ideal scripting"
+
+Estimated winter 2027

 - [ ] client with GUI support based on compose multiplatform somehow
- [ ] notebook - style workbooks with graphs, formulaes, etc.
- [ ] language server or compose-based lyng-aware editor
+- [ ] notebook - style workbooks with graphs, formulae, etc.
+- [ ] aggressive optimizations
+
+[parallelism]: docs/parallelism.md
@@ -1,5 +1,22 @@
 #!/bin/bash

+#
+# Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#
+
 set -e

 root=./lyng/build/install/lyng-jvm/
@@ -1,5 +1,22 @@
 #!/bin/bash

+#
+# Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#
+
 set -e

 file=./lyng/build/bin/linuxX64/releaseExecutable/lyng.kexe
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 plugins {
    alias(libs.plugins.androidLibrary) apply false
    alias(libs.plugins.kotlinMultiplatform) apply  false
@@ -0,0 +1,37 @@
+# Array
+
+It's an interface if the [Collection] that provides indexing access, like `array[3] = 0`.
+Array therefore implements [Iterable] too. The well known implementatino of the `Array` is
+[List].
+
+Array adds the following methods:
+
+## Binary search
+
+When applied to sorted arrays, binary search allow to quicly find an index of the element in the array, or where to insert it to keep order:
+
+    val coll = [1,2,3,4,5]
+    assertEquals( 2, coll.binarySearch(3) )
+    assertEquals( 0, coll.binarySearch(1) )
+    assertEquals( 4, coll.binarySearch(5) )
+
+    val src = (1..50).toList().shuffled()
+    val result = []
+    for( x in src ) {
+        val i = result.binarySearch(x)
+        assert( i < 0 )
+        result.insertAt(-i-1, x)
+    }
+    assertEquals( src.sorted(), result )
+    >>> void
+
+So `binarySearch(x)` returns:
+
+- index of `x`, a non-negative number
+- negative: `x` not found, but if inserted at position `-returnedValue-1` will leave array sorted.
+
+To pre-sort and array use `Iterable.sorted*` or in-place `List.sort*` families, see [List] and [Iterable] docs.
+
+[Collection]: Collection.md
+[Iterable]: Iterable.md
+[List]: List.md
@@ -102,20 +102,50 @@ As with [List], it is possible to use ranges as indexes to slice a Buffer:

    >>> void

+## Encoding
+
+You can encode `String` to buffer using buffer constructor, as was shown. Also, buffer supports out of the box base64 (
+which is used in `toString`) and hex encoding:
+
+    import lyng.buffer
+    
+    // to UTF8 and back:
+    val b = Buffer("hello")
+    assertEquals( "hello", b.decodeUtf8() )
+    
+    // to base64 and back:
+    assertEquals( b, Buffer.decodeBase64(b.base64) )
+    assertEquals( b, Buffer.decodeHex(b.hex) )
+    >>> void
+
 ## Members

-| name          | meaning                            | type          |
-|---------------|------------------------------------|---------------|
-| `size`        | size                               | Int           |
-| `decodeUtf8`  | decodee to String using UTF8 rules | Any           |
-| `+`           | buffer concatenation               | Any           |
-| `toMutable()` | create a mutable copy              | MutableBuffer |
+| name                       | meaning                                 | type          |
+|----------------------------|-----------------------------------------|---------------|
+| `size`                     | size                                    | Int           |
+| `decodeUtf8`               | decode to String using UTF8 rules       | Any           |
+| `+`                        | buffer concatenation                    | Any           |
+| `toMutable()`              | create a mutable copy                   | MutableBuffer |
+| `hex`                      | encode to hex strign                    | String        |
+| `Buffer.decodeHex(hexStr)  | decode hex string                       | Buffer        |
+| `base64`                   | encode to base64 (url flavor) (2)       | String        |
+| `Buffer.decodeBase64(str)` | decode base64 to new Buffer (2)         | Buffer        |
+| `toBitInput()`             | create bit input from a byte buffer (3) |               |

 (1)
 : optimized implementation that override `Iterable` one

+(2)
+: base64url alphabet is used without trailing '=', which allows string to be used in URI without escaping. Note that
+decoding supports both traditional and URL alphabets automatically, and ignores filling `=` characters. Base64URL is
+well known and mentioned in the internet, for example, [here](https://base64.guru/standards/base64url).
+
+(3)
+: `BitInput` is a bit buffer that is used, for example, in [Lynon.decode](serialization.md)
+
 Also, it inherits methods from [Iterable] and [Array].


 [Range]: Range.md
+
 [Iterable]: Iterable.md
@@ -6,6 +6,12 @@ Is a [Iterable] with known `size`, a finite [Iterable]:
        val size
    }

+| name                   | description                                          |
+|------------------------|------------------------------------------------------|
+
+(1)
+: `comparator(a,b)` should return -1 if `a < b`, +1 if `a > b` or zero.
+
 See [List], [Set] and [Iterable]

 [Iterable]: Iterable.md
@@ -1,5 +1,15 @@
 # Iterable interface

+The interface for anything that can be iterated, e.g. finite or infinite ordered set of data that can be accessed
+sequentially. Almost any data container in `Lyng` implements it: `List`, `Set`, `Buffer`, `RingBuffer`, `BitBuffer`,
+`Range` and many others are `Iterable`, also `Collection` and `Array` interfaces inherit it.
+
+`Map` and `String` have `Iterable` members to access its contents too.
+
+Please see also [Collection] interface: many iterables are also collections, and it adds important features.
+
+## Definition:
+
 Iterable is a class that provides function that creates _the iterator_:

    class Iterable {
@@ -17,23 +27,85 @@ Iterator itself is a simple interface that should provide only to method:

 Just remember at this stage typed declarations are not yet supported.

-Having `Iterable` in base classes allows to use it in for loop. Also, each `Iterable` has some utility functions available:
+Having `Iterable` in base classes allows to use it in for loop. Also, each `Iterable` has some utility functions
+available, for example

-## Instance methods
+    val r = 1..10  // Range is Iterable!  
+    assertEquals( [9,10], r.takeLast(2).toList() )
+    assertEquals( [1,2,3], r.take(3).toList() )
+    assertEquals( [9,10], r.drop(8).toList() )
+    assertEquals( [1,2], r.dropLast(8).toList() )
+    >>> void

-| fun/method      | description                                                                     |
-|-----------------|---------------------------------------------------------------------------------|
-| toList()        | create a list from iterable                                                     |
-| toSet()         | create a set from iterable                                                      |
-| contains(i)     | check that iterable contains `i`                                                |
-| `i in iterator` | same as `contains(i)`                                                           |
-| isEmpty()       | check iterable is empty                                                         |
-| forEach(f)      | call f for each element                                                         |
-| toMap()         | create a map from list of key-value pairs (arrays of 2 items or like)           |
-| map(f)          | create a list of values returned by `f` called for each element of the iterable |
-| indexOf(i)      | return index if the first encounter of i or a negative value if not found       |
-| associateBy(kf) | create a map where keys are returned by kf that will be called for each element |
+## joinToString

+This methods convert any iterable to a string joining string representation of each element, optionally transforming it
+and joining using specified suffix.
+
+    Iterable.joinToString(suffux=' ', transform=null)
+
+- if `Iterable` `isEmpty`, the empty string `""` is returned.
+- `suffix` is inserted between items when there are more than one.
+- `transform` of specified is applied to each element, otherwise its `toString()` method is used.
+
+Here is the sample:
+
+    assertEquals( (1..3).joinToString(), "1 2 3")
+    assertEquals( (1..3).joinToString(":"), "1:2:3")
+    assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
+    >>> void
+
+## `sum` and `sumBy`
+
+These, again, does the thing:
+
+    assertEquals( 6, [1,2,3].sum() )
+    assertEquals( 12, [1,2,3].sumOf { it*2 } )
+
+    // sum of empty collections is null:
+    assertEquals( null, [].sum() )
+    assertEquals( null, [].sumOf { 2*it } )
+
+    >>> void
+
+## Instance methods:
+
+| fun/method             | description                                                                     |
+|------------------------|---------------------------------------------------------------------------------|
+| toList()               | create a list from iterable                                                     |
+| toSet()                | create a set from iterable                                                      |
+| contains(i)            | check that iterable contains `i`                                                |
+| `i in iterator`        | same as `contains(i)`                                                           |
+| isEmpty()              | check iterable is empty                                                         |
+| forEach(f)             | call f for each element                                                         |
+| toMap()                | create a map from list of key-value pairs (arrays of 2 items or like)           |
+| map(f)                 | create a list of values returned by `f` called for each element of the iterable |
+| indexOf(i)             | return index if the first encounter of i or a negative value if not found       |
+| associateBy(kf)        | create a map where keys are returned by kf that will be called for each element |
+| first                  | first element (1)                                                               |
+| last                   | last element (1)                                                                |
+| take(n)                | return [Iterable] of up to n first elements                                     |
+| taleLast(n)            | return [Iterable] of up to n last elements                                      |
+| drop(n)                | return new [Iterable] without first n elements                                  |
+| dropLast(n)            | return new [Iterable] without last n elements                                   |
+| sum()                  | return sum of the collection applying `+` to its elements (3)                   |
+| sumOf(predicate)       | sum of the modified collection items (3)                                        |
+| sorted()               | return [List] with collection items sorted naturally                            |
+| sortedWith(comparator) | sort using a comparator that compares elements (1)                              |
+| sortedBy(predicate)    | sort by comparing results of the predicate function                             |
+| joinToString(s,t)      | convert iterable to string, see (2)                                             |
+| reversed()             | create a list containing items from this in reverse order                       |
+| shuffled()             | create a listof shiffled elements                                               |
+
+(1)
+: throws `NoSuchElementException` if there is no such element
+
+(2)
+: `joinToString(suffix=" ",transform=null)`: suffix is inserted between items if there are more than one, trasnfom is
+optional function applied to each item that must return result string for an item, otherwise `item.toString()` is used.
+
+(3)
+: sum of empty collection is `null`

    fun Iterable.toList(): List
    fun Iterable.toSet(): Set
@@ -43,9 +115,8 @@ Having `Iterable` in base classes allows to use it in for loop. Also, each `Iter
    fun Iterable.forEach(block: (Any?)->Void ): Void
    fun Iterable.map(block: (Any?)->Void ): List
    fun Iterable.associateBy( keyMaker: (Any?)->Any): Map
-    

-## Abstract methods
+## Abstract methods:

    fun iterator(): Iterator

@@ -57,7 +128,14 @@ Creates a list by iterating to the end. So, the Iterator should be finite to be

 ## Implemented in classes:

- [List], [Range]
+- [List], [Range], [Buffer](Buffer.md), [BitBuffer], [Buffer], [Set], [RingBuffer]
+
+[Collection]: Collection.md

 [List]: List.md
-[Range]: Range.md
+
+[Range]: Range.md
+
+[Set]: Set.md
+
+[RingBuffer]: RingBuffer.md
@@ -24,7 +24,7 @@ There is a shortcut for the last:

    val list = [10, 20, 30]
    [list.last, list.lastIndex]
-    >>> [30, 2]
+    >>> [30,2]

 __Important__ negative indexes works wherever indexes are used, e.g. in insertion and removal methods too.

@@ -92,22 +92,45 @@ Open end ranges remove head and tail elements:
    assert( [1, 2, 3] !== [1, 2, 3])
    >>> void

+## In-place sort
+
+List could be sorted in place, just like [Collection] provide sorted copies, in a very like way:
+
+    val l1 = [6,3,1,9]
+    l1.sort()
+    assertEquals( [1,3,6,9], l1)
+    
+    l1.sortBy { -it }
+    assertEquals( [1,3,6,9].reversed(), l1)
+    
+    l1.sort() // 1 3 6 9
+    l1.sortBy { it % 4 }
+    // 1,3,6,9 gives, mod 4:
+    // 1 3 2 1
+    // we hope we got it also stable:
+    assertEquals( [1,9,6,3], l1)
+    >>> void
+
 ## Members

-| name                          | meaning                               | type        |
-|-------------------------------|---------------------------------------|-------------|
-| `size`                        | current size                          | Int         |
-| `add(elements...)`            | add one or more elements to the end   | Any         |
-| `insertAt(index,elements...)` | insert elements at position           | Int, Any    |
-| `removeAt(index)`             | remove element at position            | Int         |
-| `remove(from,toNonInclusive)` | remove range from (incl) to (nonincl) | Int, Int    |
-| `remove(Range)`               | remove range                          | Range       |
-| `removeLast()`                | remove last element                   |             |
-| `removeLast(n)`               | remove n last elements                | Int         |
-| `contains(element)`           | check the element is in the list (1)  |             |
-| `[index]`                     | get or set element at index           | Int         |
-| `[Range]`                     | get slice of the array (copy)         | Range       |
-| `+=`                          | append element(s)                     | List or Obj |
+| name                          | meaning                                      | type        |
+|-------------------------------|----------------------------------------------|-------------|
+| `size`                        | current size                                 | Int         |
+| `add(elements...)`            | add one or more elements to the end          | Any         |
+| `insertAt(index,elements...)` | insert elements at position                  | Int, Any    |
+| `removeAt(index)`             | remove element at position                   | Int         |
+| `remove(from,toNonInclusive)` | remove range from (incl) to (nonincl)        | Int, Int    |
+| `remove(Range)`               | remove range                                 | Range       |
+| `removeLast()`                | remove last element                          |             |
+| `removeLast(n)`               | remove n last elements                       | Int         |
+| `contains(element)`           | check the element is in the list (1)         |             |
+| `[index]`                     | get or set element at index                  | Int         |
+| `[Range]`                     | get slice of the array (copy)                | Range       |
+| `+=`                          | append element(s) (2)                        | List or Obj |
+| `sort()`                      | in-place sort, natural order                 | void        |
+| `sortBy(predicate)`           | in-place sort bu `predicate` call result (3) | void        |
+| `sortWith(comparator)`        | in-place sort using `comarator` function (4) | void        |
+| `shiffle()`                   | in-place shiffle contents                    |             |

 (1)
 : optimized implementation that override `Array` one
@@ -116,7 +139,16 @@ Open end ranges remove head and tail elements:
 : `+=` append either a single element, or all elements if the List or other Iterable
 instance is appended. If you want to append an Iterable object itself, use `add` instead.

-It inherits from [Iterable] too.
+(3)
+: predicate is called on each element, and the returned values are used to sort in natural
+order, e.g. is same as `list.sortWith { a,b -> predicate(a) <=> predicate(b) }`
+
+(4)
+: comparator callable takes tho arguments and must return: negative value when first is less,
+positive if first is greater, and zero if they are equal. For example, the equvalent comparator
+for `sort()` will be `sort { a, b -> a <=> b }
+
+It inherits from [Iterable] too and thus all iterable methods are applicable to any list.

 ## Member inherited from Array

@@ -134,4 +166,5 @@ It inherits from [Iterable] too.


 [Range]: Range.md
+
 [Iterable]: Iterable.md
@@ -71,6 +71,99 @@ Functions defined inside a class body are methods, and unless declared
    void
    >>> void

+## Multiple Inheritance (MI)
+
+Lyng supports declaring a class with multiple direct base classes. The syntax is:
+
+```
+class Foo(val a) {
+    var tag = "F"
+    fun runA() { "ResultA:" + a }
+    fun common() { "CommonA" }
+    private fun privateInFoo() {}
+    protected fun protectedInFoo() {}
+}
+
+class Bar(val b) {
+    var tag = "B"
+    fun runB() { "ResultB:" + b }
+    fun common() { "CommonB" }
+}
+
+// Multiple inheritance with per‑base constructor arguments
+class FooBar(a, b) : Foo(a), Bar(b) {
+    // You can disambiguate via qualified this or casts
+    fun fromFoo() { this@Foo.common() }
+    fun fromBar() { this@Bar.common() }
+}
+
+val fb = FooBar(1, 2)
+assertEquals("ResultA:1", fb.runA())
+assertEquals("ResultB:2", fb.runB())
+// Unqualified ambiguous member resolves to the first base (leftmost)
+assertEquals("CommonA", fb.common())
+// Disambiguation via casts
+assertEquals("CommonB", (fb as Bar).common())
+assertEquals("CommonA", (fb as Foo).common())
+
+// Field inheritance with name collisions
+assertEquals("F", fb.tag)            // unqualified: leftmost base
+assertEquals("F", (fb as Foo).tag)   // qualified read: Foo.tag
+assertEquals("B", (fb as Bar).tag)   // qualified read: Bar.tag
+
+fb.tag = "X"                         // unqualified write updates leftmost base
+assertEquals("X", (fb as Foo).tag)
+assertEquals("B", (fb as Bar).tag)
+
+(fb as Bar).tag = "Y"                 // qualified write updates Bar.tag
+assertEquals("X", (fb as Foo).tag)
+assertEquals("Y", (fb as Bar).tag)
+```
+
+Key rules and features:
+
+- Syntax
+  - `class Derived(args) : Base1(b1Args), Base2(b2Args)`
+  - Each direct base may receive constructor arguments specified in the header. Only direct bases receive header args; indirect bases must either be default‑constructible or receive their args through their direct child (future extensions may add more control).
+
+- Resolution order (C3 MRO — active)
+  - Member lookup is deterministic and follows C3 linearization (Python‑like), which provides a monotonic, predictable order for complex hierarchies and diamonds.
+  - Intuition: for `class D() : B(), C()` where `B()` and `C()` both derive from `A()`, the C3 order is `D → B → C → A`.
+  - The first visible match along this order wins.
+
+- Qualified dispatch
+  - Inside a class body, use `this@Type.member(...)` to start lookup at the specified ancestor.
+  - For arbitrary receivers, use casts: `(expr as Type).member(...)` or `(expr as? Type)?.member(...)` (safe‑call `?.` is already available in Lyng).
+  - Qualified access does not relax visibility.
+
+- Field inheritance (`val`/`var`) and collisions
+  - Instance storage is kept per declaring class, internally disambiguated; unqualified read/write resolves to the first match in the resolution order (leftmost base).
+  - Qualified read/write (via `this@Type` or casts) targets the chosen ancestor’s storage.
+  - `val` remains read‑only; attempting to write raises an error as usual.
+
+- Constructors and initialization
+  - During construction, direct bases are initialized left‑to‑right in the declaration order. Each ancestor is initialized at most once (diamond‑safe de‑duplication).
+  - Arguments in the header are evaluated in the instance scope and passed to the corresponding direct base constructor.
+  - The most‑derived class’s constructor runs after the bases.
+
+- Visibility
+  - `private`: accessible only inside the declaring class body; not visible in subclasses and cannot be accessed via `this@Type` or casts.
+  - `protected`: accessible in the declaring class and in any of its transitive subclasses (including MI), but not from unrelated contexts; qualification/casts do not bypass it.
+
+- Diagnostics
+  - When a member/field is not found, error messages include the receiver class name and the considered linearization order, with suggestions to disambiguate using `this@Type` or casts if appropriate.
+  - Qualifying with a non‑ancestor in `this@Type` reports a clear error mentioning the receiver lineage.
+  - `as`/`as?` cast errors mention the actual and target types.
+
+Compatibility notes:
+
+- Existing single‑inheritance code continues to work unchanged; its resolution order reduces to the single base.
+- If your previous code accidentally relied on non‑deterministic parent set iteration, it may change behavior — the new deterministic order is a correctness fix.
+
+### Migration note (declaration‑order → C3)
+
+Earlier drafts and docs described a declaration‑order depth‑first linearization. Lyng now uses C3 MRO for member lookup and disambiguation. Most code should continue to work unchanged, but in rare edge cases involving diamonds or complex multiple inheritance, the chosen base for an ambiguous member may change to reflect C3. If needed, disambiguate explicitly using `this@Type.member(...)` inside class bodies or casts `(expr as Type).member(...)` from outside.
+
 ## fields and visibility

 It is possible to add non-constructor fields:
@@ -130,6 +223,25 @@ Private fields are visible only _inside the class instance_:
    void
    >>> void

+### Protected members
+
+Protected members are available to the declaring class and all of its transitive subclasses (including via MI), but not from unrelated contexts:
+
+```
+class A() {
+    protected fun ping() { "pong" }
+}
+class B() : A() {
+    fun call() { this@A.ping() }
+}
+
+val b = B()
+assertEquals("pong", b.call())
+
+// Unrelated access is forbidden, even via cast
+assertThrows { (b as A).ping() }
+```
+
 It is possible to provide private constructor parameters so they can be
 set at construction but not available outside the class:

@@ -147,7 +259,7 @@ In many cases it is necessary to implement custom comparison and `toString`, sti
 each class is provided with default implementations:

 - default toString outputs class name and its _public_ fields.
- default comparison compares compares all public fields in order of appearance.
+- default comparison compares all fields in order of appearance.

 For example, for our class Point:

@@ -160,6 +272,47 @@ For example, for our class Point:
    Point(1,1+1)
    >>> Point(x=1,y=2)

+## Statics: class fields and class methods
+
+You can mark a field or a method as static. This is borrowed from Java as more plain version of a kotlin's companion object or Scala's object. Static field and functions is one for a class, not for an instance. From inside the class, e.g. from the class method, it is a regular var. From outside, it is accessible as `ClassName.field` or method:
+
+
+    class Value(x) {
+        static var foo = Value("foo")
+
+        static fun exclamation() {
+            // here foo is a regular var:
+            foo.x + "!"
+        }
+    }
+    assertEquals( Value.foo.x, "foo" )
+    assertEquals( "foo!", Value.exclamation() )
+
+    // we can access foo from outside like this:
+    Value.foo = Value("bar")
+    assertEquals( "bar!", Value.exclamation() )
+    >>> void
+
+As usual, private statics are not accessible from the outside:
+
+    class Test {
+        // private, inacessible from outside protected data:
+        private static var data = null
+
+        // the interface to access and change it:
+        static fun getData() { data }
+        static fun setData(value) { data = value }
+    }
+
+    // no direct access:
+    assertThrows { Test.data }
+
+    // accessible with the interface:
+    assertEquals( null, Test.getData() )
+    Test.setData("fubar")
+    assertEquals("fubar", Test.getData() )
+    >>> void
+
 # Extending classes

 It sometimes happen that the class is missing some particular functionality that can be _added to it_ without rewriting its inner logic and using its private state. In this case _extension methods_ could be used, for example. we want to create an extension method
@@ -194,6 +347,110 @@ as they are modifying the type, not the context.

 Beware of it. We might need to reconsider it later.

+## dynamic symbols
+
+Sometimes it is convenient to provide methods and variables whose names are not known at compile time. For example, it could be external interfaces not known to library code, user-defined data fields, etc. You can use `dynamic` function to create such:
+
+    // val only dynamic object
+    val accessor = dynamic {
+        // all symbol reads are redirected here:
+        get { name ->
+            // lets provide one dynamic symbol:
+            if( name == "foo" ) "bar" else null
+            // consider also throw SymbolNotDefinedException
+        }
+    }
+    
+    // now we can access dynamic "fields" of accessor:
+    assertEquals("bar", accessor.foo)
+    assertEquals(null, accessor.bar)
+    >>> void
+
+The same we can provide writable dynamic fields (var-type), adding set method:
+
+    // store one dynamic field here
+    var storedValueForBar = null
+    
+    // create dynamic object with 2 fields:
+    val accessor = dynamic {
+        get { name ->
+            when(name) {
+                // constant field
+                "foo" -> "bar"
+                // mutable field
+                "bar" -> storedValueForBar 
+
+                else -> throw SymbolNotFoundException()
+            }
+        }
+        set { name, value ->
+            // only 'bar' is mutable:
+            if( name == "bar" )
+                storedValueForBar = value
+                // the rest is immotable. consider throw also
+                // SymbolNotFoundException when needed.
+            else throw IllegalAssignmentException("Can't assign "+name)
+        }
+    }
+    
+    assertEquals("bar", accessor.foo)
+    assertEquals(null, accessor.bar)
+    accessor.bar = "buzz"
+    assertEquals("buzz", accessor.bar)
+    
+    assertThrows {
+        accessor.bad = "!23"
+    }
+    void
+    >>> void
+
+Of course, you can return any object from dynamic fields; returning lambdas let create _dynamic methods_ - the callable method. It is very convenient to implement libraries with dynamic remote interfaces, etc.
+
+### Dynamic indexers
+
+Index access for dynamics is passed to the same getter and setter, so it is
+generally the same:
+
+    var storedValue = "bar"
+    val x = dynamic {
+        get { 
+            if( it == "foo" ) storedValue
+            else null
+        }
+    }
+    assertEquals("bar", x["foo"] )
+    assertEquals("bar", x.foo )
+    >>> void
+
+And assigning them works the same. You can make it working
+mimicking arrays, but remember, it is not Collection so
+collection's sugar won't work with it:
+
+    var storedValue = "bar"
+    val x = dynamic {
+        get { 
+            when(it) {
+                "size" -> 1
+                0 -> storedValue
+                else -> null
+            }
+        }
+        set { index, value -> 
+            if( index == 0 ) storedValue = value
+            else throw "Illegal index: "+index
+        }
+    }
+    assertEquals("bar", x[0] )
+    assertEquals(1, x.size )
+    x[0] = "buzz"
+    assertThrows { x[1] = 1 }
+    assertEquals("buzz", storedValue)
+    assertEquals("buzz", x[0])
+    >>> void
+
+If you want dynamic to function like an array, create a [feature
+request](https://gitea.sergeych.net/SergeychWorks/lyng/issues).
+
 # Theory

 ## Basic principles:
@@ -87,7 +87,7 @@ You can use Char as both ends of the closed range:
 Exclusive end char ranges are supported too:

    ('a'..<'c').toList 
-    >>> ['a', 'b']
+    >>> [a,b]


 # Instance members
@@ -0,0 +1,91 @@
+# Regular expressions
+
+In lyng, you create regular expressions using class `Regex` or `String.re` methods:
+
+    assert( "\d*".re is Regex )
+    assert( Regex("\d*") is Regex )
+    >>> void
+
+We plan to add slash syntax at some point.
+
+To check that some string matches as whole to some regex:
+
+    assert( "123".matches("\d{3}".re) )
+    assert( !"123".matches("\d{4}".re) )
+    assert( !"1234".matches("\d".re) )
+    >>> void
+
+To check that _part of the string_ matches some regular expession, use _match operator_ `=~` just like in Ruby, and its
+counterpart, _not match_ operator `!~`:
+
+    assert( "abc123def" =~ "\d\d\d".re )
+    assert( "abc" !~ "\d\d\d".re )
+    >>> void
+
+When you need to find groups, and more detailed match information, use `Regex.find`:
+
+    val result = Regex("abc(\d)(\d)(\d)").find( "bad456 good abc123")
+    assert( result  != null )
+    assertEquals( 12 .. 17, result.range )
+    assertEquals( "abc123", result[0] )
+    assertEquals( "1", result[1] )
+    assertEquals( "2", result[2] )
+    assertEquals( "3", result[3] )
+    >>> void
+
+Note that the object `RegexMatch`, returned by [Regex.find], behaves much like in many other languages: it provides the
+index range and groups matches as indexes.
+
+Match operator actually also provides `RegexMatch` in `$~` reserved variable (borrowed from Ruby too):
+
+    assert( "bad456 good abc123" =~ "abc(\d)(\d)(\d)".re )
+    assertEquals( 12 .. 17, $~.range )
+    assertEquals( "abc123", $~[0] )
+    assertEquals( "1", $~[1] )
+    assertEquals( "2", $~[2] )
+    assertEquals( "3", $~[3] )
+    >>> void
+
+This is often more readable than calling `find`.
+
+Note that `=~` and `!~` operators against strings and regular expressions are commutative, e.g. regular expression and a
+string can be either left or right operator, but not both:
+
+    assert( "abc" =~ "\wc".re )
+    assert( "abc" !~ "\w1c".re )
+    assert( "a\wc".re =~ "abcd" )
+    assert( "a[a-z]c".re !~ "a2cd" )
+    >>> void
+
+Also, string indexing is Regex-aware, and works like `Regex.find` (_not findall!_):
+
+    assert( "cd" == "abcdef"[ "c.".re ].value )
+    >>> void
+
+
+# Regex class reference
+
+| name         | description                         | notes |
+|--------------|-------------------------------------|-------|
+| matches(str) | true if the whole `str` matches     |       |
+| find(str)    | find first match in `str` or null   | (1)   |
+| findAll(str) | find all matches in `str` as [List] | (1)   |
+
+(1)
+:: See `RegexMatch` class description below
+
+# RegexMatch
+
+| name  | description                               | notes |
+|-------|-------------------------------------------|-------|
+| range | the [Range] of the match in source string |       |
+| value | the value that matches                    |       |
+| [n]   | [List] of group matches                   | (1)   |
+
+(1)
+:: the [0] element is always value, [1] is group 1 match of any, etc.
+
+[List]: List.md
+
+[Range]: Range.md
+
@@ -0,0 +1,52 @@
+# RingBuffer
+
+This is a fixed size buffer that allow to store N last elements with _O(1)_ effectiveness (no data shifting).
+
+Here is the sample:
+
+    val r = RingBuffer(3)
+    assert( r is RingBuffer )
+    assertEquals(0, r.size)
+    assertEquals(3, r.capacity)
+    
+    r += 10
+    assertEquals(1, r.size)
+    assertEquals(10, r.first)
+    
+    r += 20
+    assertEquals(2, r.size)
+    assertEquals( [10, 20], r.toList() )
+    
+    r += 30
+    assertEquals(3, r.size)
+    assertEquals( [10, 20, 30], r.toList() )
+    
+    // now first value is lost:
+    r += 40
+    assertEquals(3, r.size)
+    assertEquals( [20, 30, 40], r.toList() )
+    assertEquals(3, r.capacity)
+
+    >>> void
+
+Ring buffer implements [Iterable], so any of its methods are available for `RingBuffer`, e.g. `first`, `last`, `toList`,
+`take`, `drop`, `takelast`, `dropLast`, etc.
+
+## Constructor
+
+    RinbBuffer(capacity: Int)
+
+## Instance methods
+
+| method      | description            | remarks |
+|-------------|------------------------|---------|
+| capacity    | max size of the buffer |         |
+| size        | current size           | (1)     |
+| operator += | add new item           | (1)     |
+| add(item)   | add new item           | (1)     |
+| iterator()  | return iterator        | (1)     |
+
+(1)
+: Ringbuffer is not threadsafe, protect it with a mutex to avoid RC where necessary.
+
+[Iterable]: Iterable.md
@@ -1,5 +1,7 @@
 # Advanced topics

+__See also:__ [parallelism].
+
 ## Closures/scopes isolation

 Each block has own scope, in which it can safely use closures and override
@@ -110,4 +112,49 @@ arguments list in almost arbitrary ways. For example:
    )
    >>> void

-,
+# Annotations
+
+Annotation in Lyng resembles these proposed for Javascript. Annotation is just regular functions that, if used as annotation, are called when defining a function, var, val or class. 
+
+## Function annotation
+
+When used without params, annotation calls a function with two arguments: actual function name and callable function body. Function annotation __must return callable for the function__, either what it received as a second argument (most often), or something else. Annotation name convention is upper scaled: 
+
+    var annotated = false
+    
+    // this is annotation function:
+    fun Special(name, body) {
+        assertEquals("foo", name)
+        annotated = true
+        { body(it) + 100 }
+    }
+
+    @Special
+    fun foo(value) { value + 1 }
+
+    assert(annotated)
+    assertEquals(111, foo( 10 ))
+    >>> void
+
+Function annotation can have more args specified at call time. There arguments must follow two mandatory ones (name and body). Use default values in order to allow parameterless annotation to be used simultaneously.
+
+    val registered = Map()
+
+    // it is recommended to provide defaults for extra parameters:
+    fun Registered(name, body, overrideName = null) {
+        registered[ overrideName ?: name ] = body
+        body
+    }
+
+    // witout parameters is Ok as we provided default value
+    @Registered
+    fun foo() { "called foo" }
+
+    @Registered("bar") 
+    fun foo2() { "called foo2" }
+
+    assertEquals(registered["foo"](), "called foo")
+    assertEquals(registered["bar"](), "called foo2")
+    >>> void
+
+[parallelism]: parallelism.md
@@ -71,7 +71,7 @@ destructuring arrays when calling functions and lambdas:
        [ first, last ]
    }
    getFirstAndLast( ...(1..10) ) // see "splats" section below
-    >>> [1, 10]
+    >>> [1,10]

 # Splats

@@ -83,7 +83,7 @@ or whatever implementing [Iterable], is called _splats_. Here is how we use it:
    }
    val array = [1,2,3]
    testSplat("start", ...array, "end")
-    >>> ["start", 1, 2, 3, "end"]
+    >>> [start,1,2,3,end]
    >>> void

 There could be any number of splats at any positions. You can splat any other [Iterable] type:
@@ -93,7 +93,7 @@ There could be any number of splats at any positions. You can splat any other [I
    }
    val range = 1..3
    testSplat("start", ...range, "end")
-    >>> ["start", 1, 2, 3, "end"]
+    >>> [start,1,2,3,end]
    >>> void
    

@@ -0,0 +1,26 @@
+# String
+
+# This document is for developer notes only
+
+--------------------------
+
+
+## Interpolation proposal
+
+"""no $iterpolation"""
+    
+    val inpterpolation1 = "foo"
+    "${interpolation1}"
+    >>> "foo"
+
+"$interpolation2"
+"no $$ interpolatino"
+
+
+## Regexp vs div / ?
+
+```EBNF
+regex_literal = "/", { regchar }, "/", [ flag ]
+foag = "i" | "n"....
+regchar = x`x`
+```
@@ -0,0 +1,14 @@
+
+
+Provide:
+
+
+    fun outer(a1)
+        // a1 is caller.a1:arg
+        val a1_local = a1 + 1
+        // we return lambda:
+        { it ->
+            // a1_local
+            a1_lcoal + it
+        }
+    }
@@ -122,6 +122,32 @@ This way, in turn, can also be shortened, as it is overly popular:
 The trick, though, works with strings only, and always provide `Exception` instances, which is good for debugging but
 most often not enough.

+# Exception class
+
+Serializable class that conveys information about the exception. Important members and methods are:
+
+| name              | description                                            |
+|-------------------|--------------------------------------------------------|
+| message           | String message                                         |
+| stackTrace        | lyng stack trace, list of `StackTraceEntry`, see below |
+| printStackTrace() | format and print stack trace using println()           |
+
+## StackTraceEntry
+
+A simple structire that stores single entry in Lyng stack, it is created automatically on exception creation:
+
+```kotlin
+class StackTraceEntry(
+    val sourceName: String,
+    val line: Int,
+    val column: Int,
+    val sourceString: String
+)
+```
+
+- `sourceString` is a line extracted from sources. Note that it _is serialized and printed_, so if you want to conceal it, catch all exceptions and filter out sensitive information.
+
+
 # Custom error classes

 _this functionality is not yet released_
@@ -131,7 +157,7 @@ _this functionality is not yet released_
 | class                      | notes                                                 |
 |----------------------------|-------------------------------------------------------|
 | Exception                  | root of al throwable objects                          |
-| NullReferenceException       |                                                       |
+| NullReferenceException     |                                                       |
 | AssertionFailedException   |                                                       | 
 | ClassCastException         |                                                       |
 | IndexOutOfBoundsException  |                                                       |
@@ -9,17 +9,37 @@ Same as in C++.
 | **Highest**<br>0 | power, not, calls, indexing, dot,... |
 |        1         | `%` `*` `/`                          |
 |        2         | `+` `-`                              |
-|        3         | bit shifts (NI)                      |
+|        3         | bit shifts `<<` `>>`                 |
 |        4         | `<=>` (1)                            |
 |        5         | `<=` `>=` `<` `>`                    |
 |        6         | `==` `!=`                            |
-|        7         | bitwise and `&` (NI)                 |
-|        9         | bitwise or `\|` (NI)                 |
+|        7         | bitwise and `&`                      |
+|        8         | bitwise xor `^`                      |
+|        9         | bitwise or `\|`                      |
 |        10        | `&&`                                 |
 |  11<br/>lowest   | `\|\|`                               |

-(NI)
-: not yet implemented.
+Bitwise operators
+: available only for `Int` values. For mixed `Int`/`Real` numeric expressions, bitwise operators are not defined.
+
+Bitwise NOT `~x`
+: unary operator that inverts all bits of a 64‑bit signed integer (`Int`). It follows two's‑complement rules, so
+  `~x` is numerically equal to `-(x + 1)`. Examples: `~0 == -1`, `~1 == -2`, `~(-1) == 0`.
+
+Examples:
+
+```
+5 & 3    // -> 1
+5 | 3    // -> 7
+5 ^ 3    // -> 6
+~0       // -> -1
+1 << 3   // -> 8
+8 >> 3   // -> 1
+```
+
+Notes:
+- Shifts operate on 64-bit signed integers (`Int` is 64-bit). Right shift `>>` is arithmetic (sign-propagating).
+- Shift count is masked to the range 0..63, similar to the JVM/Kotlin behavior (e.g., `1 << 65` equals `1 << 1`).

 (1)
 : Shuttle operator: `a <=> b` returns 0 if a == b, negative Int if a < b and positive Int otherwise. It is necessary to
@@ -0,0 +1,221 @@
+# Parallelism in Lyng
+
+Lyng is built to me multithreaded where possible (e.g. all targets byt JS and wasmJS as for now)
+and cooperatively parallel (coroutine based) everywhere.
+
+In Lyng, every function, every lambda are _coroutines_. It means, you can have as many of these as you want without risking running out of memory on threads stack, or get too many threads.
+
+Depending on the platform, these coroutines may be executed on different CPU and cores, too, truly in parallel. Where not, like Javascript browser, they are still executed cooperatively. You should not care about the platform capabilities, just call `launch`:
+
+    // track coroutine call: 
+    var xIsCalled = false
+
+    // launch coroutine in parallel
+    val x = launch { 
+        // wait 10ms to let main code to be executed
+        delay(10)
+        // now set the flag
+        xIsCalled = true
+        // and return something useful:
+        "ok"
+    }
+    // corouine is launhed, but not yet executed
+    // due to delay call:
+    assert(!xIsCalled)
+    
+    // now we wait for it to be executed:
+    assertEquals( x.await(), "ok")
+
+    // now glag should be set:
+    assert(xIsCalled)
+    >>> void
+
+This example shows how to launch a coroutine with `launch` which returns [Deferred] instance, the latter have ways to await for the coroutine completion and retrieve possible result.
+
+Launch has the only argument which should be a callable (lambda usually) that is run in parallel (or cooperatively in parallel), and return anything as the result.
+
+## Synchronization: Mutex
+
+Suppose we have a resource, that could be used concurrently, a counter in our case. If we won't protect it, concurrent usage cause RC, Race Condition, providing wrong result:
+
+    var counter = 0
+    
+    (1..50).map { 
+        launch {
+            // slow increment:
+            val c = counter
+            delay(100)
+            counter = c + 1
+        }
+    }.forEach { it.await() }
+    assert(counter < 50) { "counter is "+counter }
+    >>> void
+
+The obviously wrong result is not 4, as all coroutines capture the counter value, which is 1, then sleep for 5ms, then save 1 + 1 as result. May some coroutines will pass, so it will be 1 or 2, most likely.
+
+Using [Mutex] makes it all working:
+
+    var counter = 0
+    val mutex = Mutex()
+    
+    (1..4).map { 
+        launch {
+            // slow increment:
+            mutex.withLock {
+                val c = counter
+                delay(10)
+                counter = c + 1
+            }
+        }
+    }.forEach { it.await() }
+    assertEquals(4, counter)
+    >>> void
+
+now everything works as expected: `mutex.withLock` makes them all be executed in sequence, not in parallel.
+
+
+## Completable deferred
+
+Sometimes it is convenient to manually set completion status of some deferred result. This is when [CompletableDeferred] is used:
+
+    // this variable will be completed later:
+    val done = CompletableDeferred()
+    
+    // complete it ater delay
+    launch { 
+        delay(10)
+        // complete it setting the result:
+        done.complete("ok")
+    }
+    
+    // now it is still not completed: coroutine is delayed
+    // (ot not started on sinthe-threaded platforms):
+    assert(!done.isCompleted)
+    assert(done.isActive)
+
+    // then we can just await it as any other deferred:
+    assertEquals( done.await(), "ok")
+    // and as any other deferred it is now complete:
+    assert(done.isCompleted)
+
+## True parallelism
+
+Cooperative, coroutine-based parallelism is automatically available on all platforms. Depending on the platform, though, the coroutines could be dispatched also in different threads; where there are multiple cores and/or CPU available, it means the coroutines could be exuted truly in parallel, unless [Mutex] is used:
+
+| platofrm   | multithreaded |
+|------------|---------------|
+| JVM        | yes           |
+| Android    | yes           |
+| Javascript | NO            |
+| wasmJS     | NO            |
+| IOS        | yes           |
+| MacOSX     | yes           |
+| Linux      | yes           |
+| Windows    | yes           |
+
+So it is important to always use [Mutex] where concurrent execution could be a problem (so called Race Conditions, or RC).
+
+## Yield
+
+When the coroutine is executed, on the single-threaded environment all other coroutines are suspended until active one will wait for something. Sometimes, it is undesirable; the coroutine may perform long calculations or some other CPU consuming task. The solution is to call `yield()` periodically. Unlike `delay()`, yield does not pauses the coroutine for some specified time, but it just makes all other coroutines to be executed. In other word, yield interrupts current coroutines and out it to the end of the dispatcher list of active coroutines. It is especially important on Javascript and wasmJS targets as otherwise UI thread could be blocked. 
+
+Usage example:
+
+    fun someLongTask() { // ...
+        do {
+            // execute step
+            if( done ) break
+            yield()
+        } while(true)
+    }
+
+# Data exchange for coroutines
+
+## Flow
+
+Flow is an async cold sequence; it is named after kotlin's Flow as it resembles it closely. The cold means the flow is only evaluated when iterated (collected, in Kotlin terms), before it is inactive. Sequence means that it is potentially unlimited, as in our example of glorious Fibonacci number generator:
+
+    // Fibonacch numbers flow! 
+    val f = flow {
+        println("Starting generator")
+        var n1 = 0
+        var n2 = 1
+        emit(n1)
+        emit(n2)
+        while(true) {
+            val n = n1 + n2
+            emit(n)
+            n1 = n2
+            n2 = n
+        }
+    }
+    val correctFibs = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
+    println("Generation starts")
+    assertEquals( correctFibs, f.take(correctFibs.size))
+    >>> Generation starts
+    >>> Starting generator
+    >>> void
+
+Great: the generator is not executed until collected bu the `f.take()` call, which picks specified number of elements from the flow, can cancel it.
+
+Important difference from the channels or like, every time you collect the flow, you collect it anew:
+
+    var isStarted = false
+    val f = flow {
+            emit("start")
+            isStarted = true
+            (1..4).forEach { emit(it) }
+    }
+    // flow is not yet started, e.g. not got execited, 
+    // that is called 'cold':
+    assertEquals( false, isStarted )
+
+    // let's collect flow:
+    val result = []
+    for( x in f ) result += x
+    println(result)
+
+    assertEquals( true, isStarted)
+
+    // let's collect it once again, it should be the same:
+    println(f.toList())
+
+    // and again:
+    assertEquals( result, f.toList() )
+
+    >>> [start,1,2,3,4]
+    >>> [start,1,2,3,4]
+    >>> void
+
+Notice that flow's lambda is not called until actual collection is started. Cold flows are
+better in terms of resource consumption.
+
+Flows allow easy transforming of any [Iterable]. See how the standard Lyng library functions use it:
+
+    fun Iterable.filter(predicate) {
+        val list = this
+        flow {
+            for( item in list ) {
+                if( predicate(item) ) {
+                    emit(item)
+                }
+            }
+        }
+    }
+
+
+[Iterable]: Iterable.md
+
+## Scope frame pooling (JVM)
+
+Lyng includes an optional optimization for function/method calls on JVM: scope frame pooling, toggled by the runtime flag `PerfFlags.SCOPE_POOL`.
+
+- Default: `SCOPE_POOL` is OFF on JVM.
+- Rationale: the current `ScopePool` implementation is not thread‑safe. Lyng targets multi‑threaded execution on most platforms, therefore we keep pooling disabled by default until a thread‑safe design is introduced.
+- When safe to enable: single‑threaded runs (e.g., micro‑benchmarks or scripts executed on a single worker) where no scopes are shared across threads.
+- How to toggle at runtime (Kotlin/JVM tests):
+  - `PerfFlags.SCOPE_POOL = true` to enable.
+  - `PerfFlags.SCOPE_POOL = false` to disable.
+- Expected effect (from our JVM micro‑benchmarks): in deep call loops, enabling pooling reduced total time by about 1.38× in a dedicated pooling benchmark; mileage may vary depending on workload.
+
+Future work: introduce thread‑safe pooling (e.g., per‑thread pools or confinement strategies) before considering enabling it by default in multi‑threaded environments.
@@ -0,0 +1,620 @@
+
+This document explains how to enable and measure the performance optimizations added to the Lyng interpreter. The focus is JVM‑first with safe, flag‑guarded rollouts and quick A/B testing. Other targets (JS/Wasm/Native) keep conservative defaults until validated.
+
+## Overview
+
+Optimizations are controlled by runtime‑mutable flags in `net.sergeych.lyng.PerfFlags`, initialized from platform‑specific static defaults `net.sergeych.lyng.PerfDefaults` (KMP `expect/actual`).
+
+- JVM/Android defaults are aggressive (e.g. `RVAL_FASTPATH=true`).
+- Non‑JVM defaults are conservative (e.g. `RVAL_FASTPATH=false`).
+
+All flags are `var` and can be flipped at runtime (e.g., from tests or host apps) for A/B comparisons.
+
+### Workload presets (JVM‑first)
+
+To simplify switching between recommended flag sets for different workloads, use `net.sergeych.lyng.PerfProfiles`:
+
+```
+val snap = PerfProfiles.apply(PerfProfiles.Preset.BENCH)  // or BASELINE / BOOKS
+// ... run workload ...
+PerfProfiles.restore(snap)  // restore previous flags
+```
+
+- BASELINE: restores platform defaults from `PerfDefaults` (good rollback point).
+- BENCH: expression‑heavy micro‑bench focus (aggressive R‑value and PIC optimizations on JVM).
+- BOOKS: documentation workloads (prefers simpler paths; disables some PIC/arg builder features shown neutral/negative for this load in A/B).
+
+## Key flags
+
+- `LOCAL_SLOT_PIC` — Runtime cache in `LocalVarRef` to avoid repeated name→slot lookups per frame (ON JVM default).
+- `EMIT_FAST_LOCAL_REFS` — Compiler emits `FastLocalVarRef` for identifiers known to be locals/params (ON JVM default).
+- `ARG_BUILDER` — Efficient argument building: small‑arity no‑alloc and pooled builder on JVM (ON JVM default).
+- `ARG_SMALL_ARITY_12` — Extends small‑arity no‑alloc call paths from 0–8 to 0–12 arguments (JVM‑first exploration; OFF by default). Use for codebases with many 9–12 arg calls; A/B before enabling.
+- `SKIP_ARGS_ON_NULL_RECEIVER` — Early return on optional‑null receivers before building args (semantics‑compatible). A/B only.
+- `SCOPE_POOL` — Scope frame pooling for calls (JVM, per‑thread ThreadLocal pool). ON by default on JVM; togglable at runtime.
+- `FIELD_PIC` — 2‑entry polymorphic inline cache for field reads/writes keyed by `(classId, layoutVersion)` (ON JVM default).
+- `METHOD_PIC` — 2‑entry PIC for instance method calls keyed by `(classId, layoutVersion)` (ON JVM default).
+- `FIELD_PIC_SIZE_4` — Increases Field PIC size from 2 to 4 entries (JVM-first tuning; OFF by default). Use for sites with >2 receiver shapes.
+- `METHOD_PIC_SIZE_4` — Increases Method PIC size from 2 to 4 entries (JVM-first tuning; OFF by default).
+- `PIC_ADAPTIVE_2_TO_4` — Adaptive growth of Field/Method PICs from 2→4 entries per-site when miss rate >20% over ≥256 accesses (JVM-first; OFF by default).
+- `INDEX_PIC` — Enables polymorphic inline cache for indexing (e.g., `a[i]`) and related fast paths. Defaults to follow `FIELD_PIC` on init; can be toggled independently.
+- `INDEX_PIC_SIZE_4` — Increases Index PIC size from 2 to 4 entries (JVM-first tuning). Default: ON for JVM; OFF elsewhere by default.
+- `PIC_DEBUG_COUNTERS` — Enable lightweight hit/miss counters via `PerfStats` (OFF by default).
+- `PRIMITIVE_FASTOPS` — Fast paths for `(ObjInt, ObjInt)` arithmetic/comparisons and `(ObjBool, ObjBool)` logic (ON JVM default).
+- `RVAL_FASTPATH` — Bypass `ObjRecord` in pure expression evaluation via `ObjRef.evalValue` (ON JVM default, OFF elsewhere).
+
+See `src/commonMain/kotlin/net/sergeych/lyng/PerfFlags.kt` and `PerfDefaults.*.kt` for details and platform defaults.
+
+## Where optimizations apply
+
+- Locals: `FastLocalVarRef`, `LocalVarRef` per‑frame cache (PIC).
+- Calls: small‑arity zero‑alloc paths (0–8 args; optionally 0–12 with `ARG_SMALL_ARITY_12`), pooled builder (JVM), and child frame pooling (optional).
+- Properties/methods: Field/Method PICs with receiver shape `(classId, layoutVersion)` and handle‑aware caches; configurable 2→4 entries under flags.
+- Expressions: R‑value fast paths in hot nodes (`UnaryOpRef`, `BinaryOpRef`, `ElvisRef`, logical ops, `RangeRef`, `IndexRef` read, `FieldRef` receiver eval, `ListLiteralRef` elements, `CallRef` callee, `MethodCallRef` receiver, assignment RHS).
+- Primitives: Direct boolean/int ops where safe.
+
+### Compiler constant folding (conservative)
+- The compiler folds a safe subset of literal‑only expressions at compile time to reduce runtime work:
+  - Integer arithmetic: `+ - * / %` (division/modulo only when divisor ≠ 0).
+  - Bitwise integer ops: `& ^ | << >>`.
+  - Comparisons and equality for ints/strings/chars: `== != < <= > >=`.
+  - Boolean logic for literal booleans: `|| &&` and unary `!`.
+  - String concatenation of literal strings: `"a" + "b"`.
+- Non‑literal operands or side‑effecting constructs are not folded.
+- Semantics remain unchanged; tests verify parity.
+
+## Running JVM micro‑benchmarks
+
+Each benchmark prints timings with `[DEBUG_LOG]` and includes correctness assertions to prevent dead‑code elimination.
+
+Run individual tests to avoid multiplatform matrices:
+
+```
+./gradlew :lynglib:jvmTest --tests LocalVarBenchmarkTest
+./gradlew :lynglib:jvmTest --tests CallBenchmarkTest
+./gradlew :lynglib:jvmTest --tests CallMixedArityBenchmarkTest
+./gradlew :lynglib:jvmTest --tests CallSplatBenchmarkTest
+./gradlew :lynglib:jvmTest --tests PicBenchmarkTest
+./gradlew :lynglib:jvmTest --tests PicInvalidationJvmTest
+./gradlew :lynglib:jvmTest --tests PicAdaptiveABTest
+./gradlew :lynglib:jvmTest --tests ArithmeticBenchmarkTest
+./gradlew :lynglib:jvmTest --tests ExpressionBenchmarkTest
+./gradlew :lynglib:jvmTest --tests IndexPicABTest
+./gradlew :lynglib:jvmTest --tests IndexWritePathABTest
+./gradlew :lynglib:jvmTest --tests CallPoolingBenchmarkTest
+./gradlew :lynglib:jvmTest --tests MethodPoolingBenchmarkTest
+./gradlew :lynglib:jvmTest --tests MixedBenchmarkTest
+./gradlew :lynglib:jvmTest --tests DeepPoolingStressJvmTest
+```
+
+Typical output (example):
+
+```
+[DEBUG_LOG] [BENCH] mixed-arity x200000 [ARG_BUILDER=ON]: 85.7 ms
+```
+
+Lower time is better. Run the same bench with a flag OFF vs ON to compare.
+
+### Optional JFR allocation profiling (JVM)
+
+When running end‑to‑end “book” workloads or heavier benches, you can enable JFR to capture allocation and GC details:
+
+```
+./gradlew :lynglib:jvmTest --tests BookAllocationProfileTest -Dlyng.jfr=true \
+  -Dlyng.profile.warmup=1 -Dlyng.profile.repeats=3 -Dlyng.profile.shuffle=true
+```
+
+- Dumps are saved to `lynglib/build/jfr_*.jfr` if the JVM supports Flight Recorder.
+- The test also records GC counts/time and median time/heap deltas to `lynglib/build/book_alloc_profile.txt`.
+
+## Toggling flags in tests
+
+Flags are mutable at runtime, e.g.:
+
+```kotlin
+PerfFlags.ARG_BUILDER = false
+val r1 = (Scope().eval(script) as ObjInt).value
+PerfFlags.ARG_BUILDER = true
+val r2 = (Scope().eval(script) as ObjInt).value
+```
+
+Reset flags at the end of a test to avoid impacting other tests.
+
+## PIC diagnostics (optional)
+
+Enable counters:
+
+```kotlin
+PerfFlags.PIC_DEBUG_COUNTERS = true
+PerfStats.resetAll()
+```
+
+Available counters in `PerfStats`:
+
+- Field PIC: `fieldPicHit`, `fieldPicMiss`, `fieldPicSetHit`, `fieldPicSetMiss`
+- Method PIC: `methodPicHit`, `methodPicMiss`
+- Index PIC: `indexPicHit`, `indexPicMiss`
+- Locals: `localVarPicHit`, `localVarPicMiss`, `fastLocalHit`, `fastLocalMiss`
+- Primitive ops: `primitiveFastOpsHit`
+
+Print a summary at the end of a bench/test as needed. Remember to turn counters OFF after the test.
+
+## A/B scenarios and guidance (JVM)
+
+### Adaptive PIC (fields/methods)
+- Flags: `FIELD_PIC=true`, `METHOD_PIC=true`, `FIELD_PIC_SIZE_4=false`, `METHOD_PIC_SIZE_4=false`, toggle `PIC_ADAPTIVE_2_TO_4` OFF vs ON.
+- Benchmarks: `PicBenchmarkTest`, `MixedBenchmarkTest`, `PicAdaptiveABTest`.
+- Expect wins at sites with >2 receiver shapes; counters should show fewer misses with adaptivity ON.
+
+### Index PIC and size
+- Flags: toggle `INDEX_PIC` OFF vs ON; then `INDEX_PIC_SIZE_4` OFF vs ON.
+- Benchmarks: `ExpressionBenchmarkTest` (list indexing) and `IndexPicABTest` (string/map indexing).
+- Expect wins when the same index shape recurs; counters should show higher `indexPicHit`.
+
+### Index WRITE paths (Map and List)
+- Flags: toggle `INDEX_PIC` OFF vs ON; then `INDEX_PIC_SIZE_4` OFF vs ON.
+- Benchmark: `IndexWritePathABTest` (Map[String] put, List[Int] set) — writes results to `lynglib/build/index_write_ab_results.txt`.
+- Direct fast‑paths are used on R‑value paths where safe and semantics‑preserving (e.g., optional‑chaining no‑ops on null receivers; bounds exceptions unchanged).
+
+## Guidance per flag (JVM)
+
+- Keep `RVAL_FASTPATH = true` unless debugging a suspected expression‑semantics issue.
+- Use `SCOPE_POOL = true` only for benchmarks or once pooling passes the deep stress tests and broader validation; currently OFF by default.
+- `FIELD_PIC` and `METHOD_PIC` should remain ON; they are validated with invalidation tests.
+- Consider enabling `FIELD_PIC_SIZE_4`/`METHOD_PIC_SIZE_4` for sites with 3–4 receiver shapes; measure first.
+- `PIC_ADAPTIVE_2_TO_4` is useful on polymorphic sites and may outperform fixed size 2 on mixed-shape workloads. Validate with `PicAdaptiveABTest`.
+- `INDEX_PIC` is generally beneficial on JVM; leave ON when measuring index‑heavy workloads.
+- `INDEX_PIC_SIZE_4` is ON by default on JVM as A/B showed consistent wins on String[Int] and Map[String] workloads. You can disable it by setting `PerfFlags.INDEX_PIC_SIZE_4 = false` if needed.
+- `ARG_BUILDER` should remain ON; switch OFF only to get a baseline.
+- `ARG_SMALL_ARITY_12` is experimental and OFF by default. Enable it only if your workload frequently calls functions with 9–12 arguments and A/B shows consistent wins.
+
+### Workload‑specific recommendations (JVM)
+
+- “Books”/documentation loads (BookTest): prefer simpler paths; in A/B these often benefit from the BOOKS preset (e.g., `ARG_BUILDER=false`, `SCOPE_POOL=false`, `INDEX_PIC=false`). Use `PerfProfiles.apply(PerfProfiles.Preset.BOOKS)` before the run and `restore(...)` after.
+- Expression‑heavy benches: use the BENCH preset (PICs and R‑value fast‑paths enabled, `INDEX_PIC_SIZE_4=true`).
+- Always verify with local A/B on your environment; rollback is a flag flip or applying BASELINE.
+
+## Notes on correctness & safety
+
+- Optional chaining semantics are preserved across fast paths.
+- Visibility/mutability checks are enforced even on PIC fast‑paths.
+- `frameId` is regenerated on each pooled frame borrow; stress tests verify no leakage under deep nesting/recursion.
+
+## Cross‑platform
+
+- Non‑JVM defaults keep `RVAL_FASTPATH=false` for now; other low‑risk flags may be ON.
+- Once JVM path is fully validated and measured, add lightweight benches for JS/Wasm/Native and enable flags incrementally.
+
+## Range fast iteration (experimental)
+
+- Flag: `RANGE_FAST_ITER` (default OFF).
+- When enabled and applicable, simple ascending integer ranges (`0..n`, `0..<n`) use a specialized non‑allocating iterator (`ObjFastIntRangeIterator`).
+- Benchmark: `RangeIterationBenchmarkTest` records OFF/ON timings for inclusive, exclusive, reversed, negative, and empty ranges. Semantics are preserved; non‑int or complex ranges fall back to the generic iterator.
+
+## Troubleshooting
+
+- If a benchmark shows regressions, flip related flags OFF to isolate the source (e.g., `ARG_BUILDER`, `RVAL_FASTPATH`, `FIELD_PIC`, `METHOD_PIC`).
+- Use `PIC_DEBUG_COUNTERS` to observe inline cache effectiveness.
+- Ensure tests do not accidentally keep flags ON for subsequent tests; reset after each test.
+
+
+## JVM micro-benchmark results (3× medians; OFF → ON)
+
+Date: 2025-11-10 23:04 (local)
+
+| Flag               | Benchmark/Test                              | OFF median (ms) | ON median (ms) | Speedup | Notes |
+|--------------------|----------------------------------------------|-----------------:|----------------:|:-------:|-------|
+| ARG_BUILDER        | CallMixedArityBenchmarkTest                   |           788.02 |          668.79 |  1.18×  | Clear win on mixed arity |
+| ARG_BUILDER        | CallBenchmarkTest (simple calls)              |           423.87 |          425.47 |  1.00×  | Neutral on repeated simple calls |
+| FIELD_PIC          | PicBenchmarkTest::benchmarkFieldGetSetPic     |           113.575 |          106.017 |  1.07×  | Small but consistent win |
+| METHOD_PIC         | PicBenchmarkTest::benchmarkMethodPic          |           251.068 |          149.439 |  1.68×  | Large consistent win |
+| RVAL_FASTPATH      | ExpressionBenchmarkTest                       |           514.491 |          426.800 |  1.21×  | Consistent win in expression chains |
+| PRIMITIVE_FASTOPS  | ArithmeticBenchmarkTest (int-sum)             |           243.420 |          128.146 |  1.90×  | Big win for integer addition |
+| PRIMITIVE_FASTOPS  | ArithmeticBenchmarkTest (int-cmp)             |           210.385 |          168.534 |  1.25×  | Moderate win for comparisons |
+| SCOPE_POOL         | CallPoolingBenchmarkTest                      |           505.778 |          366.737 |  1.38×  | Single-threaded bench; per-thread ThreadLocal pool; default ON on JVM |
+
+Notes:
+- All results obtained from `[DEBUG_LOG] [BENCH]` outputs with three repeated Gradle test invocations per configuration; medians reported.
+- JVM defaults (current): `ARG_BUILDER=true`, `PRIMITIVE_FASTOPS=true`, `RVAL_FASTPATH=true`, `FIELD_PIC=true`, `METHOD_PIC=true`, `SCOPE_POOL=true` (per‑thread ThreadLocal pool), `REGEX_CACHE=true`.
+
+
+## Concurrency (multi‑core) pooling results (3× medians; OFF → ON)
+
+Date: 2025-11-10 22:56 (local)
+
+| Flag       | Benchmark/Test                      | OFF median (ms) | ON median (ms) | Speedup | Notes |
+|------------|--------------------------------------|-----------------:|----------------:|:-------:|-------|
+| SCOPE_POOL | ConcurrencyCallBenchmarkTest (JVM)   |           521.102 |          201.374 |  2.59×  | Multithreaded workload on `Dispatchers.Default` with per‑thread ThreadLocal pool; workers=8, iters=15000/worker. |
+
+Methodology:
+- The test toggles `PerfFlags.SCOPE_POOL` within a single run and executes the same script across N worker coroutines scheduled on `Dispatchers.Default`.
+- We executed the test three times via Gradle and computed medians from the printed `[DEBUG_LOG]` timings:
+  - OFF runs (ms): 532.442 | 521.102 | 474.386 → median 521.102
+  - ON runs (ms):  218.683 | 201.374 | 198.737 → median 201.374
+- Speedup = OFF/ON.
+
+Reproduce:
+```
+./gradlew :lynglib:jvmTest --tests "ConcurrencyCallBenchmarkTest" --rerun-tasks
+```
+
+
+## Next optimization steps (JVM)
+
+Date: 2025-11-10 23:04 (local)
+
+- PICs
+  - Widen METHOD_PIC to 3–4 entries with tiny LRU; keep invalidation on layout change; re-run `PicInvalidationJvmTest`.
+  - Micro fast-path for FIELD_PIC read-then-write pairs (`x = x + 1`) to reuse the resolved slot within one step.
+- Locals and slots
+  - Pre-size `Scope` slot structures when compiler knows local/param counts; audit `EMIT_FAST_LOCAL_REFS` coverage.
+  - Re-run `LocalVarBenchmarkTest` to quantify gains.
+- RVAL_FASTPATH coverage
+  - Cover primitive `ObjList` index reads, pure receivers in `FieldRef`, and assignment RHS where safe; add micro-benches to `ExpressionBenchmarkTest`.
+- Collections and ranges
+  - Specialize `(Int..Int)` loops into tight counted loops (no intermediary objects).
+  - Add primitive-specialized `ObjList` ops (`map`, `filter`, `sum`, `contains`) under `PRIMITIVE_FASTOPS`.
+- Regex and strings
+  - Cache compiled regex for string literals at compile time; add a tiny LRU for dynamic patterns behind `REGEX_CACHE`.
+  - Add `RegexBenchmarkTest` for repeated matches.
+- JIT friendliness (Kotlin/JVM)
+  - Inline tiny helpers in hot paths, prefer arrays for internal buffers, finalize hot data structures where safe.
+
+Validation matrix
+- Always re-run: `CallBenchmarkTest`, `CallMixedArityBenchmarkTest`, `PicBenchmarkTest`, `ExpressionBenchmarkTest`, `ArithmeticBenchmarkTest`, `CallPoolingBenchmarkTest`, `DeepPoolingStressJvmTest`, `ConcurrencyCallBenchmarkTest` (3× medians when comparing).
+- Keep full `:lynglib:jvmTest` green after each change.
+
+
+
+## PIC update (4‑way METHOD_PIC) — JVM (3× medians; OFF → ON)
+
+Date: 2025-11-11 00:16 (local)
+
+| Flag      | Benchmark/Test                               | OFF median (ms) | ON median (ms) | Speedup | Notes |
+|-----------|-----------------------------------------------|-----------------:|----------------:|:-------:|-------|
+| FIELD_PIC | PicBenchmarkTest::benchmarkFieldGetSetPic      |          207.578 |         106.481 |  1.95×  | Read→write loop; micro fast‑path groundwork present |
+| METHOD_PIC| PicBenchmarkTest::benchmarkMethodPic           |          273.478 |         182.226 |  1.50×  | 4‑way PIC with move‑to‑front (was 2‑way before) |
+
+Medians computed from three Gradle runs in this session; see `[DEBUG_LOG] [BENCH]` lines in test output.
+
+
+## Locals/slots capacity (pre‑sizing hints) — JVM (3× medians; OFF → ON)
+
+Date: 2025-11-11 13:19 (local)
+
+| Optimization            | Benchmark/Test              | OFF config                         | ON config                          | OFF median (ms) | ON median (ms) | Speedup | Notes |
+|-------------------------|-----------------------------|------------------------------------|------------------------------------|-----------------:|----------------:|:-------:|-------|
+| Locals pre‑sizing + PIC | LocalVarBenchmarkTest       | LOCAL_SLOT_PIC=OFF, FAST_LOCAL=OFF | LOCAL_SLOT_PIC=ON, FAST_LOCAL=ON   |          472.129 |         370.871 |  1.27×  | Compiler hint `params+4`; slot pre‑size; semantics unchanged |
+
+Methodology:
+- Each configuration executed three times via `:lynglib:jvmTest --tests "…" --rerun-tasks`; medians reported.
+- Locals improvement stacks with per‑thread `SCOPE_POOL` and ARG fast paths.
+
+
+
+
+## RVAL fast paths update — JVM (IndexRef and FieldRef) [3× medians; OFF → ON]
+
+Date: 2025-11-11 13:19 (local)
+
+New micro-benchmarks have been added to quantify the latest `RVAL_FASTPATH` extensions:
+- Primitive `ObjList` index-read fast path in `IndexRef`.
+- Conservative “pure receiver” evaluation in `FieldRef` (monomorphic, immutable receiver), preserving visibility/mutability checks and optional chaining semantics.
+
+Benchmarks to run (each 3× OFF → ON):
+- `ExpressionBenchmarkTest::benchmarkListIndexReads`
+- `ExpressionBenchmarkTest::benchmarkFieldReadPureReceiver`
+
+Reproduce (3× each; collect `[DEBUG_LOG] [BENCH]` lines and compute medians):
+```
+./gradlew :lynglib:jvmTest --tests "ExpressionBenchmarkTest.benchmarkListIndexReads" --rerun-tasks
+./gradlew :lynglib:jvmTest --tests "ExpressionBenchmarkTest.benchmarkListIndexReads" --rerun-tasks
+./gradlew :lynglib:jvmTest --tests "ExpressionBenchmarkTest.benchmarkListIndexReads" --rerun-tasks
+
+./gradlew :lynglib:jvmTest --tests "ExpressionBenchmarkTest.benchmarkFieldReadPureReceiver" --rerun-tasks
+./gradlew :lynglib:jvmTest --tests "ExpressionBenchmarkTest.benchmarkFieldReadPureReceiver" --rerun-tasks
+./gradlew :lynglib:jvmTest --tests "ExpressionBenchmarkTest.benchmarkFieldReadPureReceiver" --rerun-tasks
+```
+
+Once collected, add medians and speedups to the table below:
+
+| Flag          | Benchmark/Test                                  | OFF median (ms) | ON median (ms) | Speedup | Notes |
+|---------------|---------------------------------------------------|-----------------:|----------------:|:-------:|-------|
+| RVAL_FASTPATH | ExpressionBenchmarkTest::benchmarkListIndexReads  |           305.243 |          230.942 |  1.32×  | Fast path in `IndexRef` for `ObjList` + `ObjInt` index |
+| RVAL_FASTPATH | ExpressionBenchmarkTest::benchmarkFieldReadPureReceiver |           266.222 |          190.720 |  1.40×  | Pure-receiver evaluation in `FieldRef` (monomorphic, immutable) |
+
+Notes:
+- Both benches toggle `PerfFlags.RVAL_FASTPATH` within a single run to produce OFF and ON timings under identical conditions.
+- Correctness assertions ensure the loops are not optimized away.
+- All semantics (visibility/mutability checks, optional chaining) remain intact; fast paths only skip interim `ObjRecord` traffic when safe.
+
+
+## ARG_BUILDER — splat fast‑path (3× medians; OFF → ON)
+
+Date: 2025-11-11 13:12 (local)
+
+Environment: Gradle 8.7; JVM (JDK as configured by toolchain); single‑threaded test execution; stdout enabled.
+
+| Flag        | Benchmark/Test                    | OFF median (ms) | ON median (ms) | Speedup | Notes |
+|-------------|-----------------------------------|-----------------:|----------------:|:-------:|-------|
+| ARG_BUILDER | CallSplatBenchmarkTest (splat)    |          613.689 |         463.593 |  1.32×  | Single‑splat fast‑path returns underlying list directly; avoids intermediate copies |
+
+Inputs (3×):
+- OFF runs (ms): 613.689 | 629.604 | 612.361 → median 613.689
+- ON runs (ms):  453.752 | 463.593 | 468.844 → median 463.593
+
+Reproduce (3×):
+```
+./gradlew :lynglib:jvmTest --tests "CallSplatBenchmarkTest" --rerun-tasks
+```
+
+
+
+## Phase A consolidation (JVM) — 3× medians updated
+
+Date: 2025-11-11 13:48 (local)
+Environment:
+- JDK: OpenJDK 20.0.2.1 (Amazon Corretto 20.0.2.1+10-FR)
+- Gradle: 8.7
+- OS/Arch: macOS 14.8.1 (aarch64)
+
+### ARG_BUILDER
+
+| Benchmark/Test                   | OFF median (ms) | ON median (ms) | Speedup | Notes |
+|----------------------------------|-----------------:|----------------:|:-------:|-------|
+| CallMixedArityBenchmarkTest      |          866.681 |         717.439 |  1.21×  | Small-arity 0–8 fast path + builder; correctness preserved |
+| CallSplatBenchmarkTest (splat)   |          600.880 |         459.706 |  1.31×  | Single-splat fast path returns underlying list; avoids copies |
+
+Inputs (3×):
+- Mixed arity OFF: 874.088291 | 866.680959 | 858.577125 → median 866.680959
+- Mixed arity ON:  731.308625 | 706.440125 | 717.438542 → median 717.438542
+- Splat OFF: 600.268625 | 607.849416 | 600.879666 → median 600.879666
+- Splat ON:  459.706375 | 449.950166 | 461.815167 → median 459.706375
+
+### RVAL_FASTPATH (new coverage)
+
+| Benchmark/Test                                   | OFF median (ms) | ON median (ms) | Speedup | Notes |
+|--------------------------------------------------|-----------------:|----------------:|:-------:|-------|
+| ExpressionBenchmarkTest::benchmarkListIndexReads |          299.366 |         218.812 |  1.37×  | IndexRef fast path for ObjList + ObjInt |
+| ExpressionBenchmarkTest::benchmarkFieldReadPureReceiver |          268.315 |         186.032 |  1.44×  | Pure-receiver evaluation in FieldRef (monomorphic, immutable) |
+
+Inputs (3×):
+- ListIndex OFF: 291.344 | 310.717167 | 299.365709 → median 299.365709
+- ListIndex ON:  217.795375 | 221.504166 | 218.812042 → median 218.812042
+- FieldRead OFF: 267.2775 | 274.355208 | 268.315125 → median 268.315125
+- FieldRead ON:  189.599333 | 186.031791 | 182.069167 → median 186.031791
+
+### Locals/slots capacity (precise hints)
+
+| Benchmark/Test             | OFF config                         | ON config                          | OFF median (ms) | ON median (ms) | Speedup | Notes |
+|---------------------------|------------------------------------|------------------------------------|-----------------:|----------------:|:-------:|-------|
+| LocalVarBenchmarkTest     | LOCAL_SLOT_PIC=OFF, FAST_LOCAL=OFF | LOCAL_SLOT_PIC=ON, FAST_LOCAL=ON   |          446.018 |         347.964 |  1.28×  | Precise capacity hints + fast-locals coverage |
+
+Inputs (3×):
+- Locals OFF: 470.575041 | 441.89625 | 446.017833 → median 446.017833
+- Locals ON:  370.664208 | 345.615541 | 347.964291 → median 347.964291
+
+Methodology:
+- Each test executed three times via Gradle with stdout enabled; medians computed from `[DEBUG_LOG] [BENCH]` lines.
+- Full JVM tests and stress benches remain green in this cycle.
+
+
+
+## Phase B — List ops specialization (PRIMITIVE_FASTOPS) — 3× medians (OFF → ON)
+
+Date: 2025-11-11 13:48 (local)
+Environment:
+- JDK: OpenJDK 20.0.2.1 (Amazon Corretto 20.0.2.1+10-FR)
+- Gradle: 8.7
+- OS/Arch: macOS 14.8.1 (aarch64)
+
+| Optimization        | Benchmark/Test                          | OFF median (ms) | ON median (ms) | Speedup | Notes |
+|---------------------|------------------------------------------|-----------------:|----------------:|:-------:|-------|
+| PRIMITIVE_FASTOPS   | ListOpsBenchmarkTest::benchmarkSumInts   |          324.805 |         144.908 |  2.24×  | ObjList.sum fast path for int lists; generic fallback preserved |
+| PRIMITIVE_FASTOPS   | ListOpsBenchmarkTest::benchmarkContainsInts |          440.414 |         415.476 |  1.06×  | ObjList.contains fast path when searching ObjInt in int list |
+
+Inputs (3×):
+- list-sum OFF: 332.863417 | 323.491625 | 324.804083 → median 324.804083
+- list-sum ON:  144.907833 | 148.870792 | 126.418542 → median 144.907833
+- list-contains OFF: 440.413709 | 440.368333 | 441.4365 → median 440.413709
+- list-contains ON:  416.465292 | 412.283291 | 415.475833 → median 415.475833
+
+Methodology:
+- Each test executed three times via Gradle; medians computed from `[DEBUG_LOG] [BENCH]` lines.
+- Changes are fully guarded by `PerfFlags.PRIMITIVE_FASTOPS`; semantics preserved (null on empty sum; generic fallback on mixed types).
+
+
+
+### Phase B — Ranges for-in lowering (PRIMITIVE_FASTOPS) — 3× medians (OFF → ON)
+
+Date: 2025-11-11 13:48 (local)
+Environment:
+- JDK: OpenJDK 20.0.2.1 (Amazon Corretto 20.0.2.1+10-FR)
+- Gradle: 8.7
+- OS/Arch: macOS 14.8.1 (aarch64)
+
+| Optimization        | Benchmark/Test                          | OFF median (ms) | ON median (ms) | Speedup | Notes |
+|---------------------|------------------------------------------|-----------------:|----------------:|:-------:|-------|
+| PRIMITIVE_FASTOPS   | RangeBenchmarkTest::benchmarkIntRangeForIn |         1705.299 |         788.974 |  2.16×  | Tight counted loop for (Int..Int) for-in; preserves semantics |
+
+Inputs (3×):
+- range-for-in OFF: 1705.298958 | 1684.357708 | 1735.880917 → median 1705.298958
+- range-for-in ON:  794.178458 | 778.741834 | 788.973625 → median 788.973625
+
+Methodology:
+- Each configuration executed three times via Gradle; medians computed from `[DEBUG_LOG] [BENCH]` lines.
+- Lowering is guarded by `PerfFlags.PRIMITIVE_FASTOPS` and applies only when the source is an `ObjRange` with int bounds; otherwise falls back to generic iteration.
+
+
+
+## Phase B — Regex caching (REGEX_CACHE) — 3× medians (OFF → ON)
+
+Date: 2025-11-11 13:48 (local)
+Environment:
+- JDK: OpenJDK 20.0.2.1 (Amazon Corretto 20.0.2.1+10-FR)
+- Gradle: 8.7
+- OS/Arch: macOS 14.8.1 (aarch64)
+
+| Flag         | Benchmark/Test                                  | OFF median (ms) | ON median (ms) | Speedup | Notes |
+|--------------|---------------------------------------------------|-----------------:|----------------:|:-------:|-------|
+| REGEX_CACHE  | RegexBenchmarkTest::benchmarkLiteralPatternMatches |          378.246 |         275.890 |  1.37×  | Caches compiled regex for identical literal pattern per iteration |
+| REGEX_CACHE  | RegexBenchmarkTest::benchmarkDynamicPatternMatches |          514.944 |         229.006 |  2.25×  | Two dynamic patterns alternate; cache size sufficient to retain both |
+
+Inputs (1× here; can extend to 3× on request):
+- regex-literal OFF: 378.245916; ON: 275.889541
+- regex-dynamic OFF: 514.944167; ON: 229.005834
+
+Methodology:
+- Each benchmark toggles `PerfFlags.REGEX_CACHE` inside a single test and prints `[DEBUG_LOG]` timings for OFF and ON runs under identical conditions. We recorded one set of OFF/ON timings here; we can extend to 3× medians if required for publication.
+- The cache is a tiny size-bounded map (64 entries) activated only when `PerfFlags.REGEX_CACHE` is true. Defaults remain OFF.
+
+
+
+
+## JIT tweaks (Round 1) — quick gains snapshot (locals, ranges, list ops)
+
+Date: 2025-11-11 21:05 (local)
+
+Scope: fast confirmation of overall gain using current configuration; focused on locals, ranges, and list ops. Each test prints OFF → ON timings in a single run. We executed the benches via Gradle with stdout enabled and single test fork.
+
+Environment:
+- Gradle: 8.7 (stdout enabled, maxParallelForks=1)
+- JVM: as configured by toolchain for this project
+- OS/Arch: per developer machine (unchanged from prior sections)
+
+Reproduce:
+```
+./gradlew :lynglib:jvmTest --tests LocalVarBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests RangeBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests ListOpsBenchmarkTest --rerun-tasks
+```
+
+Results (representative runs; OFF → ON):
+- Local variables — LOCAL_SLOT_PIC + EMIT_FAST_LOCAL_REFS
+  - Run 1: 468.407 ms → 367.277 ms (≈ 1.28×)
+  - Run 2: 447.031 ms → 346.126 ms (≈ 1.29×)
+- Ranges for‑in — PRIMITIVE_FASTOPS (tight counted loop for (Int..Int))
+  - 1731.780 ms → 799.023 ms (≈ 2.17×)
+- List ops — PRIMITIVE_FASTOPS
+  - sum(int list): 318.943 ms → 148.571 ms (≈ 2.15×)
+  - contains(int in int list): 440.013 ms → 412.450 ms (≈ 1.07×)
+
+Summary: All three areas improved with optimizations ON; no regressions observed in these runs. For publication‑grade stability, run each test 3× and report medians (see sections below for methodology and previous median tables).
+
+
+## Additional tweaks — verification snapshot (Index write fast‑path, List literal pre‑size, Regex LRU)
+
+Date: 2025-11-11 21:31 (local)
+
+Scope: Implemented three semantics‑neutral optimizations and verified they are green across targeted and broader JVM benches.
+
+What changed (guarded by flags where applicable):
+- RVAL_FASTPATH: Index write fast‑path
+  - `IndexRef.setAt`: direct path for `ObjList` + `ObjInt` (`list[i] = value`) mirrors the read fast‑path. Optional chaining semantics preserved; bounds exceptions propagate unchanged.
+- RVAL_FASTPATH: List literal pre‑sizing
+  - `ListLiteralRef.get`: pre‑counts element entries and uses `ArrayList` with capacity hint; for spreads of `ObjList`, uses `ensureCapacity` before bulk add. Evaluation order unchanged.
+- REGEX_CACHE: LRU‑like behavior
+  - `RegexCache`: emulates access‑order LRU within a tiny bounded map (`MAX=64`) by moving accessed entries to the tail; improves alternating‑pattern scenarios. Only active when `PerfFlags.REGEX_CACHE` is true.
+
+Reproduce quick verification (1× runs):
+```
+./gradlew :lynglib:jvmTest --tests ExpressionBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests ListOpsBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests RegexBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests PicBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests PicInvalidationJvmTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests LocalVarBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests ConcurrencyCallBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests DeepPoolingStressJvmTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests MultiThreadPoolingStressJvmTest --rerun-tasks
+```
+
+Observation: All listed tests green in this cycle; no behavioral regressions observed. For the new paths (index write, list literal), performance was neutral‑to‑positive in smoke runs; Regex benches remained positive or neutral with the LRU behavior. For publication‑grade medians, extend to 3× per test as in earlier sections.
+
+
+## Sanity matrix (JVM) — quick OFF→ON runs
+
+Date: 2025-11-11 21:59 (local)
+
+Scope: Final Round 1 sanity sweep across JVM micro‑benches and stress tests to confirm that optimizations ON do not regress performance vs OFF in representative scenarios. Each benchmark prints `[DEBUG_LOG] [BENCH]` timings for OFF → ON within a single run. This section records a quick pass confirmation (not 3× medians) and reproduction commands.
+
+Environment:
+- Gradle: 8.7 (stdout enabled, maxParallelForks=1)
+- JVM: as configured by the project toolchain
+- OS/Arch: macOS 14.x (aarch64)
+
+Benches covered (all green; no regressions observed in these runs):
+- Calls/Args: `CallBenchmarkTest`, `CallMixedArityBenchmarkTest` (ARG_BUILDER)
+- PICs: `PicBenchmarkTest` (field/method); `PicInvalidationJvmTest` correctness reconfirmed
+- Expressions/Arithmetic: `ExpressionBenchmarkTest`, `ArithmeticBenchmarkTest` (RVAL_FASTPATH, PRIMITIVE_FASTOPS)
+- Ranges: `RangeBenchmarkTest` (PRIMITIVE_FASTOPS counted loop)
+- List ops: `ListOpsBenchmarkTest` (PRIMITIVE_FASTOPS specializations)
+- Regex: `RegexBenchmarkTest` (REGEX_CACHE with LRU behavior)
+- Locals: `LocalVarBenchmarkTest` (LOCAL_SLOT_PIC + FAST_LOCAL)
+- Concurrency/Pooling: `ConcurrencyCallBenchmarkTest`, `DeepPoolingStressJvmTest`, `MultiThreadPoolingStressJvmTest` (SCOPE_POOL per‑thread)
+
+Reproduce (examples):
+```
+./gradlew :lynglib:jvmTest --tests CallBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests CallMixedArityBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests PicBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests PicInvalidationJvmTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests ExpressionBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests ArithmeticBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests RangeBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests ListOpsBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests RegexBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests LocalVarBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests ConcurrencyCallBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests DeepPoolingStressJvmTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests MultiThreadPoolingStressJvmTest --rerun-tasks
+```
+
+  Summary:
+  - All listed tests passed in this sanity sweep.
+  - For each benchmark’s OFF → ON printouts examined during this pass, ON was equal or faster than OFF; no ON<OFF regressions were observed.
+  - For publication‑grade numbers, use the 3× medians methodology outlined earlier in this document. The existing median tables in previous sections remain representative, and the additional tweaks (Index write, List literal pre‑size, Regex LRU, Field PIC 4‑way + read→write reuse, mixed Int/Real fast‑ops) remained neutral‑to‑positive.
+  
+
+## Quick snapshot — IndexRef PIC + negative miss cache (JVM) — 3× medians (OFF → ON)
+
+Date: 2025-11-11 22:32 (local)
+
+Scope
+- Confirm that the latest changes — IndexRef read/write PIC (stacked on RVAL_FASTPATH) and safe catch‑and‑cache negative entries for Field/Method PICs — do not regress performance. We collected 3× medians for the two expression sub‑benches that are most sensitive to RVAL paths and cross‑checked PICs and ranges.
+
+Environment
+- Gradle: 8.7 (stdout enabled, maxParallelForks=1)
+- JVM: project toolchain default
+- OS/Arch: macOS 14.x (aarch64)
+
+Results (3× medians)
+
+| Area | Benchmark/Test | OFF median (ms) | ON median (ms) | Speedup | Notes |
+|------|-----------------|-----------------:|----------------:|:-------:|-------|
+| RVAL_FASTPATH | ExpressionBenchmarkTest::benchmarkListIndexReads | 304.282 | 229.168 | 1.33× | IndexRef direct fast‑path for ObjList+ObjInt; 4‑way Index PIC handles polymorphic cases |
+| RVAL_FASTPATH | ExpressionBenchmarkTest::benchmarkFieldReadPureReceiver | 275.122 | 194.876 | 1.41× | Monomorphic, immutable receiver path; preserves visibility/optional semantics |
+
+Cross‑checks (from the same session, 1× quick)
+- PicBenchmarkTest::benchmarkFieldGetSetPic — OFF 203.701 ms → ON 117.129 ms (≈1.74×)
+- PicBenchmarkTest::benchmarkMethodPic — OFF 280.806 ms → ON 202.613 ms (≈1.39×)
+- RangeBenchmarkTest::benchmarkIntRangeForIn — OFF 1762.425 ms → ON 806.898 ms (≈2.18×)
+
+Reproduce
+```
+./gradlew :lynglib:jvmTest --tests "ExpressionBenchmarkTest.benchmarkListIndexReads" --rerun-tasks
+./gradlew :lynglib:jvmTest --tests "ExpressionBenchmarkTest.benchmarkListIndexReads" --rerun-tasks
+./gradlew :lynglib:jvmTest --tests "ExpressionBenchmarkTest.benchmarkListIndexReads" --rerun-tasks
+
+./gradlew :lynglib:jvmTest --tests "ExpressionBenchmarkTest.benchmarkFieldReadPureReceiver" --rerun-tasks
+./gradlew :lynglib:jvmTest --tests "ExpressionBenchmarkTest.benchmarkFieldReadPureReceiver" --rerun-tasks
+./gradlew :lynglib:jvmTest --tests "ExpressionBenchmarkTest.benchmarkFieldReadPureReceiver" --rerun-tasks
+
+./gradlew :lynglib:jvmTest --tests PicBenchmarkTest --rerun-tasks
+./gradlew :lynglib:jvmTest --tests RangeBenchmarkTest --rerun-tasks
+```
+
+Notes
+- Negative caches are installed only after a real miss throws (cache‑after‑miss), preserving error semantics and invalidation on `layoutVersion` changes.
+- IndexRef PIC augments the existing direct path and uses move‑to‑front promotion; it is keyed on `(classId, layoutVersion)` like other PICs.
+
@@ -0,0 +1,56 @@
+# JVM-only Performance Optimization Plan (Saved)
+
+Date: 2025-11-10 22:14 (local)
+
+This document captures the agreed next optimization steps so we can restore the plan later if needed.
+
+## Objectives
+- Reduce overhead on the call/argument path.
+- Extend and harden PIC performance (fields/methods/locals).
+- Improve R-value fast paths and interpreter hot nodes (loops, ranges, lists).
+- Make scope frame pooling thread-safe on JVM so it can be enabled by default later.
+- Keep semantics correct and all JVM tests green.
+
+## Prioritized tasks (now)
+1) Call/argument path: fewer allocs, tighter fast paths
+- Extend small-arity zero-alloc path to 6–8 args; benchmark with `CallMixedArityBenchmarkTest`.
+- Splat handling: fast-path single-list splats; benchmark with `CallSplatBenchmarkTest`.
+- Arg builder micro-optimizations: capacity hints, avoid redundant copies, inline simple branches.
+- Optional-chaining fast return (`SKIP_ARGS_ON_NULL_RECEIVER`) coverage audit, add A/B bench.
+
+2) Scope frame pooling: per-thread safety on JVM
+- Replace global deque with ThreadLocal pool on JVM (and Android) actuals.
+- Keep `frameId` uniqueness and pool size cap.
+- Verify with `DeepPoolingStressJvmTest`, `CallPoolingBenchmarkTest`, and spot benches.
+- Do NOT flip default yet; keep `SCOPE_POOL=false` unless explicitly approved.
+
+## Next tasks (queued)
+3) PICs: cheaper misses, broader hits
+- Method PIC 2→3/4 entries (tiny LRU); validate with `PicInvalidationJvmTest`.
+- Field PIC micro-fast path for read-then-write pairs.
+
+4) Locals and slots
+- Ensure `EMIT_FAST_LOCAL_REFS` coverage across compiler sites.
+- Pre-size `slots`/`nameToSlot` when local counts are known; re-run `LocalVarBenchmarkTest`.
+
+5) R-value fast path coverage
+- Cover index reads on primitive lists, pure receivers, assignment RHS where safe.
+- Add benches in `ExpressionBenchmarkTest`.
+
+6) Collections & ranges
+- Tight counted loop for `(Int..Int)` in `for`.
+- Primitive-specialized `ObjList` ops (`map`, `filter`, `sum`, `contains`) under `PRIMITIVE_FASTOPS`.
+
+7) Regex and string ops
+- Cache compiled regex for string literals at compile time; tiny LRU for dynamic patterns under a new `REGEX_CACHE` flag.
+
+8) JIT micro-tweaks
+- Inline tiny helpers; prefer arrays for hot buffers; finalize hot classes where safe.
+
+## Validation matrix
+- Always re-run: `CallBenchmarkTest`, `CallMixedArityBenchmarkTest`, `PicBenchmarkTest`, `ExpressionBenchmarkTest`, `ArithmeticBenchmarkTest`, `CallPoolingBenchmarkTest`, `DeepPoolingStressJvmTest`.
+- Use 3× medians where comparing flags; keep `:lynglib:jvmTest` green.
+
+## Notes
+- All risky changes remain flag-guarded and JVM-only where applicable.
+- Documentation and perf tables updated after each cycle.
@@ -16,9 +16,16 @@ fun naiveCountHappyNumbers() {
    count
 }

+import lyng.time
+
 //
-// After all optimizations it takes ~120ms.
+// After all optimizations it took ~120ms - before.
 //
-val found = naiveCountHappyNumbers()
-println("Found happy numbers: "+found)
-assert( found == 55252 )
+for( r in 1..900 ) {
+    val start = Instant.now()
+    val found = naiveCountHappyNumbers()
+    println("Found happy numbers: %d time %s"(found, Instant.now() - start))
+    assert( found == 55252 )
+    delay(0.05)
+}
+
@@ -48,6 +48,7 @@ $$ \ln(1+x)=x-{\dfrac {x^{2}}{2}}+{\dfrac {x^{3}}{3}}-\cdots =\sum \limits _{n=0
    }
    assert( почти_равны( 0.0005, 0.000501 ) )

-Во многих случаях вычисление $n+1$ члена значительно проще cчитается от предыдущего члена, в нашем случае это можно было бы записать через итератор, что мы вскоре добавим.
+Во многих случаях вычисление $n+1$ члена значительно проще cчитается от предыдущего члена, в нашем случае это можно было бы записать через итератор, см [Iterable] и `flow` в [parallelism].

-(продолжение следует)
+[Iterable]: ../Iterable.md
+[parallelism]: ../parallelism.md
@@ -0,0 +1,46 @@
+# Lyng serialization
+
+Lyng has builting binary bit-effective serialization format, called Lynon for LYng Object Notation. It is typed, binary, implements caching, automatic compression, variable-length ints, one-bit Booleans an many nice features. 
+
+It is as simple as:
+
+    import lyng.serialization
+
+    val text = "
+        We hold these truths to be self-evident, that all men are created equal, 
+        that they are endowed by their Creator with certain unalienable Rights, 
+        that among these are Life, Liberty and the pursuit of Happiness.    
+        "
+    val encodedBits = Lynon.encode(text)
+
+    // decode bits source:
+    assertEquals( text, Lynon.decode(encodedBits) )
+    
+    // compression was used automatically
+    assert( text.length > encodedBits.toBuffer().size )
+    >>> void
+
+Any class you create is serializable by default; lynon serializes first constructor fields, then any `var` member fields:
+
+    import lyng.serialization
+
+    class Point(x,y)
+
+    val p = Lynon.decode( Lynon.encode( Point(5,6) ) )
+    
+    assertEquals( 5, p.x )
+    assertEquals( 6, p.y )
+    >>> void
+
+
+just as expected.
+
+Important is to understand that normally `Lynon.decode` wants [BitBuffer], as `Lynon.encode` produces. If you have the regular [Buffer], be sure to convert it:
+
+    buffer.toBitInput()
+
+this possibly creates extra zero bits at the end, as bit content could be shorter than byte-grained but for the Lynon format it does not make sense. Note that when you serialize [BitBuffer], exact number of bits is written. To convert bit buffer to bytes:
+
+    Lynon.encode("hello").toBuffer()
+
+(topic is incomplete and under construction)
@@ -1,23 +1,3 @@
---
-gitea: none
-include_toc: true
---
-
-# Lyng tutorial
-
-Lyng is a very simple language, where we take only most important and popular features from
-other scripts and languages. In particular, we adopt _principle of minimal confusion_[^1].
-In other word, the code usually works as expected when you see it. So, nothing unusual.
-
-__Other documents to read__ maybe after this one:
-
- [Advanced topics](advanced_topics.md), [declaring arguments](declaring_arguments.md)
- [OOP notes](OOP.md), [exception handling](exceptions_handling.md)
- [math in Lyng](math.md)
- Some class references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md)
- Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples)
-
-# Expressions

 Everything is an expression in Lyng. Even an empty block:

@@ -168,9 +148,10 @@ There is also "elvis operator", null-coalesce infix operator '?:' that returns r
 The following functions simplify nullable values processing and
 allow to improve code look and readability. There are borrowed from Kotlin:

-### let 
+### let

-`value.let {}` passes to the block value as the single parameter (by default it is assigned to `it`) and return block's returned value. It is useful dealing with null or to
+`value.let {}` passes to the block value as the single parameter (by default it is assigned to `it`) and return block's
+returned value. It is useful dealing with null or to
 get a snapshot of some externally varying value, or with `?.` to process nullable value in a safe manner:

    // this state is changed from parallel processes
@@ -221,6 +202,19 @@ It works much like `also`, but is executed in the context of the source object:
    assertEquals(p, Point(2,3))
    >>> void

+## run
+
+Executes a block after it returning the value passed by the block. for example, can be used with elvis operator:
+
+    var someVar = null
+    val result = someVar ?: run {
+      someVar = 121
+      "reset"
+    }
+    assertEquals("reset", result)
+    assertEquals(121, someVar)
+    >>> void
+
 ## Math

 It is rather simple, like everywhere else:
@@ -257,6 +251,8 @@ Logical operation could be used the same
 |   ===    |     | Any               | (2)      |
 |   !==    |     | Any               | (2)      |
 |    !=    |     | Any               | (1)      |
+|    =~    |     |                   | (3)      |
+|    !~    |     |                   | (3)      |
 | ++a, a++ |     | Int               |          |
 | --a, a-- |     | Int               |          |

@@ -268,6 +264,9 @@ Logical operation could be used the same
 singleton object, like `null`, are referentially equal too, while string different literals even being equal are most
 likely referentially not equal

+(3)
+: Implemented now in String and Regex as regular expression match and not match, see [Regex].
+
 Reference quality and object equality example:

    assert( null == null)  // singletons
@@ -464,7 +463,6 @@ after function call, it is treated as a last argument to the call, e.g.:
    assert( [11, 21, 31] == mapped)
    >>> void

-
 # Lists (aka arrays)

 Lyng has built-in mutable array class `List` with simple literals:
@@ -472,7 +470,8 @@ Lyng has built-in mutable array class `List` with simple literals:
    [1, "two", 3.33].size
    >>> 3

-[List] is an implementation of the type `Array`, and through it `Collection` and [Iterable].
+[List] is an implementation of the type `Array`, and through it `Collection` and [Iterable]. Please read [Iterable],
+many collection based methods are implemented there.

 Lists can contain any type of objects, lists too:

@@ -489,21 +488,21 @@ Notice usage of indexing. You can use negative indexes to offset from the end of
 When you want to "flatten" it to single array, you can use splat syntax:

    [1, ...[2,3], 4]
-    >>> [1, 2, 3, 4]
+    >>> [1,2,3,4]

 Of course, you can splat from anything that is List (or list-like, but it will be defined later):

    val a = ["one", "two"]
    val b = [10.1, 20.2]
    ["start", ...b, ...a, "end"]
-    >>> ["start", 10.1, 20.2, "one", "two", "end"]
+    >>> [start,10.1,20.2,one,two,end]

 Of course, you can set any list element:

    val a = [1, 2, 3]
    a[1] = 200
    a
-    >>> [1, 200, 3]
+    >>> [1,200,3]

 Lists are comparable, and it works well as long as their respective elements are:

@@ -534,7 +533,8 @@ The simplest way to concatenate lists is using `+` and `+=`:
    void
    >>> void

-***Important note***: the pitfall of using `+=` is that you can't append in [Iterable] instance as an object: it will always add all its contents. Use `list.add` to add a single iterable instance:
+***Important note***: the pitfall of using `+=` is that you can't append in [Iterable] instance as an object: it will
+always add all its contents. Use `list.add` to add a single iterable instance:

    var list = [1, 2]
    val other = [3, 4]
@@ -562,7 +562,6 @@ Use `list.add` to avoid confusion:
    assert( list == [1, 2, [3, 4], (10..12)])
    >>> void

-
 To add elements to the list:

    val x = [1,2]
@@ -593,21 +592,20 @@ Using splat arguments can simplify inserting list in list:
    val x = [1, 2, 3]
    x.insertAt( 1, ...[0,100,0])
    x
-    >>> [1, 0, 100, 0, 2, 3]
-
+    >>> [1,0,100,0,2,3]

 Note that to add to the end you still need to use `add` or positive index of the after-last element:

    val x = [1,2,3]
    x.insertAt(3, 10)
    x
-    >>> [1, 2, 3, 10]
+    >>> [1,2,3,10]

 but it is much simpler, and we recommend to use '+='

    val x = [1,2,3]
    x += 10
-    >>> [1, 2, 3, 10]
+    >>> [1,2,3,10]

 ## Removing list items

@@ -739,25 +737,30 @@ Also, you can check the type too:

 ### supported when conditions:

-#### Contains: 
+#### Contains:

-You can thest that _when expression_ is _contained_, or not contained, in some object using `in container` and `!in container`. The container is any object that provides `contains` method, otherwise the runtime exception will be thrown.
+You can thest that _when expression_ is _contained_, or not contained, in some object using `in container` and
+`!in container`. The container is any object that provides `contains` method, otherwise the runtime exception will be
+thrown.

-Typical builtin types that are containers (e.g. support `conain`):
+Typical builtin types that are containers (e.g. support `contains`):

-| class      | notes                                          |
-|------------|------------------------------------------------|
-| Collection | contains an element (1)                        |
-| Array      | faster maybe that Collection's                 |
-| List       | faster than Array's                            |
-| String     | character in string or substring in string (3) |
-| Range      | object is included in the range (2)            |
+| class        | notes                                          |
+|--------------|------------------------------------------------|
+| [Collection] | contains an element (1)                        |
+| Array        | faster maybe that Collection's                 |
+| List         | faster than Array's                            |
+| String       | character in string or substring in string (3) |
+| Range        | object is included in the range (2)            |
+| Buffer       | byte is in buffer                              |
+| RingBuffer   | object is in buffer                            |

 (1)
 : Iterable is not the container as it can be infinite

 (2)
-: Depending on the inclusivity and open/closed range parameters. BE careful here: String range is allowed, but it is usually not what you expect of it:
+: Depending on the inclusivity and open/closed range parameters. BE careful here: String range is allowed, but it is
+usually not what you expect of it:

    assert( "more" in "a".."z") // string range ok
    assert( 'x' !in "a".."z") // char in string range: probably error
@@ -766,7 +769,9 @@ Typical builtin types that are containers (e.g. support `conain`):
    >>> void

 (3)
-: `String` also can provide array of characters directly with `str.characters()`, which is [Iterable] and [Array]. String itself is not iterable as otherwise it will interfere when adding strigns to lists (it will add _characters_ it it would be iterable).
+: `String` also can provide array of characters directly with `str.characters()`, which is [Iterable] and [Array].
+String itself is not iterable as otherwise it will interfere when adding strigns to lists (it will add _characters_ it
+it would be iterable).

 So we recommend not to mix characters and string ranges; use `ch in str` that works
 as expected:
@@ -844,7 +849,8 @@ We can skip the rest of the loop and restart it, as usual, with `continue` opera
    "found even numbers: " + countEven
    >>> "found even numbers: 5"

-`continue` can't "return" anything: it just restarts the loop. It can use labeled loops to restart outer ones (we intentionally avoid using for loops here):
+`continue` can't "return" anything: it just restarts the loop. It can use labeled loops to restart outer ones (we
+intentionally avoid using for loops here):

    var count = 0
    var total = 0
@@ -890,21 +896,22 @@ test function (remember function return it's last expression result):
 ```mermaid
 flowchart TD
    S((start)) --> Cond{check}
-    Cond--false, no else--->V((void))
-    Cond--true-->E(["last = loop_body()" ])
-    E--break value---->BV((value))
-    E--> Check2{check}
-    E--break---->V
-    Check2 --false-->E
-    Check2 --true, no else--->L((last))
-    Check2 --true, else-->Else(["else_clause()"])
-    Cond--false, else--->Else
+    Cond -- false, no else ---> V((void))
+    Cond -- true --> E(["last = loop_body()"])
+    E -- break value ----> BV((value))
+    E --> Check2{check}
+    E -- break ----> V
+    Check2 -- false --> E
+    Check2 -- true, no else ---> L((last))
+    Check2 -- true, else --> Else(["else_clause()"])
+    Cond -- false, else ---> Else
    Else --> Ele4$nr((else))
 ```

 So the returned value, as seen from diagram could be one of:

- `void`, if the loop was not executed, e.g. `condition` was initially false, and there was no `else` clause, or if the empty break was executed.
+- `void`, if the loop was not executed, e.g. `condition` was initially false, and there was no `else` clause, or if the
+  empty break was executed.
 - value returned from `break value' statement
 - value returned from the `else` clause, of the loop was not broken
 - value returned from the last execution of loop body, if there was no `break` and no `else` clause.
@@ -928,7 +935,8 @@ available in the condition:
    } while( continueLoop )
    >>> "OK"

-This is sometimes convenient when condition is complex and has to be calculated inside the loop body. Notice the value returning by the loop:
+This is sometimes convenient when condition is complex and has to be calculated inside the loop body. Notice the value
+returning by the loop:

    fun readLine() { "done: result" }
    val result = do {
@@ -939,7 +947,6 @@ This is sometimes convenient when condition is complex and has to be calculated

 Suppose readLine() here reads some stream of lines.

-
 ## For loops

 For loop are intended to traverse collections, and all other objects that supports
@@ -982,7 +989,8 @@ We can use labels too:

 # Exception handling

-Very much like in Kotlin. Try block returns its body block result, if no exception was cauht, or the result from the catch block that caught the exception:
+Very much like in Kotlin. Try block returns its body block result, if no exception was cauht, or the result from the
+catch block that caught the exception:

    var error = "not caught"
    var finallyCaught = false
@@ -1029,13 +1037,12 @@ And even shortest, for the Lying lang tradition, missing var is `it`:
    assert( caught is IllegalArgumentException )
    >>> void

-It is possible to catch several exceptions in the same block too, use 
+It is possible to catch several exceptions in the same block too, use
 `catch( varName: ExceptionClass1, ExceptionClass2)`, etc, use short form of throw and
 many more.

 - see [exception handling](exceptions_handling.md) for detailed exceptions tutorial and reference.

-
 # Self-assignments in expression

 There are auto-increments and auto-decrements:
@@ -1111,6 +1118,27 @@ These should be imported from [lyng.time](time.md). For example:

 See [more docs on time manipulation](time.md)

+# Enums
+
+For the moment, only simple enums are implemented. Enum is a list of constants, represented also by their
+_ordinal_ - [Int] value.
+
+    enum Color {
+        RED, GREEN, BLUE
+    }
+    
+    assert( Color.RED is Color )
+
+    assertEquals( 2, Color.BLUE.ordinal )
+    assertEquals( "BLUE", Color.BLUE.name )
+    
+    assertEquals( [Color.RED,Color.GREEN,Color.BLUE], Color.entries)
+    assertEquals( Color.valueOf("GREEN"), Color.GREEN )
+    >>> void
+
+Enums are serialized as ordinals. Please note that due to caching, serialized string arrays could be even more compact
+than enum arrays, until `Lynon.encodeTyped` will be implemented.
+
 # Comments

    // single line comment
@@ -1137,16 +1165,41 @@ See also [math operations](math.md)

 The type for the character objects is `Char`.

+### String literal escapes
+
+| escape | ASCII value           |
+|--------|-----------------------|
+| \n     | 0x10, newline         |
+| \r     | 0x13, carriage return |
+| \t     | 0x07, tabulation      |
+| \\     | \ slash character     |
+| \"     | " double quote        |
+
+Other `\c` combinations, where c is any char except mentioned above, are left intact, e.g.:
+
+    val s = "\a"
+    assert(s[0] == '\')
+    assert(s[1] == 'a')
+    >>> void
+
+same as:
+
+    val s = "\\a"
+    assert(s[0] == '\')
+    assert(s[1] == 'a')
+    >>> void
+
 ### Char literal escapes

 Are the same as in string literals with little difference:

-| escape | ASCII value       |
-|--------|-------------------|
-| \n     | 0x10, newline     |
-| \t     | 0x07, tabulation  |
-| \\     | \ slash character |
-| \'     | ' apostrophe      |
+| escape | ASCII value           |
+|--------|-----------------------|
+| \n     | 0x10, newline         |
+| \r     | 0x13, carriage return |
+| \t     | 0x07, tabulation      |
+| \\     | \ slash character     |
+| \'     | ' apostrophe          |

 ### Char instance members

@@ -1158,7 +1211,6 @@ Are the same as in string literals with little difference:
 | code   | Int  | Unicode code for the character |
 |        |      |                                |

-
 ## String details

 Strings are arrays of Unicode characters. It can be indexed, and indexing will
@@ -1186,7 +1238,10 @@ To format a string use sprintf-style modifiers like:
    assertEquals( "hello :11    ", "%-6s:%-6d"(a, b) )
    >>> void

-List of format specifiers closely resembles C sprintf() one. See [format specifiers](https://github.com/sergeych/mp_stools?tab=readme-ov-file#sprintf-syntax-summary), this is doe using [mp_stools kotlin multiplatform library](https://github.com/sergeych/mp_stools). Currently supported Lyng types are `String`, `Int`, `Real`, `Bool`, the rest are displayed using their `toString()` representation.
+List of format specifiers closely resembles C sprintf() one.
+See [format specifiers](https://github.com/sergeych/mp_stools?tab=readme-ov-file#sprintf-syntax-summary), this is doe
+using [mp_stools kotlin multiplatform library](https://github.com/sergeych/mp_stools). Currently supported Lyng types
+are `String`, `Int`, `Real`, `Bool`, the rest are displayed using their `toString()` representation.

 This list will be extended.

@@ -1213,36 +1268,56 @@ Open-ended ranges could be used to get start and end too:

 ### String operations

-Concatenation is a `+`: `"hello " + name` works as expected. No confusion.
+Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also
+[Regex] support for strings, see the link, for example, whole string match:
+
+    assert( !"123".matches( "\d\d".re ) )
+    assert( "123".matches( "\d\d\d".re ) )
+    >>> void
+
+Extraction:
+
+    "abcd42def"[ "\d+".re ].value
+    >>> "42"
+
+Part match:
+
+    assert( "abc foo def" =~ "f[oO]+".re )
+    assert( "foo" == $~.value )
+    >>> void

 Typical set of String functions includes:

-| fun/prop          | description / notes                                        |
-|-------------------|------------------------------------------------------------|
-| lower()           | change case to unicode upper                               |
-| upper()           | change case to unicode lower                               |
+| fun/prop           | description / notes                                        |
+|--------------------|------------------------------------------------------------|
+| lower()            | change case to unicode upper                               |
+| upper()            | change case to unicode lower                               |
+| trim()             | trim space chars from both ends                            |
 | startsWith(prefix) | true if starts with a prefix                               |
-| endsWith(prefix)  | true if ends with a prefix                                 |
-| take(n)           | get a new string from up to n first characters             |
-| takeLast(n)       | get a new string from up to n last characters              |
-| drop(n)           | get a new string dropping n first chars, or empty string   |
-| dropLast(n)       | get a new string dropping n last chars, or empty string    |
-| size              | size in characters like `length` because String is [Array] |
-| (args...)         | sprintf-like formatting, see [string formatting]           |
-| [index]           | character at index                                         | 
-| [Range]           | substring at range                                         |
-| s1 + s2           | concatenation                                              |
-| s1 += s2          | self-modifying concatenation                               |
-| toReal()          | attempts to parse string as a Real value                   |
-| toInt()           | parse string to Int value                                  |
-| characters()      | create [List] of characters (1)                            |
-| encodeUtf8()      | returns [Buffer] with characters encoded to utf8           |
+| endsWith(prefix)   | true if ends with a prefix                                 |
+| take(n)            | get a new string from up to n first characters             |
+| takeLast(n)        | get a new string from up to n last characters              |
+| drop(n)            | get a new string dropping n first chars, or empty string   |
+| dropLast(n)        | get a new string dropping n last chars, or empty string    |
+| size               | size in characters like `length` because String is [Array] |
+| (args...)          | sprintf-like formatting, see [string formatting]           |
+| [index]            | character at index                                         | 
+| [Range]            | substring at range (2)                                     |
+| [Regex]            | find first match of regex, like [Regex.find] (2)           |
+| s1 + s2            | concatenation                                              |
+| s1 += s2           | self-modifying concatenation                               |
+| toReal()           | attempts to parse string as a Real value                   |
+| toInt()            | parse string to Int value                                  |
+| characters()       | create [List] of characters (1)                            |
+| encodeUtf8()       | returns [Buffer] with characters encoded to utf8           |
+| matches(re)        | matches the regular expression (2)                         |
+|                    |                                                            |

 (1)
 : List is mutable therefore a new copy is created on each call.

-
-
+(2)
+: See [Regex]

 ### Literals

@@ -1251,16 +1326,45 @@ String literal could be multiline:
    "Hello
    World"

-though multiline literals is yet work in progress.
+In this case, it will be passed literally ot "hello\n World". But, if there are
+several lines with common left indent, it will be removed, also, forst and last lines,
+if blank, will be removed too, for example:
+
+    println("
+            This is a multiline text.
+            This is a second line.
+        ")
+    >>> This is a multiline text.
+    >>> This is a second line.
+    >>> void
+
+- as expected, empty lines and common indent were removed. It is much like kotlin's `""" ... """.trimIndent()`
+  technique, but simpler ;)

 # Built-in functions

 See [math functions](math.md). Other general purpose functions are:

-| name                                         | description                                              |
-|----------------------------------------------|----------------------------------------------------------|
-| assert(condition,message="assertion failed") | runtime code check. There will be an option to skip them |
-| println(args...)                             | Open for overriding, it prints to stdout.                |
+| name                                  | description                                                |
+|---------------------------------------|------------------------------------------------------------|
+| assert(condition, fn)                 | (1) runtime code check with generic or custom nessage `fn` |
+| assertEquals(a,b)                     |                                                            |
+| assertNotEquals(a,b)                  |                                                            |
+| assertTrows { /* block */ }           |                                                            |
+| check(condition, message=<default>)   | throws IllegalStateException" of condition isn't met       |
+| require(condition, message=<default>) | throws IllegalArgumentException" of condition isn't met    |
+| println(args...)                      | Open for overriding, it prints to stdout with newline.     |
+| print(args...)                        | Open for overriding, it prints to stdout without newline.  |
+| flow {}                               | create flow sequence, see [parallelism]                    |
+| delay, launch, yield                  | see [parallelism]                                          |
+| cached(builder)                       | remembers builder() on first invocation and return it then |
+| let, also, apply, run                 | see above, flow controls                                   |
+
+(1)
+: `fn` is optional lambda returning string message to add to exception string. 
+Lambda avoid unnecessary execution if assertion is not failed. for example:
+
+    assert( x < 10 ) { "x=%s should be < 10"(x) } 

 # Built-in constants

@@ -1270,12 +1374,94 @@ See [math functions](math.md). Other general purpose functions are:
 | π                                   | See [math](math.md)          |

 [List]: List.md
+
 [Iterable]: Iterable.md
+
 [Iterator]: Iterator.md
+
 [Real]: Real.md
+
 [Range]: Range.md
-[String]: String.md
+
+[String]: development/String.md
+
 [string formatting]: https://github.com/sergeych/mp_stools?tab=readme-ov-file#sprintf-syntax-summary
+
 [Set]: Set.md
+
 [Map]: Map.md
-[Buffer]: Buffer.md
+
+[Buffer]: Buffer.md
+
+[parallelism]: parallelism.md
+
+[RingBuffer]: RingBuffer.md
+
+[Collection]: Collection.md
+
+[Array]: Array.md
+
+[Regex]: Regex.md
+
+## Multiple Inheritance (quick start)
+
+Lyng supports multiple inheritance (MI) with simple, predictable rules. For a full reference see OOP notes, this is a quick, copy‑paste friendly overview.
+
+Declare a class with multiple bases and pass constructor arguments to each base in the header:
+
+```
+class Foo(val a) {
+    var tag = "F"
+    fun runA() { "ResultA:" + a }
+    fun common() { "CommonA" }
+    private fun privateInFoo() {}
+    protected fun protectedInFoo() {}
+}
+
+class Bar(val b) {
+    var tag = "B"
+    fun runB() { "ResultB:" + b }
+    fun common() { "CommonB" }
+}
+
+class FooBar(a, b) : Foo(a), Bar(b) {
+    // Inside class bodies you can qualify with this@Type
+    fun fromFoo() { this@Foo.common() }
+    fun fromBar() { this@Bar.common() }
+}
+
+val fb = FooBar(1, 2)
+assertEquals("ResultA:1", fb.runA())
+assertEquals("ResultB:2", fb.runB())
+
+// Unqualified ambiguous member uses the first base (leftmost)
+assertEquals("CommonA", fb.common())
+
+// Disambiguate with casts
+assertEquals("CommonB", (fb as Bar).common())
+assertEquals("CommonA", (fb as Foo).common())
+
+// Field collisions: unqualified read/write uses the first in order
+assertEquals("F", fb.tag)
+fb.tag = "X"
+assertEquals("X", fb.tag)          // Foo.tag updated
+assertEquals("X", (fb as Foo).tag) // qualified read: Foo.tag
+assertEquals("B", (fb as Bar).tag) // qualified read: Bar.tag
+
+// Qualified write targets the chosen base storage
+(fb as Bar).tag = "Y"
+assertEquals("X", (fb as Foo).tag)
+assertEquals("Y", (fb as Bar).tag)
+
+// Optional casts with safe call
+class Buzz : Bar(3)
+val buzz = Buzz()
+assertEquals("ResultB:3", buzz.runB())
+assertEquals("ResultB:3", (buzz as? Bar)?.runB())
+assertEquals(null, (buzz as? Foo)?.runA())
+```
+
+Notes:
+- Resolution order uses C3 MRO (active): deterministic, monotonic order suitable for diamonds and complex hierarchies. Example: for `class D() : B(), C()` where both `B()` and `C()` derive from `A()`, the C3 order is `D → B → C → A`. The first visible match wins.
+- `private` is visible only inside the declaring class; `protected` is visible from the declaring class and any of its transitive subclasses. Qualification (`this@Type`) or casts do not bypass visibility.
+- Safe‑call `?.` works with `as?` for optional dispatch.
@@ -1,3 +1,20 @@
+#
+# Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#
+
 #Gradle
 org.gradle.jvmargs=-Xmx2048M -Dfile.encoding=UTF-8 -Dkotlin.daemon.jvm.options\="-Xmx2048M"
 org.gradle.caching=true
@@ -1,10 +1,10 @@
 [versions]
 agp = "8.5.2"
 clikt = "5.0.3"
-kotlin = "2.1.21"
+kotlin = "2.2.20"
 android-minSdk = "24"
 android-compileSdk = "34"
-kotlinx-coroutines = "1.10.1"
+kotlinx-coroutines = "1.10.2"
 mp_bintools = "0.1.12"
 firebaseCrashlyticsBuildtools = "3.0.3"
 okioVersion = "3.10.2"
@@ -1,3 +1,20 @@
+#
+# Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#
+
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
@@ -1,13 +1,13 @@
 #!/bin/sh

 #
-# Copyright © 2015-2021 the original authors.
+# Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
-#      https://www.apache.org/licenses/LICENSE-2.0
+#     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ -15,6 +15,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+#

 ##############################################################################
 #
@@ -1,5 +1,22 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 plugins {
-    kotlin("multiplatform") version "2.1.21"
+    kotlin("multiplatform") version "2.2.20"
 }

 group = "net.sergeych"
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych

 import com.github.ajalt.clikt.core.CliktCommand
@@ -10,10 +27,11 @@ import com.github.ajalt.clikt.parameters.options.flag
 import com.github.ajalt.clikt.parameters.options.option
 import kotlinx.coroutines.runBlocking
 import net.sergeych.lyng.LyngVersion
-import net.sergeych.lyng.Scope
+import net.sergeych.lyng.Script
 import net.sergeych.lyng.ScriptError
 import net.sergeych.lyng.Source
 import net.sergeych.lyng.obj.*
+import net.sergeych.mp_tools.globalDefer
 import okio.FileSystem
 import okio.Path.Companion.toPath
 import okio.SYSTEM
@@ -38,14 +56,13 @@ data class CommandResult(
    val error: String
 )

-val baseScope = Scope().apply {
-    addFn("exit") {
-        exit(requireOnlyArg<ObjInt>().toInt())
-        ObjVoid
+val baseScopeDefer = globalDefer {
+    Script.newScope().apply {
+        addFn("exit") {
+            exit(requireOnlyArg<ObjInt>().toInt())
+            ObjVoid
+        }
    }
-//    ObjString.type.addFn("shell") {
-//
-//    }
 }

 fun runMain(args: Array<String>) {
@@ -69,6 +86,7 @@ private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand()
    override val printHelpOnEmptyArgs = true

    val version by option("-v", "--version", help = "Print version and exit").flag()
+    val benchmark by option("--benchmark", help = "Run JVM microbenchmarks and exit").flag()
    val script by argument(help = "one or more scripts to execute").optional()
    val execute: String? by option(
        "-x", "--execute", help = """
@@ -88,41 +106,44 @@ private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand()
        """.trimIndent()

    override fun run() {
-        when {
-            version -> {
-                println("Lyng language version ${LyngVersion}")
-            }
+        runBlocking {
+            val baseScope = baseScopeDefer.await()
+            when {
+                version -> {
+                    println("Lyng language version ${LyngVersion}")
+                }

-            execute != null -> {
-                val objargs = mutableListOf<String>()
-                script?.let { objargs += it }
-                objargs += args
-                baseScope.addConst(
-                    "ARGV", ObjList(
-                        objargs.map { ObjString(it) }.toMutableList()
+                execute != null -> {
+                    val objargs = mutableListOf<String>()
+                    script?.let { objargs += it }
+                    objargs += args
+                    baseScope.addConst(
+                        "ARGV", ObjList(
+                            objargs.map { ObjString(it) }.toMutableList()
+                        )
                    )
-                )
-                launcher {
-                    // there is no script name, it is a first argument instead:
-                    processErrors {
-                        baseScope.eval(execute!!)
+                    launcher {
+                        // there is no script name, it is a first argument instead:
+                        processErrors {
+                            baseScope.eval(execute!!)
+                        }
                    }
                }
-            }

-            else -> {
-                if (script == null) {
-                    println(
-                        """
+                else -> {
+                    if (script == null) {
+                        println(
+                            """
                        
                        Error: no script specified.
                        
                    """.trimIndent()
-                    )
-                    echoFormattedHelp()
-                } else {
-                    baseScope.addConst("ARGV", ObjList(args.map { ObjString(it) }.toMutableList()))
-                    launcher { executeFile(script!!) }
+                        )
+                        echoFormattedHelp()
+                    } else {
+                        baseScope.addConst("ARGV", ObjList(args.map { ObjString(it) }.toMutableList()))
+                        launcher { executeFile(script!!) }
+                    }
                }
            }
        }
@@ -131,7 +152,7 @@ private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand()

 fun executeFileWithArgs(fileName: String, args: List<String>) {
    runBlocking {
-        baseScope.addConst("ARGV", ObjList(args.map { ObjString(it) }.toMutableList()))
+        baseScopeDefer.await().addConst("ARGV", ObjList(args.map { ObjString(it) }.toMutableList()))
        executeFile(fileName)
    }
 }
@@ -148,7 +169,7 @@ suspend fun executeFile(fileName: String) {
        text = text.substring(pos + 1)
    }
    processErrors {
-        baseScope.eval(Source(fileName, text))
+        baseScopeDefer.await().eval(Source(fileName, text))
    }
 }

@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych

 import kotlin.system.exitProcess
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
@file:Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")

 package net.sergeych
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng_cli
+
+import kotlinx.coroutines.runBlocking
+import net.sergeych.lyng.Compiler
+import net.sergeych.lyng.Script
+
+object BenchmarkRunner {
+    private fun format(nanos: Long, iters: Int): String {
+        val secs = nanos / 1_000_000_000.0
+        val ips = iters / secs
+        return "%.3f s, %.0f ops/s".format(secs, ips)
+    }
+
+    private suspend fun runCase(name: String, code: String, iters: Int): Pair<String, String> {
+        val script = Compiler.compile(code)
+        // warmup
+        repeat(2) { script.execute(Script.newScope()) }
+        val start = System.nanoTime()
+        repeat(iters) { script.execute(Script.newScope()) }
+        val end = System.nanoTime()
+        return name to format(end - start, iters)
+    }
+
+    fun runAll() = runBlocking {
+        val iterations = 2000
+        val cases = listOf(
+            // Field get/set in a loop
+            "field_inc" to """
+                class C { var x = 0 }
+                var c = C()
+                var i = 0
+                while( i < 1000 ) { c.x = c.x + 1; i = i + 1 }
+                c.x
+            """.trimIndent(),
+            // Pure arithmetic with literals
+            "arith_literals" to """
+                var s = 0
+                var i = 0
+                while( i < 1000 ) { s = s + 1 + 2 + 3 + 4 + 5; i = i + 1 }
+                s
+            """.trimIndent(),
+            // Method call overhead via instance method
+            "method_call" to """
+                class C { fun inc() { this.x = this.x + 1 } var x = 0 }
+                var c = C()
+                var i = 0
+                while( i < 1000 ) { c.inc(); i = i + 1 }
+                c.x
+            """.trimIndent()
+        )
+
+        println("[BENCHMARK] iterations per case: $iterations")
+        for ((name, code) in cases) {
+            val (n, res) = runCase(name, code, iterations)
+            println("[BENCHMARK] $n: $res")
+        }
+    }
+}
@@ -1,7 +1,28 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng_cli

 import net.sergeych.runMain

 fun main(args: Array<String>) {
+    if (args.contains("--benchmark")) {
+        BenchmarkRunner.runAll()
+        return
+    }
    runMain(args)
 }
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 import net.sergeych.runMain

 fun main(args: Array<String>) {
@@ -1,4 +1,23 @@
-@file:OptIn(ExperimentalForeignApi::class, ExperimentalForeignApi::class, ExperimentalForeignApi::class)
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+@file:OptIn(ExperimentalForeignApi::class, ExperimentalForeignApi::class, ExperimentalForeignApi::class,
+    ExperimentalForeignApi::class
+)

 package net.sergeych

@@ -1,10 +1,27 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 import com.codingfeline.buildkonfig.compiler.FieldSpec.Type.STRING
 import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
 import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget

 group = "net.sergeych"
-version = "0.8.0-SNAPSHOT"
+version = "1.0.0-SNAPSHOT"

 buildscript {
    repositories {
@@ -20,7 +37,7 @@ plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.androidLibrary)
 //    alias(libs.plugins.vanniktech.mavenPublish)
-    kotlin("plugin.serialization") version "2.2.0"
+    kotlin("plugin.serialization") version "2.1.0"
    id("com.codingfeline.buildkonfig") version "0.17.1"
    `maven-publish`
 }
@@ -45,10 +62,14 @@ kotlin {
            jvmTarget.set(JvmTarget.JVM_11)
        }
    }
-//    iosX64()
-//    iosArm64()
-//    iosSimulatorArm64()
+    iosX64()
+    iosArm64()
+    iosSimulatorArm64()
+    macosX64()
+    macosArm64()
+    mingwX64()
    linuxX64()
+    linuxArm64()
    js {
        browser()
        nodejs()
@@ -62,9 +83,10 @@ kotlin {
    sourceSets {
        all {
            languageSettings.optIn("kotlinx.coroutines.ExperimentalCoroutinesApi")
-            languageSettings.optIn("kotlin.contracts.ExperimentalContracts")
            languageSettings.optIn("kotlin.ExperimentalUnsignedTypes")
            languageSettings.optIn("kotlin.coroutines.DelicateCoroutinesApi")
+            languageSettings.optIn("kotlin.contracts.ExperimentalContracts")
+            languageSettings.optIn("kotlinx.coroutines.flow.DelicateCoroutinesApi")
        }

        val commonMain by getting {
@@ -120,6 +142,14 @@ publishing {
    }
 }

+// Ensure JVM test stdout is visible and runs are single-threaded for stable timings
+tasks.withType<org.gradle.api.tasks.testing.Test> {
+    testLogging {
+        showStandardStreams = true
+    }
+    maxParallelForks = 1
+}
+
 //mavenPublishing {
 //    publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
 //
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng
+
+import net.sergeych.lyng.obj.Obj
+
+actual object ArgBuilderProvider {
+    private val tl = object : ThreadLocal<AndroidArgsBuilder>() {
+        override fun initialValue(): AndroidArgsBuilder = AndroidArgsBuilder()
+    }
+    actual fun acquire(): ArgsBuilder = tl.get()
+}
+
+private class AndroidArgsBuilder : ArgsBuilder {
+    private val buf: ArrayList<Obj> = ArrayList(8)
+
+    override fun reset(expectedSize: Int) {
+        buf.clear()
+        if (expectedSize > 0) buf.ensureCapacity(expectedSize)
+    }
+
+    override fun add(v: Obj) { buf.add(v) }
+
+    override fun addAll(vs: List<Obj>) {
+        if (vs.isNotEmpty()) {
+            buf.ensureCapacity(buf.size + vs.size)
+            buf.addAll(vs)
+        }
+    }
+
+    override fun build(tailBlockMode: Boolean): Arguments = Arguments(buf.toList(), tailBlockMode)
+
+    override fun release() { /* no-op, ThreadLocal keeps buffer */ }
+}
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng
+
+actual object PerfDefaults {
+    actual val LOCAL_SLOT_PIC: Boolean = true
+    actual val EMIT_FAST_LOCAL_REFS: Boolean = true
+
+    actual val ARG_BUILDER: Boolean = true
+    actual val SKIP_ARGS_ON_NULL_RECEIVER: Boolean = true
+    actual val SCOPE_POOL: Boolean = false
+
+    actual val FIELD_PIC: Boolean = true
+    actual val METHOD_PIC: Boolean = true
+    actual val FIELD_PIC_SIZE_4: Boolean = false
+    actual val METHOD_PIC_SIZE_4: Boolean = false
+    actual val PIC_ADAPTIVE_2_TO_4: Boolean = false
+    actual val PIC_ADAPTIVE_METHODS_ONLY: Boolean = false
+    actual val PIC_ADAPTIVE_HEURISTIC: Boolean = false
+
+    actual val PIC_DEBUG_COUNTERS: Boolean = false
+
+    actual val PRIMITIVE_FASTOPS: Boolean = true
+    actual val RVAL_FASTPATH: Boolean = true
+    // Regex caching aligns with JVM behavior on Android (Dalvik/ART)
+    actual val REGEX_CACHE: Boolean = true
+    actual val ARG_SMALL_ARITY_12: Boolean = false
+    actual val INDEX_PIC_SIZE_4: Boolean = false
+    actual val RANGE_FAST_ITER: Boolean = false
+}
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng
+
+import net.sergeych.lyng.obj.Obj
+import net.sergeych.lyng.obj.ObjVoid
+
+/**
+ * Android actual: per-thread scope frame pool backed by ThreadLocal.
+ */
+actual object ScopePool {
+    private const val MAX_POOL_SIZE = 64
+    private val threadLocalPool: ThreadLocal<ArrayDeque<Scope>?> = ThreadLocal()
+
+    private fun pool(): ArrayDeque<Scope> {
+        var p = threadLocalPool.get()
+        if (p == null) {
+            p = ArrayDeque<Scope>(MAX_POOL_SIZE)
+            threadLocalPool.set(p)
+        }
+        return p
+    }
+
+    actual fun borrow(parent: Scope, args: Arguments, pos: Pos, thisObj: Obj): Scope {
+        val pool = pool()
+        val s = if (pool.isNotEmpty()) pool.removeLast() else Scope(parent, args, pos, thisObj)
+        if (s.parent !== parent || s.args !== args || s.pos !== pos || s.thisObj !== thisObj) {
+            s.resetForReuse(parent, args, pos, thisObj)
+        } else {
+            s.frameId = nextFrameId()
+        }
+        return s
+    }
+
+    actual fun release(scope: Scope) {
+        val pool = pool()
+        scope.resetForReuse(parent = null, args = Arguments.EMPTY, pos = Pos.builtIn, thisObj = ObjVoid)
+        if (pool.size < MAX_POOL_SIZE) pool.addLast(scope)
+    }
+}
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 enum class AccessType(val isMutable: Boolean) {
@@ -1,19 +0,0 @@
-package net.sergeych.lyng
-
-import net.sergeych.lyng.obj.ObjRecord
-
-/**
- * Special version of the [Scope] used to `apply` new this object to
- * _parent context property.
- *
- * @param _parent context to apply to
- * @param args arguments for the new context
- * @param appliedScope the new context to apply, it will have lower priority except for `this` which
- *      will be reset by appliedContext's `this`.
- */
-class AppliedScope(_parent: Scope, args: Arguments, val appliedScope: Scope)
-    : Scope(_parent, args, appliedScope.pos, appliedScope.thisObj) {
-    override fun get(name: String): ObjRecord? =
-        if (name == "this") thisObj.asReadonly
-        else super.get(name) ?: appliedScope[name]
-}
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng
+
+import net.sergeych.lyng.obj.Obj
+
+/**
+ * Expect/actual API for an arguments builder that can reuse buffers on JVM to reduce allocations.
+ * Default (non-JVM) implementation just allocates fresh collections and has no pooling.
+ */
+expect object ArgBuilderProvider {
+    fun acquire(): ArgsBuilder
+}
+
+interface ArgsBuilder {
+    /** Prepare the builder for a new build, optionally hinting capacity. */
+    fun reset(expectedSize: Int = 0)
+    fun add(v: Obj)
+    fun addAll(vs: List<Obj>)
+    /** Build immutable [Arguments] snapshot from the current buffer. */
+    fun build(tailBlockMode: Boolean): Arguments
+    /** Return builder to pool/reset state. Safe to no-op on non-JVM. */
+    fun release()
+}
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng
+
+import net.sergeych.lyng.obj.Obj
+
+/**
+ * Helper factory for argument-building mutable lists.
+ * Currently returns a fresh ArrayList with the requested initial capacity.
+ * JVM-specific pooling/builder can be introduced later via expect/actual without
+ * changing call sites that use [newArgMutableList].
+ */
+fun newArgMutableList(initialCapacity: Int): MutableList<Obj> = ArrayList(initialCapacity)
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 import net.sergeych.lyng.obj.Obj
@@ -31,12 +48,12 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
        arguments: Arguments = scope.args,
        defaultAccessType: AccessType = AccessType.Var,
        defaultVisibility: Visibility = Visibility.Public,
-        defaultRecordType: ObjRecord.Type = ObjRecord.Type.ConstructorField
    ) {
        fun assign(a: Item, value: Obj) {
-            scope.addItem(a.name, (a.accessType ?: defaultAccessType).isMutable, value,
+            scope.addItem(a.name, (a.accessType ?: defaultAccessType).isMutable,
+                value.byValueCopy(),
                a.visibility ?: defaultVisibility,
-                recordType = defaultRecordType)
+                recordType = ObjRecord.Type.Argument)
        }

        // will be used with last lambda arg fix
@@ -1,57 +1,258 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 import net.sergeych.lyng.obj.Obj
 import net.sergeych.lyng.obj.ObjIterable
 import net.sergeych.lyng.obj.ObjList

-data class ParsedArgument(val value: Statement, val pos: Pos, val isSplat: Boolean = false)
+ data class ParsedArgument(val value: Statement, val pos: Pos, val isSplat: Boolean = false)
+ 
+ suspend fun Collection<ParsedArgument>.toArguments(scope: Scope, tailBlockMode: Boolean): Arguments {
+     // Small-arity fast path (no splats) to reduce allocations
+     if (PerfFlags.ARG_BUILDER) {
+        val limit = if (PerfFlags.ARG_SMALL_ARITY_12) 12 else 8
+         var hasSplat = false
+         var count = 0
+         for (pa in this) {
+             if (pa.isSplat) { hasSplat = true; break }
+             count++
+            if (count > limit) break
+         }
+         if (!hasSplat && count == this.size) {
+             val quick = when (count) {
+                 0 -> Arguments.EMPTY
+                 1 -> Arguments(listOf(this.elementAt(0).value.execute(scope)), tailBlockMode)
+                 2 -> {
+                     val a0 = this.elementAt(0).value.execute(scope)
+                     val a1 = this.elementAt(1).value.execute(scope)
+                     Arguments(listOf(a0, a1), tailBlockMode)
+                 }
+                 3 -> {
+                     val a0 = this.elementAt(0).value.execute(scope)
+                     val a1 = this.elementAt(1).value.execute(scope)
+                     val a2 = this.elementAt(2).value.execute(scope)
+                     Arguments(listOf(a0, a1, a2), tailBlockMode)
+                 }
+                 4 -> {
+                     val a0 = this.elementAt(0).value.execute(scope)
+                     val a1 = this.elementAt(1).value.execute(scope)
+                     val a2 = this.elementAt(2).value.execute(scope)
+                     val a3 = this.elementAt(3).value.execute(scope)
+                     Arguments(listOf(a0, a1, a2, a3), tailBlockMode)
+                 }
+                 5 -> {
+                     val a0 = this.elementAt(0).value.execute(scope)
+                     val a1 = this.elementAt(1).value.execute(scope)
+                     val a2 = this.elementAt(2).value.execute(scope)
+                     val a3 = this.elementAt(3).value.execute(scope)
+                     val a4 = this.elementAt(4).value.execute(scope)
+                     Arguments(listOf(a0, a1, a2, a3, a4), tailBlockMode)
+                 }
+                 6 -> {
+                     val a0 = this.elementAt(0).value.execute(scope)
+                     val a1 = this.elementAt(1).value.execute(scope)
+                     val a2 = this.elementAt(2).value.execute(scope)
+                     val a3 = this.elementAt(3).value.execute(scope)
+                     val a4 = this.elementAt(4).value.execute(scope)
+                     val a5 = this.elementAt(5).value.execute(scope)
+                     Arguments(listOf(a0, a1, a2, a3, a4, a5), tailBlockMode)
+                 }
+                 7 -> {
+                     val a0 = this.elementAt(0).value.execute(scope)
+                     val a1 = this.elementAt(1).value.execute(scope)
+                     val a2 = this.elementAt(2).value.execute(scope)
+                     val a3 = this.elementAt(3).value.execute(scope)
+                     val a4 = this.elementAt(4).value.execute(scope)
+                     val a5 = this.elementAt(5).value.execute(scope)
+                     val a6 = this.elementAt(6).value.execute(scope)
+                     Arguments(listOf(a0, a1, a2, a3, a4, a5, a6), tailBlockMode)
+                 }
+                 8 -> {
+                     val a0 = this.elementAt(0).value.execute(scope)
+                     val a1 = this.elementAt(1).value.execute(scope)
+                     val a2 = this.elementAt(2).value.execute(scope)
+                     val a3 = this.elementAt(3).value.execute(scope)
+                     val a4 = this.elementAt(4).value.execute(scope)
+                     val a5 = this.elementAt(5).value.execute(scope)
+                     val a6 = this.elementAt(6).value.execute(scope)
+                     val a7 = this.elementAt(7).value.execute(scope)
+                     Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7), tailBlockMode)
+                 }
+                9 -> if (PerfFlags.ARG_SMALL_ARITY_12) {
+                    val a0 = this.elementAt(0).value.execute(scope)
+                    val a1 = this.elementAt(1).value.execute(scope)
+                    val a2 = this.elementAt(2).value.execute(scope)
+                    val a3 = this.elementAt(3).value.execute(scope)
+                    val a4 = this.elementAt(4).value.execute(scope)
+                    val a5 = this.elementAt(5).value.execute(scope)
+                    val a6 = this.elementAt(6).value.execute(scope)
+                    val a7 = this.elementAt(7).value.execute(scope)
+                    val a8 = this.elementAt(8).value.execute(scope)
+                    Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8), tailBlockMode)
+                } else null
+                10 -> if (PerfFlags.ARG_SMALL_ARITY_12) {
+                    val a0 = this.elementAt(0).value.execute(scope)
+                    val a1 = this.elementAt(1).value.execute(scope)
+                    val a2 = this.elementAt(2).value.execute(scope)
+                    val a3 = this.elementAt(3).value.execute(scope)
+                    val a4 = this.elementAt(4).value.execute(scope)
+                    val a5 = this.elementAt(5).value.execute(scope)
+                    val a6 = this.elementAt(6).value.execute(scope)
+                    val a7 = this.elementAt(7).value.execute(scope)
+                    val a8 = this.elementAt(8).value.execute(scope)
+                    val a9 = this.elementAt(9).value.execute(scope)
+                    Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9), tailBlockMode)
+                } else null
+                11 -> if (PerfFlags.ARG_SMALL_ARITY_12) {
+                    val a0 = this.elementAt(0).value.execute(scope)
+                    val a1 = this.elementAt(1).value.execute(scope)
+                    val a2 = this.elementAt(2).value.execute(scope)
+                    val a3 = this.elementAt(3).value.execute(scope)
+                    val a4 = this.elementAt(4).value.execute(scope)
+                    val a5 = this.elementAt(5).value.execute(scope)
+                    val a6 = this.elementAt(6).value.execute(scope)
+                    val a7 = this.elementAt(7).value.execute(scope)
+                    val a8 = this.elementAt(8).value.execute(scope)
+                    val a9 = this.elementAt(9).value.execute(scope)
+                    val a10 = this.elementAt(10).value.execute(scope)
+                    Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10), tailBlockMode)
+                } else null
+                12 -> if (PerfFlags.ARG_SMALL_ARITY_12) {
+                    val a0 = this.elementAt(0).value.execute(scope)
+                    val a1 = this.elementAt(1).value.execute(scope)
+                    val a2 = this.elementAt(2).value.execute(scope)
+                    val a3 = this.elementAt(3).value.execute(scope)
+                    val a4 = this.elementAt(4).value.execute(scope)
+                    val a5 = this.elementAt(5).value.execute(scope)
+                    val a6 = this.elementAt(6).value.execute(scope)
+                    val a7 = this.elementAt(7).value.execute(scope)
+                    val a8 = this.elementAt(8).value.execute(scope)
+                    val a9 = this.elementAt(9).value.execute(scope)
+                    val a10 = this.elementAt(10).value.execute(scope)
+                    val a11 = this.elementAt(11).value.execute(scope)
+                    Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11), tailBlockMode)
+                } else null
+                 else -> null
+             }
+             if (quick != null) return quick
+         }
+     }
+     // Single-splat fast path: if there is exactly one splat argument that evaluates to ObjList,
+     // avoid builder and copies by returning its list directly.
+     if (PerfFlags.ARG_BUILDER) {
+         if (this.size == 1) {
+             val only = this.first()
+             if (only.isSplat) {
+                 val v = only.value.execute(scope)
+                 if (v is ObjList) {
+                     return Arguments(v.list, tailBlockMode)
+                 } else if (v.isInstanceOf(ObjIterable)) {
+                     // Convert iterable to list once and return directly
+                     val i = (v.invokeInstanceMethod(scope, "toList") as ObjList).list
+                     return Arguments(i, tailBlockMode)
+                 } else {
+                     scope.raiseClassCastError("expected list of objects for splat argument")
+                 }
+             }
+         }
+     }

-suspend fun Collection<ParsedArgument>.toArguments(scope: Scope, tailBlockMode: Boolean): Arguments {
-    val list = mutableListOf<Obj>()
-
-    for (x in this) {
-        val value = x.value.execute(scope)
-        if (x.isSplat) {
-            when {
-                value is ObjList -> {
-                    for (subitem in value.list) list.add(subitem)
-                }
-
-                value.isInstanceOf(ObjIterable) -> {
-                    val i = (value.invokeInstanceMethod(scope, "toList") as ObjList).list
-                    i.forEach { list.add(it) }
-                }
-
-                else -> scope.raiseClassCastError("expected list of objects for splat argument")
-            }
-        } else
-            list.add(value)
-    }
-    return Arguments(list,tailBlockMode)
-}
-
-data class Arguments(val list: List<Obj>, val tailBlockMode: Boolean = false) : List<Obj> by list {
-
-    constructor(vararg values: Obj) : this(values.toList())
-
-    fun firstAndOnly(pos: Pos = Pos.UNKNOWN): Obj {
-        if (list.size != 1) throw ScriptError(pos, "expected one argument, got ${list.size}")
-        return list.first()
-    }
-
-    /**
-     * Convert to list of kotlin objects, see [Obj.toKotlin].
-     */
-    suspend fun toKotlinList(scope: Scope): List<Any?> {
-        return list.map { it.toKotlin(scope) }
-    }
-
-    fun inspect(): String = list.joinToString(", ") { it.inspect() }
-
-
-    companion object {
-        val EMPTY = Arguments(emptyList())
-        fun from(values: Collection<Obj>) = Arguments(values.toList())
-    }
-}
+     // General path with builder or simple list fallback
+     if (PerfFlags.ARG_BUILDER) {
+         val b = ArgBuilderProvider.acquire()
+         try {
+             b.reset(this.size)
+             for (x in this) {
+                 val value = x.value.execute(scope)
+                 if (x.isSplat) {
+                     when {
+                         value is ObjList -> {
+                             b.addAll(value.list)
+                         }
+                         value.isInstanceOf(ObjIterable) -> {
+                             val i = (value.invokeInstanceMethod(scope, "toList") as ObjList).list
+                             b.addAll(i)
+                         }
+                         else -> scope.raiseClassCastError("expected list of objects for splat argument")
+                     }
+                 } else {
+                     b.add(value)
+                 }
+             }
+             return b.build(tailBlockMode)
+         } finally {
+             b.release()
+         }
+     } else {
+         val list: MutableList<Obj> = mutableListOf()
+         for (x in this) {
+             val value = x.value.execute(scope)
+             if (x.isSplat) {
+                 when {
+                     value is ObjList -> list.addAll(value.list)
+                     value.isInstanceOf(ObjIterable) -> {
+                         val i = (value.invokeInstanceMethod(scope, "toList") as ObjList).list
+                         list.addAll(i)
+                     }
+                     else -> scope.raiseClassCastError("expected list of objects for splat argument")
+                 }
+             } else {
+                 list.add(value)
+             }
+         }
+         return Arguments(list, tailBlockMode)
+     }
+  }
+ 
+ data class Arguments(val list: List<Obj>, val tailBlockMode: Boolean = false) : List<Obj> by list {
+ 
+     constructor(vararg values: Obj) : this(values.toList())
+ 
+     fun firstAndOnly(pos: Pos = Pos.UNKNOWN): Obj {
+         if (list.size != 1) throw ScriptError(pos, "expected one argument, got ${list.size}")
+         val v = list.first()
+         // Tiny micro-alloc win: avoid byValueCopy for immutable singletons
+         return when (v) {
+             net.sergeych.lyng.obj.ObjNull,
+             net.sergeych.lyng.obj.ObjTrue,
+            net.sergeych.lyng.obj.ObjFalse,
+            // Immutable scalars: safe to return directly
+            is net.sergeych.lyng.obj.ObjInt,
+            is net.sergeych.lyng.obj.ObjReal,
+            is net.sergeych.lyng.obj.ObjChar,
+            is net.sergeych.lyng.obj.ObjString -> v
+             else -> v.byValueCopy()
+         }
+     }
+ 
+     /**
+      * Convert to list of kotlin objects, see [Obj.toKotlin].
+      */
+     suspend fun toKotlinList(scope: Scope): List<Any?> {
+         return list.map { it.toKotlin(scope) }
+     }
+ 
+     suspend fun inspect(scope: Scope): String = list.map{ it.inspect(scope)}.joinToString(",")
+ 
+     companion object {
+         val EMPTY = Arguments(emptyList())
+         fun from(values: Collection<Obj>) = Arguments(values.toList())
+     }
+ }

@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 //fun buildDoubleFromParts(
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng
+
+import net.sergeych.lyng.obj.ObjRecord
+
+/**
+ * Scope that adds a "closure" to caller; most often it is used to apply class instance to caller scope.
+ * Inherits [Scope.args] and [Scope.thisObj] from [callScope] and adds lookup for symbols
+ * from [closureScope] with proper precedence
+ */
+class ClosureScope(val callScope: Scope, val closureScope: Scope) :
+    // Important: use closureScope.thisObj so unqualified members (e.g., fields) resolve to the instance
+    // we captured, not to the caller's `this` (e.g., FlowBuilder).
+    Scope(callScope, callScope.args, thisObj = closureScope.thisObj) {
+
+    init {
+        // Preserve the lexical class context of the closure by default. This ensures that lambdas
+        // created inside a class method keep access to that class's private/protected members even
+        // when executed from within another object's method (e.g., Mutex.withLock), which may set
+        // its own currentClassCtx temporarily. If the closure has no class context, inherit caller's.
+        this.currentClassCtx = closureScope.currentClassCtx ?: callScope.currentClassCtx
+    }
+
+    override fun get(name: String): ObjRecord? {
+        // Priority:
+        // 1) Locals and arguments declared in this lambda frame (including values defined before suspension)
+        // 2) Instance/class members of the captured receiver (`closureScope.thisObj`), e.g., fields like `coll`, `factor`
+        // 3) Symbols from the captured closure scope (its locals and parents)
+        // 4) Instance members of the caller's `this` (e.g., FlowBuilder.emit)
+        // 5) Fallback to the standard chain (this frame -> parent (callScope) -> class members)
+
+        // First, prefer locals/arguments bound in this frame
+        super.objects[name]?.let { return it }
+
+        // Prefer instance fields/methods declared on the captured receiver:
+        // First, resolve real instance fields stored in the instance scope (constructor vars like `coll`, `factor`)
+        (closureScope.thisObj as? net.sergeych.lyng.obj.ObjInstance)
+            ?.instanceScope
+            ?.objects
+            ?.get(name)
+            ?.let { return it }
+
+        // Then, try class-declared members (methods/properties declared in the class body)
+        closureScope.thisObj.objClass.getInstanceMemberOrNull(name)?.let { return it }
+
+        // Then delegate to the full closure scope chain (locals, parents, etc.)
+        closureScope.get(name)?.let { return it }
+
+        // Allow resolving instance members of the caller's `this` (e.g., FlowBuilder.emit)
+        callScope.thisObj.objClass.getInstanceMemberOrNull(name)?.let { return it }
+
+        // Fallback to the standard lookup chain: this frame -> parent (callScope) -> class members
+        return super.get(name)
+    }
+}
+
+class ApplyScope(_parent: Scope,val applied: Scope) : Scope(_parent, thisObj = applied.thisObj) {
+
+    override fun get(name: String): ObjRecord? {
+        return applied.get(name) ?: super.get(name)
+    }
+
+    override fun applyClosure(closure: Scope): Scope {
+        return this
+    }
+
+}
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng
+
+sealed class CodeContext {
+    class Module(@Suppress("unused") val packageName: String?): CodeContext()
+    class Function(val name: String): CodeContext()
+    class ClassBody(val name: String): CodeContext()
+}
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 class CompilerContext(val tokens: List<Token>) {
@@ -20,9 +37,8 @@ class CompilerContext(val tokens: List<Token>) {
    fun hasNext() = currentIndex < tokens.size
    fun hasPrevious() = currentIndex > 0
    fun next() =
-        if( currentIndex < tokens.size ) tokens[currentIndex++]
+        if (currentIndex < tokens.size) tokens[currentIndex++]
        else Token("", tokens.last().pos, Token.Type.EOF)
-//        throw IllegalStateException("No more tokens")

    fun previous() = if (!hasPrevious()) throw IllegalStateException("No previous token") else tokens[--currentIndex]

@@ -49,6 +65,10 @@ class CompilerContext(val tokens: List<Token>) {
        throw ScriptError(at, message)
    }

+    fun syntaxError(message: String = "Syntax error"): Nothing {
+        throw ScriptError(currentPos(), message)
+    }
+
    fun currentPos(): Pos = tokens[currentIndex].pos

    /**
@@ -57,7 +77,7 @@ class CompilerContext(val tokens: List<Token>) {
     */
    fun skipId(name: String): Boolean {
        current().let { t ->
-            if( t.type == Token.Type.ID && t.value == name ) {
+            if (t.type == Token.Type.ID && t.value == name) {
                next()
                return true
            }
@@ -89,6 +109,20 @@ class CompilerContext(val tokens: List<Token>) {
        } else true
    }

+    /**
+     * If next token is one of these types, skip it.
+     * @return true if token was found and skipped
+     */
+    fun skipNextIf(vararg types: Token.Type): Boolean {
+        val t = next()
+        return if (t.type in types)
+            true
+        else {
+            previous()
+            false
+        }
+    }
+
    @Suppress("unused")
    fun skipTokens(vararg tokenTypes: Token.Type) {
        while (next().type in tokenTypes) { /**/
@@ -96,6 +130,28 @@ class CompilerContext(val tokens: List<Token>) {
        previous()
    }

+    fun nextNonWhitespace(): Token {
+        while (true) {
+            val t = next()
+            if (t.type !in wstokens) return t
+        }
+    }
+
+    /**
+     * Find next non-whitespace token and return it. The token is not extracted,
+     * is will be returned on [next] call.
+     * @return next non-whitespace token without extracting it from tokens list
+     */
+    fun peekNextNonWhitespace(): Token {
+        while (true) {
+            val t = next()
+            if (t.type !in wstokens) {
+                previous()
+                return t
+            }
+        }
+    }
+

    inline fun ifNextIs(typeId: Token.Type, f: (Token) -> Unit): Boolean {
        val t = next()
@@ -108,6 +164,7 @@ class CompilerContext(val tokens: List<Token>) {
        }
    }

+    @Suppress("NOTHING_TO_INLINE")
    inline fun addBreak() {
        breakFound = true
    }
@@ -139,19 +196,24 @@ class CompilerContext(val tokens: List<Token>) {
    fun matchQualifiers(keyword: String, vararg qualifiers: String): Boolean {
        val pos = savePos()
        var count = 0
-        while( count < qualifiers.size) {
+        while (count < qualifiers.size) {
            val t = next()
-            when(t.type) {
+            when (t.type) {
                Token.Type.ID -> {
-                    if( t.value in qualifiers ) count++
-                    else { restorePos(pos); return false }
+                    if (t.value in qualifiers) count++
+                    else {
+                        restorePos(pos); return false
+                    }
                }
+
                Token.Type.MULTILINE_COMMENT, Token.Type.SINLGE_LINE_COMMENT, Token.Type.NEWLINE -> {}
-                else -> { restorePos(pos); return false }
+                else -> {
+                    restorePos(pos); return false
+                }
            }
        }
        val t = next()
-        if( t.type == Token.Type.ID && t.value == keyword ) {
+        if (t.type == Token.Type.ID && t.value == keyword) {
            return true
        } else {
            restorePos(pos)
@@ -164,10 +226,10 @@ class CompilerContext(val tokens: List<Token>) {
     * Note that [Token.Type.EOF] is not considered a whitespace token.
     */
    fun skipWsTokens(): Token {
-        while( current().type in wstokens ) {
+        while (current().type in wstokens) {
            next()
        }
-        return next()
+        return current()
    }

    companion object {
@@ -1,9 +1,26 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

-import net.sergeych.lyng.obj.Accessor
+import net.sergeych.lyng.obj.ObjRef

 sealed class ListEntry {
-    data class Element(val accessor: Accessor) : ListEntry()
+    data class Element(val ref: ObjRef) : ListEntry()

-    data class Spread(val accessor: Accessor) : ListEntry()
+    data class Spread(val ref: ObjRef) : ListEntry()
 }
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 import net.sergeych.lyng.obj.Obj
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 import net.sergeych.lyng.obj.ObjRecord
@@ -1,12 +1,29 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 val digitsSet = ('0'..'9').toSet()
 val digits = { d: Char -> d in digitsSet }
 val hexDigits = digitsSet + ('a'..'f') + ('A'..'F')
-val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() }
+val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() || d == '$' || d == '~' }

@Suppress("unused")
-val idFirstChars = { d: Char -> d.isLetter() || d == '_' }
+val idFirstChars = { d: Char -> d.isLetter() || d == '_' || d == '$' }

 fun parseLyng(source: Source): List<Token> {
    val p = Parser(fromPos = source.startPos)
@@ -50,13 +67,16 @@ private class Parser(fromPos: Pos) {
                            pos.advance()
                            Token("===", from, Token.Type.REF_EQ)
                        }
+
                        else -> Token("==", from, Token.Type.EQ)
                    }
-                } else if( currentChar == '>' ) {
+                } else if (currentChar == '>') {
                    pos.advance()
                    Token("=>", from, Token.Type.EQARROW)
-                }
-                else
+                } else if (currentChar == '~') {
+                    pos.advance()
+                    Token("=~", from, Token.Type.MATCH)
+                } else
                    Token("=", from, Token.Type.ASSIGN)
            }

@@ -171,6 +191,10 @@ private class Parser(fromPos: Pos) {
                    } else {
                        Token("<=", from, Token.Type.LTE)
                    }
+                } else if (currentChar == '<') {
+                    // Shift left <<
+                    pos.advance()
+                    Token("<<", from, Token.Type.SHL)
                } else
                    Token("<", from, Token.Type.LT)
            }
@@ -179,6 +203,10 @@ private class Parser(fromPos: Pos) {
                if (currentChar == '=') {
                    pos.advance()
                    Token(">=", from, Token.Type.GTE)
+                } else if (currentChar == '>') {
+                    // Shift right >>
+                    pos.advance()
+                    Token(">>", from, Token.Type.SHR)
                } else
                    Token(">", from, Token.Type.GT)
            }
@@ -210,6 +238,9 @@ private class Parser(fromPos: Pos) {
                            Token("!==", from, Token.Type.REF_NEQ)
                        } else
                            Token("!=", from, Token.Type.NEQ)
+                    } else if (currentChar == '~') {
+                        pos.advance()
+                        Token("!~", from, Token.Type.NOTMATCH)
                    } else
                        Token("!", from, Token.Type.NOT)
            }
@@ -230,6 +261,10 @@ private class Parser(fromPos: Pos) {
                    Token("&", from, Token.Type.BITAND)
            }

+            '^' -> Token("^", from, Token.Type.BITXOR)
+
+            '~' -> Token("~", from, Token.Type.BITNOT)
+
            '@' -> {
                val label = loadChars(idNextChars)
                if (label.isNotEmpty()) Token(label, from, Token.Type.ATLABEL)
@@ -250,7 +285,7 @@ private class Parser(fromPos: Pos) {

            in digitsSet -> {
                pos.back()
-                decodeNumber(loadChars { it in digitsSet || it == '_'}, from)
+                decodeNumber(loadChars { it in digitsSet || it == '_' }, from)
            }

            '\'' -> {
@@ -274,7 +309,7 @@ private class Parser(fromPos: Pos) {
            }

            '?' -> {
-                when(currentChar.also { pos.advance() }) {
+                when (currentChar.also { pos.advance() }) {
                    ':' -> Token("??", from, Token.Type.ELVIS)
                    '?' -> Token("??", from, Token.Type.ELVIS)
                    '.' -> Token("?.", from, Token.Type.NULL_COALESCE)
@@ -293,7 +328,7 @@ private class Parser(fromPos: Pos) {
                // Labels processing is complicated!
                // some@ statement: label 'some', ID 'statement'
                // statement@some: ID 'statement', LABEL 'some'!
-                if (ch.isLetter() || ch == '_') {
+                if (idNextChars(ch)) {
                    val text = ch + loadChars(idNextChars)
                    if (currentChar == '@') {
                        pos.advance()
@@ -307,6 +342,11 @@ private class Parser(fromPos: Pos) {
                        when (text) {
                            "in" -> Token("in", from, Token.Type.IN)
                            "is" -> Token("is", from, Token.Type.IS)
+                            "as" -> {
+                                // support both `as` and tight `as?` without spaces
+                                if (currentChar == '?') { pos.advance(); Token("as?", from, Token.Type.ASNULL) }
+                                else Token("as", from, Token.Type.AS)
+                            }
                            else -> Token(text, from, Token.Type.ID)
                        }
                } else
@@ -375,6 +415,31 @@ private class Parser(fromPos: Pos) {

    private val currentChar: Char get() = pos.currentChar

+    private fun fixMultilineStringLiteral(source: String): String {
+        val sizes = mutableListOf<Int>()
+        val lines = source.lines().toMutableList()
+        if (lines.size == 0) return ""
+        if (lines[0].isBlank()) lines.removeFirst()
+        if (lines.isEmpty()) return ""
+        if (lines.last().isBlank()) lines.removeLast()
+
+        val normalized = lines.map { l ->
+            if (l.isBlank()) {
+                sizes.add(-1)
+                ""
+            } else {
+                val margin = leftMargin(l)
+                sizes += margin
+                " ".repeat(margin) + l.trim()
+            }
+        }
+        val commonMargin = sizes.filter { it >= 0 }.min()
+        val fixed = if (commonMargin < 1) lines else normalized.map {
+            if (it.isBlank()) "" else it.drop(commonMargin)
+        }
+        return fixed.joinToString("\n")
+    }
+
    private fun loadStringToken(): Token {
        val start = currentPos

@@ -383,20 +448,46 @@ private class Parser(fromPos: Pos) {
 //        start = start.back()

        val sb = StringBuilder()
+        var newlineDetected = false
        while (currentChar != '"') {
            if (pos.end) throw ScriptError(start, "unterminated string started there")
            when (currentChar) {
                '\\' -> {
                    pos.advance() ?: raise("unterminated string")
                    when (currentChar) {
-                        'n' -> sb.append('\n')
-                        'r' -> sb.append('\r')
-                        't' -> sb.append('\t')
-                        '"' -> sb.append('"')
-                        else -> sb.append('\\').append(currentChar)
+                        'n' -> {
+                            sb.append('\n'); pos.advance()
+                        }
+
+                        'r' -> {
+                            sb.append('\r'); pos.advance()
+                        }
+
+                        't' -> {
+                            sb.append('\t'); pos.advance()
+                        }
+
+                        '"' -> {
+                            sb.append('"'); pos.advance()
+                        }
+
+                        '\\' -> {
+                            sb.append('\\'); pos.advance()
+                        }
+
+                        else -> {
+                            sb.append('\\').append(currentChar)
+                            pos.advance()
+                        }
                    }
                }

+                '\n', '\r' -> {
+                    newlineDetected = true
+                    sb.append(currentChar)
+                    pos.advance()
+                }
+
                else -> {
                    sb.append(currentChar)
                    pos.advance()
@@ -404,7 +495,10 @@ private class Parser(fromPos: Pos) {
            }
        }
        pos.advance()
-        return Token(sb.toString(), start, Token.Type.STRING)
+
+        val result = sb.toString().let { if (newlineDetected) fixMultilineStringLiteral(it) else it }
+
+        return Token(result, start, Token.Type.STRING)
    }

    /**
@@ -481,7 +575,7 @@ private class Parser(fromPos: Pos) {

    init {
        // skip shebang
-        if( pos.readFragment("#!") )
+        if (pos.readFragment("#!"))
            loadToEndOfLine()
    }

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng
+
+/**
+ * Platform-specific default values for performance flags.
+ * These defaults are applied once at static init time in [PerfFlags] and can
+ * be overridden at runtime by tests or callers.
+ */
+expect object PerfDefaults {
+    val LOCAL_SLOT_PIC: Boolean
+    val EMIT_FAST_LOCAL_REFS: Boolean
+
+    val ARG_BUILDER: Boolean
+    val SKIP_ARGS_ON_NULL_RECEIVER: Boolean
+    val SCOPE_POOL: Boolean
+
+    val FIELD_PIC: Boolean
+    val METHOD_PIC: Boolean
+    // Optional larger PICs and adaptivity (JVM-first)
+    val FIELD_PIC_SIZE_4: Boolean
+    val METHOD_PIC_SIZE_4: Boolean
+    val PIC_ADAPTIVE_2_TO_4: Boolean
+    // Enable adaptivity only for methods (independent of fields)
+    val PIC_ADAPTIVE_METHODS_ONLY: Boolean
+    // Enable per-site heuristic to revert/avoid promotion when it shows no benefit
+    val PIC_ADAPTIVE_HEURISTIC: Boolean
+
+    val PIC_DEBUG_COUNTERS: Boolean
+
+    val PRIMITIVE_FASTOPS: Boolean
+    val RVAL_FASTPATH: Boolean
+
+    // Regex caching (JVM-first): small LRU for compiled patterns
+    val REGEX_CACHE: Boolean
+
+    // Argument builder extended arity (JVM-first exploration)
+    val ARG_SMALL_ARITY_12: Boolean
+
+    // Index PIC sizing (JVM-first)
+    val INDEX_PIC_SIZE_4: Boolean
+
+    // Specialized non-allocating integer range iteration in hot loops
+    val RANGE_FAST_ITER: Boolean
+}
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng
+
+/**
+ * Runtime-togglable perf flags for micro-benchmarking and A/B comparisons.
+ * Initialized from platform-specific defaults via PerfDefaults expect/actual.
+ * Keep as `var` so tests can flip them at runtime.
+ */
+object PerfFlags {
+    // Enable PIC inside LocalVarRef (runtime cache of name->slot per frame)
+    var LOCAL_SLOT_PIC: Boolean = PerfDefaults.LOCAL_SLOT_PIC
+    // Make the compiler emit fast local refs for identifiers known to be function locals/params
+    var EMIT_FAST_LOCAL_REFS: Boolean = PerfDefaults.EMIT_FAST_LOCAL_REFS
+
+    // Enable more efficient argument building and bulk-copy for splats
+    var ARG_BUILDER: Boolean = PerfDefaults.ARG_BUILDER
+    // Extend small-arity no-alloc argument paths to 9..12 (JVM-first; default via PerfDefaults)
+    var ARG_SMALL_ARITY_12: Boolean = PerfDefaults.ARG_SMALL_ARITY_12
+    // Allow early-return in optional calls before building args (semantics-compatible). Present for A/B only.
+    var SKIP_ARGS_ON_NULL_RECEIVER: Boolean = PerfDefaults.SKIP_ARGS_ON_NULL_RECEIVER
+    // Enable pooling of Scope frames for calls (may be JVM-only optimization)
+    var SCOPE_POOL: Boolean = PerfDefaults.SCOPE_POOL
+
+    // Step 2: PICs for fields and methods
+    var FIELD_PIC: Boolean = PerfDefaults.FIELD_PIC
+    var METHOD_PIC: Boolean = PerfDefaults.METHOD_PIC
+
+    // Optional: expand PIC size for fields/methods from 2 to 4 entries (JVM-first tuning)
+    // Initialized from platform defaults; still runtime-togglable.
+    var FIELD_PIC_SIZE_4: Boolean = PerfDefaults.FIELD_PIC_SIZE_4
+    var METHOD_PIC_SIZE_4: Boolean = PerfDefaults.METHOD_PIC_SIZE_4
+    // Adaptive growth from 2→4 entries per-site for field/method PICs when polymorphism is high (JVM-first)
+    var PIC_ADAPTIVE_2_TO_4: Boolean = PerfDefaults.PIC_ADAPTIVE_2_TO_4
+    // Adaptive growth for methods only (independent of fields)
+    var PIC_ADAPTIVE_METHODS_ONLY: Boolean = PerfDefaults.PIC_ADAPTIVE_METHODS_ONLY
+    // Heuristic to avoid or revert promotion when it shows no benefit (experimental)
+    var PIC_ADAPTIVE_HEURISTIC: Boolean = PerfDefaults.PIC_ADAPTIVE_HEURISTIC
+
+    // Index PIC/fast paths (JVM-first). By default follow FIELD_PIC enablement to avoid extra flags churn.
+    // Host apps/tests can flip independently if needed.
+    var INDEX_PIC: Boolean = FIELD_PIC
+    // Optional 4-entry PIC for IndexRef (JVM-first tuning); initialized from platform defaults
+    var INDEX_PIC_SIZE_4: Boolean = PerfDefaults.INDEX_PIC_SIZE_4
+
+    // Debug/observability for PICs and fast paths (JVM-first)
+    var PIC_DEBUG_COUNTERS: Boolean = PerfDefaults.PIC_DEBUG_COUNTERS
+
+    // Step 3: Primitive arithmetic and comparison fast paths
+    var PRIMITIVE_FASTOPS: Boolean = PerfDefaults.PRIMITIVE_FASTOPS
+
+    // Step 4: R-value fast path to bypass ObjRecord in pure expression evaluation
+    var RVAL_FASTPATH: Boolean = PerfDefaults.RVAL_FASTPATH
+
+    // Regex: enable small LRU cache for compiled patterns (JVM-first usage)
+    var REGEX_CACHE: Boolean = PerfDefaults.REGEX_CACHE
+
+    // Specialized non-allocating integer range iteration in hot loops
+    var RANGE_FAST_ITER: Boolean = PerfDefaults.RANGE_FAST_ITER
+}
@@ -0,0 +1,221 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng
+
+import net.sergeych.lyng.PerfProfiles.restore
+
+
+/**
+ * Helper to quickly apply groups of [PerfFlags] for different workload profiles and restore them back.
+ * JVM-first defaults; safe to use on all targets. Applying a preset returns a [Snapshot] that can be
+ * passed to [restore] to revert the change.
+ */
+object PerfProfiles {
+    data class Snapshot(
+        val LOCAL_SLOT_PIC: Boolean,
+        val EMIT_FAST_LOCAL_REFS: Boolean,
+
+        val ARG_BUILDER: Boolean,
+        val ARG_SMALL_ARITY_12: Boolean,
+        val SKIP_ARGS_ON_NULL_RECEIVER: Boolean,
+        val SCOPE_POOL: Boolean,
+
+        val FIELD_PIC: Boolean,
+        val METHOD_PIC: Boolean,
+        val FIELD_PIC_SIZE_4: Boolean,
+        val METHOD_PIC_SIZE_4: Boolean,
+        val PIC_ADAPTIVE_2_TO_4: Boolean,
+        val PIC_ADAPTIVE_METHODS_ONLY: Boolean,
+        val PIC_ADAPTIVE_HEURISTIC: Boolean,
+
+        val INDEX_PIC: Boolean,
+        val INDEX_PIC_SIZE_4: Boolean,
+
+        val PIC_DEBUG_COUNTERS: Boolean,
+
+        val PRIMITIVE_FASTOPS: Boolean,
+        val RVAL_FASTPATH: Boolean,
+
+        val REGEX_CACHE: Boolean,
+        val RANGE_FAST_ITER: Boolean,
+    )
+
+    fun snapshot(): Snapshot = Snapshot(
+        LOCAL_SLOT_PIC = PerfFlags.LOCAL_SLOT_PIC,
+        EMIT_FAST_LOCAL_REFS = PerfFlags.EMIT_FAST_LOCAL_REFS,
+
+        ARG_BUILDER = PerfFlags.ARG_BUILDER,
+        ARG_SMALL_ARITY_12 = PerfFlags.ARG_SMALL_ARITY_12,
+        SKIP_ARGS_ON_NULL_RECEIVER = PerfFlags.SKIP_ARGS_ON_NULL_RECEIVER,
+        SCOPE_POOL = PerfFlags.SCOPE_POOL,
+
+        FIELD_PIC = PerfFlags.FIELD_PIC,
+        METHOD_PIC = PerfFlags.METHOD_PIC,
+        FIELD_PIC_SIZE_4 = PerfFlags.FIELD_PIC_SIZE_4,
+        METHOD_PIC_SIZE_4 = PerfFlags.METHOD_PIC_SIZE_4,
+        PIC_ADAPTIVE_2_TO_4 = PerfFlags.PIC_ADAPTIVE_2_TO_4,
+        PIC_ADAPTIVE_METHODS_ONLY = PerfFlags.PIC_ADAPTIVE_METHODS_ONLY,
+        PIC_ADAPTIVE_HEURISTIC = PerfFlags.PIC_ADAPTIVE_HEURISTIC,
+
+        INDEX_PIC = PerfFlags.INDEX_PIC,
+        INDEX_PIC_SIZE_4 = PerfFlags.INDEX_PIC_SIZE_4,
+
+        PIC_DEBUG_COUNTERS = PerfFlags.PIC_DEBUG_COUNTERS,
+
+        PRIMITIVE_FASTOPS = PerfFlags.PRIMITIVE_FASTOPS,
+        RVAL_FASTPATH = PerfFlags.RVAL_FASTPATH,
+
+        REGEX_CACHE = PerfFlags.REGEX_CACHE,
+        RANGE_FAST_ITER = PerfFlags.RANGE_FAST_ITER,
+    )
+
+    fun restore(s: Snapshot) {
+        PerfFlags.LOCAL_SLOT_PIC = s.LOCAL_SLOT_PIC
+        PerfFlags.EMIT_FAST_LOCAL_REFS = s.EMIT_FAST_LOCAL_REFS
+
+        PerfFlags.ARG_BUILDER = s.ARG_BUILDER
+        PerfFlags.ARG_SMALL_ARITY_12 = s.ARG_SMALL_ARITY_12
+        PerfFlags.SKIP_ARGS_ON_NULL_RECEIVER = s.SKIP_ARGS_ON_NULL_RECEIVER
+        PerfFlags.SCOPE_POOL = s.SCOPE_POOL
+
+        PerfFlags.FIELD_PIC = s.FIELD_PIC
+        PerfFlags.METHOD_PIC = s.METHOD_PIC
+        PerfFlags.FIELD_PIC_SIZE_4 = s.FIELD_PIC_SIZE_4
+        PerfFlags.METHOD_PIC_SIZE_4 = s.METHOD_PIC_SIZE_4
+        PerfFlags.PIC_ADAPTIVE_2_TO_4 = s.PIC_ADAPTIVE_2_TO_4
+        PerfFlags.PIC_ADAPTIVE_METHODS_ONLY = s.PIC_ADAPTIVE_METHODS_ONLY
+        PerfFlags.PIC_ADAPTIVE_HEURISTIC = s.PIC_ADAPTIVE_HEURISTIC
+
+        PerfFlags.INDEX_PIC = s.INDEX_PIC
+        PerfFlags.INDEX_PIC_SIZE_4 = s.INDEX_PIC_SIZE_4
+
+        PerfFlags.PIC_DEBUG_COUNTERS = s.PIC_DEBUG_COUNTERS
+
+        PerfFlags.PRIMITIVE_FASTOPS = s.PRIMITIVE_FASTOPS
+        PerfFlags.RVAL_FASTPATH = s.RVAL_FASTPATH
+
+        PerfFlags.REGEX_CACHE = s.REGEX_CACHE
+        PerfFlags.RANGE_FAST_ITER = s.RANGE_FAST_ITER
+    }
+
+    enum class Preset { BASELINE, BENCH, BOOKS }
+
+    /** Apply a preset and return a [Snapshot] of the previous state to allow restoring later. */
+    fun apply(preset: Preset): Snapshot {
+        val saved = snapshot()
+        when (preset) {
+            Preset.BASELINE -> applyBaseline()
+            Preset.BENCH -> applyBench()
+            Preset.BOOKS -> applyBooks()
+        }
+        return saved
+    }
+
+    private fun applyBaseline() {
+        // Restore platform defaults. Note: INDEX_PIC follows FIELD_PIC parity by convention.
+        PerfFlags.LOCAL_SLOT_PIC = PerfDefaults.LOCAL_SLOT_PIC
+        PerfFlags.EMIT_FAST_LOCAL_REFS = PerfDefaults.EMIT_FAST_LOCAL_REFS
+
+        PerfFlags.ARG_BUILDER = PerfDefaults.ARG_BUILDER
+        PerfFlags.ARG_SMALL_ARITY_12 = PerfDefaults.ARG_SMALL_ARITY_12
+        PerfFlags.SKIP_ARGS_ON_NULL_RECEIVER = PerfDefaults.SKIP_ARGS_ON_NULL_RECEIVER
+        PerfFlags.SCOPE_POOL = PerfDefaults.SCOPE_POOL
+
+        PerfFlags.FIELD_PIC = PerfDefaults.FIELD_PIC
+        PerfFlags.METHOD_PIC = PerfDefaults.METHOD_PIC
+        PerfFlags.FIELD_PIC_SIZE_4 = PerfDefaults.FIELD_PIC_SIZE_4
+        PerfFlags.METHOD_PIC_SIZE_4 = PerfDefaults.METHOD_PIC_SIZE_4
+        PerfFlags.PIC_ADAPTIVE_2_TO_4 = PerfDefaults.PIC_ADAPTIVE_2_TO_4
+        PerfFlags.PIC_ADAPTIVE_METHODS_ONLY = PerfDefaults.PIC_ADAPTIVE_METHODS_ONLY
+        PerfFlags.PIC_ADAPTIVE_HEURISTIC = PerfDefaults.PIC_ADAPTIVE_HEURISTIC
+
+        PerfFlags.INDEX_PIC = PerfFlags.FIELD_PIC
+        PerfFlags.INDEX_PIC_SIZE_4 = PerfDefaults.INDEX_PIC_SIZE_4
+
+        PerfFlags.PIC_DEBUG_COUNTERS = PerfDefaults.PIC_DEBUG_COUNTERS
+
+        PerfFlags.PRIMITIVE_FASTOPS = PerfDefaults.PRIMITIVE_FASTOPS
+        PerfFlags.RVAL_FASTPATH = PerfDefaults.RVAL_FASTPATH
+
+        PerfFlags.REGEX_CACHE = PerfDefaults.REGEX_CACHE
+        PerfFlags.RANGE_FAST_ITER = PerfDefaults.RANGE_FAST_ITER
+    }
+
+    private fun applyBench() {
+        // Expression-heavy micro-bench focus (JVM-first assumptions)
+        PerfFlags.LOCAL_SLOT_PIC = true
+        PerfFlags.EMIT_FAST_LOCAL_REFS = true
+
+        PerfFlags.ARG_BUILDER = true
+        PerfFlags.ARG_SMALL_ARITY_12 = false
+        PerfFlags.SKIP_ARGS_ON_NULL_RECEIVER = true
+        PerfFlags.SCOPE_POOL = true
+
+        PerfFlags.FIELD_PIC = true
+        PerfFlags.METHOD_PIC = true
+        PerfFlags.FIELD_PIC_SIZE_4 = false
+        PerfFlags.METHOD_PIC_SIZE_4 = false
+        PerfFlags.PIC_ADAPTIVE_2_TO_4 = false
+        PerfFlags.PIC_ADAPTIVE_METHODS_ONLY = false
+        PerfFlags.PIC_ADAPTIVE_HEURISTIC = false
+
+        PerfFlags.INDEX_PIC = true
+        PerfFlags.INDEX_PIC_SIZE_4 = true
+
+        PerfFlags.PIC_DEBUG_COUNTERS = false
+
+        PerfFlags.PRIMITIVE_FASTOPS = true
+        PerfFlags.RVAL_FASTPATH = true
+
+        // Keep regex cache/platform setting; enable on JVM typically
+        PerfFlags.REGEX_CACHE = PerfDefaults.REGEX_CACHE
+        PerfFlags.RANGE_FAST_ITER = false
+    }
+
+    private fun applyBooks() {
+        // Documentation/book workload focus based on profiling observations.
+        // Favor simpler paths when hot expression paths are not dominant.
+        PerfFlags.LOCAL_SLOT_PIC = PerfDefaults.LOCAL_SLOT_PIC
+        PerfFlags.EMIT_FAST_LOCAL_REFS = PerfDefaults.EMIT_FAST_LOCAL_REFS
+
+        PerfFlags.ARG_BUILDER = false
+        PerfFlags.ARG_SMALL_ARITY_12 = false
+        PerfFlags.SKIP_ARGS_ON_NULL_RECEIVER = true
+        PerfFlags.SCOPE_POOL = false
+
+        PerfFlags.FIELD_PIC = false
+        PerfFlags.METHOD_PIC = false
+        PerfFlags.FIELD_PIC_SIZE_4 = false
+        PerfFlags.METHOD_PIC_SIZE_4 = false
+        PerfFlags.PIC_ADAPTIVE_2_TO_4 = false
+        PerfFlags.PIC_ADAPTIVE_METHODS_ONLY = false
+        PerfFlags.PIC_ADAPTIVE_HEURISTIC = false
+
+        PerfFlags.INDEX_PIC = false
+        PerfFlags.INDEX_PIC_SIZE_4 = false
+
+        PerfFlags.PIC_DEBUG_COUNTERS = false
+
+        PerfFlags.PRIMITIVE_FASTOPS = false
+        PerfFlags.RVAL_FASTPATH = false
+
+        // Keep regex cache/platform default; ON on JVM usually helps string APIs in books
+        PerfFlags.REGEX_CACHE = PerfDefaults.REGEX_CACHE
+        PerfFlags.RANGE_FAST_ITER = false
+    }
+}
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng
+
+/**
+ * Lightweight runtime counters for perf diagnostics. Enabled via flags in [PerfFlags].
+ * Keep simple and zero-cost when disabled by guarding increments at call sites.
+ */
+object PerfStats {
+    // Field PIC
+    var fieldPicHit: Long = 0
+    var fieldPicMiss: Long = 0
+    var fieldPicSetHit: Long = 0
+    var fieldPicSetMiss: Long = 0
+
+    // Method PIC
+    var methodPicHit: Long = 0
+    var methodPicMiss: Long = 0
+
+    // Local var PICs
+    var localVarPicHit: Long = 0
+    var localVarPicMiss: Long = 0
+    var fastLocalHit: Long = 0
+    var fastLocalMiss: Long = 0
+
+    // Primitive fast ops
+    var primitiveFastOpsHit: Long = 0
+
+    // Index PIC
+    var indexPicHit: Long = 0
+    var indexPicMiss: Long = 0
+
+    fun resetAll() {
+        fieldPicHit = 0
+        fieldPicMiss = 0
+        fieldPicSetHit = 0
+        fieldPicSetMiss = 0
+        methodPicHit = 0
+        methodPicMiss = 0
+        localVarPicHit = 0
+        localVarPicMiss = 0
+        fastLocalHit = 0
+        fastLocalMiss = 0
+        primitiveFastOpsHit = 0
+        indexPicHit = 0
+        indexPicMiss = 0
+    }
+}
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 data class Pos(val source: Source, val line: Int, val column: Int) {
@@ -11,7 +28,9 @@ data class Pos(val source: Source, val line: Int, val column: Int) {
        else if( line > 0) Pos(source, line-1, source.lines[line-1].length - 1)
        else throw IllegalStateException("can't go back from line 0, column 0")

-    val currentLine: String get() = if( end ) "EOF" else source.lines[line]
+    val currentLine: String get() =
+        if( end ) "EOF"
+        else if( line >= 0 ) source.lines[line] else "<no line information>"

    val end: Boolean get() = line >= source.lines.size

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng
+
+/**
+ * Tiny, size-bounded cache for compiled Regex patterns. Activated only when [PerfFlags.REGEX_CACHE] is true.
+ * This is a very simple FIFO-ish cache sufficient for micro-benchmarks and common repeated patterns.
+ * Not thread-safe by design; the interpreter typically runs scripts on confined executors.
+ */
+object RegexCache {
+    private const val MAX = 64
+    private val map: MutableMap<String, Regex> = LinkedHashMap()
+
+    fun get(pattern: String): Regex {
+        // Fast path: return cached instance if present
+        map[pattern]?.let {
+            // Emulate access-order LRU on all targets by moving the entry to the tail
+            // (LinkedHashMap preserves insertion order; remove+put moves it to the end)
+            map.remove(pattern)
+            map[pattern] = it
+            return it
+        }
+        // Compile new pattern
+        val re = pattern.toRegex()
+        // Keep the cache size bounded
+        if (map.size >= MAX) {
+            // Remove the oldest inserted entry (first key in iteration order)
+            val it = map.keys.iterator()
+            if (it.hasNext()) { val k = it.next(); it.remove() }
+        }
+        map[pattern] = re
+        return re
+    }
+
+    fun clear() = map.clear()
+}
@@ -1,9 +1,30 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 import net.sergeych.lyng.obj.*
 import net.sergeych.lyng.pacman.ImportManager
 import net.sergeych.lyng.pacman.ImportProvider

+// Simple per-frame id generator for perf caches (not thread-safe, fine for scripts)
+object FrameIdGen { var c: Long = 1L; fun nextId(): Long = c++ }
+fun nextFrameId(): Long = FrameIdGen.nextId()
+
 /**
 * Scope is where local variables and methods are stored. Scope is also a parent scope for other scopes.
 * Each block usually creates a scope. Accessing Lyng closures usually is done via a scope.
@@ -16,17 +37,52 @@ import net.sergeych.lyng.pacman.ImportProvider
 *
 *  There are special types of scopes:
 *
- *  - [AppliedScope] - scope used to apply a closure to some thisObj scope
+ *  - [ClosureScope] - scope used to apply a closure to some thisObj scope
 */
 open class Scope(
-    val parent: Scope?,
-    val args: Arguments = Arguments.EMPTY,
+    var parent: Scope?,
+    var args: Arguments = Arguments.EMPTY,
    var pos: Pos = Pos.builtIn,
    var thisObj: Obj = ObjVoid,
    var skipScopeCreation: Boolean = false,
 ) {
+    /** Lexical class context for visibility checks (propagates from parent). */
+    var currentClassCtx: net.sergeych.lyng.obj.ObjClass? = parent?.currentClassCtx
+    // Unique id per scope frame for PICs; regenerated on each borrow from the pool.
+    var frameId: Long = nextFrameId()
+
+    // Fast-path storage for local variables/arguments accessed by slot index.
+    // Enabled by default for child scopes; module/class scopes can ignore it.
+    private val slots: MutableList<ObjRecord> = mutableListOf()
+    private val nameToSlot: MutableMap<String, Int> = mutableMapOf()
+    /**
+     * Auxiliary per-frame map of local bindings (locals declared in this frame).
+     * This helps resolving locals across suspension when slot ownership isn't
+     * directly discoverable from the current frame.
+     */
+    internal val localBindings: MutableMap<String, ObjRecord> = mutableMapOf()
+
+    /**
+     * Hint internal collections to reduce reallocations for upcoming parameter/local assignments.
+     * Only effective for ArrayList-backed slots; maps are left as-is (rehashed lazily by JVM).
+     */
+    private fun reserveLocalCapacity(expected: Int) {
+        if (expected <= 0) return
+        (slots as? ArrayList<ObjRecord>)?.ensureCapacity(expected)
+        // nameToSlot has no portable ensureCapacity across KMP; leave it to grow as needed.
+    }
+
+    /**
+     * Hint expected number of local variables/arguments to reduce internal reallocations.
+     * Safe no-op for small or unknown values.
+     */
+    fun hintLocalCapacity(expected: Int) {
+        reserveLocalCapacity(expected)
+    }
    open val packageName: String = "<anonymous package>"

+    fun slotCount(): Int = slots.size
+
    constructor(
        args: Arguments = Arguments.EMPTY,
        pos: Pos = Pos.builtIn,
@@ -50,6 +106,9 @@ open class Scope(
    fun raiseIllegalState(message: String = "Illegal argument error"): Nothing =
        raiseError(ObjIllegalStateException(this, message))

+    fun raiseIllegalAssignment(message: String): Nothing =
+        raiseError(ObjIllegalAssignmentException(this, message))
+
    @Suppress("unused")
    fun raiseNoSuchElement(message: String = "No such element"): Nothing =
        raiseError(ObjIllegalArgumentException(this, message))
@@ -68,9 +127,14 @@ open class Scope(
        throw ExecutionError(obj)
    }

+    @Suppress("unused")
+    fun raiseNotFound(message: String = "not found"): Nothing {
+        throw ExecutionError(ObjNotFoundException(this, message))
+    }
+
    inline fun <reified T : Obj> requiredArg(index: Int): T {
        if (args.list.size <= index) raiseError("Expected at least ${index + 1} argument, got ${args.list.size}")
-        return (args.list[index] as? T)
+        return (args.list[index].byValueCopy() as? T)
            ?: raiseClassCastError("Expected type ${T::class.simpleName}, got ${args.list[index]::class.simpleName}")
    }

@@ -87,30 +151,135 @@ open class Scope(
    }

    fun requireNoArgs() {
-        if( args.list.isNotEmpty())
+        if (args.list.isNotEmpty())
            raiseError("This function does not accept any arguments")
    }

-    inline fun <reified T : Obj> thisAs(): T = (thisObj as? T)
-        ?: raiseClassCastError("Cannot cast ${thisObj.objClass.className} to ${T::class.simpleName}")
+    inline fun <reified T : Obj> thisAs(): T {
+        var s: Scope? = this
+        do {
+            val t = s!!.thisObj
+            if (t is T) return t
+            s = s.parent
+        } while (s != null)
+        raiseClassCastError("Cannot cast ${thisObj.objClass.className} to ${T::class.simpleName}")
+    }

    internal val objects = mutableMapOf<String, ObjRecord>()

    open operator fun get(name: String): ObjRecord? =
        if (name == "this") thisObj.asReadonly
        else {
-            objects[name]
+            // Prefer direct locals/bindings declared in this frame
+            (objects[name]
+                // Then, check known local bindings in this frame (helps after suspension)
+                ?: localBindings[name]
+                // Walk up ancestry
                ?: parent?.get(name)
+                // Finally, fallback to class members on thisObj
                ?: thisObj.objClass.getInstanceMemberOrNull(name)
+                )
        }

-    fun copy(pos: Pos, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
+    // Slot fast-path API
+    fun getSlotRecord(index: Int): ObjRecord = slots[index]
+    fun setSlotValue(index: Int, newValue: Obj) {
+        slots[index].value = newValue
+    }
+
+    fun getSlotIndexOf(name: String): Int? = nameToSlot[name]
+    fun allocateSlotFor(name: String, record: ObjRecord): Int {
+        val idx = slots.size
+        slots.add(record)
+        nameToSlot[name] = idx
+        return idx
+    }
+
+    /**
+     * Reset this scope instance so it can be safely reused as a fresh child frame.
+     * Clears locals and slots, assigns new frameId, and sets parent/args/pos/thisObj.
+     */
+    fun resetForReuse(parent: Scope?, args: Arguments, pos: Pos, thisObj: Obj) {
+        this.parent = parent
+        this.args = args
+        this.pos = pos
+        this.thisObj = thisObj
+        this.skipScopeCreation = false
+        // fresh identity for PIC caches
+        this.frameId = nextFrameId()
+        // clear locals and slot maps
+        objects.clear()
+        slots.clear()
+        nameToSlot.clear()
+        localBindings.clear()
+        // Pre-size local slots for upcoming parameter assignment where possible
+        reserveLocalCapacity(args.list.size + 4)
+    }
+
+    /**
+     * Creates a new child scope using the provided arguments and optional `thisObj`.
+     */
+    fun createChildScope(pos: Pos, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
+        Scope(this, args, pos, newThisObj ?: thisObj).also { it.reserveLocalCapacity(args.list.size + 4) }
+
+    /**
+     * Execute a block inside a child frame. Guarded for future pooling via [PerfFlags.SCOPE_POOL].
+     * Currently always creates a fresh child scope to preserve unique frameId semantics.
+     */
+    inline suspend fun <R> withChildFrame(args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null, crossinline block: suspend (Scope) -> R): R {
+        if (PerfFlags.SCOPE_POOL) {
+            val child = ScopePool.borrow(this, args, pos, newThisObj ?: thisObj)
+            try {
+                return block(child)
+            } finally {
+                ScopePool.release(child)
+            }
+        } else {
+            val child = createChildScope(args, newThisObj)
+            return block(child)
+        }
+    }
+
+    /**
+     * Creates a new child scope using the provided arguments and optional `thisObj`.
+     * The child scope inherits the current scope's properties such as position and the existing `thisObj` if no new `thisObj` is provided.
+     *
+     * @param args The arguments to associate with the child scope. Defaults to [Arguments.EMPTY].
+     * @param newThisObj The new `thisObj` to associate with the child scope. Defaults to the current scope's `thisObj` if not provided.
+     * @return A new instance of [Scope] initialized with the specified arguments and `thisObj`.
+     */
+    fun createChildScope(args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
        Scope(this, args, pos, newThisObj ?: thisObj)

-    fun copy(args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
-        Scope(this, args, pos, newThisObj ?: thisObj)
+    /**
+     * @return A child scope with the same arguments, position and [thisObj]
+     */
+    fun createChildScope() = Scope(this, args, pos, thisObj)

-    fun copy() = Scope(this, args, pos, thisObj)
+    /**
+     * Add or update ObjRecord with a given value checking rights. Created [ObjRecord] is mutable.
+     * Throws Lyng [ObjIllegalArgumentException] if yje [name] exists and readonly.
+     * @return ObjRector, new or updated.
+     */
+    fun addOrUpdateItem(
+        name: String,
+        value: Obj,
+        visibility: Visibility = Visibility.Public,
+        recordType: ObjRecord.Type = ObjRecord.Type.Other
+    ): ObjRecord =
+        objects[name]?.let {
+            if( !it.isMutable )
+                raiseIllegalAssignment("symbol is readonly: $name")
+            it.value = value
+            // keep local binding index consistent within the frame
+            localBindings[name] = it
+            // If we are a ClosureScope, mirror binding into the caller frame to keep it discoverable
+            // across suspension when resumed on the call frame
+            if (this is ClosureScope) {
+                callScope.localBindings[name] = it
+            }
+            it
+        } ?: addItem(name, true, value, visibility, recordType)

    fun addItem(
        name: String,
@@ -119,7 +288,28 @@ open class Scope(
        visibility: Visibility = Visibility.Public,
        recordType: ObjRecord.Type = ObjRecord.Type.Other
    ): ObjRecord {
-        return ObjRecord(value, isMutable, visibility,type = recordType).also { objects[name] = it }
+        val rec = ObjRecord(value, isMutable, visibility, declaringClass = currentClassCtx, type = recordType)
+        objects[name] = rec
+        // Index this binding within the current frame to help resolve locals across suspension
+        localBindings[name] = rec
+        // If we are a ClosureScope, mirror binding into the caller frame to keep it discoverable
+        // across suspension when resumed on the call frame
+        if (this is ClosureScope) {
+            callScope.localBindings[name] = rec
+            // Additionally, expose the binding in caller's objects and slot map so identifier
+            // resolution after suspension can still find it even if the active scope is a child
+            // of the callScope (e.g., due to internal withChildFrame usage).
+            // This keeps visibility within the method body but prevents leaking outside the caller frame.
+            callScope.objects[name] = rec
+            if (callScope.getSlotIndexOf(name) == null) {
+                callScope.allocateSlotFor(name, rec)
+            }
+        }
+        // Map to a slot for fast local access (if not already mapped)
+        if (getSlotIndexOf(name) == null) {
+            allocateSlotFor(name, rec)
+        }
+        return rec
    }

    fun getOrCreateNamespace(name: String): ObjClass {
@@ -153,13 +343,14 @@ open class Scope(
    fun addConst(name: String, value: Obj) = addItem(name, false, value)

    suspend fun eval(code: String): Obj =
-        Compiler.compile(code.toSource(), currentImportProvider).execute(this)
+        eval(code.toSource())

-    suspend fun eval(source: Source): Obj =
-        Compiler.compile(
+    suspend fun eval(source: Source): Obj {
+        return Compiler.compile(
            source,
            currentImportProvider
        ).execute(this)
+    }

    fun containsLocal(name: String): Boolean = name in objects

@@ -187,8 +378,30 @@ open class Scope(
            parent?.currentImportProvider ?: throw IllegalStateException("this scope has no manager in the chain")
    }

-    val importManager by lazy { (currentImportProvider as? ImportManager)
-        ?: throw IllegalStateException("this scope has no manager in the chain (provided $currentImportProvider") }
+    val importManager by lazy {
+        (currentImportProvider as? ImportManager)
+            ?: throw IllegalStateException("this scope has no manager in the chain (provided $currentImportProvider")
+    }
+
+    override fun toString(): String {
+        val contents =
+            objects.entries.joinToString { "${if (it.value.isMutable) "var" else "val"} ${it.key}=${it.value.value}" }
+        return "S[this=$thisObj $contents]"
+    }
+
+    fun trace(text: String = "") {
+        println("trace Scope: $text ------------------")
+        var p = this.parent
+        var level = 0
+        while (p != null) {
+            println("     parent#${++level}: $p")
+            println("     ( ${p.args.list} )")
+            p = p.parent
+        }
+        println("--------------------")
+    }
+
+    open fun applyClosure(closure: Scope): Scope = ClosureScope(this, closure)

    companion object {

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng
+
+import net.sergeych.lyng.obj.Obj
+
+/**
+ * Expect/actual portable scope frame pool. Used only when [PerfFlags.SCOPE_POOL] is true.
+ * JVM actual provides a ThreadLocal-backed pool; other targets may use a simple global deque.
+ */
+expect object ScopePool {
+    fun borrow(parent: Scope, args: Arguments, pos: Pos, thisObj: Obj): Scope
+    fun release(scope: Scope)
+}
@@ -1,11 +1,33 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 import kotlinx.coroutines.delay
+import kotlinx.coroutines.yield
+import net.sergeych.lyng.Script.Companion.defaultImportManager
 import net.sergeych.lyng.obj.*
 import net.sergeych.lyng.pacman.ImportManager
+import net.sergeych.lyng.stdlib_included.rootLyng
 import net.sergeych.lynon.ObjLynonClass
+import net.sergeych.mp_tools.globalDefer
 import kotlin.math.*

+@Suppress("TYPE_INTERSECTION_AS_REIFIED_WARNING")
 class Script(
    override val pos: Pos,
    private val statements: List<Statement> = emptyList(),
@@ -20,16 +42,32 @@ class Script(
        return lastResult
    }

-    suspend fun execute() = execute(defaultImportManager.newModule())
+    suspend fun execute() = execute(
+        defaultImportManager.newStdScope()
+    )

    companion object {

-        private val rootScope: Scope = Scope(null).apply {
+        /**
+         * Create new scope using standard safe set of modules, using [defaultImportManager]. It is
+         * suspended as first time calls requires compilation of standard library or other
+         * asynchronous initialization.
+         */
+        suspend fun newScope(pos: Pos = Pos.builtIn) = defaultImportManager.newStdScope(pos)
+
+        internal val rootScope: Scope = Scope(null).apply {
            ObjException.addExceptionsToContext(this)
+            addFn("print") {
+                for ((i, a) in args.withIndex()) {
+                    if (i > 0) print(' ' + a.toString(this).value)
+                    else print(a.toString(this).value)
+                }
+                ObjVoid
+            }
            addFn("println") {
                for ((i, a) in args.withIndex()) {
-                    if (i > 0) print(' ' + a.asStr.value)
-                    else print(a.asStr.value)
+                    if (i > 0) print(' ' + a.toString(this).value)
+                    else print(a.toString(this).value)
                }
                println()
                ObjVoid
@@ -121,21 +159,24 @@ class Script(

            addVoidFn("assert") {
                val cond = requiredArg<ObjBool>(0)
+                val message = if( args.size > 1 )
+                    ": " + (args[1] as Statement).execute(this).toString(this).value
+                else ""
                if( !cond.value == true )
-                    raiseError(ObjAssertionFailedException(this,"Assertion failed"))
+                    raiseError(ObjAssertionFailedException(this, "Assertion failed$message"))
            }

            addVoidFn("assertEquals") {
                val a = requiredArg<Obj>(0)
                val b = requiredArg<Obj>(1)
                if( a.compareTo(this, b) != 0 )
-                    raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect()} == ${b.inspect()}"))
+                    raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect(this)} == ${b.inspect(this)}"))
            }
            addVoidFn("assertNotEquals") {
                val a = requiredArg<Obj>(0)
                val b = requiredArg<Obj>(1)
                if( a.compareTo(this, b) == 0 )
-                    raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect()} != ${b.inspect()}"))
+                    raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect(this)} != ${b.inspect(this)}"))
            }
            addFn("assertThrows") {
                val code = requireOnlyArg<Statement>()
@@ -146,14 +187,41 @@ class Script(
                catch( e: ExecutionError ) {
                    e.errorObject
                }
-                catch (e: ScriptError) {
+                catch (_: ScriptError) {
                    ObjNull
                }
                result ?: raiseError(ObjAssertionFailedException(this,"Expected exception but nothing was thrown"))
            }

+            addFn("dynamic") {
+                ObjDynamic.create(this, requireOnlyArg())
+            }
+
+            addFn("require") {
+                val condition = requiredArg<ObjBool>(0)
+                if( !condition.value ) {
+                    val message = args.list.getOrNull(1)?.toString() ?: "requirement not met"
+                    raiseIllegalArgument(message)
+                }
+                ObjVoid
+            }
+            addFn("check") {
+                val condition = requiredArg<ObjBool>(0)
+                if( !condition.value ) {
+                    val message = args.list.getOrNull(1)?.toString() ?: "check failed"
+                    raiseIllegalState(message)
+                }
+                ObjVoid
+            }
+            addFn("traceScope") {
+                this.trace(args.getOrNull(0)?.toString() ?: "")
+                ObjVoid
+            }
+
+            // Delay in milliseconds (plain numeric). For time-aware variants use lyng.time.Duration API.
            addVoidFn("delay") {
-                delay((this.args.firstAndOnly().toDouble()/1000.0).roundToLong())
+                val ms = (this.args.firstAndOnly().toDouble()).roundToLong()
+                delay(ms)
            }

            addConst("Object", rootObjectType)
@@ -173,8 +241,33 @@ class Script(
            addConst("Iterable", ObjIterable)
            addConst("Collection", ObjCollection)
            addConst("Array", ObjArray)
+            addConst("RingBuffer", ObjRingBuffer.type)
            addConst("Class", ObjClassType)

+            addConst("Deferred", ObjDeferred.type)
+            addConst("CompletableDeferred", ObjCompletableDeferred.type)
+            addConst("Mutex", ObjMutex.type)
+
+            addConst("Regex", ObjRegex.type)
+
+            addFn("launch") {
+                val callable = requireOnlyArg<Statement>()
+                ObjDeferred(globalDefer {
+                    callable.execute(this@addFn)
+                })
+            }
+
+            addFn("yield") {
+                yield()
+                ObjVoid
+            }
+
+            addFn("flow") {
+                // important is: current context contains closure often used in call;
+                // we'll need it for the producer
+                ObjFlow(requireOnlyArg<Statement>(), this)
+            }
+
            val pi = ObjReal(PI)
            addConst("π", pi)
            getOrCreateNamespace("Math").apply {
@@ -184,6 +277,9 @@ class Script(

        val defaultImportManager: ImportManager by lazy {
            ImportManager(rootScope, SecurityManager.allowAll).apply {
+                addTextPackages(
+                    rootLyng
+                )
                addPackage("lyng.buffer") {
                    it.addConst("Buffer", ObjBuffer.type)
                    it.addConst("MutableBuffer", ObjMutableBuffer.type)
@@ -200,7 +296,7 @@ class Script(
                            is ObjInt -> delay(a.value * 1000)
                            is ObjReal -> delay((a.value * 1000).roundToLong())
                            is ObjDuration -> delay(a.duration)
-                            else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect()}")
+                            else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect(this)}")
                        }
                        ObjVoid
                    }
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
@file:Suppress("CanBeParameter")

 package net.sergeych.lyng
@@ -9,11 +26,13 @@ open class ScriptError(val pos: Pos, val errorMessage: String, cause: Throwable?
        $pos: Error: $errorMessage
        
        ${pos.currentLine}
-        ${"-".repeat(pos.column)}^
+        ${if( pos.column >= 0 ) "-".repeat(pos.column) + "^" else ""}
    """.trimIndent(),
    cause
 )

-class ExecutionError(val errorObject: ObjException) : ScriptError(errorObject.scope.pos, errorObject.message)
+class ScriptFlowIsNoMoreCollected: Exception()
+
+class ExecutionError(val errorObject: ObjException) : ScriptError(errorObject.scope.pos, errorObject.message.value)

 class ImportException(pos: Pos, message: String) : ScriptError(pos, message)
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 interface SecurityManager {
@@ -1,9 +1,30 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

+import net.sergeych.lyng.obj.ObjString
+
 class Source(val fileName: String, text: String) {

    val lines = text.lines().map { it.trimEnd() }

+    val objSourceName by lazy { ObjString(fileName) }
+
    companion object {
        val builtIn: Source by lazy { Source("built-in", "") }
        val UNKNOWN: Source by lazy { Source("UNKNOWN", "") }
@@ -1,22 +1,50 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 data class Token(val value: String, val pos: Pos, val type: Type) {
+    fun raiseSyntax(text: String): Nothing {
+        throw ScriptError(pos, text)
+    }
+
    val isComment: Boolean by lazy { type == Type.SINLGE_LINE_COMMENT || type == Type.MULTILINE_COMMENT }

+    fun isId(text: String) =
+        type == Type.ID && value == text
+
+
    @Suppress("unused")
    enum class Type {
-        ID, INT, REAL, HEX, STRING, CHAR,
+        ID, INT, REAL, HEX, STRING, STRING2, REGEX,  CHAR,
        LPAREN, RPAREN, LBRACE, RBRACE, LBRACKET, RBRACKET, COMMA,
        SEMICOLON, COLON,
        PLUS, MINUS, STAR, SLASH, PERCENT,
        ASSIGN, PLUSASSIGN, MINUSASSIGN, STARASSIGN, SLASHASSIGN, PERCENTASSIGN,
        PLUS2, MINUS2,
        IN, NOTIN, IS, NOTIS,
-        EQ, NEQ, LT, LTE, GT, GTE, REF_EQ, REF_NEQ,
+        EQ, NEQ, LT, LTE, GT, GTE, REF_EQ, REF_NEQ, MATCH, NOTMATCH,
        SHUTTLE,
-        AND, BITAND, OR, BITOR, NOT, BITNOT, DOT, ARROW, EQARROW, QUESTION, COLONCOLON,
+        AND, BITAND, OR, BITOR, BITXOR, NOT, BITNOT, DOT, ARROW, EQARROW, QUESTION, COLONCOLON,
+        SHL, SHR,
        SINLGE_LINE_COMMENT, MULTILINE_COMMENT,
        LABEL, ATLABEL, // label@ at@label
+        // type-checking/casting
+        AS, ASNULL,
        //PUBLIC, PROTECTED, INTERNAL, EXPORT, OPEN, INLINE, OVERRIDE, ABSTRACT, SEALED, EXTERNAL, VAL, VAR, CONST, TYPE, FUN, CLASS, INTERFACE, ENUM, OBJECT, TRAIT, THIS,
        ELLIPSIS, DOTDOT, DOTDOTLT,
        NEWLINE,
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
@file:Suppress("unused")

 package net.sergeych.lyng
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng

 enum class Visibility {
@@ -5,4 +22,18 @@ enum class Visibility {
    val isPublic by lazy { this == Public }
    @Suppress("unused")
    val isProtected by lazy { this == Protected }
+}
+
+/** MI-aware visibility check: whether [caller] can access a member declared in [decl] with [visibility]. */
+fun canAccessMember(visibility: Visibility, decl: net.sergeych.lyng.obj.ObjClass?, caller: net.sergeych.lyng.obj.ObjClass?): Boolean {
+    return when (visibility) {
+        Visibility.Public -> true
+        Visibility.Private -> (decl != null && caller === decl)
+        Visibility.Protected -> when {
+            decl == null -> false
+            caller == null -> false
+            caller === decl -> true
+            else -> (caller.allParentsSet.contains(decl))
+        }
+    }
 }
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng


@@ -1,3 +1,19 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */

 package net.sergeych.lyng.obj

@@ -9,25 +25,36 @@ import net.sergeych.lyng.ScriptError
 // avoid KDOC bug: keep it
@Suppress("unused")
 typealias DocCompiler = Compiler
-/**
- * When we need read-write access to an object in some abstract storage, we need Accessor,
- * as in-site assigning is not always sufficient, in general case we need to replace the object
- * in the storage.
- *
- * Note that assigning new value is more complex than just replacing the object, see how assignment
- * operator is implemented in [Compiler.allOps].
- */
-data class Accessor(
-    val getter: suspend (Scope) -> ObjRecord,
-    val setterOrNull: (suspend (Scope, Obj) -> Unit)?
-) {
-    /**
-     * Simplified constructor for immutable stores.
-     */
-    constructor(getter: suspend (Scope) -> ObjRecord) : this(getter, null)

-    /**
-     * Get the setter or throw.
-     */
-    fun setter(pos: Pos) = setterOrNull ?: throw ScriptError(pos, "can't assign value")
+/**
+ * Final migration shim: make `Accessor` an alias to `ObjRef`.
+ * This preserves source compatibility while removing lambda-based indirection.
+ */
+typealias Accessor = ObjRef
+
+/** Lambda-based reference for edge cases that still construct access via lambdas. */
+private class LambdaRef(
+    private val getterFn: suspend (Scope) -> ObjRecord,
+    private val setterFn: (suspend (Pos, Scope, Obj) -> Unit)? = null
+) : ObjRef {
+    override suspend fun get(scope: Scope): ObjRecord = getterFn(scope)
+    override suspend fun setAt(pos: Pos, scope: Scope, newValue: Obj) {
+        val s = setterFn ?: throw ScriptError(pos, "can't assign value")
+        s(pos, scope, newValue)
+    }
+}
+
+// Factory functions to preserve current call sites like `Accessor { ... }`
+fun Accessor(getter: suspend (Scope) -> ObjRecord): Accessor = LambdaRef(getter)
+fun Accessor(
+    getter: suspend (Scope) -> ObjRecord,
+    setter: suspend (Scope, Obj) -> Unit
+): Accessor = LambdaRef(getter) { _, scope, value -> setter(scope, value) }
+
+// Compatibility shims used throughout Compiler: `.getter(...)` and `.setter(pos)`
+val Accessor.getter: suspend (Scope) -> ObjRecord
+    get() = { scope -> this.get(scope) }
+
+fun Accessor.setter(pos: Pos): suspend (Scope, Obj) -> Unit = { scope, newValue ->
+    this.setAt(pos, scope, newValue)
 }
@@ -1,17 +1,28 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng.obj

-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
-import net.sergeych.bintools.encodeToHex
 import net.sergeych.lyng.*
 import net.sergeych.lynon.LynonDecoder
 import net.sergeych.lynon.LynonEncoder
 import net.sergeych.lynon.LynonType
-import net.sergeych.synctools.ProtectedOp
-import net.sergeych.synctools.withLock
-import kotlin.contracts.ExperimentalContracts

 open class Obj {

@@ -25,14 +36,14 @@ open class Obj {

    var isFrozen: Boolean = false

-    private val monitor = Mutex()
+//    private val monitor = Mutex()

    //    private val memberMutex = Mutex()
-    internal var parentInstances: MutableList<Obj> = mutableListOf()
+//    internal var parentInstances: MutableList<Obj> = mutableListOf()

-    private val opInstances = ProtectedOp()
+//    private val opInstances = ProtectedOp()

-    open fun inspect(): String = toString()
+    open suspend fun inspect(scope: Scope): String = toString(scope).value

    /**
     * Some objects are by-value, historically [ObjInt] and [ObjReal] are usually treated as such.
@@ -55,7 +66,8 @@ open class Obj {
        scope: Scope,
        name: String,
        args: Arguments = Arguments.EMPTY
-    ): T = invokeInstanceMethod(scope, name, args) as T
+    ): T =
+        invokeInstanceMethod(scope, name, args) as T

    /**
     * Invoke a method of the object if exists
@@ -66,11 +78,29 @@ open class Obj {
        scope: Scope,
        name: String,
        args: Arguments = Arguments.EMPTY,
-        onNotFoundResult: Obj?=null
-    ): Obj =
-        objClass.getInstanceMemberOrNull(name)?.value?.invoke(scope, this, args)
-            ?: onNotFoundResult
-            ?: scope.raiseSymbolNotFound(name)
+        onNotFoundResult: (() -> Obj?)? = null
+    ): Obj {
+        val rec = objClass.getInstanceMemberOrNull(name)
+        if (rec != null) {
+            val decl = rec.declaringClass ?: objClass.findDeclaringClassOf(name)
+            val caller = scope.currentClassCtx
+            if (!canAccessMember(rec.visibility, decl, caller))
+                scope.raiseError(ObjAccessException(scope, "can't invoke ${name}: not visible (declared in ${decl?.className ?: "?"}, caller ${caller?.className ?: "?"})"))
+            // Propagate declaring class as current class context during method execution
+            val saved = scope.currentClassCtx
+            scope.currentClassCtx = decl
+            try {
+                return rec.value.invoke(scope, this, args)
+            } finally {
+                scope.currentClassCtx = saved
+            }
+        }
+        return onNotFoundResult?.invoke()
+            ?: scope.raiseError(
+                "no such member: $name on ${objClass.className}. Considered order: ${objClass.renderLinearization(true)}. " +
+                        "Tip: try this@Base.$name(...) or (obj as Base).$name(...) if ambiguous"
+            )
+    }

    open suspend fun getInstanceMethod(
        scope: Scope,
@@ -80,7 +110,7 @@ open class Obj {
        // note that getInstanceMember traverses the hierarchy
        objClass.getInstanceMember(scope.pos, name).value

-    fun getMemberOrNull(name: String): Obj? = objClass.getInstanceMemberOrNull(name)?.value
+//    fun getMemberOrNull(name: String): Obj? = objClass.getInstanceMemberOrNull(name)?.value

    // methods that to override

@@ -92,8 +122,28 @@ open class Obj {
        return invokeInstanceMethod(scope, "contains", other).toBool()
    }

-    open val asStr: ObjString by lazy {
-        if (this is ObjString) this else ObjString(this.toString())
+    /**
+     * Default toString implementation:
+     *
+     * - if the object is a string, returns it
+     * - otherwise, if not [calledFromLyng], calls Lyng override `toString()` if exists
+     * - otherwise, meaning either called from Lyng `toString`, or there is no
+     *   Lyng override, returns the object's Kotlin variant of `toString()
+     *
+     * Note on kotlin's `toString()`: it is preferred to use this, 'scoped` version,
+     * as it can execute Lyng code using the scope and being suspending one.
+     *
+     * @param scope the scope where the string representation was requested
+     * @param calledFromLyng true if called from Lyng's `toString`. Normally this parameter should be ignored,
+     *      but it is used to avoid endless recursion in [Obj.toString] base implementation
+     */
+    open suspend fun toString(scope: Scope,calledFromLyng: Boolean=false): ObjString {
+        return if (this is ObjString) this
+        else if( !calledFromLyng ) {
+            invokeInstanceMethod(scope, "toString") {
+                ObjString(this.toString())
+            } as ObjString
+        } else { ObjString(this.toString()) }
    }

    /**
@@ -138,8 +188,43 @@ open class Obj {
        scope.raiseNotImplemented()
    }

+    open suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun operatorNotMatch(scope: Scope, other: Obj): Obj {
+        return operatorMatch(scope,other).logicalNot(scope)
+    }
+
+    // Bitwise ops default (override in numeric types that support them)
+    open suspend fun bitAnd(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun bitOr(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun bitXor(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun shl(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun shr(scope: Scope, other: Obj): Obj {
+        scope.raiseNotImplemented()
+    }
+
+    open suspend fun bitNot(scope: Scope): Obj {
+        scope.raiseNotImplemented()
+    }
+
    open suspend fun assign(scope: Scope, other: Obj): Obj? = null

+    open fun getValue(scope: Scope) = this
+
    /**
     * a += b
     * if( the operation is not defined, it returns null and the compiler would try
@@ -182,14 +267,20 @@ open class Obj {
        if (isFrozen) scope.raiseError("attempt to mutate frozen object")
    }

-    suspend fun <T> sync(block: () -> T): T = monitor.withLock { block() }
+//    suspend fun <T> sync(block: () -> T): T = monitor.withLock { block() }

    open suspend fun readField(scope: Scope, name: String): ObjRecord {
        // could be property or class field:
-        val obj = objClass.getInstanceMemberOrNull(name) ?: scope.raiseError("no such field: $name")
+        val obj = objClass.getInstanceMemberOrNull(name) ?: scope.raiseError(
+            "no such field: $name on ${objClass.className}. Considered order: ${objClass.renderLinearization(true)}"
+        )
+        val decl = obj.declaringClass ?: objClass.findDeclaringClassOf(name)
+        val caller = scope.currentClassCtx
+        if (!canAccessMember(obj.visibility, decl, caller))
+            scope.raiseError(ObjAccessException(scope, "can't access field ${name}: not visible (declared in ${decl?.className ?: "?"}, caller ${caller?.className ?: "?"})"))
        return when (val value = obj.value) {
            is Statement -> {
-                ObjRecord(value.execute(scope.copy(scope.pos, newThisObj = this)), obj.isMutable)
+                ObjRecord(value.execute(scope.createChildScope(scope.pos, newThisObj = this)), obj.isMutable)
            }
            // could be writable property naturally
 //            null -> ObjNull.asReadonly
@@ -199,7 +290,13 @@ open class Obj {

    open suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
        willMutate(scope)
-        val field = objClass.getInstanceMemberOrNull(name) ?: scope.raiseError("no such field: $name")
+        val field = objClass.getInstanceMemberOrNull(name) ?: scope.raiseError(
+            "no such field: $name on ${objClass.className}. Considered order: ${objClass.renderLinearization(true)}"
+        )
+        val decl = field.declaringClass ?: objClass.findDeclaringClassOf(name)
+        val caller = scope.currentClassCtx
+        if (!canAccessMember(field.visibility, decl, caller))
+            scope.raiseError(ObjAccessException(scope, "can't assign field ${name}: not visible (declared in ${decl?.className ?: "?"}, caller ${caller?.className ?: "?"})"))
        if (field.isMutable) field.value = newValue else scope.raiseError("can't assign to read-only field: $name")
    }

@@ -218,11 +315,16 @@ open class Obj {
    }

    suspend fun invoke(scope: Scope, thisObj: Obj, args: Arguments): Obj =
-        callOn(scope.copy(scope.pos, args = args, newThisObj = thisObj))
+        if (PerfFlags.SCOPE_POOL)
+            scope.withChildFrame(args, newThisObj = thisObj) { child ->
+                callOn(child)
+            }
+        else
+            callOn(scope.createChildScope(scope.pos, args = args, newThisObj = thisObj))

    suspend fun invoke(scope: Scope, thisObj: Obj, vararg args: Obj): Obj =
        callOn(
-            scope.copy(
+            scope.createChildScope(
                scope.pos,
                args = Arguments(args.toList()),
                newThisObj = thisObj
@@ -231,7 +333,7 @@ open class Obj {

    suspend fun invoke(scope: Scope, thisObj: Obj): Obj =
        callOn(
-            scope.copy(
+            scope.createChildScope(
                scope.pos,
                args = Arguments.EMPTY,
                newThisObj = thisObj
@@ -239,7 +341,7 @@ open class Obj {
        )

    suspend fun invoke(scope: Scope, atPos: Pos, thisObj: Obj, args: Arguments): Obj =
-        callOn(scope.copy(atPos, args = args, newThisObj = thisObj))
+        callOn(scope.createChildScope(atPos, args = args, newThisObj = thisObj))


    val asReadonly: ObjRecord by lazy { ObjRecord(this, false) }
@@ -248,32 +350,64 @@ open class Obj {
    open suspend fun lynonType(): LynonType = LynonType.Other

    open suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
-        scope.raiseNotImplemented()
+        scope.raiseNotImplemented("lynon: can't serialize ${this.objClass}:${this.toString(scope)}")
+    }
+
+    fun autoInstanceScope(parent: Scope): Scope {
+        // Create a stable instance scope whose parent is the provided parent scope directly,
+        // not a transient child that could be pooled and reset. This preserves proper name
+        // resolution (e.g., stdlib functions like sqrt) even when call frame pooling is enabled.
+        val scope = Scope(parent, parent.args, parent.pos, this)
+        for (m in objClass.members) {
+            scope.objects[m.key] = m.value
+        }
+        return scope
+    }
+
+    inline fun <reified R: Obj> cast(scope: Scope): R {
+        castOrNull<R>()?.let { return it }
+        scope.raiseClassCastError("can't cast ${this::class.simpleName} to ${R::class.simpleName}")
+
+    }
+
+    inline fun <reified R: Obj> castOrNull(): R? {
+        (this as? R)?.let { return it }
+        // todo: check for subclasses
+        return null
    }

    companion object {

        val rootObjectType = ObjClass("Obj").apply {
-            addFn("toString") {
-                thisObj.asStr
+            addFn("toString", true) {
+                thisObj.toString(this, true)
+            }
+            addFn("inspect", true) {
+                thisObj.inspect(this).toObj()
            }
            addFn("contains") {
                ObjBool(thisObj.contains(this, args.firstAndOnly()))
            }
            // utilities
            addFn("let") {
-                args.firstAndOnly().callOn(copy(Arguments(thisObj)))
+                args.firstAndOnly().callOn(createChildScope(Arguments(thisObj)))
            }
            addFn("apply") {
-                val newContext = (thisObj as? ObjInstance)?.instanceScope ?: this
-                args.firstAndOnly()
-                    .callOn(newContext)
+                val body = args.firstAndOnly()
+                (thisObj as? ObjInstance)?.let {
+                    body.callOn(ApplyScope(this, it.instanceScope))
+                } ?: run {
+                    body.callOn(this)
+                }
                thisObj
            }
            addFn("also") {
-                args.firstAndOnly().callOn(copy(Arguments(thisObj)))
+                args.firstAndOnly().callOn(createChildScope(Arguments(thisObj)))
                thisObj
            }
+            addFn("run") {
+                args.firstAndOnly().callOn(this)
+            }
            addFn("getAt") {
                requireExactCount(1)
                thisObj.getAt(this, requiredArg<Obj>(0))
@@ -288,6 +422,7 @@ open class Obj {
        }


+        @Suppress("NOTHING_TO_INLINE")
        inline fun from(obj: Any?): Obj {
            @Suppress("UNCHECKED_CAST")
            return when (obj) {
@@ -348,9 +483,14 @@ object ObjNull : Obj() {
        scope.raiseNPE()
    }

-    override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments, onNotFoundResult: Obj?): Obj {
-        scope.raiseNPE()
-    }
+//    override suspend fun invokeInstanceMethod(
+//        scope: Scope,
+//        name: String,
+//        args: Arguments,
+//        onNotFoundResult: (()->Obj?)?
+//    ): Obj {
+//        scope.raiseNPE()
+//    }

    override suspend fun getAt(scope: Scope, index: Obj): Obj {
        scope.raiseNPE()
@@ -392,6 +532,9 @@ object ObjNull : Obj() {
    }
 }

+/**
+ * TODO: get rid of it. Maybe we ise some Lyng inheritance instead
+ */
 interface Numeric {
    val longValue: Long
    val doubleValue: Double
@@ -422,125 +565,11 @@ fun Obj.toBool(): Boolean =
 data class ObjNamespace(val name: String) : Obj() {
    override val objClass by lazy { ObjClass(name) }

-    override fun inspect(): String = "Ns[$name]"
+    override suspend fun inspect(scope: Scope): String = "Ns[$name]"

    override fun toString(): String {
        return "package $name"
    }
 }

-open class ObjException(exceptionClass: ExceptionClass, val scope: Scope, val message: String) : Obj() {
-    constructor(name: String, scope: Scope, message: String) : this(
-        getOrCreateExceptionClass(name),
-        scope,
-        message
-    )

-    constructor(scope: Scope, message: String) : this(Root, scope, message)
-
-    fun raise(): Nothing {
-        throw ExecutionError(this)
-    }
-
-    override val objClass: ObjClass = exceptionClass
-
-    override fun toString(): String {
-        return "ObjException:${objClass.className}:${scope.pos}@${hashCode().encodeToHex()}"
-    }
-
-    companion object {
-
-        class ExceptionClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {
-            override suspend fun callOn(scope: Scope): Obj {
-                val message = scope.args.getOrNull(0)?.toString() ?: name
-                return ObjException(this, scope, message)
-            }
-
-            override fun toString(): String = "ExceptionClass[$name]@${hashCode().encodeToHex()}"
-        }
-
-        val Root = ExceptionClass("Throwable").apply {
-            addConst("message", statement {
-                (thisObj as ObjException).message.toObj()
-            })
-        }
-
-        private val op = ProtectedOp()
-        private val existingErrorClasses = mutableMapOf<String, ExceptionClass>()
-
-
-        @OptIn(ExperimentalContracts::class)
-        protected fun getOrCreateExceptionClass(name: String): ExceptionClass {
-            return op.withLock {
-                existingErrorClasses.getOrPut(name) {
-                    ExceptionClass(name, Root)
-                }
-            }
-        }
-
-        /**
-         * Get [ObjClass] for error class by name if exists.
-         */
-        @OptIn(ExperimentalContracts::class)
-        fun getErrorClass(name: String): ObjClass? = op.withLock {
-            existingErrorClasses[name]
-        }
-
-        fun addExceptionsToContext(scope: Scope) {
-            scope.addConst("Exception", Root)
-            existingErrorClasses["Exception"] = Root
-            for (name in listOf(
-                "NullReferenceException",
-                "AssertionFailedException",
-                "ClassCastException",
-                "IndexOutOfBoundsException",
-                "IllegalArgumentException",
-                "NoSuchElementException",
-                "IllegalAssignmentException",
-                "SymbolNotDefinedException",
-                "IterationEndException",
-                "AccessException",
-                "UnknownException",
-            )) {
-                scope.addConst(name, getOrCreateExceptionClass(name))
-            }
-        }
-    }
-}
-
-class ObjNullReferenceException(scope: Scope) : ObjException("NullReferenceException", scope, "object is null")
-
-class ObjAssertionFailedException(scope: Scope, message: String) :
-    ObjException("AssertionFailedException", scope, message)
-
-class ObjClassCastException(scope: Scope, message: String) : ObjException("ClassCastException", scope, message)
-class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of bounds") :
-    ObjException("IndexOutOfBoundsException", scope, message)
-
-class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") :
-    ObjException("IllegalArgumentException", scope, message)
-
-class ObjIllegalStateException(scope: Scope, message: String = "illegal state") :
-    ObjException("IllegalStateException", scope, message)
-
-@Suppress("unused")
-class ObjNoSuchElementException(scope: Scope, message: String = "no such element") :
-    ObjException("IllegalArgumentException", scope, message)
-
-class ObjIllegalAssignmentException(scope: Scope, message: String = "illegal assignment") :
-    ObjException("NoSuchElementException", scope, message)
-
-class ObjSymbolNotDefinedException(scope: Scope, message: String = "symbol is not defined") :
-    ObjException("SymbolNotDefinedException", scope, message)
-
-class ObjIterationFinishedException(scope: Scope) :
-    ObjException("IterationEndException", scope, "iteration finished")
-
-class ObjAccessException(scope: Scope, message: String = "access not allowed error") :
-    ObjException("AccessException", scope, message)
-
-class ObjUnknownException(scope: Scope, message: String = "access not allowed error") :
-    ObjException("UnknownException", scope, message)
-
-class ObjIllegalOperationException(scope: Scope, message: String = "Operation is illegal") :
-    ObjException("IllegalOperationException", scope, message)
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng.obj

 val ObjArray by lazy {
@@ -34,5 +51,25 @@ val ObjArray by lazy {
            ObjRange(0.toObj(), thisObj.invokeInstanceMethod(this, "size"), false)
        }

+        addFn("binarySearch") {
+            val target = args.firstAndOnly()
+            var low = 0
+            var high = thisObj.invokeInstanceMethod(this, "size").toInt() - 1
+
+            while (low <= high) {
+                val mid = (low + high) / 2
+                val midVal = thisObj.getAt(this, ObjInt(mid.toLong()))
+
+                val cmp = midVal.compareTo(this, target)
+                when {
+                    cmp == 0 -> return@addFn (mid).toObj()
+                    cmp > 0 -> high = mid - 1
+                    else -> low = mid + 1
+                }
+            }
+
+            // Элемент не найден, возвращаем -(точка вставки) - 1
+            (-low - 1).toObj()
+        }
    }
 }
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng.obj

 import net.sergeych.lyng.Scope
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng.obj

 import net.sergeych.bintools.toDump
@@ -18,12 +35,12 @@ class ObjBitBuffer(val bitArray: BitArray) : Obj() {
        }.apply {
            addFn("toBuffer") {
                requireNoArgs()
-                ObjBuffer(thisAs<ObjBitBuffer>().bitArray.asUbyteArray())
+                ObjBuffer(thisAs<ObjBitBuffer>().bitArray.asUByteArray())
            }
            addFn("toDump") {
                requireNoArgs()
                ObjString(
-                    thisAs<ObjBitBuffer>().bitArray.asUbyteArray().toDump()
+                    thisAs<ObjBitBuffer>().bitArray.asUByteArray().toDump()
                )
            }
            addFn("size") {
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng.obj

 import net.sergeych.lyng.Scope
@@ -6,7 +23,6 @@ import net.sergeych.lynon.LynonEncoder
 import net.sergeych.lynon.LynonType

 data class ObjBool(val value: Boolean) : Obj() {
-    override val asStr by lazy { ObjString(value.toString()) }

    override suspend fun compareTo(scope: Scope, other: Obj): Int {
        if (other !is ObjBool) return -2
@@ -1,20 +1,44 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng.obj

 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.toList
+import net.sergeych.bintools.decodeHex
 import net.sergeych.bintools.encodeToHex
 import net.sergeych.bintools.toDump
 import net.sergeych.lyng.Scope
 import net.sergeych.lyng.statement
+import net.sergeych.lynon.BitArray
 import net.sergeych.lynon.LynonDecoder
 import net.sergeych.lynon.LynonEncoder
 import net.sergeych.lynon.LynonType
+import net.sergeych.mp_tools.decodeBase64Url
+import net.sergeych.mp_tools.encodeToBase64Url
 import kotlin.math.min

 open class ObjBuffer(val byteArray: UByteArray) : Obj() {

    override val objClass: ObjClass = type

+    val hex by lazy { byteArray.encodeToHex("")}
+    val base64 by lazy { byteArray.toByteArray().encodeToBase64Url()}
+
    fun checkIndex(scope: Scope, index: Obj): Int {
        if (index !is ObjInt)
            scope.raiseIllegalArgument("index must be Int")
@@ -38,7 +62,10 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
    val size by byteArray::size

    override fun hashCode(): Int {
-        return byteArray.hashCode()
+        // On some platforms (notably JS), UByteArray.hashCode() is not content-based.
+        // For map/set keys we must ensure hash is consistent with equals(contentEquals).
+        // Convert to ByteArray and use contentHashCode() which is value-based and stable.
+        return byteArray.asByteArray().contentHashCode()
    }

    override suspend fun compareTo(scope: Scope, other: Obj): Int {
@@ -63,12 +90,10 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
                byteArray + other.toFlow(scope).map { it.toLong().toUByte() }.toList().toTypedArray()
                    .toUByteArray()
            )
-        } else scope.raiseIllegalArgument("can't concatenate buffer with ${other.inspect()}")
+        } else scope.raiseIllegalArgument("can't concatenate buffer with ${other.inspect(scope)}")
    }

-    override fun toString(): String {
-        return "Buffer(${byteArray.encodeToHex()})"
-    }
+    override fun toString(): String = base64

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
@@ -85,6 +110,8 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
        encoder.encodeCachedBytes(byteArray.asByteArray())
    }

+    override suspend fun inspect(scope: Scope): String = "Buf($base64)"
+
    companion object {
        private suspend fun createBufferFrom(scope: Scope, obj: Obj): ObjBuffer =
            when (obj) {
@@ -105,7 +132,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
                        )
                    } else
                        scope.raiseIllegalArgument(
-                            "can't construct buffer from ${obj.inspect()}"
+                            "can't construct buffer from ${obj.inspect(scope)}"
                        )
                }
            }
@@ -125,7 +152,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
                                is ObjChar -> b.value.code.toUByte()
                                is ObjInt -> b.value.toUByte()
                                else -> scope.raiseIllegalArgument(
-                                    "invalid byte value for buffer constructor at index $i: ${b.inspect()}"
+                                    "invalid byte value for buffer constructor at index $i: ${b.inspect(scope)}"
                                )
                            }
                            data[i] = code
@@ -141,11 +168,27 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
                })

        }.apply {
+            addClassFn("decodeBase64") {
+                ObjBuffer(requireOnlyArg<Obj>().toString().decodeBase64Url().asUByteArray())
+            }
+            addClassFn("decodeHex") {
+                ObjBuffer(requireOnlyArg<Obj>().toString().decodeHex().asUByteArray())
+            }
            createField("size",
                statement {
                    (thisObj as ObjBuffer).byteArray.size.toObj()
                }
            )
+            createField("hex",
+                statement {
+                    thisAs<ObjBuffer>().hex.toObj()
+                }
+            )
+            createField("base64",
+                statement {
+                    thisAs<ObjBuffer>().base64.toObj()
+                }
+            )
            addFn("decodeUtf8") {
                ObjString(
                    thisAs<ObjBuffer>().byteArray.toByteArray().decodeToString()
@@ -161,6 +204,9 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
                    thisAs<ObjBuffer>().byteArray.toByteArray().toDump()
                )
            }
+            addFn("toBitInput") {
+                ObjBitBuffer(BitArray(thisAs<ObjBuffer>().byteArray, 8))
+            }
        }
    }
 }
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng.obj

 import net.sergeych.lyng.Scope
@@ -11,7 +28,7 @@ class ObjChar(val value: Char): Obj() {

    override fun toString(): String = value.toString()

-    override fun inspect(): String = "'$value'"
+    override suspend fun inspect(scope: Scope): String = "'$value'"

    override fun hashCode(): Int {
        return value.hashCode()
@@ -1,9 +1,29 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng.obj

 import net.sergeych.lyng.*
 import net.sergeych.lynon.LynonDecoder
 import net.sergeych.lynon.LynonType

+// Simple id generator for class identities (not thread-safe; fine for scripts)
+private object ClassIdGen { var c: Long = 1L; fun nextId(): Long = c++ }
+
 val ObjClassType by lazy { ObjClass("Class") }

 open class ObjClass(
@@ -11,21 +31,109 @@ open class ObjClass(
    vararg parents: ObjClass,
 ) : Obj() {

+    // Stable identity and simple structural version for PICs
+    val classId: Long = ClassIdGen.nextId()
+    var layoutVersion: Int = 0
+
    val classNameObj by lazy { ObjString(className) }

    var constructorMeta: ArgsDeclaration? = null
    var instanceConstructor: Statement? = null

+    /**
+     * Per-instance initializers collected from class body (for instance fields). These are executed
+     * during construction in the instance scope of the object, once per class in the hierarchy.
+     */
+    val instanceInitializers: MutableList<Statement> = mutableListOf()
+
+    /**
+     * the scope for class methods, initialize class vars, etc.
+     *
+     * Important notice. When create a user class, e.g. from Lyng source, it should
+     * be set to a scope by compiler, so it could access local closure, etc. Otherwise,
+     * it will be initialized to default scope on first necessity, e.g. when used in
+     * external, kotlin classes with [addClassConst] and [addClassFn], etc.
+     */
+    var classScope: Scope? = null
+
+    /** Direct parents in declaration order (kept deterministic). */
+    val directParents: List<ObjClass> = parents.toList()
+
+    /** Optional constructor argument specs for each direct parent (set by compiler for user classes). */
+    open val directParentArgs: MutableMap<ObjClass, List<ParsedArgument>> = mutableMapOf()
+
+    /**
+     * All ancestors as a Set for fast `isInstanceOf` checks. Order is not guaranteed here and
+     * must not be used for resolution
+     */
    val allParentsSet: Set<ObjClass> =
-        parents.flatMap {
-            listOf(it) + it.allParentsSet
-        }.toMutableSet()
+        buildSet {
+            fun collect(c: ObjClass) {
+                if (add(c)) c.directParents.forEach { collect(it) }
+            }
+            directParents.forEach { collect(it) }
+        }
+
+    // --- C3 Method Resolution Order (MRO) ---
+    private fun c3Merge(seqs: MutableList<MutableList<ObjClass>>): List<ObjClass> {
+        val result = mutableListOf<ObjClass>()
+        while (seqs.isNotEmpty()) {
+            // remove empty lists
+            seqs.removeAll { it.isEmpty() }
+            if (seqs.isEmpty()) break
+            var candidate: ObjClass? = null
+            outer@ for (seq in seqs) {
+                val head = seq.first()
+                // head must not appear in any other list's tail
+                var inTail = false
+                for (other in seqs) {
+                    if (other === seq || other.size <= 1) continue
+                    if (other.drop(1).contains(head)) { inTail = true; break }
+                }
+                if (!inTail) { candidate = head; break@outer }
+            }
+            val picked = candidate ?: throw ScriptError(Pos.builtIn, "C3 MRO failed: inconsistent hierarchy for $className")
+            result += picked
+            // remove picked from heads
+            for (seq in seqs) if (seq.isNotEmpty() && seq.first() === picked) seq.removeAt(0)
+        }
+        return result
+    }
+
+    private fun c3Linearize(self: ObjClass, visited: MutableMap<ObjClass, List<ObjClass>>): List<ObjClass> {
+        visited[self]?.let { return it }
+        // Linearize parents first
+        val parentLinearizations = self.directParents.map { c3Linearize(it, visited) }
+        // Merge parent MROs with the direct parent list
+        val toMerge: MutableList<MutableList<ObjClass>> = mutableListOf()
+        parentLinearizations.forEach { toMerge += it.toMutableList() }
+        toMerge += self.directParents.toMutableList()
+        val merged = c3Merge(toMerge)
+        val mro = listOf(self) + merged
+        visited[self] = mro
+        return mro
+    }
+
+    /** Full C3 MRO including this class at index 0. */
+    val mro: List<ObjClass> by lazy { c3Linearize(this, mutableMapOf()) }
+
+    /** Parents in C3 order (no self). */
+    val mroParents: List<ObjClass> by lazy { mro.drop(1) }
+
+    /** Render current linearization order for diagnostics (C3). */
+    fun renderLinearization(includeSelf: Boolean = true): String {
+        val list = mutableListOf<String>()
+        if (includeSelf) list += className
+        mroParents.forEach { list += it.className }
+        return list.joinToString(" → ")
+    }

    override val objClass: ObjClass by lazy { ObjClassType }

-    // members: fields most often
-    private val members = mutableMapOf<String, ObjRecord>()
-    private val classMembers = mutableMapOf<String, ObjRecord>()
+    /**
+     * members: fields most often. These are called with [ObjInstance] withs ths [ObjInstance.objClass]
+     */
+    internal val members = mutableMapOf<String, ObjRecord>()

    override fun toString(): String = className

@@ -33,13 +141,104 @@ open class ObjClass(

    override suspend fun callOn(scope: Scope): Obj {
        val instance = ObjInstance(this)
-        instance.instanceScope = scope.copy(newThisObj = instance,args = scope.args)
-        if (instanceConstructor != null) {
-            instanceConstructor!!.execute(instance.instanceScope)
+        // Avoid capturing a transient (pooled) call frame as the parent of the instance scope.
+        // Bind instance scope to the caller's parent chain directly so name resolution (e.g., stdlib like sqrt)
+        // remains stable even when call frames are pooled and reused.
+        val stableParent = scope.parent
+        instance.instanceScope = Scope(stableParent, scope.args, scope.pos, instance)
+        // Expose instance methods (and other callable members) directly in the instance scope for fast lookup
+        // This mirrors Obj.autoInstanceScope behavior for ad-hoc scopes and makes fb.method() resolution robust
+        // 1) members-defined methods
+        for ((k, v) in members) {
+            if (v.value is Statement) {
+                instance.instanceScope.objects[k] = v
+            }
        }
+        // 2) class-scope methods registered during class-body execution
+        classScope?.objects?.forEach { (k, rec) ->
+            if (rec.value is Statement) {
+                // if not already present, copy reference for dispatch
+                if (!instance.instanceScope.objects.containsKey(k)) {
+                    instance.instanceScope.objects[k] = rec
+                }
+            }
+        }
+        // Constructor chaining MVP: initialize base classes left-to-right, then this class.
+        // Ensure each ancestor is initialized at most once (diamond-safe).
+        val visited = hashSetOf<ObjClass>()
+
+        suspend fun initClass(c: ObjClass, argsForThis: Arguments?, isRoot: Boolean = false) {
+            if (!visited.add(c)) return
+            // For the most-derived class, bind its constructor params BEFORE parents so base arg thunks can see them
+            if (isRoot) {
+                c.constructorMeta?.let { meta ->
+                    val argsHere = argsForThis ?: Arguments.EMPTY
+                    // Assign constructor params into instance scope (unmangled)
+                    meta.assignToContext(instance.instanceScope, argsHere)
+                    // Also expose them under MI-mangled storage keys `${Class}::name` so qualified views can access them
+                    // and so that base-class casts like `(obj as Base).field` work.
+                    for (p in meta.params) {
+                        val rec = instance.instanceScope.objects[p.name]
+                        if (rec != null) {
+                            val mangled = "${c.className}::${p.name}"
+                            // Always point the mangled name to the current record to keep writes consistent
+                            // across re-bindings (e.g., second pass before ctor)
+                            instance.instanceScope.objects[mangled] = rec
+                        }
+                    }
+                }
+            }
+            // Initialize direct parents first, in order
+            for (p in c.directParents) {
+                val raw = c.directParentArgs[p]?.toArguments(instance.instanceScope, false)
+                val limited = if (raw != null) {
+                    val need = p.constructorMeta?.params?.size ?: 0
+                    if (need == 0) Arguments.EMPTY else Arguments(raw.list.take(need), tailBlockMode = false)
+                } else Arguments.EMPTY
+                initClass(p, limited)
+            }
+            // Execute per-instance initializers collected from class body for this class
+            if (c.instanceInitializers.isNotEmpty()) {
+                val savedCtx = instance.instanceScope.currentClassCtx
+                instance.instanceScope.currentClassCtx = c
+                try {
+                    for (initStmt in c.instanceInitializers) {
+                        initStmt.execute(instance.instanceScope)
+                    }
+                } finally {
+                    instance.instanceScope.currentClassCtx = savedCtx
+                }
+            }
+            // Then run this class' constructor, if any
+            c.instanceConstructor?.let { ctor ->
+                // Bind this class's constructor parameters into the instance scope now, right before ctor
+                c.constructorMeta?.let { meta ->
+                    val argsHere = argsForThis ?: Arguments.EMPTY
+                    meta.assignToContext(instance.instanceScope, argsHere)
+                    // Ensure mangled aliases exist for qualified access starting from this class
+                    for (p in meta.params) {
+                        val rec = instance.instanceScope.objects[p.name]
+                        if (rec != null) {
+                            val mangled = "${c.className}::${p.name}"
+                            // Overwrite to ensure alias refers to the latest ObjRecord after re-binding
+                            instance.instanceScope.objects[mangled] = rec
+                        }
+                    }
+                }
+                val execScope = instance.instanceScope.createChildScope(args = argsForThis ?: Arguments.EMPTY, newThisObj = instance)
+                ctor.execute(execScope)
+            }
+        }
+
+        initClass(this, instance.instanceScope.args, isRoot = true)
        return instance
    }

+    suspend fun callWithArgs(scope: Scope, vararg plainArgs: Obj): Obj {
+        return callOn(scope.createChildScope(Arguments(*plainArgs)))
+    }
+
+
    fun createField(
        name: String,
        initialValue: Obj,
@@ -47,10 +246,19 @@ open class ObjClass(
        visibility: Visibility = Visibility.Public,
        pos: Pos = Pos.builtIn
    ) {
-        val existing = members[name] ?: allParentsSet.firstNotNullOfOrNull { it.members[name] }
-        if( existing?.isMutable == false)
-            throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
-        members[name] = ObjRecord(initialValue, isMutable, visibility)
+        // Allow overriding ancestors: only prevent redefinition if THIS class already defines an immutable member
+        val existingInSelf = members[name]
+        if (existingInSelf != null && existingInSelf.isMutable == false)
+            throw ScriptError(pos, "$name is already defined in $objClass")
+        // Install/override in this class
+        members[name] = ObjRecord(initialValue, isMutable, visibility, declaringClass = this)
+        // Structural change: bump layout version for PIC invalidation
+        layoutVersion += 1
+    }
+
+    private fun initClassScope(): Scope {
+        if (classScope == null) classScope = Scope()
+        return classScope!!
    }

    fun createClassField(
@@ -60,14 +268,23 @@ open class ObjClass(
        visibility: Visibility = Visibility.Public,
        pos: Pos = Pos.builtIn
    ) {
-        val existing = classMembers[name]
-        if( existing != null)
+        initClassScope()
+        val existing = classScope!!.objects[name]
+        if (existing != null)
            throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
-        classMembers[name] = ObjRecord(initialValue, isMutable, visibility)
+        classScope!!.addItem(name, isMutable, initialValue, visibility)
+        // Structural change: bump layout version for PIC invalidation
+        layoutVersion += 1
    }

-    fun addFn(name: String, isOpen: Boolean = false, code: suspend Scope.() -> Obj) {
-        createField(name, statement { code() }, isOpen)
+    fun addFn(
+        name: String,
+        isOpen: Boolean = false,
+        visibility: Visibility = Visibility.Public,
+        code: suspend Scope.() -> Obj
+    ) {
+        val stmt = statement { code() }
+        createField(name, stmt, isOpen, visibility)
    }

    fun addConst(name: String, value: Obj) = createField(name, value, isMutable = false)
@@ -81,29 +298,71 @@ open class ObjClass(
     * Get instance member traversing the hierarchy if needed. Its meaning is different for different objects.
     */
    fun getInstanceMemberOrNull(name: String): ObjRecord? {
-        members[name]?.let { return it }
-        allParentsSet.forEach { parent -> parent.getInstanceMemberOrNull(name)?.let { return it } }
+        // Unified traversal in strict C3 order: self, then each ancestor, checking members before classScope
+        for (cls in mro) {
+            cls.members[name]?.let { return it }
+            cls.classScope?.objects?.get(name)?.let { return it }
+        }
+        // Finally, allow root object fallback (rare; mostly built-ins like toString)
        return rootObjectType.members[name]
    }

+    /** Find the declaring class where a member with [name] is defined, starting from this class along MRO. */
+    fun findDeclaringClassOf(name: String): ObjClass? {
+        if (members.containsKey(name)) return this
+        for (anc in mroParents) {
+            if (anc.members.containsKey(name)) return anc
+        }
+        return if (rootObjectType.members.containsKey(name)) rootObjectType else null
+    }
+
    fun getInstanceMember(atPos: Pos, name: String): ObjRecord =
        getInstanceMemberOrNull(name)
            ?: throw ScriptError(atPos, "symbol doesn't exist: $name")

+    /**
+     * Resolve member starting from a specific ancestor class [start], not from this class.
+     * Searches [start] first, then traverses its linearized parents.
+     */
+    fun getInstanceMemberFromAncestor(start: ObjClass, name: String): ObjRecord? {
+        val order = mro
+        val idx = order.indexOf(start)
+        if (idx < 0) return null
+        for (i in idx until order.size) {
+            val cls = order[i]
+            // Prefer true instance members on the class
+            cls.members[name]?.let { return it }
+            // Fallback to class-scope function registered during class-body execution
+            cls.classScope?.objects?.get(name)?.let { return it }
+        }
+        return rootObjectType.members[name]
+    }
+
    override suspend fun readField(scope: Scope, name: String): ObjRecord {
-        classMembers[name]?.let {
-            return it
+        classScope?.objects?.get(name)?.let {
+            if (it.visibility.isPublic) return it
        }
        return super.readField(scope, name)
    }

-    override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
-                                              onNotFoundResult: Obj?): Obj {
-        return classMembers[name]?.value?.invoke(scope, this, args)
+    override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
+        initClassScope().objects[name]?.let {
+            if (it.isMutable) it.value = newValue
+            else scope.raiseIllegalAssignment("can't assign $name is not mutable")
+        }
+            ?: super.writeField(scope, name, newValue)
+    }
+
+    override suspend fun invokeInstanceMethod(
+        scope: Scope, name: String, args: Arguments,
+        onNotFoundResult: (() -> Obj?)?
+    ): Obj {
+        return classScope?.objects?.get(name)?.value?.invoke(scope, this, args)
            ?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
    }

-    open suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj = scope.raiseNotImplemented()
+    open suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
+        scope.raiseNotImplemented()

 }

@@ -1,8 +1,25 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng.obj

 /**
- * Collection is an iterator with `size`]
+ * Collection is an iterator with `size`
 */
 val ObjCollection = ObjClass("Collection", ObjIterable).apply {
+}

-    }
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import kotlinx.coroutines.CompletableDeferred
+import net.sergeych.lyng.Scope
+
+class ObjCompletableDeferred(val completableDeferred: CompletableDeferred<Obj>): ObjDeferred(completableDeferred) {
+
+    override val objClass = type
+
+    companion object {
+        val type = object: ObjClass("CompletableDeferred", ObjDeferred.type){
+            override suspend fun callOn(scope: Scope): Obj {
+                return ObjCompletableDeferred(CompletableDeferred())
+            }
+        }.apply {
+            addFn("complete") {
+                thisAs<ObjCompletableDeferred>().completableDeferred.complete(args.firstAndOnly())
+                ObjVoid
+            }
+        }
+    }
+}
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import kotlinx.coroutines.Deferred
+import net.sergeych.lyng.Scope
+
+open class ObjDeferred(val deferred: Deferred<Obj>): Obj() {
+
+    override val objClass = type
+
+    companion object {
+        val type = object: ObjClass("Deferred"){
+            override suspend fun callOn(scope: Scope): Obj {
+                scope.raiseError("Deferred constructor is not directly callable")
+            }
+        }.apply {
+            addFn("await") {
+                thisAs<ObjDeferred>().deferred.await()
+            }
+            addFn("isCompleted") {
+                thisAs<ObjDeferred>().deferred.isCompleted.toObj()
+            }
+            addFn("isActive") {
+                val d = thisAs<ObjDeferred>().deferred
+                // Cross-engine tolerant: prefer Deferred.isActive; otherwise treat any not-yet-completed and not-cancelled as active
+                (d.isActive || (!d.isCompleted && !d.isCancelled)).toObj()
+            }
+            addFn("isCancelled") {
+                thisAs<ObjDeferred>().deferred.isCancelled.toObj()
+            }
+
+        }
+    }
+}
+
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+//class ObjDelegateContext()
+//
+//class ObjDelegate(
+//                  val getter: Statement,
+//                  val setter: Statement = statement { raiseNotImplemented("setter is not implemented") }
+//): Obj() {
+//
+//    override suspend fun assign(scope: Scope, other: Obj): Obj? {
+//        setter.execute(scope.copy(Arguments(other)))
+//        return other
+//    }
+//
+//    companion object {
+//        val type = object: ObjClass("Delegate") {
+//            override suspend fun callOn(scope: Scope): Obj {
+//                scope.raiseError("Delegate should not be constructed directly")
+//            }
+//        }.apply {
+//
+//        }
+//    }
+//
+//}
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng.obj

 import net.sergeych.lyng.Scope
@@ -40,7 +57,7 @@ class ObjDuration(val duration: Duration) : Obj() {
            override suspend fun callOn(scope: Scope): Obj {
                val args = scope.args
                if( args.list.size > 1 )
-                    scope.raiseIllegalArgument("can't construct Duration(${args.inspect()})")
+                    scope.raiseIllegalArgument("can't construct Duration(${args.inspect(scope)})")
                val a0 = args.list.getOrNull(0)

                return ObjDuration(
@@ -49,7 +66,7 @@ class ObjDuration(val duration: Duration) : Obj() {
                        is ObjInt -> a0.value.seconds
                        is ObjReal -> a0.value.seconds
                        else -> {
-                            scope.raiseIllegalArgument("can't construct Instant(${args.inspect()})")
+                            scope.raiseIllegalArgument("can't construct Instant(${args.inspect(scope)})")
                        }
                    }
                )
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import net.sergeych.lyng.Arguments
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.Statement
+
+class ObjDynamicContext(val delegate: ObjDynamic) : Obj() {
+    override val objClass: ObjClass = type
+
+    companion object {
+        val type = ObjClass("DelegateContext").apply {
+            addFn("get") {
+                val d = thisAs<ObjDynamicContext>().delegate
+                if (d.readCallback != null)
+                    raiseIllegalState("get already defined")
+                d.readCallback = requireOnlyArg()
+                ObjVoid
+            }
+
+            addFn("set") {
+                val d = thisAs<ObjDynamicContext>().delegate
+                if (d.writeCallback != null)
+                    raiseIllegalState("set already defined")
+                d.writeCallback = requireOnlyArg()
+                ObjVoid
+            }
+
+        }
+
+    }
+}
+
+/**
+ * Object that delegates all its field access/invocation operations to a callback. It is used to implement dynamic
+ * objects using "dynamic" keyword.
+ */
+open class ObjDynamic(var readCallback: Statement? = null, var writeCallback: Statement? = null) : Obj() {
+
+    override val objClass: ObjClass = type
+
+    /**
+     * Use read callback to dynamically resolve the field name. Note that it does not work
+     * with method invocation which is implemented separately in [invokeInstanceMethod] below.
+     */
+    override suspend fun readField(scope: Scope, name: String): ObjRecord {
+        return readCallback?.execute(scope.createChildScope(Arguments(ObjString(name))))?.let {
+            if (writeCallback != null)
+                it.asMutable
+            else
+                it.asReadonly
+        }
+            ?: super.readField(scope, name)
+    }
+
+    /**
+     * Notice that invocation currently does not rely on [readField], which is a buffy moment to be reconsidered
+     * in the future, so we implement it separately:
+     */
+    override suspend fun invokeInstanceMethod(
+        scope: Scope,
+        name: String,
+        args: Arguments,
+        onNotFoundResult: (() -> Obj?)?
+    ): Obj {
+        val over = readCallback?.execute(
+            scope.createChildScope(
+                Arguments(ObjString(name)
+                )
+            )
+        )
+        return over?.invoke(scope, scope.thisObj, args)
+            ?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
+    }
+
+    override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
+        writeCallback?.execute(scope.createChildScope(Arguments(ObjString(name), newValue)))
+            ?: super.writeField(scope, name, newValue)
+    }
+
+    override suspend fun getAt(scope: Scope, index: Obj): Obj {
+        return readCallback?.execute(scope.createChildScope(Arguments(index)))
+            ?: super.getAt(scope, index)
+    }
+
+    override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
+        writeCallback?.execute(scope.createChildScope(Arguments(index, newValue)))
+            ?: super.putAt(scope, index, newValue)
+    }
+
+    companion object {
+
+        suspend fun create(scope: Scope, builder: Statement): ObjDynamic {
+            val delegate = ObjDynamic()
+            val context = ObjDynamicContext(delegate)
+            builder.execute(scope.createChildScope(newThisObj = context))
+            return delegate
+        }
+
+        val type = object : ObjClass("Delegate") {}.apply {
+//            addClassConst("IndexGetName", operatorGetName)
+        }
+    }
+
+}
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import net.sergeych.lyng.Scope
+import net.sergeych.lyng.obj.*
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
+
+open class ObjEnumEntry(enumClass: ObjEnumClass, val name: ObjString, val ordinal: ObjInt) : Obj() {
+    override val objClass = enumClass
+
+    override fun toString(): String {
+        return "$objClass.$name"
+    }
+
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        encoder.encodeUnsigned(ordinal.value.toULong())
+    }
+
+    override suspend fun compareTo(scope: Scope, other: Obj): Int {
+        if( other !is ObjEnumEntry) return -2
+        if( other.objClass != objClass ) return -2
+        return ordinal.compareTo(scope, other.ordinal)
+    }
+
+}
+
+object EnumBase : ObjClass("Enum") {
+
+}
+
+class ObjEnumClass(val name: String) : ObjClass(name, EnumBase) {
+    val objEntries = ObjList()
+    val byName by lazy { objEntries.list.associateBy { (it as ObjEnumEntry).name } }
+
+    init {
+        addClassConst("entries", objEntries )
+        addClassFn("valueOf") {
+            val name = requireOnlyArg<ObjString>()
+            byName[name] ?: raiseSymbolNotFound("does not exists: enum ${className}.$name")
+        }
+        addFn("name") { thisAs<ObjEnumEntry>().name }
+        addFn("ordinal") { thisAs<ObjEnumEntry>().ordinal }
+
+    }
+
+    override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
+        val index = decoder.unpackUnsigned().toInt()
+        return objEntries.list[index]
+    }
+
+    companion object {
+        fun createSimpleEnum(enumName: String, names: List<String>): ObjEnumClass {
+            val klass = ObjEnumClass(enumName)
+            names.forEachIndexed { index, name ->
+                val entry = ObjEnumEntry(klass, ObjString(name), ObjInt(index.toLong(), isConst = true))
+                klass.objEntries.list += entry
+                klass.addClassConst(name, entry)
+            }
+            return klass
+        }
+    }
+
+}
@@ -0,0 +1,228 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import net.sergeych.bintools.encodeToHex
+import net.sergeych.lyng.*
+import net.sergeych.lynon.LynonDecoder
+import net.sergeych.lynon.LynonEncoder
+import net.sergeych.lynon.LynonType
+import net.sergeych.mptools.CachedExpression
+import net.sergeych.synctools.ProtectedOp
+import net.sergeych.synctools.withLock
+import kotlin.contracts.ExperimentalContracts
+
+/**
+ * Note on [getStackTrace]. If [useStackTrace] is not null, it is used instead. Otherwise, it is calculated
+ * from the current scope, which is treated as an exception scope. It is used to restore a serialized
+ * exception with stack trace; the scope of the deserialized exception is not valid
+ * for stack unwinding.
+ */
+open class ObjException(
+    val exceptionClass: ExceptionClass,
+    val scope: Scope,
+    val message: ObjString,
+    @Suppress("unused") val extraData: Obj = ObjNull,
+    val useStackTrace: ObjList? = null
+) : Obj() {
+    constructor(name: String, scope: Scope, message: String) : this(
+        getOrCreateExceptionClass(name),
+        scope,
+        ObjString(message)
+    )
+
+    private val cachedStackTrace = CachedExpression(initialValue = useStackTrace)
+
+    suspend fun getStackTrace(): ObjList {
+        return cachedStackTrace.get {
+            val result = ObjList()
+            val maybeCls = scope.get("StackTraceEntry")?.value as? ObjClass
+            var s: Scope? = scope
+            var lastPos: Pos? = null
+            while (s != null) {
+                val pos = s.pos
+                if (pos != lastPos && !pos.currentLine.isEmpty()) {
+                    if (maybeCls != null) {
+                        result.list += maybeCls.callWithArgs(
+                            scope,
+                            pos.source.objSourceName,
+                            ObjInt(pos.line.toLong()),
+                            ObjInt(pos.column.toLong()),
+                            ObjString(pos.currentLine)
+                        )
+                    } else {
+                        // Fallback textual entry if StackTraceEntry class is not available in this scope
+                        result.list += ObjString("${'$'}{pos.source.objSourceName}:${'$'}{pos.line}:${'$'}{pos.column}: ${'$'}{pos.currentLine}")
+                    }
+                }
+                s = s.parent
+                lastPos = pos
+            }
+            result
+        }
+    }
+
+    constructor(scope: Scope, message: String) : this(Root, scope, ObjString(message))
+
+    fun raise(): Nothing {
+        throw ExecutionError(this)
+    }
+
+    override val objClass: ObjClass = exceptionClass
+
+    override suspend fun toString(scope: Scope, calledFromLyng: Boolean): ObjString {
+        val at = getStackTrace().list.firstOrNull()?.toString(scope)
+            ?: ObjString("(unknown)")
+        return ObjString("${objClass.className}: $message at $at")
+    }
+
+    override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
+        encoder.encodeAny(scope, exceptionClass.classNameObj)
+        encoder.encodeAny(scope, message)
+        encoder.encodeAny(scope, extraData)
+        encoder.encodeAny(scope, getStackTrace())
+    }
+
+
+    companion object {
+
+        class ExceptionClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {
+            override suspend fun callOn(scope: Scope): Obj {
+                val message = scope.args.getOrNull(0)?.toString(scope) ?: ObjString(name)
+                return ObjException(this, scope, message)
+            }
+
+            override fun toString(): String = "ExceptionClass[$name]@${hashCode().encodeToHex()}"
+
+            override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
+                return try {
+                    val lyngClass = decoder.decodeAnyAs<ObjString>(scope).value.let {
+                        ((scope[it] ?: scope.raiseIllegalArgument("Unknown exception class: $it"))
+                            .value as? ExceptionClass)
+                            ?: scope.raiseIllegalArgument("Not an exception class: $it")
+                    }
+                    ObjException(
+                        lyngClass,
+                        scope,
+                        decoder.decodeAnyAs<ObjString>(scope),
+                        decoder.decodeAny(scope),
+                        decoder.decodeAnyAs<ObjList>(scope)
+                    )
+                } catch (e: ScriptError) {
+                    throw e
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                    scope.raiseIllegalArgument("Failed to deserialize exception: ${e.message}")
+                }
+            }
+        }
+
+        val Root = ExceptionClass("Exception").apply {
+            addConst("message", statement {
+                (thisObj as ObjException).message.toObj()
+            })
+            addFn("stackTrace") {
+                (thisObj as ObjException).getStackTrace()
+            }
+        }
+
+        private val op = ProtectedOp()
+        private val existingErrorClasses = mutableMapOf<String, ExceptionClass>()
+
+
+        @OptIn(ExperimentalContracts::class)
+        protected fun getOrCreateExceptionClass(name: String): ExceptionClass {
+            return op.withLock {
+                existingErrorClasses.getOrPut(name) {
+                    ExceptionClass(name, Root)
+                }
+            }
+        }
+
+        /**
+         * Get [ObjClass] for error class by name if exists.
+         */
+        @OptIn(ExperimentalContracts::class)
+        fun getErrorClass(name: String): ObjClass? = op.withLock {
+            existingErrorClasses[name]
+        }
+
+        fun addExceptionsToContext(scope: Scope) {
+            scope.addConst("Exception", Root)
+            existingErrorClasses["Exception"] = Root
+            for (name in listOf(
+                "NullReferenceException",
+                "AssertionFailedException",
+                "ClassCastException",
+                "IndexOutOfBoundsException",
+                "IllegalArgumentException",
+                "IllegalStateException",
+                "NoSuchElementException",
+                "IllegalAssignmentException",
+                "SymbolNotDefinedException",
+                "IterationEndException",
+                "AccessException",
+                "UnknownException",
+                "NotFoundException",
+                "IllegalOperationException"
+            )) {
+                scope.addConst(name, getOrCreateExceptionClass(name))
+            }
+        }
+    }
+}
+
+class ObjNullReferenceException(scope: Scope) : ObjException("NullReferenceException", scope, "object is null")
+
+class ObjAssertionFailedException(scope: Scope, message: String) :
+    ObjException("AssertionFailedException", scope, message)
+
+class ObjClassCastException(scope: Scope, message: String) : ObjException("ClassCastException", scope, message)
+class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of bounds") :
+    ObjException("IndexOutOfBoundsException", scope, message)
+
+class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") :
+    ObjException("IllegalArgumentException", scope, message)
+
+class ObjIllegalStateException(scope: Scope, message: String = "illegal state") :
+    ObjException("IllegalStateException", scope, message)
+
+@Suppress("unused")
+class ObjNoSuchElementException(scope: Scope, message: String = "no such element") :
+    ObjException("NoSuchElementException", scope, message)
+
+class ObjIllegalAssignmentException(scope: Scope, message: String = "illegal assignment") :
+    ObjException("IllegalAssignmentException", scope, message)
+
+class ObjSymbolNotDefinedException(scope: Scope, message: String = "symbol is not defined") :
+    ObjException("SymbolNotDefinedException", scope, message)
+
+class ObjIterationFinishedException(scope: Scope) :
+    ObjException("IterationEndException", scope, "iteration finished")
+
+class ObjAccessException(scope: Scope, message: String = "access not allowed error") :
+    ObjException("AccessException", scope, message)
+
+class ObjUnknownException(scope: Scope, message: String = "access not allowed error") :
+    ObjException("UnknownException", scope, message)
+
+class ObjIllegalOperationException(scope: Scope, message: String = "Operation is illegal") :
+    ObjException("IllegalOperationException", scope, message)
+
+class ObjNotFoundException(scope: Scope, message: String = "not found") :
+    ObjException("NotFoundException", scope, message)
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package net.sergeych.lyng.obj
+
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.ChannelResult
+import kotlinx.coroutines.channels.ReceiveChannel
+import kotlinx.coroutines.channels.SendChannel
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import net.sergeych.lyng.*
+import net.sergeych.mp_tools.globalLaunch
+import kotlin.coroutines.cancellation.CancellationException
+
+
+class ObjFlowBuilder(val output: SendChannel<Obj>) : Obj() {
+
+    override val objClass = type
+
+    companion object {
+        @OptIn(DelicateCoroutinesApi::class)
+        val type = object : ObjClass("FlowBuilder") {}.apply {
+            addFn("emit") {
+                val data = requireOnlyArg<Obj>()
+                try {
+                    val channel = thisAs<ObjFlowBuilder>().output
+                    if (!channel.isClosedForSend)
+                        channel.send(data)
+                    else
+                        throw ScriptFlowIsNoMoreCollected()
+                } catch (x: Exception) {
+                    if (x !is CancellationException)
+                        x.printStackTrace()
+                    throw ScriptFlowIsNoMoreCollected()
+                }
+                ObjVoid
+            }
+        }
+    }
+}
+
+private fun createLyngFlowInput(scope: Scope, producer: Statement): ReceiveChannel<Obj> {
+    val channel = Channel<Obj>(Channel.RENDEZVOUS)
+    val builder = ObjFlowBuilder(channel)
+    val builderScope = scope.createChildScope(newThisObj = builder)
+    globalLaunch {
+        try {
+            producer.execute(builderScope)
+        } catch (x: ScriptFlowIsNoMoreCollected) {
+            x.printStackTrace()
+            // premature flow closing, OK
+        } catch (x: Exception) {
+            x.printStackTrace()
+        }
+        channel.close()
+    }
+    return channel
+}
+
+class ObjFlow(val producer: Statement, val scope: Scope) : Obj() {
+
+    override val objClass = type
+
+    companion object {
+        val type = object : ObjClass("Flow", ObjIterable) {
+            override suspend fun callOn(scope: Scope): Obj {
+                scope.raiseError("Flow constructor is not available")
+            }
+        }.apply {
+            addFn("iterator") {
+                val objFlow = thisAs<ObjFlow>()
+                ObjFlowIterator(statement {
+                    objFlow.producer.execute(
+                        ClosureScope(this, objFlow.scope)
+                    )
+                })
+            }
+        }
+    }
+}
+
+
+class ObjFlowIterator(val producer: Statement) : Obj() {
+
+    override val objClass: ObjClass = type
+
+    private var channel: ReceiveChannel<Obj>? = null
+
+    private var nextItem: ChannelResult<Obj>? = null
+
+    private var isCancelled = false
+
+    private fun checkNotCancelled(scope: Scope) {
+        if (isCancelled)
+            scope.raiseIllegalState("iteration is cancelled")
+    }
+
+    suspend fun hasNext(scope: Scope): ObjBool {
+        checkNotCancelled(scope)
+        // cold start:
+        if (channel == null) channel = createLyngFlowInput(scope, producer)
+        if (nextItem == null) nextItem = channel!!.receiveCatching()
+        return ObjBool(nextItem!!.isSuccess)
+    }
+
+    suspend fun next(scope: Scope): Obj {
+        checkNotCancelled(scope)
+        if (hasNext(scope).value == false) scope.raiseIllegalState("iteration is done")
+        return nextItem!!.getOrThrow().also { nextItem = null }
+    }
+
+    private val access = Mutex()
+    suspend fun cancel() {
+        access.withLock {
+            if (!isCancelled) {
+                isCancelled = true
+                channel?.cancel()
+            }
+        }
+    }
+
+    companion object {
+        val type = object : ObjClass("FlowIterator", ObjIterator) {
+
+        }.apply {
+            addFn("hasNext") {
+                thisAs<ObjFlowIterator>().hasNext(this).toObj()
+            }
+            addFn("next") {
+                val x = thisAs<ObjFlowIterator>()
+                x.next(this)
+            }
+            addFn("cancelIteration") {
+                val x = thisAs<ObjFlowIterator>()
+                x.cancel()
+                ObjVoid
+            }
+        }
+    }
+}
@@ -1,7 +1,25 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng.obj

 import net.sergeych.lyng.Arguments
 import net.sergeych.lyng.Scope
+import net.sergeych.lyng.canAccessMember
 import net.sergeych.lynon.LynonDecoder
 import net.sergeych.lynon.LynonEncoder
 import net.sergeych.lynon.LynonType
@@ -11,37 +29,140 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
    internal lateinit var instanceScope: Scope

    override suspend fun readField(scope: Scope, name: String): ObjRecord {
-        return instanceScope[name]?.let {
-            if (it.visibility.isPublic)
-                it
-            else
-                scope.raiseError(ObjAccessException(scope, "can't access non-public field $name"))
+        // Direct (unmangled) lookup first
+        instanceScope[name]?.let {
+            val decl = it.declaringClass ?: objClass.findDeclaringClassOf(name)
+            // When execution passes through suspension points (e.g., withLock),
+            // currentClassCtx could be lost. Fall back to the instance scope class ctx
+            // to preserve correct visibility semantics for private/protected members
+            // accessed from within the class methods.
+            // Allow unconditional access when accessing through `this` of the same instance
+            if (scope.thisObj === this) return it
+            val caller0 = scope.currentClassCtx ?: instanceScope.currentClassCtx
+            val caller = caller0 // do not default to objClass for outsiders
+            if (!canAccessMember(it.visibility, decl, caller))
+                scope.raiseError(ObjAccessException(scope, "can't access field $name (declared in ${decl?.className ?: "?"})"))
+            return it
        }
-            ?: super.readField(scope, name)
+        // Try MI-mangled lookup along linearization (C3 MRO): ClassName::name
+        val cls = objClass
+        // self first, then parents
+        fun findMangled(): ObjRecord? {
+            // self
+            instanceScope.objects["${cls.className}::$name"]?.let { return it }
+            // ancestors in deterministic C3 order
+            for (p in cls.mroParents) {
+                instanceScope.objects["${p.className}::$name"]?.let { return it }
+            }
+            return null
+        }
+        findMangled()?.let { rec ->
+            // derive declaring class by mangled prefix: try self then parents
+            val declaring = when {
+                instanceScope.objects.containsKey("${cls.className}::$name") -> cls
+                else -> cls.mroParents.firstOrNull { instanceScope.objects.containsKey("${it.className}::$name") }
+            }
+            if (scope.thisObj === this) return rec
+            val caller0 = scope.currentClassCtx ?: instanceScope.currentClassCtx
+            val caller = caller0 // do not default to objClass for outsiders
+            if (!canAccessMember(rec.visibility, declaring, caller))
+                scope.raiseError(ObjAccessException(scope, "can't access field $name (declared in ${declaring?.className ?: "?"})"))
+            return rec
+        }
+        // Fall back to methods/properties on class
+        return super.readField(scope, name)
    }

    override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
+        // Direct (unmangled) first
        instanceScope[name]?.let { f ->
-            if (!f.visibility.isPublic)
-                ObjIllegalAssignmentException(scope, "can't assign to non-public field $name")
+            val decl = f.declaringClass ?: objClass.findDeclaringClassOf(name)
+            if (scope.thisObj === this) {
+                // direct self-assignment allowed; enforce mutability below
+            } else {
+                val caller0 = scope.currentClassCtx ?: instanceScope.currentClassCtx
+                val caller = caller0 // do not default to objClass for outsiders
+                if (!canAccessMember(f.visibility, decl, caller))
+                    ObjIllegalAssignmentException(scope, "can't assign to field $name (declared in ${decl?.className ?: "?"})").raise()
+            }
            if (!f.isMutable) ObjIllegalAssignmentException(scope, "can't reassign val $name").raise()
            if (f.value.assign(scope, newValue) == null)
                f.value = newValue
-        } ?: super.writeField(scope, name, newValue)
+            return
+        }
+        // Try MI-mangled resolution along linearization (C3 MRO)
+        val cls = objClass
+        fun findMangled(): ObjRecord? {
+            instanceScope.objects["${cls.className}::$name"]?.let { return it }
+            for (p in cls.mroParents) {
+                instanceScope.objects["${p.className}::$name"]?.let { return it }
+            }
+            return null
+        }
+        val rec = findMangled()
+        if (rec != null) {
+            val declaring = when {
+                instanceScope.objects.containsKey("${cls.className}::$name") -> cls
+                else -> cls.mroParents.firstOrNull { instanceScope.objects.containsKey("${it.className}::$name") }
+            }
+            if (scope.thisObj !== this) {
+                val caller0 = scope.currentClassCtx ?: instanceScope.currentClassCtx
+                val caller = caller0 // do not default to objClass for outsiders
+                if (!canAccessMember(rec.visibility, declaring, caller))
+                    ObjIllegalAssignmentException(scope, "can't assign to field $name (declared in ${declaring?.className ?: "?"})").raise()
+            }
+            if (!rec.isMutable) ObjIllegalAssignmentException(scope, "can't reassign val $name").raise()
+            if (rec.value.assign(scope, newValue) == null)
+                rec.value = newValue
+            return
+        }
+        super.writeField(scope, name, newValue)
    }

    override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
-                                              onNotFoundResult: Obj?): Obj =
-        instanceScope[name]?.let {
-            if (it.visibility.isPublic)
-                it.value.invoke(scope, this, args)
-            else
-                scope.raiseError(ObjAccessException(scope, "can't invoke non-public method $name"))
+                                              onNotFoundResult: (()->Obj?)?): Obj =
+        instanceScope[name]?.let { rec ->
+            val decl = rec.declaringClass ?: objClass.findDeclaringClassOf(name)
+            val caller0 = scope.currentClassCtx ?: instanceScope.currentClassCtx
+            val caller = caller0 ?: if (scope.thisObj === this) objClass else null
+            if (!canAccessMember(rec.visibility, decl, caller))
+                scope.raiseError(ObjAccessException(scope, "can't invoke method $name (declared in ${decl?.className ?: "?"})"))
+            // execute with lexical class context propagated to declaring class
+            val saved = instanceScope.currentClassCtx
+            instanceScope.currentClassCtx = decl
+            try {
+                rec.value.invoke(
+                    instanceScope,
+                    this,
+                    args)
+            } finally {
+                instanceScope.currentClassCtx = saved
+            }
        }
+            ?: run {
+                // fallback: class-scope function (registered during class body execution)
+                objClass.classScope?.objects?.get(name)?.let { rec ->
+                    val decl = rec.declaringClass ?: objClass.findDeclaringClassOf(name)
+                    val caller0 = scope.currentClassCtx ?: instanceScope.currentClassCtx
+                    val caller = caller0 ?: if (scope.thisObj === this) objClass else null
+                    if (!canAccessMember(rec.visibility, decl, caller))
+                        scope.raiseError(ObjAccessException(scope, "can't invoke method $name (declared in ${decl?.className ?: "?"})"))
+                    val saved = instanceScope.currentClassCtx
+                    instanceScope.currentClassCtx = decl
+                    try {
+                        rec.value.invoke(instanceScope, this, args)
+                    } finally {
+                        instanceScope.currentClassCtx = saved
+                    }
+                }
+            }
            ?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)

    private val publicFields: Map<String, ObjRecord>
-        get() = instanceScope.objects.filter { it.value.visibility.isPublic }
+        get() = instanceScope.objects.filter {
+            // Expose only human-facing fields: skip MI-mangled storage entries like "Class::name"
+            !it.key.contains("::") && it.value.visibility.isPublic && it.value.type.serializable
+        }

    override fun toString(): String {
        val fields = publicFields.map { "${it.key}=${it.value.value}" }.joinToString(",")
@@ -68,20 +189,17 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
        val vars = instanceVars.values.map { it.value }
        if( vars.isNotEmpty()) {
            encoder.encodeAnyList(scope, vars)
-            println("serialized state vars $vars")
        }
    }

    internal suspend fun deserializeStateVars(scope: Scope, decoder: LynonDecoder) {
        val localVars = instanceVars.values.toList()
        if( localVars.isNotEmpty() ) {
-            println("gonna read vars")
            val vars = decoder.decodeAnyList(scope)
            if (vars.size > instanceVars.size)
                scope.raiseIllegalArgument("serialized vars has bigger size than instance vars")
-            println("deser state vars $vars")
            for ((i, v) in vars.withIndex()) {
-                localVars[i].value = vars[i]
+                localVars[i].value = v
            }
        }
    }
@@ -103,4 +221,117 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
        }
        return 0
    }
+}
+
+/**
+ * A qualified view over an [ObjInstance] that resolves members starting from a specific ancestor class.
+ * It does not change identity; it only affects lookup precedence for fields and methods.
+ */
+class ObjQualifiedView(val instance: ObjInstance, private val startClass: ObjClass) : Obj() {
+    override val objClass: ObjClass get() = instance.objClass
+
+    private fun memberFromAncestor(name: String): ObjRecord? =
+        instance.objClass.getInstanceMemberFromAncestor(startClass, name)
+
+    override suspend fun readField(scope: Scope, name: String): ObjRecord {
+        // Qualified field access: prefer mangled storage for the qualified ancestor
+        val mangled = "${startClass.className}::$name"
+        instance.instanceScope.objects[mangled]?.let { rec ->
+            // Visibility: declaring class is the qualified ancestor for mangled storage
+            val decl = rec.declaringClass ?: startClass
+            val caller = scope.currentClassCtx
+            if (!canAccessMember(rec.visibility, decl, caller))
+                scope.raiseError(ObjAccessException(scope, "can't access field $name (declared in ${decl.className})"))
+            return rec
+        }
+        // Then try instance locals (unmangled) only if startClass is the dynamic class itself
+        if (startClass === instance.objClass) {
+            instance.instanceScope[name]?.let { rec ->
+                val decl = rec.declaringClass ?: instance.objClass.findDeclaringClassOf(name)
+                val caller = scope.currentClassCtx
+                if (!canAccessMember(rec.visibility, decl, caller))
+                    scope.raiseError(ObjAccessException(scope, "can't access field $name (declared in ${decl?.className ?: "?"})"))
+                return rec
+            }
+        }
+        // Finally try methods/properties starting from ancestor
+        val r = memberFromAncestor(name) ?: scope.raiseError("no such field: $name")
+        val decl = r.declaringClass ?: startClass
+        val caller = scope.currentClassCtx
+        if (!canAccessMember(r.visibility, decl, caller))
+            scope.raiseError(ObjAccessException(scope, "can't access field $name (declared in ${decl.className})"))
+        return when (val value = r.value) {
+            is net.sergeych.lyng.Statement -> ObjRecord(value.execute(instance.instanceScope.createChildScope(scope.pos, newThisObj = instance)), r.isMutable)
+            else -> r
+        }
+    }
+
+    override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
+        // Qualified write: target mangled storage for the ancestor
+        val mangled = "${startClass.className}::$name"
+        instance.instanceScope.objects[mangled]?.let { f ->
+            val decl = f.declaringClass ?: startClass
+            val caller = scope.currentClassCtx
+            if (!canAccessMember(f.visibility, decl, caller))
+                ObjIllegalAssignmentException(scope, "can't assign to field $name (declared in ${decl.className})").raise()
+            if (!f.isMutable) ObjIllegalAssignmentException(scope, "can't reassign val $name").raise()
+            if (f.value.assign(scope, newValue) == null) f.value = newValue
+            return
+        }
+        // If start is dynamic class, allow unmangled
+        if (startClass === instance.objClass) {
+            instance.instanceScope[name]?.let { f ->
+                val decl = f.declaringClass ?: instance.objClass.findDeclaringClassOf(name)
+                val caller = scope.currentClassCtx
+                if (!canAccessMember(f.visibility, decl, caller))
+                    ObjIllegalAssignmentException(scope, "can't assign to field $name (declared in ${decl?.className ?: "?"})").raise()
+                if (!f.isMutable) ObjIllegalAssignmentException(scope, "can't reassign val $name").raise()
+                if (f.value.assign(scope, newValue) == null) f.value = newValue
+                return
+            }
+        }
+        val r = memberFromAncestor(name) ?: scope.raiseError("no such field: $name")
+        val decl = r.declaringClass ?: startClass
+        val caller = scope.currentClassCtx
+        if (!canAccessMember(r.visibility, decl, caller))
+            ObjIllegalAssignmentException(scope, "can't assign to field $name (declared in ${decl.className})").raise()
+        if (!r.isMutable) scope.raiseError("can't assign to read-only field: $name")
+        if (r.value.assign(scope, newValue) == null) r.value = newValue
+    }
+
+    override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments, onNotFoundResult: (() -> Obj?)?): Obj {
+        // Qualified method dispatch must start from the specified ancestor, not from the instance scope.
+        memberFromAncestor(name)?.let { rec ->
+            val decl = rec.declaringClass ?: startClass
+            val caller = scope.currentClassCtx
+            if (!canAccessMember(rec.visibility, decl, caller))
+                scope.raiseError(ObjAccessException(scope, "can't invoke method $name (declared in ${decl.className})"))
+            val saved = instance.instanceScope.currentClassCtx
+            instance.instanceScope.currentClassCtx = decl
+            try {
+                return rec.value.invoke(instance.instanceScope, instance, args)
+            } finally {
+                instance.instanceScope.currentClassCtx = saved
+            }
+        }
+        // If the qualifier is the dynamic class itself, allow instance-scope methods as a fallback
+        if (startClass === instance.objClass) {
+            instance.instanceScope[name]?.let { rec ->
+                val decl = rec.declaringClass ?: instance.objClass.findDeclaringClassOf(name)
+                val caller = scope.currentClassCtx
+                if (!canAccessMember(rec.visibility, decl, caller))
+                    scope.raiseError(ObjAccessException(scope, "can't invoke method $name (declared in ${decl?.className ?: "?"})"))
+                val saved = instance.instanceScope.currentClassCtx
+                instance.instanceScope.currentClassCtx = decl
+                try {
+                    return rec.value.invoke(instance.instanceScope, instance, args)
+                } finally {
+                    instance.instanceScope.currentClassCtx = saved
+                }
+            }
+        }
+        return onNotFoundResult?.invoke() ?: scope.raiseSymbolNotFound(name)
+    }
+
+    override fun toString(): String = instance.toString()
 }
@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng.obj

 import net.sergeych.lyng.Arguments
@@ -8,20 +25,23 @@ import net.sergeych.lynon.LynonType
 /**
 * Special variant of [ObjClass] to be used in [ObjInstance], e.g. for Lyng compiled classes
 */
-class ObjInstanceClass(val name: String) : ObjClass(name) {
-
-//    val onDeserilaized =
+class ObjInstanceClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {

    override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
        val args = decoder.decodeAnyList(scope)
-        println("deserializing constructor $name, $args params")
        val actualSize = constructorMeta?.params?.size ?: 0
-        if( args.size > actualSize )
+        if (args.size > actualSize)
            scope.raiseIllegalArgument("constructor $name has only $actualSize but serialized version has ${args.size}")
-        val newScope = scope.copy(args = Arguments(args))
+        val newScope = scope.createChildScope(args = Arguments(args))
        return (callOn(newScope) as ObjInstance).apply {
-            deserializeStateVars(scope,decoder)
-            invokeInstanceMethod(scope, "onDeserialized", onNotFoundResult = ObjVoid)
+            deserializeStateVars(scope, decoder)
+            invokeInstanceMethod(scope, "onDeserialized") { ObjVoid }
+        }
+    }
+
+    init {
+        addFn("toString", true) {
+            ObjString(thisObj.toString())
        }
    }

@@ -1,3 +1,20 @@
+/*
+ * Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 package net.sergeych.lyng.obj

 import kotlinx.datetime.Clock
@@ -100,7 +117,7 @@ class ObjInstant(val instant: Instant,val truncateMode: LynonSettings.InstantTru
                        is ObjInstant -> a0.instant

                        else -> {
-                            scope.raiseIllegalArgument("can't construct Instant(${args.inspect()})")
+                            scope.raiseIllegalArgument("can't construct Instant(${args.inspect(scope)})")
                        }
                    }
                )
Author	SHA1	Message	Date
sergeych	88f035beb6	version bump	2025-11-17 15:25:26 +01:00
sergeych	41657b3558	another MI bug fixed, added tests for MI serialization	2025-11-17 15:09:02 +01:00
sergeych	1e6dd89778	added test for scope locality	2025-11-17 14:15:38 +01:00
sergeych	6eabcc315f	fixed errors	2025-11-17 14:08:32 +01:00
sergeych	aeeec2d417	added Multiple Inheritance	2025-11-17 00:28:07 +01:00
sergeych	882df67909	added new performance flags, extended PIC handling to size 4, introduced fast paths for ObjFastIntRangeIterator, small-arity arguments, index access, and unary operations	2025-11-16 00:17:15 +01:00
sergeych	0798bbee9b	version bump, added parallel execution tests	2025-11-15 10:45:33 +01:00
sergeych	5df923920c	more test for apply	2025-11-12 13:01:35 +01:00
sergeych	76d89b43db	added bitwise operators and shift support, updated parser, compiler, and docs. fixed copyright.	2025-11-12 12:57:35 +01:00
sergeych	852383e3b1	fixed execution on JS and native platforms	2025-11-12 10:32:11 +01:00
sergeych	28e8648794	fix to make it build on all platforms	2025-11-11 23:20:22 +01:00
sergeych	d2a930c0e8	further optimizations: improve PIC miss caching and add fast paths for string, char, and numeric operations	2025-11-11 22:51:03 +01:00
sergeych	0eea73c118	further optimizations	2025-11-11 22:04:04 +01:00
sergeych	fdb056e78e	big optimization	2025-11-11 21:22:10 +01:00
sergeych	dc3000e9f7	version bump, better diagnostic on unknown object serialization	2025-11-11 15:40:00 +01:00
sergeych	e8f0846840	nicrooptimizations	2025-11-10 23:59:51 +01:00
sergeych	2af5852d44	JVM multithreaded scope pool now turned on by default	2025-11-10 23:08:58 +01:00
sergeych	38c1b3c209	big optimization round	2025-11-10 22:14:21 +01:00
sergeych	029fde2883	more optimizations	2025-11-10 02:14:18 +01:00
sergeych	1498140892	further locals optimization	2025-11-10 01:35:15 +01:00
sergeych	0b9e94c6e9	v0.10.1-SNAPSHOT optimization: Accessor refactored now use more effective ObjRef and slots for locals	2025-11-09 23:19:02 +01:00
sergeych	6ca3e4589e	fixed errors with some exception object naming and serialization	2025-11-07 02:52:15 +04:00
sergeych	65963ce537	v0.9.3 published for all platforms; dyanimc improvements & more	2025-11-02 14:20:35 +01:00
sergeych	9d222be924	added random bitArray	2025-11-01 22:19:40 +01:00
sergeych	f00631cd88	some more docs	2025-11-01 22:10:26 +01:00
sergeych	b8d6ff01a6	fixed invoke overriden field problem in dynamic and the dynamic's Lyng class.	2025-11-01 22:07:22 +01:00
sergeych	ba725fc9ed	less debug noise open ObjDynamic found a pfoblem with dynamic, see todo in OOTest.kt	2025-11-01 18:33:37 +01:00
sergeych	5d4d548275	lzw utils	2025-11-01 10:28:04 +01:00
sergeych	7e289382ed	Scope.copy renamed to createChild for clarity; fixed error with Exception self serializing.	2025-10-31 14:58:02 +04:00
sergeych	c854b06683	fixed comment before else in if; dynamic now support indexing access	2025-10-04 11:25:19 +04:00
sergeych	e8b630715a	optimized BitArray.equals	2025-09-26 20:06:54 +04:00
sergeych	3481a718b1	serializable and hashable BitArray. Comparable BitList. Small improvements	2025-09-26 19:45:28 +04:00
sergeych	2696f1546d	upgrading to kotlin 2.2	2025-09-26 11:48:40 +04:00
sergeych	f45fa7f7a0	fix #49 regular expressions, operator match and docs	2025-09-05 17:53:19 +04:00
sergeych	ead2f7168e	ref #49 basic regex support (but not in when yet)	2025-08-25 12:34:04 +03:00
sergeych	2743511b62	better readme	2025-08-24 09:04:40 +03:00
sergeych	8431ab4f96	missing link in readme	2025-08-24 00:15:25 +03:00
sergeych	80735f032d	more links in docs	2025-08-24 00:10:17 +03:00
sergeych	dc837e2095	+shiffle +List.binarySearch	2025-08-24 00:09:38 +03:00
sergeych	0ec0ed96ee	sorted* moved to Iterable in-place List sort v0.8.15-SNAPSHOT	2025-08-23 22:53:10 +03:00
sergeych	a5e51a3f90	more tests	2025-08-23 09:41:23 +03:00
sergeych	cf79163802	reflected current state in readme	2025-08-22 16:18:04 +03:00
sergeych	c8e8bdc466	ref #56 exceptions are serializable +fixed ambigity betwee lyng/kotln toString, added directional parameter to kotlin	2025-08-22 09:57:36 +03:00
sergeych	4b613fda7c	fix #58 improper toString overload processing in Lyng fix #57 Exception#getStackTrace() ref #56 StackTraceEntry is serializable now	2025-08-22 00:02:23 +03:00
sergeych	8d1cafae80	fix #55 newlines in function declarations and constructors	2025-08-20 11:07:49 +03:00
sergeych	0526cdfb38	fix #54 on current version of the compiler it is no more an issue	2025-08-20 11:00:47 +03:00
sergeych	cad6ba936d	fix #53 chained calls and multiline expressions	2025-08-20 10:57:15 +03:00
sergeych	cb333ab6bd	less debug noise	2025-08-18 11:16:57 +03:00
sergeych	23737f9b5c	removed debug stuff	2025-08-18 01:48:23 +03:00
sergeych	fb6e2aa49e	bugfix: elvis + throw	2025-08-18 01:19:49 +03:00
sergeych	95c1da60ed	better elvis + throw +added run {}	2025-08-18 00:56:52 +03:00
sergeych	835333dfad	fixed objClass initialization in ObjInt.Zero, added Buffer.toBitInput, minimal descrription of Lynon	2025-08-17 23:51:50 +03:00
sergeych	eefecae7b4	more Buffer encodings	2025-08-17 19:26:15 +03:00
sergeych	2ac92a1d09	more elegant Iterable.all	2025-08-17 18:21:52 +03:00
sergeych	464a6dcb99	fixed many bugs with variable visibility in mixed scopes	2025-08-17 12:24:39 +03:00
sergeych	eca746b189	commented out delegate creation	2025-08-14 14:34:44 +03:00
sergeych	b07452e66e	more stdlib and docs, bugfixes	2025-08-14 14:31:51 +03:00
sergeych	202e70a99a	less debug noise	2025-08-14 01:36:37 +03:00
sergeych	f45310f7d9	default implementation for Iterator.cancelIteration (does nothing) and not implemented errors for iterator methods (better error messages)	2025-08-13 23:34:54 +03:00
sergeych	48a7f0839c	less warnings	2025-08-13 23:24:51 +03:00
sergeych	2adb0ff512	+copyrght, apache 2.0	2025-08-13 23:22:04 +03:00
sergeych	6735499959	more enum tests	2025-08-12 14:57:52 +03:00
sergeych	b5e89c7e78	smple enums w/serialization	2025-08-12 14:47:41 +03:00
sergeych	84e345b04e	more docs on function annotations	2025-08-12 05:01:02 +03:00
sergeych	9bd7aa368e	cleanup	2025-08-12 04:52:40 +03:00
sergeych	9704f18284	function annotation and some docs for it	2025-08-12 04:51:26 +03:00
sergeych	804087f16d	version bump	2025-08-12 00:16:09 +03:00
sergeych	6d8eed7b8c	added "dynamic" fields (get/set/call fields by name using `dynamic` standard function	2025-08-12 00:15:45 +03:00
sergeych	e916d9805a	correct end-block token processing (detect more errors)	2025-08-11 22:48:43 +03:00
sergeych	c398496ee0	refining the readme/2	2025-08-11 14:41:35 +03:00
sergeych	299738cffd	refining the readme	2025-08-11 10:36:29 +03:00
sergeych	62461c09cc	readme fix	2025-08-10 23:41:57 +03:00
sergeych	63de82393a	multiline string literals	2025-08-10 23:32:03 +03:00
sergeych	ed0a21cb06	added test config	2025-08-10 09:51:04 +03:00
sergeych	1baf69f40f	more docs on Iterable	2025-08-09 23:23:05 +03:00
sergeych	ba8d543d87	more docs on Iterable	2025-08-09 23:20:25 +03:00
sergeych	d3785afa6f	adopt stdlib to CLI tool	2025-08-09 22:59:43 +03:00
sergeych	3948283481	0.8.4: stadlib in Lyng! added universal Iterable functions	2025-08-09 22:50:48 +03:00
sergeych	f9198fe583	parallelism and flows + bugfixes release	2025-08-09 15:55:30 +03:00
sergeych	4917f99197	docs	2025-08-09 15:54:46 +03:00
sergeych	e0ed27a01f	fixed many bugs in closures processing also in flows	2025-08-09 15:48:41 +03:00
sergeych	9aae33d564	fix #48 flows	2025-08-08 19:33:17 +03:00
sergeych	1a90b25b1e	fix #51 ref #48 flows started. bad closure-based bug fixed	2025-08-08 19:23:43 +03:00
sergeych	f7f020f4d6	0.8.2-SNAPSHOT	2025-08-07 21:50:14 +03:00
sergeych	0f54e2f845	ref #47 yield	2025-08-07 21:46:45 +03:00
sergeych	19f8b6605b	fix #47 parallelism: launch, Deferred, CompletableDeferred, Mutex (delay was already implemented)	2025-08-07 20:31:36 +03:00
sergeych	de71c7c8ec	0.8.1 release version	2025-08-06 23:12:25 +03:00
sergeych	be370dfdef	fix #45 private statics and docs	2025-08-06 23:10:33 +03:00
sergeych	53a6a88924	fix #42 class static fields and methods	2025-08-06 22:48:32 +03:00
sergeych	2c2dae4d85	well redesigned class vals and vars, classScope introduced for class functions	2025-08-06 11:47:45 +03:00
sergeych	63b2808109	well redesigned class vals and vars, classScope introduced for class functions	2025-08-06 11:46:17 +03:00